drivers/net/via-rhine.c

   1 /* via-rhine.c: A Linux Ethernet device driver for VIA Rhine family chips. */
   2 /*
   3         Written 1998-2001 by Donald Becker.
   4
   5         Current Maintainer: Roger Luethi <rl@hellgate.ch>
   6
   7         This software may be used and distributed according to the terms of
   8         the GNU General Public License (GPL), incorporated herein by reference.
   9         Drivers based on or derived from this code fall under the GPL and must
  10         retain the authorship, copyright and license notice.  This file is not
  11         a complete program and may only be used when the entire operating
  12         system is licensed under the GPL.
  13
  14         This driver is designed for the VIA VT86C100A Rhine-I.
  15         It also works with the Rhine-II (6102) and Rhine-III (6105/6105L/6105LOM
  16         and management NIC 6105M).
  17
  18         The author may be reached as becker@scyld.com, or C/O
  19         Scyld Computing Corporation
  20         410 Severn Ave., Suite 210
  21         Annapolis MD 21403
  22
  23
  24         This driver contains some changes from the original Donald Becker
  25         version. He may or may not be interested in bug reports on this
  26         code. You can find his versions at:
  27         http://www.scyld.com/network/via-rhine.html
  28         [link no longer provides useful info -jgarzik]
  29
  30 */
  31
  32 #define DRV_NAME        "via-rhine"
  33 #define DRV_VERSION     "1.4.3"
  34 #define DRV_RELDATE     "2007-03-06"
  35
  36
  37 /* A few user-configurable values.
  38    These may be modified when a driver module is loaded. */
  39
  40 static int debug = 1;   /* 1 normal messages, 0 quiet .. 7 verbose. */
  41 static int max_interrupt_work = 20;
  42
  43 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
  44    Setting to > 1518 effectively disables this feature. */
  45 static int rx_copybreak;
  46
  47 /* Work-around for broken BIOSes: they are unable to get the chip back out of
  48    power state D3 so PXE booting fails. bootparam(7): via-rhine.avoid_D3=1 */
  49 static int avoid_D3;
  50
  51 /*
  52  * In case you are looking for 'options[]' or 'full_duplex[]', they
  53  * are gone. Use ethtool(8) instead.
  54  */
  55
  56 /* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
  57    The Rhine has a 64 element 8390-like hash table. */
  58 static const int multicast_filter_limit = 32;
  59
  60
  61 /* Operational parameters that are set at compile time. */
  62
  63 /* Keep the ring sizes a power of two for compile efficiency.
  64    The compiler will convert <unsigned>'%'<2^N> into a bit mask.
  65    Making the Tx ring too large decreases the effectiveness of channel
  66    bonding and packet priority.
  67    There are no ill effects from too-large receive rings. */
  68 #define TX_RING_SIZE    16
  69 #define TX_QUEUE_LEN    10      /* Limit ring entries actually used. */
  70 #ifdef CONFIG_VIA_RHINE_NAPI
  71 #define RX_RING_SIZE    64
  72 #else
  73 #define RX_RING_SIZE    16
  74 #endif
  75
  76
  77 /* Operational parameters that usually are not changed. */
  78
  79 /* Time in jiffies before concluding the transmitter is hung. */
  80 #define TX_TIMEOUT      (2*HZ)
  81
  82 #define PKT_BUF_SZ      1536    /* Size of each temporary Rx buffer.*/
  83
  84 #include <linux/module.h>
  85 #include <linux/moduleparam.h>
  86 #include <linux/kernel.h>
  87 #include <linux/string.h>
  88 #include <linux/timer.h>
  89 #include <linux/errno.h>
  90 #include <linux/ioport.h>
  91 #include <linux/slab.h>
  92 #include <linux/interrupt.h>
  93 #include <linux/pci.h>
  94 #include <linux/dma-mapping.h>
  95 #include <linux/netdevice.h>
  96 #include <linux/etherdevice.h>
  97 #include <linux/skbuff.h>
  98 #include <linux/init.h>
  99 #include <linux/delay.h>
 100 #include <linux/mii.h>
 101 #include <linux/ethtool.h>
 102 #include <linux/crc32.h>
 103 #include <linux/bitops.h>
 104 #include <asm/processor.h>      /* Processor type for cache alignment. */
 105 #include <asm/io.h>
 106 #include <asm/irq.h>
 107 #include <asm/uaccess.h>
 108 #include <linux/dmi.h>
 109
 110 /* These identify the driver base version and may not be removed. */
 111 static char version[] __devinitdata =
 112 KERN_INFO DRV_NAME ".c:v1.10-LK" DRV_VERSION " " DRV_RELDATE " Written by Donald Becker\n";
 113
 114 /* This driver was written to use PCI memory space. Some early versions
 115    of the Rhine may only work correctly with I/O space accesses. */
 116 #ifdef CONFIG_VIA_RHINE_MMIO
 117 #define USE_MMIO
 118 #else
 119 #endif
 120
 121 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
 122 MODULE_DESCRIPTION("VIA Rhine PCI Fast Ethernet driver");
 123 MODULE_LICENSE("GPL");
 124
 125 module_param(max_interrupt_work, int, 0);
 126 module_param(debug, int, 0);
 127 module_param(rx_copybreak, int, 0);
 128 module_param(avoid_D3, bool, 0);
 129 MODULE_PARM_DESC(max_interrupt_work, "VIA Rhine maximum events handled per interrupt");
 130 MODULE_PARM_DESC(debug, "VIA Rhine debug level (0-7)");
 131 MODULE_PARM_DESC(rx_copybreak, "VIA Rhine copy breakpoint for copy-only-tiny-frames");
 132 MODULE_PARM_DESC(avoid_D3, "Avoid power state D3 (work-around for broken BIOSes)");
 133
 134 /*
 135                 Theory of Operation
 136
 137 I. Board Compatibility
 138
 139 This driver is designed for the VIA 86c100A Rhine-II PCI Fast Ethernet
 140 controller.
 141
 142 II. Board-specific settings
 143
 144 Boards with this chip are functional only in a bus-master PCI slot.
 145
 146 Many operational settings are loaded from the EEPROM to the Config word at
 147 offset 0x78. For most of these settings, this driver assumes that they are
 148 correct.
 149 If this driver is compiled to use PCI memory space operations the EEPROM
 150 must be configured to enable memory ops.
 151
 152 III. Driver operation
 153
 154 IIIa. Ring buffers
 155
 156 This driver uses two statically allocated fixed-size descriptor lists
 157 formed into rings by a branch from the final descriptor to the beginning of
 158 the list. The ring sizes are set at compile time by RX/TX_RING_SIZE.
 159
 160 IIIb/c. Transmit/Receive Structure
 161
 162 This driver attempts to use a zero-copy receive and transmit scheme.
 163
 164 Alas, all data buffers are required to start on a 32 bit boundary, so
 165 the driver must often copy transmit packets into bounce buffers.
 166
 167 The driver allocates full frame size skbuffs for the Rx ring buffers at
 168 open() time and passes the skb->data field to the chip as receive data
 169 buffers. When an incoming frame is less than RX_COPYBREAK bytes long,
 170 a fresh skbuff is allocated and the frame is copied to the new skbuff.
 171 When the incoming frame is larger, the skbuff is passed directly up the
 172 protocol stack. Buffers consumed this way are replaced by newly allocated
 173 skbuffs in the last phase of rhine_rx().
 174
 175 The RX_COPYBREAK value is chosen to trade-off the memory wasted by
 176 using a full-sized skbuff for small frames vs. the copying costs of larger
 177 frames. New boards are typically used in generously configured machines
 178 and the underfilled buffers have negligible impact compared to the benefit of
 179 a single allocation size, so the default value of zero results in never
 180 copying packets. When copying is done, the cost is usually mitigated by using
 181 a combined copy/checksum routine. Copying also preloads the cache, which is
 182 most useful with small frames.
 183
 184 Since the VIA chips are only able to transfer data to buffers on 32 bit
 185 boundaries, the IP header at offset 14 in an ethernet frame isn't
 186 longword aligned for further processing. Copying these unaligned buffers
 187 has the beneficial effect of 16-byte aligning the IP header.
 188
 189 IIId. Synchronization
 190
 191 The driver runs as two independent, single-threaded flows of control. One
 192 is the send-packet routine, which enforces single-threaded use by the
 193 dev->priv->lock spinlock. The other thread is the interrupt handler, which
 194 is single threaded by the hardware and interrupt handling software.
 195
 196 The send packet thread has partial control over the Tx ring. It locks the
 197 dev->priv->lock whenever it's queuing a Tx packet. If the next slot in the ring
 198 is not available it stops the transmit queue by calling netif_stop_queue.
 199
 200 The interrupt handler has exclusive control over the Rx ring and records stats
 201 from the Tx ring. After reaping the stats, it marks the Tx queue entry as
 202 empty by incrementing the dirty_tx mark. If at least half of the entries in
 203 the Rx ring are available the transmit queue is woken up if it was stopped.
 204
 205 IV. Notes
 206
 207 IVb. References
 208
 209 Preliminary VT86C100A manual from http://www.via.com.tw/
 210 http://www.scyld.com/expert/100mbps.html
 211 http://www.scyld.com/expert/NWay.html
 212 ftp://ftp.via.com.tw/public/lan/Products/NIC/VT86C100A/Datasheet/VT86C100A03.pdf
 213 ftp://ftp.via.com.tw/public/lan/Products/NIC/VT6102/Datasheet/VT6102_021.PDF
 214
 215
 216 IVc. Errata
 217
 218 The VT86C100A manual is not reliable information.
 219 The 3043 chip does not handle unaligned transmit or receive buffers, resulting
 220 in significant performance degradation for bounce buffer copies on transmit
 221 and unaligned IP headers on receive.
 222 The chip does not pad to minimum transmit length.
 223
 224 */
 225
 226
 227 /* This table drives the PCI probe routines. It's mostly boilerplate in all
 228    of the drivers, and will likely be provided by some future kernel.
 229    Note the matching code -- the first table entry matchs all 56** cards but
 230    second only the 1234 card.
 231 */
 232
 233 enum rhine_revs {
 234         VT86C100A       = 0x00,
 235         VTunknown0      = 0x20,
 236         VT6102          = 0x40,
 237         VT8231          = 0x50, /* Integrated MAC */
 238         VT8233          = 0x60, /* Integrated MAC */
 239         VT8235          = 0x74, /* Integrated MAC */
 240         VT8237          = 0x78, /* Integrated MAC */
 241         VTunknown1      = 0x7C,
 242         VT6105          = 0x80,
 243         VT6105_B0       = 0x83,
 244         VT6105L         = 0x8A,
 245         VT6107          = 0x8C,
 246         VTunknown2      = 0x8E,
 247         VT6105M         = 0x90, /* Management adapter */
 248 };
 249
 250 enum rhine_quirks {
 251         rqWOL           = 0x0001,       /* Wake-On-LAN support */
 252         rqForceReset    = 0x0002,
 253         rq6patterns     = 0x0040,       /* 6 instead of 4 patterns for WOL */
 254         rqStatusWBRace  = 0x0080,       /* Tx Status Writeback Error possible */
 255         rqRhineI        = 0x0100,       /* See comment below */
 256 };
 257 /*
 258  * rqRhineI: VT86C100A (aka Rhine-I) uses different bits to enable
 259  * MMIO as well as for the collision counter and the Tx FIFO underflow
 260  * indicator. In addition, Tx and Rx buffers need to 4 byte aligned.
 261  */
 262
 263 /* Beware of PCI posted writes */
 264 #define IOSYNC  do { ioread8(ioaddr + StationAddr); } while (0)
 265
 266 static const struct pci_device_id rhine_pci_tbl[] = {
 267         { 0x1106, 0x3043, PCI_ANY_ID, PCI_ANY_ID, },    /* VT86C100A */
 268         { 0x1106, 0x3065, PCI_ANY_ID, PCI_ANY_ID, },    /* VT6102 */
 269         { 0x1106, 0x3106, PCI_ANY_ID, PCI_ANY_ID, },    /* 6105{,L,LOM} */
 270         { 0x1106, 0x3053, PCI_ANY_ID, PCI_ANY_ID, },    /* VT6105M */
 271         { }     /* terminate list */
 272 };
 273 MODULE_DEVICE_TABLE(pci, rhine_pci_tbl);
 274
 275
 276 /* Offsets to the device registers. */
 277 enum register_offsets {
 278         StationAddr=0x00, RxConfig=0x06, TxConfig=0x07, ChipCmd=0x08,
 279         ChipCmd1=0x09,
 280         IntrStatus=0x0C, IntrEnable=0x0E,
 281         MulticastFilter0=0x10, MulticastFilter1=0x14,
 282         RxRingPtr=0x18, TxRingPtr=0x1C, GFIFOTest=0x54,
 283         MIIPhyAddr=0x6C, MIIStatus=0x6D, PCIBusConfig=0x6E,
 284         MIICmd=0x70, MIIRegAddr=0x71, MIIData=0x72, MACRegEEcsr=0x74,
 285         ConfigA=0x78, ConfigB=0x79, ConfigC=0x7A, ConfigD=0x7B,
 286         RxMissed=0x7C, RxCRCErrs=0x7E, MiscCmd=0x81,
 287         StickyHW=0x83, IntrStatus2=0x84,
 288         WOLcrSet=0xA0, PwcfgSet=0xA1, WOLcgSet=0xA3, WOLcrClr=0xA4,
 289         WOLcrClr1=0xA6, WOLcgClr=0xA7,
 290         PwrcsrSet=0xA8, PwrcsrSet1=0xA9, PwrcsrClr=0xAC, PwrcsrClr1=0xAD,
 291 };
 292
 293 /* Bits in ConfigD */
 294 enum backoff_bits {
 295         BackOptional=0x01, BackModify=0x02,
 296         BackCaptureEffect=0x04, BackRandom=0x08
 297 };
 298
 299 #ifdef USE_MMIO
 300 /* Registers we check that mmio and reg are the same. */
 301 static const int mmio_verify_registers[] = {
 302         RxConfig, TxConfig, IntrEnable, ConfigA, ConfigB, ConfigC, ConfigD,
 303         0
 304 };
 305 #endif
 306
 307 /* Bits in the interrupt status/mask registers. */
 308 enum intr_status_bits {
 309         IntrRxDone=0x0001, IntrRxErr=0x0004, IntrRxEmpty=0x0020,
 310         IntrTxDone=0x0002, IntrTxError=0x0008, IntrTxUnderrun=0x0210,
 311         IntrPCIErr=0x0040,
 312         IntrStatsMax=0x0080, IntrRxEarly=0x0100,
 313         IntrRxOverflow=0x0400, IntrRxDropped=0x0800, IntrRxNoBuf=0x1000,
 314         IntrTxAborted=0x2000, IntrLinkChange=0x4000,
 315         IntrRxWakeUp=0x8000,
 316         IntrNormalSummary=0x0003, IntrAbnormalSummary=0xC260,
 317         IntrTxDescRace=0x080000,        /* mapped from IntrStatus2 */
 318         IntrTxErrSummary=0x082218,
 319 };
 320
 321 /* Bits in WOLcrSet/WOLcrClr and PwrcsrSet/PwrcsrClr */
 322 enum wol_bits {
 323         WOLucast        = 0x10,
 324         WOLmagic        = 0x20,
 325         WOLbmcast       = 0x30,
 326         WOLlnkon        = 0x40,
 327         WOLlnkoff       = 0x80,
 328 };
 329
 330 /* The Rx and Tx buffer descriptors. */
 331 struct rx_desc {
 332         s32 rx_status;
 333         u32 desc_length; /* Chain flag, Buffer/frame length */
 334         u32 addr;
 335         u32 next_desc;
 336 };
 337 struct tx_desc {
 338         s32 tx_status;
 339         u32 desc_length; /* Chain flag, Tx Config, Frame length */
 340         u32 addr;
 341         u32 next_desc;
 342 };
 343
 344 /* Initial value for tx_desc.desc_length, Buffer size goes to bits 0-10 */
 345 #define TXDESC          0x00e08000
 346
 347 enum rx_status_bits {
 348         RxOK=0x8000, RxWholePkt=0x0300, RxErr=0x008F
 349 };
 350
 351 /* Bits in *_desc.*_status */
 352 enum desc_status_bits {
 353         DescOwn=0x80000000
 354 };
 355
 356 /* Bits in ChipCmd. */
 357 enum chip_cmd_bits {
 358         CmdInit=0x01, CmdStart=0x02, CmdStop=0x04, CmdRxOn=0x08,
 359         CmdTxOn=0x10, Cmd1TxDemand=0x20, CmdRxDemand=0x40,
 360         Cmd1EarlyRx=0x01, Cmd1EarlyTx=0x02, Cmd1FDuplex=0x04,
 361         Cmd1NoTxPoll=0x08, Cmd1Reset=0x80,
 362 };
 363
 364 struct rhine_private {
 365         /* Descriptor rings */
 366         struct rx_desc *rx_ring;
 367         struct tx_desc *tx_ring;
 368         dma_addr_t rx_ring_dma;
 369         dma_addr_t tx_ring_dma;
 370
 371         /* The addresses of receive-in-place skbuffs. */
 372         struct sk_buff *rx_skbuff[RX_RING_SIZE];
 373         dma_addr_t rx_skbuff_dma[RX_RING_SIZE];
 374
 375         /* The saved address of a sent-in-place packet/buffer, for later free(). */
 376         struct sk_buff *tx_skbuff[TX_RING_SIZE];
 377         dma_addr_t tx_skbuff_dma[TX_RING_SIZE];
 378
 379         /* Tx bounce buffers (Rhine-I only) */
 380         unsigned char *tx_buf[TX_RING_SIZE];
 381         unsigned char *tx_bufs;
 382         dma_addr_t tx_bufs_dma;
 383
 384         struct pci_dev *pdev;
 385         long pioaddr;
 386         struct net_device_stats stats;
 387         spinlock_t lock;
 388
 389         /* Frequently used values: keep some adjacent for cache effect. */
 390         u32 quirks;
 391         struct rx_desc *rx_head_desc;
 392         unsigned int cur_rx, dirty_rx;  /* Producer/consumer ring indices */
 393         unsigned int cur_tx, dirty_tx;
 394         unsigned int rx_buf_sz;         /* Based on MTU+slack. */
 395         u8 wolopts;
 396
 397         u8 tx_thresh, rx_thresh;
 398
 399         struct mii_if_info mii_if;
 400         void __iomem *base;
 401 };
 402
 403 static int  mdio_read(struct net_device *dev, int phy_id, int location);
 404 static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
 405 static int  rhine_open(struct net_device *dev);
 406 static void rhine_tx_timeout(struct net_device *dev);
 407 static int  rhine_start_tx(struct sk_buff *skb, struct net_device *dev);
 408 static irqreturn_t rhine_interrupt(int irq, void *dev_instance);
 409 static void rhine_tx(struct net_device *dev);
 410 static int rhine_rx(struct net_device *dev, int limit);
 411 static void rhine_error(struct net_device *dev, int intr_status);
 412 static void rhine_set_rx_mode(struct net_device *dev);
 413 static struct net_device_stats *rhine_get_stats(struct net_device *dev);
 414 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 415 static const struct ethtool_ops netdev_ethtool_ops;
 416 static int  rhine_close(struct net_device *dev);
 417 static void rhine_shutdown (struct pci_dev *pdev);
 418
 419 #define RHINE_WAIT_FOR(condition) do {                                  \
 420         int i=1024;                                                     \
 421         while (!(condition) && --i)                                     \
 422                 ;                                                       \
 423         if (debug > 1 && i < 512)                                       \
 424                 printk(KERN_INFO "%s: %4d cycles used @ %s:%d\n",       \
 425                                 DRV_NAME, 1024-i, __func__, __LINE__);  \
 426 } while(0)
 427
 428 static inline u32 get_intr_status(struct net_device *dev)
 429 {
 430         struct rhine_private *rp = netdev_priv(dev);
 431         void __iomem *ioaddr = rp->base;
 432         u32 intr_status;
 433
 434         intr_status = ioread16(ioaddr + IntrStatus);
 435         /* On Rhine-II, Bit 3 indicates Tx descriptor write-back race. */
 436         if (rp->quirks & rqStatusWBRace)
 437                 intr_status |= ioread8(ioaddr + IntrStatus2) << 16;
 438         return intr_status;
 439 }
 440
 441 /*
 442  * Get power related registers into sane state.
 443  * Notify user about past WOL event.
 444  */
 445 static void rhine_power_init(struct net_device *dev)
 446 {
 447         struct rhine_private *rp = netdev_priv(dev);
 448         void __iomem *ioaddr = rp->base;
 449         u16 wolstat;
 450
 451         if (rp->quirks & rqWOL) {
 452                 /* Make sure chip is in power state D0 */
 453                 iowrite8(ioread8(ioaddr + StickyHW) & 0xFC, ioaddr + StickyHW);
 454
 455                 /* Disable "force PME-enable" */
 456                 iowrite8(0x80, ioaddr + WOLcgClr);
 457
 458                 /* Clear power-event config bits (WOL) */
 459                 iowrite8(0xFF, ioaddr + WOLcrClr);
 460                 /* More recent cards can manage two additional patterns */
 461                 if (rp->quirks & rq6patterns)
 462                         iowrite8(0x03, ioaddr + WOLcrClr1);
 463
 464                 /* Save power-event status bits */
 465                 wolstat = ioread8(ioaddr + PwrcsrSet);
 466                 if (rp->quirks & rq6patterns)
 467                         wolstat |= (ioread8(ioaddr + PwrcsrSet1) & 0x03) << 8;
 468
 469                 /* Clear power-event status bits */
 470                 iowrite8(0xFF, ioaddr + PwrcsrClr);
 471                 if (rp->quirks & rq6patterns)
 472                         iowrite8(0x03, ioaddr + PwrcsrClr1);
 473
 474                 if (wolstat) {
 475                         char *reason;
 476                         switch (wolstat) {
 477                         case WOLmagic:
 478                                 reason = "Magic packet";
 479                                 break;
 480                         case WOLlnkon:
 481                                 reason = "Link went up";
 482                                 break;
 483                         case WOLlnkoff:
 484                                 reason = "Link went down";
 485                                 break;
 486                         case WOLucast:
 487                                 reason = "Unicast packet";
 488                                 break;
 489                         case WOLbmcast:
 490                                 reason = "Multicast/broadcast packet";
 491                                 break;
 492                         default:
 493                                 reason = "Unknown";
 494                         }
 495                         printk(KERN_INFO "%s: Woke system up. Reason: %s.\n",
 496                                DRV_NAME, reason);
 497                 }
 498         }
 499 }
 500
 501 static void rhine_chip_reset(struct net_device *dev)
 502 {
 503         struct rhine_private *rp = netdev_priv(dev);
 504         void __iomem *ioaddr = rp->base;
 505
 506         iowrite8(Cmd1Reset, ioaddr + ChipCmd1);
 507         IOSYNC;
 508
 509         if (ioread8(ioaddr + ChipCmd1) & Cmd1Reset) {
 510                 printk(KERN_INFO "%s: Reset not complete yet. "
 511                         "Trying harder.\n", DRV_NAME);
 512
 513                 /* Force reset */
 514                 if (rp->quirks & rqForceReset)
 515                         iowrite8(0x40, ioaddr + MiscCmd);
 516
 517                 /* Reset can take somewhat longer (rare) */
 518                 RHINE_WAIT_FOR(!(ioread8(ioaddr + ChipCmd1) & Cmd1Reset));
 519         }
 520
 521         if (debug > 1)
 522                 printk(KERN_INFO "%s: Reset %s.\n", dev->name,
 523                         (ioread8(ioaddr + ChipCmd1) & Cmd1Reset) ?
 524                         "failed" : "succeeded");
 525 }
 526
 527 #ifdef USE_MMIO
 528 static void enable_mmio(long pioaddr, u32 quirks)
 529 {
 530         int n;
 531         if (quirks & rqRhineI) {
 532                 /* More recent docs say that this bit is reserved ... */
 533                 n = inb(pioaddr + ConfigA) | 0x20;
 534                 outb(n, pioaddr + ConfigA);
 535         } else {
 536                 n = inb(pioaddr + ConfigD) | 0x80;
 537                 outb(n, pioaddr + ConfigD);
 538         }
 539 }
 540 #endif
 541
 542 /*
 543  * Loads bytes 0x00-0x05, 0x6E-0x6F, 0x78-0x7B from EEPROM
 544  * (plus 0x6C for Rhine-I/II)
 545  */
 546 static void __devinit rhine_reload_eeprom(long pioaddr, struct net_device *dev)
 547 {
 548         struct rhine_private *rp = netdev_priv(dev);
 549         void __iomem *ioaddr = rp->base;
 550
 551         outb(0x20, pioaddr + MACRegEEcsr);
 552         RHINE_WAIT_FOR(!(inb(pioaddr + MACRegEEcsr) & 0x20));
 553
 554 #ifdef USE_MMIO
 555         /*
 556          * Reloading from EEPROM overwrites ConfigA-D, so we must re-enable
 557          * MMIO. If reloading EEPROM was done first this could be avoided, but
 558          * it is not known if that still works with the "win98-reboot" problem.
 559          */
 560         enable_mmio(pioaddr, rp->quirks);
 561 #endif
 562
 563         /* Turn off EEPROM-controlled wake-up (magic packet) */
 564         if (rp->quirks & rqWOL)
 565                 iowrite8(ioread8(ioaddr + ConfigA) & 0xFC, ioaddr + ConfigA);
 566
 567 }
 568
 569 #ifdef CONFIG_NET_POLL_CONTROLLER
 570 static void rhine_poll(struct net_device *dev)
 571 {
 572         disable_irq(dev->irq);
 573         rhine_interrupt(dev->irq, (void *)dev);
 574         enable_irq(dev->irq);
 575 }
 576 #endif
 577
 578 #ifdef CONFIG_VIA_RHINE_NAPI
 579 static int rhine_napipoll(struct net_device *dev, int *budget)
 580 {
 581         struct rhine_private *rp = netdev_priv(dev);
 582         void __iomem *ioaddr = rp->base;
 583         int done, limit = min(dev->quota, *budget);
 584
 585         done = rhine_rx(dev, limit);
 586         *budget -= done;
 587         dev->quota -= done;
 588
 589         if (done < limit) {
 590                 netif_rx_complete(dev);
 591
 592                 iowrite16(IntrRxDone | IntrRxErr | IntrRxEmpty| IntrRxOverflow |
 593                           IntrRxDropped | IntrRxNoBuf | IntrTxAborted |
 594                           IntrTxDone | IntrTxError | IntrTxUnderrun |
 595                           IntrPCIErr | IntrStatsMax | IntrLinkChange,
 596                           ioaddr + IntrEnable);
 597                 return 0;
 598         }
 599         else
 600                 return 1;
 601 }
 602 #endif
 603
 604 static void rhine_hw_init(struct net_device *dev, long pioaddr)
 605 {
 606         struct rhine_private *rp = netdev_priv(dev);
 607
 608         /* Reset the chip to erase previous misconfiguration. */
 609         rhine_chip_reset(dev);
 610
 611         /* Rhine-I needs extra time to recuperate before EEPROM reload */
 612         if (rp->quirks & rqRhineI)
 613                 msleep(5);
 614
 615         /* Reload EEPROM controlled bytes cleared by soft reset */
 616         rhine_reload_eeprom(pioaddr, dev);
 617 }
 618
 619 static int __devinit rhine_init_one(struct pci_dev *pdev,
 620                                     const struct pci_device_id *ent)
 621 {
 622         struct net_device *dev;
 623         struct rhine_private *rp;
 624         int i, rc;
 625         u32 quirks;
 626         long pioaddr;
 627         long memaddr;
 628         void __iomem *ioaddr;
 629         int io_size, phy_id;
 630         const char *name;
 631 #ifdef USE_MMIO
 632         int bar = 1;
 633 #else
 634         int bar = 0;
 635 #endif
 636
 637 /* when built into the kernel, we only print version if device is found */
 638 #ifndef MODULE
 639         static int printed_version;
 640         if (!printed_version++)
 641                 printk(version);
 642 #endif
 643
 644         io_size = 256;
 645         phy_id = 0;
 646         quirks = 0;
 647         name = "Rhine";
 648         if (pdev->revision < VTunknown0) {
 649                 quirks = rqRhineI;
 650                 io_size = 128;
 651         }
 652         else if (pdev->revision >= VT6102) {
 653                 quirks = rqWOL | rqForceReset;
 654                 if (pdev->revision < VT6105) {
 655                         name = "Rhine II";
 656                         quirks |= rqStatusWBRace;       /* Rhine-II exclusive */
 657                 }
 658                 else {
 659                         phy_id = 1;     /* Integrated PHY, phy_id fixed to 1 */
 660                         if (pdev->revision >= VT6105_B0)
 661                                 quirks |= rq6patterns;
 662                         if (pdev->revision < VT6105M)
 663                                 name = "Rhine III";
 664                         else
 665                                 name = "Rhine III (Management Adapter)";
 666                 }
 667         }
 668
 669         rc = pci_enable_device(pdev);
 670         if (rc)
 671                 goto err_out;
 672
 673         /* this should always be supported */
 674         rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
 675         if (rc) {
 676                 printk(KERN_ERR "32-bit PCI DMA addresses not supported by "
 677                        "the card!?\n");
 678                 goto err_out;
 679         }
 680
 681         /* sanity check */
 682         if ((pci_resource_len(pdev, 0) < io_size) ||
 683             (pci_resource_len(pdev, 1) < io_size)) {
 684                 rc = -EIO;
 685                 printk(KERN_ERR "Insufficient PCI resources, aborting\n");
 686                 goto err_out;
 687         }
 688
 689         pioaddr = pci_resource_start(pdev, 0);
 690         memaddr = pci_resource_start(pdev, 1);
 691
 692         pci_set_master(pdev);
 693
 694         dev = alloc_etherdev(sizeof(struct rhine_private));
 695         if (!dev) {
 696                 rc = -ENOMEM;
 697                 printk(KERN_ERR "alloc_etherdev failed\n");
 698                 goto err_out;
 699         }
 700         SET_MODULE_OWNER(dev);
 701         SET_NETDEV_DEV(dev, &pdev->dev);
 702
 703         rp = netdev_priv(dev);
 704         rp->quirks = quirks;
 705         rp->pioaddr = pioaddr;
 706         rp->pdev = pdev;
 707
 708         rc = pci_request_regions(pdev, DRV_NAME);
 709         if (rc)
 710                 goto err_out_free_netdev;
 711
 712         ioaddr = pci_iomap(pdev, bar, io_size);
 713         if (!ioaddr) {
 714                 rc = -EIO;
 715                 printk(KERN_ERR "ioremap failed for device %s, region 0x%X "
 716                        "@ 0x%lX\n", pci_name(pdev), io_size, memaddr);
 717                 goto err_out_free_res;
 718         }
 719
 720 #ifdef USE_MMIO
 721         enable_mmio(pioaddr, quirks);
 722
 723         /* Check that selected MMIO registers match the PIO ones */
 724         i = 0;
 725         while (mmio_verify_registers[i]) {
 726                 int reg = mmio_verify_registers[i++];
 727                 unsigned char a = inb(pioaddr+reg);
 728                 unsigned char b = readb(ioaddr+reg);
 729                 if (a != b) {
 730                         rc = -EIO;
 731                         printk(KERN_ERR "MMIO do not match PIO [%02x] "
 732                                "(%02x != %02x)\n", reg, a, b);
 733                         goto err_out_unmap;
 734                 }
 735         }
 736 #endif /* USE_MMIO */
 737
 738         dev->base_addr = (unsigned long)ioaddr;
 739         rp->base = ioaddr;
 740
 741         /* Get chip registers into a sane state */
 742         rhine_power_init(dev);
 743         rhine_hw_init(dev, pioaddr);
 744
 745         for (i = 0; i < 6; i++)
 746                 dev->dev_addr[i] = ioread8(ioaddr + StationAddr + i);
 747         memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 748
 749         if (!is_valid_ether_addr(dev->perm_addr)) {
 750                 rc = -EIO;
 751                 printk(KERN_ERR "Invalid MAC address\n");
 752                 goto err_out_unmap;
 753         }
 754
 755         /* For Rhine-I/II, phy_id is loaded from EEPROM */
 756         if (!phy_id)
 757                 phy_id = ioread8(ioaddr + 0x6C);
 758
 759         dev->irq = pdev->irq;
 760
 761         spin_lock_init(&rp->lock);
 762         rp->mii_if.dev = dev;
 763         rp->mii_if.mdio_read = mdio_read;
 764         rp->mii_if.mdio_write = mdio_write;
 765         rp->mii_if.phy_id_mask = 0x1f;
 766         rp->mii_if.reg_num_mask = 0x1f;
 767
 768         /* The chip-specific entries in the device structure. */
 769         dev->open = rhine_open;
 770         dev->hard_start_xmit = rhine_start_tx;
 771         dev->stop = rhine_close;
 772         dev->get_stats = rhine_get_stats;
 773         dev->set_multicast_list = rhine_set_rx_mode;
 774         dev->do_ioctl = netdev_ioctl;
 775         dev->ethtool_ops = &netdev_ethtool_ops;
 776         dev->tx_timeout = rhine_tx_timeout;
 777         dev->watchdog_timeo = TX_TIMEOUT;
 778 #ifdef CONFIG_NET_POLL_CONTROLLER
 779         dev->poll_controller = rhine_poll;
 780 #endif
 781 #ifdef CONFIG_VIA_RHINE_NAPI
 782         dev->poll = rhine_napipoll;
 783         dev->weight = 64;
 784 #endif
 785         if (rp->quirks & rqRhineI)
 786                 dev->features |= NETIF_F_SG|NETIF_F_HW_CSUM;
 787
 788         /* dev->name not defined before register_netdev()! */
 789         rc = register_netdev(dev);
 790         if (rc)
 791                 goto err_out_unmap;
 792
 793         printk(KERN_INFO "%s: VIA %s at 0x%lx, ",
 794                dev->name, name,
 795 #ifdef USE_MMIO
 796                 memaddr
 797 #else
 798                 (long)ioaddr
 799 #endif
 800                  );
 801
 802         for (i = 0; i < 5; i++)
 803                 printk("%2.2x:", dev->dev_addr[i]);
 804         printk("%2.2x, IRQ %d.\n", dev->dev_addr[i], pdev->irq);
 805
 806         pci_set_drvdata(pdev, dev);
 807
 808         {
 809                 u16 mii_cmd;
 810                 int mii_status = mdio_read(dev, phy_id, 1);
 811                 mii_cmd = mdio_read(dev, phy_id, MII_BMCR) & ~BMCR_ISOLATE;
 812                 mdio_write(dev, phy_id, MII_BMCR, mii_cmd);
 813                 if (mii_status != 0xffff && mii_status != 0x0000) {
 814                         rp->mii_if.advertising = mdio_read(dev, phy_id, 4);
 815                         printk(KERN_INFO "%s: MII PHY found at address "
 816                                "%d, status 0x%4.4x advertising %4.4x "
 817                                "Link %4.4x.\n", dev->name, phy_id,
 818                                mii_status, rp->mii_if.advertising,
 819                                mdio_read(dev, phy_id, 5));
 820
 821                         /* set IFF_RUNNING */
 822                         if (mii_status & BMSR_LSTATUS)
 823                                 netif_carrier_on(dev);
 824                         else
 825                                 netif_carrier_off(dev);
 826
 827                 }
 828         }
 829         rp->mii_if.phy_id = phy_id;
 830         if (debug > 1 && avoid_D3)
 831                 printk(KERN_INFO "%s: No D3 power state at shutdown.\n",
 832                        dev->name);
 833
 834         return 0;
 835
 836 err_out_unmap:
 837         pci_iounmap(pdev, ioaddr);
 838 err_out_free_res:
 839         pci_release_regions(pdev);
 840 err_out_free_netdev:
 841         free_netdev(dev);
 842 err_out:
 843         return rc;
 844 }
 845
 846 static int alloc_ring(struct net_device* dev)
 847 {
 848         struct rhine_private *rp = netdev_priv(dev);
 849         void *ring;
 850         dma_addr_t ring_dma;
 851
 852         ring = pci_alloc_consistent(rp->pdev,
 853                                     RX_RING_SIZE * sizeof(struct rx_desc) +
 854                                     TX_RING_SIZE * sizeof(struct tx_desc),
 855                                     &ring_dma);
 856         if (!ring) {
 857                 printk(KERN_ERR "Could not allocate DMA memory.\n");
 858                 return -ENOMEM;
 859         }
 860         if (rp->quirks & rqRhineI) {
 861                 rp->tx_bufs = pci_alloc_consistent(rp->pdev,
 862                                                    PKT_BUF_SZ * TX_RING_SIZE,
 863                                                    &rp->tx_bufs_dma);
 864                 if (rp->tx_bufs == NULL) {
 865                         pci_free_consistent(rp->pdev,
 866                                     RX_RING_SIZE * sizeof(struct rx_desc) +
 867                                     TX_RING_SIZE * sizeof(struct tx_desc),
 868                                     ring, ring_dma);
 869                         return -ENOMEM;
 870                 }
 871         }
 872
 873         rp->rx_ring = ring;
 874         rp->tx_ring = ring + RX_RING_SIZE * sizeof(struct rx_desc);
 875         rp->rx_ring_dma = ring_dma;
 876         rp->tx_ring_dma = ring_dma + RX_RING_SIZE * sizeof(struct rx_desc);
 877
 878         return 0;
 879 }
 880
 881 static void free_ring(struct net_device* dev)
 882 {
 883         struct rhine_private *rp = netdev_priv(dev);
 884
 885         pci_free_consistent(rp->pdev,
 886                             RX_RING_SIZE * sizeof(struct rx_desc) +
 887                             TX_RING_SIZE * sizeof(struct tx_desc),
 888                             rp->rx_ring, rp->rx_ring_dma);
 889         rp->tx_ring = NULL;
 890
 891         if (rp->tx_bufs)
 892                 pci_free_consistent(rp->pdev, PKT_BUF_SZ * TX_RING_SIZE,
 893                                     rp->tx_bufs, rp->tx_bufs_dma);
 894
 895         rp->tx_bufs = NULL;
 896
 897 }
 898
 899 static void alloc_rbufs(struct net_device *dev)
 900 {
 901         struct rhine_private *rp = netdev_priv(dev);
 902         dma_addr_t next;
 903         int i;
 904
 905         rp->dirty_rx = rp->cur_rx = 0;
 906
 907         rp->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
 908         rp->rx_head_desc = &rp->rx_ring[0];
 909         next = rp->rx_ring_dma;
 910
 911         /* Init the ring entries */
 912         for (i = 0; i < RX_RING_SIZE; i++) {
 913                 rp->rx_ring[i].rx_status = 0;
 914                 rp->rx_ring[i].desc_length = cpu_to_le32(rp->rx_buf_sz);
 915                 next += sizeof(struct rx_desc);
 916                 rp->rx_ring[i].next_desc = cpu_to_le32(next);
 917                 rp->rx_skbuff[i] = NULL;
 918         }
 919         /* Mark the last entry as wrapping the ring. */
 920         rp->rx_ring[i-1].next_desc = cpu_to_le32(rp->rx_ring_dma);
 921
 922         /* Fill in the Rx buffers.  Handle allocation failure gracefully. */
 923         for (i = 0; i < RX_RING_SIZE; i++) {
 924                 struct sk_buff *skb = dev_alloc_skb(rp->rx_buf_sz);
 925                 rp->rx_skbuff[i] = skb;
 926                 if (skb == NULL)
 927                         break;
 928                 skb->dev = dev;                 /* Mark as being used by this device. */
 929
 930                 rp->rx_skbuff_dma[i] =
 931                         pci_map_single(rp->pdev, skb->data, rp->rx_buf_sz,
 932                                        PCI_DMA_FROMDEVICE);
 933
 934                 rp->rx_ring[i].addr = cpu_to_le32(rp->rx_skbuff_dma[i]);
 935                 rp->rx_ring[i].rx_status = cpu_to_le32(DescOwn);
 936         }
 937         rp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
 938 }
 939
 940 static void free_rbufs(struct net_device* dev)
 941 {
 942         struct rhine_private *rp = netdev_priv(dev);
 943         int i;
 944
 945         /* Free all the skbuffs in the Rx queue. */
 946         for (i = 0; i < RX_RING_SIZE; i++) {
 947                 rp->rx_ring[i].rx_status = 0;
 948                 rp->rx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */
 949                 if (rp->rx_skbuff[i]) {
 950                         pci_unmap_single(rp->pdev,
 951                                          rp->rx_skbuff_dma[i],
 952                                          rp->rx_buf_sz, PCI_DMA_FROMDEVICE);
 953                         dev_kfree_skb(rp->rx_skbuff[i]);
 954                 }
 955                 rp->rx_skbuff[i] = NULL;
 956         }
 957 }
 958
 959 static void alloc_tbufs(struct net_device* dev)
 960 {
 961         struct rhine_private *rp = netdev_priv(dev);
 962         dma_addr_t next;
 963         int i;
 964
 965         rp->dirty_tx = rp->cur_tx = 0;
 966         next = rp->tx_ring_dma;
 967         for (i = 0; i < TX_RING_SIZE; i++) {
 968                 rp->tx_skbuff[i] = NULL;
 969                 rp->tx_ring[i].tx_status = 0;
 970                 rp->tx_ring[i].desc_length = cpu_to_le32(TXDESC);
 971                 next += sizeof(struct tx_desc);
 972                 rp->tx_ring[i].next_desc = cpu_to_le32(next);
 973                 if (rp->quirks & rqRhineI)
 974                         rp->tx_buf[i] = &rp->tx_bufs[i * PKT_BUF_SZ];
 975         }
 976         rp->tx_ring[i-1].next_desc = cpu_to_le32(rp->tx_ring_dma);
 977
 978 }
 979
 980 static void free_tbufs(struct net_device* dev)
 981 {
 982         struct rhine_private *rp = netdev_priv(dev);
 983         int i;
 984
 985         for (i = 0; i < TX_RING_SIZE; i++) {
 986                 rp->tx_ring[i].tx_status = 0;
 987                 rp->tx_ring[i].desc_length = cpu_to_le32(TXDESC);
 988                 rp->tx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */
 989                 if (rp->tx_skbuff[i]) {
 990                         if (rp->tx_skbuff_dma[i]) {
 991                                 pci_unmap_single(rp->pdev,
 992                                                  rp->tx_skbuff_dma[i],
 993                                                  rp->tx_skbuff[i]->len,
 994                                                  PCI_DMA_TODEVICE);
 995                         }
 996                         dev_kfree_skb(rp->tx_skbuff[i]);
 997                 }
 998                 rp->tx_skbuff[i] = NULL;
 999                 rp->tx_buf[i] = NULL;
1000         }
1001 }
1002
1003 static void rhine_check_media(struct net_device *dev, unsigned int init_media)
1004 {
1005         struct rhine_private *rp = netdev_priv(dev);
1006         void __iomem *ioaddr = rp->base;
1007
1008         mii_check_media(&rp->mii_if, debug, init_media);
1009
1010         if (rp->mii_if.full_duplex)
1011             iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1FDuplex,
1012                    ioaddr + ChipCmd1);
1013         else
1014             iowrite8(ioread8(ioaddr + ChipCmd1) & ~Cmd1FDuplex,
1015                    ioaddr + ChipCmd1);
1016         if (debug > 1)
1017                 printk(KERN_INFO "%s: force_media %d, carrier %d\n", dev->name,
1018                         rp->mii_if.force_media, netif_carrier_ok(dev));
1019 }
1020
1021 /* Called after status of force_media possibly changed */
1022 static void rhine_set_carrier(struct mii_if_info *mii)
1023 {
1024         if (mii->force_media) {
1025                 /* autoneg is off: Link is always assumed to be up */
1026                 if (!netif_carrier_ok(mii->dev))
1027                         netif_carrier_on(mii->dev);
1028         }
1029         else    /* Let MMI library update carrier status */
1030                 rhine_check_media(mii->dev, 0);
1031         if (debug > 1)
1032                 printk(KERN_INFO "%s: force_media %d, carrier %d\n",
1033                        mii->dev->name, mii->force_media,
1034                        netif_carrier_ok(mii->dev));
1035 }
1036
1037 static void init_registers(struct net_device *dev)
1038 {
1039         struct rhine_private *rp = netdev_priv(dev);
1040         void __iomem *ioaddr = rp->base;
1041         int i;
1042
1043         for (i = 0; i < 6; i++)
1044                 iowrite8(dev->dev_addr[i], ioaddr + StationAddr + i);
1045
1046         /* Initialize other registers. */
1047         iowrite16(0x0006, ioaddr + PCIBusConfig);       /* Tune configuration??? */
1048         /* Configure initial FIFO thresholds. */
1049         iowrite8(0x20, ioaddr + TxConfig);
1050         rp->tx_thresh = 0x20;
1051         rp->rx_thresh = 0x60;           /* Written in rhine_set_rx_mode(). */
1052
1053         iowrite32(rp->rx_ring_dma, ioaddr + RxRingPtr);
1054         iowrite32(rp->tx_ring_dma, ioaddr + TxRingPtr);
1055
1056         rhine_set_rx_mode(dev);
1057
1058         netif_poll_enable(dev);
1059
1060         /* Enable interrupts by setting the interrupt mask. */
1061         iowrite16(IntrRxDone | IntrRxErr | IntrRxEmpty| IntrRxOverflow |
1062                IntrRxDropped | IntrRxNoBuf | IntrTxAborted |
1063                IntrTxDone | IntrTxError | IntrTxUnderrun |
1064                IntrPCIErr | IntrStatsMax | IntrLinkChange,
1065                ioaddr + IntrEnable);
1066
1067         iowrite16(CmdStart | CmdTxOn | CmdRxOn | (Cmd1NoTxPoll << 8),
1068                ioaddr + ChipCmd);
1069         rhine_check_media(dev, 1);
1070 }
1071
1072 /* Enable MII link status auto-polling (required for IntrLinkChange) */
1073 static void rhine_enable_linkmon(void __iomem *ioaddr)
1074 {
1075         iowrite8(0, ioaddr + MIICmd);
1076         iowrite8(MII_BMSR, ioaddr + MIIRegAddr);
1077         iowrite8(0x80, ioaddr + MIICmd);
1078
1079         RHINE_WAIT_FOR((ioread8(ioaddr + MIIRegAddr) & 0x20));
1080
1081         iowrite8(MII_BMSR | 0x40, ioaddr + MIIRegAddr);
1082 }
1083
1084 /* Disable MII link status auto-polling (required for MDIO access) */
1085 static void rhine_disable_linkmon(void __iomem *ioaddr, u32 quirks)
1086 {
1087         iowrite8(0, ioaddr + MIICmd);
1088
1089         if (quirks & rqRhineI) {
1090                 iowrite8(0x01, ioaddr + MIIRegAddr);    // MII_BMSR
1091
1092                 /* Can be called from ISR. Evil. */
1093                 mdelay(1);
1094
1095                 /* 0x80 must be set immediately before turning it off */
1096                 iowrite8(0x80, ioaddr + MIICmd);
1097
1098                 RHINE_WAIT_FOR(ioread8(ioaddr + MIIRegAddr) & 0x20);
1099
1100                 /* Heh. Now clear 0x80 again. */
1101                 iowrite8(0, ioaddr + MIICmd);
1102         }
1103         else
1104                 RHINE_WAIT_FOR(ioread8(ioaddr + MIIRegAddr) & 0x80);
1105 }
1106
1107 /* Read and write over the MII Management Data I/O (MDIO) interface. */
1108
1109 static int mdio_read(struct net_device *dev, int phy_id, int regnum)
1110 {
1111         struct rhine_private *rp = netdev_priv(dev);
1112         void __iomem *ioaddr = rp->base;
1113         int result;
1114
1115         rhine_disable_linkmon(ioaddr, rp->quirks);
1116
1117         /* rhine_disable_linkmon already cleared MIICmd */
1118         iowrite8(phy_id, ioaddr + MIIPhyAddr);
1119         iowrite8(regnum, ioaddr + MIIRegAddr);
1120         iowrite8(0x40, ioaddr + MIICmd);                /* Trigger read */
1121         RHINE_WAIT_FOR(!(ioread8(ioaddr + MIICmd) & 0x40));
1122         result = ioread16(ioaddr + MIIData);
1123
1124         rhine_enable_linkmon(ioaddr);
1125         return result;
1126 }
1127
1128 static void mdio_write(struct net_device *dev, int phy_id, int regnum, int value)
1129 {
1130         struct rhine_private *rp = netdev_priv(dev);
1131         void __iomem *ioaddr = rp->base;
1132
1133         rhine_disable_linkmon(ioaddr, rp->quirks);
1134
1135         /* rhine_disable_linkmon already cleared MIICmd */
1136         iowrite8(phy_id, ioaddr + MIIPhyAddr);
1137         iowrite8(regnum, ioaddr + MIIRegAddr);
1138         iowrite16(value, ioaddr + MIIData);
1139         iowrite8(0x20, ioaddr + MIICmd);                /* Trigger write */
1140         RHINE_WAIT_FOR(!(ioread8(ioaddr + MIICmd) & 0x20));
1141
1142         rhine_enable_linkmon(ioaddr);
1143 }
1144
1145 static int rhine_open(struct net_device *dev)
1146 {
1147         struct rhine_private *rp = netdev_priv(dev);
1148         void __iomem *ioaddr = rp->base;
1149         int rc;
1150
1151         rc = request_irq(rp->pdev->irq, &rhine_interrupt, IRQF_SHARED, dev->name,
1152                         dev);
1153         if (rc)
1154                 return rc;
1155
1156         if (debug > 1)
1157                 printk(KERN_DEBUG "%s: rhine_open() irq %d.\n",
1158                        dev->name, rp->pdev->irq);
1159
1160         rc = alloc_ring(dev);
1161         if (rc) {
1162                 free_irq(rp->pdev->irq, dev);
1163                 return rc;
1164         }
1165         alloc_rbufs(dev);
1166         alloc_tbufs(dev);
1167         rhine_chip_reset(dev);
1168         init_registers(dev);
1169         if (debug > 2)
1170                 printk(KERN_DEBUG "%s: Done rhine_open(), status %4.4x "
1171                        "MII status: %4.4x.\n",
1172                        dev->name, ioread16(ioaddr + ChipCmd),
1173                        mdio_read(dev, rp->mii_if.phy_id, MII_BMSR));
1174
1175         netif_start_queue(dev);
1176
1177         return 0;
1178 }
1179
1180 static void rhine_tx_timeout(struct net_device *dev)
1181 {
1182         struct rhine_private *rp = netdev_priv(dev);
1183         void __iomem *ioaddr = rp->base;
1184
1185         printk(KERN_WARNING "%s: Transmit timed out, status %4.4x, PHY status "
1186                "%4.4x, resetting...\n",
1187                dev->name, ioread16(ioaddr + IntrStatus),
1188                mdio_read(dev, rp->mii_if.phy_id, MII_BMSR));
1189
1190         /* protect against concurrent rx interrupts */
1191         disable_irq(rp->pdev->irq);
1192
1193         spin_lock(&rp->lock);
1194
1195         /* clear all descriptors */
1196         free_tbufs(dev);
1197         free_rbufs(dev);
1198         alloc_tbufs(dev);
1199         alloc_rbufs(dev);
1200
1201         /* Reinitialize the hardware. */
1202         rhine_chip_reset(dev);
1203         init_registers(dev);
1204
1205         spin_unlock(&rp->lock);
1206         enable_irq(rp->pdev->irq);
1207
1208         dev->trans_start = jiffies;
1209         rp->stats.tx_errors++;
1210         netif_wake_queue(dev);
1211 }
1212
1213 static int rhine_start_tx(struct sk_buff *skb, struct net_device *dev)
1214 {
1215         struct rhine_private *rp = netdev_priv(dev);
1216         void __iomem *ioaddr = rp->base;
1217         unsigned entry;
1218
1219         /* Caution: the write order is important here, set the field
1220            with the "ownership" bits last. */
1221
1222         /* Calculate the next Tx descriptor entry. */
1223         entry = rp->cur_tx % TX_RING_SIZE;
1224
1225         if (skb_padto(skb, ETH_ZLEN))
1226                 return 0;
1227
1228         rp->tx_skbuff[entry] = skb;
1229
1230         if ((rp->quirks & rqRhineI) &&
1231             (((unsigned long)skb->data & 3) || skb_shinfo(skb)->nr_frags != 0 || skb->ip_summed == CHECKSUM_PARTIAL)) {
1232                 /* Must use alignment buffer. */
1233                 if (skb->len > PKT_BUF_SZ) {
1234                         /* packet too long, drop it */
1235                         dev_kfree_skb(skb);
1236                         rp->tx_skbuff[entry] = NULL;
1237                         rp->stats.tx_dropped++;
1238                         return 0;
1239                 }
1240
1241                 /* Padding is not copied and so must be redone. */
1242                 skb_copy_and_csum_dev(skb, rp->tx_buf[entry]);
1243                 if (skb->len < ETH_ZLEN)
1244                         memset(rp->tx_buf[entry] + skb->len, 0,
1245                                ETH_ZLEN - skb->len);
1246                 rp->tx_skbuff_dma[entry] = 0;
1247                 rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_bufs_dma +
1248                                                       (rp->tx_buf[entry] -
1249                                                        rp->tx_bufs));
1250         } else {
1251                 rp->tx_skbuff_dma[entry] =
1252                         pci_map_single(rp->pdev, skb->data, skb->len,
1253                                        PCI_DMA_TODEVICE);
1254                 rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_skbuff_dma[entry]);
1255         }
1256
1257         rp->tx_ring[entry].desc_length =
1258                 cpu_to_le32(TXDESC | (skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN));
1259
1260         /* lock eth irq */
1261         spin_lock_irq(&rp->lock);
1262         wmb();
1263         rp->tx_ring[entry].tx_status = cpu_to_le32(DescOwn);
1264         wmb();
1265
1266         rp->cur_tx++;
1267
1268         /* Non-x86 Todo: explicitly flush cache lines here. */
1269
1270         /* Wake the potentially-idle transmit channel */
1271         iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1TxDemand,
1272                ioaddr + ChipCmd1);
1273         IOSYNC;
1274
1275         if (rp->cur_tx == rp->dirty_tx + TX_QUEUE_LEN)
1276                 netif_stop_queue(dev);
1277
1278         dev->trans_start = jiffies;
1279
1280         spin_unlock_irq(&rp->lock);
1281
1282         if (debug > 4) {
1283                 printk(KERN_DEBUG "%s: Transmit frame #%d queued in slot %d.\n",
1284                        dev->name, rp->cur_tx-1, entry);
1285         }
1286         return 0;
1287 }
1288
1289 /* The interrupt handler does all of the Rx thread work and cleans up
1290    after the Tx thread. */
1291 static irqreturn_t rhine_interrupt(int irq, void *dev_instance)
1292 {
1293         struct net_device *dev = dev_instance;
1294         struct rhine_private *rp = netdev_priv(dev);
1295         void __iomem *ioaddr = rp->base;
1296         u32 intr_status;
1297         int boguscnt = max_interrupt_work;
1298         int handled = 0;
1299
1300         while ((intr_status = get_intr_status(dev))) {
1301                 handled = 1;
1302
1303                 /* Acknowledge all of the current interrupt sources ASAP. */
1304                 if (intr_status & IntrTxDescRace)
1305                         iowrite8(0x08, ioaddr + IntrStatus2);
1306                 iowrite16(intr_status & 0xffff, ioaddr + IntrStatus);
1307                 IOSYNC;
1308
1309                 if (debug > 4)
1310                         printk(KERN_DEBUG "%s: Interrupt, status %8.8x.\n",
1311                                dev->name, intr_status);
1312
1313                 if (intr_status & (IntrRxDone | IntrRxErr | IntrRxDropped |
1314                                    IntrRxWakeUp | IntrRxEmpty | IntrRxNoBuf)) {
1315 #ifdef CONFIG_VIA_RHINE_NAPI
1316                         iowrite16(IntrTxAborted |
1317                                   IntrTxDone | IntrTxError | IntrTxUnderrun |
1318                                   IntrPCIErr | IntrStatsMax | IntrLinkChange,
1319                                   ioaddr + IntrEnable);
1320
1321                         netif_rx_schedule(dev);
1322 #else
1323                         rhine_rx(dev, RX_RING_SIZE);
1324 #endif
1325                 }
1326
1327                 if (intr_status & (IntrTxErrSummary | IntrTxDone)) {
1328                         if (intr_status & IntrTxErrSummary) {
1329                                 /* Avoid scavenging before Tx engine turned off */
1330                                 RHINE_WAIT_FOR(!(ioread8(ioaddr+ChipCmd) & CmdTxOn));
1331                                 if (debug > 2 &&
1332                                     ioread8(ioaddr+ChipCmd) & CmdTxOn)
1333                                         printk(KERN_WARNING "%s: "
1334                                                "rhine_interrupt() Tx engine"
1335                                                "still on.\n", dev->name);
1336                         }
1337                         rhine_tx(dev);
1338                 }
1339
1340                 /* Abnormal error summary/uncommon events handlers. */
1341                 if (intr_status & (IntrPCIErr | IntrLinkChange |
1342                                    IntrStatsMax | IntrTxError | IntrTxAborted |
1343                                    IntrTxUnderrun | IntrTxDescRace))
1344                         rhine_error(dev, intr_status);
1345
1346                 if (--boguscnt < 0) {
1347                         printk(KERN_WARNING "%s: Too much work at interrupt, "
1348                                "status=%#8.8x.\n",
1349                                dev->name, intr_status);
1350                         break;
1351                 }
1352         }
1353
1354         if (debug > 3)
1355                 printk(KERN_DEBUG "%s: exiting interrupt, status=%8.8x.\n",
1356                        dev->name, ioread16(ioaddr + IntrStatus));
1357         return IRQ_RETVAL(handled);
1358 }
1359
1360 /* This routine is logically part of the interrupt handler, but isolated
1361    for clarity. */
1362 static void rhine_tx(struct net_device *dev)
1363 {
1364         struct rhine_private *rp = netdev_priv(dev);
1365         int txstatus = 0, entry = rp->dirty_tx % TX_RING_SIZE;
1366
1367         spin_lock(&rp->lock);
1368
1369         /* find and cleanup dirty tx descriptors */
1370         while (rp->dirty_tx != rp->cur_tx) {
1371                 txstatus = le32_to_cpu(rp->tx_ring[entry].tx_status);
1372                 if (debug > 6)
1373                         printk(KERN_DEBUG "Tx scavenge %d status %8.8x.\n",
1374                                entry, txstatus);
1375                 if (txstatus & DescOwn)
1376                         break;
1377                 if (txstatus & 0x8000) {
1378                         if (debug > 1)
1379                                 printk(KERN_DEBUG "%s: Transmit error, "
1380                                        "Tx status %8.8x.\n",
1381                                        dev->name, txstatus);
1382                         rp->stats.tx_errors++;
1383                         if (txstatus & 0x0400) rp->stats.tx_carrier_errors++;
1384                         if (txstatus & 0x0200) rp->stats.tx_window_errors++;
1385                         if (txstatus & 0x0100) rp->stats.tx_aborted_errors++;
1386                         if (txstatus & 0x0080) rp->stats.tx_heartbeat_errors++;
1387                         if (((rp->quirks & rqRhineI) && txstatus & 0x0002) ||
1388                             (txstatus & 0x0800) || (txstatus & 0x1000)) {
1389                                 rp->stats.tx_fifo_errors++;
1390                                 rp->tx_ring[entry].tx_status = cpu_to_le32(DescOwn);
1391                                 break; /* Keep the skb - we try again */
1392                         }
1393                         /* Transmitter restarted in 'abnormal' handler. */
1394                 } else {
1395                         if (rp->quirks & rqRhineI)
1396                                 rp->stats.collisions += (txstatus >> 3) & 0x0F;
1397                         else
1398                                 rp->stats.collisions += txstatus & 0x0F;
1399                         if (debug > 6)
1400                                 printk(KERN_DEBUG "collisions: %1.1x:%1.1x\n",
1401                                        (txstatus >> 3) & 0xF,
1402                                        txstatus & 0xF);
1403                         rp->stats.tx_bytes += rp->tx_skbuff[entry]->len;
1404                         rp->stats.tx_packets++;
1405                 }
1406                 /* Free the original skb. */
1407                 if (rp->tx_skbuff_dma[entry]) {
1408                         pci_unmap_single(rp->pdev,
1409                                          rp->tx_skbuff_dma[entry],
1410                                          rp->tx_skbuff[entry]->len,
1411                                          PCI_DMA_TODEVICE);
1412                 }
1413                 dev_kfree_skb_irq(rp->tx_skbuff[entry]);
1414                 rp->tx_skbuff[entry] = NULL;
1415                 entry = (++rp->dirty_tx) % TX_RING_SIZE;
1416         }
1417         if ((rp->cur_tx - rp->dirty_tx) < TX_QUEUE_LEN - 4)
1418                 netif_wake_queue(dev);
1419
1420         spin_unlock(&rp->lock);
1421 }
1422
1423 /* Process up to limit frames from receive ring */
1424 static int rhine_rx(struct net_device *dev, int limit)
1425 {
1426         struct rhine_private *rp = netdev_priv(dev);
1427         int count;
1428         int entry = rp->cur_rx % RX_RING_SIZE;
1429
1430         if (debug > 4) {
1431                 printk(KERN_DEBUG "%s: rhine_rx(), entry %d status %8.8x.\n",
1432                        dev->name, entry,
1433                        le32_to_cpu(rp->rx_head_desc->rx_status));
1434         }
1435
1436         /* If EOP is set on the next entry, it's a new packet. Send it up. */
1437         for (count = 0; count < limit; ++count) {
1438                 struct rx_desc *desc = rp->rx_head_desc;
1439                 u32 desc_status = le32_to_cpu(desc->rx_status);
1440                 int data_size = desc_status >> 16;
1441
1442                 if (desc_status & DescOwn)
1443                         break;
1444
1445                 if (debug > 4)
1446                         printk(KERN_DEBUG "rhine_rx() status is %8.8x.\n",
1447                                desc_status);
1448
1449                 if ((desc_status & (RxWholePkt | RxErr)) != RxWholePkt) {
1450                         if ((desc_status & RxWholePkt) != RxWholePkt) {
1451                                 printk(KERN_WARNING "%s: Oversized Ethernet "
1452                                        "frame spanned multiple buffers, entry "
1453                                        "%#x length %d status %8.8x!\n",
1454                                        dev->name, entry, data_size,
1455                                        desc_status);
1456                                 printk(KERN_WARNING "%s: Oversized Ethernet "
1457                                        "frame %p vs %p.\n", dev->name,
1458                                        rp->rx_head_desc, &rp->rx_ring[entry]);
1459                                 rp->stats.rx_length_errors++;
1460                         } else if (desc_status & RxErr) {
1461                                 /* There was a error. */
1462                                 if (debug > 2)
1463                                         printk(KERN_DEBUG "rhine_rx() Rx "
1464                                                "error was %8.8x.\n",
1465                                                desc_status);
1466                                 rp->stats.rx_errors++;
1467                                 if (desc_status & 0x0030) rp->stats.rx_length_errors++;
1468                                 if (desc_status & 0x0048) rp->stats.rx_fifo_errors++;
1469                                 if (desc_status & 0x0004) rp->stats.rx_frame_errors++;
1470                                 if (desc_status & 0x0002) {
1471                                         /* this can also be updated outside the interrupt handler */
1472                                         spin_lock(&rp->lock);
1473                                         rp->stats.rx_crc_errors++;
1474                                         spin_unlock(&rp->lock);
1475                                 }
1476                         }
1477                 } else {
1478                         struct sk_buff *skb;
1479                         /* Length should omit the CRC */
1480                         int pkt_len = data_size - 4;
1481
1482                         /* Check if the packet is long enough to accept without
1483                            copying to a minimally-sized skbuff. */
1484                         if (pkt_len < rx_copybreak &&
1485                                 (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
1486                                 skb_reserve(skb, 2);    /* 16 byte align the IP header */
1487                                 pci_dma_sync_single_for_cpu(rp->pdev,
1488                                                             rp->rx_skbuff_dma[entry],
1489                                                             rp->rx_buf_sz,
1490                                                             PCI_DMA_FROMDEVICE);
1491
1492                                 skb_copy_to_linear_data(skb,
1493                                                  rp->rx_skbuff[entry]->data,
1494                                                  pkt_len);
1495                                 skb_put(skb, pkt_len);
1496                                 pci_dma_sync_single_for_device(rp->pdev,
1497                                                                rp->rx_skbuff_dma[entry],
1498                                                                rp->rx_buf_sz,
1499                                                                PCI_DMA_FROMDEVICE);
1500                         } else {
1501                                 skb = rp->rx_skbuff[entry];
1502                                 if (skb == NULL) {
1503                                         printk(KERN_ERR "%s: Inconsistent Rx "
1504                                                "descriptor chain.\n",
1505                                                dev->name);
1506                                         break;
1507                                 }
1508                                 rp->rx_skbuff[entry] = NULL;
1509                                 skb_put(skb, pkt_len);
1510                                 pci_unmap_single(rp->pdev,
1511                                                  rp->rx_skbuff_dma[entry],
1512                                                  rp->rx_buf_sz,
1513                                                  PCI_DMA_FROMDEVICE);
1514                         }
1515                         skb->protocol = eth_type_trans(skb, dev);
1516 #ifdef CONFIG_VIA_RHINE_NAPI
1517                         netif_receive_skb(skb);
1518 #else
1519                         netif_rx(skb);
1520 #endif
1521                         dev->last_rx = jiffies;
1522                         rp->stats.rx_bytes += pkt_len;
1523                         rp->stats.rx_packets++;
1524                 }
1525                 entry = (++rp->cur_rx) % RX_RING_SIZE;
1526                 rp->rx_head_desc = &rp->rx_ring[entry];
1527         }
1528
1529         /* Refill the Rx ring buffers. */
1530         for (; rp->cur_rx - rp->dirty_rx > 0; rp->dirty_rx++) {
1531                 struct sk_buff *skb;
1532                 entry = rp->dirty_rx % RX_RING_SIZE;
1533                 if (rp->rx_skbuff[entry] == NULL) {
1534                         skb = dev_alloc_skb(rp->rx_buf_sz);
1535                         rp->rx_skbuff[entry] = skb;
1536                         if (skb == NULL)
1537                                 break;  /* Better luck next round. */
1538                         skb->dev = dev; /* Mark as being used by this device. */
1539                         rp->rx_skbuff_dma[entry] =
1540                                 pci_map_single(rp->pdev, skb->data,
1541                                                rp->rx_buf_sz,
1542                                                PCI_DMA_FROMDEVICE);
1543                         rp->rx_ring[entry].addr = cpu_to_le32(rp->rx_skbuff_dma[entry]);
1544                 }
1545                 rp->rx_ring[entry].rx_status = cpu_to_le32(DescOwn);
1546         }
1547
1548         return count;
1549 }
1550
1551 /*
1552  * Clears the "tally counters" for CRC errors and missed frames(?).
1553  * It has been reported that some chips need a write of 0 to clear
1554  * these, for others the counters are set to 1 when written to and
1555  * instead cleared when read. So we clear them both ways ...
1556  */
1557 static inline void clear_tally_counters(void __iomem *ioaddr)
1558 {
1559         iowrite32(0, ioaddr + RxMissed);
1560         ioread16(ioaddr + RxCRCErrs);
1561         ioread16(ioaddr + RxMissed);
1562 }
1563
1564 static void rhine_restart_tx(struct net_device *dev) {
1565         struct rhine_private *rp = netdev_priv(dev);
1566         void __iomem *ioaddr = rp->base;
1567         int entry = rp->dirty_tx % TX_RING_SIZE;
1568         u32 intr_status;
1569
1570         /*
1571          * If new errors occured, we need to sort them out before doing Tx.
1572          * In that case the ISR will be back here RSN anyway.
1573          */
1574         intr_status = get_intr_status(dev);
1575
1576         if ((intr_status & IntrTxErrSummary) == 0) {
1577
1578                 /* We know better than the chip where it should continue. */
1579                 iowrite32(rp->tx_ring_dma + entry * sizeof(struct tx_desc),
1580                        ioaddr + TxRingPtr);
1581
1582                 iowrite8(ioread8(ioaddr + ChipCmd) | CmdTxOn,
1583                        ioaddr + ChipCmd);
1584                 iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1TxDemand,
1585                        ioaddr + ChipCmd1);
1586                 IOSYNC;
1587         }
1588         else {
1589                 /* This should never happen */
1590                 if (debug > 1)
1591                         printk(KERN_WARNING "%s: rhine_restart_tx() "
1592                                "Another error occured %8.8x.\n",
1593                                dev->name, intr_status);
1594         }
1595
1596 }
1597
1598 static void rhine_error(struct net_device *dev, int intr_status)
1599 {
1600         struct rhine_private *rp = netdev_priv(dev);
1601         void __iomem *ioaddr = rp->base;
1602
1603         spin_lock(&rp->lock);
1604
1605         if (intr_status & IntrLinkChange)
1606                 rhine_check_media(dev, 0);
1607         if (intr_status & IntrStatsMax) {
1608                 rp->stats.rx_crc_errors += ioread16(ioaddr + RxCRCErrs);
1609                 rp->stats.rx_missed_errors += ioread16(ioaddr + RxMissed);
1610                 clear_tally_counters(ioaddr);
1611         }
1612         if (intr_status & IntrTxAborted) {
1613                 if (debug > 1)
1614                         printk(KERN_INFO "%s: Abort %8.8x, frame dropped.\n",
1615                                dev->name, intr_status);
1616         }
1617         if (intr_status & IntrTxUnderrun) {
1618                 if (rp->tx_thresh < 0xE0)
1619                         iowrite8(rp->tx_thresh += 0x20, ioaddr + TxConfig);
1620                 if (debug > 1)
1621                         printk(KERN_INFO "%s: Transmitter underrun, Tx "
1622                                "threshold now %2.2x.\n",
1623                                dev->name, rp->tx_thresh);
1624         }
1625         if (intr_status & IntrTxDescRace) {
1626                 if (debug > 2)
1627                         printk(KERN_INFO "%s: Tx descriptor write-back race.\n",
1628                                dev->name);
1629         }
1630         if ((intr_status & IntrTxError) &&
1631             (intr_status & (IntrTxAborted |
1632              IntrTxUnderrun | IntrTxDescRace)) == 0) {
1633                 if (rp->tx_thresh < 0xE0) {
1634                         iowrite8(rp->tx_thresh += 0x20, ioaddr + TxConfig);
1635                 }
1636                 if (debug > 1)
1637                         printk(KERN_INFO "%s: Unspecified error. Tx "
1638                                "threshold now %2.2x.\n",
1639                                dev->name, rp->tx_thresh);
1640         }
1641         if (intr_status & (IntrTxAborted | IntrTxUnderrun | IntrTxDescRace |
1642                            IntrTxError))
1643                 rhine_restart_tx(dev);
1644
1645         if (intr_status & ~(IntrLinkChange | IntrStatsMax | IntrTxUnderrun |
1646                             IntrTxError | IntrTxAborted | IntrNormalSummary |
1647                             IntrTxDescRace)) {
1648                 if (debug > 1)
1649                         printk(KERN_ERR "%s: Something Wicked happened! "
1650                                "%8.8x.\n", dev->name, intr_status);
1651         }
1652
1653         spin_unlock(&rp->lock);
1654 }
1655
1656 static struct net_device_stats *rhine_get_stats(struct net_device *dev)
1657 {
1658         struct rhine_private *rp = netdev_priv(dev);
1659         void __iomem *ioaddr = rp->base;
1660         unsigned long flags;
1661
1662         spin_lock_irqsave(&rp->lock, flags);
1663         rp->stats.rx_crc_errors += ioread16(ioaddr + RxCRCErrs);
1664         rp->stats.rx_missed_errors += ioread16(ioaddr + RxMissed);
1665         clear_tally_counters(ioaddr);
1666         spin_unlock_irqrestore(&rp->lock, flags);
1667
1668         return &rp->stats;
1669 }
1670
1671 static void rhine_set_rx_mode(struct net_device *dev)
1672 {
1673         struct rhine_private *rp = netdev_priv(dev);
1674         void __iomem *ioaddr = rp->base;
1675         u32 mc_filter[2];       /* Multicast hash filter */
1676         u8 rx_mode;             /* Note: 0x02=accept runt, 0x01=accept errs */
1677
1678         if (dev->flags & IFF_PROMISC) {         /* Set promiscuous. */
1679                 rx_mode = 0x1C;
1680                 iowrite32(0xffffffff, ioaddr + MulticastFilter0);
1681                 iowrite32(0xffffffff, ioaddr + MulticastFilter1);
1682         } else if ((dev->mc_count > multicast_filter_limit)
1683                    || (dev->flags & IFF_ALLMULTI)) {
1684                 /* Too many to match, or accept all multicasts. */
1685                 iowrite32(0xffffffff, ioaddr + MulticastFilter0);
1686                 iowrite32(0xffffffff, ioaddr + MulticastFilter1);
1687                 rx_mode = 0x0C;
1688         } else {
1689                 struct dev_mc_list *mclist;
1690                 int i;
1691                 memset(mc_filter, 0, sizeof(mc_filter));
1692                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1693                      i++, mclist = mclist->next) {
1694                         int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
1695
1696                         mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
1697                 }
1698                 iowrite32(mc_filter[0], ioaddr + MulticastFilter0);
1699                 iowrite32(mc_filter[1], ioaddr + MulticastFilter1);
1700                 rx_mode = 0x0C;
1701         }
1702         iowrite8(rp->rx_thresh | rx_mode, ioaddr + RxConfig);
1703 }
1704
1705 static void netdev_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1706 {
1707         struct rhine_private *rp = netdev_priv(dev);
1708
1709         strcpy(info->driver, DRV_NAME);
1710         strcpy(info->version, DRV_VERSION);
1711         strcpy(info->bus_info, pci_name(rp->pdev));
1712 }
1713
1714 static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1715 {
1716         struct rhine_private *rp = netdev_priv(dev);
1717         int rc;
1718
1719         spin_lock_irq(&rp->lock);
1720         rc = mii_ethtool_gset(&rp->mii_if, cmd);
1721         spin_unlock_irq(&rp->lock);
1722
1723         return rc;
1724 }
1725
1726 static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1727 {
1728         struct rhine_private *rp = netdev_priv(dev);
1729         int rc;
1730
1731         spin_lock_irq(&rp->lock);
1732         rc = mii_ethtool_sset(&rp->mii_if, cmd);
1733         spin_unlock_irq(&rp->lock);
1734         rhine_set_carrier(&rp->mii_if);
1735
1736         return rc;
1737 }
1738
1739 static int netdev_nway_reset(struct net_device *dev)
1740 {
1741         struct rhine_private *rp = netdev_priv(dev);
1742
1743         return mii_nway_restart(&rp->mii_if);
1744 }
1745
1746 static u32 netdev_get_link(struct net_device *dev)
1747 {
1748         struct rhine_private *rp = netdev_priv(dev);
1749
1750         return mii_link_ok(&rp->mii_if);
1751 }
1752
1753 static u32 netdev_get_msglevel(struct net_device *dev)
1754 {
1755         return debug;
1756 }
1757
1758 static void netdev_set_msglevel(struct net_device *dev, u32 value)
1759 {
1760         debug = value;
1761 }
1762
1763 static void rhine_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1764 {
1765         struct rhine_private *rp = netdev_priv(dev);
1766
1767         if (!(rp->quirks & rqWOL))
1768                 return;
1769
1770         spin_lock_irq(&rp->lock);
1771         wol->supported = WAKE_PHY | WAKE_MAGIC |
1772                          WAKE_UCAST | WAKE_MCAST | WAKE_BCAST;  /* Untested */
1773         wol->wolopts = rp->wolopts;
1774         spin_unlock_irq(&rp->lock);
1775 }
1776
1777 static int rhine_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1778 {
1779         struct rhine_private *rp = netdev_priv(dev);
1780         u32 support = WAKE_PHY | WAKE_MAGIC |
1781                       WAKE_UCAST | WAKE_MCAST | WAKE_BCAST;     /* Untested */
1782
1783         if (!(rp->quirks & rqWOL))
1784                 return -EINVAL;
1785
1786         if (wol->wolopts & ~support)
1787                 return -EINVAL;
1788
1789         spin_lock_irq(&rp->lock);
1790         rp->wolopts = wol->wolopts;
1791         spin_unlock_irq(&rp->lock);
1792
1793         return 0;
1794 }
1795
1796 static const struct ethtool_ops netdev_ethtool_ops = {
1797         .get_drvinfo            = netdev_get_drvinfo,
1798         .get_settings           = netdev_get_settings,
1799         .set_settings           = netdev_set_settings,
1800         .nway_reset             = netdev_nway_reset,
1801         .get_link               = netdev_get_link,
1802         .get_msglevel           = netdev_get_msglevel,
1803         .set_msglevel           = netdev_set_msglevel,
1804         .get_wol                = rhine_get_wol,
1805         .set_wol                = rhine_set_wol,
1806         .get_sg                 = ethtool_op_get_sg,
1807         .get_tx_csum            = ethtool_op_get_tx_csum,
1808 };
1809
1810 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1811 {
1812         struct rhine_private *rp = netdev_priv(dev);
1813         int rc;
1814
1815         if (!netif_running(dev))
1816                 return -EINVAL;
1817
1818         spin_lock_irq(&rp->lock);
1819         rc = generic_mii_ioctl(&rp->mii_if, if_mii(rq), cmd, NULL);
1820         spin_unlock_irq(&rp->lock);
1821         rhine_set_carrier(&rp->mii_if);
1822
1823         return rc;
1824 }
1825
1826 static int rhine_close(struct net_device *dev)
1827 {
1828         struct rhine_private *rp = netdev_priv(dev);
1829         void __iomem *ioaddr = rp->base;
1830
1831         spin_lock_irq(&rp->lock);
1832
1833         netif_stop_queue(dev);
1834         netif_poll_disable(dev);
1835
1836         if (debug > 1)
1837                 printk(KERN_DEBUG "%s: Shutting down ethercard, "
1838                        "status was %4.4x.\n",
1839                        dev->name, ioread16(ioaddr + ChipCmd));
1840
1841         /* Switch to loopback mode to avoid hardware races. */
1842         iowrite8(rp->tx_thresh | 0x02, ioaddr + TxConfig);
1843
1844         /* Disable interrupts by clearing the interrupt mask. */
1845         iowrite16(0x0000, ioaddr + IntrEnable);
1846
1847         /* Stop the chip's Tx and Rx processes. */
1848         iowrite16(CmdStop, ioaddr + ChipCmd);
1849
1850         spin_unlock_irq(&rp->lock);
1851
1852         free_irq(rp->pdev->irq, dev);
1853         free_rbufs(dev);
1854         free_tbufs(dev);
1855         free_ring(dev);
1856
1857         return 0;
1858 }
1859
1860
1861 static void __devexit rhine_remove_one(struct pci_dev *pdev)
1862 {
1863         struct net_device *dev = pci_get_drvdata(pdev);
1864         struct rhine_private *rp = netdev_priv(dev);
1865
1866         unregister_netdev(dev);
1867
1868         pci_iounmap(pdev, rp->base);
1869         pci_release_regions(pdev);
1870
1871         free_netdev(dev);
1872         pci_disable_device(pdev);
1873         pci_set_drvdata(pdev, NULL);
1874 }
1875
1876 static void rhine_shutdown (struct pci_dev *pdev)
1877 {
1878         struct net_device *dev = pci_get_drvdata(pdev);
1879         struct rhine_private *rp = netdev_priv(dev);
1880         void __iomem *ioaddr = rp->base;
1881
1882         if (!(rp->quirks & rqWOL))
1883                 return; /* Nothing to do for non-WOL adapters */
1884
1885         rhine_power_init(dev);
1886
1887         /* Make sure we use pattern 0, 1 and not 4, 5 */
1888         if (rp->quirks & rq6patterns)
1889                 iowrite8(0x04, ioaddr + 0xA7);
1890
1891         if (rp->wolopts & WAKE_MAGIC) {
1892                 iowrite8(WOLmagic, ioaddr + WOLcrSet);
1893                 /*
1894                  * Turn EEPROM-controlled wake-up back on -- some hardware may
1895                  * not cooperate otherwise.
1896                  */
1897                 iowrite8(ioread8(ioaddr + ConfigA) | 0x03, ioaddr + ConfigA);
1898         }
1899
1900         if (rp->wolopts & (WAKE_BCAST|WAKE_MCAST))
1901                 iowrite8(WOLbmcast, ioaddr + WOLcgSet);
1902
1903         if (rp->wolopts & WAKE_PHY)
1904                 iowrite8(WOLlnkon | WOLlnkoff, ioaddr + WOLcrSet);
1905
1906         if (rp->wolopts & WAKE_UCAST)
1907                 iowrite8(WOLucast, ioaddr + WOLcrSet);
1908
1909         if (rp->wolopts) {
1910                 /* Enable legacy WOL (for old motherboards) */
1911                 iowrite8(0x01, ioaddr + PwcfgSet);
1912                 iowrite8(ioread8(ioaddr + StickyHW) | 0x04, ioaddr + StickyHW);
1913         }
1914
1915         /* Hit power state D3 (sleep) */
1916         if (!avoid_D3)
1917                 iowrite8(ioread8(ioaddr + StickyHW) | 0x03, ioaddr + StickyHW);
1918
1919         /* TODO: Check use of pci_enable_wake() */
1920
1921 }
1922
1923 #ifdef CONFIG_PM
1924 static int rhine_suspend(struct pci_dev *pdev, pm_message_t state)
1925 {
1926         struct net_device *dev = pci_get_drvdata(pdev);
1927         struct rhine_private *rp = netdev_priv(dev);
1928         unsigned long flags;
1929
1930         if (!netif_running(dev))
1931                 return 0;
1932
1933         netif_device_detach(dev);
1934         pci_save_state(pdev);
1935
1936         spin_lock_irqsave(&rp->lock, flags);
1937         rhine_shutdown(pdev);
1938         spin_unlock_irqrestore(&rp->lock, flags);
1939
1940         free_irq(dev->irq, dev);
1941         return 0;
1942 }
1943
1944 static int rhine_resume(struct pci_dev *pdev)
1945 {
1946         struct net_device *dev = pci_get_drvdata(pdev);
1947         struct rhine_private *rp = netdev_priv(dev);
1948         unsigned long flags;
1949         int ret;
1950
1951         if (!netif_running(dev))
1952                 return 0;
1953
1954         if (request_irq(dev->irq, rhine_interrupt, IRQF_SHARED, dev->name, dev))
1955                 printk(KERN_ERR "via-rhine %s: request_irq failed\n", dev->name);
1956
1957         ret = pci_set_power_state(pdev, PCI_D0);
1958         if (debug > 1)
1959                 printk(KERN_INFO "%s: Entering power state D0 %s (%d).\n",
1960                         dev->name, ret ? "failed" : "succeeded", ret);
1961
1962         pci_restore_state(pdev);
1963
1964         spin_lock_irqsave(&rp->lock, flags);
1965 #ifdef USE_MMIO
1966         enable_mmio(rp->pioaddr, rp->quirks);
1967 #endif
1968         rhine_power_init(dev);
1969         free_tbufs(dev);
1970         free_rbufs(dev);
1971         alloc_tbufs(dev);
1972         alloc_rbufs(dev);
1973         init_registers(dev);
1974         spin_unlock_irqrestore(&rp->lock, flags);
1975
1976         netif_device_attach(dev);
1977
1978         return 0;
1979 }
1980 #endif /* CONFIG_PM */
1981
1982 static struct pci_driver rhine_driver = {
1983         .name           = DRV_NAME,
1984         .id_table       = rhine_pci_tbl,
1985         .probe          = rhine_init_one,
1986         .remove         = __devexit_p(rhine_remove_one),
1987 #ifdef CONFIG_PM
1988         .suspend        = rhine_suspend,
1989         .resume         = rhine_resume,
1990 #endif /* CONFIG_PM */
1991         .shutdown =     rhine_shutdown,
1992 };
1993
1994 static struct dmi_system_id __initdata rhine_dmi_table[] = {
1995         {
1996                 .ident = "EPIA-M",
1997                 .matches = {
1998                         DMI_MATCH(DMI_BIOS_VENDOR, "Award Software International, Inc."),
1999                         DMI_MATCH(DMI_BIOS_VERSION, "6.00 PG"),
2000                 },
2001         },
2002         {
2003                 .ident = "KV7",
2004                 .matches = {
2005                         DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies, LTD"),
2006                         DMI_MATCH(DMI_BIOS_VERSION, "6.00 PG"),
2007                 },
2008         },
2009         { NULL }
2010 };
2011
2012 static int __init rhine_init(void)
2013 {
2014 /* when a module, this is printed whether or not devices are found in probe */
2015 #ifdef MODULE
2016         printk(version);
2017 #endif
2018         if (dmi_check_system(rhine_dmi_table)) {
2019                 /* these BIOSes fail at PXE boot if chip is in D3 */
2020                 avoid_D3 = 1;
2021                 printk(KERN_WARNING "%s: Broken BIOS detected, avoid_D3 "
2022                                     "enabled.\n",
2023                        DRV_NAME);
2024         }
2025         else if (avoid_D3)
2026                 printk(KERN_INFO "%s: avoid_D3 set.\n", DRV_NAME);
2027
2028         return pci_register_driver(&rhine_driver);
2029 }
2030
2031
2032 static void __exit rhine_cleanup(void)
2033 {
2034         pci_unregister_driver(&rhine_driver);
2035 }
2036
2037
2038 module_init(rhine_init);
2039 module_exit(rhine_cleanup);