[PATCH] 3c59x: correct rx_dropped counting
[linux-2.6.git] / drivers / net / 3c59x.c
1 /* 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
20         Linux Kernel Additions:
21         
22         0.99H+lk0.9 - David S. Miller - softnet, PCI DMA updates
23         0.99H+lk1.0 - Jeff Garzik <jgarzik@pobox.com>
24                 Remove compatibility defines for kernel versions < 2.2.x.
25                 Update for new 2.3.x module interface
26         LK1.1.2 (March 19, 2000)
27         * New PCI interface (jgarzik)
28
29     LK1.1.3 25 April 2000, Andrew Morton <andrewm@uow.edu.au>
30     - Merged with 3c575_cb.c
31     - Don't set RxComplete in boomerang interrupt enable reg
32     - spinlock in vortex_timer to protect mdio functions
33     - disable local interrupts around call to vortex_interrupt in
34       vortex_tx_timeout() (So vortex_interrupt can use spin_lock())
35     - Select window 3 in vortex_timer()'s write to Wn3_MAC_Ctrl
36     - In vortex_start_xmit(), move the lock to _after_ we've altered
37       vp->cur_tx and vp->tx_full.  This defeats the race between
38       vortex_start_xmit() and vortex_interrupt which was identified
39       by Bogdan Costescu.
40     - Merged back support for six new cards from various sources
41     - Set vortex_have_pci if pci_module_init returns zero (fixes cardbus
42       insertion oops)
43     - Tell it that 3c905C has NWAY for 100bT autoneg
44     - Fix handling of SetStatusEnd in 'Too much work..' code, as
45       per 2.3.99's 3c575_cb (Dave Hinds).
46     - Split ISR into two for vortex & boomerang
47     - Fix MOD_INC/DEC races
48     - Handle resource allocation failures.
49     - Fix 3CCFE575CT LED polarity
50     - Make tx_interrupt_mitigation the default
51
52     LK1.1.4 25 April 2000, Andrew Morton <andrewm@uow.edu.au>    
53     - Add extra TxReset to vortex_up() to fix 575_cb hotplug initialisation probs.
54     - Put vortex_info_tbl into __devinitdata
55     - In the vortex_error StatsFull HACK, disable stats in vp->intr_enable as well
56       as in the hardware.
57     - Increased the loop counter in issue_and_wait from 2,000 to 4,000.
58
59     LK1.1.5 28 April 2000, andrewm
60     - Added powerpc defines (John Daniel <jdaniel@etresoft.com> said these work...)
61     - Some extra diagnostics
62     - In vortex_error(), reset the Tx on maxCollisions.  Otherwise most
63       chips usually get a Tx timeout.
64     - Added extra_reset module parm
65     - Replaced some inline timer manip with mod_timer
66       (Franois romieu <Francois.Romieu@nic.fr>)
67     - In vortex_up(), don't make Wn3_config initialisation dependent upon has_nway
68       (this came across from 3c575_cb).
69
70     LK1.1.6 06 Jun 2000, andrewm
71     - Backed out the PPC defines.
72     - Use del_timer_sync(), mod_timer().
73     - Fix wrapped ulong comparison in boomerang_rx()
74     - Add IS_TORNADO, use it to suppress 3c905C checksum error msg
75       (Donald Becker, I Lee Hetherington <ilh@sls.lcs.mit.edu>)
76     - Replace union wn3_config with BFINS/BFEXT manipulation for
77       sparc64 (Pete Zaitcev, Peter Jones)
78     - In vortex_error, do_tx_reset and vortex_tx_timeout(Vortex):
79       do a netif_wake_queue() to better recover from errors. (Anders Pedersen,
80       Donald Becker)
81     - Print a warning on out-of-memory (rate limited to 1 per 10 secs)
82     - Added two more Cardbus 575 NICs: 5b57 and 6564 (Paul Wagland)
83
84     LK1.1.7 2 Jul 2000 andrewm
85     - Better handling of shared IRQs
86     - Reset the transmitter on a Tx reclaim error
87     - Fixed crash under OOM during vortex_open() (Mark Hemment)
88     - Fix Rx cessation problem during OOM (help from Mark Hemment)
89     - The spinlocks around the mdio access were blocking interrupts for 300uS.
90       Fix all this to use spin_lock_bh() within mdio_read/write
91     - Only write to TxFreeThreshold if it's a boomerang - other NICs don't
92       have one.
93     - Added 802.3x MAC-layer flow control support
94
95    LK1.1.8 13 Aug 2000 andrewm
96     - Ignore request_region() return value - already reserved if Cardbus.
97     - Merged some additional Cardbus flags from Don's 0.99Qk
98     - Some fixes for 3c556 (Fred Maciel)
99     - Fix for EISA initialisation (Jan Rekorajski)
100     - Renamed MII_XCVR_PWR and EEPROM_230 to align with 3c575_cb and D. Becker's drivers
101     - Fixed MII_XCVR_PWR for 3CCFE575CT
102     - Added INVERT_LED_PWR, used it.
103     - Backed out the extra_reset stuff
104
105    LK1.1.9 12 Sep 2000 andrewm
106     - Backed out the tx_reset_resume flags.  It was a no-op.
107     - In vortex_error, don't reset the Tx on txReclaim errors
108     - In vortex_error, don't reset the Tx on maxCollisions errors.
109       Hence backed out all the DownListPtr logic here.
110     - In vortex_error, give Tornado cards a partial TxReset on
111       maxCollisions (David Hinds).  Defined MAX_COLLISION_RESET for this.
112     - Redid some driver flags and device names based on pcmcia_cs-3.1.20.
113     - Fixed a bug where, if vp->tx_full is set when the interface
114       is downed, it remains set when the interface is upped.  Bad
115       things happen.
116
117    LK1.1.10 17 Sep 2000 andrewm
118     - Added EEPROM_8BIT for 3c555 (Fred Maciel)
119     - Added experimental support for the 3c556B Laptop Hurricane (Louis Gerbarg)
120     - Add HAS_NWAY to "3c900 Cyclone 10Mbps TPO"
121
122    LK1.1.11 13 Nov 2000 andrewm
123     - Dump MOD_INC/DEC_USE_COUNT, use SET_MODULE_OWNER
124
125    LK1.1.12 1 Jan 2001 andrewm (2.4.0-pre1)
126     - Call pci_enable_device before we request our IRQ (Tobias Ringstrom)
127     - Add 3c590 PCI latency timer hack to vortex_probe1 (from 0.99Ra)
128     - Added extended issue_and_wait for the 3c905CX.
129     - Look for an MII on PHY index 24 first (3c905CX oddity).
130     - Add HAS_NWAY to 3cSOHO100-TX (Brett Frankenberger)
131     - Don't free skbs we don't own on oom path in vortex_open().
132
133    LK1.1.13 27 Jan 2001
134     - Added explicit `medialock' flag so we can truly
135       lock the media type down with `options'.
136     - "check ioremap return and some tidbits" (Arnaldo Carvalho de Melo <acme@conectiva.com.br>)
137     - Added and used EEPROM_NORESET for 3c556B PM resumes.
138     - Fixed leakage of vp->rx_ring.
139     - Break out separate HAS_HWCKSM device capability flag.
140     - Kill vp->tx_full (ANK)
141     - Merge zerocopy fragment handling (ANK?)
142
143    LK1.1.14 15 Feb 2001
144     - Enable WOL.  Can be turned on with `enable_wol' module option.
145     - EISA and PCI initialisation fixes (jgarzik, Manfred Spraul)
146     - If a device's internalconfig register reports it has NWAY,
147       use it, even if autoselect is enabled.
148
149    LK1.1.15 6 June 2001 akpm
150     - Prevent double counting of received bytes (Lars Christensen)
151     - Add ethtool support (jgarzik)
152     - Add module parm descriptions (Andrzej M. Krzysztofowicz)
153     - Implemented alloc_etherdev() API
154     - Special-case the 'Tx error 82' message.
155
156    LK1.1.16 18 July 2001 akpm
157     - Make NETIF_F_SG dependent upon nr_free_highpages(), not on CONFIG_HIGHMEM
158     - Lessen verbosity of bootup messages
159     - Fix WOL - use new PM API functions.
160     - Use netif_running() instead of vp->open in suspend/resume.
161     - Don't reset the interface logic on open/close/rmmod.  It upsets
162       autonegotiation, and hence DHCP (from 0.99T).
163     - Back out EEPROM_NORESET flag because of the above (we do it for all
164       NICs).
165     - Correct 3c982 identification string
166     - Rename wait_for_completion() to issue_and_wait() to avoid completion.h
167       clash.
168
169    LK1.1.17 18Dec01 akpm
170     - PCI ID 9805 is a Python-T, not a dual-port Cyclone.  Apparently.
171       And it has NWAY.
172     - Mask our advertised modes (vp->advertising) with our capabilities
173           (MII reg5) when deciding which duplex mode to use.
174     - Add `global_options' as default for options[].  Ditto global_enable_wol,
175       global_full_duplex.
176
177    LK1.1.18 01Jul02 akpm
178     - Fix for undocumented transceiver power-up bit on some 3c566B's
179       (Donald Becker, Rahul Karnik)
180
181     - See http://www.zip.com.au/~akpm/linux/#3c59x-2.3 for more details.
182     - Also see Documentation/networking/vortex.txt
183
184    LK1.1.19 10Nov02 Marc Zyngier <maz@wild-wind.fr.eu.org>
185     - EISA sysfs integration.
186 */
187
188 /*
189  * FIXME: This driver _could_ support MTU changing, but doesn't.  See Don's hamachi.c implementation
190  * as well as other drivers
191  *
192  * NOTE: If you make 'vortex_debug' a constant (#define vortex_debug 0) the driver shrinks by 2k
193  * due to dead code elimination.  There will be some performance benefits from this due to
194  * elimination of all the tests and reduced cache footprint.
195  */
196
197
198 #define DRV_NAME        "3c59x"
199 #define DRV_VERSION     "LK1.1.19"
200 #define DRV_RELDATE     "10 Nov 2002"
201
202
203
204 /* A few values that may be tweaked. */
205 /* Keep the ring sizes a power of two for efficiency. */
206 #define TX_RING_SIZE    16
207 #define RX_RING_SIZE    32
208 #define PKT_BUF_SZ              1536                    /* Size of each temporary Rx buffer.*/
209
210 /* "Knobs" that adjust features and parameters. */
211 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
212    Setting to > 1512 effectively disables this feature. */
213 #ifndef __arm__
214 static int rx_copybreak = 200;
215 #else
216 /* ARM systems perform better by disregarding the bus-master
217    transfer capability of these cards. -- rmk */
218 static int rx_copybreak = 1513;
219 #endif
220 /* Allow setting MTU to a larger size, bypassing the normal ethernet setup. */
221 static const int mtu = 1500;
222 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
223 static int max_interrupt_work = 32;
224 /* Tx timeout interval (millisecs) */
225 static int watchdog = 5000;
226
227 /* Allow aggregation of Tx interrupts.  Saves CPU load at the cost
228  * of possible Tx stalls if the system is blocking interrupts
229  * somewhere else.  Undefine this to disable.
230  */
231 #define tx_interrupt_mitigation 1
232
233 /* Put out somewhat more debugging messages. (0: no msg, 1 minimal .. 6). */
234 #define vortex_debug debug
235 #ifdef VORTEX_DEBUG
236 static int vortex_debug = VORTEX_DEBUG;
237 #else
238 static int vortex_debug = 1;
239 #endif
240
241 #include <linux/config.h>
242 #include <linux/module.h>
243 #include <linux/kernel.h>
244 #include <linux/string.h>
245 #include <linux/timer.h>
246 #include <linux/errno.h>
247 #include <linux/in.h>
248 #include <linux/ioport.h>
249 #include <linux/slab.h>
250 #include <linux/interrupt.h>
251 #include <linux/pci.h>
252 #include <linux/mii.h>
253 #include <linux/init.h>
254 #include <linux/netdevice.h>
255 #include <linux/etherdevice.h>
256 #include <linux/skbuff.h>
257 #include <linux/ethtool.h>
258 #include <linux/highmem.h>
259 #include <linux/eisa.h>
260 #include <linux/bitops.h>
261 #include <asm/irq.h>                    /* For NR_IRQS only. */
262 #include <asm/io.h>
263 #include <asm/uaccess.h>
264
265 /* Kernel compatibility defines, some common to David Hinds' PCMCIA package.
266    This is only in the support-all-kernels source code. */
267
268 #define RUN_AT(x) (jiffies + (x))
269
270 #include <linux/delay.h>
271
272
273 static char version[] __devinitdata =
274 DRV_NAME ": Donald Becker and others. www.scyld.com/network/vortex.html\n";
275
276 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
277 MODULE_DESCRIPTION("3Com 3c59x/3c9xx ethernet driver "
278                                         DRV_VERSION " " DRV_RELDATE);
279 MODULE_LICENSE("GPL");
280 MODULE_VERSION(DRV_VERSION);
281
282
283 /* Operational parameter that usually are not changed. */
284
285 /* The Vortex size is twice that of the original EtherLinkIII series: the
286    runtime register window, window 1, is now always mapped in.
287    The Boomerang size is twice as large as the Vortex -- it has additional
288    bus master control registers. */
289 #define VORTEX_TOTAL_SIZE 0x20
290 #define BOOMERANG_TOTAL_SIZE 0x40
291
292 /* Set iff a MII transceiver on any interface requires mdio preamble.
293    This only set with the original DP83840 on older 3c905 boards, so the extra
294    code size of a per-interface flag is not worthwhile. */
295 static char mii_preamble_required;
296
297 #define PFX DRV_NAME ": "
298
299
300
301 /*
302                                 Theory of Operation
303
304 I. Board Compatibility
305
306 This device driver is designed for the 3Com FastEtherLink and FastEtherLink
307 XL, 3Com's PCI to 10/100baseT adapters.  It also works with the 10Mbs
308 versions of the FastEtherLink cards.  The supported product IDs are
309   3c590, 3c592, 3c595, 3c597, 3c900, 3c905
310
311 The related ISA 3c515 is supported with a separate driver, 3c515.c, included
312 with the kernel source or available from
313     cesdis.gsfc.nasa.gov:/pub/linux/drivers/3c515.html
314
315 II. Board-specific settings
316
317 PCI bus devices are configured by the system at boot time, so no jumpers
318 need to be set on the board.  The system BIOS should be set to assign the
319 PCI INTA signal to an otherwise unused system IRQ line.
320
321 The EEPROM settings for media type and forced-full-duplex are observed.
322 The EEPROM media type should be left at the default "autoselect" unless using
323 10base2 or AUI connections which cannot be reliably detected.
324
325 III. Driver operation
326
327 The 3c59x series use an interface that's very similar to the previous 3c5x9
328 series.  The primary interface is two programmed-I/O FIFOs, with an
329 alternate single-contiguous-region bus-master transfer (see next).
330
331 The 3c900 "Boomerang" series uses a full-bus-master interface with separate
332 lists of transmit and receive descriptors, similar to the AMD LANCE/PCnet,
333 DEC Tulip and Intel Speedo3.  The first chip version retains a compatible
334 programmed-I/O interface that has been removed in 'B' and subsequent board
335 revisions.
336
337 One extension that is advertised in a very large font is that the adapters
338 are capable of being bus masters.  On the Vortex chip this capability was
339 only for a single contiguous region making it far less useful than the full
340 bus master capability.  There is a significant performance impact of taking
341 an extra interrupt or polling for the completion of each transfer, as well
342 as difficulty sharing the single transfer engine between the transmit and
343 receive threads.  Using DMA transfers is a win only with large blocks or
344 with the flawed versions of the Intel Orion motherboard PCI controller.
345
346 The Boomerang chip's full-bus-master interface is useful, and has the
347 currently-unused advantages over other similar chips that queued transmit
348 packets may be reordered and receive buffer groups are associated with a
349 single frame.
350
351 With full-bus-master support, this driver uses a "RX_COPYBREAK" scheme.
352 Rather than a fixed intermediate receive buffer, this scheme allocates
353 full-sized skbuffs as receive buffers.  The value RX_COPYBREAK is used as
354 the copying breakpoint: it is chosen to trade-off the memory wasted by
355 passing the full-sized skbuff to the queue layer for all frames vs. the
356 copying cost of copying a frame to a correctly-sized skbuff.
357
358 IIIC. Synchronization
359 The driver runs as two independent, single-threaded flows of control.  One
360 is the send-packet routine, which enforces single-threaded use by the
361 dev->tbusy flag.  The other thread is the interrupt handler, which is single
362 threaded by the hardware and other software.
363
364 IV. Notes
365
366 Thanks to Cameron Spitzer and Terry Murphy of 3Com for providing development
367 3c590, 3c595, and 3c900 boards.
368 The name "Vortex" is the internal 3Com project name for the PCI ASIC, and
369 the EISA version is called "Demon".  According to Terry these names come
370 from rides at the local amusement park.
371
372 The new chips support both ethernet (1.5K) and FDDI (4.5K) packet sizes!
373 This driver only supports ethernet packets because of the skbuff allocation
374 limit of 4K.
375 */
376
377 /* This table drives the PCI probe routines.  It's mostly boilerplate in all
378    of the drivers, and will likely be provided by some future kernel.
379 */
380 enum pci_flags_bit {
381         PCI_USES_IO=1, PCI_USES_MEM=2, PCI_USES_MASTER=4,
382         PCI_ADDR0=0x10<<0, PCI_ADDR1=0x10<<1, PCI_ADDR2=0x10<<2, PCI_ADDR3=0x10<<3,
383 };
384
385 enum {  IS_VORTEX=1, IS_BOOMERANG=2, IS_CYCLONE=4, IS_TORNADO=8,
386         EEPROM_8BIT=0x10,       /* AKPM: Uses 0x230 as the base bitmaps for EEPROM reads */
387         HAS_PWR_CTRL=0x20, HAS_MII=0x40, HAS_NWAY=0x80, HAS_CB_FNS=0x100,
388         INVERT_MII_PWR=0x200, INVERT_LED_PWR=0x400, MAX_COLLISION_RESET=0x800,
389         EEPROM_OFFSET=0x1000, HAS_HWCKSM=0x2000, WNO_XCVR_PWR=0x4000,
390         EXTRA_PREAMBLE=0x8000, EEPROM_RESET=0x10000, };
391
392 enum vortex_chips {
393         CH_3C590 = 0,
394         CH_3C592,
395         CH_3C597,
396         CH_3C595_1,
397         CH_3C595_2,
398
399         CH_3C595_3,
400         CH_3C900_1,
401         CH_3C900_2,
402         CH_3C900_3,
403         CH_3C900_4,
404
405         CH_3C900_5,
406         CH_3C900B_FL,
407         CH_3C905_1,
408         CH_3C905_2,
409         CH_3C905B_1,
410
411         CH_3C905B_2,
412         CH_3C905B_FX,
413         CH_3C905C,
414         CH_3C9202,
415         CH_3C980,
416         CH_3C9805,
417
418         CH_3CSOHO100_TX,
419         CH_3C555,
420         CH_3C556,
421         CH_3C556B,
422         CH_3C575,
423
424         CH_3C575_1,
425         CH_3CCFE575,
426         CH_3CCFE575CT,
427         CH_3CCFE656,
428         CH_3CCFEM656,
429
430         CH_3CCFEM656_1,
431         CH_3C450,
432         CH_3C920,
433         CH_3C982A,
434         CH_3C982B,
435
436         CH_905BT4,
437         CH_920B_EMB_WNM,
438 };
439
440
441 /* note: this array directly indexed by above enums, and MUST
442  * be kept in sync with both the enums above, and the PCI device
443  * table below
444  */
445 static struct vortex_chip_info {
446         const char *name;
447         int flags;
448         int drv_flags;
449         int io_size;
450 } vortex_info_tbl[] __devinitdata = {
451         {"3c590 Vortex 10Mbps",
452          PCI_USES_IO|PCI_USES_MASTER, IS_VORTEX, 32, },
453         {"3c592 EISA 10Mbps Demon/Vortex",                                      /* AKPM: from Don's 3c59x_cb.c 0.49H */
454          PCI_USES_IO|PCI_USES_MASTER, IS_VORTEX, 32, },
455         {"3c597 EISA Fast Demon/Vortex",                                        /* AKPM: from Don's 3c59x_cb.c 0.49H */
456          PCI_USES_IO|PCI_USES_MASTER, IS_VORTEX, 32, },
457         {"3c595 Vortex 100baseTx",
458          PCI_USES_IO|PCI_USES_MASTER, IS_VORTEX, 32, },
459         {"3c595 Vortex 100baseT4",
460          PCI_USES_IO|PCI_USES_MASTER, IS_VORTEX, 32, },
461
462         {"3c595 Vortex 100base-MII",
463          PCI_USES_IO|PCI_USES_MASTER, IS_VORTEX, 32, },
464         {"3c900 Boomerang 10baseT",
465          PCI_USES_IO|PCI_USES_MASTER, IS_BOOMERANG|EEPROM_RESET, 64, },
466         {"3c900 Boomerang 10Mbps Combo",
467          PCI_USES_IO|PCI_USES_MASTER, IS_BOOMERANG|EEPROM_RESET, 64, },
468         {"3c900 Cyclone 10Mbps TPO",                                            /* AKPM: from Don's 0.99M */
469          PCI_USES_IO|PCI_USES_MASTER, IS_CYCLONE|HAS_HWCKSM, 128, },
470         {"3c900 Cyclone 10Mbps Combo",
471          PCI_USES_IO|PCI_USES_MASTER, IS_CYCLONE|HAS_HWCKSM, 128, },
472
473         {"3c900 Cyclone 10Mbps TPC",                                            /* AKPM: from Don's 0.99M */
474          PCI_USES_IO|PCI_USES_MASTER, IS_CYCLONE|HAS_HWCKSM, 128, },
475         {"3c900B-FL Cyclone 10base-FL",
476          PCI_USES_IO|PCI_USES_MASTER, IS_CYCLONE|HAS_HWCKSM, 128, },
477         {"3c905 Boomerang 100baseTx",
478          PCI_USES_IO|PCI_USES_MASTER, IS_BOOMERANG|HAS_MII|EEPROM_RESET, 64, },
479         {"3c905 Boomerang 100baseT4",
480          PCI_USES_IO|PCI_USES_MASTER, IS_BOOMERANG|HAS_MII|EEPROM_RESET, 64, },
481         {"3c905B Cyclone 100baseTx",
482          PCI_USES_IO|PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_HWCKSM|EXTRA_PREAMBLE, 128, },
483
484         {"3c905B Cyclone 10/100/BNC",
485          PCI_USES_IO|PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_HWCKSM, 128, },
486         {"3c905B-FX Cyclone 100baseFx",
487          PCI_USES_IO|PCI_USES_MASTER, IS_CYCLONE|HAS_HWCKSM, 128, },
488         {"3c905C Tornado",
489         PCI_USES_IO|PCI_USES_MASTER, IS_TORNADO|HAS_NWAY|HAS_HWCKSM|EXTRA_PREAMBLE, 128, },
490         {"3c920B-EMB-WNM (ATI Radeon 9100 IGP)",
491          PCI_USES_IO|PCI_USES_MASTER, IS_TORNADO|HAS_MII|HAS_HWCKSM, 128, },
492         {"3c980 Cyclone",
493          PCI_USES_IO|PCI_USES_MASTER, IS_CYCLONE|HAS_HWCKSM, 128, },
494
495         {"3c980C Python-T",
496          PCI_USES_IO|PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_HWCKSM, 128, },
497         {"3cSOHO100-TX Hurricane",
498          PCI_USES_IO|PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_HWCKSM, 128, },
499         {"3c555 Laptop Hurricane",
500          PCI_USES_IO|PCI_USES_MASTER, IS_CYCLONE|EEPROM_8BIT|HAS_HWCKSM, 128, },
501         {"3c556 Laptop Tornado",
502          PCI_USES_IO|PCI_USES_MASTER, IS_TORNADO|HAS_NWAY|EEPROM_8BIT|HAS_CB_FNS|INVERT_MII_PWR|
503                                                                         HAS_HWCKSM, 128, },
504         {"3c556B Laptop Hurricane",
505          PCI_USES_IO|PCI_USES_MASTER, IS_TORNADO|HAS_NWAY|EEPROM_OFFSET|HAS_CB_FNS|INVERT_MII_PWR|
506                                         WNO_XCVR_PWR|HAS_HWCKSM, 128, },
507
508         {"3c575 [Megahertz] 10/100 LAN  CardBus",
509         PCI_USES_IO|PCI_USES_MASTER, IS_BOOMERANG|HAS_MII|EEPROM_8BIT, 128, },
510         {"3c575 Boomerang CardBus",
511          PCI_USES_IO|PCI_USES_MASTER, IS_BOOMERANG|HAS_MII|EEPROM_8BIT, 128, },
512         {"3CCFE575BT Cyclone CardBus",
513          PCI_USES_IO|PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_CB_FNS|EEPROM_8BIT|
514                                                                         INVERT_LED_PWR|HAS_HWCKSM, 128, },
515         {"3CCFE575CT Tornado CardBus",
516          PCI_USES_IO|PCI_USES_MASTER, IS_TORNADO|HAS_NWAY|HAS_CB_FNS|EEPROM_8BIT|INVERT_MII_PWR|
517                                                                         MAX_COLLISION_RESET|HAS_HWCKSM, 128, },
518         {"3CCFE656 Cyclone CardBus",
519          PCI_USES_IO|PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_CB_FNS|EEPROM_8BIT|INVERT_MII_PWR|
520                                                                         INVERT_LED_PWR|HAS_HWCKSM, 128, },
521
522         {"3CCFEM656B Cyclone+Winmodem CardBus",
523          PCI_USES_IO|PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_CB_FNS|EEPROM_8BIT|INVERT_MII_PWR|
524                                                                         INVERT_LED_PWR|HAS_HWCKSM, 128, },
525         {"3CXFEM656C Tornado+Winmodem CardBus",                 /* From pcmcia-cs-3.1.5 */
526          PCI_USES_IO|PCI_USES_MASTER, IS_TORNADO|HAS_NWAY|HAS_CB_FNS|EEPROM_8BIT|INVERT_MII_PWR|
527                                                                         MAX_COLLISION_RESET|HAS_HWCKSM, 128, },
528         {"3c450 HomePNA Tornado",                                               /* AKPM: from Don's 0.99Q */
529          PCI_USES_IO|PCI_USES_MASTER, IS_TORNADO|HAS_NWAY|HAS_HWCKSM, 128, },
530         {"3c920 Tornado",
531          PCI_USES_IO|PCI_USES_MASTER, IS_TORNADO|HAS_NWAY|HAS_HWCKSM, 128, },
532         {"3c982 Hydra Dual Port A",
533          PCI_USES_IO|PCI_USES_MASTER, IS_TORNADO|HAS_HWCKSM|HAS_NWAY, 128, },
534
535         {"3c982 Hydra Dual Port B",
536          PCI_USES_IO|PCI_USES_MASTER, IS_TORNADO|HAS_HWCKSM|HAS_NWAY, 128, },
537         {"3c905B-T4",
538          PCI_USES_IO|PCI_USES_MASTER, IS_CYCLONE|HAS_NWAY|HAS_HWCKSM|EXTRA_PREAMBLE, 128, },
539         {"3c920B-EMB-WNM Tornado",
540          PCI_USES_IO|PCI_USES_MASTER, IS_TORNADO|HAS_NWAY|HAS_HWCKSM, 128, },
541
542         {NULL,}, /* NULL terminated list. */
543 };
544
545
546 static struct pci_device_id vortex_pci_tbl[] = {
547         { 0x10B7, 0x5900, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C590 },
548         { 0x10B7, 0x5920, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C592 },
549         { 0x10B7, 0x5970, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C597 },
550         { 0x10B7, 0x5950, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C595_1 },
551         { 0x10B7, 0x5951, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C595_2 },
552
553         { 0x10B7, 0x5952, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C595_3 },
554         { 0x10B7, 0x9000, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900_1 },
555         { 0x10B7, 0x9001, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900_2 },
556         { 0x10B7, 0x9004, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900_3 },
557         { 0x10B7, 0x9005, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900_4 },
558
559         { 0x10B7, 0x9006, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900_5 },
560         { 0x10B7, 0x900A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C900B_FL },
561         { 0x10B7, 0x9050, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905_1 },
562         { 0x10B7, 0x9051, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905_2 },
563         { 0x10B7, 0x9055, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905B_1 },
564
565         { 0x10B7, 0x9058, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905B_2 },
566         { 0x10B7, 0x905A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905B_FX },
567         { 0x10B7, 0x9200, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C905C },
568         { 0x10B7, 0x9202, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C9202 },
569         { 0x10B7, 0x9800, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C980 },
570         { 0x10B7, 0x9805, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C9805 },
571
572         { 0x10B7, 0x7646, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CSOHO100_TX },
573         { 0x10B7, 0x5055, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C555 },
574         { 0x10B7, 0x6055, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C556 },
575         { 0x10B7, 0x6056, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C556B },
576         { 0x10B7, 0x5b57, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C575 },
577
578         { 0x10B7, 0x5057, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C575_1 },
579         { 0x10B7, 0x5157, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CCFE575 },
580         { 0x10B7, 0x5257, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CCFE575CT },
581         { 0x10B7, 0x6560, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CCFE656 },
582         { 0x10B7, 0x6562, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CCFEM656 },
583
584         { 0x10B7, 0x6564, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3CCFEM656_1 },
585         { 0x10B7, 0x4500, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C450 },
586         { 0x10B7, 0x9201, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C920 },
587         { 0x10B7, 0x1201, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C982A },
588         { 0x10B7, 0x1202, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_3C982B },
589
590         { 0x10B7, 0x9056, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_905BT4 },
591         { 0x10B7, 0x9210, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_920B_EMB_WNM },
592
593         {0,}                                            /* 0 terminated list. */
594 };
595 MODULE_DEVICE_TABLE(pci, vortex_pci_tbl);
596
597
598 /* Operational definitions.
599    These are not used by other compilation units and thus are not
600    exported in a ".h" file.
601
602    First the windows.  There are eight register windows, with the command
603    and status registers available in each.
604    */
605 #define EL3WINDOW(win_num) iowrite16(SelectWindow + (win_num), ioaddr + EL3_CMD)
606 #define EL3_CMD 0x0e
607 #define EL3_STATUS 0x0e
608
609 /* The top five bits written to EL3_CMD are a command, the lower
610    11 bits are the parameter, if applicable.
611    Note that 11 parameters bits was fine for ethernet, but the new chip
612    can handle FDDI length frames (~4500 octets) and now parameters count
613    32-bit 'Dwords' rather than octets. */
614
615 enum vortex_cmd {
616         TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
617         RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11,
618         UpStall = 6<<11, UpUnstall = (6<<11)+1,
619         DownStall = (6<<11)+2, DownUnstall = (6<<11)+3,
620         RxDiscard = 8<<11, TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
621         FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
622         SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
623         SetTxThreshold = 18<<11, SetTxStart = 19<<11,
624         StartDMAUp = 20<<11, StartDMADown = (20<<11)+1, StatsEnable = 21<<11,
625         StatsDisable = 22<<11, StopCoax = 23<<11, SetFilterBit = 25<<11,};
626
627 /* The SetRxFilter command accepts the following classes: */
628 enum RxFilter {
629         RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
630
631 /* Bits in the general status register. */
632 enum vortex_status {
633         IntLatch = 0x0001, HostError = 0x0002, TxComplete = 0x0004,
634         TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
635         IntReq = 0x0040, StatsFull = 0x0080,
636         DMADone = 1<<8, DownComplete = 1<<9, UpComplete = 1<<10,
637         DMAInProgress = 1<<11,                  /* DMA controller is still busy.*/
638         CmdInProgress = 1<<12,                  /* EL3_CMD is still busy.*/
639 };
640
641 /* Register window 1 offsets, the window used in normal operation.
642    On the Vortex this window is always mapped at offsets 0x10-0x1f. */
643 enum Window1 {
644         TX_FIFO = 0x10,  RX_FIFO = 0x10,  RxErrors = 0x14,
645         RxStatus = 0x18,  Timer=0x1A, TxStatus = 0x1B,
646         TxFree = 0x1C, /* Remaining free bytes in Tx buffer. */
647 };
648 enum Window0 {
649         Wn0EepromCmd = 10,              /* Window 0: EEPROM command register. */
650         Wn0EepromData = 12,             /* Window 0: EEPROM results register. */
651         IntrStatus=0x0E,                /* Valid in all windows. */
652 };
653 enum Win0_EEPROM_bits {
654         EEPROM_Read = 0x80, EEPROM_WRITE = 0x40, EEPROM_ERASE = 0xC0,
655         EEPROM_EWENB = 0x30,            /* Enable erasing/writing for 10 msec. */
656         EEPROM_EWDIS = 0x00,            /* Disable EWENB before 10 msec timeout. */
657 };
658 /* EEPROM locations. */
659 enum eeprom_offset {
660         PhysAddr01=0, PhysAddr23=1, PhysAddr45=2, ModelID=3,
661         EtherLink3ID=7, IFXcvrIO=8, IRQLine=9,
662         NodeAddr01=10, NodeAddr23=11, NodeAddr45=12,
663         DriverTune=13, Checksum=15};
664
665 enum Window2 {                  /* Window 2. */
666         Wn2_ResetOptions=12,
667 };
668 enum Window3 {                  /* Window 3: MAC/config bits. */
669         Wn3_Config=0, Wn3_MaxPktSize=4, Wn3_MAC_Ctrl=6, Wn3_Options=8,
670 };
671
672 #define BFEXT(value, offset, bitcount)  \
673     ((((unsigned long)(value)) >> (offset)) & ((1 << (bitcount)) - 1))
674
675 #define BFINS(lhs, rhs, offset, bitcount)                                       \
676         (((lhs) & ~((((1 << (bitcount)) - 1)) << (offset))) |   \
677         (((rhs) & ((1 << (bitcount)) - 1)) << (offset)))
678
679 #define RAM_SIZE(v)             BFEXT(v, 0, 3)
680 #define RAM_WIDTH(v)    BFEXT(v, 3, 1)
681 #define RAM_SPEED(v)    BFEXT(v, 4, 2)
682 #define ROM_SIZE(v)             BFEXT(v, 6, 2)
683 #define RAM_SPLIT(v)    BFEXT(v, 16, 2)
684 #define XCVR(v)                 BFEXT(v, 20, 4)
685 #define AUTOSELECT(v)   BFEXT(v, 24, 1)
686
687 enum Window4 {          /* Window 4: Xcvr/media bits. */
688         Wn4_FIFODiag = 4, Wn4_NetDiag = 6, Wn4_PhysicalMgmt=8, Wn4_Media = 10,
689 };
690 enum Win4_Media_bits {
691         Media_SQE = 0x0008,             /* Enable SQE error counting for AUI. */
692         Media_10TP = 0x00C0,    /* Enable link beat and jabber for 10baseT. */
693         Media_Lnk = 0x0080,             /* Enable just link beat for 100TX/100FX. */
694         Media_LnkBeat = 0x0800,
695 };
696 enum Window7 {                                  /* Window 7: Bus Master control. */
697         Wn7_MasterAddr = 0, Wn7_VlanEtherType=4, Wn7_MasterLen = 6,
698         Wn7_MasterStatus = 12,
699 };
700 /* Boomerang bus master control registers. */
701 enum MasterCtrl {
702         PktStatus = 0x20, DownListPtr = 0x24, FragAddr = 0x28, FragLen = 0x2c,
703         TxFreeThreshold = 0x2f, UpPktStatus = 0x30, UpListPtr = 0x38,
704 };
705
706 /* The Rx and Tx descriptor lists.
707    Caution Alpha hackers: these types are 32 bits!  Note also the 8 byte
708    alignment contraint on tx_ring[] and rx_ring[]. */
709 #define LAST_FRAG       0x80000000                      /* Last Addr/Len pair in descriptor. */
710 #define DN_COMPLETE     0x00010000                      /* This packet has been downloaded */
711 struct boom_rx_desc {
712         u32 next;                                       /* Last entry points to 0.   */
713         s32 status;
714         u32 addr;                                       /* Up to 63 addr/len pairs possible. */
715         s32 length;                                     /* Set LAST_FRAG to indicate last pair. */
716 };
717 /* Values for the Rx status entry. */
718 enum rx_desc_status {
719         RxDComplete=0x00008000, RxDError=0x4000,
720         /* See boomerang_rx() for actual error bits */
721         IPChksumErr=1<<25, TCPChksumErr=1<<26, UDPChksumErr=1<<27,
722         IPChksumValid=1<<29, TCPChksumValid=1<<30, UDPChksumValid=1<<31,
723 };
724
725 #ifdef MAX_SKB_FRAGS
726 #define DO_ZEROCOPY 1
727 #else
728 #define DO_ZEROCOPY 0
729 #endif
730
731 struct boom_tx_desc {
732         u32 next;                                       /* Last entry points to 0.   */
733         s32 status;                                     /* bits 0:12 length, others see below.  */
734 #if DO_ZEROCOPY
735         struct {
736                 u32 addr;
737                 s32 length;
738         } frag[1+MAX_SKB_FRAGS];
739 #else
740                 u32 addr;
741                 s32 length;
742 #endif
743 };
744
745 /* Values for the Tx status entry. */
746 enum tx_desc_status {
747         CRCDisable=0x2000, TxDComplete=0x8000,
748         AddIPChksum=0x02000000, AddTCPChksum=0x04000000, AddUDPChksum=0x08000000,
749         TxIntrUploaded=0x80000000,              /* IRQ when in FIFO, but maybe not sent. */
750 };
751
752 /* Chip features we care about in vp->capabilities, read from the EEPROM. */
753 enum ChipCaps { CapBusMaster=0x20, CapPwrMgmt=0x2000 };
754
755 struct vortex_extra_stats {
756         unsigned long tx_deferred;
757         unsigned long tx_multiple_collisions;
758         unsigned long rx_bad_ssd;
759 };
760
761 struct vortex_private {
762         /* The Rx and Tx rings should be quad-word-aligned. */
763         struct boom_rx_desc* rx_ring;
764         struct boom_tx_desc* tx_ring;
765         dma_addr_t rx_ring_dma;
766         dma_addr_t tx_ring_dma;
767         /* The addresses of transmit- and receive-in-place skbuffs. */
768         struct sk_buff* rx_skbuff[RX_RING_SIZE];
769         struct sk_buff* tx_skbuff[TX_RING_SIZE];
770         unsigned int cur_rx, cur_tx;            /* The next free ring entry */
771         unsigned int dirty_rx, dirty_tx;        /* The ring entries to be free()ed. */
772         struct net_device_stats stats;          /* Generic stats */
773         struct vortex_extra_stats xstats;       /* NIC-specific extra stats */
774         struct sk_buff *tx_skb;                         /* Packet being eaten by bus master ctrl.  */
775         dma_addr_t tx_skb_dma;                          /* Allocated DMA address for bus master ctrl DMA.   */
776
777         /* PCI configuration space information. */
778         struct device *gendev;
779         void __iomem *ioaddr;                   /* IO address space */
780         void __iomem *cb_fn_base;               /* CardBus function status addr space. */
781
782         /* Some values here only for performance evaluation and path-coverage */
783         int rx_nocopy, rx_copy, queued_packet, rx_csumhits;
784         int card_idx;
785
786         /* The remainder are related to chip state, mostly media selection. */
787         struct timer_list timer;                        /* Media selection timer. */
788         struct timer_list rx_oom_timer;         /* Rx skb allocation retry timer */
789         int options;                                            /* User-settable misc. driver options. */
790         unsigned int media_override:4,          /* Passed-in media type. */
791                 default_media:4,                                /* Read from the EEPROM/Wn3_Config. */
792                 full_duplex:1, force_fd:1, autoselect:1,
793                 bus_master:1,                                   /* Vortex can only do a fragment bus-m. */
794                 full_bus_master_tx:1, full_bus_master_rx:2, /* Boomerang  */
795                 flow_ctrl:1,                                    /* Use 802.3x flow control (PAUSE only) */
796                 partner_flow_ctrl:1,                    /* Partner supports flow control */
797                 has_nway:1,
798                 enable_wol:1,                                   /* Wake-on-LAN is enabled */
799                 pm_state_valid:1,                               /* pci_dev->saved_config_space has sane contents */
800                 open:1,
801                 medialock:1,
802                 must_free_region:1,                             /* Flag: if zero, Cardbus owns the I/O region */
803                 large_frames:1;                 /* accept large frames */
804         int drv_flags;
805         u16 status_enable;
806         u16 intr_enable;
807         u16 available_media;                            /* From Wn3_Options. */
808         u16 capabilities, info1, info2;         /* Various, from EEPROM. */
809         u16 advertising;                                        /* NWay media advertisement */
810         unsigned char phys[2];                          /* MII device addresses. */
811         u16 deferred;                                           /* Resend these interrupts when we
812                                                                                  * bale from the ISR */
813         u16 io_size;                                            /* Size of PCI region (for release_region) */
814         spinlock_t lock;                                        /* Serialise access to device & its vortex_private */
815         struct mii_if_info mii;                         /* MII lib hooks/info */
816 };
817
818 #ifdef CONFIG_PCI
819 #define DEVICE_PCI(dev) (((dev)->bus == &pci_bus_type) ? to_pci_dev((dev)) : NULL)
820 #else
821 #define DEVICE_PCI(dev) NULL
822 #endif
823
824 #define VORTEX_PCI(vp) (((vp)->gendev) ? DEVICE_PCI((vp)->gendev) : NULL)
825
826 #ifdef CONFIG_EISA
827 #define DEVICE_EISA(dev) (((dev)->bus == &eisa_bus_type) ? to_eisa_device((dev)) : NULL)
828 #else
829 #define DEVICE_EISA(dev) NULL
830 #endif
831
832 #define VORTEX_EISA(vp) (((vp)->gendev) ? DEVICE_EISA((vp)->gendev) : NULL)
833
834 /* The action to take with a media selection timer tick.
835    Note that we deviate from the 3Com order by checking 10base2 before AUI.
836  */
837 enum xcvr_types {
838         XCVR_10baseT=0, XCVR_AUI, XCVR_10baseTOnly, XCVR_10base2, XCVR_100baseTx,
839         XCVR_100baseFx, XCVR_MII=6, XCVR_NWAY=8, XCVR_ExtMII=9, XCVR_Default=10,
840 };
841
842 static struct media_table {
843         char *name;
844         unsigned int media_bits:16,             /* Bits to set in Wn4_Media register. */
845                 mask:8,                                         /* The transceiver-present bit in Wn3_Config.*/
846                 next:8;                                         /* The media type to try next. */
847         int wait;                                               /* Time before we check media status. */
848 } media_tbl[] = {
849   {     "10baseT",   Media_10TP,0x08, XCVR_10base2, (14*HZ)/10},
850   { "10Mbs AUI", Media_SQE, 0x20, XCVR_Default, (1*HZ)/10},
851   { "undefined", 0,                     0x80, XCVR_10baseT, 10000},
852   { "10base2",   0,                     0x10, XCVR_AUI,         (1*HZ)/10},
853   { "100baseTX", Media_Lnk, 0x02, XCVR_100baseFx, (14*HZ)/10},
854   { "100baseFX", Media_Lnk, 0x04, XCVR_MII,             (14*HZ)/10},
855   { "MII",               0,                     0x41, XCVR_10baseT, 3*HZ },
856   { "undefined", 0,                     0x01, XCVR_10baseT, 10000},
857   { "Autonegotiate", 0,         0x41, XCVR_10baseT, 3*HZ},
858   { "MII-External",      0,             0x41, XCVR_10baseT, 3*HZ },
859   { "Default",   0,                     0xFF, XCVR_10baseT, 10000},
860 };
861
862 static struct {
863         const char str[ETH_GSTRING_LEN];
864 } ethtool_stats_keys[] = {
865         { "tx_deferred" },
866         { "tx_multiple_collisions" },
867         { "rx_bad_ssd" },
868 };
869
870 /* number of ETHTOOL_GSTATS u64's */
871 #define VORTEX_NUM_STATS     3
872
873 static int vortex_probe1(struct device *gendev, void __iomem *ioaddr, int irq,
874                                    int chip_idx, int card_idx);
875 static void vortex_up(struct net_device *dev);
876 static void vortex_down(struct net_device *dev, int final);
877 static int vortex_open(struct net_device *dev);
878 static void mdio_sync(void __iomem *ioaddr, int bits);
879 static int mdio_read(struct net_device *dev, int phy_id, int location);
880 static void mdio_write(struct net_device *vp, int phy_id, int location, int value);
881 static void vortex_timer(unsigned long arg);
882 static void rx_oom_timer(unsigned long arg);
883 static int vortex_start_xmit(struct sk_buff *skb, struct net_device *dev);
884 static int boomerang_start_xmit(struct sk_buff *skb, struct net_device *dev);
885 static int vortex_rx(struct net_device *dev);
886 static int boomerang_rx(struct net_device *dev);
887 static irqreturn_t vortex_interrupt(int irq, void *dev_id, struct pt_regs *regs);
888 static irqreturn_t boomerang_interrupt(int irq, void *dev_id, struct pt_regs *regs);
889 static int vortex_close(struct net_device *dev);
890 static void dump_tx_ring(struct net_device *dev);
891 static void update_stats(void __iomem *ioaddr, struct net_device *dev);
892 static struct net_device_stats *vortex_get_stats(struct net_device *dev);
893 static void set_rx_mode(struct net_device *dev);
894 #ifdef CONFIG_PCI
895 static int vortex_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
896 #endif
897 static void vortex_tx_timeout(struct net_device *dev);
898 static void acpi_set_WOL(struct net_device *dev);
899 static struct ethtool_ops vortex_ethtool_ops;
900 static void set_8021q_mode(struct net_device *dev, int enable);
901
902 \f
903 /* This driver uses 'options' to pass the media type, full-duplex flag, etc. */
904 /* Option count limit only -- unlimited interfaces are supported. */
905 #define MAX_UNITS 8
906 static int options[MAX_UNITS] = { [0 ... MAX_UNITS-1] = -1 };
907 static int full_duplex[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
908 static int hw_checksums[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
909 static int flow_ctrl[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
910 static int enable_wol[MAX_UNITS] = {[0 ... MAX_UNITS-1] = -1 };
911 static int global_options = -1;
912 static int global_full_duplex = -1;
913 static int global_enable_wol = -1;
914
915 /* #define dev_alloc_skb dev_alloc_skb_debug */
916
917 /* Variables to work-around the Compaq PCI BIOS32 problem. */
918 static int compaq_ioaddr, compaq_irq, compaq_device_id = 0x5900;
919 static struct net_device *compaq_net_device;
920
921 static int vortex_cards_found;
922
923 module_param(debug, int, 0);
924 module_param(global_options, int, 0);
925 module_param_array(options, int, NULL, 0);
926 module_param(global_full_duplex, int, 0);
927 module_param_array(full_duplex, int, NULL, 0);
928 module_param_array(hw_checksums, int, NULL, 0);
929 module_param_array(flow_ctrl, int, NULL, 0);
930 module_param(global_enable_wol, int, 0);
931 module_param_array(enable_wol, int, NULL, 0);
932 module_param(rx_copybreak, int, 0);
933 module_param(max_interrupt_work, int, 0);
934 module_param(compaq_ioaddr, int, 0);
935 module_param(compaq_irq, int, 0);
936 module_param(compaq_device_id, int, 0);
937 module_param(watchdog, int, 0);
938 MODULE_PARM_DESC(debug, "3c59x debug level (0-6)");
939 MODULE_PARM_DESC(options, "3c59x: Bits 0-3: media type, bit 4: bus mastering, bit 9: full duplex");
940 MODULE_PARM_DESC(global_options, "3c59x: same as options, but applies to all NICs if options is unset");
941 MODULE_PARM_DESC(full_duplex, "3c59x full duplex setting(s) (1)");
942 MODULE_PARM_DESC(global_full_duplex, "3c59x: same as full_duplex, but applies to all NICs if full_duplex is unset");
943 MODULE_PARM_DESC(hw_checksums, "3c59x Hardware checksum checking by adapter(s) (0-1)");
944 MODULE_PARM_DESC(flow_ctrl, "3c59x 802.3x flow control usage (PAUSE only) (0-1)");
945 MODULE_PARM_DESC(enable_wol, "3c59x: Turn on Wake-on-LAN for adapter(s) (0-1)");
946 MODULE_PARM_DESC(global_enable_wol, "3c59x: same as enable_wol, but applies to all NICs if enable_wol is unset");
947 MODULE_PARM_DESC(rx_copybreak, "3c59x copy breakpoint for copy-only-tiny-frames");
948 MODULE_PARM_DESC(max_interrupt_work, "3c59x maximum events handled per interrupt");
949 MODULE_PARM_DESC(compaq_ioaddr, "3c59x PCI I/O base address (Compaq BIOS problem workaround)");
950 MODULE_PARM_DESC(compaq_irq, "3c59x PCI IRQ number (Compaq BIOS problem workaround)");
951 MODULE_PARM_DESC(compaq_device_id, "3c59x PCI device ID (Compaq BIOS problem workaround)");
952 MODULE_PARM_DESC(watchdog, "3c59x transmit timeout in milliseconds");
953
954 #ifdef CONFIG_NET_POLL_CONTROLLER
955 static void poll_vortex(struct net_device *dev)
956 {
957         struct vortex_private *vp = netdev_priv(dev);
958         unsigned long flags;
959         local_save_flags(flags);
960         local_irq_disable();
961         (vp->full_bus_master_rx ? boomerang_interrupt:vortex_interrupt)(dev->irq,dev,NULL);
962         local_irq_restore(flags);
963
964 #endif
965
966 #ifdef CONFIG_PM
967
968 static int vortex_suspend (struct pci_dev *pdev, pm_message_t state)
969 {
970         struct net_device *dev = pci_get_drvdata(pdev);
971
972         if (dev && dev->priv) {
973                 if (netif_running(dev)) {
974                         netif_device_detach(dev);
975                         vortex_down(dev, 1);
976                 }
977                 pci_save_state(pdev);
978                 pci_enable_wake(pdev, pci_choose_state(pdev, state), 0);
979                 free_irq(dev->irq, dev);
980                 pci_disable_device(pdev);
981                 pci_set_power_state(pdev, pci_choose_state(pdev, state));
982         }
983         return 0;
984 }
985
986 static int vortex_resume (struct pci_dev *pdev)
987 {
988         struct net_device *dev = pci_get_drvdata(pdev);
989         struct vortex_private *vp = netdev_priv(dev);
990
991         if (dev && vp) {
992                 pci_set_power_state(pdev, PCI_D0);
993                 pci_restore_state(pdev);
994                 pci_enable_device(pdev);
995                 pci_set_master(pdev);
996                 if (request_irq(dev->irq, vp->full_bus_master_rx ?
997                                 &boomerang_interrupt : &vortex_interrupt, SA_SHIRQ, dev->name, dev)) {
998                         printk(KERN_WARNING "%s: Could not reserve IRQ %d\n", dev->name, dev->irq);
999                         pci_disable_device(pdev);
1000                         return -EBUSY;
1001                 }
1002                 if (netif_running(dev)) {
1003                         vortex_up(dev);
1004                         netif_device_attach(dev);
1005                 }
1006         }
1007         return 0;
1008 }
1009
1010 #endif /* CONFIG_PM */
1011
1012 #ifdef CONFIG_EISA
1013 static struct eisa_device_id vortex_eisa_ids[] = {
1014         { "TCM5920", CH_3C592 },
1015         { "TCM5970", CH_3C597 },
1016         { "" }
1017 };
1018
1019 static int vortex_eisa_probe (struct device *device);
1020 static int vortex_eisa_remove (struct device *device);
1021
1022 static struct eisa_driver vortex_eisa_driver = {
1023         .id_table = vortex_eisa_ids,
1024         .driver   = {
1025                 .name    = "3c59x",
1026                 .probe   = vortex_eisa_probe,
1027                 .remove  = vortex_eisa_remove
1028         }
1029 };
1030
1031 static int vortex_eisa_probe (struct device *device)
1032 {
1033         void __iomem *ioaddr;
1034         struct eisa_device *edev;
1035
1036         edev = to_eisa_device (device);
1037
1038         if (!request_region(edev->base_addr, VORTEX_TOTAL_SIZE, DRV_NAME))
1039                 return -EBUSY;
1040
1041         ioaddr = ioport_map(edev->base_addr, VORTEX_TOTAL_SIZE);
1042
1043         if (vortex_probe1(device, ioaddr, ioread16(ioaddr + 0xC88) >> 12,
1044                                           edev->id.driver_data, vortex_cards_found)) {
1045                 release_region (edev->base_addr, VORTEX_TOTAL_SIZE);
1046                 return -ENODEV;
1047         }
1048
1049         vortex_cards_found++;
1050
1051         return 0;
1052 }
1053
1054 static int vortex_eisa_remove (struct device *device)
1055 {
1056         struct eisa_device *edev;
1057         struct net_device *dev;
1058         struct vortex_private *vp;
1059         void __iomem *ioaddr;
1060
1061         edev = to_eisa_device (device);
1062         dev = eisa_get_drvdata (edev);
1063
1064         if (!dev) {
1065                 printk("vortex_eisa_remove called for Compaq device!\n");
1066                 BUG();
1067         }
1068
1069         vp = netdev_priv(dev);
1070         ioaddr = vp->ioaddr;
1071         
1072         unregister_netdev (dev);
1073         iowrite16 (TotalReset|0x14, ioaddr + EL3_CMD);
1074         release_region (dev->base_addr, VORTEX_TOTAL_SIZE);
1075
1076         free_netdev (dev);
1077         return 0;
1078 }
1079 #endif
1080
1081 /* returns count found (>= 0), or negative on error */
1082 static int __init vortex_eisa_init (void)
1083 {
1084         int eisa_found = 0;
1085         int orig_cards_found = vortex_cards_found;
1086
1087 #ifdef CONFIG_EISA
1088         if (eisa_driver_register (&vortex_eisa_driver) >= 0) {
1089                         /* Because of the way EISA bus is probed, we cannot assume
1090                          * any device have been found when we exit from
1091                          * eisa_driver_register (the bus root driver may not be
1092                          * initialized yet). So we blindly assume something was
1093                          * found, and let the sysfs magic happend... */
1094                         
1095                         eisa_found = 1;
1096         }
1097 #endif
1098         
1099         /* Special code to work-around the Compaq PCI BIOS32 problem. */
1100         if (compaq_ioaddr) {
1101                 vortex_probe1(NULL, ioport_map(compaq_ioaddr, VORTEX_TOTAL_SIZE),
1102                               compaq_irq, compaq_device_id, vortex_cards_found++);
1103         }
1104
1105         return vortex_cards_found - orig_cards_found + eisa_found;
1106 }
1107
1108 /* returns count (>= 0), or negative on error */
1109 static int __devinit vortex_init_one (struct pci_dev *pdev,
1110                                       const struct pci_device_id *ent)
1111 {
1112         int rc;
1113
1114         /* wake up and enable device */         
1115         rc = pci_enable_device (pdev);
1116         if (rc < 0)
1117                 goto out;
1118
1119         rc = vortex_probe1 (&pdev->dev, pci_iomap(pdev, 0, 0),
1120                             pdev->irq, ent->driver_data, vortex_cards_found);
1121         if (rc < 0) {
1122                 pci_disable_device (pdev);
1123                 goto out;
1124         }
1125
1126         vortex_cards_found++;
1127
1128 out:
1129         return rc;
1130 }
1131
1132 /*
1133  * Start up the PCI/EISA device which is described by *gendev.
1134  * Return 0 on success.
1135  *
1136  * NOTE: pdev can be NULL, for the case of a Compaq device
1137  */
1138 static int __devinit vortex_probe1(struct device *gendev,
1139                                    void __iomem *ioaddr, int irq,
1140                                    int chip_idx, int card_idx)
1141 {
1142         struct vortex_private *vp;
1143         int option;
1144         unsigned int eeprom[0x40], checksum = 0;                /* EEPROM contents */
1145         int i, step;
1146         struct net_device *dev;
1147         static int printed_version;
1148         int retval, print_info;
1149         struct vortex_chip_info * const vci = &vortex_info_tbl[chip_idx];
1150         char *print_name = "3c59x";
1151         struct pci_dev *pdev = NULL;
1152         struct eisa_device *edev = NULL;
1153
1154         if (!printed_version) {
1155                 printk (version);
1156                 printed_version = 1;
1157         }
1158
1159         if (gendev) {
1160                 if ((pdev = DEVICE_PCI(gendev))) {
1161                         print_name = pci_name(pdev);
1162                 }
1163
1164                 if ((edev = DEVICE_EISA(gendev))) {
1165                         print_name = edev->dev.bus_id;
1166                 }
1167         }
1168
1169         dev = alloc_etherdev(sizeof(*vp));
1170         retval = -ENOMEM;
1171         if (!dev) {
1172                 printk (KERN_ERR PFX "unable to allocate etherdev, aborting\n");
1173                 goto out;
1174         }
1175         SET_MODULE_OWNER(dev);
1176         SET_NETDEV_DEV(dev, gendev);
1177         vp = netdev_priv(dev);
1178
1179         option = global_options;
1180
1181         /* The lower four bits are the media type. */
1182         if (dev->mem_start) {
1183                 /*
1184                  * The 'options' param is passed in as the third arg to the
1185                  * LILO 'ether=' argument for non-modular use
1186                  */
1187                 option = dev->mem_start;
1188         }
1189         else if (card_idx < MAX_UNITS) {
1190                 if (options[card_idx] >= 0)
1191                         option = options[card_idx];
1192         }
1193
1194         if (option > 0) {
1195                 if (option & 0x8000)
1196                         vortex_debug = 7;
1197                 if (option & 0x4000)
1198                         vortex_debug = 2;
1199                 if (option & 0x0400)
1200                         vp->enable_wol = 1;
1201         }
1202
1203         print_info = (vortex_debug > 1);
1204         if (print_info)
1205                 printk (KERN_INFO "See Documentation/networking/vortex.txt\n");
1206
1207         printk(KERN_INFO "%s: 3Com %s %s at %p. Vers " DRV_VERSION "\n",
1208                print_name,
1209                pdev ? "PCI" : "EISA",
1210                vci->name,
1211                ioaddr);
1212
1213         dev->base_addr = (unsigned long)ioaddr;
1214         dev->irq = irq;
1215         dev->mtu = mtu;
1216         vp->ioaddr = ioaddr;
1217         vp->large_frames = mtu > 1500;
1218         vp->drv_flags = vci->drv_flags;
1219         vp->has_nway = (vci->drv_flags & HAS_NWAY) ? 1 : 0;
1220         vp->io_size = vci->io_size;
1221         vp->card_idx = card_idx;
1222
1223         /* module list only for Compaq device */
1224         if (gendev == NULL) {
1225                 compaq_net_device = dev;
1226         }
1227
1228         /* PCI-only startup logic */
1229         if (pdev) {
1230                 /* EISA resources already marked, so only PCI needs to do this here */
1231                 /* Ignore return value, because Cardbus drivers already allocate for us */
1232                 if (request_region(dev->base_addr, vci->io_size, print_name) != NULL)
1233                         vp->must_free_region = 1;
1234
1235                 /* enable bus-mastering if necessary */         
1236                 if (vci->flags & PCI_USES_MASTER)
1237                         pci_set_master (pdev);
1238
1239                 if (vci->drv_flags & IS_VORTEX) {
1240                         u8 pci_latency;
1241                         u8 new_latency = 248;
1242
1243                         /* Check the PCI latency value.  On the 3c590 series the latency timer
1244                            must be set to the maximum value to avoid data corruption that occurs
1245                            when the timer expires during a transfer.  This bug exists the Vortex
1246                            chip only. */
1247                         pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &pci_latency);
1248                         if (pci_latency < new_latency) {
1249                                 printk(KERN_INFO "%s: Overriding PCI latency"
1250                                         " timer (CFLT) setting of %d, new value is %d.\n",
1251                                         print_name, pci_latency, new_latency);
1252                                         pci_write_config_byte(pdev, PCI_LATENCY_TIMER, new_latency);
1253                         }
1254                 }
1255         }
1256
1257         spin_lock_init(&vp->lock);
1258         vp->gendev = gendev;
1259         vp->mii.dev = dev;
1260         vp->mii.mdio_read = mdio_read;
1261         vp->mii.mdio_write = mdio_write;
1262         vp->mii.phy_id_mask = 0x1f;
1263         vp->mii.reg_num_mask = 0x1f;
1264
1265         /* Makes sure rings are at least 16 byte aligned. */
1266         vp->rx_ring = pci_alloc_consistent(pdev, sizeof(struct boom_rx_desc) * RX_RING_SIZE
1267                                            + sizeof(struct boom_tx_desc) * TX_RING_SIZE,
1268                                            &vp->rx_ring_dma);
1269         retval = -ENOMEM;
1270         if (vp->rx_ring == 0)
1271                 goto free_region;
1272
1273         vp->tx_ring = (struct boom_tx_desc *)(vp->rx_ring + RX_RING_SIZE);
1274         vp->tx_ring_dma = vp->rx_ring_dma + sizeof(struct boom_rx_desc) * RX_RING_SIZE;
1275
1276         /* if we are a PCI driver, we store info in pdev->driver_data
1277          * instead of a module list */  
1278         if (pdev)
1279                 pci_set_drvdata(pdev, dev);
1280         if (edev)
1281                 eisa_set_drvdata (edev, dev);
1282
1283         vp->media_override = 7;
1284         if (option >= 0) {
1285                 vp->media_override = ((option & 7) == 2)  ?  0  :  option & 15;
1286                 if (vp->media_override != 7)
1287                         vp->medialock = 1;
1288                 vp->full_duplex = (option & 0x200) ? 1 : 0;
1289                 vp->bus_master = (option & 16) ? 1 : 0;
1290         }
1291
1292         if (global_full_duplex > 0)
1293                 vp->full_duplex = 1;
1294         if (global_enable_wol > 0)
1295                 vp->enable_wol = 1;
1296
1297         if (card_idx < MAX_UNITS) {
1298                 if (full_duplex[card_idx] > 0)
1299                         vp->full_duplex = 1;
1300                 if (flow_ctrl[card_idx] > 0)
1301                         vp->flow_ctrl = 1;
1302                 if (enable_wol[card_idx] > 0)
1303                         vp->enable_wol = 1;
1304         }
1305
1306         vp->force_fd = vp->full_duplex;
1307         vp->options = option;
1308         /* Read the station address from the EEPROM. */
1309         EL3WINDOW(0);
1310         {
1311                 int base;
1312
1313                 if (vci->drv_flags & EEPROM_8BIT)
1314                         base = 0x230;
1315                 else if (vci->drv_flags & EEPROM_OFFSET)
1316                         base = EEPROM_Read + 0x30;
1317                 else
1318                         base = EEPROM_Read;
1319
1320                 for (i = 0; i < 0x40; i++) {
1321                         int timer;
1322                         iowrite16(base + i, ioaddr + Wn0EepromCmd);
1323                         /* Pause for at least 162 us. for the read to take place. */
1324                         for (timer = 10; timer >= 0; timer--) {
1325                                 udelay(162);
1326                                 if ((ioread16(ioaddr + Wn0EepromCmd) & 0x8000) == 0)
1327                                         break;
1328                         }
1329                         eeprom[i] = ioread16(ioaddr + Wn0EepromData);
1330                 }
1331         }
1332         for (i = 0; i < 0x18; i++)
1333                 checksum ^= eeprom[i];
1334         checksum = (checksum ^ (checksum >> 8)) & 0xff;
1335         if (checksum != 0x00) {         /* Grrr, needless incompatible change 3Com. */
1336                 while (i < 0x21)
1337                         checksum ^= eeprom[i++];
1338                 checksum = (checksum ^ (checksum >> 8)) & 0xff;
1339         }
1340         if ((checksum != 0x00) && !(vci->drv_flags & IS_TORNADO))
1341                 printk(" ***INVALID CHECKSUM %4.4x*** ", checksum);
1342         for (i = 0; i < 3; i++)
1343                 ((u16 *)dev->dev_addr)[i] = htons(eeprom[i + 10]);
1344         memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
1345         if (print_info) {
1346                 for (i = 0; i < 6; i++)
1347                         printk("%c%2.2x", i ? ':' : ' ', dev->dev_addr[i]);
1348         }
1349         /* Unfortunately an all zero eeprom passes the checksum and this
1350            gets found in the wild in failure cases. Crypto is hard 8) */
1351         if (!is_valid_ether_addr(dev->dev_addr)) {
1352                 retval = -EINVAL;
1353                 printk(KERN_ERR "*** EEPROM MAC address is invalid.\n");
1354                 goto free_ring; /* With every pack */
1355         }
1356         EL3WINDOW(2);
1357         for (i = 0; i < 6; i++)
1358                 iowrite8(dev->dev_addr[i], ioaddr + i);
1359
1360 #ifdef __sparc__
1361         if (print_info)
1362                 printk(", IRQ %s\n", __irq_itoa(dev->irq));
1363 #else
1364         if (print_info)
1365                 printk(", IRQ %d\n", dev->irq);
1366         /* Tell them about an invalid IRQ. */
1367         if (dev->irq <= 0 || dev->irq >= NR_IRQS)
1368                 printk(KERN_WARNING " *** Warning: IRQ %d is unlikely to work! ***\n",
1369                            dev->irq);
1370 #endif
1371
1372         EL3WINDOW(4);
1373         step = (ioread8(ioaddr + Wn4_NetDiag) & 0x1e) >> 1;
1374         if (print_info) {
1375                 printk(KERN_INFO "  product code %02x%02x rev %02x.%d date %02d-"
1376                         "%02d-%02d\n", eeprom[6]&0xff, eeprom[6]>>8, eeprom[0x14],
1377                         step, (eeprom[4]>>5) & 15, eeprom[4] & 31, eeprom[4]>>9);
1378         }
1379
1380
1381         if (pdev && vci->drv_flags & HAS_CB_FNS) {
1382                 unsigned short n;
1383
1384                 vp->cb_fn_base = pci_iomap(pdev, 2, 0);
1385                 if (!vp->cb_fn_base) {
1386                         retval = -ENOMEM;
1387                         goto free_ring;
1388                 }
1389
1390                 if (print_info) {
1391                         printk(KERN_INFO "%s: CardBus functions mapped %8.8lx->%p\n",
1392                                 print_name, pci_resource_start(pdev, 2),
1393                                 vp->cb_fn_base);
1394                 }
1395                 EL3WINDOW(2);
1396
1397                 n = ioread16(ioaddr + Wn2_ResetOptions) & ~0x4010;
1398                 if (vp->drv_flags & INVERT_LED_PWR)
1399                         n |= 0x10;
1400                 if (vp->drv_flags & INVERT_MII_PWR)
1401                         n |= 0x4000;
1402                 iowrite16(n, ioaddr + Wn2_ResetOptions);
1403                 if (vp->drv_flags & WNO_XCVR_PWR) {
1404                         EL3WINDOW(0);
1405                         iowrite16(0x0800, ioaddr);
1406                 }
1407         }
1408
1409         /* Extract our information from the EEPROM data. */
1410         vp->info1 = eeprom[13];
1411         vp->info2 = eeprom[15];
1412         vp->capabilities = eeprom[16];
1413
1414         if (vp->info1 & 0x8000) {
1415                 vp->full_duplex = 1;
1416                 if (print_info)
1417                         printk(KERN_INFO "Full duplex capable\n");
1418         }
1419
1420         {
1421                 static const char * ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
1422                 unsigned int config;
1423                 EL3WINDOW(3);
1424                 vp->available_media = ioread16(ioaddr + Wn3_Options);
1425                 if ((vp->available_media & 0xff) == 0)          /* Broken 3c916 */
1426                         vp->available_media = 0x40;
1427                 config = ioread32(ioaddr + Wn3_Config);
1428                 if (print_info) {
1429                         printk(KERN_DEBUG "  Internal config register is %4.4x, "
1430                                    "transceivers %#x.\n", config, ioread16(ioaddr + Wn3_Options));
1431                         printk(KERN_INFO "  %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
1432                                    8 << RAM_SIZE(config),
1433                                    RAM_WIDTH(config) ? "word" : "byte",
1434                                    ram_split[RAM_SPLIT(config)],
1435                                    AUTOSELECT(config) ? "autoselect/" : "",
1436                                    XCVR(config) > XCVR_ExtMII ? "<invalid transceiver>" :
1437                                    media_tbl[XCVR(config)].name);
1438                 }
1439                 vp->default_media = XCVR(config);
1440                 if (vp->default_media == XCVR_NWAY)
1441                         vp->has_nway = 1;
1442                 vp->autoselect = AUTOSELECT(config);
1443         }
1444
1445         if (vp->media_override != 7) {
1446                 printk(KERN_INFO "%s:  Media override to transceiver type %d (%s).\n",
1447                                 print_name, vp->media_override,
1448                                 media_tbl[vp->media_override].name);
1449                 dev->if_port = vp->media_override;
1450         } else
1451                 dev->if_port = vp->default_media;
1452
1453         if ((vp->available_media & 0x40) || (vci->drv_flags & HAS_NWAY) ||
1454                 dev->if_port == XCVR_MII || dev->if_port == XCVR_NWAY) {
1455                 int phy, phy_idx = 0;
1456                 EL3WINDOW(4);
1457                 mii_preamble_required++;
1458                 if (vp->drv_flags & EXTRA_PREAMBLE)
1459                         mii_preamble_required++;
1460                 mdio_sync(ioaddr, 32);
1461                 mdio_read(dev, 24, MII_BMSR);
1462                 for (phy = 0; phy < 32 && phy_idx < 1; phy++) {
1463                         int mii_status, phyx;
1464
1465                         /*
1466                          * For the 3c905CX we look at index 24 first, because it bogusly
1467                          * reports an external PHY at all indices
1468                          */
1469                         if (phy == 0)
1470                                 phyx = 24;
1471                         else if (phy <= 24)
1472                                 phyx = phy - 1;
1473                         else
1474                                 phyx = phy;
1475                         mii_status = mdio_read(dev, phyx, MII_BMSR);
1476                         if (mii_status  &&  mii_status != 0xffff) {
1477                                 vp->phys[phy_idx++] = phyx;
1478                                 if (print_info) {
1479                                         printk(KERN_INFO "  MII transceiver found at address %d,"
1480                                                 " status %4x.\n", phyx, mii_status);
1481                                 }
1482                                 if ((mii_status & 0x0040) == 0)
1483                                         mii_preamble_required++;
1484                         }
1485                 }
1486                 mii_preamble_required--;
1487                 if (phy_idx == 0) {
1488                         printk(KERN_WARNING"  ***WARNING*** No MII transceivers found!\n");
1489                         vp->phys[0] = 24;
1490                 } else {
1491                         vp->advertising = mdio_read(dev, vp->phys[0], MII_ADVERTISE);
1492                         if (vp->full_duplex) {
1493                                 /* Only advertise the FD media types. */
1494                                 vp->advertising &= ~0x02A0;
1495                                 mdio_write(dev, vp->phys[0], 4, vp->advertising);
1496                         }
1497                 }
1498                 vp->mii.phy_id = vp->phys[0];
1499         }
1500
1501         if (vp->capabilities & CapBusMaster) {
1502                 vp->full_bus_master_tx = 1;
1503                 if (print_info) {
1504                         printk(KERN_INFO "  Enabling bus-master transmits and %s receives.\n",
1505                         (vp->info2 & 1) ? "early" : "whole-frame" );
1506                 }
1507                 vp->full_bus_master_rx = (vp->info2 & 1) ? 1 : 2;
1508                 vp->bus_master = 0;             /* AKPM: vortex only */
1509         }
1510
1511         /* The 3c59x-specific entries in the device structure. */
1512         dev->open = vortex_open;
1513         if (vp->full_bus_master_tx) {
1514                 dev->hard_start_xmit = boomerang_start_xmit;
1515                 /* Actually, it still should work with iommu. */
1516                 dev->features |= NETIF_F_SG;
1517                 if (card_idx < MAX_UNITS &&
1518                     ((hw_checksums[card_idx] == -1 && (vp->drv_flags & HAS_HWCKSM)) ||
1519                                 hw_checksums[card_idx] == 1)) {
1520                         dev->features |= NETIF_F_IP_CSUM;
1521                 }
1522         } else {
1523                 dev->hard_start_xmit = vortex_start_xmit;
1524         }
1525
1526         if (print_info) {
1527                 printk(KERN_INFO "%s: scatter/gather %sabled. h/w checksums %sabled\n",
1528                                 print_name,
1529                                 (dev->features & NETIF_F_SG) ? "en":"dis",
1530                                 (dev->features & NETIF_F_IP_CSUM) ? "en":"dis");
1531         }
1532
1533         dev->stop = vortex_close;
1534         dev->get_stats = vortex_get_stats;
1535 #ifdef CONFIG_PCI
1536         dev->do_ioctl = vortex_ioctl;
1537 #endif
1538         dev->ethtool_ops = &vortex_ethtool_ops;
1539         dev->set_multicast_list = set_rx_mode;
1540         dev->tx_timeout = vortex_tx_timeout;
1541         dev->watchdog_timeo = (watchdog * HZ) / 1000;
1542 #ifdef CONFIG_NET_POLL_CONTROLLER
1543         dev->poll_controller = poll_vortex; 
1544 #endif
1545         if (pdev) {
1546                 vp->pm_state_valid = 1;
1547                 pci_save_state(VORTEX_PCI(vp));
1548                 acpi_set_WOL(dev);
1549         }
1550         retval = register_netdev(dev);
1551         if (retval == 0)
1552                 return 0;
1553
1554 free_ring:
1555         pci_free_consistent(pdev,
1556                                                 sizeof(struct boom_rx_desc) * RX_RING_SIZE
1557                                                         + sizeof(struct boom_tx_desc) * TX_RING_SIZE,
1558                                                 vp->rx_ring,
1559                                                 vp->rx_ring_dma);
1560 free_region:
1561         if (vp->must_free_region)
1562                 release_region(dev->base_addr, vci->io_size);
1563         free_netdev(dev);
1564         printk(KERN_ERR PFX "vortex_probe1 fails.  Returns %d\n", retval);
1565 out:
1566         return retval;
1567 }
1568
1569 static void
1570 issue_and_wait(struct net_device *dev, int cmd)
1571 {
1572         struct vortex_private *vp = netdev_priv(dev);
1573         void __iomem *ioaddr = vp->ioaddr;
1574         int i;
1575
1576         iowrite16(cmd, ioaddr + EL3_CMD);
1577         for (i = 0; i < 2000; i++) {
1578                 if (!(ioread16(ioaddr + EL3_STATUS) & CmdInProgress))
1579                         return;
1580         }
1581
1582         /* OK, that didn't work.  Do it the slow way.  One second */
1583         for (i = 0; i < 100000; i++) {
1584                 if (!(ioread16(ioaddr + EL3_STATUS) & CmdInProgress)) {
1585                         if (vortex_debug > 1)
1586                                 printk(KERN_INFO "%s: command 0x%04x took %d usecs\n",
1587                                            dev->name, cmd, i * 10);
1588                         return;
1589                 }
1590                 udelay(10);
1591         }
1592         printk(KERN_ERR "%s: command 0x%04x did not complete! Status=0x%x\n",
1593                            dev->name, cmd, ioread16(ioaddr + EL3_STATUS));
1594 }
1595
1596 static void
1597 vortex_up(struct net_device *dev)
1598 {
1599         struct vortex_private *vp = netdev_priv(dev);
1600         void __iomem *ioaddr = vp->ioaddr;
1601         unsigned int config;
1602         int i;
1603
1604         if (VORTEX_PCI(vp)) {
1605                 pci_set_power_state(VORTEX_PCI(vp), PCI_D0);    /* Go active */
1606                 if (vp->pm_state_valid)
1607                         pci_restore_state(VORTEX_PCI(vp));
1608                 pci_enable_device(VORTEX_PCI(vp));
1609         }
1610
1611         /* Before initializing select the active media port. */
1612         EL3WINDOW(3);
1613         config = ioread32(ioaddr + Wn3_Config);
1614
1615         if (vp->media_override != 7) {
1616                 printk(KERN_INFO "%s: Media override to transceiver %d (%s).\n",
1617                            dev->name, vp->media_override,
1618                            media_tbl[vp->media_override].name);
1619                 dev->if_port = vp->media_override;
1620         } else if (vp->autoselect) {
1621                 if (vp->has_nway) {
1622                         if (vortex_debug > 1)
1623                                 printk(KERN_INFO "%s: using NWAY device table, not %d\n",
1624                                                                 dev->name, dev->if_port);
1625                         dev->if_port = XCVR_NWAY;
1626                 } else {
1627                         /* Find first available media type, starting with 100baseTx. */
1628                         dev->if_port = XCVR_100baseTx;
1629                         while (! (vp->available_media & media_tbl[dev->if_port].mask))
1630                                 dev->if_port = media_tbl[dev->if_port].next;
1631                         if (vortex_debug > 1)
1632                                 printk(KERN_INFO "%s: first available media type: %s\n",
1633                                         dev->name, media_tbl[dev->if_port].name);
1634                 }
1635         } else {
1636                 dev->if_port = vp->default_media;
1637                 if (vortex_debug > 1)
1638                         printk(KERN_INFO "%s: using default media %s\n",
1639                                 dev->name, media_tbl[dev->if_port].name);
1640         }
1641
1642         init_timer(&vp->timer);
1643         vp->timer.expires = RUN_AT(media_tbl[dev->if_port].wait);
1644         vp->timer.data = (unsigned long)dev;
1645         vp->timer.function = vortex_timer;              /* timer handler */
1646         add_timer(&vp->timer);
1647
1648         init_timer(&vp->rx_oom_timer);
1649         vp->rx_oom_timer.data = (unsigned long)dev;
1650         vp->rx_oom_timer.function = rx_oom_timer;
1651
1652         if (vortex_debug > 1)
1653                 printk(KERN_DEBUG "%s: Initial media type %s.\n",
1654                            dev->name, media_tbl[dev->if_port].name);
1655
1656         vp->full_duplex = vp->force_fd;
1657         config = BFINS(config, dev->if_port, 20, 4);
1658         if (vortex_debug > 6)
1659                 printk(KERN_DEBUG "vortex_up(): writing 0x%x to InternalConfig\n", config);
1660         iowrite32(config, ioaddr + Wn3_Config);
1661
1662         if (dev->if_port == XCVR_MII || dev->if_port == XCVR_NWAY) {
1663                 int mii_reg1, mii_reg5;
1664                 EL3WINDOW(4);
1665                 /* Read BMSR (reg1) only to clear old status. */
1666                 mii_reg1 = mdio_read(dev, vp->phys[0], MII_BMSR);
1667                 mii_reg5 = mdio_read(dev, vp->phys[0], MII_LPA);
1668                 if (mii_reg5 == 0xffff  ||  mii_reg5 == 0x0000) {
1669                         netif_carrier_off(dev); /* No MII device or no link partner report */
1670                 } else {
1671                         mii_reg5 &= vp->advertising;
1672                         if ((mii_reg5 & 0x0100) != 0    /* 100baseTx-FD */
1673                                  || (mii_reg5 & 0x00C0) == 0x0040) /* 10T-FD, but not 100-HD */
1674                         vp->full_duplex = 1;
1675                         netif_carrier_on(dev);
1676                 }
1677                 vp->partner_flow_ctrl = ((mii_reg5 & 0x0400) != 0);
1678                 if (vortex_debug > 1)
1679                         printk(KERN_INFO "%s: MII #%d status %4.4x, link partner capability %4.4x,"
1680                                    " info1 %04x, setting %s-duplex.\n",
1681                                         dev->name, vp->phys[0],
1682                                         mii_reg1, mii_reg5,
1683                                         vp->info1, ((vp->info1 & 0x8000) || vp->full_duplex) ? "full" : "half");
1684                 EL3WINDOW(3);
1685         }
1686
1687         /* Set the full-duplex bit. */
1688         iowrite16(      ((vp->info1 & 0x8000) || vp->full_duplex ? 0x20 : 0) |
1689                         (vp->large_frames ? 0x40 : 0) |
1690                         ((vp->full_duplex && vp->flow_ctrl && vp->partner_flow_ctrl) ? 0x100 : 0),
1691                         ioaddr + Wn3_MAC_Ctrl);
1692
1693         if (vortex_debug > 1) {
1694                 printk(KERN_DEBUG "%s: vortex_up() InternalConfig %8.8x.\n",
1695                         dev->name, config);
1696         }
1697
1698         issue_and_wait(dev, TxReset);
1699         /*
1700          * Don't reset the PHY - that upsets autonegotiation during DHCP operations.
1701          */
1702         issue_and_wait(dev, RxReset|0x04);
1703
1704         iowrite16(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
1705
1706         if (vortex_debug > 1) {
1707                 EL3WINDOW(4);
1708                 printk(KERN_DEBUG "%s: vortex_up() irq %d media status %4.4x.\n",
1709                            dev->name, dev->irq, ioread16(ioaddr + Wn4_Media));
1710         }
1711
1712         /* Set the station address and mask in window 2 each time opened. */
1713         EL3WINDOW(2);
1714         for (i = 0; i < 6; i++)
1715                 iowrite8(dev->dev_addr[i], ioaddr + i);
1716         for (; i < 12; i+=2)
1717                 iowrite16(0, ioaddr + i);
1718
1719         if (vp->cb_fn_base) {
1720                 unsigned short n = ioread16(ioaddr + Wn2_ResetOptions) & ~0x4010;
1721                 if (vp->drv_flags & INVERT_LED_PWR)
1722                         n |= 0x10;
1723                 if (vp->drv_flags & INVERT_MII_PWR)
1724                         n |= 0x4000;
1725                 iowrite16(n, ioaddr + Wn2_ResetOptions);
1726         }
1727
1728         if (dev->if_port == XCVR_10base2)
1729                 /* Start the thinnet transceiver. We should really wait 50ms...*/
1730                 iowrite16(StartCoax, ioaddr + EL3_CMD);
1731         if (dev->if_port != XCVR_NWAY) {
1732                 EL3WINDOW(4);
1733                 iowrite16((ioread16(ioaddr + Wn4_Media) & ~(Media_10TP|Media_SQE)) |
1734                          media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
1735         }
1736
1737         /* Switch to the stats window, and clear all stats by reading. */
1738         iowrite16(StatsDisable, ioaddr + EL3_CMD);
1739         EL3WINDOW(6);
1740         for (i = 0; i < 10; i++)
1741                 ioread8(ioaddr + i);
1742         ioread16(ioaddr + 10);
1743         ioread16(ioaddr + 12);
1744         /* New: On the Vortex we must also clear the BadSSD counter. */
1745         EL3WINDOW(4);
1746         ioread8(ioaddr + 12);
1747         /* ..and on the Boomerang we enable the extra statistics bits. */
1748         iowrite16(0x0040, ioaddr + Wn4_NetDiag);
1749
1750         /* Switch to register set 7 for normal use. */
1751         EL3WINDOW(7);
1752
1753         if (vp->full_bus_master_rx) { /* Boomerang bus master. */
1754                 vp->cur_rx = vp->dirty_rx = 0;
1755                 /* Initialize the RxEarly register as recommended. */
1756                 iowrite16(SetRxThreshold + (1536>>2), ioaddr + EL3_CMD);
1757                 iowrite32(0x0020, ioaddr + PktStatus);
1758                 iowrite32(vp->rx_ring_dma, ioaddr + UpListPtr);
1759         }
1760         if (vp->full_bus_master_tx) {           /* Boomerang bus master Tx. */
1761                 vp->cur_tx = vp->dirty_tx = 0;
1762                 if (vp->drv_flags & IS_BOOMERANG)
1763                         iowrite8(PKT_BUF_SZ>>8, ioaddr + TxFreeThreshold); /* Room for a packet. */
1764                 /* Clear the Rx, Tx rings. */
1765                 for (i = 0; i < RX_RING_SIZE; i++)      /* AKPM: this is done in vortex_open, too */
1766                         vp->rx_ring[i].status = 0;
1767                 for (i = 0; i < TX_RING_SIZE; i++)
1768                         vp->tx_skbuff[i] = NULL;
1769                 iowrite32(0, ioaddr + DownListPtr);
1770         }
1771         /* Set receiver mode: presumably accept b-case and phys addr only. */
1772         set_rx_mode(dev);
1773         /* enable 802.1q tagged frames */
1774         set_8021q_mode(dev, 1);
1775         iowrite16(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
1776
1777 //      issue_and_wait(dev, SetTxStart|0x07ff);
1778         iowrite16(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
1779         iowrite16(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
1780         /* Allow status bits to be seen. */
1781         vp->status_enable = SetStatusEnb | HostError|IntReq|StatsFull|TxComplete|
1782                 (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
1783                 (vp->full_bus_master_rx ? UpComplete : RxComplete) |
1784                 (vp->bus_master ? DMADone : 0);
1785         vp->intr_enable = SetIntrEnb | IntLatch | TxAvailable |
1786                 (vp->full_bus_master_rx ? 0 : RxComplete) |
1787                 StatsFull | HostError | TxComplete | IntReq
1788                 | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete;
1789         iowrite16(vp->status_enable, ioaddr + EL3_CMD);
1790         /* Ack all pending events, and set active indicator mask. */
1791         iowrite16(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
1792                  ioaddr + EL3_CMD);
1793         iowrite16(vp->intr_enable, ioaddr + EL3_CMD);
1794         if (vp->cb_fn_base)                     /* The PCMCIA people are idiots.  */
1795                 iowrite32(0x8000, vp->cb_fn_base + 4);
1796         netif_start_queue (dev);
1797 }
1798
1799 static int
1800 vortex_open(struct net_device *dev)
1801 {
1802         struct vortex_private *vp = netdev_priv(dev);
1803         int i;
1804         int retval;
1805
1806         /* Use the now-standard shared IRQ implementation. */
1807         if ((retval = request_irq(dev->irq, vp->full_bus_master_rx ?
1808                                 &boomerang_interrupt : &vortex_interrupt, SA_SHIRQ, dev->name, dev))) {
1809                 printk(KERN_ERR "%s: Could not reserve IRQ %d\n", dev->name, dev->irq);
1810                 goto out;
1811         }
1812
1813         if (vp->full_bus_master_rx) { /* Boomerang bus master. */
1814                 if (vortex_debug > 2)
1815                         printk(KERN_DEBUG "%s:  Filling in the Rx ring.\n", dev->name);
1816                 for (i = 0; i < RX_RING_SIZE; i++) {
1817                         struct sk_buff *skb;
1818                         vp->rx_ring[i].next = cpu_to_le32(vp->rx_ring_dma + sizeof(struct boom_rx_desc) * (i+1));
1819                         vp->rx_ring[i].status = 0;      /* Clear complete bit. */
1820                         vp->rx_ring[i].length = cpu_to_le32(PKT_BUF_SZ | LAST_FRAG);
1821                         skb = dev_alloc_skb(PKT_BUF_SZ);
1822                         vp->rx_skbuff[i] = skb;
1823                         if (skb == NULL)
1824                                 break;                  /* Bad news!  */
1825                         skb->dev = dev;                 /* Mark as being used by this device. */
1826                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1827                         vp->rx_ring[i].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data, PKT_BUF_SZ, PCI_DMA_FROMDEVICE));
1828                 }
1829                 if (i != RX_RING_SIZE) {
1830                         int j;
1831                         printk(KERN_EMERG "%s: no memory for rx ring\n", dev->name);
1832                         for (j = 0; j < i; j++) {
1833                                 if (vp->rx_skbuff[j]) {
1834                                         dev_kfree_skb(vp->rx_skbuff[j]);
1835                                         vp->rx_skbuff[j] = NULL;
1836                                 }
1837                         }
1838                         retval = -ENOMEM;
1839                         goto out_free_irq;
1840                 }
1841                 /* Wrap the ring. */
1842                 vp->rx_ring[i-1].next = cpu_to_le32(vp->rx_ring_dma);
1843         }
1844
1845         vortex_up(dev);
1846         return 0;
1847
1848 out_free_irq:
1849         free_irq(dev->irq, dev);
1850 out:
1851         if (vortex_debug > 1)
1852                 printk(KERN_ERR "%s: vortex_open() fails: returning %d\n", dev->name, retval);
1853         return retval;
1854 }
1855
1856 static void
1857 vortex_timer(unsigned long data)
1858 {
1859         struct net_device *dev = (struct net_device *)data;
1860         struct vortex_private *vp = netdev_priv(dev);
1861         void __iomem *ioaddr = vp->ioaddr;
1862         int next_tick = 60*HZ;
1863         int ok = 0;
1864         int media_status, mii_status, old_window;
1865
1866         if (vortex_debug > 2) {
1867                 printk(KERN_DEBUG "%s: Media selection timer tick happened, %s.\n",
1868                            dev->name, media_tbl[dev->if_port].name);
1869                 printk(KERN_DEBUG "dev->watchdog_timeo=%d\n", dev->watchdog_timeo);
1870         }
1871
1872         if (vp->medialock)
1873                 goto leave_media_alone;
1874         disable_irq(dev->irq);
1875         old_window = ioread16(ioaddr + EL3_CMD) >> 13;
1876         EL3WINDOW(4);
1877         media_status = ioread16(ioaddr + Wn4_Media);
1878         switch (dev->if_port) {
1879         case XCVR_10baseT:  case XCVR_100baseTx:  case XCVR_100baseFx:
1880                 if (media_status & Media_LnkBeat) {
1881                         netif_carrier_on(dev);
1882                         ok = 1;
1883                         if (vortex_debug > 1)
1884                                 printk(KERN_DEBUG "%s: Media %s has link beat, %x.\n",
1885                                            dev->name, media_tbl[dev->if_port].name, media_status);
1886                 } else {
1887                         netif_carrier_off(dev);
1888                         if (vortex_debug > 1) {
1889                                 printk(KERN_DEBUG "%s: Media %s has no link beat, %x.\n",
1890                                            dev->name, media_tbl[dev->if_port].name, media_status);
1891                         }
1892                 }
1893                 break;
1894         case XCVR_MII: case XCVR_NWAY:
1895                 {
1896                         spin_lock_bh(&vp->lock);
1897                         mii_status = mdio_read(dev, vp->phys[0], MII_BMSR);
1898                         if (!(mii_status & BMSR_LSTATUS)) {
1899                                 /* Re-read to get actual link status */
1900                                 mii_status = mdio_read(dev, vp->phys[0], MII_BMSR);
1901                         }
1902                         ok = 1;
1903                         if (vortex_debug > 2)
1904                                 printk(KERN_DEBUG "%s: MII transceiver has status %4.4x.\n",
1905                                         dev->name, mii_status);
1906                         if (mii_status & BMSR_LSTATUS) {
1907                                 int mii_reg5 = mdio_read(dev, vp->phys[0], MII_LPA);
1908                                 if (! vp->force_fd  &&  mii_reg5 != 0xffff) {
1909                                         int duplex;
1910
1911                                         mii_reg5 &= vp->advertising;
1912                                         duplex = (mii_reg5&0x0100) || (mii_reg5 & 0x01C0) == 0x0040;
1913                                         if (vp->full_duplex != duplex) {
1914                                                 vp->full_duplex = duplex;
1915                                                 printk(KERN_INFO "%s: Setting %s-duplex based on MII "
1916                                                         "#%d link partner capability of %4.4x.\n",
1917                                                         dev->name, vp->full_duplex ? "full" : "half",
1918                                                         vp->phys[0], mii_reg5);
1919                                                 /* Set the full-duplex bit. */
1920                                                 EL3WINDOW(3);
1921                                                 iowrite16(      (vp->full_duplex ? 0x20 : 0) |
1922                                                                 (vp->large_frames ? 0x40 : 0) |
1923                                                                 ((vp->full_duplex && vp->flow_ctrl && vp->partner_flow_ctrl) ? 0x100 : 0),
1924                                                                 ioaddr + Wn3_MAC_Ctrl);
1925                                                 if (vortex_debug > 1)
1926                                                         printk(KERN_DEBUG "Setting duplex in Wn3_MAC_Ctrl\n");
1927                                                 /* AKPM: bug: should reset Tx and Rx after setting Duplex.  Page 180 */
1928                                         }
1929                                 }
1930                                 netif_carrier_on(dev);
1931                         } else {
1932                                 netif_carrier_off(dev);
1933                         }
1934                         spin_unlock_bh(&vp->lock);
1935                 }
1936                 break;
1937           default:                                      /* Other media types handled by Tx timeouts. */
1938                 if (vortex_debug > 1)
1939                   printk(KERN_DEBUG "%s: Media %s has no indication, %x.\n",
1940                                  dev->name, media_tbl[dev->if_port].name, media_status);
1941                 ok = 1;
1942         }
1943         if ( ! ok) {
1944                 unsigned int config;
1945
1946                 do {
1947                         dev->if_port = media_tbl[dev->if_port].next;
1948                 } while ( ! (vp->available_media & media_tbl[dev->if_port].mask));
1949                 if (dev->if_port == XCVR_Default) { /* Go back to default. */
1950                   dev->if_port = vp->default_media;
1951                   if (vortex_debug > 1)
1952                         printk(KERN_DEBUG "%s: Media selection failing, using default "
1953                                    "%s port.\n",
1954                                    dev->name, media_tbl[dev->if_port].name);
1955                 } else {
1956                         if (vortex_debug > 1)
1957                                 printk(KERN_DEBUG "%s: Media selection failed, now trying "
1958                                            "%s port.\n",
1959                                            dev->name, media_tbl[dev->if_port].name);
1960                         next_tick = media_tbl[dev->if_port].wait;
1961                 }
1962                 iowrite16((media_status & ~(Media_10TP|Media_SQE)) |
1963                          media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
1964
1965                 EL3WINDOW(3);
1966                 config = ioread32(ioaddr + Wn3_Config);
1967                 config = BFINS(config, dev->if_port, 20, 4);
1968                 iowrite32(config, ioaddr + Wn3_Config);
1969
1970                 iowrite16(dev->if_port == XCVR_10base2 ? StartCoax : StopCoax,
1971                          ioaddr + EL3_CMD);
1972                 if (vortex_debug > 1)
1973                         printk(KERN_DEBUG "wrote 0x%08x to Wn3_Config\n", config);
1974                 /* AKPM: FIXME: Should reset Rx & Tx here.  P60 of 3c90xc.pdf */
1975         }
1976         EL3WINDOW(old_window);
1977         enable_irq(dev->irq);
1978
1979 leave_media_alone:
1980         if (vortex_debug > 2)
1981           printk(KERN_DEBUG "%s: Media selection timer finished, %s.\n",
1982                          dev->name, media_tbl[dev->if_port].name);
1983
1984         mod_timer(&vp->timer, RUN_AT(next_tick));
1985         if (vp->deferred)
1986                 iowrite16(FakeIntr, ioaddr + EL3_CMD);
1987         return;
1988 }
1989
1990 static void vortex_tx_timeout(struct net_device *dev)
1991 {
1992         struct vortex_private *vp = netdev_priv(dev);
1993         void __iomem *ioaddr = vp->ioaddr;
1994
1995         printk(KERN_ERR "%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
1996                    dev->name, ioread8(ioaddr + TxStatus),
1997                    ioread16(ioaddr + EL3_STATUS));
1998         EL3WINDOW(4);
1999         printk(KERN_ERR "  diagnostics: net %04x media %04x dma %08x fifo %04x\n",
2000                         ioread16(ioaddr + Wn4_NetDiag),
2001                         ioread16(ioaddr + Wn4_Media),
2002                         ioread32(ioaddr + PktStatus),
2003                         ioread16(ioaddr + Wn4_FIFODiag));
2004         /* Slight code bloat to be user friendly. */
2005         if ((ioread8(ioaddr + TxStatus) & 0x88) == 0x88)
2006                 printk(KERN_ERR "%s: Transmitter encountered 16 collisions --"
2007                            " network cable problem?\n", dev->name);
2008         if (ioread16(ioaddr + EL3_STATUS) & IntLatch) {
2009                 printk(KERN_ERR "%s: Interrupt posted but not delivered --"
2010                            " IRQ blocked by another device?\n", dev->name);
2011                 /* Bad idea here.. but we might as well handle a few events. */
2012                 {
2013                         /*
2014                          * Block interrupts because vortex_interrupt does a bare spin_lock()
2015                          */
2016                         unsigned long flags;
2017                         local_irq_save(flags);
2018                         if (vp->full_bus_master_tx)
2019                                 boomerang_interrupt(dev->irq, dev, NULL);
2020                         else
2021                                 vortex_interrupt(dev->irq, dev, NULL);
2022                         local_irq_restore(flags);
2023                 }
2024         }
2025
2026         if (vortex_debug > 0)
2027                 dump_tx_ring(dev);
2028
2029         issue_and_wait(dev, TxReset);
2030
2031         vp->stats.tx_errors++;
2032         if (vp->full_bus_master_tx) {
2033                 printk(KERN_DEBUG "%s: Resetting the Tx ring pointer.\n", dev->name);
2034                 if (vp->cur_tx - vp->dirty_tx > 0  &&  ioread32(ioaddr + DownListPtr) == 0)
2035                         iowrite32(vp->tx_ring_dma + (vp->dirty_tx % TX_RING_SIZE) * sizeof(struct boom_tx_desc),
2036                                  ioaddr + DownListPtr);
2037                 if (vp->cur_tx - vp->dirty_tx < TX_RING_SIZE)
2038                         netif_wake_queue (dev);
2039                 if (vp->drv_flags & IS_BOOMERANG)
2040                         iowrite8(PKT_BUF_SZ>>8, ioaddr + TxFreeThreshold);
2041                 iowrite16(DownUnstall, ioaddr + EL3_CMD);
2042         } else {
2043                 vp->stats.tx_dropped++;
2044                 netif_wake_queue(dev);
2045         }
2046         
2047         /* Issue Tx Enable */
2048         iowrite16(TxEnable, ioaddr + EL3_CMD);
2049         dev->trans_start = jiffies;
2050         
2051         /* Switch to register set 7 for normal use. */
2052         EL3WINDOW(7);
2053 }
2054
2055 /*
2056  * Handle uncommon interrupt sources.  This is a separate routine to minimize
2057  * the cache impact.
2058  */
2059 static void
2060 vortex_error(struct net_device *dev, int status)
2061 {
2062         struct vortex_private *vp = netdev_priv(dev);
2063         void __iomem *ioaddr = vp->ioaddr;
2064         int do_tx_reset = 0, reset_mask = 0;
2065         unsigned char tx_status = 0;
2066
2067         if (vortex_debug > 2) {
2068                 printk(KERN_ERR "%s: vortex_error(), status=0x%x\n", dev->name, status);
2069         }
2070
2071         if (status & TxComplete) {                      /* Really "TxError" for us. */
2072                 tx_status = ioread8(ioaddr + TxStatus);
2073                 /* Presumably a tx-timeout. We must merely re-enable. */
2074                 if (vortex_debug > 2
2075                         || (tx_status != 0x88 && vortex_debug > 0)) {
2076                         printk(KERN_ERR "%s: Transmit error, Tx status register %2.2x.\n",
2077                                    dev->name, tx_status);
2078                         if (tx_status == 0x82) {
2079                                 printk(KERN_ERR "Probably a duplex mismatch.  See "
2080                                                 "Documentation/networking/vortex.txt\n");
2081                         }
2082                         dump_tx_ring(dev);
2083                 }
2084                 if (tx_status & 0x14)  vp->stats.tx_fifo_errors++;
2085                 if (tx_status & 0x38)  vp->stats.tx_aborted_errors++;
2086                 iowrite8(0, ioaddr + TxStatus);
2087                 if (tx_status & 0x30) {                 /* txJabber or txUnderrun */
2088                         do_tx_reset = 1;
2089                 } else if ((tx_status & 0x08) && (vp->drv_flags & MAX_COLLISION_RESET)) {       /* maxCollisions */
2090                         do_tx_reset = 1;
2091                         reset_mask = 0x0108;            /* Reset interface logic, but not download logic */
2092                 } else {                                                /* Merely re-enable the transmitter. */
2093                         iowrite16(TxEnable, ioaddr + EL3_CMD);
2094                 }
2095         }
2096
2097         if (status & RxEarly) {                         /* Rx early is unused. */
2098                 vortex_rx(dev);
2099                 iowrite16(AckIntr | RxEarly, ioaddr + EL3_CMD);
2100         }
2101         if (status & StatsFull) {                       /* Empty statistics. */
2102                 static int DoneDidThat;
2103                 if (vortex_debug > 4)
2104                         printk(KERN_DEBUG "%s: Updating stats.\n", dev->name);
2105                 update_stats(ioaddr, dev);
2106                 /* HACK: Disable statistics as an interrupt source. */
2107                 /* This occurs when we have the wrong media type! */
2108                 if (DoneDidThat == 0  &&
2109                         ioread16(ioaddr + EL3_STATUS) & StatsFull) {
2110                         printk(KERN_WARNING "%s: Updating statistics failed, disabling "
2111                                    "stats as an interrupt source.\n", dev->name);
2112                         EL3WINDOW(5);
2113                         iowrite16(SetIntrEnb | (ioread16(ioaddr + 10) & ~StatsFull), ioaddr + EL3_CMD);
2114                         vp->intr_enable &= ~StatsFull;
2115                         EL3WINDOW(7);
2116                         DoneDidThat++;
2117                 }
2118         }
2119         if (status & IntReq) {          /* Restore all interrupt sources.  */
2120                 iowrite16(vp->status_enable, ioaddr + EL3_CMD);
2121                 iowrite16(vp->intr_enable, ioaddr + EL3_CMD);
2122         }
2123         if (status & HostError) {
2124                 u16 fifo_diag;
2125                 EL3WINDOW(4);
2126                 fifo_diag = ioread16(ioaddr + Wn4_FIFODiag);
2127                 printk(KERN_ERR "%s: Host error, FIFO diagnostic register %4.4x.\n",
2128                            dev->name, fifo_diag);
2129                 /* Adapter failure requires Tx/Rx reset and reinit. */
2130                 if (vp->full_bus_master_tx) {
2131                         int bus_status = ioread32(ioaddr + PktStatus);
2132                         /* 0x80000000 PCI master abort. */
2133                         /* 0x40000000 PCI target abort. */
2134                         if (vortex_debug)
2135                                 printk(KERN_ERR "%s: PCI bus error, bus status %8.8x\n", dev->name, bus_status);
2136
2137                         /* In this case, blow the card away */
2138                         /* Must not enter D3 or we can't legally issue the reset! */
2139                         vortex_down(dev, 0);
2140                         issue_and_wait(dev, TotalReset | 0xff);
2141                         vortex_up(dev);         /* AKPM: bug.  vortex_up() assumes that the rx ring is full. It may not be. */
2142                 } else if (fifo_diag & 0x0400)
2143                         do_tx_reset = 1;
2144                 if (fifo_diag & 0x3000) {
2145                         /* Reset Rx fifo and upload logic */
2146                         issue_and_wait(dev, RxReset|0x07);
2147                         /* Set the Rx filter to the current state. */
2148                         set_rx_mode(dev);
2149                         /* enable 802.1q VLAN tagged frames */
2150                         set_8021q_mode(dev, 1);
2151                         iowrite16(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
2152                         iowrite16(AckIntr | HostError, ioaddr + EL3_CMD);
2153                 }
2154         }
2155
2156         if (do_tx_reset) {
2157                 issue_and_wait(dev, TxReset|reset_mask);
2158                 iowrite16(TxEnable, ioaddr + EL3_CMD);
2159                 if (!vp->full_bus_master_tx)
2160                         netif_wake_queue(dev);
2161         }
2162 }
2163
2164 static int
2165 vortex_start_xmit(struct sk_buff *skb, struct net_device *dev)
2166 {
2167         struct vortex_private *vp = netdev_priv(dev);
2168         void __iomem *ioaddr = vp->ioaddr;
2169
2170         /* Put out the doubleword header... */
2171         iowrite32(skb->len, ioaddr + TX_FIFO);
2172         if (vp->bus_master) {
2173                 /* Set the bus-master controller to transfer the packet. */
2174                 int len = (skb->len + 3) & ~3;
2175                 iowrite32(      vp->tx_skb_dma = pci_map_single(VORTEX_PCI(vp), skb->data, len, PCI_DMA_TODEVICE),
2176                                 ioaddr + Wn7_MasterAddr);
2177                 iowrite16(len, ioaddr + Wn7_MasterLen);
2178                 vp->tx_skb = skb;
2179                 iowrite16(StartDMADown, ioaddr + EL3_CMD);
2180                 /* netif_wake_queue() will be called at the DMADone interrupt. */
2181         } else {
2182                 /* ... and the packet rounded to a doubleword. */
2183                 iowrite32_rep(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
2184                 dev_kfree_skb (skb);
2185                 if (ioread16(ioaddr + TxFree) > 1536) {
2186                         netif_start_queue (dev);        /* AKPM: redundant? */
2187                 } else {
2188                         /* Interrupt us when the FIFO has room for max-sized packet. */
2189                         netif_stop_queue(dev);
2190                         iowrite16(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
2191                 }
2192         }
2193
2194         dev->trans_start = jiffies;
2195
2196         /* Clear the Tx status stack. */
2197         {
2198                 int tx_status;
2199                 int i = 32;
2200
2201                 while (--i > 0  &&      (tx_status = ioread8(ioaddr + TxStatus)) > 0) {
2202                         if (tx_status & 0x3C) {         /* A Tx-disabling error occurred.  */
2203                                 if (vortex_debug > 2)
2204                                   printk(KERN_DEBUG "%s: Tx error, status %2.2x.\n",
2205                                                  dev->name, tx_status);
2206                                 if (tx_status & 0x04) vp->stats.tx_fifo_errors++;
2207                                 if (tx_status & 0x38) vp->stats.tx_aborted_errors++;
2208                                 if (tx_status & 0x30) {
2209                                         issue_and_wait(dev, TxReset);
2210                                 }
2211                                 iowrite16(TxEnable, ioaddr + EL3_CMD);
2212                         }
2213                         iowrite8(0x00, ioaddr + TxStatus); /* Pop the status stack. */
2214                 }
2215         }
2216         return 0;
2217 }
2218
2219 static int
2220 boomerang_start_xmit(struct sk_buff *skb, struct net_device *dev)
2221 {
2222         struct vortex_private *vp = netdev_priv(dev);
2223         void __iomem *ioaddr = vp->ioaddr;
2224         /* Calculate the next Tx descriptor entry. */
2225         int entry = vp->cur_tx % TX_RING_SIZE;
2226         struct boom_tx_desc *prev_entry = &vp->tx_ring[(vp->cur_tx-1) % TX_RING_SIZE];
2227         unsigned long flags;
2228
2229         if (vortex_debug > 6) {
2230                 printk(KERN_DEBUG "boomerang_start_xmit()\n");
2231                 printk(KERN_DEBUG "%s: Trying to send a packet, Tx index %d.\n",
2232                            dev->name, vp->cur_tx);
2233         }
2234
2235         if (vp->cur_tx - vp->dirty_tx >= TX_RING_SIZE) {
2236                 if (vortex_debug > 0)
2237                         printk(KERN_WARNING "%s: BUG! Tx Ring full, refusing to send buffer.\n",
2238                                    dev->name);
2239                 netif_stop_queue(dev);
2240                 return 1;
2241         }
2242
2243         vp->tx_skbuff[entry] = skb;
2244
2245         vp->tx_ring[entry].next = 0;
2246 #if DO_ZEROCOPY
2247         if (skb->ip_summed != CHECKSUM_HW)
2248                         vp->tx_ring[entry].status = cpu_to_le32(skb->len | TxIntrUploaded);
2249         else
2250                         vp->tx_ring[entry].status = cpu_to_le32(skb->len | TxIntrUploaded | AddTCPChksum | AddUDPChksum);
2251
2252         if (!skb_shinfo(skb)->nr_frags) {
2253                 vp->tx_ring[entry].frag[0].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data,
2254                                                                                 skb->len, PCI_DMA_TODEVICE));
2255                 vp->tx_ring[entry].frag[0].length = cpu_to_le32(skb->len | LAST_FRAG);
2256         } else {
2257                 int i;
2258
2259                 vp->tx_ring[entry].frag[0].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data,
2260                                                                                 skb->len-skb->data_len, PCI_DMA_TODEVICE));
2261                 vp->tx_ring[entry].frag[0].length = cpu_to_le32(skb->len-skb->data_len);
2262
2263                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
2264                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
2265
2266                         vp->tx_ring[entry].frag[i+1].addr =
2267                                         cpu_to_le32(pci_map_single(VORTEX_PCI(vp),
2268                                                                                            (void*)page_address(frag->page) + frag->page_offset,
2269                                                                                            frag->size, PCI_DMA_TODEVICE));
2270
2271                         if (i == skb_shinfo(skb)->nr_frags-1)
2272                                         vp->tx_ring[entry].frag[i+1].length = cpu_to_le32(frag->size|LAST_FRAG);
2273                         else
2274                                         vp->tx_ring[entry].frag[i+1].length = cpu_to_le32(frag->size);
2275                 }
2276         }
2277 #else
2278         vp->tx_ring[entry].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data, skb->len, PCI_DMA_TODEVICE));
2279         vp->tx_ring[entry].length = cpu_to_le32(skb->len | LAST_FRAG);
2280         vp->tx_ring[entry].status = cpu_to_le32(skb->len | TxIntrUploaded);
2281 #endif
2282
2283         spin_lock_irqsave(&vp->lock, flags);
2284         /* Wait for the stall to complete. */
2285         issue_and_wait(dev, DownStall);
2286         prev_entry->next = cpu_to_le32(vp->tx_ring_dma + entry * sizeof(struct boom_tx_desc));
2287         if (ioread32(ioaddr + DownListPtr) == 0) {
2288                 iowrite32(vp->tx_ring_dma + entry * sizeof(struct boom_tx_desc), ioaddr + DownListPtr);
2289                 vp->queued_packet++;
2290         }
2291
2292         vp->cur_tx++;
2293         if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1) {
2294                 netif_stop_queue (dev);
2295         } else {                                        /* Clear previous interrupt enable. */
2296 #if defined(tx_interrupt_mitigation)
2297                 /* Dubious. If in boomeang_interrupt "faster" cyclone ifdef
2298                  * were selected, this would corrupt DN_COMPLETE. No?
2299                  */
2300                 prev_entry->status &= cpu_to_le32(~TxIntrUploaded);
2301 #endif
2302         }
2303         iowrite16(DownUnstall, ioaddr + EL3_CMD);
2304         spin_unlock_irqrestore(&vp->lock, flags);
2305         dev->trans_start = jiffies;
2306         return 0;
2307 }
2308
2309 /* The interrupt handler does all of the Rx thread work and cleans up
2310    after the Tx thread. */
2311
2312 /*
2313  * This is the ISR for the vortex series chips.
2314  * full_bus_master_tx == 0 && full_bus_master_rx == 0
2315  */
2316
2317 static irqreturn_t
2318 vortex_interrupt(int irq, void *dev_id, struct pt_regs *regs)
2319 {
2320         struct net_device *dev = dev_id;
2321         struct vortex_private *vp = netdev_priv(dev);
2322         void __iomem *ioaddr;
2323         int status;
2324         int work_done = max_interrupt_work;
2325         int handled = 0;
2326
2327         ioaddr = vp->ioaddr;
2328         spin_lock(&vp->lock);
2329
2330         status = ioread16(ioaddr + EL3_STATUS);
2331
2332         if (vortex_debug > 6)
2333                 printk("vortex_interrupt(). status=0x%4x\n", status);
2334
2335         if ((status & IntLatch) == 0)
2336                 goto handler_exit;              /* No interrupt: shared IRQs cause this */
2337         handled = 1;
2338
2339         if (status & IntReq) {
2340                 status |= vp->deferred;
2341                 vp->deferred = 0;
2342         }
2343
2344         if (status == 0xffff)           /* h/w no longer present (hotplug)? */
2345                 goto handler_exit;
2346
2347         if (vortex_debug > 4)
2348                 printk(KERN_DEBUG "%s: interrupt, status %4.4x, latency %d ticks.\n",
2349                            dev->name, status, ioread8(ioaddr + Timer));
2350
2351         do {
2352                 if (vortex_debug > 5)
2353                                 printk(KERN_DEBUG "%s: In interrupt loop, status %4.4x.\n",
2354                                            dev->name, status);
2355                 if (status & RxComplete)
2356                         vortex_rx(dev);
2357
2358                 if (status & TxAvailable) {
2359                         if (vortex_debug > 5)
2360                                 printk(KERN_DEBUG "     TX room bit was handled.\n");
2361                         /* There's room in the FIFO for a full-sized packet. */
2362                         iowrite16(AckIntr | TxAvailable, ioaddr + EL3_CMD);
2363                         netif_wake_queue (dev);
2364                 }
2365
2366                 if (status & DMADone) {
2367                         if (ioread16(ioaddr + Wn7_MasterStatus) & 0x1000) {
2368                                 iowrite16(0x1000, ioaddr + Wn7_MasterStatus); /* Ack the event. */
2369                                 pci_unmap_single(VORTEX_PCI(vp), vp->tx_skb_dma, (vp->tx_skb->len + 3) & ~3, PCI_DMA_TODEVICE);
2370                                 dev_kfree_skb_irq(vp->tx_skb); /* Release the transferred buffer */
2371                                 if (ioread16(ioaddr + TxFree) > 1536) {
2372                                         /*
2373                                          * AKPM: FIXME: I don't think we need this.  If the queue was stopped due to
2374                                          * insufficient FIFO room, the TxAvailable test will succeed and call
2375                                          * netif_wake_queue()
2376                                          */
2377                                         netif_wake_queue(dev);
2378                                 } else { /* Interrupt when FIFO has room for max-sized packet. */
2379                                         iowrite16(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
2380                                         netif_stop_queue(dev);
2381                                 }
2382                         }
2383                 }
2384                 /* Check for all uncommon interrupts at once. */
2385                 if (status & (HostError | RxEarly | StatsFull | TxComplete | IntReq)) {
2386                         if (status == 0xffff)
2387                                 break;
2388                         vortex_error(dev, status);
2389                 }
2390
2391                 if (--work_done < 0) {
2392                         printk(KERN_WARNING "%s: Too much work in interrupt, status "
2393                                    "%4.4x.\n", dev->name, status);
2394                         /* Disable all pending interrupts. */
2395                         do {
2396                                 vp->deferred |= status;
2397                                 iowrite16(SetStatusEnb | (~vp->deferred & vp->status_enable),
2398                                          ioaddr + EL3_CMD);
2399                                 iowrite16(AckIntr | (vp->deferred & 0x7ff), ioaddr + EL3_CMD);
2400                         } while ((status = ioread16(ioaddr + EL3_CMD)) & IntLatch);
2401                         /* The timer will reenable interrupts. */
2402                         mod_timer(&vp->timer, jiffies + 1*HZ);
2403                         break;
2404                 }
2405                 /* Acknowledge the IRQ. */
2406                 iowrite16(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
2407         } while ((status = ioread16(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
2408
2409         if (vortex_debug > 4)
2410                 printk(KERN_DEBUG "%s: exiting interrupt, status %4.4x.\n",
2411                            dev->name, status);
2412 handler_exit:
2413         spin_unlock(&vp->lock);
2414         return IRQ_RETVAL(handled);
2415 }
2416
2417 /*
2418  * This is the ISR for the boomerang series chips.
2419  * full_bus_master_tx == 1 && full_bus_master_rx == 1
2420  */
2421
2422 static irqreturn_t
2423 boomerang_interrupt(int irq, void *dev_id, struct pt_regs *regs)
2424 {
2425         struct net_device *dev = dev_id;
2426         struct vortex_private *vp = netdev_priv(dev);
2427         void __iomem *ioaddr;
2428         int status;
2429         int work_done = max_interrupt_work;
2430
2431         ioaddr = vp->ioaddr;
2432
2433         /*
2434          * It seems dopey to put the spinlock this early, but we could race against vortex_tx_timeout
2435          * and boomerang_start_xmit
2436          */
2437         spin_lock(&vp->lock);
2438
2439         status = ioread16(ioaddr + EL3_STATUS);
2440
2441         if (vortex_debug > 6)
2442                 printk(KERN_DEBUG "boomerang_interrupt. status=0x%4x\n", status);
2443
2444         if ((status & IntLatch) == 0)
2445                 goto handler_exit;              /* No interrupt: shared IRQs can cause this */
2446
2447         if (status == 0xffff) {         /* h/w no longer present (hotplug)? */
2448                 if (vortex_debug > 1)
2449                         printk(KERN_DEBUG "boomerang_interrupt(1): status = 0xffff\n");
2450                 goto handler_exit;
2451         }
2452
2453         if (status & IntReq) {
2454                 status |= vp->deferred;
2455                 vp->deferred = 0;
2456         }
2457
2458         if (vortex_debug > 4)
2459                 printk(KERN_DEBUG "%s: interrupt, status %4.4x, latency %d ticks.\n",
2460                            dev->name, status, ioread8(ioaddr + Timer));
2461         do {
2462                 if (vortex_debug > 5)
2463                                 printk(KERN_DEBUG "%s: In interrupt loop, status %4.4x.\n",
2464                                            dev->name, status);
2465                 if (status & UpComplete) {
2466                         iowrite16(AckIntr | UpComplete, ioaddr + EL3_CMD);
2467                         if (vortex_debug > 5)
2468                                 printk(KERN_DEBUG "boomerang_interrupt->boomerang_rx\n");
2469                         boomerang_rx(dev);
2470                 }
2471
2472                 if (status & DownComplete) {
2473                         unsigned int dirty_tx = vp->dirty_tx;
2474
2475                         iowrite16(AckIntr | DownComplete, ioaddr + EL3_CMD);
2476                         while (vp->cur_tx - dirty_tx > 0) {
2477                                 int entry = dirty_tx % TX_RING_SIZE;
2478 #if 1   /* AKPM: the latter is faster, but cyclone-only */
2479                                 if (ioread32(ioaddr + DownListPtr) ==
2480                                         vp->tx_ring_dma + entry * sizeof(struct boom_tx_desc))
2481                                         break;                  /* It still hasn't been processed. */
2482 #else
2483                                 if ((vp->tx_ring[entry].status & DN_COMPLETE) == 0)
2484                                         break;                  /* It still hasn't been processed. */
2485 #endif
2486                                         
2487                                 if (vp->tx_skbuff[entry]) {
2488                                         struct sk_buff *skb = vp->tx_skbuff[entry];
2489 #if DO_ZEROCOPY                                 
2490                                         int i;
2491                                         for (i=0; i<=skb_shinfo(skb)->nr_frags; i++)
2492                                                         pci_unmap_single(VORTEX_PCI(vp),
2493                                                                                          le32_to_cpu(vp->tx_ring[entry].frag[i].addr),
2494                                                                                          le32_to_cpu(vp->tx_ring[entry].frag[i].length)&0xFFF,
2495                                                                                          PCI_DMA_TODEVICE);
2496 #else
2497                                         pci_unmap_single(VORTEX_PCI(vp),
2498                                                 le32_to_cpu(vp->tx_ring[entry].addr), skb->len, PCI_DMA_TODEVICE);
2499 #endif
2500                                         dev_kfree_skb_irq(skb);
2501                                         vp->tx_skbuff[entry] = NULL;
2502                                 } else {
2503                                         printk(KERN_DEBUG "boomerang_interrupt: no skb!\n");
2504                                 }
2505                                 /* vp->stats.tx_packets++;  Counted below. */
2506                                 dirty_tx++;
2507                         }
2508                         vp->dirty_tx = dirty_tx;
2509                         if (vp->cur_tx - dirty_tx <= TX_RING_SIZE - 1) {
2510                                 if (vortex_debug > 6)
2511                                         printk(KERN_DEBUG "boomerang_interrupt: wake queue\n");
2512                                 netif_wake_queue (dev);
2513                         }
2514                 }
2515
2516                 /* Check for all uncommon interrupts at once. */
2517                 if (status & (HostError | RxEarly | StatsFull | TxComplete | IntReq))
2518                         vortex_error(dev, status);
2519
2520                 if (--work_done < 0) {
2521                         printk(KERN_WARNING "%s: Too much work in interrupt, status "
2522                                    "%4.4x.\n", dev->name, status);
2523                         /* Disable all pending interrupts. */
2524                         do {
2525                                 vp->deferred |= status;
2526                                 iowrite16(SetStatusEnb | (~vp->deferred & vp->status_enable),
2527                                          ioaddr + EL3_CMD);
2528                                 iowrite16(AckIntr | (vp->deferred & 0x7ff), ioaddr + EL3_CMD);
2529                         } while ((status = ioread16(ioaddr + EL3_CMD)) & IntLatch);
2530                         /* The timer will reenable interrupts. */
2531                         mod_timer(&vp->timer, jiffies + 1*HZ);
2532                         break;
2533                 }
2534                 /* Acknowledge the IRQ. */
2535                 iowrite16(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
2536                 if (vp->cb_fn_base)                     /* The PCMCIA people are idiots.  */
2537                         iowrite32(0x8000, vp->cb_fn_base + 4);
2538
2539         } while ((status = ioread16(ioaddr + EL3_STATUS)) & IntLatch);
2540
2541         if (vortex_debug > 4)
2542                 printk(KERN_DEBUG "%s: exiting interrupt, status %4.4x.\n",
2543                            dev->name, status);
2544 handler_exit:
2545         spin_unlock(&vp->lock);
2546         return IRQ_HANDLED;
2547 }
2548
2549 static int vortex_rx(struct net_device *dev)
2550 {
2551         struct vortex_private *vp = netdev_priv(dev);
2552         void __iomem *ioaddr = vp->ioaddr;
2553         int i;
2554         short rx_status;
2555
2556         if (vortex_debug > 5)
2557                 printk(KERN_DEBUG "vortex_rx(): status %4.4x, rx_status %4.4x.\n",
2558                            ioread16(ioaddr+EL3_STATUS), ioread16(ioaddr+RxStatus));
2559         while ((rx_status = ioread16(ioaddr + RxStatus)) > 0) {
2560                 if (rx_status & 0x4000) { /* Error, update stats. */
2561                         unsigned char rx_error = ioread8(ioaddr + RxErrors);
2562                         if (vortex_debug > 2)
2563                                 printk(KERN_DEBUG " Rx error: status %2.2x.\n", rx_error);
2564                         vp->stats.rx_errors++;
2565                         if (rx_error & 0x01)  vp->stats.rx_over_errors++;
2566                         if (rx_error & 0x02)  vp->stats.rx_length_errors++;
2567                         if (rx_error & 0x04)  vp->stats.rx_frame_errors++;
2568                         if (rx_error & 0x08)  vp->stats.rx_crc_errors++;
2569                         if (rx_error & 0x10)  vp->stats.rx_length_errors++;
2570                 } else {
2571                         /* The packet length: up to 4.5K!. */
2572                         int pkt_len = rx_status & 0x1fff;
2573                         struct sk_buff *skb;
2574
2575                         skb = dev_alloc_skb(pkt_len + 5);
2576                         if (vortex_debug > 4)
2577                                 printk(KERN_DEBUG "Receiving packet size %d status %4.4x.\n",
2578                                            pkt_len, rx_status);
2579                         if (skb != NULL) {
2580                                 skb->dev = dev;
2581                                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
2582                                 /* 'skb_put()' points to the start of sk_buff data area. */
2583                                 if (vp->bus_master &&
2584                                         ! (ioread16(ioaddr + Wn7_MasterStatus) & 0x8000)) {
2585                                         dma_addr_t dma = pci_map_single(VORTEX_PCI(vp), skb_put(skb, pkt_len),
2586                                                                            pkt_len, PCI_DMA_FROMDEVICE);
2587                                         iowrite32(dma, ioaddr + Wn7_MasterAddr);
2588                                         iowrite16((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
2589                                         iowrite16(StartDMAUp, ioaddr + EL3_CMD);
2590                                         while (ioread16(ioaddr + Wn7_MasterStatus) & 0x8000)
2591                                                 ;
2592                                         pci_unmap_single(VORTEX_PCI(vp), dma, pkt_len, PCI_DMA_FROMDEVICE);
2593                                 } else {
2594                                         ioread32_rep(ioaddr + RX_FIFO,
2595                                                      skb_put(skb, pkt_len),
2596                                                      (pkt_len + 3) >> 2);
2597                                 }
2598                                 iowrite16(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
2599                                 skb->protocol = eth_type_trans(skb, dev);
2600                                 netif_rx(skb);
2601                                 dev->last_rx = jiffies;
2602                                 vp->stats.rx_packets++;
2603                                 /* Wait a limited time to go to next packet. */
2604                                 for (i = 200; i >= 0; i--)
2605                                         if ( ! (ioread16(ioaddr + EL3_STATUS) & CmdInProgress))
2606                                                 break;
2607                                 continue;
2608                         } else if (vortex_debug > 0)
2609                                 printk(KERN_NOTICE "%s: No memory to allocate a sk_buff of "
2610                                            "size %d.\n", dev->name, pkt_len);
2611                         vp->stats.rx_dropped++;
2612                 }
2613                 issue_and_wait(dev, RxDiscard);
2614         }
2615
2616         return 0;
2617 }
2618
2619 static int
2620 boomerang_rx(struct net_device *dev)
2621 {
2622         struct vortex_private *vp = netdev_priv(dev);
2623         int entry = vp->cur_rx % RX_RING_SIZE;
2624         void __iomem *ioaddr = vp->ioaddr;
2625         int rx_status;
2626         int rx_work_limit = vp->dirty_rx + RX_RING_SIZE - vp->cur_rx;
2627
2628         if (vortex_debug > 5)
2629                 printk(KERN_DEBUG "boomerang_rx(): status %4.4x\n", ioread16(ioaddr+EL3_STATUS));
2630
2631         while ((rx_status = le32_to_cpu(vp->rx_ring[entry].status)) & RxDComplete){
2632                 if (--rx_work_limit < 0)
2633                         break;
2634                 if (rx_status & RxDError) { /* Error, update stats. */
2635                         unsigned char rx_error = rx_status >> 16;
2636                         if (vortex_debug > 2)
2637                                 printk(KERN_DEBUG " Rx error: status %2.2x.\n", rx_error);
2638                         vp->stats.rx_errors++;
2639                         if (rx_error & 0x01)  vp->stats.rx_over_errors++;
2640                         if (rx_error & 0x02)  vp->stats.rx_length_errors++;
2641                         if (rx_error & 0x04)  vp->stats.rx_frame_errors++;
2642                         if (rx_error & 0x08)  vp->stats.rx_crc_errors++;
2643                         if (rx_error & 0x10)  vp->stats.rx_length_errors++;
2644                 } else {
2645                         /* The packet length: up to 4.5K!. */
2646                         int pkt_len = rx_status & 0x1fff;
2647                         struct sk_buff *skb;
2648                         dma_addr_t dma = le32_to_cpu(vp->rx_ring[entry].addr);
2649
2650                         if (vortex_debug > 4)
2651                                 printk(KERN_DEBUG "Receiving packet size %d status %4.4x.\n",
2652                                            pkt_len, rx_status);
2653
2654                         /* Check if the packet is long enough to just accept without
2655                            copying to a properly sized skbuff. */
2656                         if (pkt_len < rx_copybreak && (skb = dev_alloc_skb(pkt_len + 2)) != 0) {
2657                                 skb->dev = dev;
2658                                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
2659                                 pci_dma_sync_single_for_cpu(VORTEX_PCI(vp), dma, PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
2660                                 /* 'skb_put()' points to the start of sk_buff data area. */
2661                                 memcpy(skb_put(skb, pkt_len),
2662                                            vp->rx_skbuff[entry]->data,
2663                                            pkt_len);
2664                                 pci_dma_sync_single_for_device(VORTEX_PCI(vp), dma, PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
2665                                 vp->rx_copy++;
2666                         } else {
2667                                 /* Pass up the skbuff already on the Rx ring. */
2668                                 skb = vp->rx_skbuff[entry];
2669                                 vp->rx_skbuff[entry] = NULL;
2670                                 skb_put(skb, pkt_len);
2671                                 pci_unmap_single(VORTEX_PCI(vp), dma, PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
2672                                 vp->rx_nocopy++;
2673                         }
2674                         skb->protocol = eth_type_trans(skb, dev);
2675                         {                                       /* Use hardware checksum info. */
2676                                 int csum_bits = rx_status & 0xee000000;
2677                                 if (csum_bits &&
2678                                         (csum_bits == (IPChksumValid | TCPChksumValid) ||
2679                                          csum_bits == (IPChksumValid | UDPChksumValid))) {
2680                                         skb->ip_summed = CHECKSUM_UNNECESSARY;
2681                                         vp->rx_csumhits++;
2682                                 }
2683                         }
2684                         netif_rx(skb);
2685                         dev->last_rx = jiffies;
2686                         vp->stats.rx_packets++;
2687                 }
2688                 entry = (++vp->cur_rx) % RX_RING_SIZE;
2689         }
2690         /* Refill the Rx ring buffers. */
2691         for (; vp->cur_rx - vp->dirty_rx > 0; vp->dirty_rx++) {
2692                 struct sk_buff *skb;
2693                 entry = vp->dirty_rx % RX_RING_SIZE;
2694                 if (vp->rx_skbuff[entry] == NULL) {
2695                         skb = dev_alloc_skb(PKT_BUF_SZ);
2696                         if (skb == NULL) {
2697                                 static unsigned long last_jif;
2698                                 if ((jiffies - last_jif) > 10 * HZ) {
2699                                         printk(KERN_WARNING "%s: memory shortage\n", dev->name);
2700                                         last_jif = jiffies;
2701                                 }
2702                                 if ((vp->cur_rx - vp->dirty_rx) == RX_RING_SIZE)
2703                                         mod_timer(&vp->rx_oom_timer, RUN_AT(HZ * 1));
2704                                 break;                  /* Bad news!  */
2705                         }
2706                         skb->dev = dev;                 /* Mark as being used by this device. */
2707                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
2708                         vp->rx_ring[entry].addr = cpu_to_le32(pci_map_single(VORTEX_PCI(vp), skb->data, PKT_BUF_SZ, PCI_DMA_FROMDEVICE));
2709                         vp->rx_skbuff[entry] = skb;
2710                 }
2711                 vp->rx_ring[entry].status = 0;  /* Clear complete bit. */
2712                 iowrite16(UpUnstall, ioaddr + EL3_CMD);
2713         }
2714         return 0;
2715 }
2716
2717 /*
2718  * If we've hit a total OOM refilling the Rx ring we poll once a second
2719  * for some memory.  Otherwise there is no way to restart the rx process.
2720  */
2721 static void
2722 rx_oom_timer(unsigned long arg)
2723 {
2724         struct net_device *dev = (struct net_device *)arg;
2725         struct vortex_private *vp = netdev_priv(dev);
2726
2727         spin_lock_irq(&vp->lock);
2728         if ((vp->cur_rx - vp->dirty_rx) == RX_RING_SIZE)        /* This test is redundant, but makes me feel good */
2729                 boomerang_rx(dev);
2730         if (vortex_debug > 1) {
2731                 printk(KERN_DEBUG "%s: rx_oom_timer %s\n", dev->name,
2732                         ((vp->cur_rx - vp->dirty_rx) != RX_RING_SIZE) ? "succeeded" : "retrying");
2733         }
2734         spin_unlock_irq(&vp->lock);
2735 }
2736
2737 static void
2738 vortex_down(struct net_device *dev, int final_down)
2739 {
2740         struct vortex_private *vp = netdev_priv(dev);
2741         void __iomem *ioaddr = vp->ioaddr;
2742
2743         netif_stop_queue (dev);
2744
2745         del_timer_sync(&vp->rx_oom_timer);
2746         del_timer_sync(&vp->timer);
2747
2748         /* Turn off statistics ASAP.  We update vp->stats below. */
2749         iowrite16(StatsDisable, ioaddr + EL3_CMD);
2750
2751         /* Disable the receiver and transmitter. */
2752         iowrite16(RxDisable, ioaddr + EL3_CMD);
2753         iowrite16(TxDisable, ioaddr + EL3_CMD);
2754
2755         /* Disable receiving 802.1q tagged frames */
2756         set_8021q_mode(dev, 0);
2757
2758         if (dev->if_port == XCVR_10base2)
2759                 /* Turn off thinnet power.  Green! */
2760                 iowrite16(StopCoax, ioaddr + EL3_CMD);
2761
2762         iowrite16(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
2763
2764         update_stats(ioaddr, dev);
2765         if (vp->full_bus_master_rx)
2766                 iowrite32(0, ioaddr + UpListPtr);
2767         if (vp->full_bus_master_tx)
2768                 iowrite32(0, ioaddr + DownListPtr);
2769
2770         if (final_down && VORTEX_PCI(vp)) {
2771                 vp->pm_state_valid = 1;
2772                 pci_save_state(VORTEX_PCI(vp));
2773                 acpi_set_WOL(dev);
2774         }
2775 }
2776
2777 static int
2778 vortex_close(struct net_device *dev)
2779 {
2780         struct vortex_private *vp = netdev_priv(dev);
2781         void __iomem *ioaddr = vp->ioaddr;
2782         int i;
2783
2784         if (netif_device_present(dev))
2785                 vortex_down(dev, 1);
2786
2787         if (vortex_debug > 1) {
2788                 printk(KERN_DEBUG"%s: vortex_close() status %4.4x, Tx status %2.2x.\n",
2789                            dev->name, ioread16(ioaddr + EL3_STATUS), ioread8(ioaddr + TxStatus));
2790                 printk(KERN_DEBUG "%s: vortex close stats: rx_nocopy %d rx_copy %d"
2791                            " tx_queued %d Rx pre-checksummed %d.\n",
2792                            dev->name, vp->rx_nocopy, vp->rx_copy, vp->queued_packet, vp->rx_csumhits);
2793         }
2794
2795 #if DO_ZEROCOPY
2796         if (vp->rx_csumhits &&
2797             (vp->drv_flags & HAS_HWCKSM) == 0 &&
2798             (vp->card_idx >= MAX_UNITS || hw_checksums[vp->card_idx] == -1)) {
2799                         printk(KERN_WARNING "%s supports hardware checksums, and we're "
2800                                                 "not using them!\n", dev->name);
2801         }
2802 #endif
2803                 
2804         free_irq(dev->irq, dev);
2805
2806         if (vp->full_bus_master_rx) { /* Free Boomerang bus master Rx buffers. */
2807                 for (i = 0; i < RX_RING_SIZE; i++)
2808                         if (vp->rx_skbuff[i]) {
2809                                 pci_unmap_single(       VORTEX_PCI(vp), le32_to_cpu(vp->rx_ring[i].addr),
2810                                                                         PKT_BUF_SZ, PCI_DMA_FROMDEVICE);
2811                                 dev_kfree_skb(vp->rx_skbuff[i]);
2812                                 vp->rx_skbuff[i] = NULL;
2813                         }
2814         }
2815         if (vp->full_bus_master_tx) { /* Free Boomerang bus master Tx buffers. */
2816                 for (i = 0; i < TX_RING_SIZE; i++) {
2817                         if (vp->tx_skbuff[i]) {
2818                                 struct sk_buff *skb = vp->tx_skbuff[i];
2819 #if DO_ZEROCOPY
2820                                 int k;
2821
2822                                 for (k=0; k<=skb_shinfo(skb)->nr_frags; k++)
2823                                                 pci_unmap_single(VORTEX_PCI(vp),
2824                                                                                  le32_to_cpu(vp->tx_ring[i].frag[k].addr),
2825                                                                                  le32_to_cpu(vp->tx_ring[i].frag[k].length)&0xFFF,
2826                                                                                  PCI_DMA_TODEVICE);
2827 #else
2828                                 pci_unmap_single(VORTEX_PCI(vp), le32_to_cpu(vp->tx_ring[i].addr), skb->len, PCI_DMA_TODEVICE);
2829 #endif
2830                                 dev_kfree_skb(skb);
2831                                 vp->tx_skbuff[i] = NULL;
2832                         }
2833                 }
2834         }
2835
2836         return 0;
2837 }
2838
2839 static void
2840 dump_tx_ring(struct net_device *dev)
2841 {
2842         if (vortex_debug > 0) {
2843         struct vortex_private *vp = netdev_priv(dev);
2844                 void __iomem *ioaddr = vp->ioaddr;
2845                 
2846                 if (vp->full_bus_master_tx) {
2847                         int i;
2848                         int stalled = ioread32(ioaddr + PktStatus) & 0x04;      /* Possible racy. But it's only debug stuff */
2849
2850                         printk(KERN_ERR "  Flags; bus-master %d, dirty %d(%d) current %d(%d)\n",
2851                                         vp->full_bus_master_tx,
2852                                         vp->dirty_tx, vp->dirty_tx % TX_RING_SIZE,
2853                                         vp->cur_tx, vp->cur_tx % TX_RING_SIZE);
2854                         printk(KERN_ERR "  Transmit list %8.8x vs. %p.\n",
2855                                    ioread32(ioaddr + DownListPtr),
2856                                    &vp->tx_ring[vp->dirty_tx % TX_RING_SIZE]);
2857                         issue_and_wait(dev, DownStall);
2858                         for (i = 0; i < TX_RING_SIZE; i++) {
2859                                 printk(KERN_ERR "  %d: @%p  length %8.8x status %8.8x\n", i,
2860                                            &vp->tx_ring[i],
2861 #if DO_ZEROCOPY
2862                                            le32_to_cpu(vp->tx_ring[i].frag[0].length),
2863 #else
2864                                            le32_to_cpu(vp->tx_ring[i].length),
2865 #endif
2866                                            le32_to_cpu(vp->tx_ring[i].status));
2867                         }
2868                         if (!stalled)
2869                                 iowrite16(DownUnstall, ioaddr + EL3_CMD);
2870                 }
2871         }
2872 }
2873
2874 static struct net_device_stats *vortex_get_stats(struct net_device *dev)
2875 {
2876         struct vortex_private *vp = netdev_priv(dev);
2877         void __iomem *ioaddr = vp->ioaddr;
2878         unsigned long flags;
2879
2880         if (netif_device_present(dev)) {        /* AKPM: Used to be netif_running */
2881                 spin_lock_irqsave (&vp->lock, flags);
2882                 update_stats(ioaddr, dev);
2883                 spin_unlock_irqrestore (&vp->lock, flags);
2884         }
2885         return &vp->stats;
2886 }
2887
2888 /*  Update statistics.
2889         Unlike with the EL3 we need not worry about interrupts changing
2890         the window setting from underneath us, but we must still guard
2891         against a race condition with a StatsUpdate interrupt updating the
2892         table.  This is done by checking that the ASM (!) code generated uses
2893         atomic updates with '+='.
2894         */
2895 static void update_stats(void __iomem *ioaddr, struct net_device *dev)
2896 {
2897         struct vortex_private *vp = netdev_priv(dev);
2898         int old_window = ioread16(ioaddr + EL3_CMD);
2899
2900         if (old_window == 0xffff)       /* Chip suspended or ejected. */
2901                 return;
2902         /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
2903         /* Switch to the stats window, and read everything. */
2904         EL3WINDOW(6);
2905         vp->stats.tx_carrier_errors             += ioread8(ioaddr + 0);
2906         vp->stats.tx_heartbeat_errors           += ioread8(ioaddr + 1);
2907         vp->stats.collisions                    += ioread8(ioaddr + 3);
2908         vp->stats.tx_window_errors              += ioread8(ioaddr + 4);
2909         vp->stats.rx_fifo_errors                += ioread8(ioaddr + 5);
2910         vp->stats.tx_packets                    += ioread8(ioaddr + 6);
2911         vp->stats.tx_packets                    += (ioread8(ioaddr + 9)&0x30) << 4;
2912         /* Rx packets   */                      ioread8(ioaddr + 7);   /* Must read to clear */
2913         /* Don't bother with register 9, an extension of registers 6&7.
2914            If we do use the 6&7 values the atomic update assumption above
2915            is invalid. */
2916         vp->stats.rx_bytes                      += ioread16(ioaddr + 10);
2917         vp->stats.tx_bytes                      += ioread16(ioaddr + 12);
2918         /* Extra stats for get_ethtool_stats() */
2919         vp->xstats.tx_multiple_collisions       += ioread8(ioaddr + 2);
2920         vp->xstats.tx_deferred                  += ioread8(ioaddr + 8);
2921         EL3WINDOW(4);
2922         vp->xstats.rx_bad_ssd                   += ioread8(ioaddr + 12);
2923
2924         {
2925                 u8 up = ioread8(ioaddr + 13);
2926                 vp->stats.rx_bytes += (up & 0x0f) << 16;
2927                 vp->stats.tx_bytes += (up & 0xf0) << 12;
2928         }
2929
2930         EL3WINDOW(old_window >> 13);
2931         return;
2932 }
2933
2934 static int vortex_nway_reset(struct net_device *dev)
2935 {
2936         struct vortex_private *vp = netdev_priv(dev);
2937         void __iomem *ioaddr = vp->ioaddr;
2938         unsigned long flags;
2939         int rc;
2940
2941         spin_lock_irqsave(&vp->lock, flags);
2942         EL3WINDOW(4);
2943         rc = mii_nway_restart(&vp->mii);
2944         spin_unlock_irqrestore(&vp->lock, flags);
2945         return rc;
2946 }
2947
2948 static u32 vortex_get_link(struct net_device *dev)
2949 {
2950         struct vortex_private *vp = netdev_priv(dev);
2951         void __iomem *ioaddr = vp->ioaddr;
2952         unsigned long flags;
2953         int rc;
2954
2955         spin_lock_irqsave(&vp->lock, flags);
2956         EL3WINDOW(4);
2957         rc = mii_link_ok(&vp->mii);
2958         spin_unlock_irqrestore(&vp->lock, flags);
2959         return rc;
2960 }
2961
2962 static int vortex_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2963 {
2964         struct vortex_private *vp = netdev_priv(dev);
2965         void __iomem *ioaddr = vp->ioaddr;
2966         unsigned long flags;
2967         int rc;
2968
2969         spin_lock_irqsave(&vp->lock, flags);
2970         EL3WINDOW(4);
2971         rc = mii_ethtool_gset(&vp->mii, cmd);
2972         spin_unlock_irqrestore(&vp->lock, flags);
2973         return rc;
2974 }
2975
2976 static int vortex_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
2977 {
2978         struct vortex_private *vp = netdev_priv(dev);
2979         void __iomem *ioaddr = vp->ioaddr;
2980         unsigned long flags;
2981         int rc;
2982
2983         spin_lock_irqsave(&vp->lock, flags);
2984         EL3WINDOW(4);
2985         rc = mii_ethtool_sset(&vp->mii, cmd);
2986         spin_unlock_irqrestore(&vp->lock, flags);
2987         return rc;
2988 }
2989
2990 static u32 vortex_get_msglevel(struct net_device *dev)
2991 {
2992         return vortex_debug;
2993 }
2994
2995 static void vortex_set_msglevel(struct net_device *dev, u32 dbg)
2996 {
2997         vortex_debug = dbg;
2998 }
2999
3000 static int vortex_get_stats_count(struct net_device *dev)
3001 {
3002         return VORTEX_NUM_STATS;
3003 }
3004
3005 static void vortex_get_ethtool_stats(struct net_device *dev,
3006         struct ethtool_stats *stats, u64 *data)
3007 {
3008         struct vortex_private *vp = netdev_priv(dev);
3009         void __iomem *ioaddr = vp->ioaddr;
3010         unsigned long flags;
3011
3012         spin_lock_irqsave(&vp->lock, flags);
3013         update_stats(ioaddr, dev);
3014         spin_unlock_irqrestore(&vp->lock, flags);
3015
3016         data[0] = vp->xstats.tx_deferred;
3017         data[1] = vp->xstats.tx_multiple_collisions;
3018         data[2] = vp->xstats.rx_bad_ssd;
3019 }
3020
3021
3022 static void vortex_get_strings(struct net_device *dev, u32 stringset, u8 *data)
3023 {
3024         switch (stringset) {
3025         case ETH_SS_STATS:
3026                 memcpy(data, &ethtool_stats_keys, sizeof(ethtool_stats_keys));
3027                 break;
3028         default:
3029                 WARN_ON(1);
3030                 break;
3031         }
3032 }
3033
3034 static void vortex_get_drvinfo(struct net_device *dev,
3035                                         struct ethtool_drvinfo *info)
3036 {
3037         struct vortex_private *vp = netdev_priv(dev);
3038
3039         strcpy(info->driver, DRV_NAME);
3040         strcpy(info->version, DRV_VERSION);
3041         if (VORTEX_PCI(vp)) {
3042                 strcpy(info->bus_info, pci_name(VORTEX_PCI(vp)));
3043         } else {
3044                 if (VORTEX_EISA(vp))
3045                         sprintf(info->bus_info, vp->gendev->bus_id);
3046                 else
3047                         sprintf(info->bus_info, "EISA 0x%lx %d",
3048                                         dev->base_addr, dev->irq);
3049         }
3050 }
3051
3052 static struct ethtool_ops vortex_ethtool_ops = {
3053         .get_drvinfo            = vortex_get_drvinfo,
3054         .get_strings            = vortex_get_strings,
3055         .get_msglevel           = vortex_get_msglevel,
3056         .set_msglevel           = vortex_set_msglevel,
3057         .get_ethtool_stats      = vortex_get_ethtool_stats,
3058         .get_stats_count        = vortex_get_stats_count,
3059         .get_settings           = vortex_get_settings,
3060         .set_settings           = vortex_set_settings,
3061         .get_link               = vortex_get_link,
3062         .nway_reset             = vortex_nway_reset,
3063         .get_perm_addr                  = ethtool_op_get_perm_addr,
3064 };
3065
3066 #ifdef CONFIG_PCI
3067 /*
3068  *      Must power the device up to do MDIO operations
3069  */
3070 static int vortex_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
3071 {
3072         int err;
3073         struct vortex_private *vp = netdev_priv(dev);
3074         void __iomem *ioaddr = vp->ioaddr;
3075         unsigned long flags;
3076         int state = 0;
3077
3078         if(VORTEX_PCI(vp))
3079                 state = VORTEX_PCI(vp)->current_state;
3080
3081         /* The kernel core really should have pci_get_power_state() */
3082
3083         if(state != 0)
3084                 pci_set_power_state(VORTEX_PCI(vp), PCI_D0);
3085         spin_lock_irqsave(&vp->lock, flags);
3086         EL3WINDOW(4);
3087         err = generic_mii_ioctl(&vp->mii, if_mii(rq), cmd, NULL);
3088         spin_unlock_irqrestore(&vp->lock, flags);
3089         if(state != 0)
3090                 pci_set_power_state(VORTEX_PCI(vp), state);
3091
3092         return err;
3093 }
3094 #endif
3095
3096
3097 /* Pre-Cyclone chips have no documented multicast filter, so the only
3098    multicast setting is to receive all multicast frames.  At least
3099    the chip has a very clean way to set the mode, unlike many others. */
3100 static void set_rx_mode(struct net_device *dev)
3101 {
3102         struct vortex_private *vp = netdev_priv(dev);
3103         void __iomem *ioaddr = vp->ioaddr;
3104         int new_mode;
3105
3106         if (dev->flags & IFF_PROMISC) {
3107                 if (vortex_debug > 0)
3108                         printk(KERN_NOTICE "%s: Setting promiscuous mode.\n", dev->name);
3109                 new_mode = SetRxFilter|RxStation|RxMulticast|RxBroadcast|RxProm;
3110         } else  if ((dev->mc_list)  ||  (dev->flags & IFF_ALLMULTI)) {
3111                 new_mode = SetRxFilter|RxStation|RxMulticast|RxBroadcast;
3112         } else
3113                 new_mode = SetRxFilter | RxStation | RxBroadcast;
3114
3115         iowrite16(new_mode, ioaddr + EL3_CMD);
3116 }
3117
3118 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
3119 /* Setup the card so that it can receive frames with an 802.1q VLAN tag.
3120    Note that this must be done after each RxReset due to some backwards
3121    compatibility logic in the Cyclone and Tornado ASICs */
3122
3123 /* The Ethernet Type used for 802.1q tagged frames */
3124 #define VLAN_ETHER_TYPE 0x8100
3125
3126 static void set_8021q_mode(struct net_device *dev, int enable)
3127 {
3128         struct vortex_private *vp = netdev_priv(dev);
3129         void __iomem *ioaddr = vp->ioaddr;
3130         int old_window = ioread16(ioaddr + EL3_CMD);
3131         int mac_ctrl;
3132
3133         if ((vp->drv_flags&IS_CYCLONE) || (vp->drv_flags&IS_TORNADO)) {
3134                 /* cyclone and tornado chipsets can recognize 802.1q
3135                  * tagged frames and treat them correctly */
3136
3137                 int max_pkt_size = dev->mtu+14; /* MTU+Ethernet header */
3138                 if (enable)
3139                         max_pkt_size += 4;      /* 802.1Q VLAN tag */
3140
3141                 EL3WINDOW(3);
3142                 iowrite16(max_pkt_size, ioaddr+Wn3_MaxPktSize);
3143
3144                 /* set VlanEtherType to let the hardware checksumming
3145                    treat tagged frames correctly */
3146                 EL3WINDOW(7);
3147                 iowrite16(VLAN_ETHER_TYPE, ioaddr+Wn7_VlanEtherType);
3148         } else {
3149                 /* on older cards we have to enable large frames */
3150
3151                 vp->large_frames = dev->mtu > 1500 || enable;
3152
3153                 EL3WINDOW(3);
3154                 mac_ctrl = ioread16(ioaddr+Wn3_MAC_Ctrl);
3155                 if (vp->large_frames)
3156                         mac_ctrl |= 0x40;
3157                 else
3158                         mac_ctrl &= ~0x40;
3159                 iowrite16(mac_ctrl, ioaddr+Wn3_MAC_Ctrl);
3160         }
3161
3162         EL3WINDOW(old_window);
3163 }
3164 #else
3165
3166 static void set_8021q_mode(struct net_device *dev, int enable)
3167 {
3168 }
3169
3170
3171 #endif
3172
3173 /* MII transceiver control section.
3174    Read and write the MII registers using software-generated serial
3175    MDIO protocol.  See the MII specifications or DP83840A data sheet
3176    for details. */
3177
3178 /* The maximum data clock rate is 2.5 Mhz.  The minimum timing is usually
3179    met by back-to-back PCI I/O cycles, but we insert a delay to avoid
3180    "overclocking" issues. */
3181 #define mdio_delay() ioread32(mdio_addr)
3182
3183 #define MDIO_SHIFT_CLK  0x01
3184 #define MDIO_DIR_WRITE  0x04
3185 #define MDIO_DATA_WRITE0 (0x00 | MDIO_DIR_WRITE)
3186 #define MDIO_DATA_WRITE1 (0x02 | MDIO_DIR_WRITE)
3187 #define MDIO_DATA_READ  0x02
3188 #define MDIO_ENB_IN             0x00
3189
3190 /* Generate the preamble required for initial synchronization and
3191    a few older transceivers. */
3192 static void mdio_sync(void __iomem *ioaddr, int bits)
3193 {
3194         void __iomem *mdio_addr = ioaddr + Wn4_PhysicalMgmt;
3195
3196         /* Establish sync by sending at least 32 logic ones. */
3197         while (-- bits >= 0) {
3198                 iowrite16(MDIO_DATA_WRITE1, mdio_addr);
3199                 mdio_delay();
3200                 iowrite16(MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
3201                 mdio_delay();
3202         }
3203 }
3204
3205 static int mdio_read(struct net_device *dev, int phy_id, int location)
3206 {
3207         int i;
3208         struct vortex_private *vp = netdev_priv(dev);
3209         void __iomem *ioaddr = vp->ioaddr;
3210         int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
3211         unsigned int retval = 0;
3212         void __iomem *mdio_addr = ioaddr + Wn4_PhysicalMgmt;
3213
3214         if (mii_preamble_required)
3215                 mdio_sync(ioaddr, 32);
3216
3217         /* Shift the read command bits out. */
3218         for (i = 14; i >= 0; i--) {
3219                 int dataval = (read_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
3220                 iowrite16(dataval, mdio_addr);
3221                 mdio_delay();
3222                 iowrite16(dataval | MDIO_SHIFT_CLK, mdio_addr);
3223                 mdio_delay();
3224         }
3225         /* Read the two transition, 16 data, and wire-idle bits. */
3226         for (i = 19; i > 0; i--) {
3227                 iowrite16(MDIO_ENB_IN, mdio_addr);
3228                 mdio_delay();
3229                 retval = (retval << 1) | ((ioread16(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
3230                 iowrite16(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
3231                 mdio_delay();
3232         }
3233         return retval & 0x20000 ? 0xffff : retval>>1 & 0xffff;
3234 }
3235
3236 static void mdio_write(struct net_device *dev, int phy_id, int location, int value)
3237 {
3238         struct vortex_private *vp = netdev_priv(dev);
3239         void __iomem *ioaddr = vp->ioaddr;
3240         int write_cmd = 0x50020000 | (phy_id << 23) | (location << 18) | value;
3241         void __iomem *mdio_addr = ioaddr + Wn4_PhysicalMgmt;
3242         int i;
3243
3244         if (mii_preamble_required)
3245                 mdio_sync(ioaddr, 32);
3246
3247         /* Shift the command bits out. */
3248         for (i = 31; i >= 0; i--) {
3249                 int dataval = (write_cmd&(1<<i)) ? MDIO_DATA_WRITE1 : MDIO_DATA_WRITE0;
3250                 iowrite16(dataval, mdio_addr);
3251                 mdio_delay();
3252                 iowrite16(dataval | MDIO_SHIFT_CLK, mdio_addr);
3253                 mdio_delay();
3254         }
3255         /* Leave the interface idle. */
3256         for (i = 1; i >= 0; i--) {
3257                 iowrite16(MDIO_ENB_IN, mdio_addr);
3258                 mdio_delay();
3259                 iowrite16(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
3260                 mdio_delay();
3261         }
3262         return;
3263 }
3264 \f
3265 /* ACPI: Advanced Configuration and Power Interface. */
3266 /* Set Wake-On-LAN mode and put the board into D3 (power-down) state. */
3267 static void acpi_set_WOL(struct net_device *dev)
3268 {
3269         struct vortex_private *vp = netdev_priv(dev);
3270         void __iomem *ioaddr = vp->ioaddr;
3271
3272         if (vp->enable_wol) {
3273                 /* Power up on: 1==Downloaded Filter, 2==Magic Packets, 4==Link Status. */
3274                 EL3WINDOW(7);
3275                 iowrite16(2, ioaddr + 0x0c);
3276                 /* The RxFilter must accept the WOL frames. */
3277                 iowrite16(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
3278                 iowrite16(RxEnable, ioaddr + EL3_CMD);
3279
3280                 pci_enable_wake(VORTEX_PCI(vp), 0, 1);
3281
3282                 /* Change the power state to D3; RxEnable doesn't take effect. */
3283                 pci_set_power_state(VORTEX_PCI(vp), PCI_D3hot);
3284         }
3285 }
3286
3287
3288 static void __devexit vortex_remove_one (struct pci_dev *pdev)
3289 {
3290         struct net_device *dev = pci_get_drvdata(pdev);
3291         struct vortex_private *vp;
3292
3293         if (!dev) {
3294                 printk("vortex_remove_one called for Compaq device!\n");
3295                 BUG();
3296         }
3297
3298         vp = netdev_priv(dev);
3299
3300         if (vp->cb_fn_base)
3301                 pci_iounmap(VORTEX_PCI(vp), vp->cb_fn_base);
3302
3303         unregister_netdev(dev);
3304
3305         if (VORTEX_PCI(vp)) {
3306                 pci_set_power_state(VORTEX_PCI(vp), PCI_D0);    /* Go active */
3307                 if (vp->pm_state_valid)
3308                         pci_restore_state(VORTEX_PCI(vp));
3309                 pci_disable_device(VORTEX_PCI(vp));
3310         }
3311         /* Should really use issue_and_wait() here */
3312         iowrite16(TotalReset | ((vp->drv_flags & EEPROM_RESET) ? 0x04 : 0x14),
3313              vp->ioaddr + EL3_CMD);
3314
3315         pci_iounmap(VORTEX_PCI(vp), vp->ioaddr);
3316
3317         pci_free_consistent(pdev,
3318                                                 sizeof(struct boom_rx_desc) * RX_RING_SIZE
3319                                                         + sizeof(struct boom_tx_desc) * TX_RING_SIZE,
3320                                                 vp->rx_ring,
3321                                                 vp->rx_ring_dma);
3322         if (vp->must_free_region)
3323                 release_region(dev->base_addr, vp->io_size);
3324         free_netdev(dev);
3325 }
3326
3327
3328 static struct pci_driver vortex_driver = {
3329         .name           = "3c59x",
3330         .probe          = vortex_init_one,
3331         .remove         = __devexit_p(vortex_remove_one),
3332         .id_table       = vortex_pci_tbl,
3333 #ifdef CONFIG_PM
3334         .suspend        = vortex_suspend,
3335         .resume         = vortex_resume,
3336 #endif
3337 };
3338
3339
3340 static int vortex_have_pci;
3341 static int vortex_have_eisa;
3342
3343
3344 static int __init vortex_init (void)
3345 {
3346         int pci_rc, eisa_rc;
3347
3348         pci_rc = pci_module_init(&vortex_driver);
3349         eisa_rc = vortex_eisa_init();
3350
3351         if (pci_rc == 0)
3352                 vortex_have_pci = 1;
3353         if (eisa_rc > 0)
3354                 vortex_have_eisa = 1;
3355
3356         return (vortex_have_pci + vortex_have_eisa) ? 0 : -ENODEV;
3357 }
3358
3359
3360 static void __exit vortex_eisa_cleanup (void)
3361 {
3362         struct vortex_private *vp;
3363         void __iomem *ioaddr;
3364
3365 #ifdef CONFIG_EISA
3366         /* Take care of the EISA devices */
3367         eisa_driver_unregister (&vortex_eisa_driver);
3368 #endif
3369         
3370         if (compaq_net_device) {
3371                 vp = compaq_net_device->priv;
3372                 ioaddr = ioport_map(compaq_net_device->base_addr,
3373                                     VORTEX_TOTAL_SIZE);
3374
3375                 unregister_netdev (compaq_net_device);
3376                 iowrite16 (TotalReset, ioaddr + EL3_CMD);
3377                 release_region(compaq_net_device->base_addr,
3378                                VORTEX_TOTAL_SIZE);
3379
3380                 free_netdev (compaq_net_device);
3381         }
3382 }
3383
3384
3385 static void __exit vortex_cleanup (void)
3386 {
3387         if (vortex_have_pci)
3388                 pci_unregister_driver (&vortex_driver);
3389         if (vortex_have_eisa)
3390                 vortex_eisa_cleanup ();
3391 }
3392
3393
3394 module_init(vortex_init);
3395 module_exit(vortex_cleanup);
3396
3397 \f
3398 /*
3399  * Local variables:
3400  *  c-indent-level: 4
3401  *  c-basic-offset: 4
3402  *  tab-width: 4
3403  * End:
3404  */