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