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