]> pilppa.org Git - linux-2.6-omap-h63xx.git/blob - drivers/net/starfire.c
Merge branch 'master'
[linux-2.6-omap-h63xx.git] / drivers / net / starfire.c
1 /* starfire.c: Linux device driver for the Adaptec Starfire network adapter. */
2 /*
3         Written 1998-2000 by Donald Becker.
4
5         Current maintainer is Ion Badulescu <ionut ta badula tod org>. Please
6         send all bug reports to me, and not to Donald Becker, as this code
7         has been heavily modified from Donald's original version.
8
9         This software may be used and distributed according to the terms of
10         the GNU General Public License (GPL), incorporated herein by reference.
11         Drivers based on or derived from this code fall under the GPL and must
12         retain the authorship, copyright and license notice.  This file is not
13         a complete program and may only be used when the entire operating
14         system is licensed under the GPL.
15
16         The information below comes from Donald Becker's original driver:
17
18         The author may be reached as becker@scyld.com, or C/O
19         Scyld Computing Corporation
20         410 Severn Ave., Suite 210
21         Annapolis MD 21403
22
23         Support and updates available at
24         http://www.scyld.com/network/starfire.html
25
26         -----------------------------------------------------------
27
28         Linux kernel-specific changes:
29
30         LK1.1.1 (jgarzik):
31         - Use PCI driver interface
32         - Fix MOD_xxx races
33         - softnet fixups
34
35         LK1.1.2 (jgarzik):
36         - Merge Becker version 0.15
37
38         LK1.1.3 (Andrew Morton)
39         - Timer cleanups
40
41         LK1.1.4 (jgarzik):
42         - Merge Becker version 1.03
43
44         LK1.2.1 (Ion Badulescu <ionut@cs.columbia.edu>)
45         - Support hardware Rx/Tx checksumming
46         - Use the GFP firmware taken from Adaptec's Netware driver
47
48         LK1.2.2 (Ion Badulescu)
49         - Backported to 2.2.x
50
51         LK1.2.3 (Ion Badulescu)
52         - Fix the flaky mdio interface
53         - More compat clean-ups
54
55         LK1.2.4 (Ion Badulescu)
56         - More 2.2.x initialization fixes
57
58         LK1.2.5 (Ion Badulescu)
59         - Several fixes from Manfred Spraul
60
61         LK1.2.6 (Ion Badulescu)
62         - Fixed ifup/ifdown/ifup problem in 2.4.x
63
64         LK1.2.7 (Ion Badulescu)
65         - Removed unused code
66         - Made more functions static and __init
67
68         LK1.2.8 (Ion Badulescu)
69         - Quell bogus error messages, inform about the Tx threshold
70         - Removed #ifdef CONFIG_PCI, this driver is PCI only
71
72         LK1.2.9 (Ion Badulescu)
73         - Merged Jeff Garzik's changes from 2.4.4-pre5
74         - Added 2.2.x compatibility stuff required by the above changes
75
76         LK1.2.9a (Ion Badulescu)
77         - More updates from Jeff Garzik
78
79         LK1.3.0 (Ion Badulescu)
80         - Merged zerocopy support
81
82         LK1.3.1 (Ion Badulescu)
83         - Added ethtool support
84         - Added GPIO (media change) interrupt support
85
86         LK1.3.2 (Ion Badulescu)
87         - Fixed 2.2.x compatibility issues introduced in 1.3.1
88         - Fixed ethtool ioctl returning uninitialized memory
89
90         LK1.3.3 (Ion Badulescu)
91         - Initialize the TxMode register properly
92         - Don't dereference dev->priv after freeing it
93
94         LK1.3.4 (Ion Badulescu)
95         - Fixed initialization timing problems
96         - Fixed interrupt mask definitions
97
98         LK1.3.5 (jgarzik)
99         - ethtool NWAY_RST, GLINK, [GS]MSGLVL support
100
101         LK1.3.6:
102         - Sparc64 support and fixes (Ion Badulescu)
103         - Better stats and error handling (Ion Badulescu)
104         - Use new pci_set_mwi() PCI API function (jgarzik)
105
106         LK1.3.7 (Ion Badulescu)
107         - minimal implementation of tx_timeout()
108         - correctly shutdown the Rx/Tx engines in netdev_close()
109         - added calls to netif_carrier_on/off
110         (patch from Stefan Rompf <srompf@isg.de>)
111         - VLAN support
112
113         LK1.3.8 (Ion Badulescu)
114         - adjust DMA burst size on sparc64
115         - 64-bit support
116         - reworked zerocopy support for 64-bit buffers
117         - working and usable interrupt mitigation/latency
118         - reduced Tx interrupt frequency for lower interrupt overhead
119
120         LK1.3.9 (Ion Badulescu)
121         - bugfix for mcast filter
122         - enable the right kind of Tx interrupts (TxDMADone, not TxDone)
123
124         LK1.4.0 (Ion Badulescu)
125         - NAPI support
126
127         LK1.4.1 (Ion Badulescu)
128         - flush PCI posting buffers after disabling Rx interrupts
129         - put the chip to a D3 slumber on driver unload
130         - added config option to enable/disable NAPI
131
132         LK1.4.2 (Ion Badulescu)
133         - finally added firmware (GPL'ed by Adaptec)
134         - removed compatibility code for 2.2.x
135
136         LK1.4.2.1 (Ion Badulescu)
137         - fixed 32/64 bit issues on i386 + CONFIG_HIGHMEM
138         - added 32-bit padding to outgoing skb's, removed previous workaround
139
140 TODO:   - fix forced speed/duplexing code (broken a long time ago, when
141         somebody converted the driver to use the generic MII code)
142         - fix VLAN support
143 */
144
145 #define DRV_NAME        "starfire"
146 #define DRV_VERSION     "1.03+LK1.4.2.1"
147 #define DRV_RELDATE     "October 3, 2005"
148
149 #include <linux/config.h>
150 #include <linux/version.h>
151 #include <linux/module.h>
152 #include <linux/kernel.h>
153 #include <linux/pci.h>
154 #include <linux/netdevice.h>
155 #include <linux/etherdevice.h>
156 #include <linux/init.h>
157 #include <linux/delay.h>
158 #include <linux/crc32.h>
159 #include <linux/ethtool.h>
160 #include <linux/mii.h>
161 #include <linux/if_vlan.h>
162 #include <asm/processor.h>              /* Processor type for cache alignment. */
163 #include <asm/uaccess.h>
164 #include <asm/io.h>
165
166 #include "starfire_firmware.h"
167 /*
168  * The current frame processor firmware fails to checksum a fragment
169  * of length 1. If and when this is fixed, the #define below can be removed.
170  */
171 #define HAS_BROKEN_FIRMWARE
172
173 /*
174  * If using the broken firmware, data must be padded to the next 32-bit boundary.
175  */
176 #ifdef HAS_BROKEN_FIRMWARE
177 #define PADDING_MASK 3
178 #endif
179
180 /*
181  * Define this if using the driver with the zero-copy patch
182  */
183 #define ZEROCOPY
184
185 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
186 #define VLAN_SUPPORT
187 #endif
188
189 #ifndef CONFIG_ADAPTEC_STARFIRE_NAPI
190 #undef HAVE_NETDEV_POLL
191 #endif
192
193 /* The user-configurable values.
194    These may be modified when a driver module is loaded.*/
195
196 /* Used for tuning interrupt latency vs. overhead. */
197 static int intr_latency;
198 static int small_frames;
199
200 static int debug = 1;                   /* 1 normal messages, 0 quiet .. 7 verbose. */
201 static int max_interrupt_work = 20;
202 static int mtu;
203 /* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
204    The Starfire has a 512 element hash table based on the Ethernet CRC. */
205 static int multicast_filter_limit = 512;
206 /* Whether to do TCP/UDP checksums in hardware */
207 static int enable_hw_cksum = 1;
208
209 #define PKT_BUF_SZ      1536            /* Size of each temporary Rx buffer.*/
210 /*
211  * Set the copy breakpoint for the copy-only-tiny-frames scheme.
212  * Setting to > 1518 effectively disables this feature.
213  *
214  * NOTE:
215  * The ia64 doesn't allow for unaligned loads even of integers being
216  * misaligned on a 2 byte boundary. Thus always force copying of
217  * packets as the starfire doesn't allow for misaligned DMAs ;-(
218  * 23/10/2000 - Jes
219  *
220  * The Alpha and the Sparc don't like unaligned loads, either. On Sparc64,
221  * at least, having unaligned frames leads to a rather serious performance
222  * penalty. -Ion
223  */
224 #if defined(__ia64__) || defined(__alpha__) || defined(__sparc__)
225 static int rx_copybreak = PKT_BUF_SZ;
226 #else
227 static int rx_copybreak /* = 0 */;
228 #endif
229
230 /* PCI DMA burst size -- on sparc64 we want to force it to 64 bytes, on the others the default of 128 is fine. */
231 #ifdef __sparc__
232 #define DMA_BURST_SIZE 64
233 #else
234 #define DMA_BURST_SIZE 128
235 #endif
236
237 /* Used to pass the media type, etc.
238    Both 'options[]' and 'full_duplex[]' exist for driver interoperability.
239    The media type is usually passed in 'options[]'.
240    These variables are deprecated, use ethtool instead. -Ion
241 */
242 #define MAX_UNITS 8             /* More are supported, limit only on options */
243 static int options[MAX_UNITS] = {0, };
244 static int full_duplex[MAX_UNITS] = {0, };
245
246 /* Operational parameters that are set at compile time. */
247
248 /* The "native" ring sizes are either 256 or 2048.
249    However in some modes a descriptor may be marked to wrap the ring earlier.
250 */
251 #define RX_RING_SIZE    256
252 #define TX_RING_SIZE    32
253 /* The completion queues are fixed at 1024 entries i.e. 4K or 8KB. */
254 #define DONE_Q_SIZE     1024
255 /* All queues must be aligned on a 256-byte boundary */
256 #define QUEUE_ALIGN     256
257
258 #if RX_RING_SIZE > 256
259 #define RX_Q_ENTRIES Rx2048QEntries
260 #else
261 #define RX_Q_ENTRIES Rx256QEntries
262 #endif
263
264 /* Operational parameters that usually are not changed. */
265 /* Time in jiffies before concluding the transmitter is hung. */
266 #define TX_TIMEOUT      (2 * HZ)
267
268 /*
269  * This SUCKS.
270  * We need a much better method to determine if dma_addr_t is 64-bit.
271  */
272 #if (defined(__i386__) && defined(CONFIG_HIGHMEM64G)) || defined(__x86_64__) || defined (__ia64__) || defined(__mips64__) || (defined(__mips__) && defined(CONFIG_HIGHMEM) && defined(CONFIG_64BIT_PHYS_ADDR))
273 /* 64-bit dma_addr_t */
274 #define ADDR_64BITS     /* This chip uses 64 bit addresses. */
275 #define netdrv_addr_t u64
276 #define cpu_to_dma(x) cpu_to_le64(x)
277 #define dma_to_cpu(x) le64_to_cpu(x)
278 #define RX_DESC_Q_ADDR_SIZE RxDescQAddr64bit
279 #define TX_DESC_Q_ADDR_SIZE TxDescQAddr64bit
280 #define RX_COMPL_Q_ADDR_SIZE RxComplQAddr64bit
281 #define TX_COMPL_Q_ADDR_SIZE TxComplQAddr64bit
282 #define RX_DESC_ADDR_SIZE RxDescAddr64bit
283 #else  /* 32-bit dma_addr_t */
284 #define netdrv_addr_t u32
285 #define cpu_to_dma(x) cpu_to_le32(x)
286 #define dma_to_cpu(x) le32_to_cpu(x)
287 #define RX_DESC_Q_ADDR_SIZE RxDescQAddr32bit
288 #define TX_DESC_Q_ADDR_SIZE TxDescQAddr32bit
289 #define RX_COMPL_Q_ADDR_SIZE RxComplQAddr32bit
290 #define TX_COMPL_Q_ADDR_SIZE TxComplQAddr32bit
291 #define RX_DESC_ADDR_SIZE RxDescAddr32bit
292 #endif
293
294 #define skb_first_frag_len(skb) skb_headlen(skb)
295 #define skb_num_frags(skb) (skb_shinfo(skb)->nr_frags + 1)
296
297 #ifdef HAVE_NETDEV_POLL
298 #define init_poll(dev) \
299 do { \
300         dev->poll = &netdev_poll; \
301         dev->weight = max_interrupt_work; \
302 } while (0)
303 #define netdev_rx(dev, ioaddr) \
304 do { \
305         u32 intr_enable; \
306         if (netif_rx_schedule_prep(dev)) { \
307                 __netif_rx_schedule(dev); \
308                 intr_enable = readl(ioaddr + IntrEnable); \
309                 intr_enable &= ~(IntrRxDone | IntrRxEmpty); \
310                 writel(intr_enable, ioaddr + IntrEnable); \
311                 readl(ioaddr + IntrEnable); /* flush PCI posting buffers */ \
312         } else { \
313                 /* Paranoia check */ \
314                 intr_enable = readl(ioaddr + IntrEnable); \
315                 if (intr_enable & (IntrRxDone | IntrRxEmpty)) { \
316                         printk(KERN_INFO "%s: interrupt while in polling mode!\n", dev->name); \
317                         intr_enable &= ~(IntrRxDone | IntrRxEmpty); \
318                         writel(intr_enable, ioaddr + IntrEnable); \
319                 } \
320         } \
321 } while (0)
322 #define netdev_receive_skb(skb) netif_receive_skb(skb)
323 #define vlan_netdev_receive_skb(skb, vlgrp, vlid) vlan_hwaccel_receive_skb(skb, vlgrp, vlid)
324 static int      netdev_poll(struct net_device *dev, int *budget);
325 #else  /* not HAVE_NETDEV_POLL */
326 #define init_poll(dev)
327 #define netdev_receive_skb(skb) netif_rx(skb)
328 #define vlan_netdev_receive_skb(skb, vlgrp, vlid) vlan_hwaccel_rx(skb, vlgrp, vlid)
329 #define netdev_rx(dev, ioaddr) \
330 do { \
331         int quota = np->dirty_rx + RX_RING_SIZE - np->cur_rx; \
332         __netdev_rx(dev, &quota);\
333 } while (0)
334 #endif /* not HAVE_NETDEV_POLL */
335 /* end of compatibility code */
336
337
338 /* These identify the driver base version and may not be removed. */
339 static char version[] __devinitdata =
340 KERN_INFO "starfire.c:v1.03 7/26/2000  Written by Donald Becker <becker@scyld.com>\n"
341 KERN_INFO " (unofficial 2.2/2.4 kernel port, version " DRV_VERSION ", " DRV_RELDATE ")\n";
342
343 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
344 MODULE_DESCRIPTION("Adaptec Starfire Ethernet driver");
345 MODULE_LICENSE("GPL");
346 MODULE_VERSION(DRV_VERSION);
347
348 module_param(max_interrupt_work, int, 0);
349 module_param(mtu, int, 0);
350 module_param(debug, int, 0);
351 module_param(rx_copybreak, int, 0);
352 module_param(intr_latency, int, 0);
353 module_param(small_frames, int, 0);
354 module_param_array(options, int, NULL, 0);
355 module_param_array(full_duplex, int, NULL, 0);
356 module_param(enable_hw_cksum, int, 0);
357 MODULE_PARM_DESC(max_interrupt_work, "Maximum events handled per interrupt");
358 MODULE_PARM_DESC(mtu, "MTU (all boards)");
359 MODULE_PARM_DESC(debug, "Debug level (0-6)");
360 MODULE_PARM_DESC(rx_copybreak, "Copy breakpoint for copy-only-tiny-frames");
361 MODULE_PARM_DESC(intr_latency, "Maximum interrupt latency, in microseconds");
362 MODULE_PARM_DESC(small_frames, "Maximum size of receive frames that bypass interrupt latency (0,64,128,256,512)");
363 MODULE_PARM_DESC(options, "Deprecated: Bits 0-3: media type, bit 17: full duplex");
364 MODULE_PARM_DESC(full_duplex, "Deprecated: Forced full-duplex setting (0/1)");
365 MODULE_PARM_DESC(enable_hw_cksum, "Enable/disable hardware cksum support (0/1)");
366
367 /*
368                                 Theory of Operation
369
370 I. Board Compatibility
371
372 This driver is for the Adaptec 6915 "Starfire" 64 bit PCI Ethernet adapter.
373
374 II. Board-specific settings
375
376 III. Driver operation
377
378 IIIa. Ring buffers
379
380 The Starfire hardware uses multiple fixed-size descriptor queues/rings.  The
381 ring sizes are set fixed by the hardware, but may optionally be wrapped
382 earlier by the END bit in the descriptor.
383 This driver uses that hardware queue size for the Rx ring, where a large
384 number of entries has no ill effect beyond increases the potential backlog.
385 The Tx ring is wrapped with the END bit, since a large hardware Tx queue
386 disables the queue layer priority ordering and we have no mechanism to
387 utilize the hardware two-level priority queue.  When modifying the
388 RX/TX_RING_SIZE pay close attention to page sizes and the ring-empty warning
389 levels.
390
391 IIIb/c. Transmit/Receive Structure
392
393 See the Adaptec manual for the many possible structures, and options for
394 each structure.  There are far too many to document all of them here.
395
396 For transmit this driver uses type 0/1 transmit descriptors (depending
397 on the 32/64 bitness of the architecture), and relies on automatic
398 minimum-length padding.  It does not use the completion queue
399 consumer index, but instead checks for non-zero status entries.
400
401 For receive this driver uses type 2/3 receive descriptors.  The driver
402 allocates full frame size skbuffs for the Rx ring buffers, so all frames
403 should fit in a single descriptor.  The driver does not use the completion
404 queue consumer index, but instead checks for non-zero status entries.
405
406 When an incoming frame is less than RX_COPYBREAK bytes long, a fresh skbuff
407 is allocated and the frame is copied to the new skbuff.  When the incoming
408 frame is larger, the skbuff is passed directly up the protocol stack.
409 Buffers consumed this way are replaced by newly allocated skbuffs in a later
410 phase of receive.
411
412 A notable aspect of operation is that unaligned buffers are not permitted by
413 the Starfire hardware.  Thus the IP header at offset 14 in an ethernet frame
414 isn't longword aligned, which may cause problems on some machine
415 e.g. Alphas and IA64. For these architectures, the driver is forced to copy
416 the frame into a new skbuff unconditionally. Copied frames are put into the
417 skbuff at an offset of "+2", thus 16-byte aligning the IP header.
418
419 IIId. Synchronization
420
421 The driver runs as two independent, single-threaded flows of control.  One
422 is the send-packet routine, which enforces single-threaded use by the
423 dev->tbusy flag.  The other thread is the interrupt handler, which is single
424 threaded by the hardware and interrupt handling software.
425
426 The send packet thread has partial control over the Tx ring and the netif_queue
427 status. If the number of free Tx slots in the ring falls below a certain number
428 (currently hardcoded to 4), it signals the upper layer to stop the queue.
429
430 The interrupt handler has exclusive control over the Rx ring and records stats
431 from the Tx ring.  After reaping the stats, it marks the Tx queue entry as
432 empty by incrementing the dirty_tx mark. Iff the netif_queue is stopped and the
433 number of free Tx slow is above the threshold, it signals the upper layer to
434 restart the queue.
435
436 IV. Notes
437
438 IVb. References
439
440 The Adaptec Starfire manuals, available only from Adaptec.
441 http://www.scyld.com/expert/100mbps.html
442 http://www.scyld.com/expert/NWay.html
443
444 IVc. Errata
445
446 - StopOnPerr is broken, don't enable
447 - Hardware ethernet padding exposes random data, perform software padding
448   instead (unverified -- works correctly for all the hardware I have)
449
450 */
451
452
453
454 enum chip_capability_flags {CanHaveMII=1, };
455
456 enum chipset {
457         CH_6915 = 0,
458 };
459
460 static struct pci_device_id starfire_pci_tbl[] = {
461         { 0x9004, 0x6915, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_6915 },
462         { 0, }
463 };
464 MODULE_DEVICE_TABLE(pci, starfire_pci_tbl);
465
466 /* A chip capabilities table, matching the CH_xxx entries in xxx_pci_tbl[] above. */
467 static struct chip_info {
468         const char *name;
469         int drv_flags;
470 } netdrv_tbl[] __devinitdata = {
471         { "Adaptec Starfire 6915", CanHaveMII },
472 };
473
474
475 /* Offsets to the device registers.
476    Unlike software-only systems, device drivers interact with complex hardware.
477    It's not useful to define symbolic names for every register bit in the
478    device.  The name can only partially document the semantics and make
479    the driver longer and more difficult to read.
480    In general, only the important configuration values or bits changed
481    multiple times should be defined symbolically.
482 */
483 enum register_offsets {
484         PCIDeviceConfig=0x50040, GenCtrl=0x50070, IntrTimerCtrl=0x50074,
485         IntrClear=0x50080, IntrStatus=0x50084, IntrEnable=0x50088,
486         MIICtrl=0x52000, TxStationAddr=0x50120, EEPROMCtrl=0x51000,
487         GPIOCtrl=0x5008C, TxDescCtrl=0x50090,
488         TxRingPtr=0x50098, HiPriTxRingPtr=0x50094, /* Low and High priority. */
489         TxRingHiAddr=0x5009C,           /* 64 bit address extension. */
490         TxProducerIdx=0x500A0, TxConsumerIdx=0x500A4,
491         TxThreshold=0x500B0,
492         CompletionHiAddr=0x500B4, TxCompletionAddr=0x500B8,
493         RxCompletionAddr=0x500BC, RxCompletionQ2Addr=0x500C0,
494         CompletionQConsumerIdx=0x500C4, RxDMACtrl=0x500D0,
495         RxDescQCtrl=0x500D4, RxDescQHiAddr=0x500DC, RxDescQAddr=0x500E0,
496         RxDescQIdx=0x500E8, RxDMAStatus=0x500F0, RxFilterMode=0x500F4,
497         TxMode=0x55000, VlanType=0x55064,
498         PerfFilterTable=0x56000, HashTable=0x56100,
499         TxGfpMem=0x58000, RxGfpMem=0x5a000,
500 };
501
502 /*
503  * Bits in the interrupt status/mask registers.
504  * Warning: setting Intr[Ab]NormalSummary in the IntrEnable register
505  * enables all the interrupt sources that are or'ed into those status bits.
506  */
507 enum intr_status_bits {
508         IntrLinkChange=0xf0000000, IntrStatsMax=0x08000000,
509         IntrAbnormalSummary=0x02000000, IntrGeneralTimer=0x01000000,
510         IntrSoftware=0x800000, IntrRxComplQ1Low=0x400000,
511         IntrTxComplQLow=0x200000, IntrPCI=0x100000,
512         IntrDMAErr=0x080000, IntrTxDataLow=0x040000,
513         IntrRxComplQ2Low=0x020000, IntrRxDescQ1Low=0x010000,
514         IntrNormalSummary=0x8000, IntrTxDone=0x4000,
515         IntrTxDMADone=0x2000, IntrTxEmpty=0x1000,
516         IntrEarlyRxQ2=0x0800, IntrEarlyRxQ1=0x0400,
517         IntrRxQ2Done=0x0200, IntrRxQ1Done=0x0100,
518         IntrRxGFPDead=0x80, IntrRxDescQ2Low=0x40,
519         IntrNoTxCsum=0x20, IntrTxBadID=0x10,
520         IntrHiPriTxBadID=0x08, IntrRxGfp=0x04,
521         IntrTxGfp=0x02, IntrPCIPad=0x01,
522         /* not quite bits */
523         IntrRxDone=IntrRxQ2Done | IntrRxQ1Done,
524         IntrRxEmpty=IntrRxDescQ1Low | IntrRxDescQ2Low,
525         IntrNormalMask=0xff00, IntrAbnormalMask=0x3ff00fe,
526 };
527
528 /* Bits in the RxFilterMode register. */
529 enum rx_mode_bits {
530         AcceptBroadcast=0x04, AcceptAllMulticast=0x02, AcceptAll=0x01,
531         AcceptMulticast=0x10, PerfectFilter=0x40, HashFilter=0x30,
532         PerfectFilterVlan=0x80, MinVLANPrio=0xE000, VlanMode=0x0200,
533         WakeupOnGFP=0x0800,
534 };
535
536 /* Bits in the TxMode register */
537 enum tx_mode_bits {
538         MiiSoftReset=0x8000, MIILoopback=0x4000,
539         TxFlowEnable=0x0800, RxFlowEnable=0x0400,
540         PadEnable=0x04, FullDuplex=0x02, HugeFrame=0x01,
541 };
542
543 /* Bits in the TxDescCtrl register. */
544 enum tx_ctrl_bits {
545         TxDescSpaceUnlim=0x00, TxDescSpace32=0x10, TxDescSpace64=0x20,
546         TxDescSpace128=0x30, TxDescSpace256=0x40,
547         TxDescType0=0x00, TxDescType1=0x01, TxDescType2=0x02,
548         TxDescType3=0x03, TxDescType4=0x04,
549         TxNoDMACompletion=0x08,
550         TxDescQAddr64bit=0x80, TxDescQAddr32bit=0,
551         TxHiPriFIFOThreshShift=24, TxPadLenShift=16,
552         TxDMABurstSizeShift=8,
553 };
554
555 /* Bits in the RxDescQCtrl register. */
556 enum rx_ctrl_bits {
557         RxBufferLenShift=16, RxMinDescrThreshShift=0,
558         RxPrefetchMode=0x8000, RxVariableQ=0x2000,
559         Rx2048QEntries=0x4000, Rx256QEntries=0,
560         RxDescAddr64bit=0x1000, RxDescAddr32bit=0,
561         RxDescQAddr64bit=0x0100, RxDescQAddr32bit=0,
562         RxDescSpace4=0x000, RxDescSpace8=0x100,
563         RxDescSpace16=0x200, RxDescSpace32=0x300,
564         RxDescSpace64=0x400, RxDescSpace128=0x500,
565         RxConsumerWrEn=0x80,
566 };
567
568 /* Bits in the RxDMACtrl register. */
569 enum rx_dmactrl_bits {
570         RxReportBadFrames=0x80000000, RxDMAShortFrames=0x40000000,
571         RxDMABadFrames=0x20000000, RxDMACrcErrorFrames=0x10000000,
572         RxDMAControlFrame=0x08000000, RxDMAPauseFrame=0x04000000,
573         RxChecksumIgnore=0, RxChecksumRejectTCPUDP=0x02000000,
574         RxChecksumRejectTCPOnly=0x01000000,
575         RxCompletionQ2Enable=0x800000,
576         RxDMAQ2Disable=0, RxDMAQ2FPOnly=0x100000,
577         RxDMAQ2SmallPkt=0x200000, RxDMAQ2HighPrio=0x300000,
578         RxDMAQ2NonIP=0x400000,
579         RxUseBackupQueue=0x080000, RxDMACRC=0x040000,
580         RxEarlyIntThreshShift=12, RxHighPrioThreshShift=8,
581         RxBurstSizeShift=0,
582 };
583
584 /* Bits in the RxCompletionAddr register */
585 enum rx_compl_bits {
586         RxComplQAddr64bit=0x80, RxComplQAddr32bit=0,
587         RxComplProducerWrEn=0x40,
588         RxComplType0=0x00, RxComplType1=0x10,
589         RxComplType2=0x20, RxComplType3=0x30,
590         RxComplThreshShift=0,
591 };
592
593 /* Bits in the TxCompletionAddr register */
594 enum tx_compl_bits {
595         TxComplQAddr64bit=0x80, TxComplQAddr32bit=0,
596         TxComplProducerWrEn=0x40,
597         TxComplIntrStatus=0x20,
598         CommonQueueMode=0x10,
599         TxComplThreshShift=0,
600 };
601
602 /* Bits in the GenCtrl register */
603 enum gen_ctrl_bits {
604         RxEnable=0x05, TxEnable=0x0a,
605         RxGFPEnable=0x10, TxGFPEnable=0x20,
606 };
607
608 /* Bits in the IntrTimerCtrl register */
609 enum intr_ctrl_bits {
610         Timer10X=0x800, EnableIntrMasking=0x60, SmallFrameBypass=0x100,
611         SmallFrame64=0, SmallFrame128=0x200, SmallFrame256=0x400, SmallFrame512=0x600,
612         IntrLatencyMask=0x1f,
613 };
614
615 /* The Rx and Tx buffer descriptors. */
616 struct starfire_rx_desc {
617         dma_addr_t rxaddr;
618 };
619 enum rx_desc_bits {
620         RxDescValid=1, RxDescEndRing=2,
621 };
622
623 /* Completion queue entry. */
624 struct short_rx_done_desc {
625         u32 status;                     /* Low 16 bits is length. */
626 };
627 struct basic_rx_done_desc {
628         u32 status;                     /* Low 16 bits is length. */
629         u16 vlanid;
630         u16 status2;
631 };
632 struct csum_rx_done_desc {
633         u32 status;                     /* Low 16 bits is length. */
634         u16 csum;                       /* Partial checksum */
635         u16 status2;
636 };
637 struct full_rx_done_desc {
638         u32 status;                     /* Low 16 bits is length. */
639         u16 status3;
640         u16 status2;
641         u16 vlanid;
642         u16 csum;                       /* partial checksum */
643         u32 timestamp;
644 };
645 /* XXX: this is ugly and I'm not sure it's worth the trouble -Ion */
646 #ifdef VLAN_SUPPORT
647 typedef struct full_rx_done_desc rx_done_desc;
648 #define RxComplType RxComplType3
649 #else  /* not VLAN_SUPPORT */
650 typedef struct csum_rx_done_desc rx_done_desc;
651 #define RxComplType RxComplType2
652 #endif /* not VLAN_SUPPORT */
653
654 enum rx_done_bits {
655         RxOK=0x20000000, RxFIFOErr=0x10000000, RxBufQ2=0x08000000,
656 };
657
658 /* Type 1 Tx descriptor. */
659 struct starfire_tx_desc_1 {
660         u32 status;                     /* Upper bits are status, lower 16 length. */
661         u32 addr;
662 };
663
664 /* Type 2 Tx descriptor. */
665 struct starfire_tx_desc_2 {
666         u32 status;                     /* Upper bits are status, lower 16 length. */
667         u32 reserved;
668         u64 addr;
669 };
670
671 #ifdef ADDR_64BITS
672 typedef struct starfire_tx_desc_2 starfire_tx_desc;
673 #define TX_DESC_TYPE TxDescType2
674 #else  /* not ADDR_64BITS */
675 typedef struct starfire_tx_desc_1 starfire_tx_desc;
676 #define TX_DESC_TYPE TxDescType1
677 #endif /* not ADDR_64BITS */
678 #define TX_DESC_SPACING TxDescSpaceUnlim
679
680 enum tx_desc_bits {
681         TxDescID=0xB0000000,
682         TxCRCEn=0x01000000, TxDescIntr=0x08000000,
683         TxRingWrap=0x04000000, TxCalTCP=0x02000000,
684 };
685 struct tx_done_desc {
686         u32 status;                     /* timestamp, index. */
687 #if 0
688         u32 intrstatus;                 /* interrupt status */
689 #endif
690 };
691
692 struct rx_ring_info {
693         struct sk_buff *skb;
694         dma_addr_t mapping;
695 };
696 struct tx_ring_info {
697         struct sk_buff *skb;
698         dma_addr_t mapping;
699         unsigned int used_slots;
700 };
701
702 #define PHY_CNT         2
703 struct netdev_private {
704         /* Descriptor rings first for alignment. */
705         struct starfire_rx_desc *rx_ring;
706         starfire_tx_desc *tx_ring;
707         dma_addr_t rx_ring_dma;
708         dma_addr_t tx_ring_dma;
709         /* The addresses of rx/tx-in-place skbuffs. */
710         struct rx_ring_info rx_info[RX_RING_SIZE];
711         struct tx_ring_info tx_info[TX_RING_SIZE];
712         /* Pointers to completion queues (full pages). */
713         rx_done_desc *rx_done_q;
714         dma_addr_t rx_done_q_dma;
715         unsigned int rx_done;
716         struct tx_done_desc *tx_done_q;
717         dma_addr_t tx_done_q_dma;
718         unsigned int tx_done;
719         struct net_device_stats stats;
720         struct pci_dev *pci_dev;
721 #ifdef VLAN_SUPPORT
722         struct vlan_group *vlgrp;
723 #endif
724         void *queue_mem;
725         dma_addr_t queue_mem_dma;
726         size_t queue_mem_size;
727
728         /* Frequently used values: keep some adjacent for cache effect. */
729         spinlock_t lock;
730         unsigned int cur_rx, dirty_rx;  /* Producer/consumer ring indices */
731         unsigned int cur_tx, dirty_tx, reap_tx;
732         unsigned int rx_buf_sz;         /* Based on MTU+slack. */
733         /* These values keep track of the transceiver/media in use. */
734         int speed100;                   /* Set if speed == 100MBit. */
735         u32 tx_mode;
736         u32 intr_timer_ctrl;
737         u8 tx_threshold;
738         /* MII transceiver section. */
739         struct mii_if_info mii_if;              /* MII lib hooks/info */
740         int phy_cnt;                    /* MII device addresses. */
741         unsigned char phys[PHY_CNT];    /* MII device addresses. */
742         void __iomem *base;
743 };
744
745
746 static int      mdio_read(struct net_device *dev, int phy_id, int location);
747 static void     mdio_write(struct net_device *dev, int phy_id, int location, int value);
748 static int      netdev_open(struct net_device *dev);
749 static void     check_duplex(struct net_device *dev);
750 static void     tx_timeout(struct net_device *dev);
751 static void     init_ring(struct net_device *dev);
752 static int      start_tx(struct sk_buff *skb, struct net_device *dev);
753 static irqreturn_t intr_handler(int irq, void *dev_instance, struct pt_regs *regs);
754 static void     netdev_error(struct net_device *dev, int intr_status);
755 static int      __netdev_rx(struct net_device *dev, int *quota);
756 static void     refill_rx_ring(struct net_device *dev);
757 static void     netdev_error(struct net_device *dev, int intr_status);
758 static void     set_rx_mode(struct net_device *dev);
759 static struct net_device_stats *get_stats(struct net_device *dev);
760 static int      netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
761 static int      netdev_close(struct net_device *dev);
762 static void     netdev_media_change(struct net_device *dev);
763 static struct ethtool_ops ethtool_ops;
764
765
766 #ifdef VLAN_SUPPORT
767 static void netdev_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
768 {
769         struct netdev_private *np = netdev_priv(dev);
770
771         spin_lock(&np->lock);
772         if (debug > 2)
773                 printk("%s: Setting vlgrp to %p\n", dev->name, grp);
774         np->vlgrp = grp;
775         set_rx_mode(dev);
776         spin_unlock(&np->lock);
777 }
778
779 static void netdev_vlan_rx_add_vid(struct net_device *dev, unsigned short vid)
780 {
781         struct netdev_private *np = netdev_priv(dev);
782
783         spin_lock(&np->lock);
784         if (debug > 1)
785                 printk("%s: Adding vlanid %d to vlan filter\n", dev->name, vid);
786         set_rx_mode(dev);
787         spin_unlock(&np->lock);
788 }
789
790 static void netdev_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
791 {
792         struct netdev_private *np = netdev_priv(dev);
793
794         spin_lock(&np->lock);
795         if (debug > 1)
796                 printk("%s: removing vlanid %d from vlan filter\n", dev->name, vid);
797         if (np->vlgrp)
798                 np->vlgrp->vlan_devices[vid] = NULL;
799         set_rx_mode(dev);
800         spin_unlock(&np->lock);
801 }
802 #endif /* VLAN_SUPPORT */
803
804
805 static int __devinit starfire_init_one(struct pci_dev *pdev,
806                                        const struct pci_device_id *ent)
807 {
808         struct netdev_private *np;
809         int i, irq, option, chip_idx = ent->driver_data;
810         struct net_device *dev;
811         static int card_idx = -1;
812         long ioaddr;
813         void __iomem *base;
814         int drv_flags, io_size;
815         int boguscnt;
816
817 /* when built into the kernel, we only print version if device is found */
818 #ifndef MODULE
819         static int printed_version;
820         if (!printed_version++)
821                 printk(version);
822 #endif
823
824         card_idx++;
825
826         if (pci_enable_device (pdev))
827                 return -EIO;
828
829         ioaddr = pci_resource_start(pdev, 0);
830         io_size = pci_resource_len(pdev, 0);
831         if (!ioaddr || ((pci_resource_flags(pdev, 0) & IORESOURCE_MEM) == 0)) {
832                 printk(KERN_ERR DRV_NAME " %d: no PCI MEM resources, aborting\n", card_idx);
833                 return -ENODEV;
834         }
835
836         dev = alloc_etherdev(sizeof(*np));
837         if (!dev) {
838                 printk(KERN_ERR DRV_NAME " %d: cannot alloc etherdev, aborting\n", card_idx);
839                 return -ENOMEM;
840         }
841         SET_MODULE_OWNER(dev);
842         SET_NETDEV_DEV(dev, &pdev->dev);
843
844         irq = pdev->irq;
845
846         if (pci_request_regions (pdev, DRV_NAME)) {
847                 printk(KERN_ERR DRV_NAME " %d: cannot reserve PCI resources, aborting\n", card_idx);
848                 goto err_out_free_netdev;
849         }
850
851         /* ioremap is borken in Linux-2.2.x/sparc64 */
852         base = ioremap(ioaddr, io_size);
853         if (!base) {
854                 printk(KERN_ERR DRV_NAME " %d: cannot remap %#x @ %#lx, aborting\n",
855                         card_idx, io_size, ioaddr);
856                 goto err_out_free_res;
857         }
858
859         pci_set_master(pdev);
860
861         /* enable MWI -- it vastly improves Rx performance on sparc64 */
862         pci_set_mwi(pdev);
863
864 #ifdef ZEROCOPY
865         /* Starfire can do TCP/UDP checksumming */
866         if (enable_hw_cksum)
867                 dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
868 #endif /* ZEROCOPY */
869 #ifdef VLAN_SUPPORT
870         dev->features |= NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_FILTER;
871         dev->vlan_rx_register = netdev_vlan_rx_register;
872         dev->vlan_rx_add_vid = netdev_vlan_rx_add_vid;
873         dev->vlan_rx_kill_vid = netdev_vlan_rx_kill_vid;
874 #endif /* VLAN_RX_KILL_VID */
875 #ifdef ADDR_64BITS
876         dev->features |= NETIF_F_HIGHDMA;
877 #endif /* ADDR_64BITS */
878
879         /* Serial EEPROM reads are hidden by the hardware. */
880         for (i = 0; i < 6; i++)
881                 dev->dev_addr[i] = readb(base + EEPROMCtrl + 20 - i);
882
883 #if ! defined(final_version) /* Dump the EEPROM contents during development. */
884         if (debug > 4)
885                 for (i = 0; i < 0x20; i++)
886                         printk("%2.2x%s",
887                                (unsigned int)readb(base + EEPROMCtrl + i),
888                                i % 16 != 15 ? " " : "\n");
889 #endif
890
891         /* Issue soft reset */
892         writel(MiiSoftReset, base + TxMode);
893         udelay(1000);
894         writel(0, base + TxMode);
895
896         /* Reset the chip to erase previous misconfiguration. */
897         writel(1, base + PCIDeviceConfig);
898         boguscnt = 1000;
899         while (--boguscnt > 0) {
900                 udelay(10);
901                 if ((readl(base + PCIDeviceConfig) & 1) == 0)
902                         break;
903         }
904         if (boguscnt == 0)
905                 printk("%s: chipset reset never completed!\n", dev->name);
906         /* wait a little longer */
907         udelay(1000);
908
909         dev->base_addr = (unsigned long)base;
910         dev->irq = irq;
911
912         np = netdev_priv(dev);
913         np->base = base;
914         spin_lock_init(&np->lock);
915         pci_set_drvdata(pdev, dev);
916
917         np->pci_dev = pdev;
918
919         np->mii_if.dev = dev;
920         np->mii_if.mdio_read = mdio_read;
921         np->mii_if.mdio_write = mdio_write;
922         np->mii_if.phy_id_mask = 0x1f;
923         np->mii_if.reg_num_mask = 0x1f;
924
925         drv_flags = netdrv_tbl[chip_idx].drv_flags;
926
927         option = card_idx < MAX_UNITS ? options[card_idx] : 0;
928         if (dev->mem_start)
929                 option = dev->mem_start;
930
931         /* The lower four bits are the media type. */
932         if (option & 0x200)
933                 np->mii_if.full_duplex = 1;
934
935         if (card_idx < MAX_UNITS && full_duplex[card_idx] > 0)
936                 np->mii_if.full_duplex = 1;
937
938         if (np->mii_if.full_duplex)
939                 np->mii_if.force_media = 1;
940         else
941                 np->mii_if.force_media = 0;
942         np->speed100 = 1;
943
944         /* timer resolution is 128 * 0.8us */
945         np->intr_timer_ctrl = (((intr_latency * 10) / 1024) & IntrLatencyMask) |
946                 Timer10X | EnableIntrMasking;
947
948         if (small_frames > 0) {
949                 np->intr_timer_ctrl |= SmallFrameBypass;
950                 switch (small_frames) {
951                 case 1 ... 64:
952                         np->intr_timer_ctrl |= SmallFrame64;
953                         break;
954                 case 65 ... 128:
955                         np->intr_timer_ctrl |= SmallFrame128;
956                         break;
957                 case 129 ... 256:
958                         np->intr_timer_ctrl |= SmallFrame256;
959                         break;
960                 default:
961                         np->intr_timer_ctrl |= SmallFrame512;
962                         if (small_frames > 512)
963                                 printk("Adjusting small_frames down to 512\n");
964                         break;
965                 }
966         }
967
968         /* The chip-specific entries in the device structure. */
969         dev->open = &netdev_open;
970         dev->hard_start_xmit = &start_tx;
971         dev->tx_timeout = tx_timeout;
972         dev->watchdog_timeo = TX_TIMEOUT;
973         init_poll(dev);
974         dev->stop = &netdev_close;
975         dev->get_stats = &get_stats;
976         dev->set_multicast_list = &set_rx_mode;
977         dev->do_ioctl = &netdev_ioctl;
978         SET_ETHTOOL_OPS(dev, &ethtool_ops);
979
980         if (mtu)
981                 dev->mtu = mtu;
982
983         if (register_netdev(dev))
984                 goto err_out_cleardev;
985
986         printk(KERN_INFO "%s: %s at %p, ",
987                    dev->name, netdrv_tbl[chip_idx].name, base);
988         for (i = 0; i < 5; i++)
989                 printk("%2.2x:", dev->dev_addr[i]);
990         printk("%2.2x, IRQ %d.\n", dev->dev_addr[i], irq);
991
992         if (drv_flags & CanHaveMII) {
993                 int phy, phy_idx = 0;
994                 int mii_status;
995                 for (phy = 0; phy < 32 && phy_idx < PHY_CNT; phy++) {
996                         mdio_write(dev, phy, MII_BMCR, BMCR_RESET);
997                         mdelay(100);
998                         boguscnt = 1000;
999                         while (--boguscnt > 0)
1000                                 if ((mdio_read(dev, phy, MII_BMCR) & BMCR_RESET) == 0)
1001                                         break;
1002                         if (boguscnt == 0) {
1003                                 printk("%s: PHY#%d reset never completed!\n", dev->name, phy);
1004                                 continue;
1005                         }
1006                         mii_status = mdio_read(dev, phy, MII_BMSR);
1007                         if (mii_status != 0) {
1008                                 np->phys[phy_idx++] = phy;
1009                                 np->mii_if.advertising = mdio_read(dev, phy, MII_ADVERTISE);
1010                                 printk(KERN_INFO "%s: MII PHY found at address %d, status "
1011                                            "%#4.4x advertising %#4.4x.\n",
1012                                            dev->name, phy, mii_status, np->mii_if.advertising);
1013                                 /* there can be only one PHY on-board */
1014                                 break;
1015                         }
1016                 }
1017                 np->phy_cnt = phy_idx;
1018                 if (np->phy_cnt > 0)
1019                         np->mii_if.phy_id = np->phys[0];
1020                 else
1021                         memset(&np->mii_if, 0, sizeof(np->mii_if));
1022         }
1023
1024         printk(KERN_INFO "%s: scatter-gather and hardware TCP cksumming %s.\n",
1025                dev->name, enable_hw_cksum ? "enabled" : "disabled");
1026         return 0;
1027
1028 err_out_cleardev:
1029         pci_set_drvdata(pdev, NULL);
1030         iounmap(base);
1031 err_out_free_res:
1032         pci_release_regions (pdev);
1033 err_out_free_netdev:
1034         free_netdev(dev);
1035         return -ENODEV;
1036 }
1037
1038
1039 /* Read the MII Management Data I/O (MDIO) interfaces. */
1040 static int mdio_read(struct net_device *dev, int phy_id, int location)
1041 {
1042         struct netdev_private *np = netdev_priv(dev);
1043         void __iomem *mdio_addr = np->base + MIICtrl + (phy_id<<7) + (location<<2);
1044         int result, boguscnt=1000;
1045         /* ??? Should we add a busy-wait here? */
1046         do
1047                 result = readl(mdio_addr);
1048         while ((result & 0xC0000000) != 0x80000000 && --boguscnt > 0);
1049         if (boguscnt == 0)
1050                 return 0;
1051         if ((result & 0xffff) == 0xffff)
1052                 return 0;
1053         return result & 0xffff;
1054 }
1055
1056
1057 static void mdio_write(struct net_device *dev, int phy_id, int location, int value)
1058 {
1059         struct netdev_private *np = netdev_priv(dev);
1060         void __iomem *mdio_addr = np->base + MIICtrl + (phy_id<<7) + (location<<2);
1061         writel(value, mdio_addr);
1062         /* The busy-wait will occur before a read. */
1063 }
1064
1065
1066 static int netdev_open(struct net_device *dev)
1067 {
1068         struct netdev_private *np = netdev_priv(dev);
1069         void __iomem *ioaddr = np->base;
1070         int i, retval;
1071         size_t tx_done_q_size, rx_done_q_size, tx_ring_size, rx_ring_size;
1072
1073         /* Do we ever need to reset the chip??? */
1074
1075         retval = request_irq(dev->irq, &intr_handler, SA_SHIRQ, dev->name, dev);
1076         if (retval)
1077                 return retval;
1078
1079         /* Disable the Rx and Tx, and reset the chip. */
1080         writel(0, ioaddr + GenCtrl);
1081         writel(1, ioaddr + PCIDeviceConfig);
1082         if (debug > 1)
1083                 printk(KERN_DEBUG "%s: netdev_open() irq %d.\n",
1084                        dev->name, dev->irq);
1085
1086         /* Allocate the various queues. */
1087         if (np->queue_mem == 0) {
1088                 tx_done_q_size = ((sizeof(struct tx_done_desc) * DONE_Q_SIZE + QUEUE_ALIGN - 1) / QUEUE_ALIGN) * QUEUE_ALIGN;
1089                 rx_done_q_size = ((sizeof(rx_done_desc) * DONE_Q_SIZE + QUEUE_ALIGN - 1) / QUEUE_ALIGN) * QUEUE_ALIGN;
1090                 tx_ring_size = ((sizeof(starfire_tx_desc) * TX_RING_SIZE + QUEUE_ALIGN - 1) / QUEUE_ALIGN) * QUEUE_ALIGN;
1091                 rx_ring_size = sizeof(struct starfire_rx_desc) * RX_RING_SIZE;
1092                 np->queue_mem_size = tx_done_q_size + rx_done_q_size + tx_ring_size + rx_ring_size;
1093                 np->queue_mem = pci_alloc_consistent(np->pci_dev, np->queue_mem_size, &np->queue_mem_dma);
1094                 if (np->queue_mem == 0)
1095                         return -ENOMEM;
1096
1097                 np->tx_done_q     = np->queue_mem;
1098                 np->tx_done_q_dma = np->queue_mem_dma;
1099                 np->rx_done_q     = (void *) np->tx_done_q + tx_done_q_size;
1100                 np->rx_done_q_dma = np->tx_done_q_dma + tx_done_q_size;
1101                 np->tx_ring       = (void *) np->rx_done_q + rx_done_q_size;
1102                 np->tx_ring_dma   = np->rx_done_q_dma + rx_done_q_size;
1103                 np->rx_ring       = (void *) np->tx_ring + tx_ring_size;
1104                 np->rx_ring_dma   = np->tx_ring_dma + tx_ring_size;
1105         }
1106
1107         /* Start with no carrier, it gets adjusted later */
1108         netif_carrier_off(dev);
1109         init_ring(dev);
1110         /* Set the size of the Rx buffers. */
1111         writel((np->rx_buf_sz << RxBufferLenShift) |
1112                (0 << RxMinDescrThreshShift) |
1113                RxPrefetchMode | RxVariableQ |
1114                RX_Q_ENTRIES |
1115                RX_DESC_Q_ADDR_SIZE | RX_DESC_ADDR_SIZE |
1116                RxDescSpace4,
1117                ioaddr + RxDescQCtrl);
1118
1119         /* Set up the Rx DMA controller. */
1120         writel(RxChecksumIgnore |
1121                (0 << RxEarlyIntThreshShift) |
1122                (6 << RxHighPrioThreshShift) |
1123                ((DMA_BURST_SIZE / 32) << RxBurstSizeShift),
1124                ioaddr + RxDMACtrl);
1125
1126         /* Set Tx descriptor */
1127         writel((2 << TxHiPriFIFOThreshShift) |
1128                (0 << TxPadLenShift) |
1129                ((DMA_BURST_SIZE / 32) << TxDMABurstSizeShift) |
1130                TX_DESC_Q_ADDR_SIZE |
1131                TX_DESC_SPACING | TX_DESC_TYPE,
1132                ioaddr + TxDescCtrl);
1133
1134         writel( (np->queue_mem_dma >> 16) >> 16, ioaddr + RxDescQHiAddr);
1135         writel( (np->queue_mem_dma >> 16) >> 16, ioaddr + TxRingHiAddr);
1136         writel( (np->queue_mem_dma >> 16) >> 16, ioaddr + CompletionHiAddr);
1137         writel(np->rx_ring_dma, ioaddr + RxDescQAddr);
1138         writel(np->tx_ring_dma, ioaddr + TxRingPtr);
1139
1140         writel(np->tx_done_q_dma, ioaddr + TxCompletionAddr);
1141         writel(np->rx_done_q_dma |
1142                RxComplType |
1143                (0 << RxComplThreshShift),
1144                ioaddr + RxCompletionAddr);
1145
1146         if (debug > 1)
1147                 printk(KERN_DEBUG "%s: Filling in the station address.\n", dev->name);
1148
1149         /* Fill both the Tx SA register and the Rx perfect filter. */
1150         for (i = 0; i < 6; i++)
1151                 writeb(dev->dev_addr[i], ioaddr + TxStationAddr + 5 - i);
1152         /* The first entry is special because it bypasses the VLAN filter.
1153            Don't use it. */
1154         writew(0, ioaddr + PerfFilterTable);
1155         writew(0, ioaddr + PerfFilterTable + 4);
1156         writew(0, ioaddr + PerfFilterTable + 8);
1157         for (i = 1; i < 16; i++) {
1158                 u16 *eaddrs = (u16 *)dev->dev_addr;
1159                 void __iomem *setup_frm = ioaddr + PerfFilterTable + i * 16;
1160                 writew(cpu_to_be16(eaddrs[2]), setup_frm); setup_frm += 4;
1161                 writew(cpu_to_be16(eaddrs[1]), setup_frm); setup_frm += 4;
1162                 writew(cpu_to_be16(eaddrs[0]), setup_frm); setup_frm += 8;
1163         }
1164
1165         /* Initialize other registers. */
1166         /* Configure the PCI bus bursts and FIFO thresholds. */
1167         np->tx_mode = TxFlowEnable|RxFlowEnable|PadEnable;      /* modified when link is up. */
1168         writel(MiiSoftReset | np->tx_mode, ioaddr + TxMode);
1169         udelay(1000);
1170         writel(np->tx_mode, ioaddr + TxMode);
1171         np->tx_threshold = 4;
1172         writel(np->tx_threshold, ioaddr + TxThreshold);
1173
1174         writel(np->intr_timer_ctrl, ioaddr + IntrTimerCtrl);
1175
1176         netif_start_queue(dev);
1177
1178         if (debug > 1)
1179                 printk(KERN_DEBUG "%s: Setting the Rx and Tx modes.\n", dev->name);
1180         set_rx_mode(dev);
1181
1182         np->mii_if.advertising = mdio_read(dev, np->phys[0], MII_ADVERTISE);
1183         check_duplex(dev);
1184
1185         /* Enable GPIO interrupts on link change */
1186         writel(0x0f00ff00, ioaddr + GPIOCtrl);
1187
1188         /* Set the interrupt mask */
1189         writel(IntrRxDone | IntrRxEmpty | IntrDMAErr |
1190                IntrTxDMADone | IntrStatsMax | IntrLinkChange |
1191                IntrRxGFPDead | IntrNoTxCsum | IntrTxBadID,
1192                ioaddr + IntrEnable);
1193         /* Enable PCI interrupts. */
1194         writel(0x00800000 | readl(ioaddr + PCIDeviceConfig),
1195                ioaddr + PCIDeviceConfig);
1196
1197 #ifdef VLAN_SUPPORT
1198         /* Set VLAN type to 802.1q */
1199         writel(ETH_P_8021Q, ioaddr + VlanType);
1200 #endif /* VLAN_SUPPORT */
1201
1202         /* Load Rx/Tx firmware into the frame processors */
1203         for (i = 0; i < FIRMWARE_RX_SIZE * 2; i++)
1204                 writel(firmware_rx[i], ioaddr + RxGfpMem + i * 4);
1205         for (i = 0; i < FIRMWARE_TX_SIZE * 2; i++)
1206                 writel(firmware_tx[i], ioaddr + TxGfpMem + i * 4);
1207         if (enable_hw_cksum)
1208                 /* Enable the Rx and Tx units, and the Rx/Tx frame processors. */
1209                 writel(TxEnable|TxGFPEnable|RxEnable|RxGFPEnable, ioaddr + GenCtrl);
1210         else
1211                 /* Enable the Rx and Tx units only. */
1212                 writel(TxEnable|RxEnable, ioaddr + GenCtrl);
1213
1214         if (debug > 1)
1215                 printk(KERN_DEBUG "%s: Done netdev_open().\n",
1216                        dev->name);
1217
1218         return 0;
1219 }
1220
1221
1222 static void check_duplex(struct net_device *dev)
1223 {
1224         struct netdev_private *np = netdev_priv(dev);
1225         u16 reg0;
1226         int silly_count = 1000;
1227
1228         mdio_write(dev, np->phys[0], MII_ADVERTISE, np->mii_if.advertising);
1229         mdio_write(dev, np->phys[0], MII_BMCR, BMCR_RESET);
1230         udelay(500);
1231         while (--silly_count && mdio_read(dev, np->phys[0], MII_BMCR) & BMCR_RESET)
1232                 /* do nothing */;
1233         if (!silly_count) {
1234                 printk("%s: MII reset failed!\n", dev->name);
1235                 return;
1236         }
1237
1238         reg0 = mdio_read(dev, np->phys[0], MII_BMCR);
1239
1240         if (!np->mii_if.force_media) {
1241                 reg0 |= BMCR_ANENABLE | BMCR_ANRESTART;
1242         } else {
1243                 reg0 &= ~(BMCR_ANENABLE | BMCR_ANRESTART);
1244                 if (np->speed100)
1245                         reg0 |= BMCR_SPEED100;
1246                 if (np->mii_if.full_duplex)
1247                         reg0 |= BMCR_FULLDPLX;
1248                 printk(KERN_DEBUG "%s: Link forced to %sMbit %s-duplex\n",
1249                        dev->name,
1250                        np->speed100 ? "100" : "10",
1251                        np->mii_if.full_duplex ? "full" : "half");
1252         }
1253         mdio_write(dev, np->phys[0], MII_BMCR, reg0);
1254 }
1255
1256
1257 static void tx_timeout(struct net_device *dev)
1258 {
1259         struct netdev_private *np = netdev_priv(dev);
1260         void __iomem *ioaddr = np->base;
1261         int old_debug;
1262
1263         printk(KERN_WARNING "%s: Transmit timed out, status %#8.8x, "
1264                "resetting...\n", dev->name, (int) readl(ioaddr + IntrStatus));
1265
1266         /* Perhaps we should reinitialize the hardware here. */
1267
1268         /*
1269          * Stop and restart the interface.
1270          * Cheat and increase the debug level temporarily.
1271          */
1272         old_debug = debug;
1273         debug = 2;
1274         netdev_close(dev);
1275         netdev_open(dev);
1276         debug = old_debug;
1277
1278         /* Trigger an immediate transmit demand. */
1279
1280         dev->trans_start = jiffies;
1281         np->stats.tx_errors++;
1282         netif_wake_queue(dev);
1283 }
1284
1285
1286 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
1287 static void init_ring(struct net_device *dev)
1288 {
1289         struct netdev_private *np = netdev_priv(dev);
1290         int i;
1291
1292         np->cur_rx = np->cur_tx = np->reap_tx = 0;
1293         np->dirty_rx = np->dirty_tx = np->rx_done = np->tx_done = 0;
1294
1295         np->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
1296
1297         /* Fill in the Rx buffers.  Handle allocation failure gracefully. */
1298         for (i = 0; i < RX_RING_SIZE; i++) {
1299                 struct sk_buff *skb = dev_alloc_skb(np->rx_buf_sz);
1300                 np->rx_info[i].skb = skb;
1301                 if (skb == NULL)
1302                         break;
1303                 np->rx_info[i].mapping = pci_map_single(np->pci_dev, skb->data, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1304                 skb->dev = dev;                 /* Mark as being used by this device. */
1305                 /* Grrr, we cannot offset to correctly align the IP header. */
1306                 np->rx_ring[i].rxaddr = cpu_to_dma(np->rx_info[i].mapping | RxDescValid);
1307         }
1308         writew(i - 1, np->base + RxDescQIdx);
1309         np->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
1310
1311         /* Clear the remainder of the Rx buffer ring. */
1312         for (  ; i < RX_RING_SIZE; i++) {
1313                 np->rx_ring[i].rxaddr = 0;
1314                 np->rx_info[i].skb = NULL;
1315                 np->rx_info[i].mapping = 0;
1316         }
1317         /* Mark the last entry as wrapping the ring. */
1318         np->rx_ring[RX_RING_SIZE - 1].rxaddr |= cpu_to_dma(RxDescEndRing);
1319
1320         /* Clear the completion rings. */
1321         for (i = 0; i < DONE_Q_SIZE; i++) {
1322                 np->rx_done_q[i].status = 0;
1323                 np->tx_done_q[i].status = 0;
1324         }
1325
1326         for (i = 0; i < TX_RING_SIZE; i++)
1327                 memset(&np->tx_info[i], 0, sizeof(np->tx_info[i]));
1328
1329         return;
1330 }
1331
1332
1333 static int start_tx(struct sk_buff *skb, struct net_device *dev)
1334 {
1335         struct netdev_private *np = netdev_priv(dev);
1336         unsigned int entry;
1337         u32 status;
1338         int i;
1339
1340         /*
1341          * be cautious here, wrapping the queue has weird semantics
1342          * and we may not have enough slots even when it seems we do.
1343          */
1344         if ((np->cur_tx - np->dirty_tx) + skb_num_frags(skb) * 2 > TX_RING_SIZE) {
1345                 netif_stop_queue(dev);
1346                 return 1;
1347         }
1348
1349 #if defined(ZEROCOPY) && defined(HAS_BROKEN_FIRMWARE)
1350         if (skb->ip_summed == CHECKSUM_HW) {
1351                 skb = skb_padto(skb, (skb->len + PADDING_MASK) & ~PADDING_MASK);
1352                 if (skb == NULL)
1353                         return NETDEV_TX_OK;
1354         }
1355 #endif /* ZEROCOPY && HAS_BROKEN_FIRMWARE */
1356
1357         entry = np->cur_tx % TX_RING_SIZE;
1358         for (i = 0; i < skb_num_frags(skb); i++) {
1359                 int wrap_ring = 0;
1360                 status = TxDescID;
1361
1362                 if (i == 0) {
1363                         np->tx_info[entry].skb = skb;
1364                         status |= TxCRCEn;
1365                         if (entry >= TX_RING_SIZE - skb_num_frags(skb)) {
1366                                 status |= TxRingWrap;
1367                                 wrap_ring = 1;
1368                         }
1369                         if (np->reap_tx) {
1370                                 status |= TxDescIntr;
1371                                 np->reap_tx = 0;
1372                         }
1373                         if (skb->ip_summed == CHECKSUM_HW) {
1374                                 status |= TxCalTCP;
1375                                 np->stats.tx_compressed++;
1376                         }
1377                         status |= skb_first_frag_len(skb) | (skb_num_frags(skb) << 16);
1378
1379                         np->tx_info[entry].mapping =
1380                                 pci_map_single(np->pci_dev, skb->data, skb_first_frag_len(skb), PCI_DMA_TODEVICE);
1381                 } else {
1382                         skb_frag_t *this_frag = &skb_shinfo(skb)->frags[i - 1];
1383                         status |= this_frag->size;
1384                         np->tx_info[entry].mapping =
1385                                 pci_map_single(np->pci_dev, page_address(this_frag->page) + this_frag->page_offset, this_frag->size, PCI_DMA_TODEVICE);
1386                 }
1387
1388                 np->tx_ring[entry].addr = cpu_to_dma(np->tx_info[entry].mapping);
1389                 np->tx_ring[entry].status = cpu_to_le32(status);
1390                 if (debug > 3)
1391                         printk(KERN_DEBUG "%s: Tx #%d/#%d slot %d status %#8.8x.\n",
1392                                dev->name, np->cur_tx, np->dirty_tx,
1393                                entry, status);
1394                 if (wrap_ring) {
1395                         np->tx_info[entry].used_slots = TX_RING_SIZE - entry;
1396                         np->cur_tx += np->tx_info[entry].used_slots;
1397                         entry = 0;
1398                 } else {
1399                         np->tx_info[entry].used_slots = 1;
1400                         np->cur_tx += np->tx_info[entry].used_slots;
1401                         entry++;
1402                 }
1403                 /* scavenge the tx descriptors twice per TX_RING_SIZE */
1404                 if (np->cur_tx % (TX_RING_SIZE / 2) == 0)
1405                         np->reap_tx = 1;
1406         }
1407
1408         /* Non-x86: explicitly flush descriptor cache lines here. */
1409         /* Ensure all descriptors are written back before the transmit is
1410            initiated. - Jes */
1411         wmb();
1412
1413         /* Update the producer index. */
1414         writel(entry * (sizeof(starfire_tx_desc) / 8), np->base + TxProducerIdx);
1415
1416         /* 4 is arbitrary, but should be ok */
1417         if ((np->cur_tx - np->dirty_tx) + 4 > TX_RING_SIZE)
1418                 netif_stop_queue(dev);
1419
1420         dev->trans_start = jiffies;
1421
1422         return 0;
1423 }
1424
1425
1426 /* The interrupt handler does all of the Rx thread work and cleans up
1427    after the Tx thread. */
1428 static irqreturn_t intr_handler(int irq, void *dev_instance, struct pt_regs *rgs)
1429 {
1430         struct net_device *dev = dev_instance;
1431         struct netdev_private *np = netdev_priv(dev);
1432         void __iomem *ioaddr = np->base;
1433         int boguscnt = max_interrupt_work;
1434         int consumer;
1435         int tx_status;
1436         int handled = 0;
1437
1438         do {
1439                 u32 intr_status = readl(ioaddr + IntrClear);
1440
1441                 if (debug > 4)
1442                         printk(KERN_DEBUG "%s: Interrupt status %#8.8x.\n",
1443                                dev->name, intr_status);
1444
1445                 if (intr_status == 0 || intr_status == (u32) -1)
1446                         break;
1447
1448                 handled = 1;
1449
1450                 if (intr_status & (IntrRxDone | IntrRxEmpty))
1451                         netdev_rx(dev, ioaddr);
1452
1453                 /* Scavenge the skbuff list based on the Tx-done queue.
1454                    There are redundant checks here that may be cleaned up
1455                    after the driver has proven to be reliable. */
1456                 consumer = readl(ioaddr + TxConsumerIdx);
1457                 if (debug > 3)
1458                         printk(KERN_DEBUG "%s: Tx Consumer index is %d.\n",
1459                                dev->name, consumer);
1460
1461                 while ((tx_status = le32_to_cpu(np->tx_done_q[np->tx_done].status)) != 0) {
1462                         if (debug > 3)
1463                                 printk(KERN_DEBUG "%s: Tx completion #%d entry %d is %#8.8x.\n",
1464                                        dev->name, np->dirty_tx, np->tx_done, tx_status);
1465                         if ((tx_status & 0xe0000000) == 0xa0000000) {
1466                                 np->stats.tx_packets++;
1467                         } else if ((tx_status & 0xe0000000) == 0x80000000) {
1468                                 u16 entry = (tx_status & 0x7fff) / sizeof(starfire_tx_desc);
1469                                 struct sk_buff *skb = np->tx_info[entry].skb;
1470                                 np->tx_info[entry].skb = NULL;
1471                                 pci_unmap_single(np->pci_dev,
1472                                                  np->tx_info[entry].mapping,
1473                                                  skb_first_frag_len(skb),
1474                                                  PCI_DMA_TODEVICE);
1475                                 np->tx_info[entry].mapping = 0;
1476                                 np->dirty_tx += np->tx_info[entry].used_slots;
1477                                 entry = (entry + np->tx_info[entry].used_slots) % TX_RING_SIZE;
1478                                 {
1479                                         int i;
1480                                         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1481                                                 pci_unmap_single(np->pci_dev,
1482                                                                  np->tx_info[entry].mapping,
1483                                                                  skb_shinfo(skb)->frags[i].size,
1484                                                                  PCI_DMA_TODEVICE);
1485                                                 np->dirty_tx++;
1486                                                 entry++;
1487                                         }
1488                                 }
1489
1490                                 dev_kfree_skb_irq(skb);
1491                         }
1492                         np->tx_done_q[np->tx_done].status = 0;
1493                         np->tx_done = (np->tx_done + 1) % DONE_Q_SIZE;
1494                 }
1495                 writew(np->tx_done, ioaddr + CompletionQConsumerIdx + 2);
1496
1497                 if (netif_queue_stopped(dev) &&
1498                     (np->cur_tx - np->dirty_tx + 4 < TX_RING_SIZE)) {
1499                         /* The ring is no longer full, wake the queue. */
1500                         netif_wake_queue(dev);
1501                 }
1502
1503                 /* Stats overflow */
1504                 if (intr_status & IntrStatsMax)
1505                         get_stats(dev);
1506
1507                 /* Media change interrupt. */
1508                 if (intr_status & IntrLinkChange)
1509                         netdev_media_change(dev);
1510
1511                 /* Abnormal error summary/uncommon events handlers. */
1512                 if (intr_status & IntrAbnormalSummary)
1513                         netdev_error(dev, intr_status);
1514
1515                 if (--boguscnt < 0) {
1516                         if (debug > 1)
1517                                 printk(KERN_WARNING "%s: Too much work at interrupt, "
1518                                        "status=%#8.8x.\n",
1519                                        dev->name, intr_status);
1520                         break;
1521                 }
1522         } while (1);
1523
1524         if (debug > 4)
1525                 printk(KERN_DEBUG "%s: exiting interrupt, status=%#8.8x.\n",
1526                        dev->name, (int) readl(ioaddr + IntrStatus));
1527         return IRQ_RETVAL(handled);
1528 }
1529
1530
1531 /* This routine is logically part of the interrupt/poll handler, but separated
1532    for clarity, code sharing between NAPI/non-NAPI, and better register allocation. */
1533 static int __netdev_rx(struct net_device *dev, int *quota)
1534 {
1535         struct netdev_private *np = netdev_priv(dev);
1536         u32 desc_status;
1537         int retcode = 0;
1538
1539         /* If EOP is set on the next entry, it's a new packet. Send it up. */
1540         while ((desc_status = le32_to_cpu(np->rx_done_q[np->rx_done].status)) != 0) {
1541                 struct sk_buff *skb;
1542                 u16 pkt_len;
1543                 int entry;
1544                 rx_done_desc *desc = &np->rx_done_q[np->rx_done];
1545
1546                 if (debug > 4)
1547                         printk(KERN_DEBUG "  netdev_rx() status of %d was %#8.8x.\n", np->rx_done, desc_status);
1548                 if (!(desc_status & RxOK)) {
1549                         /* There was an error. */
1550                         if (debug > 2)
1551                                 printk(KERN_DEBUG "  netdev_rx() Rx error was %#8.8x.\n", desc_status);
1552                         np->stats.rx_errors++;
1553                         if (desc_status & RxFIFOErr)
1554                                 np->stats.rx_fifo_errors++;
1555                         goto next_rx;
1556                 }
1557
1558                 if (*quota <= 0) {      /* out of rx quota */
1559                         retcode = 1;
1560                         goto out;
1561                 }
1562                 (*quota)--;
1563
1564                 pkt_len = desc_status;  /* Implicitly Truncate */
1565                 entry = (desc_status >> 16) & 0x7ff;
1566
1567                 if (debug > 4)
1568                         printk(KERN_DEBUG "  netdev_rx() normal Rx pkt length %d, quota %d.\n", pkt_len, *quota);
1569                 /* Check if the packet is long enough to accept without copying
1570                    to a minimally-sized skbuff. */
1571                 if (pkt_len < rx_copybreak
1572                     && (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
1573                         skb->dev = dev;
1574                         skb_reserve(skb, 2);    /* 16 byte align the IP header */
1575                         pci_dma_sync_single_for_cpu(np->pci_dev,
1576                                                     np->rx_info[entry].mapping,
1577                                                     pkt_len, PCI_DMA_FROMDEVICE);
1578                         eth_copy_and_sum(skb, np->rx_info[entry].skb->data, pkt_len, 0);
1579                         pci_dma_sync_single_for_device(np->pci_dev,
1580                                                        np->rx_info[entry].mapping,
1581                                                        pkt_len, PCI_DMA_FROMDEVICE);
1582                         skb_put(skb, pkt_len);
1583                 } else {
1584                         pci_unmap_single(np->pci_dev, np->rx_info[entry].mapping, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1585                         skb = np->rx_info[entry].skb;
1586                         skb_put(skb, pkt_len);
1587                         np->rx_info[entry].skb = NULL;
1588                         np->rx_info[entry].mapping = 0;
1589                 }
1590 #ifndef final_version                   /* Remove after testing. */
1591                 /* You will want this info for the initial debug. */
1592                 if (debug > 5)
1593                         printk(KERN_DEBUG "  Rx data %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:"
1594                                "%2.2x %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x %2.2x%2.2x.\n",
1595                                skb->data[0], skb->data[1], skb->data[2], skb->data[3],
1596                                skb->data[4], skb->data[5], skb->data[6], skb->data[7],
1597                                skb->data[8], skb->data[9], skb->data[10],
1598                                skb->data[11], skb->data[12], skb->data[13]);
1599 #endif
1600
1601                 skb->protocol = eth_type_trans(skb, dev);
1602 #ifdef VLAN_SUPPORT
1603                 if (debug > 4)
1604                         printk(KERN_DEBUG "  netdev_rx() status2 of %d was %#4.4x.\n", np->rx_done, le16_to_cpu(desc->status2));
1605 #endif
1606                 if (le16_to_cpu(desc->status2) & 0x0100) {
1607                         skb->ip_summed = CHECKSUM_UNNECESSARY;
1608                         np->stats.rx_compressed++;
1609                 }
1610                 /*
1611                  * This feature doesn't seem to be working, at least
1612                  * with the two firmware versions I have. If the GFP sees
1613                  * an IP fragment, it either ignores it completely, or reports
1614                  * "bad checksum" on it.
1615                  *
1616                  * Maybe I missed something -- corrections are welcome.
1617                  * Until then, the printk stays. :-) -Ion
1618                  */
1619                 else if (le16_to_cpu(desc->status2) & 0x0040) {
1620                         skb->ip_summed = CHECKSUM_HW;
1621                         skb->csum = le16_to_cpu(desc->csum);
1622                         printk(KERN_DEBUG "%s: checksum_hw, status2 = %#x\n", dev->name, le16_to_cpu(desc->status2));
1623                 }
1624 #ifdef VLAN_SUPPORT
1625                 if (np->vlgrp && le16_to_cpu(desc->status2) & 0x0200) {
1626                         if (debug > 4)
1627                                 printk(KERN_DEBUG "  netdev_rx() vlanid = %d\n", le16_to_cpu(desc->vlanid));
1628                         /* vlan_netdev_receive_skb() expects a packet with the VLAN tag stripped out */
1629                         vlan_netdev_receive_skb(skb, np->vlgrp, le16_to_cpu(desc->vlanid) & VLAN_VID_MASK);
1630                 } else
1631 #endif /* VLAN_SUPPORT */
1632                         netdev_receive_skb(skb);
1633                 dev->last_rx = jiffies;
1634                 np->stats.rx_packets++;
1635
1636         next_rx:
1637                 np->cur_rx++;
1638                 desc->status = 0;
1639                 np->rx_done = (np->rx_done + 1) % DONE_Q_SIZE;
1640         }
1641         writew(np->rx_done, np->base + CompletionQConsumerIdx);
1642
1643  out:
1644         refill_rx_ring(dev);
1645         if (debug > 5)
1646                 printk(KERN_DEBUG "  exiting netdev_rx(): %d, status of %d was %#8.8x.\n",
1647                        retcode, np->rx_done, desc_status);
1648         return retcode;
1649 }
1650
1651
1652 #ifdef HAVE_NETDEV_POLL
1653 static int netdev_poll(struct net_device *dev, int *budget)
1654 {
1655         u32 intr_status;
1656         struct netdev_private *np = netdev_priv(dev);
1657         void __iomem *ioaddr = np->base;
1658         int retcode = 0, quota = dev->quota;
1659
1660         do {
1661                 writel(IntrRxDone | IntrRxEmpty, ioaddr + IntrClear);
1662
1663                 retcode = __netdev_rx(dev, &quota);
1664                 *budget -= (dev->quota - quota);
1665                 dev->quota = quota;
1666                 if (retcode)
1667                         goto out;
1668
1669                 intr_status = readl(ioaddr + IntrStatus);
1670         } while (intr_status & (IntrRxDone | IntrRxEmpty));
1671
1672         netif_rx_complete(dev);
1673         intr_status = readl(ioaddr + IntrEnable);
1674         intr_status |= IntrRxDone | IntrRxEmpty;
1675         writel(intr_status, ioaddr + IntrEnable);
1676
1677  out:
1678         if (debug > 5)
1679                 printk(KERN_DEBUG "  exiting netdev_poll(): %d.\n", retcode);
1680
1681         /* Restart Rx engine if stopped. */
1682         return retcode;
1683 }
1684 #endif /* HAVE_NETDEV_POLL */
1685
1686
1687 static void refill_rx_ring(struct net_device *dev)
1688 {
1689         struct netdev_private *np = netdev_priv(dev);
1690         struct sk_buff *skb;
1691         int entry = -1;
1692
1693         /* Refill the Rx ring buffers. */
1694         for (; np->cur_rx - np->dirty_rx > 0; np->dirty_rx++) {
1695                 entry = np->dirty_rx % RX_RING_SIZE;
1696                 if (np->rx_info[entry].skb == NULL) {
1697                         skb = dev_alloc_skb(np->rx_buf_sz);
1698                         np->rx_info[entry].skb = skb;
1699                         if (skb == NULL)
1700                                 break;  /* Better luck next round. */
1701                         np->rx_info[entry].mapping =
1702                                 pci_map_single(np->pci_dev, skb->data, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1703                         skb->dev = dev; /* Mark as being used by this device. */
1704                         np->rx_ring[entry].rxaddr =
1705                                 cpu_to_dma(np->rx_info[entry].mapping | RxDescValid);
1706                 }
1707                 if (entry == RX_RING_SIZE - 1)
1708                         np->rx_ring[entry].rxaddr |= cpu_to_dma(RxDescEndRing);
1709         }
1710         if (entry >= 0)
1711                 writew(entry, np->base + RxDescQIdx);
1712 }
1713
1714
1715 static void netdev_media_change(struct net_device *dev)
1716 {
1717         struct netdev_private *np = netdev_priv(dev);
1718         void __iomem *ioaddr = np->base;
1719         u16 reg0, reg1, reg4, reg5;
1720         u32 new_tx_mode;
1721         u32 new_intr_timer_ctrl;
1722
1723         /* reset status first */
1724         mdio_read(dev, np->phys[0], MII_BMCR);
1725         mdio_read(dev, np->phys[0], MII_BMSR);
1726
1727         reg0 = mdio_read(dev, np->phys[0], MII_BMCR);
1728         reg1 = mdio_read(dev, np->phys[0], MII_BMSR);
1729
1730         if (reg1 & BMSR_LSTATUS) {
1731                 /* link is up */
1732                 if (reg0 & BMCR_ANENABLE) {
1733                         /* autonegotiation is enabled */
1734                         reg4 = mdio_read(dev, np->phys[0], MII_ADVERTISE);
1735                         reg5 = mdio_read(dev, np->phys[0], MII_LPA);
1736                         if (reg4 & ADVERTISE_100FULL && reg5 & LPA_100FULL) {
1737                                 np->speed100 = 1;
1738                                 np->mii_if.full_duplex = 1;
1739                         } else if (reg4 & ADVERTISE_100HALF && reg5 & LPA_100HALF) {
1740                                 np->speed100 = 1;
1741                                 np->mii_if.full_duplex = 0;
1742                         } else if (reg4 & ADVERTISE_10FULL && reg5 & LPA_10FULL) {
1743                                 np->speed100 = 0;
1744                                 np->mii_if.full_duplex = 1;
1745                         } else {
1746                                 np->speed100 = 0;
1747                                 np->mii_if.full_duplex = 0;
1748                         }
1749                 } else {
1750                         /* autonegotiation is disabled */
1751                         if (reg0 & BMCR_SPEED100)
1752                                 np->speed100 = 1;
1753                         else
1754                                 np->speed100 = 0;
1755                         if (reg0 & BMCR_FULLDPLX)
1756                                 np->mii_if.full_duplex = 1;
1757                         else
1758                                 np->mii_if.full_duplex = 0;
1759                 }
1760                 netif_carrier_on(dev);
1761                 printk(KERN_DEBUG "%s: Link is up, running at %sMbit %s-duplex\n",
1762                        dev->name,
1763                        np->speed100 ? "100" : "10",
1764                        np->mii_if.full_duplex ? "full" : "half");
1765
1766                 new_tx_mode = np->tx_mode & ~FullDuplex;        /* duplex setting */
1767                 if (np->mii_if.full_duplex)
1768                         new_tx_mode |= FullDuplex;
1769                 if (np->tx_mode != new_tx_mode) {
1770                         np->tx_mode = new_tx_mode;
1771                         writel(np->tx_mode | MiiSoftReset, ioaddr + TxMode);
1772                         udelay(1000);
1773                         writel(np->tx_mode, ioaddr + TxMode);
1774                 }
1775
1776                 new_intr_timer_ctrl = np->intr_timer_ctrl & ~Timer10X;
1777                 if (np->speed100)
1778                         new_intr_timer_ctrl |= Timer10X;
1779                 if (np->intr_timer_ctrl != new_intr_timer_ctrl) {
1780                         np->intr_timer_ctrl = new_intr_timer_ctrl;
1781                         writel(new_intr_timer_ctrl, ioaddr + IntrTimerCtrl);
1782                 }
1783         } else {
1784                 netif_carrier_off(dev);
1785                 printk(KERN_DEBUG "%s: Link is down\n", dev->name);
1786         }
1787 }
1788
1789
1790 static void netdev_error(struct net_device *dev, int intr_status)
1791 {
1792         struct netdev_private *np = netdev_priv(dev);
1793
1794         /* Came close to underrunning the Tx FIFO, increase threshold. */
1795         if (intr_status & IntrTxDataLow) {
1796                 if (np->tx_threshold <= PKT_BUF_SZ / 16) {
1797                         writel(++np->tx_threshold, np->base + TxThreshold);
1798                         printk(KERN_NOTICE "%s: PCI bus congestion, increasing Tx FIFO threshold to %d bytes\n",
1799                                dev->name, np->tx_threshold * 16);
1800                 } else
1801                         printk(KERN_WARNING "%s: PCI Tx underflow -- adapter is probably malfunctioning\n", dev->name);
1802         }
1803         if (intr_status & IntrRxGFPDead) {
1804                 np->stats.rx_fifo_errors++;
1805                 np->stats.rx_errors++;
1806         }
1807         if (intr_status & (IntrNoTxCsum | IntrDMAErr)) {
1808                 np->stats.tx_fifo_errors++;
1809                 np->stats.tx_errors++;
1810         }
1811         if ((intr_status & ~(IntrNormalMask | IntrAbnormalSummary | IntrLinkChange | IntrStatsMax | IntrTxDataLow | IntrRxGFPDead | IntrNoTxCsum | IntrPCIPad)) && debug)
1812                 printk(KERN_ERR "%s: Something Wicked happened! %#8.8x.\n",
1813                        dev->name, intr_status);
1814 }
1815
1816
1817 static struct net_device_stats *get_stats(struct net_device *dev)
1818 {
1819         struct netdev_private *np = netdev_priv(dev);
1820         void __iomem *ioaddr = np->base;
1821
1822         /* This adapter architecture needs no SMP locks. */
1823         np->stats.tx_bytes = readl(ioaddr + 0x57010);
1824         np->stats.rx_bytes = readl(ioaddr + 0x57044);
1825         np->stats.tx_packets = readl(ioaddr + 0x57000);
1826         np->stats.tx_aborted_errors =
1827                 readl(ioaddr + 0x57024) + readl(ioaddr + 0x57028);
1828         np->stats.tx_window_errors = readl(ioaddr + 0x57018);
1829         np->stats.collisions =
1830                 readl(ioaddr + 0x57004) + readl(ioaddr + 0x57008);
1831
1832         /* The chip only need report frame silently dropped. */
1833         np->stats.rx_dropped += readw(ioaddr + RxDMAStatus);
1834         writew(0, ioaddr + RxDMAStatus);
1835         np->stats.rx_crc_errors = readl(ioaddr + 0x5703C);
1836         np->stats.rx_frame_errors = readl(ioaddr + 0x57040);
1837         np->stats.rx_length_errors = readl(ioaddr + 0x57058);
1838         np->stats.rx_missed_errors = readl(ioaddr + 0x5707C);
1839
1840         return &np->stats;
1841 }
1842
1843
1844 static void set_rx_mode(struct net_device *dev)
1845 {
1846         struct netdev_private *np = netdev_priv(dev);
1847         void __iomem *ioaddr = np->base;
1848         u32 rx_mode = MinVLANPrio;
1849         struct dev_mc_list *mclist;
1850         int i;
1851 #ifdef VLAN_SUPPORT
1852
1853         rx_mode |= VlanMode;
1854         if (np->vlgrp) {
1855                 int vlan_count = 0;
1856                 void __iomem *filter_addr = ioaddr + HashTable + 8;
1857                 for (i = 0; i < VLAN_VID_MASK; i++) {
1858                         if (np->vlgrp->vlan_devices[i]) {
1859                                 if (vlan_count >= 32)
1860                                         break;
1861                                 writew(cpu_to_be16(i), filter_addr);
1862                                 filter_addr += 16;
1863                                 vlan_count++;
1864                         }
1865                 }
1866                 if (i == VLAN_VID_MASK) {
1867                         rx_mode |= PerfectFilterVlan;
1868                         while (vlan_count < 32) {
1869                                 writew(0, filter_addr);
1870                                 filter_addr += 16;
1871                                 vlan_count++;
1872                         }
1873                 }
1874         }
1875 #endif /* VLAN_SUPPORT */
1876
1877         if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
1878                 rx_mode |= AcceptAll;
1879         } else if ((dev->mc_count > multicast_filter_limit)
1880                    || (dev->flags & IFF_ALLMULTI)) {
1881                 /* Too many to match, or accept all multicasts. */
1882                 rx_mode |= AcceptBroadcast|AcceptAllMulticast|PerfectFilter;
1883         } else if (dev->mc_count <= 14) {
1884                 /* Use the 16 element perfect filter, skip first two entries. */
1885                 void __iomem *filter_addr = ioaddr + PerfFilterTable + 2 * 16;
1886                 u16 *eaddrs;
1887                 for (i = 2, mclist = dev->mc_list; mclist && i < dev->mc_count + 2;
1888                      i++, mclist = mclist->next) {
1889                         eaddrs = (u16 *)mclist->dmi_addr;
1890                         writew(cpu_to_be16(eaddrs[2]), filter_addr); filter_addr += 4;
1891                         writew(cpu_to_be16(eaddrs[1]), filter_addr); filter_addr += 4;
1892                         writew(cpu_to_be16(eaddrs[0]), filter_addr); filter_addr += 8;
1893                 }
1894                 eaddrs = (u16 *)dev->dev_addr;
1895                 while (i++ < 16) {
1896                         writew(cpu_to_be16(eaddrs[0]), filter_addr); filter_addr += 4;
1897                         writew(cpu_to_be16(eaddrs[1]), filter_addr); filter_addr += 4;
1898                         writew(cpu_to_be16(eaddrs[2]), filter_addr); filter_addr += 8;
1899                 }
1900                 rx_mode |= AcceptBroadcast|PerfectFilter;
1901         } else {
1902                 /* Must use a multicast hash table. */
1903                 void __iomem *filter_addr;
1904                 u16 *eaddrs;
1905                 u16 mc_filter[32] __attribute__ ((aligned(sizeof(long))));      /* Multicast hash filter */
1906
1907                 memset(mc_filter, 0, sizeof(mc_filter));
1908                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1909                      i++, mclist = mclist->next) {
1910                         /* The chip uses the upper 9 CRC bits
1911                            as index into the hash table */
1912                         int bit_nr = ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 23;
1913                         __u32 *fptr = (__u32 *) &mc_filter[(bit_nr >> 4) & ~1];
1914
1915                         *fptr |= cpu_to_le32(1 << (bit_nr & 31));
1916                 }
1917                 /* Clear the perfect filter list, skip first two entries. */
1918                 filter_addr = ioaddr + PerfFilterTable + 2 * 16;
1919                 eaddrs = (u16 *)dev->dev_addr;
1920                 for (i = 2; i < 16; i++) {
1921                         writew(cpu_to_be16(eaddrs[0]), filter_addr); filter_addr += 4;
1922                         writew(cpu_to_be16(eaddrs[1]), filter_addr); filter_addr += 4;
1923                         writew(cpu_to_be16(eaddrs[2]), filter_addr); filter_addr += 8;
1924                 }
1925                 for (filter_addr = ioaddr + HashTable, i = 0; i < 32; filter_addr+= 16, i++)
1926                         writew(mc_filter[i], filter_addr);
1927                 rx_mode |= AcceptBroadcast|PerfectFilter|HashFilter;
1928         }
1929         writel(rx_mode, ioaddr + RxFilterMode);
1930 }
1931
1932 static int check_if_running(struct net_device *dev)
1933 {
1934         if (!netif_running(dev))
1935                 return -EINVAL;
1936         return 0;
1937 }
1938
1939 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1940 {
1941         struct netdev_private *np = netdev_priv(dev);
1942         strcpy(info->driver, DRV_NAME);
1943         strcpy(info->version, DRV_VERSION);
1944         strcpy(info->bus_info, pci_name(np->pci_dev));
1945 }
1946
1947 static int get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1948 {
1949         struct netdev_private *np = netdev_priv(dev);
1950         spin_lock_irq(&np->lock);
1951         mii_ethtool_gset(&np->mii_if, ecmd);
1952         spin_unlock_irq(&np->lock);
1953         return 0;
1954 }
1955
1956 static int set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1957 {
1958         struct netdev_private *np = netdev_priv(dev);
1959         int res;
1960         spin_lock_irq(&np->lock);
1961         res = mii_ethtool_sset(&np->mii_if, ecmd);
1962         spin_unlock_irq(&np->lock);
1963         check_duplex(dev);
1964         return res;
1965 }
1966
1967 static int nway_reset(struct net_device *dev)
1968 {
1969         struct netdev_private *np = netdev_priv(dev);
1970         return mii_nway_restart(&np->mii_if);
1971 }
1972
1973 static u32 get_link(struct net_device *dev)
1974 {
1975         struct netdev_private *np = netdev_priv(dev);
1976         return mii_link_ok(&np->mii_if);
1977 }
1978
1979 static u32 get_msglevel(struct net_device *dev)
1980 {
1981         return debug;
1982 }
1983
1984 static void set_msglevel(struct net_device *dev, u32 val)
1985 {
1986         debug = val;
1987 }
1988
1989 static struct ethtool_ops ethtool_ops = {
1990         .begin = check_if_running,
1991         .get_drvinfo = get_drvinfo,
1992         .get_settings = get_settings,
1993         .set_settings = set_settings,
1994         .nway_reset = nway_reset,
1995         .get_link = get_link,
1996         .get_msglevel = get_msglevel,
1997         .set_msglevel = set_msglevel,
1998 };
1999
2000 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2001 {
2002         struct netdev_private *np = netdev_priv(dev);
2003         struct mii_ioctl_data *data = if_mii(rq);
2004         int rc;
2005
2006         if (!netif_running(dev))
2007                 return -EINVAL;
2008
2009         spin_lock_irq(&np->lock);
2010         rc = generic_mii_ioctl(&np->mii_if, data, cmd, NULL);
2011         spin_unlock_irq(&np->lock);
2012
2013         if ((cmd == SIOCSMIIREG) && (data->phy_id == np->phys[0]))
2014                 check_duplex(dev);
2015
2016         return rc;
2017 }
2018
2019 static int netdev_close(struct net_device *dev)
2020 {
2021         struct netdev_private *np = netdev_priv(dev);
2022         void __iomem *ioaddr = np->base;
2023         int i;
2024
2025         netif_stop_queue(dev);
2026
2027         if (debug > 1) {
2028                 printk(KERN_DEBUG "%s: Shutting down ethercard, Intr status %#8.8x.\n",
2029                            dev->name, (int) readl(ioaddr + IntrStatus));
2030                 printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d, Rx %d / %d.\n",
2031                        dev->name, np->cur_tx, np->dirty_tx,
2032                        np->cur_rx, np->dirty_rx);
2033         }
2034
2035         /* Disable interrupts by clearing the interrupt mask. */
2036         writel(0, ioaddr + IntrEnable);
2037
2038         /* Stop the chip's Tx and Rx processes. */
2039         writel(0, ioaddr + GenCtrl);
2040         readl(ioaddr + GenCtrl);
2041
2042         if (debug > 5) {
2043                 printk(KERN_DEBUG"  Tx ring at %#llx:\n",
2044                        (long long) np->tx_ring_dma);
2045                 for (i = 0; i < 8 /* TX_RING_SIZE is huge! */; i++)
2046                         printk(KERN_DEBUG " #%d desc. %#8.8x %#llx -> %#8.8x.\n",
2047                                i, le32_to_cpu(np->tx_ring[i].status),
2048                                (long long) dma_to_cpu(np->tx_ring[i].addr),
2049                                le32_to_cpu(np->tx_done_q[i].status));
2050                 printk(KERN_DEBUG "  Rx ring at %#llx -> %p:\n",
2051                        (long long) np->rx_ring_dma, np->rx_done_q);
2052                 if (np->rx_done_q)
2053                         for (i = 0; i < 8 /* RX_RING_SIZE */; i++) {
2054                                 printk(KERN_DEBUG " #%d desc. %#llx -> %#8.8x\n",
2055                                        i, (long long) dma_to_cpu(np->rx_ring[i].rxaddr), le32_to_cpu(np->rx_done_q[i].status));
2056                 }
2057         }
2058
2059         free_irq(dev->irq, dev);
2060
2061         /* Free all the skbuffs in the Rx queue. */
2062         for (i = 0; i < RX_RING_SIZE; i++) {
2063                 np->rx_ring[i].rxaddr = cpu_to_dma(0xBADF00D0); /* An invalid address. */
2064                 if (np->rx_info[i].skb != NULL) {
2065                         pci_unmap_single(np->pci_dev, np->rx_info[i].mapping, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
2066                         dev_kfree_skb(np->rx_info[i].skb);
2067                 }
2068                 np->rx_info[i].skb = NULL;
2069                 np->rx_info[i].mapping = 0;
2070         }
2071         for (i = 0; i < TX_RING_SIZE; i++) {
2072                 struct sk_buff *skb = np->tx_info[i].skb;
2073                 if (skb == NULL)
2074                         continue;
2075                 pci_unmap_single(np->pci_dev,
2076                                  np->tx_info[i].mapping,
2077                                  skb_first_frag_len(skb), PCI_DMA_TODEVICE);
2078                 np->tx_info[i].mapping = 0;
2079                 dev_kfree_skb(skb);
2080                 np->tx_info[i].skb = NULL;
2081         }
2082
2083         return 0;
2084 }
2085
2086
2087 static void __devexit starfire_remove_one (struct pci_dev *pdev)
2088 {
2089         struct net_device *dev = pci_get_drvdata(pdev);
2090         struct netdev_private *np = netdev_priv(dev);
2091
2092         if (!dev)
2093                 BUG();
2094
2095         unregister_netdev(dev);
2096
2097         if (np->queue_mem)
2098                 pci_free_consistent(pdev, np->queue_mem_size, np->queue_mem, np->queue_mem_dma);
2099
2100
2101         /* XXX: add wakeup code -- requires firmware for MagicPacket */
2102         pci_set_power_state(pdev, PCI_D3hot);   /* go to sleep in D3 mode */
2103         pci_disable_device(pdev);
2104
2105         iounmap(np->base);
2106         pci_release_regions(pdev);
2107
2108         pci_set_drvdata(pdev, NULL);
2109         free_netdev(dev);                       /* Will also free np!! */
2110 }
2111
2112
2113 static struct pci_driver starfire_driver = {
2114         .name           = DRV_NAME,
2115         .probe          = starfire_init_one,
2116         .remove         = __devexit_p(starfire_remove_one),
2117         .id_table       = starfire_pci_tbl,
2118 };
2119
2120
2121 static int __init starfire_init (void)
2122 {
2123 /* when a module, this is printed whether or not devices are found in probe */
2124 #ifdef MODULE
2125         printk(version);
2126 #ifdef HAVE_NETDEV_POLL
2127         printk(KERN_INFO DRV_NAME ": polling (NAPI) enabled\n");
2128 #else
2129         printk(KERN_INFO DRV_NAME ": polling (NAPI) disabled\n");
2130 #endif
2131 #endif
2132
2133         /* we can do this test only at run-time... sigh */
2134         if (sizeof(dma_addr_t) != sizeof(netdrv_addr_t)) {
2135                 printk("This driver has dma_addr_t issues, please send email to maintainer\n");
2136                 return -ENODEV;
2137         }
2138
2139         return pci_module_init (&starfire_driver);
2140 }
2141
2142
2143 static void __exit starfire_cleanup (void)
2144 {
2145         pci_unregister_driver (&starfire_driver);
2146 }
2147
2148
2149 module_init(starfire_init);
2150 module_exit(starfire_cleanup);
2151
2152
2153 /*
2154  * Local variables:
2155  *  c-basic-offset: 8
2156  *  tab-width: 8
2157  * End:
2158  */