[NETFILTER]: Remove IPv4 only connection tracking/NAT
[linux-2.6] / drivers / net / yellowfin.c
1 /* yellowfin.c: A Packet Engines G-NIC ethernet driver for linux. */
2 /*
3         Written 1997-2001 by Donald Becker.
4
5         This software may be used and distributed according to the terms of
6         the GNU General Public License (GPL), incorporated herein by reference.
7         Drivers based on or derived from this code fall under the GPL and must
8         retain the authorship, copyright and license notice.  This file is not
9         a complete program and may only be used when the entire operating
10         system is licensed under the GPL.
11
12         This driver is for the Packet Engines G-NIC PCI Gigabit Ethernet adapter.
13         It also supports the Symbios Logic version of the same chip core.
14
15         The author may be reached as becker@scyld.com, or C/O
16         Scyld Computing Corporation
17         410 Severn Ave., Suite 210
18         Annapolis MD 21403
19
20         Support and updates available at
21         http://www.scyld.com/network/yellowfin.html
22         [link no longer provides useful info -jgarzik]
23
24 */
25
26 #define DRV_NAME        "yellowfin"
27 #define DRV_VERSION     "2.1"
28 #define DRV_RELDATE     "Sep 11, 2006"
29
30 #define PFX DRV_NAME ": "
31
32 /* The user-configurable values.
33    These may be modified when a driver module is loaded.*/
34
35 static int debug = 1;                   /* 1 normal messages, 0 quiet .. 7 verbose. */
36 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
37 static int max_interrupt_work = 20;
38 static int mtu;
39 #ifdef YF_PROTOTYPE                     /* Support for prototype hardware errata. */
40 /* System-wide count of bogus-rx frames. */
41 static int bogus_rx;
42 static int dma_ctrl = 0x004A0263;                       /* Constrained by errata */
43 static int fifo_cfg = 0x0020;                           /* Bypass external Tx FIFO. */
44 #elif defined(YF_NEW)                                   /* A future perfect board :->.  */
45 static int dma_ctrl = 0x00CAC277;                       /* Override when loading module! */
46 static int fifo_cfg = 0x0028;
47 #else
48 static const int dma_ctrl = 0x004A0263;                         /* Constrained by errata */
49 static const int fifo_cfg = 0x0020;                             /* Bypass external Tx FIFO. */
50 #endif
51
52 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
53    Setting to > 1514 effectively disables this feature. */
54 static int rx_copybreak;
55
56 /* Used to pass the media type, etc.
57    No media types are currently defined.  These exist for driver
58    interoperability.
59 */
60 #define MAX_UNITS 8                             /* More are supported, limit only on options */
61 static int options[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
62 static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
63
64 /* Do ugly workaround for GX server chipset errata. */
65 static int gx_fix;
66
67 /* Operational parameters that are set at compile time. */
68
69 /* Keep the ring sizes a power of two for efficiency.
70    Making the Tx ring too long decreases the effectiveness of channel
71    bonding and packet priority.
72    There are no ill effects from too-large receive rings. */
73 #define TX_RING_SIZE    16
74 #define TX_QUEUE_SIZE   12              /* Must be > 4 && <= TX_RING_SIZE */
75 #define RX_RING_SIZE    64
76 #define STATUS_TOTAL_SIZE       TX_RING_SIZE*sizeof(struct tx_status_words)
77 #define TX_TOTAL_SIZE           2*TX_RING_SIZE*sizeof(struct yellowfin_desc)
78 #define RX_TOTAL_SIZE           RX_RING_SIZE*sizeof(struct yellowfin_desc)
79
80 /* Operational parameters that usually are not changed. */
81 /* Time in jiffies before concluding the transmitter is hung. */
82 #define TX_TIMEOUT  (2*HZ)
83 #define PKT_BUF_SZ              1536                    /* Size of each temporary Rx buffer.*/
84
85 #define yellowfin_debug debug
86
87 #include <linux/module.h>
88 #include <linux/kernel.h>
89 #include <linux/string.h>
90 #include <linux/timer.h>
91 #include <linux/errno.h>
92 #include <linux/ioport.h>
93 #include <linux/slab.h>
94 #include <linux/interrupt.h>
95 #include <linux/pci.h>
96 #include <linux/init.h>
97 #include <linux/mii.h>
98 #include <linux/netdevice.h>
99 #include <linux/etherdevice.h>
100 #include <linux/skbuff.h>
101 #include <linux/ethtool.h>
102 #include <linux/crc32.h>
103 #include <linux/bitops.h>
104 #include <asm/uaccess.h>
105 #include <asm/processor.h>              /* Processor type for cache alignment. */
106 #include <asm/unaligned.h>
107 #include <asm/io.h>
108
109 /* These identify the driver base version and may not be removed. */
110 static char version[] __devinitdata =
111 KERN_INFO DRV_NAME ".c:v1.05  1/09/2001  Written by Donald Becker <becker@scyld.com>\n"
112 KERN_INFO "  http://www.scyld.com/network/yellowfin.html\n"
113 KERN_INFO "  (unofficial 2.4.x port, " DRV_VERSION ", " DRV_RELDATE ")\n";
114
115 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
116 MODULE_DESCRIPTION("Packet Engines Yellowfin G-NIC Gigabit Ethernet driver");
117 MODULE_LICENSE("GPL");
118
119 module_param(max_interrupt_work, int, 0);
120 module_param(mtu, int, 0);
121 module_param(debug, int, 0);
122 module_param(rx_copybreak, int, 0);
123 module_param_array(options, int, NULL, 0);
124 module_param_array(full_duplex, int, NULL, 0);
125 module_param(gx_fix, int, 0);
126 MODULE_PARM_DESC(max_interrupt_work, "G-NIC maximum events handled per interrupt");
127 MODULE_PARM_DESC(mtu, "G-NIC MTU (all boards)");
128 MODULE_PARM_DESC(debug, "G-NIC debug level (0-7)");
129 MODULE_PARM_DESC(rx_copybreak, "G-NIC copy breakpoint for copy-only-tiny-frames");
130 MODULE_PARM_DESC(options, "G-NIC: Bits 0-3: media type, bit 17: full duplex");
131 MODULE_PARM_DESC(full_duplex, "G-NIC full duplex setting(s) (1)");
132 MODULE_PARM_DESC(gx_fix, "G-NIC: enable GX server chipset bug workaround (0-1)");
133
134 /*
135                                 Theory of Operation
136
137 I. Board Compatibility
138
139 This device driver is designed for the Packet Engines "Yellowfin" Gigabit
140 Ethernet adapter.  The G-NIC 64-bit PCI card is supported, as well as the
141 Symbios 53C885E dual function chip.
142
143 II. Board-specific settings
144
145 PCI bus devices are configured by the system at boot time, so no jumpers
146 need to be set on the board.  The system BIOS preferably should assign the
147 PCI INTA signal to an otherwise unused system IRQ line.
148 Note: Kernel versions earlier than 1.3.73 do not support shared PCI
149 interrupt lines.
150
151 III. Driver operation
152
153 IIIa. Ring buffers
154
155 The Yellowfin uses the Descriptor Based DMA Architecture specified by Apple.
156 This is a descriptor list scheme similar to that used by the EEPro100 and
157 Tulip.  This driver uses two statically allocated fixed-size descriptor lists
158 formed into rings by a branch from the final descriptor to the beginning of
159 the list.  The ring sizes are set at compile time by RX/TX_RING_SIZE.
160
161 The driver allocates full frame size skbuffs for the Rx ring buffers at
162 open() time and passes the skb->data field to the Yellowfin as receive data
163 buffers.  When an incoming frame is less than RX_COPYBREAK bytes long,
164 a fresh skbuff is allocated and the frame is copied to the new skbuff.
165 When the incoming frame is larger, the skbuff is passed directly up the
166 protocol stack and replaced by a newly allocated skbuff.
167
168 The RX_COPYBREAK value is chosen to trade-off the memory wasted by
169 using a full-sized skbuff for small frames vs. the copying costs of larger
170 frames.  For small frames the copying cost is negligible (esp. considering
171 that we are pre-loading the cache with immediately useful header
172 information).  For large frames the copying cost is non-trivial, and the
173 larger copy might flush the cache of useful data.
174
175 IIIC. Synchronization
176
177 The driver runs as two independent, single-threaded flows of control.  One
178 is the send-packet routine, which enforces single-threaded use by the
179 dev->tbusy flag.  The other thread is the interrupt handler, which is single
180 threaded by the hardware and other software.
181
182 The send packet thread has partial control over the Tx ring and 'dev->tbusy'
183 flag.  It sets the tbusy flag whenever it's queuing a Tx packet. If the next
184 queue slot is empty, it clears the tbusy flag when finished otherwise it sets
185 the 'yp->tx_full' flag.
186
187 The interrupt handler has exclusive control over the Rx ring and records stats
188 from the Tx ring.  After reaping the stats, it marks the Tx queue entry as
189 empty by incrementing the dirty_tx mark. Iff the 'yp->tx_full' flag is set, it
190 clears both the tx_full and tbusy flags.
191
192 IV. Notes
193
194 Thanks to Kim Stearns of Packet Engines for providing a pair of G-NIC boards.
195 Thanks to Bruce Faust of Digitalscape for providing both their SYM53C885 board
196 and an AlphaStation to verifty the Alpha port!
197
198 IVb. References
199
200 Yellowfin Engineering Design Specification, 4/23/97 Preliminary/Confidential
201 Symbios SYM53C885 PCI-SCSI/Fast Ethernet Multifunction Controller Preliminary
202    Data Manual v3.0
203 http://cesdis.gsfc.nasa.gov/linux/misc/NWay.html
204 http://cesdis.gsfc.nasa.gov/linux/misc/100mbps.html
205
206 IVc. Errata
207
208 See Packet Engines confidential appendix (prototype chips only).
209 */
210
211
212
213 enum capability_flags {
214         HasMII=1, FullTxStatus=2, IsGigabit=4, HasMulticastBug=8, FullRxStatus=16,
215         HasMACAddrBug=32, /* Only on early revs.  */
216         DontUseEeprom=64, /* Don't read the MAC from the EEPROm. */
217 };
218
219 /* The PCI I/O space extent. */
220 enum {
221         YELLOWFIN_SIZE  = 0x100,
222 };
223
224 struct pci_id_info {
225         const char *name;
226         struct match_info {
227                 int     pci, pci_mask, subsystem, subsystem_mask;
228                 int revision, revision_mask;                            /* Only 8 bits. */
229         } id;
230         int drv_flags;                          /* Driver use, intended as capability flags. */
231 };
232
233 static const struct pci_id_info pci_id_tbl[] = {
234         {"Yellowfin G-NIC Gigabit Ethernet", { 0x07021000, 0xffffffff},
235          FullTxStatus | IsGigabit | HasMulticastBug | HasMACAddrBug | DontUseEeprom},
236         {"Symbios SYM83C885", { 0x07011000, 0xffffffff},
237           HasMII | DontUseEeprom },
238         { }
239 };
240
241 static const struct pci_device_id yellowfin_pci_tbl[] = {
242         { 0x1000, 0x0702, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
243         { 0x1000, 0x0701, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
244         { }
245 };
246 MODULE_DEVICE_TABLE (pci, yellowfin_pci_tbl);
247
248
249 /* Offsets to the Yellowfin registers.  Various sizes and alignments. */
250 enum yellowfin_offsets {
251         TxCtrl=0x00, TxStatus=0x04, TxPtr=0x0C,
252         TxIntrSel=0x10, TxBranchSel=0x14, TxWaitSel=0x18,
253         RxCtrl=0x40, RxStatus=0x44, RxPtr=0x4C,
254         RxIntrSel=0x50, RxBranchSel=0x54, RxWaitSel=0x58,
255         EventStatus=0x80, IntrEnb=0x82, IntrClear=0x84, IntrStatus=0x86,
256         ChipRev=0x8C, DMACtrl=0x90, TxThreshold=0x94,
257         Cnfg=0xA0, FrameGap0=0xA2, FrameGap1=0xA4,
258         MII_Cmd=0xA6, MII_Addr=0xA8, MII_Wr_Data=0xAA, MII_Rd_Data=0xAC,
259         MII_Status=0xAE,
260         RxDepth=0xB8, FlowCtrl=0xBC,
261         AddrMode=0xD0, StnAddr=0xD2, HashTbl=0xD8, FIFOcfg=0xF8,
262         EEStatus=0xF0, EECtrl=0xF1, EEAddr=0xF2, EERead=0xF3, EEWrite=0xF4,
263         EEFeature=0xF5,
264 };
265
266 /* The Yellowfin Rx and Tx buffer descriptors.
267    Elements are written as 32 bit for endian portability. */
268 struct yellowfin_desc {
269         u32 dbdma_cmd;
270         u32 addr;
271         u32 branch_addr;
272         u32 result_status;
273 };
274
275 struct tx_status_words {
276 #ifdef __BIG_ENDIAN
277         u16 tx_errs;
278         u16 tx_cnt;
279         u16 paused;
280         u16 total_tx_cnt;
281 #else  /* Little endian chips. */
282         u16 tx_cnt;
283         u16 tx_errs;
284         u16 total_tx_cnt;
285         u16 paused;
286 #endif /* __BIG_ENDIAN */
287 };
288
289 /* Bits in yellowfin_desc.cmd */
290 enum desc_cmd_bits {
291         CMD_TX_PKT=0x10000000, CMD_RX_BUF=0x20000000, CMD_TXSTATUS=0x30000000,
292         CMD_NOP=0x60000000, CMD_STOP=0x70000000,
293         BRANCH_ALWAYS=0x0C0000, INTR_ALWAYS=0x300000, WAIT_ALWAYS=0x030000,
294         BRANCH_IFTRUE=0x040000,
295 };
296
297 /* Bits in yellowfin_desc.status */
298 enum desc_status_bits { RX_EOP=0x0040, };
299
300 /* Bits in the interrupt status/mask registers. */
301 enum intr_status_bits {
302         IntrRxDone=0x01, IntrRxInvalid=0x02, IntrRxPCIFault=0x04,IntrRxPCIErr=0x08,
303         IntrTxDone=0x10, IntrTxInvalid=0x20, IntrTxPCIFault=0x40,IntrTxPCIErr=0x80,
304         IntrEarlyRx=0x100, IntrWakeup=0x200, };
305
306 #define PRIV_ALIGN      31      /* Required alignment mask */
307 #define MII_CNT         4
308 struct yellowfin_private {
309         /* Descriptor rings first for alignment.
310            Tx requires a second descriptor for status. */
311         struct yellowfin_desc *rx_ring;
312         struct yellowfin_desc *tx_ring;
313         struct sk_buff* rx_skbuff[RX_RING_SIZE];
314         struct sk_buff* tx_skbuff[TX_RING_SIZE];
315         dma_addr_t rx_ring_dma;
316         dma_addr_t tx_ring_dma;
317
318         struct tx_status_words *tx_status;
319         dma_addr_t tx_status_dma;
320
321         struct timer_list timer;        /* Media selection timer. */
322         struct net_device_stats stats;
323         /* Frequently used and paired value: keep adjacent for cache effect. */
324         int chip_id, drv_flags;
325         struct pci_dev *pci_dev;
326         unsigned int cur_rx, dirty_rx;          /* Producer/consumer ring indices */
327         unsigned int rx_buf_sz;                         /* Based on MTU+slack. */
328         struct tx_status_words *tx_tail_desc;
329         unsigned int cur_tx, dirty_tx;
330         int tx_threshold;
331         unsigned int tx_full:1;                         /* The Tx queue is full. */
332         unsigned int full_duplex:1;                     /* Full-duplex operation requested. */
333         unsigned int duplex_lock:1;
334         unsigned int medialock:1;                       /* Do not sense media. */
335         unsigned int default_port:4;            /* Last dev->if_port value. */
336         /* MII transceiver section. */
337         int mii_cnt;                                            /* MII device addresses. */
338         u16 advertising;                                        /* NWay media advertisement */
339         unsigned char phys[MII_CNT];            /* MII device addresses, only first one used */
340         spinlock_t lock;
341         void __iomem *base;
342 };
343
344 static int read_eeprom(void __iomem *ioaddr, int location);
345 static int mdio_read(void __iomem *ioaddr, int phy_id, int location);
346 static void mdio_write(void __iomem *ioaddr, int phy_id, int location, int value);
347 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
348 static int yellowfin_open(struct net_device *dev);
349 static void yellowfin_timer(unsigned long data);
350 static void yellowfin_tx_timeout(struct net_device *dev);
351 static void yellowfin_init_ring(struct net_device *dev);
352 static int yellowfin_start_xmit(struct sk_buff *skb, struct net_device *dev);
353 static irqreturn_t yellowfin_interrupt(int irq, void *dev_instance);
354 static int yellowfin_rx(struct net_device *dev);
355 static void yellowfin_error(struct net_device *dev, int intr_status);
356 static int yellowfin_close(struct net_device *dev);
357 static struct net_device_stats *yellowfin_get_stats(struct net_device *dev);
358 static void set_rx_mode(struct net_device *dev);
359 static const struct ethtool_ops ethtool_ops;
360
361
362 static int __devinit yellowfin_init_one(struct pci_dev *pdev,
363                                         const struct pci_device_id *ent)
364 {
365         struct net_device *dev;
366         struct yellowfin_private *np;
367         int irq;
368         int chip_idx = ent->driver_data;
369         static int find_cnt;
370         void __iomem *ioaddr;
371         int i, option = find_cnt < MAX_UNITS ? options[find_cnt] : 0;
372         int drv_flags = pci_id_tbl[chip_idx].drv_flags;
373         void *ring_space;
374         dma_addr_t ring_dma;
375 #ifdef USE_IO_OPS
376         int bar = 0;
377 #else
378         int bar = 1;
379 #endif
380
381 /* when built into the kernel, we only print version if device is found */
382 #ifndef MODULE
383         static int printed_version;
384         if (!printed_version++)
385                 printk(version);
386 #endif
387
388         i = pci_enable_device(pdev);
389         if (i) return i;
390
391         dev = alloc_etherdev(sizeof(*np));
392         if (!dev) {
393                 printk (KERN_ERR PFX "cannot allocate ethernet device\n");
394                 return -ENOMEM;
395         }
396         SET_MODULE_OWNER(dev);
397         SET_NETDEV_DEV(dev, &pdev->dev);
398
399         np = netdev_priv(dev);
400
401         if (pci_request_regions(pdev, DRV_NAME))
402                 goto err_out_free_netdev;
403
404         pci_set_master (pdev);
405
406         ioaddr = pci_iomap(pdev, bar, YELLOWFIN_SIZE);
407         if (!ioaddr)
408                 goto err_out_free_res;
409
410         irq = pdev->irq;
411
412         if (drv_flags & DontUseEeprom)
413                 for (i = 0; i < 6; i++)
414                         dev->dev_addr[i] = ioread8(ioaddr + StnAddr + i);
415         else {
416                 int ee_offset = (read_eeprom(ioaddr, 6) == 0xff ? 0x100 : 0);
417                 for (i = 0; i < 6; i++)
418                         dev->dev_addr[i] = read_eeprom(ioaddr, ee_offset + i);
419         }
420
421         /* Reset the chip. */
422         iowrite32(0x80000000, ioaddr + DMACtrl);
423
424         dev->base_addr = (unsigned long)ioaddr;
425         dev->irq = irq;
426
427         pci_set_drvdata(pdev, dev);
428         spin_lock_init(&np->lock);
429
430         np->pci_dev = pdev;
431         np->chip_id = chip_idx;
432         np->drv_flags = drv_flags;
433         np->base = ioaddr;
434
435         ring_space = pci_alloc_consistent(pdev, TX_TOTAL_SIZE, &ring_dma);
436         if (!ring_space)
437                 goto err_out_cleardev;
438         np->tx_ring = (struct yellowfin_desc *)ring_space;
439         np->tx_ring_dma = ring_dma;
440
441         ring_space = pci_alloc_consistent(pdev, RX_TOTAL_SIZE, &ring_dma);
442         if (!ring_space)
443                 goto err_out_unmap_tx;
444         np->rx_ring = (struct yellowfin_desc *)ring_space;
445         np->rx_ring_dma = ring_dma;
446
447         ring_space = pci_alloc_consistent(pdev, STATUS_TOTAL_SIZE, &ring_dma);
448         if (!ring_space)
449                 goto err_out_unmap_rx;
450         np->tx_status = (struct tx_status_words *)ring_space;
451         np->tx_status_dma = ring_dma;
452
453         if (dev->mem_start)
454                 option = dev->mem_start;
455
456         /* The lower four bits are the media type. */
457         if (option > 0) {
458                 if (option & 0x200)
459                         np->full_duplex = 1;
460                 np->default_port = option & 15;
461                 if (np->default_port)
462                         np->medialock = 1;
463         }
464         if (find_cnt < MAX_UNITS  &&  full_duplex[find_cnt] > 0)
465                 np->full_duplex = 1;
466
467         if (np->full_duplex)
468                 np->duplex_lock = 1;
469
470         /* The Yellowfin-specific entries in the device structure. */
471         dev->open = &yellowfin_open;
472         dev->hard_start_xmit = &yellowfin_start_xmit;
473         dev->stop = &yellowfin_close;
474         dev->get_stats = &yellowfin_get_stats;
475         dev->set_multicast_list = &set_rx_mode;
476         dev->do_ioctl = &netdev_ioctl;
477         SET_ETHTOOL_OPS(dev, &ethtool_ops);
478         dev->tx_timeout = yellowfin_tx_timeout;
479         dev->watchdog_timeo = TX_TIMEOUT;
480
481         if (mtu)
482                 dev->mtu = mtu;
483
484         i = register_netdev(dev);
485         if (i)
486                 goto err_out_unmap_status;
487
488         printk(KERN_INFO "%s: %s type %8x at %p, ",
489                    dev->name, pci_id_tbl[chip_idx].name,
490                    ioread32(ioaddr + ChipRev), ioaddr);
491         for (i = 0; i < 5; i++)
492                         printk("%2.2x:", dev->dev_addr[i]);
493         printk("%2.2x, IRQ %d.\n", dev->dev_addr[i], irq);
494
495         if (np->drv_flags & HasMII) {
496                 int phy, phy_idx = 0;
497                 for (phy = 0; phy < 32 && phy_idx < MII_CNT; phy++) {
498                         int mii_status = mdio_read(ioaddr, phy, 1);
499                         if (mii_status != 0xffff  &&  mii_status != 0x0000) {
500                                 np->phys[phy_idx++] = phy;
501                                 np->advertising = mdio_read(ioaddr, phy, 4);
502                                 printk(KERN_INFO "%s: MII PHY found at address %d, status "
503                                            "0x%4.4x advertising %4.4x.\n",
504                                            dev->name, phy, mii_status, np->advertising);
505                         }
506                 }
507                 np->mii_cnt = phy_idx;
508         }
509
510         find_cnt++;
511
512         return 0;
513
514 err_out_unmap_status:
515         pci_free_consistent(pdev, STATUS_TOTAL_SIZE, np->tx_status,
516                 np->tx_status_dma);
517 err_out_unmap_rx:
518         pci_free_consistent(pdev, RX_TOTAL_SIZE, np->rx_ring, np->rx_ring_dma);
519 err_out_unmap_tx:
520         pci_free_consistent(pdev, TX_TOTAL_SIZE, np->tx_ring, np->tx_ring_dma);
521 err_out_cleardev:
522         pci_set_drvdata(pdev, NULL);
523         pci_iounmap(pdev, ioaddr);
524 err_out_free_res:
525         pci_release_regions(pdev);
526 err_out_free_netdev:
527         free_netdev (dev);
528         return -ENODEV;
529 }
530
531 static int __devinit read_eeprom(void __iomem *ioaddr, int location)
532 {
533         int bogus_cnt = 10000;          /* Typical 33Mhz: 1050 ticks */
534
535         iowrite8(location, ioaddr + EEAddr);
536         iowrite8(0x30 | ((location >> 8) & 7), ioaddr + EECtrl);
537         while ((ioread8(ioaddr + EEStatus) & 0x80)  &&  --bogus_cnt > 0)
538                 ;
539         return ioread8(ioaddr + EERead);
540 }
541
542 /* MII Managemen Data I/O accesses.
543    These routines assume the MDIO controller is idle, and do not exit until
544    the command is finished. */
545
546 static int mdio_read(void __iomem *ioaddr, int phy_id, int location)
547 {
548         int i;
549
550         iowrite16((phy_id<<8) + location, ioaddr + MII_Addr);
551         iowrite16(1, ioaddr + MII_Cmd);
552         for (i = 10000; i >= 0; i--)
553                 if ((ioread16(ioaddr + MII_Status) & 1) == 0)
554                         break;
555         return ioread16(ioaddr + MII_Rd_Data);
556 }
557
558 static void mdio_write(void __iomem *ioaddr, int phy_id, int location, int value)
559 {
560         int i;
561
562         iowrite16((phy_id<<8) + location, ioaddr + MII_Addr);
563         iowrite16(value, ioaddr + MII_Wr_Data);
564
565         /* Wait for the command to finish. */
566         for (i = 10000; i >= 0; i--)
567                 if ((ioread16(ioaddr + MII_Status) & 1) == 0)
568                         break;
569         return;
570 }
571
572
573 static int yellowfin_open(struct net_device *dev)
574 {
575         struct yellowfin_private *yp = netdev_priv(dev);
576         void __iomem *ioaddr = yp->base;
577         int i;
578
579         /* Reset the chip. */
580         iowrite32(0x80000000, ioaddr + DMACtrl);
581
582         i = request_irq(dev->irq, &yellowfin_interrupt, IRQF_SHARED, dev->name, dev);
583         if (i) return i;
584
585         if (yellowfin_debug > 1)
586                 printk(KERN_DEBUG "%s: yellowfin_open() irq %d.\n",
587                            dev->name, dev->irq);
588
589         yellowfin_init_ring(dev);
590
591         iowrite32(yp->rx_ring_dma, ioaddr + RxPtr);
592         iowrite32(yp->tx_ring_dma, ioaddr + TxPtr);
593
594         for (i = 0; i < 6; i++)
595                 iowrite8(dev->dev_addr[i], ioaddr + StnAddr + i);
596
597         /* Set up various condition 'select' registers.
598            There are no options here. */
599         iowrite32(0x00800080, ioaddr + TxIntrSel);      /* Interrupt on Tx abort */
600         iowrite32(0x00800080, ioaddr + TxBranchSel);    /* Branch on Tx abort */
601         iowrite32(0x00400040, ioaddr + TxWaitSel);      /* Wait on Tx status */
602         iowrite32(0x00400040, ioaddr + RxIntrSel);      /* Interrupt on Rx done */
603         iowrite32(0x00400040, ioaddr + RxBranchSel);    /* Branch on Rx error */
604         iowrite32(0x00400040, ioaddr + RxWaitSel);      /* Wait on Rx done */
605
606         /* Initialize other registers: with so many this eventually this will
607            converted to an offset/value list. */
608         iowrite32(dma_ctrl, ioaddr + DMACtrl);
609         iowrite16(fifo_cfg, ioaddr + FIFOcfg);
610         /* Enable automatic generation of flow control frames, period 0xffff. */
611         iowrite32(0x0030FFFF, ioaddr + FlowCtrl);
612
613         yp->tx_threshold = 32;
614         iowrite32(yp->tx_threshold, ioaddr + TxThreshold);
615
616         if (dev->if_port == 0)
617                 dev->if_port = yp->default_port;
618
619         netif_start_queue(dev);
620
621         /* Setting the Rx mode will start the Rx process. */
622         if (yp->drv_flags & IsGigabit) {
623                 /* We are always in full-duplex mode with gigabit! */
624                 yp->full_duplex = 1;
625                 iowrite16(0x01CF, ioaddr + Cnfg);
626         } else {
627                 iowrite16(0x0018, ioaddr + FrameGap0); /* 0060/4060 for non-MII 10baseT */
628                 iowrite16(0x1018, ioaddr + FrameGap1);
629                 iowrite16(0x101C | (yp->full_duplex ? 2 : 0), ioaddr + Cnfg);
630         }
631         set_rx_mode(dev);
632
633         /* Enable interrupts by setting the interrupt mask. */
634         iowrite16(0x81ff, ioaddr + IntrEnb);                    /* See enum intr_status_bits */
635         iowrite16(0x0000, ioaddr + EventStatus);                /* Clear non-interrupting events */
636         iowrite32(0x80008000, ioaddr + RxCtrl);         /* Start Rx and Tx channels. */
637         iowrite32(0x80008000, ioaddr + TxCtrl);
638
639         if (yellowfin_debug > 2) {
640                 printk(KERN_DEBUG "%s: Done yellowfin_open().\n",
641                            dev->name);
642         }
643
644         /* Set the timer to check for link beat. */
645         init_timer(&yp->timer);
646         yp->timer.expires = jiffies + 3*HZ;
647         yp->timer.data = (unsigned long)dev;
648         yp->timer.function = &yellowfin_timer;                          /* timer handler */
649         add_timer(&yp->timer);
650
651         return 0;
652 }
653
654 static void yellowfin_timer(unsigned long data)
655 {
656         struct net_device *dev = (struct net_device *)data;
657         struct yellowfin_private *yp = netdev_priv(dev);
658         void __iomem *ioaddr = yp->base;
659         int next_tick = 60*HZ;
660
661         if (yellowfin_debug > 3) {
662                 printk(KERN_DEBUG "%s: Yellowfin timer tick, status %8.8x.\n",
663                            dev->name, ioread16(ioaddr + IntrStatus));
664         }
665
666         if (yp->mii_cnt) {
667                 int bmsr = mdio_read(ioaddr, yp->phys[0], MII_BMSR);
668                 int lpa = mdio_read(ioaddr, yp->phys[0], MII_LPA);
669                 int negotiated = lpa & yp->advertising;
670                 if (yellowfin_debug > 1)
671                         printk(KERN_DEBUG "%s: MII #%d status register is %4.4x, "
672                                    "link partner capability %4.4x.\n",
673                                    dev->name, yp->phys[0], bmsr, lpa);
674
675                 yp->full_duplex = mii_duplex(yp->duplex_lock, negotiated);
676
677                 iowrite16(0x101C | (yp->full_duplex ? 2 : 0), ioaddr + Cnfg);
678
679                 if (bmsr & BMSR_LSTATUS)
680                         next_tick = 60*HZ;
681                 else
682                         next_tick = 3*HZ;
683         }
684
685         yp->timer.expires = jiffies + next_tick;
686         add_timer(&yp->timer);
687 }
688
689 static void yellowfin_tx_timeout(struct net_device *dev)
690 {
691         struct yellowfin_private *yp = netdev_priv(dev);
692         void __iomem *ioaddr = yp->base;
693
694         printk(KERN_WARNING "%s: Yellowfin transmit timed out at %d/%d Tx "
695                    "status %4.4x, Rx status %4.4x, resetting...\n",
696                    dev->name, yp->cur_tx, yp->dirty_tx,
697                    ioread32(ioaddr + TxStatus), ioread32(ioaddr + RxStatus));
698
699         /* Note: these should be KERN_DEBUG. */
700         if (yellowfin_debug) {
701                 int i;
702                 printk(KERN_WARNING "  Rx ring %p: ", yp->rx_ring);
703                 for (i = 0; i < RX_RING_SIZE; i++)
704                         printk(" %8.8x", yp->rx_ring[i].result_status);
705                 printk("\n"KERN_WARNING"  Tx ring %p: ", yp->tx_ring);
706                 for (i = 0; i < TX_RING_SIZE; i++)
707                         printk(" %4.4x /%8.8x", yp->tx_status[i].tx_errs,
708                                    yp->tx_ring[i].result_status);
709                 printk("\n");
710         }
711
712         /* If the hardware is found to hang regularly, we will update the code
713            to reinitialize the chip here. */
714         dev->if_port = 0;
715
716         /* Wake the potentially-idle transmit channel. */
717         iowrite32(0x10001000, yp->base + TxCtrl);
718         if (yp->cur_tx - yp->dirty_tx < TX_QUEUE_SIZE)
719                 netif_wake_queue (dev);         /* Typical path */
720
721         dev->trans_start = jiffies;
722         yp->stats.tx_errors++;
723 }
724
725 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
726 static void yellowfin_init_ring(struct net_device *dev)
727 {
728         struct yellowfin_private *yp = netdev_priv(dev);
729         int i;
730
731         yp->tx_full = 0;
732         yp->cur_rx = yp->cur_tx = 0;
733         yp->dirty_tx = 0;
734
735         yp->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
736
737         for (i = 0; i < RX_RING_SIZE; i++) {
738                 yp->rx_ring[i].dbdma_cmd =
739                         cpu_to_le32(CMD_RX_BUF | INTR_ALWAYS | yp->rx_buf_sz);
740                 yp->rx_ring[i].branch_addr = cpu_to_le32(yp->rx_ring_dma +
741                         ((i+1)%RX_RING_SIZE)*sizeof(struct yellowfin_desc));
742         }
743
744         for (i = 0; i < RX_RING_SIZE; i++) {
745                 struct sk_buff *skb = dev_alloc_skb(yp->rx_buf_sz);
746                 yp->rx_skbuff[i] = skb;
747                 if (skb == NULL)
748                         break;
749                 skb->dev = dev;         /* Mark as being used by this device. */
750                 skb_reserve(skb, 2);    /* 16 byte align the IP header. */
751                 yp->rx_ring[i].addr = cpu_to_le32(pci_map_single(yp->pci_dev,
752                         skb->data, yp->rx_buf_sz, PCI_DMA_FROMDEVICE));
753         }
754         yp->rx_ring[i-1].dbdma_cmd = cpu_to_le32(CMD_STOP);
755         yp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
756
757 #define NO_TXSTATS
758 #ifdef NO_TXSTATS
759         /* In this mode the Tx ring needs only a single descriptor. */
760         for (i = 0; i < TX_RING_SIZE; i++) {
761                 yp->tx_skbuff[i] = NULL;
762                 yp->tx_ring[i].dbdma_cmd = cpu_to_le32(CMD_STOP);
763                 yp->tx_ring[i].branch_addr = cpu_to_le32(yp->tx_ring_dma +
764                         ((i+1)%TX_RING_SIZE)*sizeof(struct yellowfin_desc));
765         }
766         /* Wrap ring */
767         yp->tx_ring[--i].dbdma_cmd = cpu_to_le32(CMD_STOP | BRANCH_ALWAYS);
768 #else
769 {
770         int j;
771
772         /* Tx ring needs a pair of descriptors, the second for the status. */
773         for (i = 0; i < TX_RING_SIZE; i++) {
774                 j = 2*i;
775                 yp->tx_skbuff[i] = 0;
776                 /* Branch on Tx error. */
777                 yp->tx_ring[j].dbdma_cmd = cpu_to_le32(CMD_STOP);
778                 yp->tx_ring[j].branch_addr = cpu_to_le32(yp->tx_ring_dma +
779                         (j+1)*sizeof(struct yellowfin_desc);
780                 j++;
781                 if (yp->flags & FullTxStatus) {
782                         yp->tx_ring[j].dbdma_cmd =
783                                 cpu_to_le32(CMD_TXSTATUS | sizeof(*yp->tx_status));
784                         yp->tx_ring[j].request_cnt = sizeof(*yp->tx_status);
785                         yp->tx_ring[j].addr = cpu_to_le32(yp->tx_status_dma +
786                                 i*sizeof(struct tx_status_words);
787                 } else {
788                         /* Symbios chips write only tx_errs word. */
789                         yp->tx_ring[j].dbdma_cmd =
790                                 cpu_to_le32(CMD_TXSTATUS | INTR_ALWAYS | 2);
791                         yp->tx_ring[j].request_cnt = 2;
792                         /* Om pade ummmmm... */
793                         yp->tx_ring[j].addr = cpu_to_le32(yp->tx_status_dma +
794                                 i*sizeof(struct tx_status_words) +
795                                 &(yp->tx_status[0].tx_errs) -
796                                 &(yp->tx_status[0]));
797                 }
798                 yp->tx_ring[j].branch_addr = cpu_to_le32(yp->tx_ring_dma +
799                         ((j+1)%(2*TX_RING_SIZE))*sizeof(struct yellowfin_desc));
800         }
801         /* Wrap ring */
802         yp->tx_ring[++j].dbdma_cmd |= cpu_to_le32(BRANCH_ALWAYS | INTR_ALWAYS);
803 }
804 #endif
805         yp->tx_tail_desc = &yp->tx_status[0];
806         return;
807 }
808
809 static int yellowfin_start_xmit(struct sk_buff *skb, struct net_device *dev)
810 {
811         struct yellowfin_private *yp = netdev_priv(dev);
812         unsigned entry;
813         int len = skb->len;
814
815         netif_stop_queue (dev);
816
817         /* Note: Ordering is important here, set the field with the
818            "ownership" bit last, and only then increment cur_tx. */
819
820         /* Calculate the next Tx descriptor entry. */
821         entry = yp->cur_tx % TX_RING_SIZE;
822
823         if (gx_fix) {   /* Note: only works for paddable protocols e.g.  IP. */
824                 int cacheline_end = ((unsigned long)skb->data + skb->len) % 32;
825                 /* Fix GX chipset errata. */
826                 if (cacheline_end > 24  || cacheline_end == 0) {
827                         len = skb->len + 32 - cacheline_end + 1;
828                         if (skb_padto(skb, len)) {
829                                 yp->tx_skbuff[entry] = NULL;
830                                 netif_wake_queue(dev);
831                                 return 0;
832                         }
833                 }
834         }
835         yp->tx_skbuff[entry] = skb;
836
837 #ifdef NO_TXSTATS
838         yp->tx_ring[entry].addr = cpu_to_le32(pci_map_single(yp->pci_dev,
839                 skb->data, len, PCI_DMA_TODEVICE));
840         yp->tx_ring[entry].result_status = 0;
841         if (entry >= TX_RING_SIZE-1) {
842                 /* New stop command. */
843                 yp->tx_ring[0].dbdma_cmd = cpu_to_le32(CMD_STOP);
844                 yp->tx_ring[TX_RING_SIZE-1].dbdma_cmd =
845                         cpu_to_le32(CMD_TX_PKT|BRANCH_ALWAYS | len);
846         } else {
847                 yp->tx_ring[entry+1].dbdma_cmd = cpu_to_le32(CMD_STOP);
848                 yp->tx_ring[entry].dbdma_cmd =
849                         cpu_to_le32(CMD_TX_PKT | BRANCH_IFTRUE | len);
850         }
851         yp->cur_tx++;
852 #else
853         yp->tx_ring[entry<<1].request_cnt = len;
854         yp->tx_ring[entry<<1].addr = cpu_to_le32(pci_map_single(yp->pci_dev,
855                 skb->data, len, PCI_DMA_TODEVICE));
856         /* The input_last (status-write) command is constant, but we must
857            rewrite the subsequent 'stop' command. */
858
859         yp->cur_tx++;
860         {
861                 unsigned next_entry = yp->cur_tx % TX_RING_SIZE;
862                 yp->tx_ring[next_entry<<1].dbdma_cmd = cpu_to_le32(CMD_STOP);
863         }
864         /* Final step -- overwrite the old 'stop' command. */
865
866         yp->tx_ring[entry<<1].dbdma_cmd =
867                 cpu_to_le32( ((entry % 6) == 0 ? CMD_TX_PKT|INTR_ALWAYS|BRANCH_IFTRUE :
868                                           CMD_TX_PKT | BRANCH_IFTRUE) | len);
869 #endif
870
871         /* Non-x86 Todo: explicitly flush cache lines here. */
872
873         /* Wake the potentially-idle transmit channel. */
874         iowrite32(0x10001000, yp->base + TxCtrl);
875
876         if (yp->cur_tx - yp->dirty_tx < TX_QUEUE_SIZE)
877                 netif_start_queue (dev);                /* Typical path */
878         else
879                 yp->tx_full = 1;
880         dev->trans_start = jiffies;
881
882         if (yellowfin_debug > 4) {
883                 printk(KERN_DEBUG "%s: Yellowfin transmit frame #%d queued in slot %d.\n",
884                            dev->name, yp->cur_tx, entry);
885         }
886         return 0;
887 }
888
889 /* The interrupt handler does all of the Rx thread work and cleans up
890    after the Tx thread. */
891 static irqreturn_t yellowfin_interrupt(int irq, void *dev_instance)
892 {
893         struct net_device *dev = dev_instance;
894         struct yellowfin_private *yp;
895         void __iomem *ioaddr;
896         int boguscnt = max_interrupt_work;
897         unsigned int handled = 0;
898
899         yp = netdev_priv(dev);
900         ioaddr = yp->base;
901
902         spin_lock (&yp->lock);
903
904         do {
905                 u16 intr_status = ioread16(ioaddr + IntrClear);
906
907                 if (yellowfin_debug > 4)
908                         printk(KERN_DEBUG "%s: Yellowfin interrupt, status %4.4x.\n",
909                                    dev->name, intr_status);
910
911                 if (intr_status == 0)
912                         break;
913                 handled = 1;
914
915                 if (intr_status & (IntrRxDone | IntrEarlyRx)) {
916                         yellowfin_rx(dev);
917                         iowrite32(0x10001000, ioaddr + RxCtrl);         /* Wake Rx engine. */
918                 }
919
920 #ifdef NO_TXSTATS
921                 for (; yp->cur_tx - yp->dirty_tx > 0; yp->dirty_tx++) {
922                         int entry = yp->dirty_tx % TX_RING_SIZE;
923                         struct sk_buff *skb;
924
925                         if (yp->tx_ring[entry].result_status == 0)
926                                 break;
927                         skb = yp->tx_skbuff[entry];
928                         yp->stats.tx_packets++;
929                         yp->stats.tx_bytes += skb->len;
930                         /* Free the original skb. */
931                         pci_unmap_single(yp->pci_dev, yp->tx_ring[entry].addr,
932                                 skb->len, PCI_DMA_TODEVICE);
933                         dev_kfree_skb_irq(skb);
934                         yp->tx_skbuff[entry] = NULL;
935                 }
936                 if (yp->tx_full
937                         && yp->cur_tx - yp->dirty_tx < TX_QUEUE_SIZE - 4) {
938                         /* The ring is no longer full, clear tbusy. */
939                         yp->tx_full = 0;
940                         netif_wake_queue(dev);
941                 }
942 #else
943                 if ((intr_status & IntrTxDone) || (yp->tx_tail_desc->tx_errs)) {
944                         unsigned dirty_tx = yp->dirty_tx;
945
946                         for (dirty_tx = yp->dirty_tx; yp->cur_tx - dirty_tx > 0;
947                                  dirty_tx++) {
948                                 /* Todo: optimize this. */
949                                 int entry = dirty_tx % TX_RING_SIZE;
950                                 u16 tx_errs = yp->tx_status[entry].tx_errs;
951                                 struct sk_buff *skb;
952
953 #ifndef final_version
954                                 if (yellowfin_debug > 5)
955                                         printk(KERN_DEBUG "%s: Tx queue %d check, Tx status "
956                                                    "%4.4x %4.4x %4.4x %4.4x.\n",
957                                                    dev->name, entry,
958                                                    yp->tx_status[entry].tx_cnt,
959                                                    yp->tx_status[entry].tx_errs,
960                                                    yp->tx_status[entry].total_tx_cnt,
961                                                    yp->tx_status[entry].paused);
962 #endif
963                                 if (tx_errs == 0)
964                                         break;  /* It still hasn't been Txed */
965                                 skb = yp->tx_skbuff[entry];
966                                 if (tx_errs & 0xF810) {
967                                         /* There was an major error, log it. */
968 #ifndef final_version
969                                         if (yellowfin_debug > 1)
970                                                 printk(KERN_DEBUG "%s: Transmit error, Tx status %4.4x.\n",
971                                                            dev->name, tx_errs);
972 #endif
973                                         yp->stats.tx_errors++;
974                                         if (tx_errs & 0xF800) yp->stats.tx_aborted_errors++;
975                                         if (tx_errs & 0x0800) yp->stats.tx_carrier_errors++;
976                                         if (tx_errs & 0x2000) yp->stats.tx_window_errors++;
977                                         if (tx_errs & 0x8000) yp->stats.tx_fifo_errors++;
978                                 } else {
979 #ifndef final_version
980                                         if (yellowfin_debug > 4)
981                                                 printk(KERN_DEBUG "%s: Normal transmit, Tx status %4.4x.\n",
982                                                            dev->name, tx_errs);
983 #endif
984                                         yp->stats.tx_bytes += skb->len;
985                                         yp->stats.collisions += tx_errs & 15;
986                                         yp->stats.tx_packets++;
987                                 }
988                                 /* Free the original skb. */
989                                 pci_unmap_single(yp->pci_dev,
990                                         yp->tx_ring[entry<<1].addr, skb->len,
991                                         PCI_DMA_TODEVICE);
992                                 dev_kfree_skb_irq(skb);
993                                 yp->tx_skbuff[entry] = 0;
994                                 /* Mark status as empty. */
995                                 yp->tx_status[entry].tx_errs = 0;
996                         }
997
998 #ifndef final_version
999                         if (yp->cur_tx - dirty_tx > TX_RING_SIZE) {
1000                                 printk(KERN_ERR "%s: Out-of-sync dirty pointer, %d vs. %d, full=%d.\n",
1001                                            dev->name, dirty_tx, yp->cur_tx, yp->tx_full);
1002                                 dirty_tx += TX_RING_SIZE;
1003                         }
1004 #endif
1005
1006                         if (yp->tx_full
1007                                 && yp->cur_tx - dirty_tx < TX_QUEUE_SIZE - 2) {
1008                                 /* The ring is no longer full, clear tbusy. */
1009                                 yp->tx_full = 0;
1010                                 netif_wake_queue(dev);
1011                         }
1012
1013                         yp->dirty_tx = dirty_tx;
1014                         yp->tx_tail_desc = &yp->tx_status[dirty_tx % TX_RING_SIZE];
1015                 }
1016 #endif
1017
1018                 /* Log errors and other uncommon events. */
1019                 if (intr_status & 0x2ee)        /* Abnormal error summary. */
1020                         yellowfin_error(dev, intr_status);
1021
1022                 if (--boguscnt < 0) {
1023                         printk(KERN_WARNING "%s: Too much work at interrupt, "
1024                                    "status=0x%4.4x.\n",
1025                                    dev->name, intr_status);
1026                         break;
1027                 }
1028         } while (1);
1029
1030         if (yellowfin_debug > 3)
1031                 printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.\n",
1032                            dev->name, ioread16(ioaddr + IntrStatus));
1033
1034         spin_unlock (&yp->lock);
1035         return IRQ_RETVAL(handled);
1036 }
1037
1038 /* This routine is logically part of the interrupt handler, but separated
1039    for clarity and better register allocation. */
1040 static int yellowfin_rx(struct net_device *dev)
1041 {
1042         struct yellowfin_private *yp = netdev_priv(dev);
1043         int entry = yp->cur_rx % RX_RING_SIZE;
1044         int boguscnt = yp->dirty_rx + RX_RING_SIZE - yp->cur_rx;
1045
1046         if (yellowfin_debug > 4) {
1047                 printk(KERN_DEBUG " In yellowfin_rx(), entry %d status %8.8x.\n",
1048                            entry, yp->rx_ring[entry].result_status);
1049                 printk(KERN_DEBUG "   #%d desc. %8.8x %8.8x %8.8x.\n",
1050                            entry, yp->rx_ring[entry].dbdma_cmd, yp->rx_ring[entry].addr,
1051                            yp->rx_ring[entry].result_status);
1052         }
1053
1054         /* If EOP is set on the next entry, it's a new packet. Send it up. */
1055         while (1) {
1056                 struct yellowfin_desc *desc = &yp->rx_ring[entry];
1057                 struct sk_buff *rx_skb = yp->rx_skbuff[entry];
1058                 s16 frame_status;
1059                 u16 desc_status;
1060                 int data_size;
1061                 u8 *buf_addr;
1062
1063                 if(!desc->result_status)
1064                         break;
1065                 pci_dma_sync_single_for_cpu(yp->pci_dev, desc->addr,
1066                         yp->rx_buf_sz, PCI_DMA_FROMDEVICE);
1067                 desc_status = le32_to_cpu(desc->result_status) >> 16;
1068                 buf_addr = rx_skb->data;
1069                 data_size = (le32_to_cpu(desc->dbdma_cmd) -
1070                         le32_to_cpu(desc->result_status)) & 0xffff;
1071                 frame_status = le16_to_cpu(get_unaligned((s16*)&(buf_addr[data_size - 2])));
1072                 if (yellowfin_debug > 4)
1073                         printk(KERN_DEBUG "  yellowfin_rx() status was %4.4x.\n",
1074                                    frame_status);
1075                 if (--boguscnt < 0)
1076                         break;
1077                 if ( ! (desc_status & RX_EOP)) {
1078                         if (data_size != 0)
1079                                 printk(KERN_WARNING "%s: Oversized Ethernet frame spanned multiple buffers,"
1080                                            " status %4.4x, data_size %d!\n", dev->name, desc_status, data_size);
1081                         yp->stats.rx_length_errors++;
1082                 } else if ((yp->drv_flags & IsGigabit)  &&  (frame_status & 0x0038)) {
1083                         /* There was a error. */
1084                         if (yellowfin_debug > 3)
1085                                 printk(KERN_DEBUG "  yellowfin_rx() Rx error was %4.4x.\n",
1086                                            frame_status);
1087                         yp->stats.rx_errors++;
1088                         if (frame_status & 0x0060) yp->stats.rx_length_errors++;
1089                         if (frame_status & 0x0008) yp->stats.rx_frame_errors++;
1090                         if (frame_status & 0x0010) yp->stats.rx_crc_errors++;
1091                         if (frame_status < 0) yp->stats.rx_dropped++;
1092                 } else if ( !(yp->drv_flags & IsGigabit)  &&
1093                                    ((buf_addr[data_size-1] & 0x85) || buf_addr[data_size-2] & 0xC0)) {
1094                         u8 status1 = buf_addr[data_size-2];
1095                         u8 status2 = buf_addr[data_size-1];
1096                         yp->stats.rx_errors++;
1097                         if (status1 & 0xC0) yp->stats.rx_length_errors++;
1098                         if (status2 & 0x03) yp->stats.rx_frame_errors++;
1099                         if (status2 & 0x04) yp->stats.rx_crc_errors++;
1100                         if (status2 & 0x80) yp->stats.rx_dropped++;
1101 #ifdef YF_PROTOTYPE             /* Support for prototype hardware errata. */
1102                 } else if ((yp->flags & HasMACAddrBug)  &&
1103                         memcmp(le32_to_cpu(yp->rx_ring_dma +
1104                                 entry*sizeof(struct yellowfin_desc)),
1105                                 dev->dev_addr, 6) != 0 &&
1106                         memcmp(le32_to_cpu(yp->rx_ring_dma +
1107                                 entry*sizeof(struct yellowfin_desc)),
1108                                 "\377\377\377\377\377\377", 6) != 0) {
1109                         if (bogus_rx++ == 0)
1110                                 printk(KERN_WARNING "%s: Bad frame to %2.2x:%2.2x:%2.2x:%2.2x:"
1111                                            "%2.2x:%2.2x.\n",
1112                                            dev->name, buf_addr[0], buf_addr[1], buf_addr[2],
1113                                            buf_addr[3], buf_addr[4], buf_addr[5]);
1114 #endif
1115                 } else {
1116                         struct sk_buff *skb;
1117                         int pkt_len = data_size -
1118                                 (yp->chip_id ? 7 : 8 + buf_addr[data_size - 8]);
1119                         /* To verify: Yellowfin Length should omit the CRC! */
1120
1121 #ifndef final_version
1122                         if (yellowfin_debug > 4)
1123                                 printk(KERN_DEBUG "  yellowfin_rx() normal Rx pkt length %d"
1124                                            " of %d, bogus_cnt %d.\n",
1125                                            pkt_len, data_size, boguscnt);
1126 #endif
1127                         /* Check if the packet is long enough to just pass up the skbuff
1128                            without copying to a properly sized skbuff. */
1129                         if (pkt_len > rx_copybreak) {
1130                                 skb_put(skb = rx_skb, pkt_len);
1131                                 pci_unmap_single(yp->pci_dev,
1132                                         yp->rx_ring[entry].addr,
1133                                         yp->rx_buf_sz,
1134                                         PCI_DMA_FROMDEVICE);
1135                                 yp->rx_skbuff[entry] = NULL;
1136                         } else {
1137                                 skb = dev_alloc_skb(pkt_len + 2);
1138                                 if (skb == NULL)
1139                                         break;
1140                                 skb_reserve(skb, 2);    /* 16 byte align the IP header */
1141                                 eth_copy_and_sum(skb, rx_skb->data, pkt_len, 0);
1142                                 skb_put(skb, pkt_len);
1143                                 pci_dma_sync_single_for_device(yp->pci_dev, desc->addr,
1144                                                                                            yp->rx_buf_sz,
1145                                                                                            PCI_DMA_FROMDEVICE);
1146                         }
1147                         skb->protocol = eth_type_trans(skb, dev);
1148                         netif_rx(skb);
1149                         dev->last_rx = jiffies;
1150                         yp->stats.rx_packets++;
1151                         yp->stats.rx_bytes += pkt_len;
1152                 }
1153                 entry = (++yp->cur_rx) % RX_RING_SIZE;
1154         }
1155
1156         /* Refill the Rx ring buffers. */
1157         for (; yp->cur_rx - yp->dirty_rx > 0; yp->dirty_rx++) {
1158                 entry = yp->dirty_rx % RX_RING_SIZE;
1159                 if (yp->rx_skbuff[entry] == NULL) {
1160                         struct sk_buff *skb = dev_alloc_skb(yp->rx_buf_sz);
1161                         if (skb == NULL)
1162                                 break;                          /* Better luck next round. */
1163                         yp->rx_skbuff[entry] = skb;
1164                         skb->dev = dev; /* Mark as being used by this device. */
1165                         skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
1166                         yp->rx_ring[entry].addr = cpu_to_le32(pci_map_single(yp->pci_dev,
1167                                 skb->data, yp->rx_buf_sz, PCI_DMA_FROMDEVICE));
1168                 }
1169                 yp->rx_ring[entry].dbdma_cmd = cpu_to_le32(CMD_STOP);
1170                 yp->rx_ring[entry].result_status = 0;   /* Clear complete bit. */
1171                 if (entry != 0)
1172                         yp->rx_ring[entry - 1].dbdma_cmd =
1173                                 cpu_to_le32(CMD_RX_BUF | INTR_ALWAYS | yp->rx_buf_sz);
1174                 else
1175                         yp->rx_ring[RX_RING_SIZE - 1].dbdma_cmd =
1176                                 cpu_to_le32(CMD_RX_BUF | INTR_ALWAYS | BRANCH_ALWAYS
1177                                                         | yp->rx_buf_sz);
1178         }
1179
1180         return 0;
1181 }
1182
1183 static void yellowfin_error(struct net_device *dev, int intr_status)
1184 {
1185         struct yellowfin_private *yp = netdev_priv(dev);
1186
1187         printk(KERN_ERR "%s: Something Wicked happened! %4.4x.\n",
1188                    dev->name, intr_status);
1189         /* Hmmmmm, it's not clear what to do here. */
1190         if (intr_status & (IntrTxPCIErr | IntrTxPCIFault))
1191                 yp->stats.tx_errors++;
1192         if (intr_status & (IntrRxPCIErr | IntrRxPCIFault))
1193                 yp->stats.rx_errors++;
1194 }
1195
1196 static int yellowfin_close(struct net_device *dev)
1197 {
1198         struct yellowfin_private *yp = netdev_priv(dev);
1199         void __iomem *ioaddr = yp->base;
1200         int i;
1201
1202         netif_stop_queue (dev);
1203
1204         if (yellowfin_debug > 1) {
1205                 printk(KERN_DEBUG "%s: Shutting down ethercard, status was Tx %4.4x "
1206                            "Rx %4.4x Int %2.2x.\n",
1207                            dev->name, ioread16(ioaddr + TxStatus),
1208                            ioread16(ioaddr + RxStatus),
1209                            ioread16(ioaddr + IntrStatus));
1210                 printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d,  Rx %d / %d.\n",
1211                            dev->name, yp->cur_tx, yp->dirty_tx, yp->cur_rx, yp->dirty_rx);
1212         }
1213
1214         /* Disable interrupts by clearing the interrupt mask. */
1215         iowrite16(0x0000, ioaddr + IntrEnb);
1216
1217         /* Stop the chip's Tx and Rx processes. */
1218         iowrite32(0x80000000, ioaddr + RxCtrl);
1219         iowrite32(0x80000000, ioaddr + TxCtrl);
1220
1221         del_timer(&yp->timer);
1222
1223 #if defined(__i386__)
1224         if (yellowfin_debug > 2) {
1225                 printk("\n"KERN_DEBUG"  Tx ring at %8.8llx:\n",
1226                                 (unsigned long long)yp->tx_ring_dma);
1227                 for (i = 0; i < TX_RING_SIZE*2; i++)
1228                         printk(" %c #%d desc. %8.8x %8.8x %8.8x %8.8x.\n",
1229                                    ioread32(ioaddr + TxPtr) == (long)&yp->tx_ring[i] ? '>' : ' ',
1230                                    i, yp->tx_ring[i].dbdma_cmd, yp->tx_ring[i].addr,
1231                                    yp->tx_ring[i].branch_addr, yp->tx_ring[i].result_status);
1232                 printk(KERN_DEBUG "  Tx status %p:\n", yp->tx_status);
1233                 for (i = 0; i < TX_RING_SIZE; i++)
1234                         printk("   #%d status %4.4x %4.4x %4.4x %4.4x.\n",
1235                                    i, yp->tx_status[i].tx_cnt, yp->tx_status[i].tx_errs,
1236                                    yp->tx_status[i].total_tx_cnt, yp->tx_status[i].paused);
1237
1238                 printk("\n"KERN_DEBUG "  Rx ring %8.8llx:\n",
1239                                 (unsigned long long)yp->rx_ring_dma);
1240                 for (i = 0; i < RX_RING_SIZE; i++) {
1241                         printk(KERN_DEBUG " %c #%d desc. %8.8x %8.8x %8.8x\n",
1242                                    ioread32(ioaddr + RxPtr) == (long)&yp->rx_ring[i] ? '>' : ' ',
1243                                    i, yp->rx_ring[i].dbdma_cmd, yp->rx_ring[i].addr,
1244                                    yp->rx_ring[i].result_status);
1245                         if (yellowfin_debug > 6) {
1246                                 if (get_unaligned((u8*)yp->rx_ring[i].addr) != 0x69) {
1247                                         int j;
1248                                         for (j = 0; j < 0x50; j++)
1249                                                 printk(" %4.4x",
1250                                                            get_unaligned(((u16*)yp->rx_ring[i].addr) + j));
1251                                         printk("\n");
1252                                 }
1253                         }
1254                 }
1255         }
1256 #endif /* __i386__ debugging only */
1257
1258         free_irq(dev->irq, dev);
1259
1260         /* Free all the skbuffs in the Rx queue. */
1261         for (i = 0; i < RX_RING_SIZE; i++) {
1262                 yp->rx_ring[i].dbdma_cmd = cpu_to_le32(CMD_STOP);
1263                 yp->rx_ring[i].addr = 0xBADF00D0; /* An invalid address. */
1264                 if (yp->rx_skbuff[i]) {
1265                         dev_kfree_skb(yp->rx_skbuff[i]);
1266                 }
1267                 yp->rx_skbuff[i] = NULL;
1268         }
1269         for (i = 0; i < TX_RING_SIZE; i++) {
1270                 if (yp->tx_skbuff[i])
1271                         dev_kfree_skb(yp->tx_skbuff[i]);
1272                 yp->tx_skbuff[i] = NULL;
1273         }
1274
1275 #ifdef YF_PROTOTYPE                     /* Support for prototype hardware errata. */
1276         if (yellowfin_debug > 0) {
1277                 printk(KERN_DEBUG "%s: Received %d frames that we should not have.\n",
1278                            dev->name, bogus_rx);
1279         }
1280 #endif
1281
1282         return 0;
1283 }
1284
1285 static struct net_device_stats *yellowfin_get_stats(struct net_device *dev)
1286 {
1287         struct yellowfin_private *yp = netdev_priv(dev);
1288         return &yp->stats;
1289 }
1290
1291 /* Set or clear the multicast filter for this adaptor. */
1292
1293 static void set_rx_mode(struct net_device *dev)
1294 {
1295         struct yellowfin_private *yp = netdev_priv(dev);
1296         void __iomem *ioaddr = yp->base;
1297         u16 cfg_value = ioread16(ioaddr + Cnfg);
1298
1299         /* Stop the Rx process to change any value. */
1300         iowrite16(cfg_value & ~0x1000, ioaddr + Cnfg);
1301         if (dev->flags & IFF_PROMISC) {                 /* Set promiscuous. */
1302                 iowrite16(0x000F, ioaddr + AddrMode);
1303         } else if ((dev->mc_count > 64)  ||  (dev->flags & IFF_ALLMULTI)) {
1304                 /* Too many to filter well, or accept all multicasts. */
1305                 iowrite16(0x000B, ioaddr + AddrMode);
1306         } else if (dev->mc_count > 0) { /* Must use the multicast hash table. */
1307                 struct dev_mc_list *mclist;
1308                 u16 hash_table[4];
1309                 int i;
1310                 memset(hash_table, 0, sizeof(hash_table));
1311                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1312                          i++, mclist = mclist->next) {
1313                         unsigned int bit;
1314
1315                         /* Due to a bug in the early chip versions, multiple filter
1316                            slots must be set for each address. */
1317                         if (yp->drv_flags & HasMulticastBug) {
1318                                 bit = (ether_crc_le(3, mclist->dmi_addr) >> 3) & 0x3f;
1319                                 hash_table[bit >> 4] |= (1 << bit);
1320                                 bit = (ether_crc_le(4, mclist->dmi_addr) >> 3) & 0x3f;
1321                                 hash_table[bit >> 4] |= (1 << bit);
1322                                 bit = (ether_crc_le(5, mclist->dmi_addr) >> 3) & 0x3f;
1323                                 hash_table[bit >> 4] |= (1 << bit);
1324                         }
1325                         bit = (ether_crc_le(6, mclist->dmi_addr) >> 3) & 0x3f;
1326                         hash_table[bit >> 4] |= (1 << bit);
1327                 }
1328                 /* Copy the hash table to the chip. */
1329                 for (i = 0; i < 4; i++)
1330                         iowrite16(hash_table[i], ioaddr + HashTbl + i*2);
1331                 iowrite16(0x0003, ioaddr + AddrMode);
1332         } else {                                        /* Normal, unicast/broadcast-only mode. */
1333                 iowrite16(0x0001, ioaddr + AddrMode);
1334         }
1335         /* Restart the Rx process. */
1336         iowrite16(cfg_value | 0x1000, ioaddr + Cnfg);
1337 }
1338
1339 static void yellowfin_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1340 {
1341         struct yellowfin_private *np = netdev_priv(dev);
1342         strcpy(info->driver, DRV_NAME);
1343         strcpy(info->version, DRV_VERSION);
1344         strcpy(info->bus_info, pci_name(np->pci_dev));
1345 }
1346
1347 static const struct ethtool_ops ethtool_ops = {
1348         .get_drvinfo = yellowfin_get_drvinfo
1349 };
1350
1351 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1352 {
1353         struct yellowfin_private *np = netdev_priv(dev);
1354         void __iomem *ioaddr = np->base;
1355         struct mii_ioctl_data *data = if_mii(rq);
1356
1357         switch(cmd) {
1358         case SIOCGMIIPHY:               /* Get address of MII PHY in use. */
1359                 data->phy_id = np->phys[0] & 0x1f;
1360                 /* Fall Through */
1361
1362         case SIOCGMIIREG:               /* Read MII PHY register. */
1363                 data->val_out = mdio_read(ioaddr, data->phy_id & 0x1f, data->reg_num & 0x1f);
1364                 return 0;
1365
1366         case SIOCSMIIREG:               /* Write MII PHY register. */
1367                 if (!capable(CAP_NET_ADMIN))
1368                         return -EPERM;
1369                 if (data->phy_id == np->phys[0]) {
1370                         u16 value = data->val_in;
1371                         switch (data->reg_num) {
1372                         case 0:
1373                                 /* Check for autonegotiation on or reset. */
1374                                 np->medialock = (value & 0x9000) ? 0 : 1;
1375                                 if (np->medialock)
1376                                         np->full_duplex = (value & 0x0100) ? 1 : 0;
1377                                 break;
1378                         case 4: np->advertising = value; break;
1379                         }
1380                         /* Perhaps check_duplex(dev), depending on chip semantics. */
1381                 }
1382                 mdio_write(ioaddr, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
1383                 return 0;
1384         default:
1385                 return -EOPNOTSUPP;
1386         }
1387 }
1388
1389
1390 static void __devexit yellowfin_remove_one (struct pci_dev *pdev)
1391 {
1392         struct net_device *dev = pci_get_drvdata(pdev);
1393         struct yellowfin_private *np;
1394
1395         BUG_ON(!dev);
1396         np = netdev_priv(dev);
1397
1398         pci_free_consistent(pdev, STATUS_TOTAL_SIZE, np->tx_status,
1399                 np->tx_status_dma);
1400         pci_free_consistent(pdev, RX_TOTAL_SIZE, np->rx_ring, np->rx_ring_dma);
1401         pci_free_consistent(pdev, TX_TOTAL_SIZE, np->tx_ring, np->tx_ring_dma);
1402         unregister_netdev (dev);
1403
1404         pci_iounmap(pdev, np->base);
1405
1406         pci_release_regions (pdev);
1407
1408         free_netdev (dev);
1409         pci_set_drvdata(pdev, NULL);
1410 }
1411
1412
1413 static struct pci_driver yellowfin_driver = {
1414         .name           = DRV_NAME,
1415         .id_table       = yellowfin_pci_tbl,
1416         .probe          = yellowfin_init_one,
1417         .remove         = __devexit_p(yellowfin_remove_one),
1418 };
1419
1420
1421 static int __init yellowfin_init (void)
1422 {
1423 /* when a module, this is printed whether or not devices are found in probe */
1424 #ifdef MODULE
1425         printk(version);
1426 #endif
1427         return pci_register_driver(&yellowfin_driver);
1428 }
1429
1430
1431 static void __exit yellowfin_cleanup (void)
1432 {
1433         pci_unregister_driver (&yellowfin_driver);
1434 }
1435
1436
1437 module_init(yellowfin_init);
1438 module_exit(yellowfin_cleanup);
1439
1440 /*
1441  * Local variables:
1442  *  compile-command: "gcc -DMODULE -Wall -Wstrict-prototypes -O6 -c yellowfin.c"
1443  *  compile-command-alphaLX: "gcc -DMODULE -Wall -Wstrict-prototypes -O2 -c yellowfin.c -fomit-frame-pointer -fno-strength-reduce -mno-fp-regs -Wa,-m21164a -DBWX_USABLE -DBWIO_ENABLED"
1444  *  simple-compile-command: "gcc -DMODULE -O6 -c yellowfin.c"
1445  *  c-indent-level: 4
1446  *  c-basic-offset: 4
1447  *  tab-width: 4
1448  * End:
1449  */