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/slab.h>
  93 #include <linux/interrupt.h>
  94 #include <linux/pci.h>
  95 #include <linux/dma-mapping.h>
  96 #include <linux/netdevice.h>
  97 #include <linux/etherdevice.h>
  98 #include <linux/skbuff.h>
  99 #include <linux/init.h>
 100 #include <linux/delay.h>
 101 #include <linux/mii.h>
 102 #include <linux/ethtool.h>
 103 #include <linux/crc32.h>
 104 #include <linux/bitops.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 const struct pci_device_id 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
 393         /* Frequently used values: keep some adjacent for cache effect. */
 394         u32 quirks;
 395         struct rx_desc *rx_head_desc;
 396         unsigned int cur_rx, dirty_rx;  /* Producer/consumer ring indices */
 397         unsigned int cur_tx, dirty_tx;
 398         unsigned int rx_buf_sz;         /* Based on MTU+slack. */
 399         u8 wolopts;
 400
 401         u8 tx_thresh, rx_thresh;
 402
 403         struct mii_if_info mii_if;
 404         void __iomem *base;
 405 };
 406
 407 static int  mdio_read(struct net_device *dev, int phy_id, int location);
 408 static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
 409 static int  rhine_open(struct net_device *dev);
 410 static void rhine_tx_timeout(struct net_device *dev);
 411 static int  rhine_start_tx(struct sk_buff *skb, struct net_device *dev);
 412 static irqreturn_t rhine_interrupt(int irq, void *dev_instance);
 413 static void rhine_tx(struct net_device *dev);
 414 static int rhine_rx(struct net_device *dev, int limit);
 415 static void rhine_error(struct net_device *dev, int intr_status);
 416 static void rhine_set_rx_mode(struct net_device *dev);
 417 static struct net_device_stats *rhine_get_stats(struct net_device *dev);
 418 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 419 static const struct ethtool_ops netdev_ethtool_ops;
 420 static int  rhine_close(struct net_device *dev);
 421 static void rhine_shutdown (struct pci_dev *pdev);
 422
 423 #define RHINE_WAIT_FOR(condition) do {                                  \
 424         int i=1024;                                                     \
 425         while (!(condition) && --i)                                     \
 426                 ;                                                       \
 427         if (debug > 1 && i < 512)                                       \
 428                 printk(KERN_INFO "%s: %4d cycles used @ %s:%d\n",       \
 429                                 DRV_NAME, 1024-i, __func__, __LINE__);  \
 430 } while(0)
 431
 432 static inline u32 get_intr_status(struct net_device *dev)
 433 {
 434         struct rhine_private *rp = netdev_priv(dev);
 435         void __iomem *ioaddr = rp->base;
 436         u32 intr_status;
 437
 438         intr_status = ioread16(ioaddr + IntrStatus);
 439         /* On Rhine-II, Bit 3 indicates Tx descriptor write-back race. */
 440         if (rp->quirks & rqStatusWBRace)
 441                 intr_status |= ioread8(ioaddr + IntrStatus2) << 16;
 442         return intr_status;
 443 }
 444
 445 /*
 446  * Get power related registers into sane state.
 447  * Notify user about past WOL event.
 448  */
 449 static void rhine_power_init(struct net_device *dev)
 450 {
 451         struct rhine_private *rp = netdev_priv(dev);
 452         void __iomem *ioaddr = rp->base;
 453         u16 wolstat;
 454
 455         if (rp->quirks & rqWOL) {
 456                 /* Make sure chip is in power state D0 */
 457                 iowrite8(ioread8(ioaddr + StickyHW) & 0xFC, ioaddr + StickyHW);
 458
 459                 /* Disable "force PME-enable" */
 460                 iowrite8(0x80, ioaddr + WOLcgClr);
 461
 462                 /* Clear power-event config bits (WOL) */
 463                 iowrite8(0xFF, ioaddr + WOLcrClr);
 464                 /* More recent cards can manage two additional patterns */
 465                 if (rp->quirks & rq6patterns)
 466                         iowrite8(0x03, ioaddr + WOLcrClr1);
 467
 468                 /* Save power-event status bits */
 469                 wolstat = ioread8(ioaddr + PwrcsrSet);
 470                 if (rp->quirks & rq6patterns)
 471                         wolstat |= (ioread8(ioaddr + PwrcsrSet1) & 0x03) << 8;
 472
 473                 /* Clear power-event status bits */
 474                 iowrite8(0xFF, ioaddr + PwrcsrClr);
 475                 if (rp->quirks & rq6patterns)
 476                         iowrite8(0x03, ioaddr + PwrcsrClr1);
 477
 478                 if (wolstat) {
 479                         char *reason;
 480                         switch (wolstat) {
 481                         case WOLmagic:
 482                                 reason = "Magic packet";
 483                                 break;
 484                         case WOLlnkon:
 485                                 reason = "Link went up";
 486                                 break;
 487                         case WOLlnkoff:
 488                                 reason = "Link went down";
 489                                 break;
 490                         case WOLucast:
 491                                 reason = "Unicast packet";
 492                                 break;
 493                         case WOLbmcast:
 494                                 reason = "Multicast/broadcast packet";
 495                                 break;
 496                         default:
 497                                 reason = "Unknown";
 498                         }
 499                         printk(KERN_INFO "%s: Woke system up. Reason: %s.\n",
 500                                DRV_NAME, reason);
 501                 }
 502         }
 503 }
 504
 505 static void rhine_chip_reset(struct net_device *dev)
 506 {
 507         struct rhine_private *rp = netdev_priv(dev);
 508         void __iomem *ioaddr = rp->base;
 509
 510         iowrite8(Cmd1Reset, ioaddr + ChipCmd1);
 511         IOSYNC;
 512
 513         if (ioread8(ioaddr + ChipCmd1) & Cmd1Reset) {
 514                 printk(KERN_INFO "%s: Reset not complete yet. "
 515                         "Trying harder.\n", DRV_NAME);
 516
 517                 /* Force reset */
 518                 if (rp->quirks & rqForceReset)
 519                         iowrite8(0x40, ioaddr + MiscCmd);
 520
 521                 /* Reset can take somewhat longer (rare) */
 522                 RHINE_WAIT_FOR(!(ioread8(ioaddr + ChipCmd1) & Cmd1Reset));
 523         }
 524
 525         if (debug > 1)
 526                 printk(KERN_INFO "%s: Reset %s.\n", dev->name,
 527                         (ioread8(ioaddr + ChipCmd1) & Cmd1Reset) ?
 528                         "failed" : "succeeded");
 529 }
 530
 531 #ifdef USE_MMIO
 532 static void enable_mmio(long pioaddr, u32 quirks)
 533 {
 534         int n;
 535         if (quirks & rqRhineI) {
 536                 /* More recent docs say that this bit is reserved ... */
 537                 n = inb(pioaddr + ConfigA) | 0x20;
 538                 outb(n, pioaddr + ConfigA);
 539         } else {
 540                 n = inb(pioaddr + ConfigD) | 0x80;
 541                 outb(n, pioaddr + ConfigD);
 542         }
 543 }
 544 #endif
 545
 546 /*
 547  * Loads bytes 0x00-0x05, 0x6E-0x6F, 0x78-0x7B from EEPROM
 548  * (plus 0x6C for Rhine-I/II)
 549  */
 550 static void __devinit rhine_reload_eeprom(long pioaddr, struct net_device *dev)
 551 {
 552         struct rhine_private *rp = netdev_priv(dev);
 553         void __iomem *ioaddr = rp->base;
 554
 555         outb(0x20, pioaddr + MACRegEEcsr);
 556         RHINE_WAIT_FOR(!(inb(pioaddr + MACRegEEcsr) & 0x20));
 557
 558 #ifdef USE_MMIO
 559         /*
 560          * Reloading from EEPROM overwrites ConfigA-D, so we must re-enable
 561          * MMIO. If reloading EEPROM was done first this could be avoided, but
 562          * it is not known if that still works with the "win98-reboot" problem.
 563          */
 564         enable_mmio(pioaddr, rp->quirks);
 565 #endif
 566
 567         /* Turn off EEPROM-controlled wake-up (magic packet) */
 568         if (rp->quirks & rqWOL)
 569                 iowrite8(ioread8(ioaddr + ConfigA) & 0xFC, ioaddr + ConfigA);
 570
 571 }
 572
 573 #ifdef CONFIG_NET_POLL_CONTROLLER
 574 static void rhine_poll(struct net_device *dev)
 575 {
 576         disable_irq(dev->irq);
 577         rhine_interrupt(dev->irq, (void *)dev);
 578         enable_irq(dev->irq);
 579 }
 580 #endif
 581
 582 static int rhine_napipoll(struct napi_struct *napi, int budget)
 583 {
 584         struct rhine_private *rp = container_of(napi, struct rhine_private, napi);
 585         struct net_device *dev = rp->dev;
 586         void __iomem *ioaddr = rp->base;
 587         int work_done;
 588
 589         work_done = rhine_rx(dev, budget);
 590
 591         if (work_done < budget) {
 592                 napi_complete(napi);
 593
 594                 iowrite16(IntrRxDone | IntrRxErr | IntrRxEmpty| IntrRxOverflow |
 595                           IntrRxDropped | IntrRxNoBuf | IntrTxAborted |
 596                           IntrTxDone | IntrTxError | IntrTxUnderrun |
 597                           IntrPCIErr | IntrStatsMax | IntrLinkChange,
 598                           ioaddr + IntrEnable);
 599         }
 600         return work_done;
 601 }
 602
 603 static void __devinit rhine_hw_init(struct net_device *dev, long pioaddr)
 604 {
 605         struct rhine_private *rp = netdev_priv(dev);
 606
 607         /* Reset the chip to erase previous misconfiguration. */
 608         rhine_chip_reset(dev);
 609
 610         /* Rhine-I needs extra time to recuperate before EEPROM reload */
 611         if (rp->quirks & rqRhineI)
 612                 msleep(5);
 613
 614         /* Reload EEPROM controlled bytes cleared by soft reset */
 615         rhine_reload_eeprom(pioaddr, dev);
 616 }
 617
 618 static const struct net_device_ops rhine_netdev_ops = {
 619         .ndo_open                = rhine_open,
 620         .ndo_stop                = rhine_close,
 621         .ndo_start_xmit          = rhine_start_tx,
 622         .ndo_get_stats           = rhine_get_stats,
 623         .ndo_set_multicast_list  = rhine_set_rx_mode,
 624         .ndo_validate_addr       = eth_validate_addr,
 625         .ndo_set_mac_address     = eth_mac_addr,
 626         .ndo_do_ioctl            = netdev_ioctl,
 627         .ndo_tx_timeout          = rhine_tx_timeout,
 628 #ifdef CONFIG_NET_POLL_CONTROLLER
 629         .ndo_poll_controller     = rhine_poll,
 630 #endif
 631 };
 632
 633 static int __devinit rhine_init_one(struct pci_dev *pdev,
 634                                     const struct pci_device_id *ent)
 635 {
 636         struct net_device *dev;
 637         struct rhine_private *rp;
 638         int i, rc;
 639         u32 quirks;
 640         long pioaddr;
 641         long memaddr;
 642         void __iomem *ioaddr;
 643         int io_size, phy_id;
 644         const char *name;
 645 #ifdef USE_MMIO
 646         int bar = 1;
 647 #else
 648         int bar = 0;
 649 #endif
 650
 651 /* when built into the kernel, we only print version if device is found */
 652 #ifndef MODULE
 653         static int printed_version;
 654         if (!printed_version++)
 655                 printk(version);
 656 #endif
 657
 658         io_size = 256;
 659         phy_id = 0;
 660         quirks = 0;
 661         name = "Rhine";
 662         if (pdev->revision < VTunknown0) {
 663                 quirks = rqRhineI;
 664                 io_size = 128;
 665         }
 666         else if (pdev->revision >= VT6102) {
 667                 quirks = rqWOL | rqForceReset;
 668                 if (pdev->revision < VT6105) {
 669                         name = "Rhine II";
 670                         quirks |= rqStatusWBRace;       /* Rhine-II exclusive */
 671                 }
 672                 else {
 673                         phy_id = 1;     /* Integrated PHY, phy_id fixed to 1 */
 674                         if (pdev->revision >= VT6105_B0)
 675                                 quirks |= rq6patterns;
 676                         if (pdev->revision < VT6105M)
 677                                 name = "Rhine III";
 678                         else
 679                                 name = "Rhine III (Management Adapter)";
 680                 }
 681         }
 682
 683         rc = pci_enable_device(pdev);
 684         if (rc)
 685                 goto err_out;
 686
 687         /* this should always be supported */
 688         rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
 689         if (rc) {
 690                 printk(KERN_ERR "32-bit PCI DMA addresses not supported by "
 691                        "the card!?\n");
 692                 goto err_out;
 693         }
 694
 695         /* sanity check */
 696         if ((pci_resource_len(pdev, 0) < io_size) ||
 697             (pci_resource_len(pdev, 1) < io_size)) {
 698                 rc = -EIO;
 699                 printk(KERN_ERR "Insufficient PCI resources, aborting\n");
 700                 goto err_out;
 701         }
 702
 703         pioaddr = pci_resource_start(pdev, 0);
 704         memaddr = pci_resource_start(pdev, 1);
 705
 706         pci_set_master(pdev);
 707
 708         dev = alloc_etherdev(sizeof(struct rhine_private));
 709         if (!dev) {
 710                 rc = -ENOMEM;
 711                 printk(KERN_ERR "alloc_etherdev failed\n");
 712                 goto err_out;
 713         }
 714         SET_NETDEV_DEV(dev, &pdev->dev);
 715
 716         rp = netdev_priv(dev);
 717         rp->dev = dev;
 718         rp->quirks = quirks;
 719         rp->pioaddr = pioaddr;
 720         rp->pdev = pdev;
 721
 722         rc = pci_request_regions(pdev, DRV_NAME);
 723         if (rc)
 724                 goto err_out_free_netdev;
 725
 726         ioaddr = pci_iomap(pdev, bar, io_size);
 727         if (!ioaddr) {
 728                 rc = -EIO;
 729                 printk(KERN_ERR "ioremap failed for device %s, region 0x%X "
 730                        "@ 0x%lX\n", pci_name(pdev), io_size, memaddr);
 731                 goto err_out_free_res;
 732         }
 733
 734 #ifdef USE_MMIO
 735         enable_mmio(pioaddr, quirks);
 736
 737         /* Check that selected MMIO registers match the PIO ones */
 738         i = 0;
 739         while (mmio_verify_registers[i]) {
 740                 int reg = mmio_verify_registers[i++];
 741                 unsigned char a = inb(pioaddr+reg);
 742                 unsigned char b = readb(ioaddr+reg);
 743                 if (a != b) {
 744                         rc = -EIO;
 745                         printk(KERN_ERR "MMIO do not match PIO [%02x] "
 746                                "(%02x != %02x)\n", reg, a, b);
 747                         goto err_out_unmap;
 748                 }
 749         }
 750 #endif /* USE_MMIO */
 751
 752         dev->base_addr = (unsigned long)ioaddr;
 753         rp->base = ioaddr;
 754
 755         /* Get chip registers into a sane state */
 756         rhine_power_init(dev);
 757         rhine_hw_init(dev, pioaddr);
 758
 759         for (i = 0; i < 6; i++)
 760                 dev->dev_addr[i] = ioread8(ioaddr + StationAddr + i);
 761         memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
 762
 763         if (!is_valid_ether_addr(dev->perm_addr)) {
 764                 rc = -EIO;
 765                 printk(KERN_ERR "Invalid MAC address\n");
 766                 goto err_out_unmap;
 767         }
 768
 769         /* For Rhine-I/II, phy_id is loaded from EEPROM */
 770         if (!phy_id)
 771                 phy_id = ioread8(ioaddr + 0x6C);
 772
 773         dev->irq = pdev->irq;
 774
 775         spin_lock_init(&rp->lock);
 776         rp->mii_if.dev = dev;
 777         rp->mii_if.mdio_read = mdio_read;
 778         rp->mii_if.mdio_write = mdio_write;
 779         rp->mii_if.phy_id_mask = 0x1f;
 780         rp->mii_if.reg_num_mask = 0x1f;
 781
 782         /* The chip-specific entries in the device structure. */
 783         dev->netdev_ops = &rhine_netdev_ops;
 784         dev->ethtool_ops = &netdev_ethtool_ops,
 785         dev->watchdog_timeo = TX_TIMEOUT;
 786
 787         netif_napi_add(dev, &rp->napi, rhine_napipoll, 64);
 788
 789         if (rp->quirks & rqRhineI)
 790                 dev->features |= NETIF_F_SG|NETIF_F_HW_CSUM;
 791
 792         /* dev->name not defined before register_netdev()! */
 793         rc = register_netdev(dev);
 794         if (rc)
 795                 goto err_out_unmap;
 796
 797         printk(KERN_INFO "%s: VIA %s at 0x%lx, %pM, IRQ %d.\n",
 798                dev->name, name,
 799 #ifdef USE_MMIO
 800                memaddr,
 801 #else
 802                (long)ioaddr,
 803 #endif
 804                dev->dev_addr, 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 = netdev_alloc_skb(dev, 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         napi_enable(&rp->napi);
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         napi_disable(&rp->napi);
1194
1195         spin_lock(&rp->lock);
1196
1197         /* clear all descriptors */
1198         free_tbufs(dev);
1199         free_rbufs(dev);
1200         alloc_tbufs(dev);
1201         alloc_rbufs(dev);
1202
1203         /* Reinitialize the hardware. */
1204         rhine_chip_reset(dev);
1205         init_registers(dev);
1206
1207         spin_unlock(&rp->lock);
1208         enable_irq(rp->pdev->irq);
1209
1210         dev->trans_start = jiffies;
1211         dev->stats.tx_errors++;
1212         netif_wake_queue(dev);
1213 }
1214
1215 static int rhine_start_tx(struct sk_buff *skb, struct net_device *dev)
1216 {
1217         struct rhine_private *rp = netdev_priv(dev);
1218         void __iomem *ioaddr = rp->base;
1219         unsigned entry;
1220
1221         /* Caution: the write order is important here, set the field
1222            with the "ownership" bits last. */
1223
1224         /* Calculate the next Tx descriptor entry. */
1225         entry = rp->cur_tx % TX_RING_SIZE;
1226
1227         if (skb_padto(skb, ETH_ZLEN))
1228                 return 0;
1229
1230         rp->tx_skbuff[entry] = skb;
1231
1232         if ((rp->quirks & rqRhineI) &&
1233             (((unsigned long)skb->data & 3) || skb_shinfo(skb)->nr_frags != 0 || skb->ip_summed == CHECKSUM_PARTIAL)) {
1234                 /* Must use alignment buffer. */
1235                 if (skb->len > PKT_BUF_SZ) {
1236                         /* packet too long, drop it */
1237                         dev_kfree_skb(skb);
1238                         rp->tx_skbuff[entry] = NULL;
1239                         dev->stats.tx_dropped++;
1240                         return 0;
1241                 }
1242
1243                 /* Padding is not copied and so must be redone. */
1244                 skb_copy_and_csum_dev(skb, rp->tx_buf[entry]);
1245                 if (skb->len < ETH_ZLEN)
1246                         memset(rp->tx_buf[entry] + skb->len, 0,
1247                                ETH_ZLEN - skb->len);
1248                 rp->tx_skbuff_dma[entry] = 0;
1249                 rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_bufs_dma +
1250                                                       (rp->tx_buf[entry] -
1251                                                        rp->tx_bufs));
1252         } else {
1253                 rp->tx_skbuff_dma[entry] =
1254                         pci_map_single(rp->pdev, skb->data, skb->len,
1255                                        PCI_DMA_TODEVICE);
1256                 rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_skbuff_dma[entry]);
1257         }
1258
1259         rp->tx_ring[entry].desc_length =
1260                 cpu_to_le32(TXDESC | (skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN));
1261
1262         /* lock eth irq */
1263         spin_lock_irq(&rp->lock);
1264         wmb();
1265         rp->tx_ring[entry].tx_status = cpu_to_le32(DescOwn);
1266         wmb();
1267
1268         rp->cur_tx++;
1269
1270         /* Non-x86 Todo: explicitly flush cache lines here. */
1271
1272         /* Wake the potentially-idle transmit channel */
1273         iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1TxDemand,
1274                ioaddr + ChipCmd1);
1275         IOSYNC;
1276
1277         if (rp->cur_tx == rp->dirty_tx + TX_QUEUE_LEN)
1278                 netif_stop_queue(dev);
1279
1280         dev->trans_start = jiffies;
1281
1282         spin_unlock_irq(&rp->lock);
1283
1284         if (debug > 4) {
1285                 printk(KERN_DEBUG "%s: Transmit frame #%d queued in slot %d.\n",
1286                        dev->name, rp->cur_tx-1, entry);
1287         }
1288         return 0;
1289 }
1290
1291 /* The interrupt handler does all of the Rx thread work and cleans up
1292    after the Tx thread. */
1293 static irqreturn_t rhine_interrupt(int irq, void *dev_instance)
1294 {
1295         struct net_device *dev = dev_instance;
1296         struct rhine_private *rp = netdev_priv(dev);
1297         void __iomem *ioaddr = rp->base;
1298         u32 intr_status;
1299         int boguscnt = max_interrupt_work;
1300         int handled = 0;
1301
1302         while ((intr_status = get_intr_status(dev))) {
1303                 handled = 1;
1304
1305                 /* Acknowledge all of the current interrupt sources ASAP. */
1306                 if (intr_status & IntrTxDescRace)
1307                         iowrite8(0x08, ioaddr + IntrStatus2);
1308                 iowrite16(intr_status & 0xffff, ioaddr + IntrStatus);
1309                 IOSYNC;
1310
1311                 if (debug > 4)
1312                         printk(KERN_DEBUG "%s: Interrupt, status %8.8x.\n",
1313                                dev->name, intr_status);
1314
1315                 if (intr_status & (IntrRxDone | IntrRxErr | IntrRxDropped |
1316                                    IntrRxWakeUp | IntrRxEmpty | IntrRxNoBuf)) {
1317                         iowrite16(IntrTxAborted |
1318                                   IntrTxDone | IntrTxError | IntrTxUnderrun |
1319                                   IntrPCIErr | IntrStatsMax | IntrLinkChange,
1320                                   ioaddr + IntrEnable);
1321
1322                         napi_schedule(&rp->napi);
1323                 }
1324
1325                 if (intr_status & (IntrTxErrSummary | IntrTxDone)) {
1326                         if (intr_status & IntrTxErrSummary) {
1327                                 /* Avoid scavenging before Tx engine turned off */
1328                                 RHINE_WAIT_FOR(!(ioread8(ioaddr+ChipCmd) & CmdTxOn));
1329                                 if (debug > 2 &&
1330                                     ioread8(ioaddr+ChipCmd) & CmdTxOn)
1331                                         printk(KERN_WARNING "%s: "
1332                                                "rhine_interrupt() Tx engine "
1333                                                "still on.\n", dev->name);
1334                         }
1335                         rhine_tx(dev);
1336                 }
1337
1338                 /* Abnormal error summary/uncommon events handlers. */
1339                 if (intr_status & (IntrPCIErr | IntrLinkChange |
1340                                    IntrStatsMax | IntrTxError | IntrTxAborted |
1341                                    IntrTxUnderrun | IntrTxDescRace))
1342                         rhine_error(dev, intr_status);
1343
1344                 if (--boguscnt < 0) {
1345                         printk(KERN_WARNING "%s: Too much work at interrupt, "
1346                                "status=%#8.8x.\n",
1347                                dev->name, intr_status);
1348                         break;
1349                 }
1350         }
1351
1352         if (debug > 3)
1353                 printk(KERN_DEBUG "%s: exiting interrupt, status=%8.8x.\n",
1354                        dev->name, ioread16(ioaddr + IntrStatus));
1355         return IRQ_RETVAL(handled);
1356 }
1357
1358 /* This routine is logically part of the interrupt handler, but isolated
1359    for clarity. */
1360 static void rhine_tx(struct net_device *dev)
1361 {
1362         struct rhine_private *rp = netdev_priv(dev);
1363         int txstatus = 0, entry = rp->dirty_tx % TX_RING_SIZE;
1364
1365         spin_lock(&rp->lock);
1366
1367         /* find and cleanup dirty tx descriptors */
1368         while (rp->dirty_tx != rp->cur_tx) {
1369                 txstatus = le32_to_cpu(rp->tx_ring[entry].tx_status);
1370                 if (debug > 6)
1371                         printk(KERN_DEBUG "Tx scavenge %d status %8.8x.\n",
1372                                entry, txstatus);
1373                 if (txstatus & DescOwn)
1374                         break;
1375                 if (txstatus & 0x8000) {
1376                         if (debug > 1)
1377                                 printk(KERN_DEBUG "%s: Transmit error, "
1378                                        "Tx status %8.8x.\n",
1379                                        dev->name, txstatus);
1380                         dev->stats.tx_errors++;
1381                         if (txstatus & 0x0400)
1382                                 dev->stats.tx_carrier_errors++;
1383                         if (txstatus & 0x0200)
1384                                 dev->stats.tx_window_errors++;
1385                         if (txstatus & 0x0100)
1386                                 dev->stats.tx_aborted_errors++;
1387                         if (txstatus & 0x0080)
1388                                 dev->stats.tx_heartbeat_errors++;
1389                         if (((rp->quirks & rqRhineI) && txstatus & 0x0002) ||
1390                             (txstatus & 0x0800) || (txstatus & 0x1000)) {
1391                                 dev->stats.tx_fifo_errors++;
1392                                 rp->tx_ring[entry].tx_status = cpu_to_le32(DescOwn);
1393                                 break; /* Keep the skb - we try again */
1394                         }
1395                         /* Transmitter restarted in 'abnormal' handler. */
1396                 } else {
1397                         if (rp->quirks & rqRhineI)
1398                                 dev->stats.collisions += (txstatus >> 3) & 0x0F;
1399                         else
1400                                 dev->stats.collisions += txstatus & 0x0F;
1401                         if (debug > 6)
1402                                 printk(KERN_DEBUG "collisions: %1.1x:%1.1x\n",
1403                                        (txstatus >> 3) & 0xF,
1404                                        txstatus & 0xF);
1405                         dev->stats.tx_bytes += rp->tx_skbuff[entry]->len;
1406                         dev->stats.tx_packets++;
1407                 }
1408                 /* Free the original skb. */
1409                 if (rp->tx_skbuff_dma[entry]) {
1410                         pci_unmap_single(rp->pdev,
1411                                          rp->tx_skbuff_dma[entry],
1412                                          rp->tx_skbuff[entry]->len,
1413                                          PCI_DMA_TODEVICE);
1414                 }
1415                 dev_kfree_skb_irq(rp->tx_skbuff[entry]);
1416                 rp->tx_skbuff[entry] = NULL;
1417                 entry = (++rp->dirty_tx) % TX_RING_SIZE;
1418         }
1419         if ((rp->cur_tx - rp->dirty_tx) < TX_QUEUE_LEN - 4)
1420                 netif_wake_queue(dev);
1421
1422         spin_unlock(&rp->lock);
1423 }
1424
1425 /* Process up to limit frames from receive ring */
1426 static int rhine_rx(struct net_device *dev, int limit)
1427 {
1428         struct rhine_private *rp = netdev_priv(dev);
1429         int count;
1430         int entry = rp->cur_rx % RX_RING_SIZE;
1431
1432         if (debug > 4) {
1433                 printk(KERN_DEBUG "%s: rhine_rx(), entry %d status %8.8x.\n",
1434                        dev->name, entry,
1435                        le32_to_cpu(rp->rx_head_desc->rx_status));
1436         }
1437
1438         /* If EOP is set on the next entry, it's a new packet. Send it up. */
1439         for (count = 0; count < limit; ++count) {
1440                 struct rx_desc *desc = rp->rx_head_desc;
1441                 u32 desc_status = le32_to_cpu(desc->rx_status);
1442                 int data_size = desc_status >> 16;
1443
1444                 if (desc_status & DescOwn)
1445                         break;
1446
1447                 if (debug > 4)
1448                         printk(KERN_DEBUG "rhine_rx() status is %8.8x.\n",
1449                                desc_status);
1450
1451                 if ((desc_status & (RxWholePkt | RxErr)) != RxWholePkt) {
1452                         if ((desc_status & RxWholePkt) != RxWholePkt) {
1453                                 printk(KERN_WARNING "%s: Oversized Ethernet "
1454                                        "frame spanned multiple buffers, entry "
1455                                        "%#x length %d status %8.8x!\n",
1456                                        dev->name, entry, data_size,
1457                                        desc_status);
1458                                 printk(KERN_WARNING "%s: Oversized Ethernet "
1459                                        "frame %p vs %p.\n", dev->name,
1460                                        rp->rx_head_desc, &rp->rx_ring[entry]);
1461                                 dev->stats.rx_length_errors++;
1462                         } else if (desc_status & RxErr) {
1463                                 /* There was a error. */
1464                                 if (debug > 2)
1465                                         printk(KERN_DEBUG "rhine_rx() Rx "
1466                                                "error was %8.8x.\n",
1467                                                desc_status);
1468                                 dev->stats.rx_errors++;
1469                                 if (desc_status & 0x0030)
1470                                         dev->stats.rx_length_errors++;
1471                                 if (desc_status & 0x0048)
1472                                         dev->stats.rx_fifo_errors++;
1473                                 if (desc_status & 0x0004)
1474                                         dev->stats.rx_frame_errors++;
1475                                 if (desc_status & 0x0002) {
1476                                         /* this can also be updated outside the interrupt handler */
1477                                         spin_lock(&rp->lock);
1478                                         dev->stats.rx_crc_errors++;
1479                                         spin_unlock(&rp->lock);
1480                                 }
1481                         }
1482                 } else {
1483                         struct sk_buff *skb;
1484                         /* Length should omit the CRC */
1485                         int pkt_len = data_size - 4;
1486
1487                         /* Check if the packet is long enough to accept without
1488                            copying to a minimally-sized skbuff. */
1489                         if (pkt_len < rx_copybreak &&
1490                                 (skb = netdev_alloc_skb(dev, pkt_len + NET_IP_ALIGN)) != NULL) {
1491                                 skb_reserve(skb, NET_IP_ALIGN); /* 16 byte align the IP header */
1492                                 pci_dma_sync_single_for_cpu(rp->pdev,
1493                                                             rp->rx_skbuff_dma[entry],
1494                                                             rp->rx_buf_sz,
1495                                                             PCI_DMA_FROMDEVICE);
1496
1497                                 skb_copy_to_linear_data(skb,
1498                                                  rp->rx_skbuff[entry]->data,
1499                                                  pkt_len);
1500                                 skb_put(skb, pkt_len);
1501                                 pci_dma_sync_single_for_device(rp->pdev,
1502                                                                rp->rx_skbuff_dma[entry],
1503                                                                rp->rx_buf_sz,
1504                                                                PCI_DMA_FROMDEVICE);
1505                         } else {
1506                                 skb = rp->rx_skbuff[entry];
1507                                 if (skb == NULL) {
1508                                         printk(KERN_ERR "%s: Inconsistent Rx "
1509                                                "descriptor chain.\n",
1510                                                dev->name);
1511                                         break;
1512                                 }
1513                                 rp->rx_skbuff[entry] = NULL;
1514                                 skb_put(skb, pkt_len);
1515                                 pci_unmap_single(rp->pdev,
1516                                                  rp->rx_skbuff_dma[entry],
1517                                                  rp->rx_buf_sz,
1518                                                  PCI_DMA_FROMDEVICE);
1519                         }
1520                         skb->protocol = eth_type_trans(skb, dev);
1521                         netif_receive_skb(skb);
1522                         dev->stats.rx_bytes += pkt_len;
1523                         dev->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 = netdev_alloc_skb(dev, 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                 dev->stats.rx_crc_errors += ioread16(ioaddr + RxCRCErrs);
1609                 dev->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         dev->stats.rx_crc_errors += ioread16(ioaddr + RxCRCErrs);
1664         dev->stats.rx_missed_errors += ioread16(ioaddr + RxMissed);
1665         clear_tally_counters(ioaddr);
1666         spin_unlock_irqrestore(&rp->lock, flags);
1667
1668         return &dev->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 };
1807
1808 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1809 {
1810         struct rhine_private *rp = netdev_priv(dev);
1811         int rc;
1812
1813         if (!netif_running(dev))
1814                 return -EINVAL;
1815
1816         spin_lock_irq(&rp->lock);
1817         rc = generic_mii_ioctl(&rp->mii_if, if_mii(rq), cmd, NULL);
1818         spin_unlock_irq(&rp->lock);
1819         rhine_set_carrier(&rp->mii_if);
1820
1821         return rc;
1822 }
1823
1824 static int rhine_close(struct net_device *dev)
1825 {
1826         struct rhine_private *rp = netdev_priv(dev);
1827         void __iomem *ioaddr = rp->base;
1828
1829         spin_lock_irq(&rp->lock);
1830
1831         netif_stop_queue(dev);
1832         napi_disable(&rp->napi);
1833
1834         if (debug > 1)
1835                 printk(KERN_DEBUG "%s: Shutting down ethercard, "
1836                        "status was %4.4x.\n",
1837                        dev->name, ioread16(ioaddr + ChipCmd));
1838
1839         /* Switch to loopback mode to avoid hardware races. */
1840         iowrite8(rp->tx_thresh | 0x02, ioaddr + TxConfig);
1841
1842         /* Disable interrupts by clearing the interrupt mask. */
1843         iowrite16(0x0000, ioaddr + IntrEnable);
1844
1845         /* Stop the chip's Tx and Rx processes. */
1846         iowrite16(CmdStop, ioaddr + ChipCmd);
1847
1848         spin_unlock_irq(&rp->lock);
1849
1850         free_irq(rp->pdev->irq, dev);
1851         free_rbufs(dev);
1852         free_tbufs(dev);
1853         free_ring(dev);
1854
1855         return 0;
1856 }
1857
1858
1859 static void __devexit rhine_remove_one(struct pci_dev *pdev)
1860 {
1861         struct net_device *dev = pci_get_drvdata(pdev);
1862         struct rhine_private *rp = netdev_priv(dev);
1863
1864         unregister_netdev(dev);
1865
1866         pci_iounmap(pdev, rp->base);
1867         pci_release_regions(pdev);
1868
1869         free_netdev(dev);
1870         pci_disable_device(pdev);
1871         pci_set_drvdata(pdev, NULL);
1872 }
1873
1874 static void rhine_shutdown (struct pci_dev *pdev)
1875 {
1876         struct net_device *dev = pci_get_drvdata(pdev);
1877         struct rhine_private *rp = netdev_priv(dev);
1878         void __iomem *ioaddr = rp->base;
1879
1880         if (!(rp->quirks & rqWOL))
1881                 return; /* Nothing to do for non-WOL adapters */
1882
1883         rhine_power_init(dev);
1884
1885         /* Make sure we use pattern 0, 1 and not 4, 5 */
1886         if (rp->quirks & rq6patterns)
1887                 iowrite8(0x04, ioaddr + WOLcgClr);
1888
1889         if (rp->wolopts & WAKE_MAGIC) {
1890                 iowrite8(WOLmagic, ioaddr + WOLcrSet);
1891                 /*
1892                  * Turn EEPROM-controlled wake-up back on -- some hardware may
1893                  * not cooperate otherwise.
1894                  */
1895                 iowrite8(ioread8(ioaddr + ConfigA) | 0x03, ioaddr + ConfigA);
1896         }
1897
1898         if (rp->wolopts & (WAKE_BCAST|WAKE_MCAST))
1899                 iowrite8(WOLbmcast, ioaddr + WOLcgSet);
1900
1901         if (rp->wolopts & WAKE_PHY)
1902                 iowrite8(WOLlnkon | WOLlnkoff, ioaddr + WOLcrSet);
1903
1904         if (rp->wolopts & WAKE_UCAST)
1905                 iowrite8(WOLucast, ioaddr + WOLcrSet);
1906
1907         if (rp->wolopts) {
1908                 /* Enable legacy WOL (for old motherboards) */
1909                 iowrite8(0x01, ioaddr + PwcfgSet);
1910                 iowrite8(ioread8(ioaddr + StickyHW) | 0x04, ioaddr + StickyHW);
1911         }
1912
1913         /* Hit power state D3 (sleep) */
1914         if (!avoid_D3)
1915                 iowrite8(ioread8(ioaddr + StickyHW) | 0x03, ioaddr + StickyHW);
1916
1917         /* TODO: Check use of pci_enable_wake() */
1918
1919 }
1920
1921 #ifdef CONFIG_PM
1922 static int rhine_suspend(struct pci_dev *pdev, pm_message_t state)
1923 {
1924         struct net_device *dev = pci_get_drvdata(pdev);
1925         struct rhine_private *rp = netdev_priv(dev);
1926         unsigned long flags;
1927
1928         if (!netif_running(dev))
1929                 return 0;
1930
1931         napi_disable(&rp->napi);
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);