blob: 74b7ae76906e3b482d0c4ad7a47f5c4893adeb7e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* starfire.c: Linux device driver for the Adaptec Starfire network adapter. */
2/*
3 Written 1998-2000 by Donald Becker.
4
Jeff Garzikfdecea62005-05-12 20:16:24 -04005 Current maintainer is Ion Badulescu <ionut ta badula tod org>. Please
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 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
Jeff Garzik03a8c662006-06-27 07:57:22 -040025 [link no longer provides useful info -jgarzik]
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
Linus Torvalds1da177e2005-04-16 15:20:36 -070027*/
28
29#define DRV_NAME "starfire"
Francois Romieua6676012008-07-06 20:54:45 -070030#define DRV_VERSION "2.1"
31#define DRV_RELDATE "July 6, 2008"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#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>
Jeff Garzikfdecea62005-05-12 20:16:24 -040040#include <linux/crc32.h>
41#include <linux/ethtool.h>
42#include <linux/mii.h>
43#include <linux/if_vlan.h>
Al Virod7fe0f22006-12-03 23:15:30 -050044#include <linux/mm.h>
Jaswinder Singh Rajputcfc3a442009-01-04 16:12:11 -080045#include <linux/firmware.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include <asm/processor.h> /* Processor type for cache alignment. */
47#include <asm/uaccess.h>
48#include <asm/io.h>
49
Linus Torvalds1da177e2005-04-16 15:20:36 -070050/*
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
Ion Badulescu67974232005-10-03 22:31:36 -040055
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070063/*
64 * Define this if using the driver with the zero-copy patch
65 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#define ZEROCOPY
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
68#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
69#define VLAN_SUPPORT
70#endif
71
Linus Torvalds1da177e2005-04-16 15:20:36 -070072/* The user-configurable values.
73 These may be modified when a driver module is loaded.*/
74
75/* Used for tuning interrupt latency vs. overhead. */
76static int intr_latency;
77static int small_frames;
78
79static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */
80static int max_interrupt_work = 20;
81static 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. */
Arjan van de Venf71e1302006-03-03 21:33:57 -050084static const int multicast_filter_limit = 512;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085/* Whether to do TCP/UDP checksums in hardware */
Linus Torvalds1da177e2005-04-16 15:20:36 -070086static int enable_hw_cksum = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
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__)
104static int rx_copybreak = PKT_BUF_SZ;
105#else
106static 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 */
122static int options[MAX_UNITS] = {0, };
123static 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 */
maximilian attems983b7dc2007-06-24 23:36:45 +0200151#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))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152/* 64-bit dma_addr_t */
153#define ADDR_64BITS /* This chip uses 64 bit addresses. */
Al Viro88b19432007-08-23 02:29:45 -0400154#define netdrv_addr_t __le64
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155#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 */
Al Viro88b19432007-08-23 02:29:45 -0400163#define netdrv_addr_t __le32
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164#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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173#define skb_first_frag_len(skb) skb_headlen(skb)
174#define skb_num_frags(skb) (skb_shinfo(skb)->nr_frags + 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
Jaswinder Singh Rajputcfc3a442009-01-04 16:12:11 -0800176/* Firmware names */
177#define FIRMWARE_RX "adaptec/starfire_rx.bin"
178#define FIRMWARE_TX "adaptec/starfire_tx.bin"
179
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180/* These identify the driver base version and may not be removed. */
Stephen Hemmingerb5defaa2009-02-26 10:19:32 +0000181static const char version[] __devinitconst =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182KERN_INFO "starfire.c:v1.03 7/26/2000 Written by Donald Becker <becker@scyld.com>\n"
Joe Perchesad361c92009-07-06 13:05:40 -0700183" (unofficial 2.2/2.4 kernel port, version " DRV_VERSION ", " DRV_RELDATE ")\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
185MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
186MODULE_DESCRIPTION("Adaptec Starfire Ethernet driver");
187MODULE_LICENSE("GPL");
Jeff Garzikfdecea62005-05-12 20:16:24 -0400188MODULE_VERSION(DRV_VERSION);
Jaswinder Singh Rajputcfc3a442009-01-04 16:12:11 -0800189MODULE_FIRMWARE(FIRMWARE_RX);
190MODULE_FIRMWARE(FIRMWARE_TX);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
192module_param(max_interrupt_work, int, 0);
193module_param(mtu, int, 0);
194module_param(debug, int, 0);
195module_param(rx_copybreak, int, 0);
196module_param(intr_latency, int, 0);
197module_param(small_frames, int, 0);
198module_param_array(options, int, NULL, 0);
199module_param_array(full_duplex, int, NULL, 0);
200module_param(enable_hw_cksum, int, 0);
201MODULE_PARM_DESC(max_interrupt_work, "Maximum events handled per interrupt");
202MODULE_PARM_DESC(mtu, "MTU (all boards)");
203MODULE_PARM_DESC(debug, "Debug level (0-6)");
204MODULE_PARM_DESC(rx_copybreak, "Copy breakpoint for copy-only-tiny-frames");
205MODULE_PARM_DESC(intr_latency, "Maximum interrupt latency, in microseconds");
206MODULE_PARM_DESC(small_frames, "Maximum size of receive frames that bypass interrupt latency (0,64,128,256,512)");
207MODULE_PARM_DESC(options, "Deprecated: Bits 0-3: media type, bit 17: full duplex");
208MODULE_PARM_DESC(full_duplex, "Deprecated: Forced full-duplex setting (0/1)");
209MODULE_PARM_DESC(enable_hw_cksum, "Enable/disable hardware cksum support (0/1)");
210
211/*
212 Theory of Operation
213
214I. Board Compatibility
215
216This driver is for the Adaptec 6915 "Starfire" 64 bit PCI Ethernet adapter.
217
218II. Board-specific settings
219
220III. Driver operation
221
222IIIa. Ring buffers
223
224The Starfire hardware uses multiple fixed-size descriptor queues/rings. The
225ring sizes are set fixed by the hardware, but may optionally be wrapped
226earlier by the END bit in the descriptor.
227This driver uses that hardware queue size for the Rx ring, where a large
228number of entries has no ill effect beyond increases the potential backlog.
229The Tx ring is wrapped with the END bit, since a large hardware Tx queue
230disables the queue layer priority ordering and we have no mechanism to
231utilize the hardware two-level priority queue. When modifying the
232RX/TX_RING_SIZE pay close attention to page sizes and the ring-empty warning
233levels.
234
235IIIb/c. Transmit/Receive Structure
236
237See the Adaptec manual for the many possible structures, and options for
238each structure. There are far too many to document all of them here.
239
240For transmit this driver uses type 0/1 transmit descriptors (depending
241on the 32/64 bitness of the architecture), and relies on automatic
242minimum-length padding. It does not use the completion queue
243consumer index, but instead checks for non-zero status entries.
244
Jeff Garzikfdecea62005-05-12 20:16:24 -0400245For receive this driver uses type 2/3 receive descriptors. The driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246allocates full frame size skbuffs for the Rx ring buffers, so all frames
247should fit in a single descriptor. The driver does not use the completion
248queue consumer index, but instead checks for non-zero status entries.
249
250When an incoming frame is less than RX_COPYBREAK bytes long, a fresh skbuff
251is allocated and the frame is copied to the new skbuff. When the incoming
252frame is larger, the skbuff is passed directly up the protocol stack.
253Buffers consumed this way are replaced by newly allocated skbuffs in a later
254phase of receive.
255
256A notable aspect of operation is that unaligned buffers are not permitted by
257the Starfire hardware. Thus the IP header at offset 14 in an ethernet frame
258isn't longword aligned, which may cause problems on some machine
259e.g. Alphas and IA64. For these architectures, the driver is forced to copy
260the frame into a new skbuff unconditionally. Copied frames are put into the
261skbuff at an offset of "+2", thus 16-byte aligning the IP header.
262
263IIId. Synchronization
264
265The driver runs as two independent, single-threaded flows of control. One
266is the send-packet routine, which enforces single-threaded use by the
267dev->tbusy flag. The other thread is the interrupt handler, which is single
268threaded by the hardware and interrupt handling software.
269
270The send packet thread has partial control over the Tx ring and the netif_queue
271status. 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
274The interrupt handler has exclusive control over the Rx ring and records stats
275from the Tx ring. After reaping the stats, it marks the Tx queue entry as
276empty by incrementing the dirty_tx mark. Iff the netif_queue is stopped and the
277number of free Tx slow is above the threshold, it signals the upper layer to
278restart the queue.
279
280IV. Notes
281
282IVb. References
283
284The Adaptec Starfire manuals, available only from Adaptec.
285http://www.scyld.com/expert/100mbps.html
286http://www.scyld.com/expert/NWay.html
287
288IVc. 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
Jeff Garzikfdecea62005-05-12 20:16:24 -0400296
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
298enum chip_capability_flags {CanHaveMII=1, };
299
300enum chipset {
301 CH_6915 = 0,
302};
303
Alexey Dobriyana3aa1882010-01-07 11:58:11 +0000304static DEFINE_PCI_DEVICE_TABLE(starfire_pci_tbl) = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 { 0x9004, 0x6915, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_6915 },
306 { 0, }
307};
308MODULE_DEVICE_TABLE(pci, starfire_pci_tbl);
309
310/* A chip capabilities table, matching the CH_xxx entries in xxx_pci_tbl[] above. */
Arjan van de Venf71e1302006-03-03 21:33:57 -0500311static const struct chip_info {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 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*/
327enum 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 */
351enum 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. */
373enum 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 */
381enum 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. */
388enum 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. */
400enum 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. */
413enum 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 */
429enum 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 */
438enum 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 */
447enum gen_ctrl_bits {
448 RxEnable=0x05, TxEnable=0x0a,
449 RxGFPEnable=0x10, TxGFPEnable=0x20,
450};
451
452/* Bits in the IntrTimerCtrl register */
453enum 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. */
460struct starfire_rx_desc {
Al Viro88b19432007-08-23 02:29:45 -0400461 netdrv_addr_t rxaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462};
463enum rx_desc_bits {
464 RxDescValid=1, RxDescEndRing=2,
465};
466
467/* Completion queue entry. */
468struct short_rx_done_desc {
Al Viro88b19432007-08-23 02:29:45 -0400469 __le32 status; /* Low 16 bits is length. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470};
471struct basic_rx_done_desc {
Al Viro88b19432007-08-23 02:29:45 -0400472 __le32 status; /* Low 16 bits is length. */
473 __le16 vlanid;
474 __le16 status2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475};
476struct csum_rx_done_desc {
Al Viro88b19432007-08-23 02:29:45 -0400477 __le32 status; /* Low 16 bits is length. */
478 __le16 csum; /* Partial checksum */
479 __le16 status2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480};
481struct full_rx_done_desc {
Al Viro88b19432007-08-23 02:29:45 -0400482 __le32 status; /* Low 16 bits is length. */
483 __le16 status3;
484 __le16 status2;
485 __le16 vlanid;
486 __le16 csum; /* partial checksum */
487 __le32 timestamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488};
489/* XXX: this is ugly and I'm not sure it's worth the trouble -Ion */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490#ifdef VLAN_SUPPORT
491typedef struct full_rx_done_desc rx_done_desc;
492#define RxComplType RxComplType3
493#else /* not VLAN_SUPPORT */
494typedef struct csum_rx_done_desc rx_done_desc;
495#define RxComplType RxComplType2
496#endif /* not VLAN_SUPPORT */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
498enum rx_done_bits {
499 RxOK=0x20000000, RxFIFOErr=0x10000000, RxBufQ2=0x08000000,
500};
501
502/* Type 1 Tx descriptor. */
503struct starfire_tx_desc_1 {
Al Viro88b19432007-08-23 02:29:45 -0400504 __le32 status; /* Upper bits are status, lower 16 length. */
505 __le32 addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506};
507
508/* Type 2 Tx descriptor. */
509struct starfire_tx_desc_2 {
Al Viro88b19432007-08-23 02:29:45 -0400510 __le32 status; /* Upper bits are status, lower 16 length. */
511 __le32 reserved;
512 __le64 addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513};
514
515#ifdef ADDR_64BITS
516typedef struct starfire_tx_desc_2 starfire_tx_desc;
517#define TX_DESC_TYPE TxDescType2
518#else /* not ADDR_64BITS */
519typedef 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
524enum tx_desc_bits {
525 TxDescID=0xB0000000,
526 TxCRCEn=0x01000000, TxDescIntr=0x08000000,
527 TxRingWrap=0x04000000, TxCalTCP=0x02000000,
528};
529struct tx_done_desc {
Al Viro88b19432007-08-23 02:29:45 -0400530 __le32 status; /* timestamp, index. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531#if 0
Al Viro88b19432007-08-23 02:29:45 -0400532 __le32 intrstatus; /* interrupt status */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533#endif
534};
535
536struct rx_ring_info {
537 struct sk_buff *skb;
538 dma_addr_t mapping;
539};
540struct 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
547struct 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;
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700563 struct napi_struct napi;
564 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 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
592static int mdio_read(struct net_device *dev, int phy_id, int location);
593static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
594static int netdev_open(struct net_device *dev);
595static void check_duplex(struct net_device *dev);
596static void tx_timeout(struct net_device *dev);
597static void init_ring(struct net_device *dev);
Stephen Hemminger613573252009-08-31 19:50:58 +0000598static netdev_tx_t start_tx(struct sk_buff *skb, struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100599static irqreturn_t intr_handler(int irq, void *dev_instance);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600static void netdev_error(struct net_device *dev, int intr_status);
601static int __netdev_rx(struct net_device *dev, int *quota);
Francois Romieua6676012008-07-06 20:54:45 -0700602static int netdev_poll(struct napi_struct *napi, int budget);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603static void refill_rx_ring(struct net_device *dev);
604static void netdev_error(struct net_device *dev, int intr_status);
605static void set_rx_mode(struct net_device *dev);
606static struct net_device_stats *get_stats(struct net_device *dev);
607static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
608static int netdev_close(struct net_device *dev);
609static void netdev_media_change(struct net_device *dev);
Jeff Garzik7282d492006-09-13 14:30:00 -0400610static const struct ethtool_ops ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611
612
613#ifdef VLAN_SUPPORT
614static 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
626static 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
637static 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);
Dan Aloni5c15bde2007-03-02 20:44:51 -0800644 vlan_group_set_device(np->vlgrp, vid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 set_rx_mode(dev);
646 spin_unlock(&np->lock);
647}
648#endif /* VLAN_SUPPORT */
649
650
Stephen Hemminger4fc80062009-01-07 17:58:17 -0800651static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669static 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 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 */
Randy Dunlap694625c2007-07-09 11:55:54 -0700724 pci_try_set_mwi(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726#ifdef ZEROCOPY
727 /* Starfire can do TCP/UDP checksumming */
728 if (enable_hw_cksum)
Jeff Garzikfdecea62005-05-12 20:16:24 -0400729 dev->features |= NETIF_F_IP_CSUM | NETIF_F_SG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730#endif /* ZEROCOPY */
Stephen Hemminger4fc80062009-01-07 17:58:17 -0800731
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732#ifdef VLAN_SUPPORT
733 dev->features |= NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_FILTER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734#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);
Stephen Hemmingerbea33482007-10-03 16:41:36 -0700773 np->dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 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
Stephen Hemminger4fc80062009-01-07 17:58:17 -0800829 dev->netdev_ops = &netdev_ops;
Jeff Garzikfdecea62005-05-12 20:16:24 -0400830 dev->watchdog_timeo = TX_TIMEOUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 SET_ETHTOOL_OPS(dev, &ethtool_ops);
832
Stephen Hemminger4fc80062009-01-07 17:58:17 -0800833 netif_napi_add(dev, &np->napi, netdev_poll, max_interrupt_work);
834
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 if (mtu)
836 dev->mtu = mtu;
837
838 if (register_netdev(dev))
839 goto err_out_cleardev;
840
Johannes Berge1749612008-10-27 15:59:26 -0700841 printk(KERN_INFO "%s: %s at %p, %pM, IRQ %d.\n",
Joe Perches0795af52007-10-03 17:59:30 -0700842 dev->name, netdrv_tbl[chip_idx].name, base,
Johannes Berge1749612008-10-27 15:59:26 -0700843 dev->dev_addr, irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844
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) {
Jeff Garzikfdecea62005-05-12 20:16:24 -0400856 printk("%s: PHY#%d reset never completed!\n", dev->name, phy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 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
881err_out_cleardev:
882 pci_set_drvdata(pdev, NULL);
883 iounmap(base);
884err_out_free_res:
885 pci_release_regions (pdev);
886err_out_free_netdev:
887 free_netdev(dev);
888 return -ENODEV;
889}
890
891
892/* Read the MII Management Data I/O (MDIO) interfaces. */
893static 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? */
Hannes Edere4c3c132008-12-25 23:55:35 -0800899 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 result = readl(mdio_addr);
Hannes Edere4c3c132008-12-25 23:55:35 -0800901 } while ((result & 0xC0000000) != 0x80000000 && --boguscnt > 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 if (boguscnt == 0)
903 return 0;
904 if ((result & 0xffff) == 0xffff)
905 return 0;
906 return result & 0xffff;
907}
908
909
910static 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
919static int netdev_open(struct net_device *dev)
920{
Jaswinder Singh Rajputcfc3a442009-01-04 16:12:11 -0800921 const struct firmware *fw_rx, *fw_tx;
922 const __be32 *fw_rx_data, *fw_tx_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 struct netdev_private *np = netdev_priv(dev);
924 void __iomem *ioaddr = np->base;
925 int i, retval;
Jaswinder Singh Rajputcfc3a442009-01-04 16:12:11 -0800926 size_t tx_size, rx_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 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??? */
Jeff Garzikfdecea62005-05-12 20:16:24 -0400930
Joe Perchesa0607fd2009-11-18 23:29:17 -0800931 retval = request_irq(dev->irq, intr_handler, IRQF_SHARED, dev->name, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 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. */
Al Viro88b19432007-08-23 02:29:45 -0400943 if (!np->queue_mem) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 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);
Alexey Dobriyand8840ac2005-10-07 02:05:23 +0400950 if (np->queue_mem == NULL) {
951 free_irq(dev->irq, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 return -ENOMEM;
Alexey Dobriyand8840ac2005-10-07 02:05:23 +0400953 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954
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++) {
Al Viro88b19432007-08-23 02:29:45 -04001016 __be16 *eaddrs = (__be16 *)dev->dev_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 void __iomem *setup_frm = ioaddr + PerfFilterTable + i * 16;
Al Viro88b19432007-08-23 02:29:45 -04001018 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 }
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
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001034 napi_enable(&np->napi);
Francois Romieua6676012008-07-06 20:54:45 -07001035
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 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
Jaswinder Singh Rajputcfc3a442009-01-04 16:12:11 -08001062 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);
Ben Hutchingsc928feb2010-01-26 18:27:09 +00001066 goto out_init;
Jaswinder Singh Rajputcfc3a442009-01-04 16:12:11 -08001067 }
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
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 /* Load Rx/Tx firmware into the frame processors */
Jaswinder Singh Rajputcfc3a442009-01-04 16:12:11 -08001092 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 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
Jaswinder Singh Rajputcfc3a442009-01-04 16:12:11 -08001107out_tx:
1108 release_firmware(fw_tx);
1109out_rx:
1110 release_firmware(fw_rx);
Ben Hutchingsc928feb2010-01-26 18:27:09 +00001111out_init:
1112 if (retval)
1113 netdev_close(dev);
Jaswinder Singh Rajputcfc3a442009-01-04 16:12:11 -08001114 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115}
1116
1117
1118static 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
1153static 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
Eric Dumazet1ae5dc32010-05-10 05:01:31 -07001176 dev->trans_start = jiffies; /* prevent tx timeout */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 np->stats.tx_errors++;
1178 netif_wake_queue(dev);
1179}
1180
1181
1182/* Initialize the Rx and Tx rings, along with various 'dev' bits. */
1183static 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;
David S. Miller689be432005-06-28 15:25:31 -07001199 np->rx_info[i].mapping = pci_map_single(np->pci_dev, skb->data, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 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]));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224}
1225
1226
Stephen Hemminger613573252009-08-31 19:50:58 +00001227static netdev_tx_t start_tx(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228{
1229 struct netdev_private *np = netdev_priv(dev);
1230 unsigned int entry;
1231 u32 status;
1232 int i;
1233
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 /*
1235 * be cautious here, wrapping the queue has weird semantics
1236 * and we may not have enough slots even when it seems we do.
1237 */
1238 if ((np->cur_tx - np->dirty_tx) + skb_num_frags(skb) * 2 > TX_RING_SIZE) {
1239 netif_stop_queue(dev);
Patrick McHardy5b548142009-06-12 06:22:29 +00001240 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 }
1242
1243#if defined(ZEROCOPY) && defined(HAS_BROKEN_FIRMWARE)
Patrick McHardy84fa7932006-08-29 16:44:56 -07001244 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Herbert Xu5b057c62006-06-23 02:06:41 -07001245 if (skb_padto(skb, (skb->len + PADDING_MASK) & ~PADDING_MASK))
Ion Badulescu67974232005-10-03 22:31:36 -04001246 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 }
1248#endif /* ZEROCOPY && HAS_BROKEN_FIRMWARE */
1249
1250 entry = np->cur_tx % TX_RING_SIZE;
1251 for (i = 0; i < skb_num_frags(skb); i++) {
1252 int wrap_ring = 0;
1253 status = TxDescID;
1254
1255 if (i == 0) {
1256 np->tx_info[entry].skb = skb;
1257 status |= TxCRCEn;
1258 if (entry >= TX_RING_SIZE - skb_num_frags(skb)) {
1259 status |= TxRingWrap;
1260 wrap_ring = 1;
1261 }
1262 if (np->reap_tx) {
1263 status |= TxDescIntr;
1264 np->reap_tx = 0;
1265 }
Patrick McHardy84fa7932006-08-29 16:44:56 -07001266 if (skb->ip_summed == CHECKSUM_PARTIAL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 status |= TxCalTCP;
1268 np->stats.tx_compressed++;
1269 }
1270 status |= skb_first_frag_len(skb) | (skb_num_frags(skb) << 16);
1271
1272 np->tx_info[entry].mapping =
1273 pci_map_single(np->pci_dev, skb->data, skb_first_frag_len(skb), PCI_DMA_TODEVICE);
1274 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 skb_frag_t *this_frag = &skb_shinfo(skb)->frags[i - 1];
1276 status |= this_frag->size;
1277 np->tx_info[entry].mapping =
1278 pci_map_single(np->pci_dev, page_address(this_frag->page) + this_frag->page_offset, this_frag->size, PCI_DMA_TODEVICE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 }
1280
1281 np->tx_ring[entry].addr = cpu_to_dma(np->tx_info[entry].mapping);
1282 np->tx_ring[entry].status = cpu_to_le32(status);
1283 if (debug > 3)
1284 printk(KERN_DEBUG "%s: Tx #%d/#%d slot %d status %#8.8x.\n",
1285 dev->name, np->cur_tx, np->dirty_tx,
1286 entry, status);
1287 if (wrap_ring) {
1288 np->tx_info[entry].used_slots = TX_RING_SIZE - entry;
1289 np->cur_tx += np->tx_info[entry].used_slots;
1290 entry = 0;
1291 } else {
1292 np->tx_info[entry].used_slots = 1;
1293 np->cur_tx += np->tx_info[entry].used_slots;
1294 entry++;
1295 }
1296 /* scavenge the tx descriptors twice per TX_RING_SIZE */
1297 if (np->cur_tx % (TX_RING_SIZE / 2) == 0)
1298 np->reap_tx = 1;
1299 }
1300
1301 /* Non-x86: explicitly flush descriptor cache lines here. */
1302 /* Ensure all descriptors are written back before the transmit is
1303 initiated. - Jes */
1304 wmb();
1305
1306 /* Update the producer index. */
1307 writel(entry * (sizeof(starfire_tx_desc) / 8), np->base + TxProducerIdx);
1308
1309 /* 4 is arbitrary, but should be ok */
1310 if ((np->cur_tx - np->dirty_tx) + 4 > TX_RING_SIZE)
1311 netif_stop_queue(dev);
1312
Patrick McHardy6ed10652009-06-23 06:03:08 +00001313 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314}
1315
1316
1317/* The interrupt handler does all of the Rx thread work and cleans up
1318 after the Tx thread. */
David Howells7d12e782006-10-05 14:55:46 +01001319static irqreturn_t intr_handler(int irq, void *dev_instance)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320{
1321 struct net_device *dev = dev_instance;
1322 struct netdev_private *np = netdev_priv(dev);
1323 void __iomem *ioaddr = np->base;
1324 int boguscnt = max_interrupt_work;
1325 int consumer;
1326 int tx_status;
1327 int handled = 0;
1328
1329 do {
1330 u32 intr_status = readl(ioaddr + IntrClear);
1331
1332 if (debug > 4)
1333 printk(KERN_DEBUG "%s: Interrupt status %#8.8x.\n",
1334 dev->name, intr_status);
1335
1336 if (intr_status == 0 || intr_status == (u32) -1)
1337 break;
1338
1339 handled = 1;
1340
Francois Romieua6676012008-07-06 20:54:45 -07001341 if (intr_status & (IntrRxDone | IntrRxEmpty)) {
1342 u32 enable;
1343
Ben Hutchings288379f2009-01-19 16:43:59 -08001344 if (likely(napi_schedule_prep(&np->napi))) {
1345 __napi_schedule(&np->napi);
Francois Romieua6676012008-07-06 20:54:45 -07001346 enable = readl(ioaddr + IntrEnable);
1347 enable &= ~(IntrRxDone | IntrRxEmpty);
1348 writel(enable, ioaddr + IntrEnable);
1349 /* flush PCI posting buffers */
1350 readl(ioaddr + IntrEnable);
1351 } else {
1352 /* Paranoia check */
1353 enable = readl(ioaddr + IntrEnable);
1354 if (enable & (IntrRxDone | IntrRxEmpty)) {
1355 printk(KERN_INFO
1356 "%s: interrupt while in poll!\n",
1357 dev->name);
1358 enable &= ~(IntrRxDone | IntrRxEmpty);
1359 writel(enable, ioaddr + IntrEnable);
1360 }
1361 }
1362 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
1364 /* Scavenge the skbuff list based on the Tx-done queue.
1365 There are redundant checks here that may be cleaned up
1366 after the driver has proven to be reliable. */
1367 consumer = readl(ioaddr + TxConsumerIdx);
1368 if (debug > 3)
1369 printk(KERN_DEBUG "%s: Tx Consumer index is %d.\n",
1370 dev->name, consumer);
1371
1372 while ((tx_status = le32_to_cpu(np->tx_done_q[np->tx_done].status)) != 0) {
1373 if (debug > 3)
1374 printk(KERN_DEBUG "%s: Tx completion #%d entry %d is %#8.8x.\n",
1375 dev->name, np->dirty_tx, np->tx_done, tx_status);
1376 if ((tx_status & 0xe0000000) == 0xa0000000) {
1377 np->stats.tx_packets++;
1378 } else if ((tx_status & 0xe0000000) == 0x80000000) {
1379 u16 entry = (tx_status & 0x7fff) / sizeof(starfire_tx_desc);
1380 struct sk_buff *skb = np->tx_info[entry].skb;
1381 np->tx_info[entry].skb = NULL;
1382 pci_unmap_single(np->pci_dev,
1383 np->tx_info[entry].mapping,
1384 skb_first_frag_len(skb),
1385 PCI_DMA_TODEVICE);
1386 np->tx_info[entry].mapping = 0;
1387 np->dirty_tx += np->tx_info[entry].used_slots;
1388 entry = (entry + np->tx_info[entry].used_slots) % TX_RING_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 {
1390 int i;
1391 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1392 pci_unmap_single(np->pci_dev,
1393 np->tx_info[entry].mapping,
1394 skb_shinfo(skb)->frags[i].size,
1395 PCI_DMA_TODEVICE);
1396 np->dirty_tx++;
1397 entry++;
1398 }
1399 }
Jeff Garzikfdecea62005-05-12 20:16:24 -04001400
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 dev_kfree_skb_irq(skb);
1402 }
1403 np->tx_done_q[np->tx_done].status = 0;
1404 np->tx_done = (np->tx_done + 1) % DONE_Q_SIZE;
1405 }
1406 writew(np->tx_done, ioaddr + CompletionQConsumerIdx + 2);
1407
1408 if (netif_queue_stopped(dev) &&
1409 (np->cur_tx - np->dirty_tx + 4 < TX_RING_SIZE)) {
1410 /* The ring is no longer full, wake the queue. */
1411 netif_wake_queue(dev);
1412 }
1413
1414 /* Stats overflow */
1415 if (intr_status & IntrStatsMax)
1416 get_stats(dev);
1417
1418 /* Media change interrupt. */
1419 if (intr_status & IntrLinkChange)
1420 netdev_media_change(dev);
1421
1422 /* Abnormal error summary/uncommon events handlers. */
1423 if (intr_status & IntrAbnormalSummary)
1424 netdev_error(dev, intr_status);
1425
1426 if (--boguscnt < 0) {
1427 if (debug > 1)
1428 printk(KERN_WARNING "%s: Too much work at interrupt, "
1429 "status=%#8.8x.\n",
1430 dev->name, intr_status);
1431 break;
1432 }
1433 } while (1);
1434
1435 if (debug > 4)
1436 printk(KERN_DEBUG "%s: exiting interrupt, status=%#8.8x.\n",
1437 dev->name, (int) readl(ioaddr + IntrStatus));
1438 return IRQ_RETVAL(handled);
1439}
1440
1441
Francois Romieua6676012008-07-06 20:54:45 -07001442/*
1443 * This routine is logically part of the interrupt/poll handler, but separated
1444 * for clarity and better register allocation.
1445 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446static int __netdev_rx(struct net_device *dev, int *quota)
1447{
1448 struct netdev_private *np = netdev_priv(dev);
1449 u32 desc_status;
1450 int retcode = 0;
1451
1452 /* If EOP is set on the next entry, it's a new packet. Send it up. */
1453 while ((desc_status = le32_to_cpu(np->rx_done_q[np->rx_done].status)) != 0) {
1454 struct sk_buff *skb;
1455 u16 pkt_len;
1456 int entry;
1457 rx_done_desc *desc = &np->rx_done_q[np->rx_done];
1458
1459 if (debug > 4)
1460 printk(KERN_DEBUG " netdev_rx() status of %d was %#8.8x.\n", np->rx_done, desc_status);
1461 if (!(desc_status & RxOK)) {
Jeff Garzikfdecea62005-05-12 20:16:24 -04001462 /* There was an error. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 if (debug > 2)
1464 printk(KERN_DEBUG " netdev_rx() Rx error was %#8.8x.\n", desc_status);
1465 np->stats.rx_errors++;
1466 if (desc_status & RxFIFOErr)
1467 np->stats.rx_fifo_errors++;
1468 goto next_rx;
1469 }
1470
1471 if (*quota <= 0) { /* out of rx quota */
1472 retcode = 1;
1473 goto out;
1474 }
1475 (*quota)--;
1476
1477 pkt_len = desc_status; /* Implicitly Truncate */
1478 entry = (desc_status >> 16) & 0x7ff;
1479
1480 if (debug > 4)
1481 printk(KERN_DEBUG " netdev_rx() normal Rx pkt length %d, quota %d.\n", pkt_len, *quota);
1482 /* Check if the packet is long enough to accept without copying
1483 to a minimally-sized skbuff. */
Joe Perches8e95a202009-12-03 07:58:21 +00001484 if (pkt_len < rx_copybreak &&
1485 (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 skb_reserve(skb, 2); /* 16 byte align the IP header */
1487 pci_dma_sync_single_for_cpu(np->pci_dev,
1488 np->rx_info[entry].mapping,
1489 pkt_len, PCI_DMA_FROMDEVICE);
David S. Miller8c7b7fa2007-07-10 22:08:12 -07001490 skb_copy_to_linear_data(skb, np->rx_info[entry].skb->data, pkt_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 pci_dma_sync_single_for_device(np->pci_dev,
1492 np->rx_info[entry].mapping,
1493 pkt_len, PCI_DMA_FROMDEVICE);
1494 skb_put(skb, pkt_len);
1495 } else {
1496 pci_unmap_single(np->pci_dev, np->rx_info[entry].mapping, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1497 skb = np->rx_info[entry].skb;
1498 skb_put(skb, pkt_len);
1499 np->rx_info[entry].skb = NULL;
1500 np->rx_info[entry].mapping = 0;
1501 }
1502#ifndef final_version /* Remove after testing. */
1503 /* You will want this info for the initial debug. */
Joe Perches0795af52007-10-03 17:59:30 -07001504 if (debug > 5) {
Johannes Berge1749612008-10-27 15:59:26 -07001505 printk(KERN_DEBUG " Rx data %pM %pM %2.2x%2.2x.\n",
1506 skb->data, skb->data + 6,
Joe Perches0795af52007-10-03 17:59:30 -07001507 skb->data[12], skb->data[13]);
1508 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509#endif
1510
1511 skb->protocol = eth_type_trans(skb, dev);
Jeff Garzikfdecea62005-05-12 20:16:24 -04001512#ifdef VLAN_SUPPORT
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513 if (debug > 4)
1514 printk(KERN_DEBUG " netdev_rx() status2 of %d was %#4.4x.\n", np->rx_done, le16_to_cpu(desc->status2));
1515#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 if (le16_to_cpu(desc->status2) & 0x0100) {
1517 skb->ip_summed = CHECKSUM_UNNECESSARY;
1518 np->stats.rx_compressed++;
1519 }
1520 /*
1521 * This feature doesn't seem to be working, at least
1522 * with the two firmware versions I have. If the GFP sees
1523 * an IP fragment, it either ignores it completely, or reports
1524 * "bad checksum" on it.
1525 *
1526 * Maybe I missed something -- corrections are welcome.
1527 * Until then, the printk stays. :-) -Ion
1528 */
1529 else if (le16_to_cpu(desc->status2) & 0x0040) {
Patrick McHardy84fa7932006-08-29 16:44:56 -07001530 skb->ip_summed = CHECKSUM_COMPLETE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 skb->csum = le16_to_cpu(desc->csum);
1532 printk(KERN_DEBUG "%s: checksum_hw, status2 = %#x\n", dev->name, le16_to_cpu(desc->status2));
1533 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534#ifdef VLAN_SUPPORT
1535 if (np->vlgrp && le16_to_cpu(desc->status2) & 0x0200) {
Francois Romieua6676012008-07-06 20:54:45 -07001536 u16 vlid = le16_to_cpu(desc->vlanid);
1537
1538 if (debug > 4) {
1539 printk(KERN_DEBUG " netdev_rx() vlanid = %d\n",
1540 vlid);
1541 }
1542 /*
1543 * vlan_hwaccel_rx expects a packet with the VLAN tag
1544 * stripped out.
1545 */
1546 vlan_hwaccel_rx(skb, np->vlgrp, vlid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 } else
1548#endif /* VLAN_SUPPORT */
Francois Romieua6676012008-07-06 20:54:45 -07001549 netif_receive_skb(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 np->stats.rx_packets++;
1551
1552 next_rx:
1553 np->cur_rx++;
1554 desc->status = 0;
1555 np->rx_done = (np->rx_done + 1) % DONE_Q_SIZE;
1556 }
Jarek Poplawski9a3de252008-12-16 15:42:20 -08001557
1558 if (*quota == 0) { /* out of rx quota */
1559 retcode = 1;
1560 goto out;
1561 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 writew(np->rx_done, np->base + CompletionQConsumerIdx);
1563
1564 out:
1565 refill_rx_ring(dev);
1566 if (debug > 5)
1567 printk(KERN_DEBUG " exiting netdev_rx(): %d, status of %d was %#8.8x.\n",
1568 retcode, np->rx_done, desc_status);
1569 return retcode;
1570}
1571
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001572static int netdev_poll(struct napi_struct *napi, int budget)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573{
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001574 struct netdev_private *np = container_of(napi, struct netdev_private, napi);
1575 struct net_device *dev = np->dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 u32 intr_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 void __iomem *ioaddr = np->base;
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001578 int quota = budget;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579
1580 do {
1581 writel(IntrRxDone | IntrRxEmpty, ioaddr + IntrClear);
1582
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001583 if (__netdev_rx(dev, &quota))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 goto out;
1585
1586 intr_status = readl(ioaddr + IntrStatus);
1587 } while (intr_status & (IntrRxDone | IntrRxEmpty));
1588
Ben Hutchings288379f2009-01-19 16:43:59 -08001589 napi_complete(napi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 intr_status = readl(ioaddr + IntrEnable);
1591 intr_status |= IntrRxDone | IntrRxEmpty;
1592 writel(intr_status, ioaddr + IntrEnable);
1593
1594 out:
1595 if (debug > 5)
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001596 printk(KERN_DEBUG " exiting netdev_poll(): %d.\n",
1597 budget - quota);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598
1599 /* Restart Rx engine if stopped. */
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001600 return budget - quota;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602
1603static void refill_rx_ring(struct net_device *dev)
1604{
1605 struct netdev_private *np = netdev_priv(dev);
1606 struct sk_buff *skb;
1607 int entry = -1;
1608
1609 /* Refill the Rx ring buffers. */
1610 for (; np->cur_rx - np->dirty_rx > 0; np->dirty_rx++) {
1611 entry = np->dirty_rx % RX_RING_SIZE;
1612 if (np->rx_info[entry].skb == NULL) {
1613 skb = dev_alloc_skb(np->rx_buf_sz);
1614 np->rx_info[entry].skb = skb;
1615 if (skb == NULL)
1616 break; /* Better luck next round. */
1617 np->rx_info[entry].mapping =
David S. Miller689be432005-06-28 15:25:31 -07001618 pci_map_single(np->pci_dev, skb->data, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 skb->dev = dev; /* Mark as being used by this device. */
1620 np->rx_ring[entry].rxaddr =
1621 cpu_to_dma(np->rx_info[entry].mapping | RxDescValid);
1622 }
1623 if (entry == RX_RING_SIZE - 1)
1624 np->rx_ring[entry].rxaddr |= cpu_to_dma(RxDescEndRing);
1625 }
1626 if (entry >= 0)
1627 writew(entry, np->base + RxDescQIdx);
1628}
1629
1630
1631static void netdev_media_change(struct net_device *dev)
1632{
1633 struct netdev_private *np = netdev_priv(dev);
1634 void __iomem *ioaddr = np->base;
1635 u16 reg0, reg1, reg4, reg5;
1636 u32 new_tx_mode;
1637 u32 new_intr_timer_ctrl;
1638
1639 /* reset status first */
1640 mdio_read(dev, np->phys[0], MII_BMCR);
1641 mdio_read(dev, np->phys[0], MII_BMSR);
1642
1643 reg0 = mdio_read(dev, np->phys[0], MII_BMCR);
1644 reg1 = mdio_read(dev, np->phys[0], MII_BMSR);
1645
1646 if (reg1 & BMSR_LSTATUS) {
1647 /* link is up */
1648 if (reg0 & BMCR_ANENABLE) {
1649 /* autonegotiation is enabled */
1650 reg4 = mdio_read(dev, np->phys[0], MII_ADVERTISE);
1651 reg5 = mdio_read(dev, np->phys[0], MII_LPA);
1652 if (reg4 & ADVERTISE_100FULL && reg5 & LPA_100FULL) {
1653 np->speed100 = 1;
1654 np->mii_if.full_duplex = 1;
1655 } else if (reg4 & ADVERTISE_100HALF && reg5 & LPA_100HALF) {
1656 np->speed100 = 1;
1657 np->mii_if.full_duplex = 0;
1658 } else if (reg4 & ADVERTISE_10FULL && reg5 & LPA_10FULL) {
1659 np->speed100 = 0;
1660 np->mii_if.full_duplex = 1;
1661 } else {
1662 np->speed100 = 0;
1663 np->mii_if.full_duplex = 0;
1664 }
1665 } else {
1666 /* autonegotiation is disabled */
1667 if (reg0 & BMCR_SPEED100)
1668 np->speed100 = 1;
1669 else
1670 np->speed100 = 0;
1671 if (reg0 & BMCR_FULLDPLX)
1672 np->mii_if.full_duplex = 1;
1673 else
1674 np->mii_if.full_duplex = 0;
1675 }
1676 netif_carrier_on(dev);
1677 printk(KERN_DEBUG "%s: Link is up, running at %sMbit %s-duplex\n",
1678 dev->name,
1679 np->speed100 ? "100" : "10",
1680 np->mii_if.full_duplex ? "full" : "half");
1681
1682 new_tx_mode = np->tx_mode & ~FullDuplex; /* duplex setting */
1683 if (np->mii_if.full_duplex)
1684 new_tx_mode |= FullDuplex;
1685 if (np->tx_mode != new_tx_mode) {
1686 np->tx_mode = new_tx_mode;
1687 writel(np->tx_mode | MiiSoftReset, ioaddr + TxMode);
1688 udelay(1000);
1689 writel(np->tx_mode, ioaddr + TxMode);
1690 }
1691
1692 new_intr_timer_ctrl = np->intr_timer_ctrl & ~Timer10X;
1693 if (np->speed100)
1694 new_intr_timer_ctrl |= Timer10X;
1695 if (np->intr_timer_ctrl != new_intr_timer_ctrl) {
1696 np->intr_timer_ctrl = new_intr_timer_ctrl;
1697 writel(new_intr_timer_ctrl, ioaddr + IntrTimerCtrl);
1698 }
1699 } else {
1700 netif_carrier_off(dev);
1701 printk(KERN_DEBUG "%s: Link is down\n", dev->name);
1702 }
1703}
1704
1705
1706static void netdev_error(struct net_device *dev, int intr_status)
1707{
1708 struct netdev_private *np = netdev_priv(dev);
1709
1710 /* Came close to underrunning the Tx FIFO, increase threshold. */
1711 if (intr_status & IntrTxDataLow) {
1712 if (np->tx_threshold <= PKT_BUF_SZ / 16) {
1713 writel(++np->tx_threshold, np->base + TxThreshold);
1714 printk(KERN_NOTICE "%s: PCI bus congestion, increasing Tx FIFO threshold to %d bytes\n",
1715 dev->name, np->tx_threshold * 16);
1716 } else
1717 printk(KERN_WARNING "%s: PCI Tx underflow -- adapter is probably malfunctioning\n", dev->name);
1718 }
1719 if (intr_status & IntrRxGFPDead) {
1720 np->stats.rx_fifo_errors++;
1721 np->stats.rx_errors++;
1722 }
1723 if (intr_status & (IntrNoTxCsum | IntrDMAErr)) {
1724 np->stats.tx_fifo_errors++;
1725 np->stats.tx_errors++;
1726 }
1727 if ((intr_status & ~(IntrNormalMask | IntrAbnormalSummary | IntrLinkChange | IntrStatsMax | IntrTxDataLow | IntrRxGFPDead | IntrNoTxCsum | IntrPCIPad)) && debug)
1728 printk(KERN_ERR "%s: Something Wicked happened! %#8.8x.\n",
1729 dev->name, intr_status);
1730}
1731
1732
1733static struct net_device_stats *get_stats(struct net_device *dev)
1734{
1735 struct netdev_private *np = netdev_priv(dev);
1736 void __iomem *ioaddr = np->base;
1737
1738 /* This adapter architecture needs no SMP locks. */
1739 np->stats.tx_bytes = readl(ioaddr + 0x57010);
1740 np->stats.rx_bytes = readl(ioaddr + 0x57044);
1741 np->stats.tx_packets = readl(ioaddr + 0x57000);
1742 np->stats.tx_aborted_errors =
1743 readl(ioaddr + 0x57024) + readl(ioaddr + 0x57028);
1744 np->stats.tx_window_errors = readl(ioaddr + 0x57018);
1745 np->stats.collisions =
1746 readl(ioaddr + 0x57004) + readl(ioaddr + 0x57008);
1747
1748 /* The chip only need report frame silently dropped. */
1749 np->stats.rx_dropped += readw(ioaddr + RxDMAStatus);
1750 writew(0, ioaddr + RxDMAStatus);
1751 np->stats.rx_crc_errors = readl(ioaddr + 0x5703C);
1752 np->stats.rx_frame_errors = readl(ioaddr + 0x57040);
1753 np->stats.rx_length_errors = readl(ioaddr + 0x57058);
1754 np->stats.rx_missed_errors = readl(ioaddr + 0x5707C);
1755
1756 return &np->stats;
1757}
1758
1759
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760static void set_rx_mode(struct net_device *dev)
1761{
1762 struct netdev_private *np = netdev_priv(dev);
1763 void __iomem *ioaddr = np->base;
1764 u32 rx_mode = MinVLANPrio;
Jiri Pirko22bedad32010-04-01 21:22:57 +00001765 struct netdev_hw_addr *ha;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 int i;
1767#ifdef VLAN_SUPPORT
1768
1769 rx_mode |= VlanMode;
1770 if (np->vlgrp) {
1771 int vlan_count = 0;
1772 void __iomem *filter_addr = ioaddr + HashTable + 8;
1773 for (i = 0; i < VLAN_VID_MASK; i++) {
Dan Aloni5c15bde2007-03-02 20:44:51 -08001774 if (vlan_group_get_device(np->vlgrp, i)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 if (vlan_count >= 32)
1776 break;
Al Viro813820b2007-12-09 17:00:54 +00001777 writew(i, filter_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 filter_addr += 16;
1779 vlan_count++;
1780 }
1781 }
1782 if (i == VLAN_VID_MASK) {
1783 rx_mode |= PerfectFilterVlan;
1784 while (vlan_count < 32) {
1785 writew(0, filter_addr);
1786 filter_addr += 16;
1787 vlan_count++;
1788 }
1789 }
1790 }
1791#endif /* VLAN_SUPPORT */
1792
1793 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
1794 rx_mode |= AcceptAll;
Jiri Pirko4cd24ea2010-02-08 04:30:35 +00001795 } else if ((netdev_mc_count(dev) > multicast_filter_limit) ||
Joe Perches8e95a202009-12-03 07:58:21 +00001796 (dev->flags & IFF_ALLMULTI)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 /* Too many to match, or accept all multicasts. */
1798 rx_mode |= AcceptBroadcast|AcceptAllMulticast|PerfectFilter;
Jiri Pirko4cd24ea2010-02-08 04:30:35 +00001799 } else if (netdev_mc_count(dev) <= 14) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 /* Use the 16 element perfect filter, skip first two entries. */
1801 void __iomem *filter_addr = ioaddr + PerfFilterTable + 2 * 16;
Al Viro88b19432007-08-23 02:29:45 -04001802 __be16 *eaddrs;
Jiri Pirko22bedad32010-04-01 21:22:57 +00001803 netdev_for_each_mc_addr(ha, dev) {
1804 eaddrs = (__be16 *) ha->addr;
Al Viro88b19432007-08-23 02:29:45 -04001805 writew(be16_to_cpu(eaddrs[2]), filter_addr); filter_addr += 4;
1806 writew(be16_to_cpu(eaddrs[1]), filter_addr); filter_addr += 4;
1807 writew(be16_to_cpu(eaddrs[0]), filter_addr); filter_addr += 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 }
Al Viro88b19432007-08-23 02:29:45 -04001809 eaddrs = (__be16 *)dev->dev_addr;
Jiri Pirko55085902010-02-18 00:42:54 +00001810 i = netdev_mc_count(dev) + 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 while (i++ < 16) {
Al Viro88b19432007-08-23 02:29:45 -04001812 writew(be16_to_cpu(eaddrs[0]), filter_addr); filter_addr += 4;
1813 writew(be16_to_cpu(eaddrs[1]), filter_addr); filter_addr += 4;
1814 writew(be16_to_cpu(eaddrs[2]), filter_addr); filter_addr += 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 }
1816 rx_mode |= AcceptBroadcast|PerfectFilter;
1817 } else {
1818 /* Must use a multicast hash table. */
1819 void __iomem *filter_addr;
Al Viro88b19432007-08-23 02:29:45 -04001820 __be16 *eaddrs;
1821 __le16 mc_filter[32] __attribute__ ((aligned(sizeof(long)))); /* Multicast hash filter */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822
1823 memset(mc_filter, 0, sizeof(mc_filter));
Jiri Pirko22bedad32010-04-01 21:22:57 +00001824 netdev_for_each_mc_addr(ha, dev) {
Jeff Garzikfdecea62005-05-12 20:16:24 -04001825 /* The chip uses the upper 9 CRC bits
1826 as index into the hash table */
Jiri Pirko22bedad32010-04-01 21:22:57 +00001827 int bit_nr = ether_crc_le(ETH_ALEN, ha->addr) >> 23;
Al Viro88b19432007-08-23 02:29:45 -04001828 __le32 *fptr = (__le32 *) &mc_filter[(bit_nr >> 4) & ~1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829
1830 *fptr |= cpu_to_le32(1 << (bit_nr & 31));
1831 }
1832 /* Clear the perfect filter list, skip first two entries. */
1833 filter_addr = ioaddr + PerfFilterTable + 2 * 16;
Al Viro88b19432007-08-23 02:29:45 -04001834 eaddrs = (__be16 *)dev->dev_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 for (i = 2; i < 16; i++) {
Al Viro88b19432007-08-23 02:29:45 -04001836 writew(be16_to_cpu(eaddrs[0]), filter_addr); filter_addr += 4;
1837 writew(be16_to_cpu(eaddrs[1]), filter_addr); filter_addr += 4;
1838 writew(be16_to_cpu(eaddrs[2]), filter_addr); filter_addr += 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 }
1840 for (filter_addr = ioaddr + HashTable, i = 0; i < 32; filter_addr+= 16, i++)
1841 writew(mc_filter[i], filter_addr);
1842 rx_mode |= AcceptBroadcast|PerfectFilter|HashFilter;
1843 }
1844 writel(rx_mode, ioaddr + RxFilterMode);
1845}
1846
1847static int check_if_running(struct net_device *dev)
1848{
1849 if (!netif_running(dev))
1850 return -EINVAL;
1851 return 0;
1852}
1853
1854static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1855{
1856 struct netdev_private *np = netdev_priv(dev);
1857 strcpy(info->driver, DRV_NAME);
1858 strcpy(info->version, DRV_VERSION);
Jeff Garzikfdecea62005-05-12 20:16:24 -04001859 strcpy(info->bus_info, pci_name(np->pci_dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860}
1861
1862static int get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1863{
1864 struct netdev_private *np = netdev_priv(dev);
1865 spin_lock_irq(&np->lock);
1866 mii_ethtool_gset(&np->mii_if, ecmd);
1867 spin_unlock_irq(&np->lock);
1868 return 0;
1869}
1870
1871static int set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1872{
1873 struct netdev_private *np = netdev_priv(dev);
1874 int res;
1875 spin_lock_irq(&np->lock);
1876 res = mii_ethtool_sset(&np->mii_if, ecmd);
1877 spin_unlock_irq(&np->lock);
1878 check_duplex(dev);
1879 return res;
1880}
1881
1882static int nway_reset(struct net_device *dev)
1883{
1884 struct netdev_private *np = netdev_priv(dev);
1885 return mii_nway_restart(&np->mii_if);
1886}
1887
1888static u32 get_link(struct net_device *dev)
1889{
1890 struct netdev_private *np = netdev_priv(dev);
1891 return mii_link_ok(&np->mii_if);
1892}
1893
1894static u32 get_msglevel(struct net_device *dev)
1895{
1896 return debug;
1897}
1898
1899static void set_msglevel(struct net_device *dev, u32 val)
1900{
1901 debug = val;
1902}
1903
Jeff Garzik7282d492006-09-13 14:30:00 -04001904static const struct ethtool_ops ethtool_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 .begin = check_if_running,
1906 .get_drvinfo = get_drvinfo,
1907 .get_settings = get_settings,
1908 .set_settings = set_settings,
1909 .nway_reset = nway_reset,
1910 .get_link = get_link,
1911 .get_msglevel = get_msglevel,
1912 .set_msglevel = set_msglevel,
1913};
1914
1915static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1916{
1917 struct netdev_private *np = netdev_priv(dev);
1918 struct mii_ioctl_data *data = if_mii(rq);
1919 int rc;
1920
1921 if (!netif_running(dev))
1922 return -EINVAL;
1923
1924 spin_lock_irq(&np->lock);
1925 rc = generic_mii_ioctl(&np->mii_if, data, cmd, NULL);
1926 spin_unlock_irq(&np->lock);
1927
1928 if ((cmd == SIOCSMIIREG) && (data->phy_id == np->phys[0]))
1929 check_duplex(dev);
1930
1931 return rc;
1932}
1933
1934static int netdev_close(struct net_device *dev)
1935{
1936 struct netdev_private *np = netdev_priv(dev);
1937 void __iomem *ioaddr = np->base;
1938 int i;
1939
1940 netif_stop_queue(dev);
Francois Romieua6676012008-07-06 20:54:45 -07001941
Stephen Hemmingerbea33482007-10-03 16:41:36 -07001942 napi_disable(&np->napi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943
1944 if (debug > 1) {
1945 printk(KERN_DEBUG "%s: Shutting down ethercard, Intr status %#8.8x.\n",
1946 dev->name, (int) readl(ioaddr + IntrStatus));
1947 printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d, Rx %d / %d.\n",
1948 dev->name, np->cur_tx, np->dirty_tx,
1949 np->cur_rx, np->dirty_rx);
1950 }
1951
1952 /* Disable interrupts by clearing the interrupt mask. */
1953 writel(0, ioaddr + IntrEnable);
1954
1955 /* Stop the chip's Tx and Rx processes. */
1956 writel(0, ioaddr + GenCtrl);
1957 readl(ioaddr + GenCtrl);
1958
1959 if (debug > 5) {
1960 printk(KERN_DEBUG" Tx ring at %#llx:\n",
1961 (long long) np->tx_ring_dma);
1962 for (i = 0; i < 8 /* TX_RING_SIZE is huge! */; i++)
1963 printk(KERN_DEBUG " #%d desc. %#8.8x %#llx -> %#8.8x.\n",
1964 i, le32_to_cpu(np->tx_ring[i].status),
1965 (long long) dma_to_cpu(np->tx_ring[i].addr),
1966 le32_to_cpu(np->tx_done_q[i].status));
1967 printk(KERN_DEBUG " Rx ring at %#llx -> %p:\n",
1968 (long long) np->rx_ring_dma, np->rx_done_q);
1969 if (np->rx_done_q)
1970 for (i = 0; i < 8 /* RX_RING_SIZE */; i++) {
1971 printk(KERN_DEBUG " #%d desc. %#llx -> %#8.8x\n",
1972 i, (long long) dma_to_cpu(np->rx_ring[i].rxaddr), le32_to_cpu(np->rx_done_q[i].status));
1973 }
1974 }
1975
1976 free_irq(dev->irq, dev);
1977
1978 /* Free all the skbuffs in the Rx queue. */
1979 for (i = 0; i < RX_RING_SIZE; i++) {
1980 np->rx_ring[i].rxaddr = cpu_to_dma(0xBADF00D0); /* An invalid address. */
1981 if (np->rx_info[i].skb != NULL) {
1982 pci_unmap_single(np->pci_dev, np->rx_info[i].mapping, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
1983 dev_kfree_skb(np->rx_info[i].skb);
1984 }
1985 np->rx_info[i].skb = NULL;
1986 np->rx_info[i].mapping = 0;
1987 }
1988 for (i = 0; i < TX_RING_SIZE; i++) {
1989 struct sk_buff *skb = np->tx_info[i].skb;
1990 if (skb == NULL)
1991 continue;
1992 pci_unmap_single(np->pci_dev,
1993 np->tx_info[i].mapping,
1994 skb_first_frag_len(skb), PCI_DMA_TODEVICE);
1995 np->tx_info[i].mapping = 0;
1996 dev_kfree_skb(skb);
1997 np->tx_info[i].skb = NULL;
1998 }
1999
2000 return 0;
2001}
2002
Stefan Rompfd4fbeab2006-01-17 22:52:51 +01002003#ifdef CONFIG_PM
2004static int starfire_suspend(struct pci_dev *pdev, pm_message_t state)
2005{
2006 struct net_device *dev = pci_get_drvdata(pdev);
2007
2008 if (netif_running(dev)) {
2009 netif_device_detach(dev);
2010 netdev_close(dev);
2011 }
2012
2013 pci_save_state(pdev);
2014 pci_set_power_state(pdev, pci_choose_state(pdev,state));
2015
2016 return 0;
2017}
2018
2019static int starfire_resume(struct pci_dev *pdev)
2020{
2021 struct net_device *dev = pci_get_drvdata(pdev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04002022
Stefan Rompfd4fbeab2006-01-17 22:52:51 +01002023 pci_set_power_state(pdev, PCI_D0);
2024 pci_restore_state(pdev);
2025
2026 if (netif_running(dev)) {
2027 netdev_open(dev);
2028 netif_device_attach(dev);
2029 }
2030
2031 return 0;
2032}
2033#endif /* CONFIG_PM */
2034
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035
2036static void __devexit starfire_remove_one (struct pci_dev *pdev)
2037{
2038 struct net_device *dev = pci_get_drvdata(pdev);
2039 struct netdev_private *np = netdev_priv(dev);
2040
Eric Sesterhenn5d9428d2006-04-02 13:52:48 +02002041 BUG_ON(!dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042
2043 unregister_netdev(dev);
2044
2045 if (np->queue_mem)
2046 pci_free_consistent(pdev, np->queue_mem_size, np->queue_mem, np->queue_mem_dma);
2047
2048
2049 /* XXX: add wakeup code -- requires firmware for MagicPacket */
2050 pci_set_power_state(pdev, PCI_D3hot); /* go to sleep in D3 mode */
2051 pci_disable_device(pdev);
2052
2053 iounmap(np->base);
2054 pci_release_regions(pdev);
2055
2056 pci_set_drvdata(pdev, NULL);
2057 free_netdev(dev); /* Will also free np!! */
2058}
2059
2060
2061static struct pci_driver starfire_driver = {
2062 .name = DRV_NAME,
2063 .probe = starfire_init_one,
2064 .remove = __devexit_p(starfire_remove_one),
Stefan Rompfd4fbeab2006-01-17 22:52:51 +01002065#ifdef CONFIG_PM
2066 .suspend = starfire_suspend,
2067 .resume = starfire_resume,
2068#endif /* CONFIG_PM */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069 .id_table = starfire_pci_tbl,
2070};
2071
2072
2073static int __init starfire_init (void)
2074{
2075/* when a module, this is printed whether or not devices are found in probe */
2076#ifdef MODULE
2077 printk(version);
Francois Romieua6676012008-07-06 20:54:45 -07002078
Jeff Garzikfdecea62005-05-12 20:16:24 -04002079 printk(KERN_INFO DRV_NAME ": polling (NAPI) enabled\n");
Jeff Garzikfdecea62005-05-12 20:16:24 -04002080#endif
2081
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 /* we can do this test only at run-time... sigh */
Ion Badulescu67974232005-10-03 22:31:36 -04002083 if (sizeof(dma_addr_t) != sizeof(netdrv_addr_t)) {
2084 printk("This driver has dma_addr_t issues, please send email to maintainer\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085 return -ENODEV;
2086 }
Ion Badulescu67974232005-10-03 22:31:36 -04002087
Jeff Garzik29917622006-08-19 17:48:59 -04002088 return pci_register_driver(&starfire_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089}
2090
2091
2092static void __exit starfire_cleanup (void)
2093{
2094 pci_unregister_driver (&starfire_driver);
2095}
2096
2097
2098module_init(starfire_init);
2099module_exit(starfire_cleanup);
2100
2101
2102/*
2103 * Local variables:
2104 * c-basic-offset: 8
2105 * tab-width: 8
2106 * End:
2107 */