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;
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         dev->trans_start = jiffies;
1298
1299         spin_unlock_irqrestore(&rp->lock, flags);
1300
1301         if (debug > 4) {
1302                 printk(KERN_DEBUG "%s: Transmit frame #%d queued in slot %d.\n",
1303                        dev->name, rp->cur_tx-1, entry);
1304         }
1305         return NETDEV_TX_OK;
1306 }
1307
1308 /* The interrupt handler does all of the Rx thread work and cleans up
1309    after the Tx thread. */
1310 static irqreturn_t rhine_interrupt(int irq, void *dev_instance)
1311 {
1312         struct net_device *dev = dev_instance;
1313         struct rhine_private *rp = netdev_priv(dev);
1314         void __iomem *ioaddr = rp->base;
1315         u32 intr_status;
1316         int boguscnt = max_interrupt_work;
1317         int handled = 0;
1318
1319         while ((intr_status = get_intr_status(dev))) {
1320                 handled = 1;
1321
1322                 /* Acknowledge all of the current interrupt sources ASAP. */
1323                 if (intr_status & IntrTxDescRace)
1324                         iowrite8(0x08, ioaddr + IntrStatus2);
1325                 iowrite16(intr_status & 0xffff, ioaddr + IntrStatus);
1326                 IOSYNC;
1327
1328                 if (debug > 4)
1329                         printk(KERN_DEBUG "%s: Interrupt, status %8.8x.\n",
1330                                dev->name, intr_status);
1331
1332                 if (intr_status & (IntrRxDone | IntrRxErr | IntrRxDropped |
1333                                    IntrRxWakeUp | IntrRxEmpty | IntrRxNoBuf)) {
1334                         iowrite16(IntrTxAborted |
1335                                   IntrTxDone | IntrTxError | IntrTxUnderrun |
1336                                   IntrPCIErr | IntrStatsMax | IntrLinkChange,
1337                                   ioaddr + IntrEnable);
1338
1339                         napi_schedule(&rp->napi);
1340                 }
1341
1342                 if (intr_status & (IntrTxErrSummary | IntrTxDone)) {
1343                         if (intr_status & IntrTxErrSummary) {
1344                                 /* Avoid scavenging before Tx engine turned off */
1345                                 RHINE_WAIT_FOR(!(ioread8(ioaddr+ChipCmd) & CmdTxOn));
1346                                 if (debug > 2 &&
1347                                     ioread8(ioaddr+ChipCmd) & CmdTxOn)
1348                                         printk(KERN_WARNING "%s: "
1349                                                "rhine_interrupt() Tx engine "
1350                                                "still on.\n", dev->name);
1351                         }
1352                         rhine_tx(dev);
1353                 }
1354
1355                 /* Abnormal error summary/uncommon events handlers. */
1356                 if (intr_status & (IntrPCIErr | IntrLinkChange |
1357                                    IntrStatsMax | IntrTxError | IntrTxAborted |
1358                                    IntrTxUnderrun | IntrTxDescRace))
1359                         rhine_error(dev, intr_status);
1360
1361                 if (--boguscnt < 0) {
1362                         printk(KERN_WARNING "%s: Too much work at interrupt, "
1363                                "status=%#8.8x.\n",
1364                                dev->name, intr_status);
1365                         break;
1366                 }
1367         }
1368
1369         if (debug > 3)
1370                 printk(KERN_DEBUG "%s: exiting interrupt, status=%8.8x.\n",
1371                        dev->name, ioread16(ioaddr + IntrStatus));
1372         return IRQ_RETVAL(handled);
1373 }
1374
1375 /* This routine is logically part of the interrupt handler, but isolated
1376    for clarity. */
1377 static void rhine_tx(struct net_device *dev)
1378 {
1379         struct rhine_private *rp = netdev_priv(dev);
1380         int txstatus = 0, entry = rp->dirty_tx % TX_RING_SIZE;
1381
1382         spin_lock(&rp->lock);
1383
1384         /* find and cleanup dirty tx descriptors */
1385         while (rp->dirty_tx != rp->cur_tx) {
1386                 txstatus = le32_to_cpu(rp->tx_ring[entry].tx_status);
1387                 if (debug > 6)
1388                         printk(KERN_DEBUG "Tx scavenge %d status %8.8x.\n",
1389                                entry, txstatus);
1390                 if (txstatus & DescOwn)
1391                         break;
1392                 if (txstatus & 0x8000) {
1393                         if (debug > 1)
1394                                 printk(KERN_DEBUG "%s: Transmit error, "
1395                                        "Tx status %8.8x.\n",
1396                                        dev->name, txstatus);
1397                         dev->stats.tx_errors++;
1398                         if (txstatus & 0x0400)
1399                                 dev->stats.tx_carrier_errors++;
1400                         if (txstatus & 0x0200)
1401                                 dev->stats.tx_window_errors++;
1402                         if (txstatus & 0x0100)
1403                                 dev->stats.tx_aborted_errors++;
1404                         if (txstatus & 0x0080)
1405                                 dev->stats.tx_heartbeat_errors++;
1406                         if (((rp->quirks & rqRhineI) && txstatus & 0x0002) ||
1407                             (txstatus & 0x0800) || (txstatus & 0x1000)) {
1408                                 dev->stats.tx_fifo_errors++;
1409                                 rp->tx_ring[entry].tx_status = cpu_to_le32(DescOwn);
1410                                 break; /* Keep the skb - we try again */
1411                         }
1412                         /* Transmitter restarted in 'abnormal' handler. */
1413                 } else {
1414                         if (rp->quirks & rqRhineI)
1415                                 dev->stats.collisions += (txstatus >> 3) & 0x0F;
1416                         else
1417                                 dev->stats.collisions += txstatus & 0x0F;
1418                         if (debug > 6)
1419                                 printk(KERN_DEBUG "collisions: %1.1x:%1.1x\n",
1420                                        (txstatus >> 3) & 0xF,
1421                                        txstatus & 0xF);
1422                         dev->stats.tx_bytes += rp->tx_skbuff[entry]->len;
1423                         dev->stats.tx_packets++;
1424                 }
1425                 /* Free the original skb. */
1426                 if (rp->tx_skbuff_dma[entry]) {
1427                         pci_unmap_single(rp->pdev,
1428                                          rp->tx_skbuff_dma[entry],
1429                                          rp->tx_skbuff[entry]->len,
1430                                          PCI_DMA_TODEVICE);
1431                 }
1432                 dev_kfree_skb_irq(rp->tx_skbuff[entry]);
1433                 rp->tx_skbuff[entry] = NULL;
1434                 entry = (++rp->dirty_tx) % TX_RING_SIZE;
1435         }
1436         if ((rp->cur_tx - rp->dirty_tx) < TX_QUEUE_LEN - 4)
1437                 netif_wake_queue(dev);
1438
1439         spin_unlock(&rp->lock);
1440 }
1441
1442 /* Process up to limit frames from receive ring */
1443 static int rhine_rx(struct net_device *dev, int limit)
1444 {
1445         struct rhine_private *rp = netdev_priv(dev);
1446         int count;
1447         int entry = rp->cur_rx % RX_RING_SIZE;
1448
1449         if (debug > 4) {
1450                 printk(KERN_DEBUG "%s: rhine_rx(), entry %d status %8.8x.\n",
1451                        dev->name, entry,
1452                        le32_to_cpu(rp->rx_head_desc->rx_status));
1453         }
1454
1455         /* If EOP is set on the next entry, it's a new packet. Send it up. */
1456         for (count = 0; count < limit; ++count) {
1457                 struct rx_desc *desc = rp->rx_head_desc;
1458                 u32 desc_status = le32_to_cpu(desc->rx_status);
1459                 int data_size = desc_status >> 16;
1460
1461                 if (desc_status & DescOwn)
1462                         break;
1463
1464                 if (debug > 4)
1465                         printk(KERN_DEBUG "rhine_rx() status is %8.8x.\n",
1466                                desc_status);
1467
1468                 if ((desc_status & (RxWholePkt | RxErr)) != RxWholePkt) {
1469                         if ((desc_status & RxWholePkt) != RxWholePkt) {
1470                                 printk(KERN_WARNING "%s: Oversized Ethernet "
1471                                        "frame spanned multiple buffers, entry "
1472                                        "%#x length %d status %8.8x!\n",
1473                                        dev->name, entry, data_size,
1474                                        desc_status);
1475                                 printk(KERN_WARNING "%s: Oversized Ethernet "
1476                                        "frame %p vs %p.\n", dev->name,
1477                                        rp->rx_head_desc, &rp->rx_ring[entry]);
1478                                 dev->stats.rx_length_errors++;
1479                         } else if (desc_status & RxErr) {
1480                                 /* There was a error. */
1481                                 if (debug > 2)
1482                                         printk(KERN_DEBUG "rhine_rx() Rx "
1483                                                "error was %8.8x.\n",
1484                                                desc_status);
1485                                 dev->stats.rx_errors++;
1486                                 if (desc_status & 0x0030)
1487                                         dev->stats.rx_length_errors++;
1488                                 if (desc_status & 0x0048)
1489                                         dev->stats.rx_fifo_errors++;
1490                                 if (desc_status & 0x0004)
1491                                         dev->stats.rx_frame_errors++;
1492                                 if (desc_status & 0x0002) {
1493                                         /* this can also be updated outside the interrupt handler */
1494                                         spin_lock(&rp->lock);
1495                                         dev->stats.rx_crc_errors++;
1496                                         spin_unlock(&rp->lock);
1497                                 }
1498                         }
1499                 } else {
1500                         struct sk_buff *skb = NULL;
1501                         /* Length should omit the CRC */
1502                         int pkt_len = data_size - 4;
1503
1504                         /* Check if the packet is long enough to accept without
1505                            copying to a minimally-sized skbuff. */
1506                         if (pkt_len < rx_copybreak)
1507                                 skb = netdev_alloc_skb_ip_align(dev, pkt_len);
1508                         if (skb) {
1509                                 pci_dma_sync_single_for_cpu(rp->pdev,
1510                                                             rp->rx_skbuff_dma[entry],
1511                                                             rp->rx_buf_sz,
1512                                                             PCI_DMA_FROMDEVICE);
1513
1514                                 skb_copy_to_linear_data(skb,
1515                                                  rp->rx_skbuff[entry]->data,
1516                                                  pkt_len);
1517                                 skb_put(skb, pkt_len);
1518                                 pci_dma_sync_single_for_device(rp->pdev,
1519                                                                rp->rx_skbuff_dma[entry],
1520                                                                rp->rx_buf_sz,
1521                                                                PCI_DMA_FROMDEVICE);
1522                         } else {
1523                                 skb = rp->rx_skbuff[entry];
1524                                 if (skb == NULL) {
1525                                         printk(KERN_ERR "%s: Inconsistent Rx "
1526                                                "descriptor chain.\n",
1527                                                dev->name);
1528                                         break;
1529                                 }
1530                                 rp->rx_skbuff[entry] = NULL;
1531                                 skb_put(skb, pkt_len);
1532                                 pci_unmap_single(rp->pdev,
1533                                                  rp->rx_skbuff_dma[entry],
1534                                                  rp->rx_buf_sz,
1535                                                  PCI_DMA_FROMDEVICE);
1536                         }
1537                         skb->protocol = eth_type_trans(skb, dev);
1538                         netif_receive_skb(skb);
1539                         dev->stats.rx_bytes += pkt_len;
1540                         dev->stats.rx_packets++;
1541                 }
1542                 entry = (++rp->cur_rx) % RX_RING_SIZE;
1543                 rp->rx_head_desc = &rp->rx_ring[entry];
1544         }
1545
1546         /* Refill the Rx ring buffers. */
1547         for (; rp->cur_rx - rp->dirty_rx > 0; rp->dirty_rx++) {
1548                 struct sk_buff *skb;
1549                 entry = rp->dirty_rx % RX_RING_SIZE;
1550                 if (rp->rx_skbuff[entry] == NULL) {
1551                         skb = netdev_alloc_skb(dev, rp->rx_buf_sz);
1552                         rp->rx_skbuff[entry] = skb;
1553                         if (skb == NULL)
1554                                 break;  /* Better luck next round. */
1555                         skb->dev = dev; /* Mark as being used by this device. */
1556                         rp->rx_skbuff_dma[entry] =
1557                                 pci_map_single(rp->pdev, skb->data,
1558                                                rp->rx_buf_sz,
1559                                                PCI_DMA_FROMDEVICE);
1560                         rp->rx_ring[entry].addr = cpu_to_le32(rp->rx_skbuff_dma[entry]);
1561                 }
1562                 rp->rx_ring[entry].rx_status = cpu_to_le32(DescOwn);
1563         }
1564
1565         return count;
1566 }
1567
1568 /*
1569  * Clears the "tally counters" for CRC errors and missed frames(?).
1570  * It has been reported that some chips need a write of 0 to clear
1571  * these, for others the counters are set to 1 when written to and
1572  * instead cleared when read. So we clear them both ways ...
1573  */
1574 static inline void clear_tally_counters(void __iomem *ioaddr)
1575 {
1576         iowrite32(0, ioaddr + RxMissed);
1577         ioread16(ioaddr + RxCRCErrs);
1578         ioread16(ioaddr + RxMissed);
1579 }
1580
1581 static void rhine_restart_tx(struct net_device *dev) {
1582         struct rhine_private *rp = netdev_priv(dev);
1583         void __iomem *ioaddr = rp->base;
1584         int entry = rp->dirty_tx % TX_RING_SIZE;
1585         u32 intr_status;
1586
1587         /*
1588          * If new errors occured, we need to sort them out before doing Tx.
1589          * In that case the ISR will be back here RSN anyway.
1590          */
1591         intr_status = get_intr_status(dev);
1592
1593         if ((intr_status & IntrTxErrSummary) == 0) {
1594
1595                 /* We know better than the chip where it should continue. */
1596                 iowrite32(rp->tx_ring_dma + entry * sizeof(struct tx_desc),
1597                        ioaddr + TxRingPtr);
1598
1599                 iowrite8(ioread8(ioaddr + ChipCmd) | CmdTxOn,
1600                        ioaddr + ChipCmd);
1601                 iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1TxDemand,
1602                        ioaddr + ChipCmd1);
1603                 IOSYNC;
1604         }
1605         else {
1606                 /* This should never happen */
1607                 if (debug > 1)
1608                         printk(KERN_WARNING "%s: rhine_restart_tx() "
1609                                "Another error occured %8.8x.\n",
1610                                dev->name, intr_status);
1611         }
1612
1613 }
1614
1615 static void rhine_error(struct net_device *dev, int intr_status)
1616 {
1617         struct rhine_private *rp = netdev_priv(dev);
1618         void __iomem *ioaddr = rp->base;
1619
1620         spin_lock(&rp->lock);
1621
1622         if (intr_status & IntrLinkChange)
1623                 rhine_check_media(dev, 0);
1624         if (intr_status & IntrStatsMax) {
1625                 dev->stats.rx_crc_errors += ioread16(ioaddr + RxCRCErrs);
1626                 dev->stats.rx_missed_errors += ioread16(ioaddr + RxMissed);
1627                 clear_tally_counters(ioaddr);
1628         }
1629         if (intr_status & IntrTxAborted) {
1630                 if (debug > 1)
1631                         printk(KERN_INFO "%s: Abort %8.8x, frame dropped.\n",
1632                                dev->name, intr_status);
1633         }
1634         if (intr_status & IntrTxUnderrun) {
1635                 if (rp->tx_thresh < 0xE0)
1636                         iowrite8(rp->tx_thresh += 0x20, ioaddr + TxConfig);
1637                 if (debug > 1)
1638                         printk(KERN_INFO "%s: Transmitter underrun, Tx "
1639                                "threshold now %2.2x.\n",
1640                                dev->name, rp->tx_thresh);
1641         }
1642         if (intr_status & IntrTxDescRace) {
1643                 if (debug > 2)
1644                         printk(KERN_INFO "%s: Tx descriptor write-back race.\n",
1645                                dev->name);
1646         }
1647         if ((intr_status & IntrTxError) &&
1648             (intr_status & (IntrTxAborted |
1649              IntrTxUnderrun | IntrTxDescRace)) == 0) {
1650                 if (rp->tx_thresh < 0xE0) {
1651                         iowrite8(rp->tx_thresh += 0x20, ioaddr + TxConfig);
1652                 }
1653                 if (debug > 1)
1654                         printk(KERN_INFO "%s: Unspecified error. Tx "
1655                                "threshold now %2.2x.\n",
1656                                dev->name, rp->tx_thresh);
1657         }
1658         if (intr_status & (IntrTxAborted | IntrTxUnderrun | IntrTxDescRace |
1659                            IntrTxError))
1660                 rhine_restart_tx(dev);
1661
1662         if (intr_status & ~(IntrLinkChange | IntrStatsMax | IntrTxUnderrun |
1663                             IntrTxError | IntrTxAborted | IntrNormalSummary |
1664                             IntrTxDescRace)) {
1665                 if (debug > 1)
1666                         printk(KERN_ERR "%s: Something Wicked happened! "
1667                                "%8.8x.\n", dev->name, intr_status);
1668         }
1669
1670         spin_unlock(&rp->lock);
1671 }
1672
1673 static struct net_device_stats *rhine_get_stats(struct net_device *dev)
1674 {
1675         struct rhine_private *rp = netdev_priv(dev);
1676         void __iomem *ioaddr = rp->base;
1677         unsigned long flags;
1678
1679         spin_lock_irqsave(&rp->lock, flags);
1680         dev->stats.rx_crc_errors += ioread16(ioaddr + RxCRCErrs);
1681         dev->stats.rx_missed_errors += ioread16(ioaddr + RxMissed);
1682         clear_tally_counters(ioaddr);
1683         spin_unlock_irqrestore(&rp->lock, flags);
1684
1685         return &dev->stats;
1686 }
1687
1688 static void rhine_set_rx_mode(struct net_device *dev)
1689 {
1690         struct rhine_private *rp = netdev_priv(dev);
1691         void __iomem *ioaddr = rp->base;
1692         u32 mc_filter[2];       /* Multicast hash filter */
1693         u8 rx_mode;             /* Note: 0x02=accept runt, 0x01=accept errs */
1694
1695         if (dev->flags & IFF_PROMISC) {         /* Set promiscuous. */
1696                 rx_mode = 0x1C;
1697                 iowrite32(0xffffffff, ioaddr + MulticastFilter0);
1698                 iowrite32(0xffffffff, ioaddr + MulticastFilter1);
1699         } else if ((netdev_mc_count(dev) > multicast_filter_limit) ||
1700                    (dev->flags & IFF_ALLMULTI)) {
1701                 /* Too many to match, or accept all multicasts. */
1702                 iowrite32(0xffffffff, ioaddr + MulticastFilter0);
1703                 iowrite32(0xffffffff, ioaddr + MulticastFilter1);
1704                 rx_mode = 0x0C;
1705         } else {
1706                 struct dev_mc_list *mclist;
1707
1708                 memset(mc_filter, 0, sizeof(mc_filter));
1709                 netdev_for_each_mc_addr(mclist, dev) {
1710                         int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
1711
1712                         mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
1713                 }
1714                 iowrite32(mc_filter[0], ioaddr + MulticastFilter0);
1715                 iowrite32(mc_filter[1], ioaddr + MulticastFilter1);
1716                 rx_mode = 0x0C;
1717         }
1718         iowrite8(rp->rx_thresh | rx_mode, ioaddr + RxConfig);
1719 }
1720
1721 static void netdev_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1722 {
1723         struct rhine_private *rp = netdev_priv(dev);
1724
1725         strcpy(info->driver, DRV_NAME);
1726         strcpy(info->version, DRV_VERSION);
1727         strcpy(info->bus_info, pci_name(rp->pdev));
1728 }
1729
1730 static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1731 {
1732         struct rhine_private *rp = netdev_priv(dev);
1733         int rc;
1734
1735         spin_lock_irq(&rp->lock);
1736         rc = mii_ethtool_gset(&rp->mii_if, cmd);
1737         spin_unlock_irq(&rp->lock);
1738
1739         return rc;
1740 }
1741
1742 static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1743 {
1744         struct rhine_private *rp = netdev_priv(dev);
1745         int rc;
1746
1747         spin_lock_irq(&rp->lock);
1748         rc = mii_ethtool_sset(&rp->mii_if, cmd);
1749         spin_unlock_irq(&rp->lock);
1750         rhine_set_carrier(&rp->mii_if);
1751
1752         return rc;
1753 }
1754
1755 static int netdev_nway_reset(struct net_device *dev)
1756 {
1757         struct rhine_private *rp = netdev_priv(dev);
1758
1759         return mii_nway_restart(&rp->mii_if);
1760 }
1761
1762 static u32 netdev_get_link(struct net_device *dev)
1763 {
1764         struct rhine_private *rp = netdev_priv(dev);
1765
1766         return mii_link_ok(&rp->mii_if);
1767 }
1768
1769 static u32 netdev_get_msglevel(struct net_device *dev)
1770 {
1771         return debug;
1772 }
1773
1774 static void netdev_set_msglevel(struct net_device *dev, u32 value)
1775 {
1776         debug = value;
1777 }
1778
1779 static void rhine_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1780 {
1781         struct rhine_private *rp = netdev_priv(dev);
1782
1783         if (!(rp->quirks & rqWOL))
1784                 return;
1785
1786         spin_lock_irq(&rp->lock);
1787         wol->supported = WAKE_PHY | WAKE_MAGIC |
1788                          WAKE_UCAST | WAKE_MCAST | WAKE_BCAST;  /* Untested */
1789         wol->wolopts = rp->wolopts;
1790         spin_unlock_irq(&rp->lock);
1791 }
1792
1793 static int rhine_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
1794 {
1795         struct rhine_private *rp = netdev_priv(dev);
1796         u32 support = WAKE_PHY | WAKE_MAGIC |
1797                       WAKE_UCAST | WAKE_MCAST | WAKE_BCAST;     /* Untested */
1798
1799         if (!(rp->quirks & rqWOL))
1800                 return -EINVAL;
1801
1802         if (wol->wolopts & ~support)
1803                 return -EINVAL;
1804
1805         spin_lock_irq(&rp->lock);
1806         rp->wolopts = wol->wolopts;
1807         spin_unlock_irq(&rp->lock);
1808
1809         return 0;
1810 }
1811
1812 static const struct ethtool_ops netdev_ethtool_ops = {
1813         .get_drvinfo            = netdev_get_drvinfo,
1814         .get_settings           = netdev_get_settings,
1815         .set_settings           = netdev_set_settings,
1816         .nway_reset             = netdev_nway_reset,
1817         .get_link               = netdev_get_link,
1818         .get_msglevel           = netdev_get_msglevel,
1819         .set_msglevel           = netdev_set_msglevel,
1820         .get_wol                = rhine_get_wol,
1821         .set_wol                = rhine_set_wol,
1822 };
1823
1824 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1825 {
1826         struct rhine_private *rp = netdev_priv(dev);
1827         int rc;
1828
1829         if (!netif_running(dev))
1830                 return -EINVAL;
1831
1832         spin_lock_irq(&rp->lock);
1833         rc = generic_mii_ioctl(&rp->mii_if, if_mii(rq), cmd, NULL);
1834         spin_unlock_irq(&rp->lock);
1835         rhine_set_carrier(&rp->mii_if);
1836
1837         return rc;
1838 }
1839
1840 static int rhine_close(struct net_device *dev)
1841 {
1842         struct rhine_private *rp = netdev_priv(dev);
1843         void __iomem *ioaddr = rp->base;
1844
1845         napi_disable(&rp->napi);
1846         cancel_work_sync(&rp->reset_task);
1847         netif_stop_queue(dev);
1848
1849         spin_lock_irq(&rp->lock);
1850
1851         if (debug > 1)
1852                 printk(KERN_DEBUG "%s: Shutting down ethercard, "
1853                        "status was %4.4x.\n",
1854                        dev->name, ioread16(ioaddr + ChipCmd));
1855
1856         /* Switch to loopback mode to avoid hardware races. */
1857         iowrite8(rp->tx_thresh | 0x02, ioaddr + TxConfig);
1858
1859         /* Disable interrupts by clearing the interrupt mask. */
1860         iowrite16(0x0000, ioaddr + IntrEnable);
1861
1862         /* Stop the chip's Tx and Rx processes. */
1863         iowrite16(CmdStop, ioaddr + ChipCmd);
1864
1865         spin_unlock_irq(&rp->lock);
1866
1867         free_irq(rp->pdev->irq, dev);
1868         free_rbufs(dev);
1869         free_tbufs(dev);
1870         free_ring(dev);
1871
1872         return 0;
1873 }
1874
1875
1876 static void __devexit rhine_remove_one(struct pci_dev *pdev)
1877 {
1878         struct net_device *dev = pci_get_drvdata(pdev);
1879         struct rhine_private *rp = netdev_priv(dev);
1880
1881         unregister_netdev(dev);
1882
1883         pci_iounmap(pdev, rp->base);
1884         pci_release_regions(pdev);
1885
1886         free_netdev(dev);
1887         pci_disable_device(pdev);
1888         pci_set_drvdata(pdev, NULL);
1889 }
1890
1891 static void rhine_shutdown (struct pci_dev *pdev)
1892 {
1893         struct net_device *dev = pci_get_drvdata(pdev);
1894         struct rhine_private *rp = netdev_priv(dev);
1895         void __iomem *ioaddr = rp->base;
1896
1897         if (!(rp->quirks & rqWOL))
1898                 return; /* Nothing to do for non-WOL adapters */
1899
1900         rhine_power_init(dev);
1901
1902         /* Make sure we use pattern 0, 1 and not 4, 5 */
1903         if (rp->quirks & rq6patterns)
1904                 iowrite8(0x04, ioaddr + WOLcgClr);
1905
1906         if (rp->wolopts & WAKE_MAGIC) {
1907                 iowrite8(WOLmagic, ioaddr + WOLcrSet);
1908                 /*
1909                  * Turn EEPROM-controlled wake-up back on -- some hardware may
1910                  * not cooperate otherwise.
1911                  */
1912                 iowrite8(ioread8(ioaddr + ConfigA) | 0x03, ioaddr + ConfigA);
1913         }
1914
1915         if (rp->wolopts & (WAKE_BCAST|WAKE_MCAST))
1916                 iowrite8(WOLbmcast, ioaddr + WOLcgSet);
1917
1918         if (rp->wolopts & WAKE_PHY)
1919                 iowrite8(WOLlnkon | WOLlnkoff, ioaddr + WOLcrSet);
1920
1921         if (rp->wolopts & WAKE_UCAST)
1922                 iowrite8(WOLucast, ioaddr + WOLcrSet);
1923
1924         if (rp->wolopts) {
1925                 /* Enable legacy WOL (for old motherboards) */
1926                 iowrite8(0x01, ioaddr + PwcfgSet);
1927                 iowrite8(ioread8(ioaddr + StickyHW) | 0x04, ioaddr + StickyHW);
1928         }
1929
1930         /* Hit power state D3 (sleep) */
1931         if (!avoid_D3)
1932                 iowrite8(ioread8(ioaddr + StickyHW) | 0x03, ioaddr + StickyHW);
1933
1934         /* TODO: Check use of pci_enable_wake() */
1935
1936 }
1937
1938 #ifdef CONFIG_PM
1939 static int rhine_suspend(struct pci_dev *pdev, pm_message_t state)
1940 {
1941         struct net_device *dev = pci_get_drvdata(pdev);
1942         struct rhine_private *rp = netdev_priv(dev);
1943         unsigned long flags;
1944
1945         if (!netif_running(dev))
1946                 return 0;
1947
1948         napi_disable(&rp->napi);
1949
1950         netif_device_detach(dev);
1951         pci_save_state(pdev);
1952
1953         spin_lock_irqsave(&rp->lock, flags);
1954         rhine_shutdown(pdev);
1955         spin_unlock_irqrestore(&rp->lock, flags);
1956
1957         free_irq(dev->irq, dev);
1958         return 0;
1959 }
1960
1961 static int rhine_resume(struct pci_dev *pdev)
1962 {
1963         struct net_device *dev = pci_get_drvdata(pdev);
1964         struct rhine_private *rp = netdev_priv(dev);
1965         unsigned long flags;
1966         int ret;
1967
1968         if (!netif_running(dev))
1969                 return 0;
1970
1971         if (request_irq(dev->irq, rhine_interrupt, IRQF_SHARED, dev->name, dev))
1972                 printk(KERN_ERR "via-rhine %s: request_irq failed\n", dev->name);
1973
1974         ret = pci_set_power_state(pdev, PCI_D0);
1975         if (debug > 1)
1976                 printk(KERN_INFO "%s: Entering power state D0 %s (%d).\n",
1977                         dev->name, ret ? "failed" : "succeeded", ret);
1978
1979         pci_restore_state(pdev);
1980
1981         spin_lock_irqsave(&rp->lock, flags);
1982 #ifdef USE_MMIO
1983         enable_mmio(rp->pioaddr, rp->quirks);
1984 #endif
1985         rhine_power_init(dev);
1986         free_tbufs(dev);
1987         free_rbufs(dev);
1988         alloc_tbufs(dev);
1989         alloc_rbufs(dev);
1990         init_registers(dev);
1991         spin_unlock_irqrestore(&rp->lock, flags);
1992
1993         netif_device_attach(dev);
1994
1995         return 0;
1996 }
1997 #endif /* CONFIG_PM */
1998
1999 static struct pci_driver rhine_driver = {
2000         .name           = DRV_NAME,
2001         .id_table       = rhine_pci_tbl,
2002         .probe          = rhine_init_one,
2003         .remove         = __devexit_p(rhine_remove_one),
2004 #ifdef CONFIG_PM
2005         .suspend        = rhine_suspend,
2006         .resume         = rhine_resume,
2007 #endif /* CONFIG_PM */
2008         .shutdown =     rhine_shutdown,
2009 };
2010
2011 static struct dmi_system_id __initdata rhine_dmi_table[] = {
2012         {
2013                 .ident = "EPIA-M",
2014                 .matches = {
2015                         DMI_MATCH(DMI_BIOS_VENDOR, "Award Software International, Inc."),
2016                         DMI_MATCH(DMI_BIOS_VERSION, "6.00 PG"),
2017                 },
2018         },
2019         {
2020                 .ident = "KV7",
2021                 .matches = {
2022                         DMI_MATCH(DMI_BIOS_VENDOR, "Phoenix Technologies, LTD"),
2023                         DMI_MATCH(DMI_BIOS_VERSION, "6.00 PG"),
2024                 },
2025         },
2026         { NULL }
2027 };
2028
2029 static int __init rhine_init(void)
2030 {
2031 /* when a module, this is printed whether or not devices are found in probe */
2032 #ifdef MODULE
2033         printk(version);
2034 #endif
2035         if (dmi_check_system(rhine_dmi_table)) {
2036                 /* these BIOSes fail at PXE boot if chip is in D3 */
2037                 avoid_D3 = 1;
2038                 printk(KERN_WARNING "%s: Broken BIOS detected, avoid_D3 "
2039                                     "enabled.\n",
2040                        DRV_NAME);
2041         }
2042         else if (avoid_D3)
2043                 printk(KERN_INFO "%s: avoid_D3 set.\n", DRV_NAME);
2044
2045         return pci_register_driver(&rhine_driver);
2046 }
2047
2048
2049 static void __exit rhine_cleanup(void)
2050 {
2051         pci_unregister_driver(&rhine_driver);
2052 }
2053
2054
2055 module_init(rhine_init);
2056 module_exit(rhine_cleanup);