]> pilppa.org Git - linux-2.6-omap-h63xx.git/blob - drivers/net/starfire.c
[PATCH] starfire: free_irq() on error path of netdev_open()
[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 == NULL) {
1095                         free_irq(dev->irq, dev);
1096                         return -ENOMEM;
1097                 }
1098
1099                 np->tx_done_q     = np->queue_mem;
1100                 np->tx_done_q_dma = np->queue_mem_dma;
1101                 np->rx_done_q     = (void *) np->tx_done_q + tx_done_q_size;
1102                 np->rx_done_q_dma = np->tx_done_q_dma + tx_done_q_size;
1103                 np->tx_ring       = (void *) np->rx_done_q + rx_done_q_size;
1104                 np->tx_ring_dma   = np->rx_done_q_dma + rx_done_q_size;
1105                 np->rx_ring       = (void *) np->tx_ring + tx_ring_size;
1106                 np->rx_ring_dma   = np->tx_ring_dma + tx_ring_size;
1107         }
1108
1109         /* Start with no carrier, it gets adjusted later */
1110         netif_carrier_off(dev);
1111         init_ring(dev);
1112         /* Set the size of the Rx buffers. */
1113         writel((np->rx_buf_sz << RxBufferLenShift) |
1114                (0 << RxMinDescrThreshShift) |
1115                RxPrefetchMode | RxVariableQ |
1116                RX_Q_ENTRIES |
1117                RX_DESC_Q_ADDR_SIZE | RX_DESC_ADDR_SIZE |
1118                RxDescSpace4,
1119                ioaddr + RxDescQCtrl);
1120
1121         /* Set up the Rx DMA controller. */
1122         writel(RxChecksumIgnore |
1123                (0 << RxEarlyIntThreshShift) |
1124                (6 << RxHighPrioThreshShift) |
1125                ((DMA_BURST_SIZE / 32) << RxBurstSizeShift),
1126                ioaddr + RxDMACtrl);
1127
1128         /* Set Tx descriptor */
1129         writel((2 << TxHiPriFIFOThreshShift) |
1130                (0 << TxPadLenShift) |
1131                ((DMA_BURST_SIZE / 32) << TxDMABurstSizeShift) |
1132                TX_DESC_Q_ADDR_SIZE |
1133                TX_DESC_SPACING | TX_DESC_TYPE,
1134                ioaddr + TxDescCtrl);
1135
1136         writel( (np->queue_mem_dma >> 16) >> 16, ioaddr + RxDescQHiAddr);
1137         writel( (np->queue_mem_dma >> 16) >> 16, ioaddr + TxRingHiAddr);
1138         writel( (np->queue_mem_dma >> 16) >> 16, ioaddr + CompletionHiAddr);
1139         writel(np->rx_ring_dma, ioaddr + RxDescQAddr);
1140         writel(np->tx_ring_dma, ioaddr + TxRingPtr);
1141
1142         writel(np->tx_done_q_dma, ioaddr + TxCompletionAddr);
1143         writel(np->rx_done_q_dma |
1144                RxComplType |
1145                (0 << RxComplThreshShift),
1146                ioaddr + RxCompletionAddr);
1147
1148         if (debug > 1)
1149                 printk(KERN_DEBUG "%s: Filling in the station address.\n", dev->name);
1150
1151         /* Fill both the Tx SA register and the Rx perfect filter. */
1152         for (i = 0; i < 6; i++)
1153                 writeb(dev->dev_addr[i], ioaddr + TxStationAddr + 5 - i);
1154         /* The first entry is special because it bypasses the VLAN filter.
1155            Don't use it. */
1156         writew(0, ioaddr + PerfFilterTable);
1157         writew(0, ioaddr + PerfFilterTable + 4);
1158         writew(0, ioaddr + PerfFilterTable + 8);
1159         for (i = 1; i < 16; i++) {
1160                 u16 *eaddrs = (u16 *)dev->dev_addr;
1161                 void __iomem *setup_frm = ioaddr + PerfFilterTable + i * 16;
1162                 writew(cpu_to_be16(eaddrs[2]), setup_frm); setup_frm += 4;
1163                 writew(cpu_to_be16(eaddrs[1]), setup_frm); setup_frm += 4;
1164                 writew(cpu_to_be16(eaddrs[0]), setup_frm); setup_frm += 8;
1165         }
1166
1167         /* Initialize other registers. */
1168         /* Configure the PCI bus bursts and FIFO thresholds. */
1169         np->tx_mode = TxFlowEnable|RxFlowEnable|PadEnable;      /* modified when link is up. */
1170         writel(MiiSoftReset | np->tx_mode, ioaddr + TxMode);
1171         udelay(1000);
1172         writel(np->tx_mode, ioaddr + TxMode);
1173         np->tx_threshold = 4;
1174         writel(np->tx_threshold, ioaddr + TxThreshold);
1175
1176         writel(np->intr_timer_ctrl, ioaddr + IntrTimerCtrl);
1177
1178         netif_start_queue(dev);
1179
1180         if (debug > 1)
1181                 printk(KERN_DEBUG "%s: Setting the Rx and Tx modes.\n", dev->name);
1182         set_rx_mode(dev);
1183
1184         np->mii_if.advertising = mdio_read(dev, np->phys[0], MII_ADVERTISE);
1185         check_duplex(dev);
1186
1187         /* Enable GPIO interrupts on link change */
1188         writel(0x0f00ff00, ioaddr + GPIOCtrl);
1189
1190         /* Set the interrupt mask */
1191         writel(IntrRxDone | IntrRxEmpty | IntrDMAErr |
1192                IntrTxDMADone | IntrStatsMax | IntrLinkChange |
1193                IntrRxGFPDead | IntrNoTxCsum | IntrTxBadID,
1194                ioaddr + IntrEnable);
1195         /* Enable PCI interrupts. */
1196         writel(0x00800000 | readl(ioaddr + PCIDeviceConfig),
1197                ioaddr + PCIDeviceConfig);
1198
1199 #ifdef VLAN_SUPPORT
1200         /* Set VLAN type to 802.1q */
1201         writel(ETH_P_8021Q, ioaddr + VlanType);
1202 #endif /* VLAN_SUPPORT */
1203
1204         /* Load Rx/Tx firmware into the frame processors */
1205         for (i = 0; i < FIRMWARE_RX_SIZE * 2; i++)
1206                 writel(firmware_rx[i], ioaddr + RxGfpMem + i * 4);
1207         for (i = 0; i < FIRMWARE_TX_SIZE * 2; i++)
1208                 writel(firmware_tx[i], ioaddr + TxGfpMem + i * 4);
1209         if (enable_hw_cksum)
1210                 /* Enable the Rx and Tx units, and the Rx/Tx frame processors. */
1211                 writel(TxEnable|TxGFPEnable|RxEnable|RxGFPEnable, ioaddr + GenCtrl);
1212         else
1213                 /* Enable the Rx and Tx units only. */
1214                 writel(TxEnable|RxEnable, ioaddr + GenCtrl);
1215
1216         if (debug > 1)
1217                 printk(KERN_DEBUG "%s: Done netdev_open().\n",
1218                        dev->name);
1219
1220         return 0;
1221 }
1222
1223
1224 static void check_duplex(struct net_device *dev)
1225 {
1226         struct netdev_private *np = netdev_priv(dev);
1227         u16 reg0;
1228         int silly_count = 1000;
1229
1230         mdio_write(dev, np->phys[0], MII_ADVERTISE, np->mii_if.advertising);
1231         mdio_write(dev, np->phys[0], MII_BMCR, BMCR_RESET);
1232         udelay(500);
1233         while (--silly_count && mdio_read(dev, np->phys[0], MII_BMCR) & BMCR_RESET)
1234                 /* do nothing */;
1235         if (!silly_count) {
1236                 printk("%s: MII reset failed!\n", dev->name);
1237                 return;
1238         }
1239
1240         reg0 = mdio_read(dev, np->phys[0], MII_BMCR);
1241
1242         if (!np->mii_if.force_media) {
1243                 reg0 |= BMCR_ANENABLE | BMCR_ANRESTART;
1244         } else {
1245                 reg0 &= ~(BMCR_ANENABLE | BMCR_ANRESTART);
1246                 if (np->speed100)
1247                         reg0 |= BMCR_SPEED100;
1248                 if (np->mii_if.full_duplex)
1249                         reg0 |= BMCR_FULLDPLX;
1250                 printk(KERN_DEBUG "%s: Link forced to %sMbit %s-duplex\n",
1251                        dev->name,
1252                        np->speed100 ? "100" : "10",
1253                        np->mii_if.full_duplex ? "full" : "half");
1254         }
1255         mdio_write(dev, np->phys[0], MII_BMCR, reg0);
1256 }
1257
1258
1259 static void tx_timeout(struct net_device *dev)
1260 {
1261         struct netdev_private *np = netdev_priv(dev);
1262         void __iomem *ioaddr = np->base;
1263         int old_debug;
1264
1265         printk(KERN_WARNING "%s: Transmit timed out, status %#8.8x, "
1266                "resetting...\n", dev->name, (int) readl(ioaddr + IntrStatus));
1267
1268         /* Perhaps we should reinitialize the hardware here. */
1269
1270         /*
1271          * Stop and restart the interface.
1272          * Cheat and increase the debug level temporarily.
1273          */
1274         old_debug = debug;
1275         debug = 2;
1276         netdev_close(dev);
1277         netdev_open(dev);
1278         debug = old_debug;
1279
1280         /* Trigger an immediate transmit demand. */
1281
1282         dev->trans_start = jiffies;
1283         np->stats.tx_errors++;
1284         netif_wake_queue(dev);
1285 }
1286
1287
1288 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
1289 static void init_ring(struct net_device *dev)
1290 {
1291         struct netdev_private *np = netdev_priv(dev);
1292         int i;
1293
1294         np->cur_rx = np->cur_tx = np->reap_tx = 0;
1295         np->dirty_rx = np->dirty_tx = np->rx_done = np->tx_done = 0;
1296
1297         np->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
1298
1299         /* Fill in the Rx buffers.  Handle allocation failure gracefully. */
1300         for (i = 0; i < RX_RING_SIZE; i++) {
1301                 struct sk_buff *skb = dev_alloc_skb(np->rx_buf_sz);
1302                 np->rx_info[i].skb = skb;
1303                 if (skb == NULL)
1304                         break;
1305                 np->rx_info[i].mapping = pci_map_single(np->pci_dev, skb->data, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1306                 skb->dev = dev;                 /* Mark as being used by this device. */
1307                 /* Grrr, we cannot offset to correctly align the IP header. */
1308                 np->rx_ring[i].rxaddr = cpu_to_dma(np->rx_info[i].mapping | RxDescValid);
1309         }
1310         writew(i - 1, np->base + RxDescQIdx);
1311         np->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
1312
1313         /* Clear the remainder of the Rx buffer ring. */
1314         for (  ; i < RX_RING_SIZE; i++) {
1315                 np->rx_ring[i].rxaddr = 0;
1316                 np->rx_info[i].skb = NULL;
1317                 np->rx_info[i].mapping = 0;
1318         }
1319         /* Mark the last entry as wrapping the ring. */
1320         np->rx_ring[RX_RING_SIZE - 1].rxaddr |= cpu_to_dma(RxDescEndRing);
1321
1322         /* Clear the completion rings. */
1323         for (i = 0; i < DONE_Q_SIZE; i++) {
1324                 np->rx_done_q[i].status = 0;
1325                 np->tx_done_q[i].status = 0;
1326         }
1327
1328         for (i = 0; i < TX_RING_SIZE; i++)
1329                 memset(&np->tx_info[i], 0, sizeof(np->tx_info[i]));
1330
1331         return;
1332 }
1333
1334
1335 static int start_tx(struct sk_buff *skb, struct net_device *dev)
1336 {
1337         struct netdev_private *np = netdev_priv(dev);
1338         unsigned int entry;
1339         u32 status;
1340         int i;
1341
1342         /*
1343          * be cautious here, wrapping the queue has weird semantics
1344          * and we may not have enough slots even when it seems we do.
1345          */
1346         if ((np->cur_tx - np->dirty_tx) + skb_num_frags(skb) * 2 > TX_RING_SIZE) {
1347                 netif_stop_queue(dev);
1348                 return 1;
1349         }
1350
1351 #if defined(ZEROCOPY) && defined(HAS_BROKEN_FIRMWARE)
1352         if (skb->ip_summed == CHECKSUM_HW) {
1353                 skb = skb_padto(skb, (skb->len + PADDING_MASK) & ~PADDING_MASK);
1354                 if (skb == NULL)
1355                         return NETDEV_TX_OK;
1356         }
1357 #endif /* ZEROCOPY && HAS_BROKEN_FIRMWARE */
1358
1359         entry = np->cur_tx % TX_RING_SIZE;
1360         for (i = 0; i < skb_num_frags(skb); i++) {
1361                 int wrap_ring = 0;
1362                 status = TxDescID;
1363
1364                 if (i == 0) {
1365                         np->tx_info[entry].skb = skb;
1366                         status |= TxCRCEn;
1367                         if (entry >= TX_RING_SIZE - skb_num_frags(skb)) {
1368                                 status |= TxRingWrap;
1369                                 wrap_ring = 1;
1370                         }
1371                         if (np->reap_tx) {
1372                                 status |= TxDescIntr;
1373                                 np->reap_tx = 0;
1374                         }
1375                         if (skb->ip_summed == CHECKSUM_HW) {
1376                                 status |= TxCalTCP;
1377                                 np->stats.tx_compressed++;
1378                         }
1379                         status |= skb_first_frag_len(skb) | (skb_num_frags(skb) << 16);
1380
1381                         np->tx_info[entry].mapping =
1382                                 pci_map_single(np->pci_dev, skb->data, skb_first_frag_len(skb), PCI_DMA_TODEVICE);
1383                 } else {
1384                         skb_frag_t *this_frag = &skb_shinfo(skb)->frags[i - 1];
1385                         status |= this_frag->size;
1386                         np->tx_info[entry].mapping =
1387                                 pci_map_single(np->pci_dev, page_address(this_frag->page) + this_frag->page_offset, this_frag->size, PCI_DMA_TODEVICE);
1388                 }
1389
1390                 np->tx_ring[entry].addr = cpu_to_dma(np->tx_info[entry].mapping);
1391                 np->tx_ring[entry].status = cpu_to_le32(status);
1392                 if (debug > 3)
1393                         printk(KERN_DEBUG "%s: Tx #%d/#%d slot %d status %#8.8x.\n",
1394                                dev->name, np->cur_tx, np->dirty_tx,
1395                                entry, status);
1396                 if (wrap_ring) {
1397                         np->tx_info[entry].used_slots = TX_RING_SIZE - entry;
1398                         np->cur_tx += np->tx_info[entry].used_slots;
1399                         entry = 0;
1400                 } else {
1401                         np->tx_info[entry].used_slots = 1;
1402                         np->cur_tx += np->tx_info[entry].used_slots;
1403                         entry++;
1404                 }
1405                 /* scavenge the tx descriptors twice per TX_RING_SIZE */
1406                 if (np->cur_tx % (TX_RING_SIZE / 2) == 0)
1407                         np->reap_tx = 1;
1408         }
1409
1410         /* Non-x86: explicitly flush descriptor cache lines here. */
1411         /* Ensure all descriptors are written back before the transmit is
1412            initiated. - Jes */
1413         wmb();
1414
1415         /* Update the producer index. */
1416         writel(entry * (sizeof(starfire_tx_desc) / 8), np->base + TxProducerIdx);
1417
1418         /* 4 is arbitrary, but should be ok */
1419         if ((np->cur_tx - np->dirty_tx) + 4 > TX_RING_SIZE)
1420                 netif_stop_queue(dev);
1421
1422         dev->trans_start = jiffies;
1423
1424         return 0;
1425 }
1426
1427
1428 /* The interrupt handler does all of the Rx thread work and cleans up
1429    after the Tx thread. */
1430 static irqreturn_t intr_handler(int irq, void *dev_instance, struct pt_regs *rgs)
1431 {
1432         struct net_device *dev = dev_instance;
1433         struct netdev_private *np = netdev_priv(dev);
1434         void __iomem *ioaddr = np->base;
1435         int boguscnt = max_interrupt_work;
1436         int consumer;
1437         int tx_status;
1438         int handled = 0;
1439
1440         do {
1441                 u32 intr_status = readl(ioaddr + IntrClear);
1442
1443                 if (debug > 4)
1444                         printk(KERN_DEBUG "%s: Interrupt status %#8.8x.\n",
1445                                dev->name, intr_status);
1446
1447                 if (intr_status == 0 || intr_status == (u32) -1)
1448                         break;
1449
1450                 handled = 1;
1451
1452                 if (intr_status & (IntrRxDone | IntrRxEmpty))
1453                         netdev_rx(dev, ioaddr);
1454
1455                 /* Scavenge the skbuff list based on the Tx-done queue.
1456                    There are redundant checks here that may be cleaned up
1457                    after the driver has proven to be reliable. */
1458                 consumer = readl(ioaddr + TxConsumerIdx);
1459                 if (debug > 3)
1460                         printk(KERN_DEBUG "%s: Tx Consumer index is %d.\n",
1461                                dev->name, consumer);
1462
1463                 while ((tx_status = le32_to_cpu(np->tx_done_q[np->tx_done].status)) != 0) {
1464                         if (debug > 3)
1465                                 printk(KERN_DEBUG "%s: Tx completion #%d entry %d is %#8.8x.\n",
1466                                        dev->name, np->dirty_tx, np->tx_done, tx_status);
1467                         if ((tx_status & 0xe0000000) == 0xa0000000) {
1468                                 np->stats.tx_packets++;
1469                         } else if ((tx_status & 0xe0000000) == 0x80000000) {
1470                                 u16 entry = (tx_status & 0x7fff) / sizeof(starfire_tx_desc);
1471                                 struct sk_buff *skb = np->tx_info[entry].skb;
1472                                 np->tx_info[entry].skb = NULL;
1473                                 pci_unmap_single(np->pci_dev,
1474                                                  np->tx_info[entry].mapping,
1475                                                  skb_first_frag_len(skb),
1476                                                  PCI_DMA_TODEVICE);
1477                                 np->tx_info[entry].mapping = 0;
1478                                 np->dirty_tx += np->tx_info[entry].used_slots;
1479                                 entry = (entry + np->tx_info[entry].used_slots) % TX_RING_SIZE;
1480                                 {
1481                                         int i;
1482                                         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1483                                                 pci_unmap_single(np->pci_dev,
1484                                                                  np->tx_info[entry].mapping,
1485                                                                  skb_shinfo(skb)->frags[i].size,
1486                                                                  PCI_DMA_TODEVICE);
1487                                                 np->dirty_tx++;
1488                                                 entry++;
1489                                         }
1490                                 }
1491
1492                                 dev_kfree_skb_irq(skb);
1493                         }
1494                         np->tx_done_q[np->tx_done].status = 0;
1495                         np->tx_done = (np->tx_done + 1) % DONE_Q_SIZE;
1496                 }
1497                 writew(np->tx_done, ioaddr + CompletionQConsumerIdx + 2);
1498
1499                 if (netif_queue_stopped(dev) &&
1500                     (np->cur_tx - np->dirty_tx + 4 < TX_RING_SIZE)) {
1501                         /* The ring is no longer full, wake the queue. */
1502                         netif_wake_queue(dev);
1503                 }
1504
1505                 /* Stats overflow */
1506                 if (intr_status & IntrStatsMax)
1507                         get_stats(dev);
1508
1509                 /* Media change interrupt. */
1510                 if (intr_status & IntrLinkChange)
1511                         netdev_media_change(dev);
1512
1513                 /* Abnormal error summary/uncommon events handlers. */
1514                 if (intr_status & IntrAbnormalSummary)
1515                         netdev_error(dev, intr_status);
1516
1517                 if (--boguscnt < 0) {
1518                         if (debug > 1)
1519                                 printk(KERN_WARNING "%s: Too much work at interrupt, "
1520                                        "status=%#8.8x.\n",
1521                                        dev->name, intr_status);
1522                         break;
1523                 }
1524         } while (1);
1525
1526         if (debug > 4)
1527                 printk(KERN_DEBUG "%s: exiting interrupt, status=%#8.8x.\n",
1528                        dev->name, (int) readl(ioaddr + IntrStatus));
1529         return IRQ_RETVAL(handled);
1530 }
1531
1532
1533 /* This routine is logically part of the interrupt/poll handler, but separated
1534    for clarity, code sharing between NAPI/non-NAPI, and better register allocation. */
1535 static int __netdev_rx(struct net_device *dev, int *quota)
1536 {
1537         struct netdev_private *np = netdev_priv(dev);
1538         u32 desc_status;
1539         int retcode = 0;
1540
1541         /* If EOP is set on the next entry, it's a new packet. Send it up. */
1542         while ((desc_status = le32_to_cpu(np->rx_done_q[np->rx_done].status)) != 0) {
1543                 struct sk_buff *skb;
1544                 u16 pkt_len;
1545                 int entry;
1546                 rx_done_desc *desc = &np->rx_done_q[np->rx_done];
1547
1548                 if (debug > 4)
1549                         printk(KERN_DEBUG "  netdev_rx() status of %d was %#8.8x.\n", np->rx_done, desc_status);
1550                 if (!(desc_status & RxOK)) {
1551                         /* There was an error. */
1552                         if (debug > 2)
1553                                 printk(KERN_DEBUG "  netdev_rx() Rx error was %#8.8x.\n", desc_status);
1554                         np->stats.rx_errors++;
1555                         if (desc_status & RxFIFOErr)
1556                                 np->stats.rx_fifo_errors++;
1557                         goto next_rx;
1558                 }
1559
1560                 if (*quota <= 0) {      /* out of rx quota */
1561                         retcode = 1;
1562                         goto out;
1563                 }
1564                 (*quota)--;
1565
1566                 pkt_len = desc_status;  /* Implicitly Truncate */
1567                 entry = (desc_status >> 16) & 0x7ff;
1568
1569                 if (debug > 4)
1570                         printk(KERN_DEBUG "  netdev_rx() normal Rx pkt length %d, quota %d.\n", pkt_len, *quota);
1571                 /* Check if the packet is long enough to accept without copying
1572                    to a minimally-sized skbuff. */
1573                 if (pkt_len < rx_copybreak
1574                     && (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
1575                         skb->dev = dev;
1576                         skb_reserve(skb, 2);    /* 16 byte align the IP header */
1577                         pci_dma_sync_single_for_cpu(np->pci_dev,
1578                                                     np->rx_info[entry].mapping,
1579                                                     pkt_len, PCI_DMA_FROMDEVICE);
1580                         eth_copy_and_sum(skb, np->rx_info[entry].skb->data, pkt_len, 0);
1581                         pci_dma_sync_single_for_device(np->pci_dev,
1582                                                        np->rx_info[entry].mapping,
1583                                                        pkt_len, PCI_DMA_FROMDEVICE);
1584                         skb_put(skb, pkt_len);
1585                 } else {
1586                         pci_unmap_single(np->pci_dev, np->rx_info[entry].mapping, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1587                         skb = np->rx_info[entry].skb;
1588                         skb_put(skb, pkt_len);
1589                         np->rx_info[entry].skb = NULL;
1590                         np->rx_info[entry].mapping = 0;
1591                 }
1592 #ifndef final_version                   /* Remove after testing. */
1593                 /* You will want this info for the initial debug. */
1594                 if (debug > 5)
1595                         printk(KERN_DEBUG "  Rx data %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:"
1596                                "%2.2x %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x %2.2x%2.2x.\n",
1597                                skb->data[0], skb->data[1], skb->data[2], skb->data[3],
1598                                skb->data[4], skb->data[5], skb->data[6], skb->data[7],
1599                                skb->data[8], skb->data[9], skb->data[10],
1600                                skb->data[11], skb->data[12], skb->data[13]);
1601 #endif
1602
1603                 skb->protocol = eth_type_trans(skb, dev);
1604 #ifdef VLAN_SUPPORT
1605                 if (debug > 4)
1606                         printk(KERN_DEBUG "  netdev_rx() status2 of %d was %#4.4x.\n", np->rx_done, le16_to_cpu(desc->status2));
1607 #endif
1608                 if (le16_to_cpu(desc->status2) & 0x0100) {
1609                         skb->ip_summed = CHECKSUM_UNNECESSARY;
1610                         np->stats.rx_compressed++;
1611                 }
1612                 /*
1613                  * This feature doesn't seem to be working, at least
1614                  * with the two firmware versions I have. If the GFP sees
1615                  * an IP fragment, it either ignores it completely, or reports
1616                  * "bad checksum" on it.
1617                  *
1618                  * Maybe I missed something -- corrections are welcome.
1619                  * Until then, the printk stays. :-) -Ion
1620                  */
1621                 else if (le16_to_cpu(desc->status2) & 0x0040) {
1622                         skb->ip_summed = CHECKSUM_HW;
1623                         skb->csum = le16_to_cpu(desc->csum);
1624                         printk(KERN_DEBUG "%s: checksum_hw, status2 = %#x\n", dev->name, le16_to_cpu(desc->status2));
1625                 }
1626 #ifdef VLAN_SUPPORT
1627                 if (np->vlgrp && le16_to_cpu(desc->status2) & 0x0200) {
1628                         if (debug > 4)
1629                                 printk(KERN_DEBUG "  netdev_rx() vlanid = %d\n", le16_to_cpu(desc->vlanid));
1630                         /* vlan_netdev_receive_skb() expects a packet with the VLAN tag stripped out */
1631                         vlan_netdev_receive_skb(skb, np->vlgrp, le16_to_cpu(desc->vlanid) & VLAN_VID_MASK);
1632                 } else
1633 #endif /* VLAN_SUPPORT */
1634                         netdev_receive_skb(skb);
1635                 dev->last_rx = jiffies;
1636                 np->stats.rx_packets++;
1637
1638         next_rx:
1639                 np->cur_rx++;
1640                 desc->status = 0;
1641                 np->rx_done = (np->rx_done + 1) % DONE_Q_SIZE;
1642         }
1643         writew(np->rx_done, np->base + CompletionQConsumerIdx);
1644
1645  out:
1646         refill_rx_ring(dev);
1647         if (debug > 5)
1648                 printk(KERN_DEBUG "  exiting netdev_rx(): %d, status of %d was %#8.8x.\n",
1649                        retcode, np->rx_done, desc_status);
1650         return retcode;
1651 }
1652
1653
1654 #ifdef HAVE_NETDEV_POLL
1655 static int netdev_poll(struct net_device *dev, int *budget)
1656 {
1657         u32 intr_status;
1658         struct netdev_private *np = netdev_priv(dev);
1659         void __iomem *ioaddr = np->base;
1660         int retcode = 0, quota = dev->quota;
1661
1662         do {
1663                 writel(IntrRxDone | IntrRxEmpty, ioaddr + IntrClear);
1664
1665                 retcode = __netdev_rx(dev, &quota);
1666                 *budget -= (dev->quota - quota);
1667                 dev->quota = quota;
1668                 if (retcode)
1669                         goto out;
1670
1671                 intr_status = readl(ioaddr + IntrStatus);
1672         } while (intr_status & (IntrRxDone | IntrRxEmpty));
1673
1674         netif_rx_complete(dev);
1675         intr_status = readl(ioaddr + IntrEnable);
1676         intr_status |= IntrRxDone | IntrRxEmpty;
1677         writel(intr_status, ioaddr + IntrEnable);
1678
1679  out:
1680         if (debug > 5)
1681                 printk(KERN_DEBUG "  exiting netdev_poll(): %d.\n", retcode);
1682
1683         /* Restart Rx engine if stopped. */
1684         return retcode;
1685 }
1686 #endif /* HAVE_NETDEV_POLL */
1687
1688
1689 static void refill_rx_ring(struct net_device *dev)
1690 {
1691         struct netdev_private *np = netdev_priv(dev);
1692         struct sk_buff *skb;
1693         int entry = -1;
1694
1695         /* Refill the Rx ring buffers. */
1696         for (; np->cur_rx - np->dirty_rx > 0; np->dirty_rx++) {
1697                 entry = np->dirty_rx % RX_RING_SIZE;
1698                 if (np->rx_info[entry].skb == NULL) {
1699                         skb = dev_alloc_skb(np->rx_buf_sz);
1700                         np->rx_info[entry].skb = skb;
1701                         if (skb == NULL)
1702                                 break;  /* Better luck next round. */
1703                         np->rx_info[entry].mapping =
1704                                 pci_map_single(np->pci_dev, skb->data, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1705                         skb->dev = dev; /* Mark as being used by this device. */
1706                         np->rx_ring[entry].rxaddr =
1707                                 cpu_to_dma(np->rx_info[entry].mapping | RxDescValid);
1708                 }
1709                 if (entry == RX_RING_SIZE - 1)
1710                         np->rx_ring[entry].rxaddr |= cpu_to_dma(RxDescEndRing);
1711         }
1712         if (entry >= 0)
1713                 writew(entry, np->base + RxDescQIdx);
1714 }
1715
1716
1717 static void netdev_media_change(struct net_device *dev)
1718 {
1719         struct netdev_private *np = netdev_priv(dev);
1720         void __iomem *ioaddr = np->base;
1721         u16 reg0, reg1, reg4, reg5;
1722         u32 new_tx_mode;
1723         u32 new_intr_timer_ctrl;
1724
1725         /* reset status first */
1726         mdio_read(dev, np->phys[0], MII_BMCR);
1727         mdio_read(dev, np->phys[0], MII_BMSR);
1728
1729         reg0 = mdio_read(dev, np->phys[0], MII_BMCR);
1730         reg1 = mdio_read(dev, np->phys[0], MII_BMSR);
1731
1732         if (reg1 & BMSR_LSTATUS) {
1733                 /* link is up */
1734                 if (reg0 & BMCR_ANENABLE) {
1735                         /* autonegotiation is enabled */
1736                         reg4 = mdio_read(dev, np->phys[0], MII_ADVERTISE);
1737                         reg5 = mdio_read(dev, np->phys[0], MII_LPA);
1738                         if (reg4 & ADVERTISE_100FULL && reg5 & LPA_100FULL) {
1739                                 np->speed100 = 1;
1740                                 np->mii_if.full_duplex = 1;
1741                         } else if (reg4 & ADVERTISE_100HALF && reg5 & LPA_100HALF) {
1742                                 np->speed100 = 1;
1743                                 np->mii_if.full_duplex = 0;
1744                         } else if (reg4 & ADVERTISE_10FULL && reg5 & LPA_10FULL) {
1745                                 np->speed100 = 0;
1746                                 np->mii_if.full_duplex = 1;
1747                         } else {
1748                                 np->speed100 = 0;
1749                                 np->mii_if.full_duplex = 0;
1750                         }
1751                 } else {
1752                         /* autonegotiation is disabled */
1753                         if (reg0 & BMCR_SPEED100)
1754                                 np->speed100 = 1;
1755                         else
1756                                 np->speed100 = 0;
1757                         if (reg0 & BMCR_FULLDPLX)
1758                                 np->mii_if.full_duplex = 1;
1759                         else
1760                                 np->mii_if.full_duplex = 0;
1761                 }
1762                 netif_carrier_on(dev);
1763                 printk(KERN_DEBUG "%s: Link is up, running at %sMbit %s-duplex\n",
1764                        dev->name,
1765                        np->speed100 ? "100" : "10",
1766                        np->mii_if.full_duplex ? "full" : "half");
1767
1768                 new_tx_mode = np->tx_mode & ~FullDuplex;        /* duplex setting */
1769                 if (np->mii_if.full_duplex)
1770                         new_tx_mode |= FullDuplex;
1771                 if (np->tx_mode != new_tx_mode) {
1772                         np->tx_mode = new_tx_mode;
1773                         writel(np->tx_mode | MiiSoftReset, ioaddr + TxMode);
1774                         udelay(1000);
1775                         writel(np->tx_mode, ioaddr + TxMode);
1776                 }
1777
1778                 new_intr_timer_ctrl = np->intr_timer_ctrl & ~Timer10X;
1779                 if (np->speed100)
1780                         new_intr_timer_ctrl |= Timer10X;
1781                 if (np->intr_timer_ctrl != new_intr_timer_ctrl) {
1782                         np->intr_timer_ctrl = new_intr_timer_ctrl;
1783                         writel(new_intr_timer_ctrl, ioaddr + IntrTimerCtrl);
1784                 }
1785         } else {
1786                 netif_carrier_off(dev);
1787                 printk(KERN_DEBUG "%s: Link is down\n", dev->name);
1788         }
1789 }
1790
1791
1792 static void netdev_error(struct net_device *dev, int intr_status)
1793 {
1794         struct netdev_private *np = netdev_priv(dev);
1795
1796         /* Came close to underrunning the Tx FIFO, increase threshold. */
1797         if (intr_status & IntrTxDataLow) {
1798                 if (np->tx_threshold <= PKT_BUF_SZ / 16) {
1799                         writel(++np->tx_threshold, np->base + TxThreshold);
1800                         printk(KERN_NOTICE "%s: PCI bus congestion, increasing Tx FIFO threshold to %d bytes\n",
1801                                dev->name, np->tx_threshold * 16);
1802                 } else
1803                         printk(KERN_WARNING "%s: PCI Tx underflow -- adapter is probably malfunctioning\n", dev->name);
1804         }
1805         if (intr_status & IntrRxGFPDead) {
1806                 np->stats.rx_fifo_errors++;
1807                 np->stats.rx_errors++;
1808         }
1809         if (intr_status & (IntrNoTxCsum | IntrDMAErr)) {
1810                 np->stats.tx_fifo_errors++;
1811                 np->stats.tx_errors++;
1812         }
1813         if ((intr_status & ~(IntrNormalMask | IntrAbnormalSummary | IntrLinkChange | IntrStatsMax | IntrTxDataLow | IntrRxGFPDead | IntrNoTxCsum | IntrPCIPad)) && debug)
1814                 printk(KERN_ERR "%s: Something Wicked happened! %#8.8x.\n",
1815                        dev->name, intr_status);
1816 }
1817
1818
1819 static struct net_device_stats *get_stats(struct net_device *dev)
1820 {
1821         struct netdev_private *np = netdev_priv(dev);
1822         void __iomem *ioaddr = np->base;
1823
1824         /* This adapter architecture needs no SMP locks. */
1825         np->stats.tx_bytes = readl(ioaddr + 0x57010);
1826         np->stats.rx_bytes = readl(ioaddr + 0x57044);
1827         np->stats.tx_packets = readl(ioaddr + 0x57000);
1828         np->stats.tx_aborted_errors =
1829                 readl(ioaddr + 0x57024) + readl(ioaddr + 0x57028);
1830         np->stats.tx_window_errors = readl(ioaddr + 0x57018);
1831         np->stats.collisions =
1832                 readl(ioaddr + 0x57004) + readl(ioaddr + 0x57008);
1833
1834         /* The chip only need report frame silently dropped. */
1835         np->stats.rx_dropped += readw(ioaddr + RxDMAStatus);
1836         writew(0, ioaddr + RxDMAStatus);
1837         np->stats.rx_crc_errors = readl(ioaddr + 0x5703C);
1838         np->stats.rx_frame_errors = readl(ioaddr + 0x57040);
1839         np->stats.rx_length_errors = readl(ioaddr + 0x57058);
1840         np->stats.rx_missed_errors = readl(ioaddr + 0x5707C);
1841
1842         return &np->stats;
1843 }
1844
1845
1846 static void set_rx_mode(struct net_device *dev)
1847 {
1848         struct netdev_private *np = netdev_priv(dev);
1849         void __iomem *ioaddr = np->base;
1850         u32 rx_mode = MinVLANPrio;
1851         struct dev_mc_list *mclist;
1852         int i;
1853 #ifdef VLAN_SUPPORT
1854
1855         rx_mode |= VlanMode;
1856         if (np->vlgrp) {
1857                 int vlan_count = 0;
1858                 void __iomem *filter_addr = ioaddr + HashTable + 8;
1859                 for (i = 0; i < VLAN_VID_MASK; i++) {
1860                         if (np->vlgrp->vlan_devices[i]) {
1861                                 if (vlan_count >= 32)
1862                                         break;
1863                                 writew(cpu_to_be16(i), filter_addr);
1864                                 filter_addr += 16;
1865                                 vlan_count++;
1866                         }
1867                 }
1868                 if (i == VLAN_VID_MASK) {
1869                         rx_mode |= PerfectFilterVlan;
1870                         while (vlan_count < 32) {
1871                                 writew(0, filter_addr);
1872                                 filter_addr += 16;
1873                                 vlan_count++;
1874                         }
1875                 }
1876         }
1877 #endif /* VLAN_SUPPORT */
1878
1879         if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
1880                 rx_mode |= AcceptAll;
1881         } else if ((dev->mc_count > multicast_filter_limit)
1882                    || (dev->flags & IFF_ALLMULTI)) {
1883                 /* Too many to match, or accept all multicasts. */
1884                 rx_mode |= AcceptBroadcast|AcceptAllMulticast|PerfectFilter;
1885         } else if (dev->mc_count <= 14) {
1886                 /* Use the 16 element perfect filter, skip first two entries. */
1887                 void __iomem *filter_addr = ioaddr + PerfFilterTable + 2 * 16;
1888                 u16 *eaddrs;
1889                 for (i = 2, mclist = dev->mc_list; mclist && i < dev->mc_count + 2;
1890                      i++, mclist = mclist->next) {
1891                         eaddrs = (u16 *)mclist->dmi_addr;
1892                         writew(cpu_to_be16(eaddrs[2]), filter_addr); filter_addr += 4;
1893                         writew(cpu_to_be16(eaddrs[1]), filter_addr); filter_addr += 4;
1894                         writew(cpu_to_be16(eaddrs[0]), filter_addr); filter_addr += 8;
1895                 }
1896                 eaddrs = (u16 *)dev->dev_addr;
1897                 while (i++ < 16) {
1898                         writew(cpu_to_be16(eaddrs[0]), filter_addr); filter_addr += 4;
1899                         writew(cpu_to_be16(eaddrs[1]), filter_addr); filter_addr += 4;
1900                         writew(cpu_to_be16(eaddrs[2]), filter_addr); filter_addr += 8;
1901                 }
1902                 rx_mode |= AcceptBroadcast|PerfectFilter;
1903         } else {
1904                 /* Must use a multicast hash table. */
1905                 void __iomem *filter_addr;
1906                 u16 *eaddrs;
1907                 u16 mc_filter[32] __attribute__ ((aligned(sizeof(long))));      /* Multicast hash filter */
1908
1909                 memset(mc_filter, 0, sizeof(mc_filter));
1910                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1911                      i++, mclist = mclist->next) {
1912                         /* The chip uses the upper 9 CRC bits
1913                            as index into the hash table */
1914                         int bit_nr = ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 23;
1915                         __u32 *fptr = (__u32 *) &mc_filter[(bit_nr >> 4) & ~1];
1916
1917                         *fptr |= cpu_to_le32(1 << (bit_nr & 31));
1918                 }
1919                 /* Clear the perfect filter list, skip first two entries. */
1920                 filter_addr = ioaddr + PerfFilterTable + 2 * 16;
1921                 eaddrs = (u16 *)dev->dev_addr;
1922                 for (i = 2; i < 16; i++) {
1923                         writew(cpu_to_be16(eaddrs[0]), filter_addr); filter_addr += 4;
1924                         writew(cpu_to_be16(eaddrs[1]), filter_addr); filter_addr += 4;
1925                         writew(cpu_to_be16(eaddrs[2]), filter_addr); filter_addr += 8;
1926                 }
1927                 for (filter_addr = ioaddr + HashTable, i = 0; i < 32; filter_addr+= 16, i++)
1928                         writew(mc_filter[i], filter_addr);
1929                 rx_mode |= AcceptBroadcast|PerfectFilter|HashFilter;
1930         }
1931         writel(rx_mode, ioaddr + RxFilterMode);
1932 }
1933
1934 static int check_if_running(struct net_device *dev)
1935 {
1936         if (!netif_running(dev))
1937                 return -EINVAL;
1938         return 0;
1939 }
1940
1941 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1942 {
1943         struct netdev_private *np = netdev_priv(dev);
1944         strcpy(info->driver, DRV_NAME);
1945         strcpy(info->version, DRV_VERSION);
1946         strcpy(info->bus_info, pci_name(np->pci_dev));
1947 }
1948
1949 static int get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1950 {
1951         struct netdev_private *np = netdev_priv(dev);
1952         spin_lock_irq(&np->lock);
1953         mii_ethtool_gset(&np->mii_if, ecmd);
1954         spin_unlock_irq(&np->lock);
1955         return 0;
1956 }
1957
1958 static int set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1959 {
1960         struct netdev_private *np = netdev_priv(dev);
1961         int res;
1962         spin_lock_irq(&np->lock);
1963         res = mii_ethtool_sset(&np->mii_if, ecmd);
1964         spin_unlock_irq(&np->lock);
1965         check_duplex(dev);
1966         return res;
1967 }
1968
1969 static int nway_reset(struct net_device *dev)
1970 {
1971         struct netdev_private *np = netdev_priv(dev);
1972         return mii_nway_restart(&np->mii_if);
1973 }
1974
1975 static u32 get_link(struct net_device *dev)
1976 {
1977         struct netdev_private *np = netdev_priv(dev);
1978         return mii_link_ok(&np->mii_if);
1979 }
1980
1981 static u32 get_msglevel(struct net_device *dev)
1982 {
1983         return debug;
1984 }
1985
1986 static void set_msglevel(struct net_device *dev, u32 val)
1987 {
1988         debug = val;
1989 }
1990
1991 static struct ethtool_ops ethtool_ops = {
1992         .begin = check_if_running,
1993         .get_drvinfo = get_drvinfo,
1994         .get_settings = get_settings,
1995         .set_settings = set_settings,
1996         .nway_reset = nway_reset,
1997         .get_link = get_link,
1998         .get_msglevel = get_msglevel,
1999         .set_msglevel = set_msglevel,
2000 };
2001
2002 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2003 {
2004         struct netdev_private *np = netdev_priv(dev);
2005         struct mii_ioctl_data *data = if_mii(rq);
2006         int rc;
2007
2008         if (!netif_running(dev))
2009                 return -EINVAL;
2010
2011         spin_lock_irq(&np->lock);
2012         rc = generic_mii_ioctl(&np->mii_if, data, cmd, NULL);
2013         spin_unlock_irq(&np->lock);
2014
2015         if ((cmd == SIOCSMIIREG) && (data->phy_id == np->phys[0]))
2016                 check_duplex(dev);
2017
2018         return rc;
2019 }
2020
2021 static int netdev_close(struct net_device *dev)
2022 {
2023         struct netdev_private *np = netdev_priv(dev);
2024         void __iomem *ioaddr = np->base;
2025         int i;
2026
2027         netif_stop_queue(dev);
2028
2029         if (debug > 1) {
2030                 printk(KERN_DEBUG "%s: Shutting down ethercard, Intr status %#8.8x.\n",
2031                            dev->name, (int) readl(ioaddr + IntrStatus));
2032                 printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d, Rx %d / %d.\n",
2033                        dev->name, np->cur_tx, np->dirty_tx,
2034                        np->cur_rx, np->dirty_rx);
2035         }
2036
2037         /* Disable interrupts by clearing the interrupt mask. */
2038         writel(0, ioaddr + IntrEnable);
2039
2040         /* Stop the chip's Tx and Rx processes. */
2041         writel(0, ioaddr + GenCtrl);
2042         readl(ioaddr + GenCtrl);
2043
2044         if (debug > 5) {
2045                 printk(KERN_DEBUG"  Tx ring at %#llx:\n",
2046                        (long long) np->tx_ring_dma);
2047                 for (i = 0; i < 8 /* TX_RING_SIZE is huge! */; i++)
2048                         printk(KERN_DEBUG " #%d desc. %#8.8x %#llx -> %#8.8x.\n",
2049                                i, le32_to_cpu(np->tx_ring[i].status),
2050                                (long long) dma_to_cpu(np->tx_ring[i].addr),
2051                                le32_to_cpu(np->tx_done_q[i].status));
2052                 printk(KERN_DEBUG "  Rx ring at %#llx -> %p:\n",
2053                        (long long) np->rx_ring_dma, np->rx_done_q);
2054                 if (np->rx_done_q)
2055                         for (i = 0; i < 8 /* RX_RING_SIZE */; i++) {
2056                                 printk(KERN_DEBUG " #%d desc. %#llx -> %#8.8x\n",
2057                                        i, (long long) dma_to_cpu(np->rx_ring[i].rxaddr), le32_to_cpu(np->rx_done_q[i].status));
2058                 }
2059         }
2060
2061         free_irq(dev->irq, dev);
2062
2063         /* Free all the skbuffs in the Rx queue. */
2064         for (i = 0; i < RX_RING_SIZE; i++) {
2065                 np->rx_ring[i].rxaddr = cpu_to_dma(0xBADF00D0); /* An invalid address. */
2066                 if (np->rx_info[i].skb != NULL) {
2067                         pci_unmap_single(np->pci_dev, np->rx_info[i].mapping, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
2068                         dev_kfree_skb(np->rx_info[i].skb);
2069                 }
2070                 np->rx_info[i].skb = NULL;
2071                 np->rx_info[i].mapping = 0;
2072         }
2073         for (i = 0; i < TX_RING_SIZE; i++) {
2074                 struct sk_buff *skb = np->tx_info[i].skb;
2075                 if (skb == NULL)
2076                         continue;
2077                 pci_unmap_single(np->pci_dev,
2078                                  np->tx_info[i].mapping,
2079                                  skb_first_frag_len(skb), PCI_DMA_TODEVICE);
2080                 np->tx_info[i].mapping = 0;
2081                 dev_kfree_skb(skb);
2082                 np->tx_info[i].skb = NULL;
2083         }
2084
2085         return 0;
2086 }
2087
2088
2089 static void __devexit starfire_remove_one (struct pci_dev *pdev)
2090 {
2091         struct net_device *dev = pci_get_drvdata(pdev);
2092         struct netdev_private *np = netdev_priv(dev);
2093
2094         if (!dev)
2095                 BUG();
2096
2097         unregister_netdev(dev);
2098
2099         if (np->queue_mem)
2100                 pci_free_consistent(pdev, np->queue_mem_size, np->queue_mem, np->queue_mem_dma);
2101
2102
2103         /* XXX: add wakeup code -- requires firmware for MagicPacket */
2104         pci_set_power_state(pdev, PCI_D3hot);   /* go to sleep in D3 mode */
2105         pci_disable_device(pdev);
2106
2107         iounmap(np->base);
2108         pci_release_regions(pdev);
2109
2110         pci_set_drvdata(pdev, NULL);
2111         free_netdev(dev);                       /* Will also free np!! */
2112 }
2113
2114
2115 static struct pci_driver starfire_driver = {
2116         .name           = DRV_NAME,
2117         .probe          = starfire_init_one,
2118         .remove         = __devexit_p(starfire_remove_one),
2119         .id_table       = starfire_pci_tbl,
2120 };
2121
2122
2123 static int __init starfire_init (void)
2124 {
2125 /* when a module, this is printed whether or not devices are found in probe */
2126 #ifdef MODULE
2127         printk(version);
2128 #ifdef HAVE_NETDEV_POLL
2129         printk(KERN_INFO DRV_NAME ": polling (NAPI) enabled\n");
2130 #else
2131         printk(KERN_INFO DRV_NAME ": polling (NAPI) disabled\n");
2132 #endif
2133 #endif
2134
2135         /* we can do this test only at run-time... sigh */
2136         if (sizeof(dma_addr_t) != sizeof(netdrv_addr_t)) {
2137                 printk("This driver has dma_addr_t issues, please send email to maintainer\n");
2138                 return -ENODEV;
2139         }
2140
2141         return pci_module_init (&starfire_driver);
2142 }
2143
2144
2145 static void __exit starfire_cleanup (void)
2146 {
2147         pci_unregister_driver (&starfire_driver);
2148 }
2149
2150
2151 module_init(starfire_init);
2152 module_exit(starfire_cleanup);
2153
2154
2155 /*
2156  * Local variables:
2157  *  c-basic-offset: 8
2158  *  tab-width: 8
2159  * End:
2160  */