8139cp net driver updates:
[opensuse:kernel.git] / drivers / net / 8139cp.c
1 /* 8139cp.c: A Linux PCI Ethernet driver for the RealTek 8139C+ chips. */
2 /*
3         Copyright 2001,2002 Jeff Garzik <jgarzik@mandrakesoft.com>
4
5         Copyright (C) 2001, 2002 David S. Miller (davem@redhat.com) [tg3.c]
6         Copyright (C) 2000, 2001 David S. Miller (davem@redhat.com) [sungem.c]
7         Copyright 2001 Manfred Spraul                               [natsemi.c]
8         Copyright 1999-2001 by Donald Becker.                       [natsemi.c]
9         Written 1997-2001 by Donald Becker.                         [8139too.c]
10         Copyright 1998-2001 by Jes Sorensen, <jes@trained-monkey.org>. [acenic.c]
11
12         This software may be used and distributed according to the terms of
13         the GNU General Public License (GPL), incorporated herein by reference.
14         Drivers based on or derived from this code fall under the GPL and must
15         retain the authorship, copyright and license notice.  This file is not
16         a complete program and may only be used when the entire operating
17         system is licensed under the GPL.
18
19         See the file COPYING in this distribution for more information.
20
21         TODO, in rough priority order:
22         * dev->tx_timeout
23         * LinkChg interrupt
24         * Support forcing media type with a module parameter,
25           like dl2k.c/sundance.c
26         * Implement PCI suspend/resume
27         * Constants (module parms?) for Rx work limit
28         * support 64-bit PCI DMA
29         * Complete reset on PciErr
30         * Consider Rx interrupt mitigation using TimerIntr
31         * Implement 8139C+ statistics dump; maybe not...
32           h/w stats can be reset only by software reset
33         * Tx checksumming
34         * Handle netif_rx return value
35         * ETHTOOL_GREGS, ETHTOOL_[GS]WOL,
36         * Investigate using skb->priority with h/w VLAN priority
37         * Investigate using High Priority Tx Queue with skb->priority
38         * Adjust Rx FIFO threshold and Max Rx DMA burst on Rx FIFO error
39         * Adjust Tx FIFO threshold and Max Tx DMA burst on Tx FIFO error
40         * Implement Tx software interrupt mitigation via
41                   Tx descriptor bit
42         * The real minimum of CP_MIN_MTU is 4 bytes.  However,
43           for this to be supported, one must(?) turn on packet padding.
44
45  */
46
47 #define DRV_NAME                "8139cp"
48 #define DRV_VERSION             "0.0.7"
49 #define DRV_RELDATE             "Feb 27, 2002"
50
51
52 #include <linux/config.h>
53 #include <linux/module.h>
54 #include <linux/kernel.h>
55 #include <linux/compiler.h>
56 #include <linux/netdevice.h>
57 #include <linux/etherdevice.h>
58 #include <linux/init.h>
59 #include <linux/pci.h>
60 #include <linux/delay.h>
61 #include <linux/ethtool.h>
62 #include <linux/mii.h>
63 #include <linux/if_vlan.h>
64 #include <linux/crc32.h>
65 #include <asm/io.h>
66 #include <asm/uaccess.h>
67
68 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
69 #define CP_VLAN_TAG_USED 1
70 #define CP_VLAN_TX_TAG(tx_desc,vlan_tag_value) \
71         do { (tx_desc)->opts2 = (vlan_tag_value); } while (0)
72 #else
73 #define CP_VLAN_TAG_USED 0
74 #define CP_VLAN_TX_TAG(tx_desc,vlan_tag_value) \
75         do { (tx_desc)->opts2 = 0; } while (0)
76 #endif
77
78 /* These identify the driver base version and may not be removed. */
79 static char version[] __devinitdata =
80 KERN_INFO DRV_NAME " 10/100 PCI Ethernet driver v" DRV_VERSION " (" DRV_RELDATE ")\n";
81
82 MODULE_AUTHOR("Jeff Garzik <jgarzik@mandrakesoft.com>");
83 MODULE_DESCRIPTION("RealTek RTL-8139C+ series 10/100 PCI Ethernet driver");
84 MODULE_LICENSE("GPL");
85
86 static int debug = -1;
87 MODULE_PARM (debug, "i");
88 MODULE_PARM_DESC (debug, "8139cp bitmapped message enable number");
89
90 /* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
91    The RTL chips use a 64 element hash table based on the Ethernet CRC.  */
92 static int multicast_filter_limit = 32;
93 MODULE_PARM (multicast_filter_limit, "i");
94 MODULE_PARM_DESC (multicast_filter_limit, "8139cp maximum number of filtered multicast addresses");
95
96 #define PFX                     DRV_NAME ": "
97
98 #define CP_DEF_MSG_ENABLE       (NETIF_MSG_DRV          | \
99                                  NETIF_MSG_PROBE        | \
100                                  NETIF_MSG_LINK)
101 #define CP_REGS_SIZE            (0xff + 1)
102 #define CP_RX_RING_SIZE         64
103 #define CP_TX_RING_SIZE         64
104 #define CP_RING_BYTES           \
105                 ((sizeof(struct cp_desc) * CP_RX_RING_SIZE) +   \
106                 (sizeof(struct cp_desc) * CP_TX_RING_SIZE))
107 #define NEXT_TX(N)              (((N) + 1) & (CP_TX_RING_SIZE - 1))
108 #define NEXT_RX(N)              (((N) + 1) & (CP_RX_RING_SIZE - 1))
109 #define TX_BUFFS_AVAIL(CP)                                      \
110         (((CP)->tx_tail <= (CP)->tx_head) ?                     \
111           (CP)->tx_tail + (CP_TX_RING_SIZE - 1) - (CP)->tx_head :       \
112           (CP)->tx_tail - (CP)->tx_head - 1)
113
114 #define PKT_BUF_SZ              1536    /* Size of each temporary Rx buffer.*/
115 #define RX_OFFSET               2
116 #define CP_INTERNAL_PHY         32
117
118 /* The following settings are log_2(bytes)-4:  0 == 16 bytes .. 6==1024, 7==end of packet. */
119 #define RX_FIFO_THRESH          5       /* Rx buffer level before first PCI xfer.  */
120 #define RX_DMA_BURST            4       /* Maximum PCI burst, '4' is 256 */
121 #define TX_DMA_BURST            6       /* Maximum PCI burst, '6' is 1024 */
122 #define TX_EARLY_THRESH         256     /* Early Tx threshold, in bytes */
123
124 /* Time in jiffies before concluding the transmitter is hung. */
125 #define TX_TIMEOUT              (6*HZ)
126
127 /* hardware minimum and maximum for a single frame's data payload */
128 #define CP_MIN_MTU              60      /* TODO: allow lower, but pad */
129 #define CP_MAX_MTU              4096
130
131 enum {
132         /* NIC register offsets */
133         MAC0            = 0x00, /* Ethernet hardware address. */
134         MAR0            = 0x08, /* Multicast filter. */
135         TxRingAddr      = 0x20, /* 64-bit start addr of Tx ring */
136         HiTxRingAddr    = 0x28, /* 64-bit start addr of high priority Tx ring */
137         Cmd             = 0x37, /* Command register */
138         IntrMask        = 0x3C, /* Interrupt mask */
139         IntrStatus      = 0x3E, /* Interrupt status */
140         TxConfig        = 0x40, /* Tx configuration */
141         ChipVersion     = 0x43, /* 8-bit chip version, inside TxConfig */
142         RxConfig        = 0x44, /* Rx configuration */
143         Cfg9346         = 0x50, /* EEPROM select/control; Cfg reg [un]lock */
144         Config1         = 0x52, /* Config1 */
145         Config3         = 0x59, /* Config3 */
146         Config4         = 0x5A, /* Config4 */
147         MultiIntr       = 0x5C, /* Multiple interrupt select */
148         BasicModeCtrl   = 0x62, /* MII BMCR */
149         BasicModeStatus = 0x64, /* MII BMSR */
150         NWayAdvert      = 0x66, /* MII ADVERTISE */
151         NWayLPAR        = 0x68, /* MII LPA */
152         NWayExpansion   = 0x6A, /* MII Expansion */
153         Config5         = 0xD8, /* Config5 */
154         TxPoll          = 0xD9, /* Tell chip to check Tx descriptors for work */
155         CpCmd           = 0xE0, /* C+ Command register (C+ mode only) */
156         RxRingAddr      = 0xE4, /* 64-bit start addr of Rx ring */
157         TxThresh        = 0xEC, /* Early Tx threshold */
158         OldRxBufAddr    = 0x30, /* DMA address of Rx ring buffer (C mode) */
159         OldTSD0         = 0x10, /* DMA address of first Tx desc (C mode) */
160
161         /* Tx and Rx status descriptors */
162         DescOwn         = (1 << 31), /* Descriptor is owned by NIC */
163         RingEnd         = (1 << 30), /* End of descriptor ring */
164         FirstFrag       = (1 << 29), /* First segment of a packet */
165         LastFrag        = (1 << 28), /* Final segment of a packet */
166         TxError         = (1 << 23), /* Tx error summary */
167         RxError         = (1 << 20), /* Rx error summary */
168         IPCS            = (1 << 18), /* Calculate IP checksum */
169         UDPCS           = (1 << 17), /* Calculate UDP/IP checksum */
170         TCPCS           = (1 << 16), /* Calculate TCP/IP checksum */
171         TxVlanTag       = (1 << 17), /* Add VLAN tag */
172         RxVlanTagged    = (1 << 16), /* Rx VLAN tag available */
173         IPFail          = (1 << 15), /* IP checksum failed */
174         UDPFail         = (1 << 14), /* UDP/IP checksum failed */
175         TCPFail         = (1 << 13), /* TCP/IP checksum failed */
176         NormalTxPoll    = (1 << 6),  /* One or more normal Tx packets to send */
177         PID1            = (1 << 17), /* 2 protocol id bits:  0==non-IP, */
178         PID0            = (1 << 16), /* 1==UDP/IP, 2==TCP/IP, 3==IP */
179         RxProtoTCP      = 2,
180         RxProtoUDP      = 1,
181         RxProtoIP       = 3,
182         TxFIFOUnder     = (1 << 25), /* Tx FIFO underrun */
183         TxOWC           = (1 << 22), /* Tx Out-of-window collision */
184         TxLinkFail      = (1 << 21), /* Link failed during Tx of packet */
185         TxMaxCol        = (1 << 20), /* Tx aborted due to excessive collisions */
186         TxColCntShift   = 16,        /* Shift, to get 4-bit Tx collision cnt */
187         TxColCntMask    = 0x01 | 0x02 | 0x04 | 0x08, /* 4-bit collision count */
188         RxErrFrame      = (1 << 27), /* Rx frame alignment error */
189         RxMcast         = (1 << 26), /* Rx multicast packet rcv'd */
190         RxErrCRC        = (1 << 18), /* Rx CRC error */
191         RxErrRunt       = (1 << 19), /* Rx error, packet < 64 bytes */
192         RxErrLong       = (1 << 21), /* Rx error, packet > 4096 bytes */
193         RxErrFIFO       = (1 << 22), /* Rx error, FIFO overflowed, pkt bad */
194
195         /* RxConfig register */
196         RxCfgFIFOShift  = 13,        /* Shift, to get Rx FIFO thresh value */
197         RxCfgDMAShift   = 8,         /* Shift, to get Rx Max DMA value */
198         AcceptErr       = 0x20,      /* Accept packets with CRC errors */
199         AcceptRunt      = 0x10,      /* Accept runt (<64 bytes) packets */
200         AcceptBroadcast = 0x08,      /* Accept broadcast packets */
201         AcceptMulticast = 0x04,      /* Accept multicast packets */
202         AcceptMyPhys    = 0x02,      /* Accept pkts with our MAC as dest */
203         AcceptAllPhys   = 0x01,      /* Accept all pkts w/ physical dest */
204
205         /* IntrMask / IntrStatus registers */
206         PciErr          = (1 << 15), /* System error on the PCI bus */
207         TimerIntr       = (1 << 14), /* Asserted when TCTR reaches TimerInt value */
208         LenChg          = (1 << 13), /* Cable length change */
209         SWInt           = (1 << 8),  /* Software-requested interrupt */
210         TxEmpty         = (1 << 7),  /* No Tx descriptors available */
211         RxFIFOOvr       = (1 << 6),  /* Rx FIFO Overflow */
212         LinkChg         = (1 << 5),  /* Packet underrun, or link change */
213         RxEmpty         = (1 << 4),  /* No Rx descriptors available */
214         TxErr           = (1 << 3),  /* Tx error */
215         TxOK            = (1 << 2),  /* Tx packet sent */
216         RxErr           = (1 << 1),  /* Rx error */
217         RxOK            = (1 << 0),  /* Rx packet received */
218         IntrResvd       = (1 << 10), /* reserved, according to RealTek engineers,
219                                         but hardware likes to raise it */
220
221         IntrAll         = PciErr | TimerIntr | LenChg | SWInt | TxEmpty |
222                           RxFIFOOvr | LinkChg | RxEmpty | TxErr | TxOK |
223                           RxErr | RxOK | IntrResvd,
224
225         /* C mode command register */
226         CmdReset        = (1 << 4),  /* Enable to reset; self-clearing */
227         RxOn            = (1 << 3),  /* Rx mode enable */
228         TxOn            = (1 << 2),  /* Tx mode enable */
229
230         /* C+ mode command register */
231         RxVlanOn        = (1 << 6),  /* Rx VLAN de-tagging enable */
232         RxChkSum        = (1 << 5),  /* Rx checksum offload enable */
233         PCIMulRW        = (1 << 3),  /* Enable PCI read/write multiple */
234         CpRxOn          = (1 << 1),  /* Rx mode enable */
235         CpTxOn          = (1 << 0),  /* Tx mode enable */
236
237         /* Cfg9436 EEPROM control register */
238         Cfg9346_Lock    = 0x00,      /* Lock ConfigX/MII register access */
239         Cfg9346_Unlock  = 0xC0,      /* Unlock ConfigX/MII register access */
240
241         /* TxConfig register */
242         IFG             = (1 << 25) | (1 << 24), /* standard IEEE interframe gap */
243         TxDMAShift      = 8,         /* DMA burst value (0-7) is shift this many bits */
244
245         /* Early Tx Threshold register */
246         TxThreshMask    = 0x3f,      /* Mask bits 5-0 */
247         TxThreshMax     = 2048,      /* Max early Tx threshold */
248
249         /* Config1 register */
250         DriverLoaded    = (1 << 5),  /* Software marker, driver is loaded */
251         PMEnable        = (1 << 0),  /* Enable various PM features of chip */
252
253         /* Config3 register */
254         PARMEnable      = (1 << 6),  /* Enable auto-loading of PHY parms */
255
256         /* Config5 register */
257         PMEStatus       = (1 << 0),  /* PME status can be reset by PCI RST# */
258 };
259
260 static const unsigned int cp_intr_mask =
261         PciErr | LinkChg |
262         RxOK | RxErr | RxEmpty | RxFIFOOvr |
263         TxOK | TxErr | TxEmpty;
264
265 static const unsigned int cp_rx_config =
266           (RX_FIFO_THRESH << RxCfgFIFOShift) |
267           (RX_DMA_BURST << RxCfgDMAShift);
268
269 struct cp_desc {
270         u32             opts1;
271         u32             opts2;
272         u32             addr_lo;
273         u32             addr_hi;
274 };
275
276 struct ring_info {
277         struct sk_buff          *skb;
278         dma_addr_t              mapping;
279         unsigned                frag;
280 };
281
282 struct cp_extra_stats {
283         unsigned long           rx_frags;
284 };
285
286 struct cp_private {
287         unsigned                tx_head;
288         unsigned                tx_tail;
289         unsigned                rx_tail;
290
291         void                    *regs;
292         struct net_device       *dev;
293         spinlock_t              lock;
294
295         struct cp_desc          *rx_ring;
296         struct cp_desc          *tx_ring;
297         struct ring_info        tx_skb[CP_TX_RING_SIZE];
298         struct ring_info        rx_skb[CP_RX_RING_SIZE];
299         unsigned                rx_buf_sz;
300         dma_addr_t              ring_dma;
301
302 #if CP_VLAN_TAG_USED
303         struct vlan_group       *vlgrp;
304 #endif
305
306         u32                     msg_enable;
307
308         struct net_device_stats net_stats;
309         struct cp_extra_stats   cp_stats;
310
311         struct pci_dev          *pdev;
312         u32                     rx_config;
313
314         struct sk_buff          *frag_skb;
315         unsigned                dropping_frag : 1;
316
317         struct mii_if_info      mii_if;
318 };
319
320 #define cpr8(reg)       readb(cp->regs + (reg))
321 #define cpr16(reg)      readw(cp->regs + (reg))
322 #define cpr32(reg)      readl(cp->regs + (reg))
323 #define cpw8(reg,val)   writeb((val), cp->regs + (reg))
324 #define cpw16(reg,val)  writew((val), cp->regs + (reg))
325 #define cpw32(reg,val)  writel((val), cp->regs + (reg))
326 #define cpw8_f(reg,val) do {                    \
327         writeb((val), cp->regs + (reg));        \
328         readb(cp->regs + (reg));                \
329         } while (0)
330 #define cpw16_f(reg,val) do {                   \
331         writew((val), cp->regs + (reg));        \
332         readw(cp->regs + (reg));                \
333         } while (0)
334 #define cpw32_f(reg,val) do {                   \
335         writel((val), cp->regs + (reg));        \
336         readl(cp->regs + (reg));                \
337         } while (0)
338
339
340 static void __cp_set_rx_mode (struct net_device *dev);
341 static void cp_tx (struct cp_private *cp);
342 static void cp_clean_rings (struct cp_private *cp);
343
344
345 static struct pci_device_id cp_pci_tbl[] __devinitdata = {
346         { PCI_VENDOR_ID_REALTEK, PCI_DEVICE_ID_REALTEK_8139,
347           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
348         { },
349 };
350 MODULE_DEVICE_TABLE(pci, cp_pci_tbl);
351
352 static inline void cp_set_rxbufsize (struct cp_private *cp)
353 {
354         unsigned int mtu = cp->dev->mtu;
355         
356         if (mtu > ETH_DATA_LEN)
357                 /* MTU + ethernet header + FCS + optional VLAN tag */
358                 cp->rx_buf_sz = mtu + ETH_HLEN + 8;
359         else
360                 cp->rx_buf_sz = PKT_BUF_SZ;
361 }
362
363 static inline void cp_rx_skb (struct cp_private *cp, struct sk_buff *skb,
364                               struct cp_desc *desc)
365 {
366         skb->protocol = eth_type_trans (skb, cp->dev);
367
368         cp->net_stats.rx_packets++;
369         cp->net_stats.rx_bytes += skb->len;
370         cp->dev->last_rx = jiffies;
371
372 #if CP_VLAN_TAG_USED
373         if (cp->vlgrp && (desc->opts2 & RxVlanTagged)) {
374                 vlan_hwaccel_rx(skb, cp->vlgrp, desc->opts2 & 0xffff);
375         } else
376 #endif
377                 netif_rx(skb);
378 }
379
380 static void cp_rx_err_acct (struct cp_private *cp, unsigned rx_tail,
381                             u32 status, u32 len)
382 {
383         if (netif_msg_rx_err (cp))
384                 printk (KERN_DEBUG
385                         "%s: rx err, slot %d status 0x%x len %d\n",
386                         cp->dev->name, rx_tail, status, len);
387         cp->net_stats.rx_errors++;
388         if (status & RxErrFrame)
389                 cp->net_stats.rx_frame_errors++;
390         if (status & RxErrCRC)
391                 cp->net_stats.rx_crc_errors++;
392         if (status & RxErrRunt)
393                 cp->net_stats.rx_length_errors++;
394         if (status & RxErrLong)
395                 cp->net_stats.rx_length_errors++;
396         if (status & RxErrFIFO)
397                 cp->net_stats.rx_fifo_errors++;
398 }
399
400 static void cp_rx_frag (struct cp_private *cp, unsigned rx_tail,
401                         struct sk_buff *skb, u32 status, u32 len)
402 {
403         struct sk_buff *copy_skb, *frag_skb = cp->frag_skb;
404         unsigned orig_len = frag_skb ? frag_skb->len : 0;
405         unsigned target_len = orig_len + len;
406         unsigned first_frag = status & FirstFrag;
407         unsigned last_frag = status & LastFrag;
408
409         if (netif_msg_rx_status (cp))
410                 printk (KERN_DEBUG "%s: rx %s%sfrag, slot %d status 0x%x len %d\n",
411                         cp->dev->name,
412                         cp->dropping_frag ? "dropping " : "",
413                         first_frag ? "first " :
414                         last_frag ? "last " : "",
415                         rx_tail, status, len);
416
417         cp->cp_stats.rx_frags++;
418
419         if (!frag_skb && !first_frag)
420                 cp->dropping_frag = 1;
421         if (cp->dropping_frag)
422                 goto drop_frag;
423
424         copy_skb = dev_alloc_skb (target_len + RX_OFFSET);
425         if (!copy_skb) {
426                 printk(KERN_WARNING "%s: rx slot %d alloc failed\n",
427                        cp->dev->name, rx_tail);
428
429                 cp->dropping_frag = 1;
430 drop_frag:
431                 if (frag_skb) {
432                         dev_kfree_skb_irq(frag_skb);
433                         cp->frag_skb = NULL;
434                 }
435                 if (last_frag) {
436                         cp->net_stats.rx_dropped++;
437                         cp->dropping_frag = 0;
438                 }
439                 return;
440         }
441
442         copy_skb->dev = cp->dev;
443         skb_reserve(copy_skb, RX_OFFSET);
444         skb_put(copy_skb, target_len);
445         if (frag_skb) {
446                 memcpy(copy_skb->data, frag_skb->data, orig_len);
447                 dev_kfree_skb_irq(frag_skb);
448         }
449         pci_dma_sync_single(cp->pdev, cp->rx_skb[rx_tail].mapping,
450                             len, PCI_DMA_FROMDEVICE);
451         memcpy(copy_skb->data + orig_len, skb->data, len);
452
453         copy_skb->ip_summed = CHECKSUM_NONE;
454
455         if (last_frag) {
456                 if (status & (RxError | RxErrFIFO)) {
457                         cp_rx_err_acct(cp, rx_tail, status, len);
458                         dev_kfree_skb_irq(copy_skb);
459                 } else
460                         cp_rx_skb(cp, copy_skb, &cp->rx_ring[rx_tail]);
461                 cp->frag_skb = NULL;
462         } else {
463                 cp->frag_skb = copy_skb;
464         }
465 }
466
467 static inline unsigned int cp_rx_csum_ok (u32 status)
468 {
469         unsigned int protocol = (status >> 16) & 0x3;
470         
471         if (likely((protocol == RxProtoTCP) && (!(status & TCPFail))))
472                 return 1;
473         else if ((protocol == RxProtoUDP) && (!(status & UDPFail)))
474                 return 1;
475         else if ((protocol == RxProtoIP) && (!(status & IPFail)))
476                 return 1;
477         return 0;
478 }
479
480 static void cp_rx (struct cp_private *cp)
481 {
482         unsigned rx_tail = cp->rx_tail;
483         unsigned rx_work = 100;
484
485         while (rx_work--) {
486                 u32 status, len;
487                 dma_addr_t mapping;
488                 struct sk_buff *skb, *new_skb;
489                 struct cp_desc *desc;
490                 unsigned buflen;
491
492                 skb = cp->rx_skb[rx_tail].skb;
493                 if (!skb)
494                         BUG();
495
496                 desc = &cp->rx_ring[rx_tail];
497                 status = le32_to_cpu(desc->opts1);
498                 if (status & DescOwn)
499                         break;
500
501                 len = (status & 0x1fff) - 4;
502                 mapping = cp->rx_skb[rx_tail].mapping;
503
504                 if ((status & (FirstFrag | LastFrag)) != (FirstFrag | LastFrag)) {
505                         cp_rx_frag(cp, rx_tail, skb, status, len);
506                         goto rx_next;
507                 }
508
509                 if (status & (RxError | RxErrFIFO)) {
510                         cp_rx_err_acct(cp, rx_tail, status, len);
511                         goto rx_next;
512                 }
513
514                 if (netif_msg_rx_status(cp))
515                         printk(KERN_DEBUG "%s: rx slot %d status 0x%x len %d\n",
516                                cp->dev->name, rx_tail, status, len);
517
518                 buflen = cp->rx_buf_sz + RX_OFFSET;
519                 new_skb = dev_alloc_skb (buflen);
520                 if (!new_skb) {
521                         cp->net_stats.rx_dropped++;
522                         goto rx_next;
523                 }
524
525                 skb_reserve(new_skb, RX_OFFSET);
526                 new_skb->dev = cp->dev;
527
528                 pci_unmap_single(cp->pdev, mapping,
529                                  buflen, PCI_DMA_FROMDEVICE);
530
531                 /* Handle checksum offloading for incoming packets. */
532                 if (cp_rx_csum_ok(status))
533                         skb->ip_summed = CHECKSUM_UNNECESSARY;
534                 else
535                         skb->ip_summed = CHECKSUM_NONE;
536
537                 skb_put(skb, len);
538
539                 mapping =
540                 cp->rx_skb[rx_tail].mapping =
541                         pci_map_single(cp->pdev, new_skb->tail,
542                                        buflen, PCI_DMA_FROMDEVICE);
543                 cp->rx_skb[rx_tail].skb = new_skb;
544
545                 cp_rx_skb(cp, skb, desc);
546
547 rx_next:
548                 if (rx_tail == (CP_RX_RING_SIZE - 1))
549                         desc->opts1 = cpu_to_le32(DescOwn | RingEnd |
550                                                   cp->rx_buf_sz);
551                 else
552                         desc->opts1 = cpu_to_le32(DescOwn | cp->rx_buf_sz);
553                 cp->rx_ring[rx_tail].opts2 = 0;
554                 cp->rx_ring[rx_tail].addr_lo = cpu_to_le32(mapping);
555                 rx_tail = NEXT_RX(rx_tail);
556         }
557
558         if (!rx_work)
559                 printk(KERN_WARNING "%s: rx work limit reached\n", cp->dev->name);
560
561         cp->rx_tail = rx_tail;
562 }
563
564 static void cp_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
565 {
566         struct net_device *dev = dev_instance;
567         struct cp_private *cp = dev->priv;
568         u16 status;
569
570         status = cpr16(IntrStatus);
571         if (!status || (status == 0xFFFF))
572                 return;
573
574         if (netif_msg_intr(cp))
575                 printk(KERN_DEBUG "%s: intr, status %04x cmd %02x cpcmd %04x\n",
576                         dev->name, status, cpr8(Cmd), cpr16(CpCmd));
577
578         spin_lock(&cp->lock);
579
580         if (status & (RxOK | RxErr | RxEmpty | RxFIFOOvr))
581                 cp_rx(cp);
582         if (status & (TxOK | TxErr | TxEmpty | SWInt))
583                 cp_tx(cp);
584
585         cpw16_f(IntrStatus, status);
586
587         if (status & PciErr) {
588                 u16 pci_status;
589
590                 pci_read_config_word(cp->pdev, PCI_STATUS, &pci_status);
591                 pci_write_config_word(cp->pdev, PCI_STATUS, pci_status);
592                 printk(KERN_ERR "%s: PCI bus error, status=%04x, PCI status=%04x\n",
593                        dev->name, status, pci_status);
594         }
595
596         spin_unlock(&cp->lock);
597 }
598
599 static void cp_tx (struct cp_private *cp)
600 {
601         unsigned tx_head = cp->tx_head;
602         unsigned tx_tail = cp->tx_tail;
603
604         while (tx_tail != tx_head) {
605                 struct sk_buff *skb;
606                 u32 status;
607
608                 rmb();
609                 status = le32_to_cpu(cp->tx_ring[tx_tail].opts1);
610                 if (status & DescOwn)
611                         break;
612
613                 skb = cp->tx_skb[tx_tail].skb;
614                 if (!skb)
615                         BUG();
616
617                 pci_unmap_single(cp->pdev, cp->tx_skb[tx_tail].mapping,
618                                         skb->len, PCI_DMA_TODEVICE);
619
620                 if (status & LastFrag) {
621                         if (status & (TxError | TxFIFOUnder)) {
622                                 if (netif_msg_tx_err(cp))
623                                         printk(KERN_DEBUG "%s: tx err, status 0x%x\n",
624                                                cp->dev->name, status);
625                                 cp->net_stats.tx_errors++;
626                                 if (status & TxOWC)
627                                         cp->net_stats.tx_window_errors++;
628                                 if (status & TxMaxCol)
629                                         cp->net_stats.tx_aborted_errors++;
630                                 if (status & TxLinkFail)
631                                         cp->net_stats.tx_carrier_errors++;
632                                 if (status & TxFIFOUnder)
633                                         cp->net_stats.tx_fifo_errors++;
634                         } else {
635                                 cp->net_stats.collisions +=
636                                         ((status >> TxColCntShift) & TxColCntMask);
637                                 cp->net_stats.tx_packets++;
638                                 cp->net_stats.tx_bytes += skb->len;
639                                 if (netif_msg_tx_done(cp))
640                                         printk(KERN_DEBUG "%s: tx done, slot %d\n", cp->dev->name, tx_tail);
641                         }
642                         dev_kfree_skb_irq(skb);
643                 }
644
645                 cp->tx_skb[tx_tail].skb = NULL;
646
647                 tx_tail = NEXT_TX(tx_tail);
648         }
649
650         cp->tx_tail = tx_tail;
651
652         if (netif_queue_stopped(cp->dev) && (TX_BUFFS_AVAIL(cp) > (MAX_SKB_FRAGS + 1)))
653                 netif_wake_queue(cp->dev);
654 }
655
656 static int cp_start_xmit (struct sk_buff *skb, struct net_device *dev)
657 {
658         struct cp_private *cp = dev->priv;
659         unsigned entry;
660         u32 eor;
661 #if CP_VLAN_TAG_USED
662         u32 vlan_tag = 0;
663 #endif
664
665         spin_lock_irq(&cp->lock);
666
667         /* This is a hard error, log it. */
668         if (TX_BUFFS_AVAIL(cp) <= (skb_shinfo(skb)->nr_frags + 1)) {
669                 netif_stop_queue(dev);
670                 spin_unlock_irq(&cp->lock);
671                 printk(KERN_ERR PFX "%s: BUG! Tx Ring full when queue awake!\n",
672                        dev->name);
673                 return 1;
674         }
675
676 #if CP_VLAN_TAG_USED
677         if (cp->vlgrp && vlan_tx_tag_present(skb))
678                 vlan_tag = TxVlanTag | vlan_tx_tag_get(skb);
679 #endif
680
681         entry = cp->tx_head;
682         eor = (entry == (CP_TX_RING_SIZE - 1)) ? RingEnd : 0;
683         if (skb_shinfo(skb)->nr_frags == 0) {
684                 struct cp_desc *txd = &cp->tx_ring[entry];
685                 u32 mapping, len;
686
687                 len = skb->len;
688                 mapping = pci_map_single(cp->pdev, skb->data, len, PCI_DMA_TODEVICE);
689                 eor = (entry == (CP_TX_RING_SIZE - 1)) ? RingEnd : 0;
690                 CP_VLAN_TX_TAG(txd, vlan_tag);
691                 txd->addr_lo = cpu_to_le32(mapping);
692                 wmb();
693
694 #ifdef CP_TX_CHECKSUM
695                 txd->opts1 = cpu_to_le32(eor | len | DescOwn | FirstFrag |
696                         LastFrag | IPCS | UDPCS | TCPCS);
697 #else
698                 txd->opts1 = cpu_to_le32(eor | len | DescOwn | FirstFrag |
699                         LastFrag);
700 #endif
701                 wmb();
702
703                 cp->tx_skb[entry].skb = skb;
704                 cp->tx_skb[entry].mapping = mapping;
705                 cp->tx_skb[entry].frag = 0;
706                 entry = NEXT_TX(entry);
707         } else {
708                 struct cp_desc *txd;
709                 u32 first_len, first_mapping;
710                 int frag, first_entry = entry;
711
712                 /* We must give this initial chunk to the device last.
713                  * Otherwise we could race with the device.
714                  */
715                 first_len = skb->len - skb->data_len;
716                 first_mapping = pci_map_single(cp->pdev, skb->data,
717                                                first_len, PCI_DMA_TODEVICE);
718                 cp->tx_skb[entry].skb = skb;
719                 cp->tx_skb[entry].mapping = first_mapping;
720                 cp->tx_skb[entry].frag = 1;
721                 entry = NEXT_TX(entry);
722
723                 for (frag = 0; frag < skb_shinfo(skb)->nr_frags; frag++) {
724                         skb_frag_t *this_frag = &skb_shinfo(skb)->frags[frag];
725                         u32 len, mapping;
726                         u32 ctrl;
727
728                         len = this_frag->size;
729                         mapping = pci_map_single(cp->pdev,
730                                                  ((void *) page_address(this_frag->page) +
731                                                   this_frag->page_offset),
732                                                  len, PCI_DMA_TODEVICE);
733                         eor = (entry == (CP_TX_RING_SIZE - 1)) ? RingEnd : 0;
734 #ifdef CP_TX_CHECKSUM
735                         ctrl = eor | len | DescOwn | IPCS | UDPCS | TCPCS;
736 #else
737                         ctrl = eor | len | DescOwn;
738 #endif
739                         if (frag == skb_shinfo(skb)->nr_frags - 1)
740                                 ctrl |= LastFrag;
741
742                         txd = &cp->tx_ring[entry];
743                         CP_VLAN_TX_TAG(txd, vlan_tag);
744                         txd->addr_lo = cpu_to_le32(mapping);
745                         wmb();
746
747                         txd->opts1 = cpu_to_le32(ctrl);
748                         wmb();
749
750                         cp->tx_skb[entry].skb = skb;
751                         cp->tx_skb[entry].mapping = mapping;
752                         cp->tx_skb[entry].frag = frag + 2;
753                         entry = NEXT_TX(entry);
754                 }
755
756                 txd = &cp->tx_ring[first_entry];
757                 CP_VLAN_TX_TAG(txd, vlan_tag);
758                 txd->addr_lo = cpu_to_le32(first_mapping);
759                 wmb();
760
761 #ifdef CP_TX_CHECKSUM
762                 txd->opts1 = cpu_to_le32(first_len | FirstFrag | DescOwn | IPCS | UDPCS | TCPCS);
763 #else
764                 txd->opts1 = cpu_to_le32(first_len | FirstFrag | DescOwn);
765 #endif
766                 wmb();
767         }
768         cp->tx_head = entry;
769         if (netif_msg_tx_queued(cp))
770                 printk(KERN_DEBUG "%s: tx queued, slot %d, skblen %d\n",
771                        dev->name, entry, skb->len);
772         if (TX_BUFFS_AVAIL(cp) <= (MAX_SKB_FRAGS + 1))
773                 netif_stop_queue(dev);
774
775         spin_unlock_irq(&cp->lock);
776
777         cpw8(TxPoll, NormalTxPoll);
778         dev->trans_start = jiffies;
779
780         return 0;
781 }
782
783 /* Set or clear the multicast filter for this adaptor.
784    This routine is not state sensitive and need not be SMP locked. */
785
786 static void __cp_set_rx_mode (struct net_device *dev)
787 {
788         struct cp_private *cp = dev->priv;
789         u32 mc_filter[2];       /* Multicast hash filter */
790         int i, rx_mode;
791         u32 tmp;
792
793         /* Note: do not reorder, GCC is clever about common statements. */
794         if (dev->flags & IFF_PROMISC) {
795                 /* Unconditionally log net taps. */
796                 printk (KERN_NOTICE "%s: Promiscuous mode enabled.\n",
797                         dev->name);
798                 rx_mode =
799                     AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
800                     AcceptAllPhys;
801                 mc_filter[1] = mc_filter[0] = 0xffffffff;
802         } else if ((dev->mc_count > multicast_filter_limit)
803                    || (dev->flags & IFF_ALLMULTI)) {
804                 /* Too many to filter perfectly -- accept all multicasts. */
805                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
806                 mc_filter[1] = mc_filter[0] = 0xffffffff;
807         } else {
808                 struct dev_mc_list *mclist;
809                 rx_mode = AcceptBroadcast | AcceptMyPhys;
810                 mc_filter[1] = mc_filter[0] = 0;
811                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
812                      i++, mclist = mclist->next) {
813                         int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
814
815                         mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
816                         rx_mode |= AcceptMulticast;
817                 }
818         }
819
820         /* We can safely update without stopping the chip. */
821         tmp = cp_rx_config | rx_mode;
822         if (cp->rx_config != tmp) {
823                 cpw32_f (RxConfig, tmp);
824                 cp->rx_config = tmp;
825         }
826         cpw32_f (MAR0 + 0, mc_filter[0]);
827         cpw32_f (MAR0 + 4, mc_filter[1]);
828 }
829
830 static void cp_set_rx_mode (struct net_device *dev)
831 {
832         unsigned long flags;
833         struct cp_private *cp = dev->priv;
834
835         spin_lock_irqsave (&cp->lock, flags);
836         __cp_set_rx_mode(dev);
837         spin_unlock_irqrestore (&cp->lock, flags);
838 }
839
840 static void __cp_get_stats(struct cp_private *cp)
841 {
842         /* XXX implement */
843 }
844
845 static struct net_device_stats *cp_get_stats(struct net_device *dev)
846 {
847         struct cp_private *cp = dev->priv;
848
849         /* The chip only need report frame silently dropped. */
850         spin_lock_irq(&cp->lock);
851         if (netif_running(dev) && netif_device_present(dev))
852                 __cp_get_stats(cp);
853         spin_unlock_irq(&cp->lock);
854
855         return &cp->net_stats;
856 }
857
858 static void cp_stop_hw (struct cp_private *cp)
859 {
860         cpw16(IntrMask, 0);
861         cpr16(IntrMask);
862         cpw8(Cmd, 0);
863         cpw16(CpCmd, 0);
864         cpr16(CpCmd);
865         cpw16(IntrStatus, ~(cpr16(IntrStatus)));
866         synchronize_irq();
867         udelay(10);
868
869         cp->rx_tail = 0;
870         cp->tx_head = cp->tx_tail = 0;
871 }
872
873 static void cp_reset_hw (struct cp_private *cp)
874 {
875         unsigned work = 1000;
876
877         cpw8(Cmd, CmdReset);
878
879         while (work--) {
880                 if (!(cpr8(Cmd) & CmdReset))
881                         return;
882
883                 set_current_state(TASK_UNINTERRUPTIBLE);
884                 schedule_timeout(10);
885         }
886
887         printk(KERN_ERR "%s: hardware reset timeout\n", cp->dev->name);
888 }
889
890 static inline void cp_start_hw (struct cp_private *cp)
891 {
892         cpw8(Cmd, RxOn | TxOn);
893         cpw16(CpCmd, PCIMulRW | RxChkSum | CpRxOn | CpTxOn);
894 }
895
896 static void cp_init_hw (struct cp_private *cp)
897 {
898         struct net_device *dev = cp->dev;
899
900         cp_reset_hw(cp);
901
902         cpw8_f (Cfg9346, Cfg9346_Unlock);
903
904         /* Restore our idea of the MAC address. */
905         cpw32_f (MAC0 + 0, cpu_to_le32 (*(u32 *) (dev->dev_addr + 0)));
906         cpw32_f (MAC0 + 4, cpu_to_le32 (*(u32 *) (dev->dev_addr + 4)));
907
908         cp_start_hw(cp);
909         cpw8(TxThresh, 0x06); /* XXX convert magic num to a constant */
910
911         __cp_set_rx_mode(dev);
912         cpw32_f (TxConfig, IFG | (TX_DMA_BURST << TxDMAShift));
913
914         cpw8(Config1, cpr8(Config1) | DriverLoaded | PMEnable);
915         cpw8(Config3, PARMEnable); /* disables magic packet and WOL */
916         cpw8(Config5, cpr8(Config5) & PMEStatus); /* disables more WOL stuff */
917
918         cpw32_f(HiTxRingAddr, 0);
919         cpw32_f(HiTxRingAddr + 4, 0);
920         cpw32_f(OldRxBufAddr, 0);
921         cpw32_f(OldTSD0, 0);
922         cpw32_f(OldTSD0 + 4, 0);
923         cpw32_f(OldTSD0 + 8, 0);
924         cpw32_f(OldTSD0 + 12, 0);
925
926         cpw32_f(RxRingAddr, cp->ring_dma);
927         cpw32_f(RxRingAddr + 4, 0);
928         cpw32_f(TxRingAddr, cp->ring_dma + (sizeof(struct cp_desc) * CP_RX_RING_SIZE));
929         cpw32_f(TxRingAddr + 4, 0);
930
931         cpw16(MultiIntr, 0);
932
933         cpw16(IntrMask, cp_intr_mask);
934
935         cpw8_f (Cfg9346, Cfg9346_Lock);
936 }
937
938 static int cp_refill_rx (struct cp_private *cp)
939 {
940         unsigned i;
941
942         for (i = 0; i < CP_RX_RING_SIZE; i++) {
943                 struct sk_buff *skb;
944
945                 skb = dev_alloc_skb(cp->rx_buf_sz + RX_OFFSET);
946                 if (!skb)
947                         goto err_out;
948
949                 skb->dev = cp->dev;
950                 skb_reserve(skb, RX_OFFSET);
951
952                 cp->rx_skb[i].mapping = pci_map_single(cp->pdev,
953                         skb->tail, cp->rx_buf_sz, PCI_DMA_FROMDEVICE);
954                 cp->rx_skb[i].skb = skb;
955                 cp->rx_skb[i].frag = 0;
956
957                 if (i == (CP_RX_RING_SIZE - 1))
958                         cp->rx_ring[i].opts1 =
959                                 cpu_to_le32(DescOwn | RingEnd | cp->rx_buf_sz);
960                 else
961                         cp->rx_ring[i].opts1 =
962                                 cpu_to_le32(DescOwn | cp->rx_buf_sz);
963                 cp->rx_ring[i].opts2 = 0;
964                 cp->rx_ring[i].addr_lo = cpu_to_le32(cp->rx_skb[i].mapping);
965                 cp->rx_ring[i].addr_hi = 0;
966         }
967
968         return 0;
969
970 err_out:
971         cp_clean_rings(cp);
972         return -ENOMEM;
973 }
974
975 static int cp_init_rings (struct cp_private *cp)
976 {
977         memset(cp->tx_ring, 0, sizeof(struct cp_desc) * CP_TX_RING_SIZE);
978         cp->tx_ring[CP_TX_RING_SIZE - 1].opts1 = cpu_to_le32(RingEnd);
979
980         cp->rx_tail = 0;
981         cp->tx_head = cp->tx_tail = 0;
982
983         return cp_refill_rx (cp);
984 }
985
986 static int cp_alloc_rings (struct cp_private *cp)
987 {
988         cp->rx_ring = pci_alloc_consistent(cp->pdev, CP_RING_BYTES, &cp->ring_dma);
989         if (!cp->rx_ring)
990                 return -ENOMEM;
991         cp->tx_ring = &cp->rx_ring[CP_RX_RING_SIZE];
992         return cp_init_rings(cp);
993 }
994
995 static void cp_clean_rings (struct cp_private *cp)
996 {
997         unsigned i;
998
999         memset(cp->rx_ring, 0, sizeof(struct cp_desc) * CP_RX_RING_SIZE);
1000         memset(cp->tx_ring, 0, sizeof(struct cp_desc) * CP_TX_RING_SIZE);
1001
1002         for (i = 0; i < CP_RX_RING_SIZE; i++) {
1003                 if (cp->rx_skb[i].skb) {
1004                         pci_unmap_single(cp->pdev, cp->rx_skb[i].mapping,
1005                                          cp->rx_buf_sz, PCI_DMA_FROMDEVICE);
1006                         dev_kfree_skb(cp->rx_skb[i].skb);
1007                 }
1008         }
1009
1010         for (i = 0; i < CP_TX_RING_SIZE; i++) {
1011                 if (cp->tx_skb[i].skb) {
1012                         struct sk_buff *skb = cp->tx_skb[i].skb;
1013                         pci_unmap_single(cp->pdev, cp->tx_skb[i].mapping,
1014                                          skb->len, PCI_DMA_TODEVICE);
1015                         dev_kfree_skb(skb);
1016                         cp->net_stats.tx_dropped++;
1017                 }
1018         }
1019
1020         memset(&cp->rx_skb, 0, sizeof(struct ring_info) * CP_RX_RING_SIZE);
1021         memset(&cp->tx_skb, 0, sizeof(struct ring_info) * CP_TX_RING_SIZE);
1022 }
1023
1024 static void cp_free_rings (struct cp_private *cp)
1025 {
1026         cp_clean_rings(cp);
1027         pci_free_consistent(cp->pdev, CP_RING_BYTES, cp->rx_ring, cp->ring_dma);
1028         cp->rx_ring = NULL;
1029         cp->tx_ring = NULL;
1030 }
1031
1032 static int cp_open (struct net_device *dev)
1033 {
1034         struct cp_private *cp = dev->priv;
1035         int rc;
1036
1037         if (netif_msg_ifup(cp))
1038                 printk(KERN_DEBUG "%s: enabling interface\n", dev->name);
1039
1040         rc = cp_alloc_rings(cp);
1041         if (rc)
1042                 return rc;
1043
1044         cp_init_hw(cp);
1045
1046         rc = request_irq(dev->irq, cp_interrupt, SA_SHIRQ, dev->name, dev);
1047         if (rc)
1048                 goto err_out_hw;
1049
1050         netif_start_queue(dev);
1051
1052         return 0;
1053
1054 err_out_hw:
1055         cp_stop_hw(cp);
1056         cp_free_rings(cp);
1057         return rc;
1058 }
1059
1060 static int cp_close (struct net_device *dev)
1061 {
1062         struct cp_private *cp = dev->priv;
1063
1064         if (netif_msg_ifdown(cp))
1065                 printk(KERN_DEBUG "%s: disabling interface\n", dev->name);
1066
1067         netif_stop_queue(dev);
1068         cp_stop_hw(cp);
1069         free_irq(dev->irq, dev);
1070         cp_free_rings(cp);
1071         return 0;
1072 }
1073
1074 static int cp_change_mtu(struct net_device *dev, int new_mtu)
1075 {
1076         struct cp_private *cp = dev->priv;
1077         int rc;
1078
1079         /* check for invalid MTU, according to hardware limits */
1080         if (new_mtu < CP_MIN_MTU || new_mtu > CP_MAX_MTU)
1081                 return -EINVAL;
1082
1083         /* if network interface not up, no need for complexity */
1084         if (!netif_running(dev)) {
1085                 dev->mtu = new_mtu;
1086                 cp_set_rxbufsize(cp);   /* set new rx buf size */
1087                 return 0;
1088         }
1089
1090         spin_lock_irq(&cp->lock);
1091
1092         cp_stop_hw(cp);                 /* stop h/w and free rings */
1093         cp_clean_rings(cp);
1094
1095         dev->mtu = new_mtu;
1096         cp_set_rxbufsize(cp);           /* set new rx buf size */
1097
1098         rc = cp_init_rings(cp);         /* realloc and restart h/w */
1099         cp_start_hw(cp);
1100
1101         spin_unlock_irq(&cp->lock);
1102
1103         return rc;
1104 }
1105
1106 static char mii_2_8139_map[8] = {
1107         BasicModeCtrl,
1108         BasicModeStatus,
1109         0,
1110         0,
1111         NWayAdvert,
1112         NWayLPAR,
1113         NWayExpansion,
1114         0
1115 };
1116
1117 static int mdio_read(struct net_device *dev, int phy_id, int location)
1118 {
1119         struct cp_private *cp = dev->priv;
1120
1121         return location < 8 && mii_2_8139_map[location] ?
1122                readw(cp->regs + mii_2_8139_map[location]) : 0;
1123 }
1124
1125
1126 static void mdio_write(struct net_device *dev, int phy_id, int location,
1127                        int value)
1128 {
1129         struct cp_private *cp = dev->priv;
1130
1131         if (location == 0) {
1132                 cpw8(Cfg9346, Cfg9346_Unlock);
1133                 cpw16(BasicModeCtrl, value);
1134                 cpw8(Cfg9346, Cfg9346_Lock);
1135         } else if (location < 8 && mii_2_8139_map[location])
1136                 cpw16(mii_2_8139_map[location], value);
1137 }
1138
1139 static int cp_ethtool_ioctl (struct cp_private *cp, void *useraddr)
1140 {
1141         u32 ethcmd;
1142
1143         /* dev_ioctl() in ../../net/core/dev.c has already checked
1144            capable(CAP_NET_ADMIN), so don't bother with that here.  */
1145
1146         if (get_user(ethcmd, (u32 *)useraddr))
1147                 return -EFAULT;
1148
1149         switch (ethcmd) {
1150
1151         case ETHTOOL_GDRVINFO: {
1152                 struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
1153                 strcpy (info.driver, DRV_NAME);
1154                 strcpy (info.version, DRV_VERSION);
1155                 strcpy (info.bus_info, cp->pdev->slot_name);
1156                 if (copy_to_user (useraddr, &info, sizeof (info)))
1157                         return -EFAULT;
1158                 return 0;
1159         }
1160
1161         /* get settings */
1162         case ETHTOOL_GSET: {
1163                 struct ethtool_cmd ecmd = { ETHTOOL_GSET };
1164                 spin_lock_irq(&cp->lock);
1165                 mii_ethtool_gset(&cp->mii_if, &ecmd);
1166                 spin_unlock_irq(&cp->lock);
1167                 if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
1168                         return -EFAULT;
1169                 return 0;
1170         }
1171         /* set settings */
1172         case ETHTOOL_SSET: {
1173                 int r;
1174                 struct ethtool_cmd ecmd;
1175                 if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
1176                         return -EFAULT;
1177                 spin_lock_irq(&cp->lock);
1178                 r = mii_ethtool_sset(&cp->mii_if, &ecmd);
1179                 spin_unlock_irq(&cp->lock);
1180                 return r;
1181         }
1182         /* restart autonegotiation */
1183         case ETHTOOL_NWAY_RST: {
1184                 return mii_nway_restart(&cp->mii_if);
1185         }
1186         /* get link status */
1187         case ETHTOOL_GLINK: {
1188                 struct ethtool_value edata = {ETHTOOL_GLINK};
1189                 edata.data = mii_link_ok(&cp->mii_if);
1190                 if (copy_to_user(useraddr, &edata, sizeof(edata)))
1191                         return -EFAULT;
1192                 return 0;
1193         }
1194
1195         /* get message-level */
1196         case ETHTOOL_GMSGLVL: {
1197                 struct ethtool_value edata = {ETHTOOL_GMSGLVL};
1198                 edata.data = cp->msg_enable;
1199                 if (copy_to_user(useraddr, &edata, sizeof(edata)))
1200                         return -EFAULT;
1201                 return 0;
1202         }
1203         /* set message-level */
1204         case ETHTOOL_SMSGLVL: {
1205                 struct ethtool_value edata;
1206                 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1207                         return -EFAULT;
1208                 cp->msg_enable = edata.data;
1209                 return 0;
1210         }
1211
1212         default:
1213                 break;
1214         }
1215
1216         return -EOPNOTSUPP;
1217 }
1218
1219
1220 static int cp_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
1221 {
1222         struct cp_private *cp = dev->priv;
1223         int rc = 0;
1224
1225         if (!netif_running(dev))
1226                 return -EINVAL;
1227
1228         switch (cmd) {
1229         case SIOCETHTOOL:
1230                 return cp_ethtool_ioctl(cp, (void *) rq->ifr_data);
1231
1232         default:
1233                 rc = -EOPNOTSUPP;
1234                 break;
1235         }
1236
1237         return rc;
1238 }
1239
1240 #if CP_VLAN_TAG_USED
1241 static void cp_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
1242 {
1243         struct cp_private *cp = dev->priv;
1244
1245         spin_lock_irq(&cp->lock);
1246         cp->vlgrp = grp;
1247         cpw16(CpCmd, cpr16(CpCmd) | RxVlanOn);
1248         spin_unlock_irq(&cp->lock);
1249 }
1250
1251 static void cp_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
1252 {
1253         struct cp_private *cp = dev->priv;
1254
1255         spin_lock_irq(&cp->lock);
1256         cpw16(CpCmd, cpr16(CpCmd) & ~RxVlanOn);
1257         if (cp->vlgrp)
1258                 cp->vlgrp->vlan_devices[vid] = NULL;
1259         spin_unlock_irq(&cp->lock);
1260 }
1261 #endif
1262
1263 /* Serial EEPROM section. */
1264
1265 /*  EEPROM_Ctrl bits. */
1266 #define EE_SHIFT_CLK    0x04    /* EEPROM shift clock. */
1267 #define EE_CS                   0x08    /* EEPROM chip select. */
1268 #define EE_DATA_WRITE   0x02    /* EEPROM chip data in. */
1269 #define EE_WRITE_0              0x00
1270 #define EE_WRITE_1              0x02
1271 #define EE_DATA_READ    0x01    /* EEPROM chip data out. */
1272 #define EE_ENB                  (0x80 | EE_CS)
1273
1274 /* Delay between EEPROM clock transitions.
1275    No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
1276  */
1277
1278 #define eeprom_delay()  readl(ee_addr)
1279
1280 /* The EEPROM commands include the alway-set leading bit. */
1281 #define EE_WRITE_CMD    (5)
1282 #define EE_READ_CMD             (6)
1283 #define EE_ERASE_CMD    (7)
1284
1285 static int __devinit read_eeprom (void *ioaddr, int location, int addr_len)
1286 {
1287         int i;
1288         unsigned retval = 0;
1289         void *ee_addr = ioaddr + Cfg9346;
1290         int read_cmd = location | (EE_READ_CMD << addr_len);
1291
1292         writeb (EE_ENB & ~EE_CS, ee_addr);
1293         writeb (EE_ENB, ee_addr);
1294         eeprom_delay ();
1295
1296         /* Shift the read command bits out. */
1297         for (i = 4 + addr_len; i >= 0; i--) {
1298                 int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
1299                 writeb (EE_ENB | dataval, ee_addr);
1300                 eeprom_delay ();
1301                 writeb (EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
1302                 eeprom_delay ();
1303         }
1304         writeb (EE_ENB, ee_addr);
1305         eeprom_delay ();
1306
1307         for (i = 16; i > 0; i--) {
1308                 writeb (EE_ENB | EE_SHIFT_CLK, ee_addr);
1309                 eeprom_delay ();
1310                 retval =
1311                     (retval << 1) | ((readb (ee_addr) & EE_DATA_READ) ? 1 :
1312                                      0);
1313                 writeb (EE_ENB, ee_addr);
1314                 eeprom_delay ();
1315         }
1316
1317         /* Terminate the EEPROM access. */
1318         writeb (~EE_CS, ee_addr);
1319         eeprom_delay ();
1320
1321         return retval;
1322 }
1323
1324 static int __devinit cp_init_one (struct pci_dev *pdev,
1325                                   const struct pci_device_id *ent)
1326 {
1327         struct net_device *dev;
1328         struct cp_private *cp;
1329         int rc;
1330         void *regs;
1331         long pciaddr;
1332         unsigned addr_len, i;
1333         u8 pci_rev, cache_size;
1334         u16 pci_command;
1335
1336 #ifndef MODULE
1337         static int version_printed;
1338         if (version_printed++ == 0)
1339                 printk("%s", version);
1340 #endif
1341
1342         pci_read_config_byte(pdev, PCI_REVISION_ID, &pci_rev);
1343
1344         if (pdev->vendor == PCI_VENDOR_ID_REALTEK &&
1345             pdev->device == PCI_DEVICE_ID_REALTEK_8139 && pci_rev < 0x20) {
1346                 printk(KERN_ERR PFX "pci dev %s (id %04x:%04x rev %02x) is not an 8139C+ compatible chip\n",
1347                        pdev->slot_name, pdev->vendor, pdev->device, pci_rev);
1348                 printk(KERN_ERR PFX "Try the \"8139too\" driver instead.\n");
1349                 return -ENODEV;
1350         }
1351
1352         dev = alloc_etherdev(sizeof(struct cp_private));
1353         if (!dev)
1354                 return -ENOMEM;
1355         SET_MODULE_OWNER(dev);
1356         cp = dev->priv;
1357         cp->pdev = pdev;
1358         cp->dev = dev;
1359         cp->msg_enable = (debug < 0 ? CP_DEF_MSG_ENABLE : debug);
1360         spin_lock_init (&cp->lock);
1361         cp->mii_if.dev = dev;
1362         cp->mii_if.mdio_read = mdio_read;
1363         cp->mii_if.mdio_write = mdio_write;
1364         cp->mii_if.phy_id = CP_INTERNAL_PHY;
1365         cp_set_rxbufsize(cp);
1366
1367         rc = pci_enable_device(pdev);
1368         if (rc)
1369                 goto err_out_free;
1370
1371         rc = pci_request_regions(pdev, DRV_NAME);
1372         if (rc)
1373                 goto err_out_disable;
1374
1375         if (pdev->irq < 2) {
1376                 rc = -EIO;
1377                 printk(KERN_ERR PFX "invalid irq (%d) for pci dev %s\n",
1378                        pdev->irq, pdev->slot_name);
1379                 goto err_out_res;
1380         }
1381         pciaddr = pci_resource_start(pdev, 1);
1382         if (!pciaddr) {
1383                 rc = -EIO;
1384                 printk(KERN_ERR PFX "no MMIO resource for pci dev %s\n",
1385                        pdev->slot_name);
1386                 goto err_out_res;
1387         }
1388         if (pci_resource_len(pdev, 1) < CP_REGS_SIZE) {
1389                 rc = -EIO;
1390                 printk(KERN_ERR PFX "MMIO resource (%lx) too small on pci dev %s\n",
1391                        pci_resource_len(pdev, 1), pdev->slot_name);
1392                 goto err_out_res;
1393         }
1394
1395         regs = ioremap_nocache(pciaddr, CP_REGS_SIZE);
1396         if (!regs) {
1397                 rc = -EIO;
1398                 printk(KERN_ERR PFX "Cannot map PCI MMIO (%lx@%lx) on pci dev %s\n",
1399                        pci_resource_len(pdev, 1), pciaddr, pdev->slot_name);
1400                 goto err_out_res;
1401         }
1402         dev->base_addr = (unsigned long) regs;
1403         cp->regs = regs;
1404
1405         cp_stop_hw(cp);
1406
1407         /* read MAC address from EEPROM */
1408         addr_len = read_eeprom (regs, 0, 8) == 0x8129 ? 8 : 6;
1409         for (i = 0; i < 3; i++)
1410                 ((u16 *) (dev->dev_addr))[i] =
1411                     le16_to_cpu (read_eeprom (regs, i + 7, addr_len));
1412
1413         dev->open = cp_open;
1414         dev->stop = cp_close;
1415         dev->set_multicast_list = cp_set_rx_mode;
1416         dev->hard_start_xmit = cp_start_xmit;
1417         dev->get_stats = cp_get_stats;
1418         dev->do_ioctl = cp_ioctl;
1419         dev->change_mtu = cp_change_mtu;
1420 #if 0
1421         dev->tx_timeout = cp_tx_timeout;
1422         dev->watchdog_timeo = TX_TIMEOUT;
1423 #endif
1424 #ifdef CP_TX_CHECKSUM
1425         dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
1426 #endif
1427 #if CP_VLAN_TAG_USED
1428         dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
1429         dev->vlan_rx_register = cp_vlan_rx_register;
1430         dev->vlan_rx_kill_vid = cp_vlan_rx_kill_vid;
1431 #endif
1432
1433         dev->irq = pdev->irq;
1434
1435         rc = register_netdev(dev);
1436         if (rc)
1437                 goto err_out_iomap;
1438
1439         printk (KERN_INFO "%s: %s at 0x%lx, "
1440                 "%02x:%02x:%02x:%02x:%02x:%02x, "
1441                 "IRQ %d\n",
1442                 dev->name,
1443                 "RTL-8139C+",
1444                 dev->base_addr,
1445                 dev->dev_addr[0], dev->dev_addr[1],
1446                 dev->dev_addr[2], dev->dev_addr[3],
1447                 dev->dev_addr[4], dev->dev_addr[5],
1448                 dev->irq);
1449
1450         pci_set_drvdata(pdev, dev);
1451
1452         /*
1453          * Looks like this is necessary to deal with on all architectures,
1454          * even this %$#%$# N440BX Intel based thing doesn't get it right.
1455          * Ie. having two NICs in the machine, one will have the cache
1456          * line set at boot time, the other will not.
1457          */
1458         pci_read_config_byte(pdev, PCI_CACHE_LINE_SIZE, &cache_size);
1459         cache_size <<= 2;
1460         if (cache_size != SMP_CACHE_BYTES) {
1461                 printk(KERN_INFO "%s: PCI cache line size set incorrectly "
1462                        "(%i bytes) by BIOS/FW, ", dev->name, cache_size);
1463                 if (cache_size > SMP_CACHE_BYTES)
1464                         printk("expecting %i\n", SMP_CACHE_BYTES);
1465                 else {
1466                         printk("correcting to %i\n", SMP_CACHE_BYTES);
1467                         pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
1468                                               SMP_CACHE_BYTES >> 2);
1469                 }
1470         }
1471
1472         /* enable busmastering and memory-write-invalidate */
1473         pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
1474         if (!(pci_command & PCI_COMMAND_INVALIDATE)) {
1475                 pci_command |= PCI_COMMAND_INVALIDATE;
1476                 pci_write_config_word(pdev, PCI_COMMAND, pci_command);
1477         }
1478         pci_set_master(pdev);
1479
1480         return 0;
1481
1482 err_out_iomap:
1483         iounmap(regs);
1484 err_out_res:
1485         pci_release_regions(pdev);
1486 err_out_disable:
1487         pci_disable_device(pdev);
1488 err_out_free:
1489         kfree(dev);
1490         return rc;
1491 }
1492
1493 static void __devexit cp_remove_one (struct pci_dev *pdev)
1494 {
1495         struct net_device *dev = pci_get_drvdata(pdev);
1496         struct cp_private *cp = dev->priv;
1497
1498         if (!dev)
1499                 BUG();
1500         unregister_netdev(dev);
1501         iounmap(cp->regs);
1502         pci_release_regions(pdev);
1503         pci_disable_device(pdev);
1504         pci_set_drvdata(pdev, NULL);
1505         kfree(dev);
1506 }
1507
1508 static struct pci_driver cp_driver = {
1509         name:           DRV_NAME,
1510         id_table:       cp_pci_tbl,
1511         probe:          cp_init_one,
1512         remove:         __devexit_p(cp_remove_one),
1513 };
1514
1515 static int __init cp_init (void)
1516 {
1517 #ifdef MODULE
1518         printk("%s", version);
1519 #endif
1520         return pci_module_init (&cp_driver);
1521 }
1522
1523 static void __exit cp_exit (void)
1524 {
1525         pci_unregister_driver (&cp_driver);
1526 }
1527
1528 module_init(cp_init);
1529 module_exit(cp_exit);