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