git.oblomov.eu Git - linux-2.6/blob - drivers/net/pci-skeleton.c

   1 /*
   2
   3         drivers/net/pci-skeleton.c
   4
   5         Maintained by Jeff Garzik <jgarzik@pobox.com>
   6
   7         Original code came from 8139too.c, which in turns was based
   8         originally on Donald Becker's rtl8139.c driver, versions 1.11
   9         and older.  This driver was originally based on rtl8139.c
  10         version 1.07.  Header of rtl8139.c version 1.11:
  11
  12         -----<snip>-----
  13
  14                 Written 1997-2000 by Donald Becker.
  15                 This software may be used and distributed according to the
  16                 terms of the GNU General Public License (GPL), incorporated
  17                 herein by reference.  Drivers based on or derived from this
  18                 code fall under the GPL and must retain the authorship,
  19                 copyright and license notice.  This file is not a complete
  20                 program and may only be used when the entire operating
  21                 system is licensed under the GPL.
  22
  23                 This driver is for boards based on the RTL8129 and RTL8139
  24                 PCI ethernet chips.
  25
  26                 The author may be reached as becker@scyld.com, or C/O Scyld
  27                 Computing Corporation 410 Severn Ave., Suite 210 Annapolis
  28                 MD 21403
  29
  30                 Support and updates available at
  31                 http://www.scyld.com/network/rtl8139.html
  32
  33                 Twister-tuning table provided by Kinston
  34                 <shangh@realtek.com.tw>.
  35
  36         -----<snip>-----
  37
  38         This software may be used and distributed according to the terms
  39         of the GNU General Public License, incorporated herein by reference.
  40
  41
  42 -----------------------------------------------------------------------------
  43
  44                                 Theory of Operation
  45
  46 I. Board Compatibility
  47
  48 This device driver is designed for the RealTek RTL8139 series, the RealTek
  49 Fast Ethernet controllers for PCI and CardBus.  This chip is used on many
  50 low-end boards, sometimes with its markings changed.
  51
  52
  53 II. Board-specific settings
  54
  55 PCI bus devices are configured by the system at boot time, so no jumpers
  56 need to be set on the board.  The system BIOS will assign the
  57 PCI INTA signal to a (preferably otherwise unused) system IRQ line.
  58
  59 III. Driver operation
  60
  61 IIIa. Rx Ring buffers
  62
  63 The receive unit uses a single linear ring buffer rather than the more
  64 common (and more efficient) descriptor-based architecture.  Incoming frames
  65 are sequentially stored into the Rx region, and the host copies them into
  66 skbuffs.
  67
  68 Comment: While it is theoretically possible to process many frames in place,
  69 any delay in Rx processing would cause us to drop frames.  More importantly,
  70 the Linux protocol stack is not designed to operate in this manner.
  71
  72 IIIb. Tx operation
  73
  74 The RTL8139 uses a fixed set of four Tx descriptors in register space.
  75 In a stunningly bad design choice, Tx frames must be 32 bit aligned.  Linux
  76 aligns the IP header on word boundaries, and 14 byte ethernet header means
  77 that almost all frames will need to be copied to an alignment buffer.
  78
  79 IVb. References
  80
  81 http://www.realtek.com.tw/cn/cn.html
  82 http://www.scyld.com/expert/NWay.html
  83
  84 IVc. Errata
  85
  86 */
  87
  88 #include <linux/module.h>
  89 #include <linux/kernel.h>
  90 #include <linux/pci.h>
  91 #include <linux/init.h>
  92 #include <linux/ioport.h>
  93 #include <linux/netdevice.h>
  94 #include <linux/etherdevice.h>
  95 #include <linux/delay.h>
  96 #include <linux/ethtool.h>
  97 #include <linux/mii.h>
  98 #include <linux/crc32.h>
  99 #include <asm/io.h>
 100
 101 #define NETDRV_VERSION          "1.0.1"
 102 #define MODNAME                 "netdrv"
 103 #define NETDRV_DRIVER_LOAD_MSG  "MyVendor Fast Ethernet driver " NETDRV_VERSION " loaded"
 104 #define PFX                     MODNAME ": "
 105
 106 static char version[] __devinitdata =
 107 KERN_INFO NETDRV_DRIVER_LOAD_MSG "\n"
 108 KERN_INFO "  Support available from http://foo.com/bar/baz.html\n";
 109
 110 /* define to 1 to enable PIO instead of MMIO */
 111 #undef USE_IO_OPS
 112
 113 /* define to 1 to enable copious debugging info */
 114 #undef NETDRV_DEBUG
 115
 116 /* define to 1 to disable lightweight runtime debugging checks */
 117 #undef NETDRV_NDEBUG
 118
 119
 120 #ifdef NETDRV_DEBUG
 121 /* note: prints function name for you */
 122 #  define DPRINTK(fmt, args...) printk(KERN_DEBUG "%s: " fmt, __FUNCTION__ , ## args)
 123 #else
 124 #  define DPRINTK(fmt, args...)
 125 #endif
 126
 127 #ifdef NETDRV_NDEBUG
 128 #  define assert(expr) do {} while (0)
 129 #else
 130 #  define assert(expr) \
 131         if(!(expr)) {                                   \
 132         printk( "Assertion failed! %s,%s,%s,line=%d\n", \
 133         #expr,__FILE__,__FUNCTION__,__LINE__);          \
 134         }
 135 #endif
 136
 137
 138 /* A few user-configurable values. */
 139 /* media options */
 140 static int media[] = {-1, -1, -1, -1, -1, -1, -1, -1};
 141
 142 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
 143 static int max_interrupt_work = 20;
 144
 145 /* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
 146    The RTL chips use a 64 element hash table based on the Ethernet CRC.  */
 147 static int multicast_filter_limit = 32;
 148
 149 /* Size of the in-memory receive ring. */
 150 #define RX_BUF_LEN_IDX  2       /* 0==8K, 1==16K, 2==32K, 3==64K */
 151 #define RX_BUF_LEN (8192 << RX_BUF_LEN_IDX)
 152 #define RX_BUF_PAD 16
 153 #define RX_BUF_WRAP_PAD 2048 /* spare padding to handle lack of packet wrap */
 154 #define RX_BUF_TOT_LEN (RX_BUF_LEN + RX_BUF_PAD + RX_BUF_WRAP_PAD)
 155
 156 /* Number of Tx descriptor registers. */
 157 #define NUM_TX_DESC     4
 158
 159 /* max supported ethernet frame size -- must be at least (dev->mtu+14+4).*/
 160 #define MAX_ETH_FRAME_SIZE      1536
 161
 162 /* Size of the Tx bounce buffers -- must be at least (dev->mtu+14+4). */
 163 #define TX_BUF_SIZE     MAX_ETH_FRAME_SIZE
 164 #define TX_BUF_TOT_LEN  (TX_BUF_SIZE * NUM_TX_DESC)
 165
 166 /* PCI Tuning Parameters
 167    Threshold is bytes transferred to chip before transmission starts. */
 168 #define TX_FIFO_THRESH 256      /* In bytes, rounded down to 32 byte units. */
 169
 170 /* The following settings are log_2(bytes)-4:  0 == 16 bytes .. 6==1024, 7==end of packet. */
 171 #define RX_FIFO_THRESH  6       /* Rx buffer level before first PCI xfer.  */
 172 #define RX_DMA_BURST    6       /* Maximum PCI burst, '6' is 1024 */
 173 #define TX_DMA_BURST    6       /* Maximum PCI burst, '6' is 1024 */
 174
 175
 176 /* Operational parameters that usually are not changed. */
 177 /* Time in jiffies before concluding the transmitter is hung. */
 178 #define TX_TIMEOUT  (6*HZ)
 179
 180
 181 enum {
 182         HAS_CHIP_XCVR = 0x020000,
 183         HAS_LNK_CHNG = 0x040000,
 184 };
 185
 186 #define NETDRV_MIN_IO_SIZE 0x80
 187 #define RTL8139B_IO_SIZE 256
 188
 189 #define NETDRV_CAPS     HAS_CHIP_XCVR|HAS_LNK_CHNG
 190
 191 typedef enum {
 192         RTL8139 = 0,
 193         NETDRV_CB,
 194         SMC1211TX,
 195         /*MPX5030,*/
 196         DELTA8139,
 197         ADDTRON8139,
 198 } board_t;
 199
 200
 201 /* indexed by board_t, above */
 202 static struct {
 203         const char *name;
 204 } board_info[] __devinitdata = {
 205         { "RealTek RTL8139 Fast Ethernet" },
 206         { "RealTek RTL8139B PCI/CardBus" },
 207         { "SMC1211TX EZCard 10/100 (RealTek RTL8139)" },
 208 /*      { MPX5030, "Accton MPX5030 (RealTek RTL8139)" },*/
 209         { "Delta Electronics 8139 10/100BaseTX" },
 210         { "Addtron Technolgy 8139 10/100BaseTX" },
 211 };
 212
 213
 214 static struct pci_device_id netdrv_pci_tbl[] = {
 215         {0x10ec, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
 216         {0x10ec, 0x8138, PCI_ANY_ID, PCI_ANY_ID, 0, 0, NETDRV_CB },
 217         {0x1113, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, SMC1211TX },
 218 /*      {0x1113, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, MPX5030 },*/
 219         {0x1500, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, DELTA8139 },
 220         {0x4033, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ADDTRON8139 },
 221         {0,}
 222 };
 223 MODULE_DEVICE_TABLE (pci, netdrv_pci_tbl);
 224
 225
 226 /* The rest of these values should never change. */
 227
 228 /* Symbolic offsets to registers. */
 229 enum NETDRV_registers {
 230         MAC0 = 0,               /* Ethernet hardware address. */
 231         MAR0 = 8,               /* Multicast filter. */
 232         TxStatus0 = 0x10,       /* Transmit status (Four 32bit registers). */
 233         TxAddr0 = 0x20,         /* Tx descriptors (also four 32bit). */
 234         RxBuf = 0x30,
 235         RxEarlyCnt = 0x34,
 236         RxEarlyStatus = 0x36,
 237         ChipCmd = 0x37,
 238         RxBufPtr = 0x38,
 239         RxBufAddr = 0x3A,
 240         IntrMask = 0x3C,
 241         IntrStatus = 0x3E,
 242         TxConfig = 0x40,
 243         ChipVersion = 0x43,
 244         RxConfig = 0x44,
 245         Timer = 0x48,           /* A general-purpose counter. */
 246         RxMissed = 0x4C,        /* 24 bits valid, write clears. */
 247         Cfg9346 = 0x50,
 248         Config0 = 0x51,
 249         Config1 = 0x52,
 250         FlashReg = 0x54,
 251         MediaStatus = 0x58,
 252         Config3 = 0x59,
 253         Config4 = 0x5A,         /* absent on RTL-8139A */
 254         HltClk = 0x5B,
 255         MultiIntr = 0x5C,
 256         TxSummary = 0x60,
 257         BasicModeCtrl = 0x62,
 258         BasicModeStatus = 0x64,
 259         NWayAdvert = 0x66,
 260         NWayLPAR = 0x68,
 261         NWayExpansion = 0x6A,
 262         /* Undocumented registers, but required for proper operation. */
 263         FIFOTMS = 0x70,         /* FIFO Control and test. */
 264         CSCR = 0x74,            /* Chip Status and Configuration Register. */
 265         PARA78 = 0x78,
 266         PARA7c = 0x7c,          /* Magic transceiver parameter register. */
 267         Config5 = 0xD8,         /* absent on RTL-8139A */
 268 };
 269
 270 enum ClearBitMasks {
 271         MultiIntrClear = 0xF000,
 272         ChipCmdClear = 0xE2,
 273         Config1Clear = (1<<7)|(1<<6)|(1<<3)|(1<<2)|(1<<1),
 274 };
 275
 276 enum ChipCmdBits {
 277         CmdReset = 0x10,
 278         CmdRxEnb = 0x08,
 279         CmdTxEnb = 0x04,
 280         RxBufEmpty = 0x01,
 281 };
 282
 283 /* Interrupt register bits, using my own meaningful names. */
 284 enum IntrStatusBits {
 285         PCIErr = 0x8000,
 286         PCSTimeout = 0x4000,
 287         RxFIFOOver = 0x40,
 288         RxUnderrun = 0x20,
 289         RxOverflow = 0x10,
 290         TxErr = 0x08,
 291         TxOK = 0x04,
 292         RxErr = 0x02,
 293         RxOK = 0x01,
 294 };
 295 enum TxStatusBits {
 296         TxHostOwns = 0x2000,
 297         TxUnderrun = 0x4000,
 298         TxStatOK = 0x8000,
 299         TxOutOfWindow = 0x20000000,
 300         TxAborted = 0x40000000,
 301         TxCarrierLost = 0x80000000,
 302 };
 303 enum RxStatusBits {
 304         RxMulticast = 0x8000,
 305         RxPhysical = 0x4000,
 306         RxBroadcast = 0x2000,
 307         RxBadSymbol = 0x0020,
 308         RxRunt = 0x0010,
 309         RxTooLong = 0x0008,
 310         RxCRCErr = 0x0004,
 311         RxBadAlign = 0x0002,
 312         RxStatusOK = 0x0001,
 313 };
 314
 315 /* Bits in RxConfig. */
 316 enum rx_mode_bits {
 317         AcceptErr = 0x20,
 318         AcceptRunt = 0x10,
 319         AcceptBroadcast = 0x08,
 320         AcceptMulticast = 0x04,
 321         AcceptMyPhys = 0x02,
 322         AcceptAllPhys = 0x01,
 323 };
 324
 325 /* Bits in TxConfig. */
 326 enum tx_config_bits {
 327         TxIFG1 = (1 << 25),     /* Interframe Gap Time */
 328         TxIFG0 = (1 << 24),     /* Enabling these bits violates IEEE 802.3 */
 329         TxLoopBack = (1 << 18) | (1 << 17), /* enable loopback test mode */
 330         TxCRC = (1 << 16),      /* DISABLE appending CRC to end of Tx packets */
 331         TxClearAbt = (1 << 0),  /* Clear abort (WO) */
 332         TxDMAShift = 8,         /* DMA burst value (0-7) is shift this many bits */
 333
 334         TxVersionMask = 0x7C800000, /* mask out version bits 30-26, 23 */
 335 };
 336
 337 /* Bits in Config1 */
 338 enum Config1Bits {
 339         Cfg1_PM_Enable = 0x01,
 340         Cfg1_VPD_Enable = 0x02,
 341         Cfg1_PIO = 0x04,
 342         Cfg1_MMIO = 0x08,
 343         Cfg1_LWAKE = 0x10,
 344         Cfg1_Driver_Load = 0x20,
 345         Cfg1_LED0 = 0x40,
 346         Cfg1_LED1 = 0x80,
 347 };
 348
 349 enum RxConfigBits {
 350         /* Early Rx threshold, none or X/16 */
 351         RxCfgEarlyRxNone = 0,
 352         RxCfgEarlyRxShift = 24,
 353
 354         /* rx fifo threshold */
 355         RxCfgFIFOShift = 13,
 356         RxCfgFIFONone = (7 << RxCfgFIFOShift),
 357
 358         /* Max DMA burst */
 359         RxCfgDMAShift = 8,
 360         RxCfgDMAUnlimited = (7 << RxCfgDMAShift),
 361
 362         /* rx ring buffer length */
 363         RxCfgRcv8K = 0,
 364         RxCfgRcv16K = (1 << 11),
 365         RxCfgRcv32K = (1 << 12),
 366         RxCfgRcv64K = (1 << 11) | (1 << 12),
 367
 368         /* Disable packet wrap at end of Rx buffer */
 369         RxNoWrap = (1 << 7),
 370 };
 371
 372
 373 /* Twister tuning parameters from RealTek.
 374    Completely undocumented, but required to tune bad links. */
 375 enum CSCRBits {
 376         CSCR_LinkOKBit = 0x0400,
 377         CSCR_LinkChangeBit = 0x0800,
 378         CSCR_LinkStatusBits = 0x0f000,
 379         CSCR_LinkDownOffCmd = 0x003c0,
 380         CSCR_LinkDownCmd = 0x0f3c0,
 381 };
 382
 383
 384 enum Cfg9346Bits {
 385         Cfg9346_Lock = 0x00,
 386         Cfg9346_Unlock = 0xC0,
 387 };
 388
 389
 390 #define PARA78_default  0x78fa8388
 391 #define PARA7c_default  0xcb38de43      /* param[0][3] */
 392 #define PARA7c_xxx              0xcb38de43
 393 static const unsigned long param[4][4] = {
 394         {0xcb39de43, 0xcb39ce43, 0xfb38de03, 0xcb38de43},
 395         {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
 396         {0xcb39de43, 0xcb39ce43, 0xcb39ce83, 0xcb39ce83},
 397         {0xbb39de43, 0xbb39ce43, 0xbb39ce83, 0xbb39ce83}
 398 };
 399
 400 struct ring_info {
 401         struct sk_buff *skb;
 402         dma_addr_t mapping;
 403 };
 404
 405
 406 typedef enum {
 407         CH_8139 = 0,
 408         CH_8139_K,
 409         CH_8139A,
 410         CH_8139B,
 411         CH_8130,
 412         CH_8139C,
 413 } chip_t;
 414
 415
 416 /* directly indexed by chip_t, above */
 417 static const struct {
 418         const char *name;
 419         u8 version; /* from RTL8139C docs */
 420         u32 RxConfigMask; /* should clear the bits supported by this chip */
 421 } rtl_chip_info[] = {
 422         { "RTL-8139",
 423           0x40,
 424           0xf0fe0040, /* XXX copied from RTL8139A, verify */
 425         },
 426
 427         { "RTL-8139 rev K",
 428           0x60,
 429           0xf0fe0040,
 430         },
 431
 432         { "RTL-8139A",
 433           0x70,
 434           0xf0fe0040,
 435         },
 436
 437         { "RTL-8139B",
 438           0x78,
 439           0xf0fc0040
 440         },
 441
 442         { "RTL-8130",
 443           0x7C,
 444           0xf0fe0040, /* XXX copied from RTL8139A, verify */
 445         },
 446
 447         { "RTL-8139C",
 448           0x74,
 449           0xf0fc0040, /* XXX copied from RTL8139B, verify */
 450         },
 451
 452 };
 453
 454
 455 struct netdrv_private {
 456         board_t board;
 457         void *mmio_addr;
 458         int drv_flags;
 459         struct pci_dev *pci_dev;
 460         struct timer_list timer;        /* Media selection timer. */
 461         unsigned char *rx_ring;
 462         unsigned int cur_rx;    /* Index into the Rx buffer of next Rx pkt. */
 463         unsigned int tx_flag;
 464         atomic_t cur_tx;
 465         atomic_t dirty_tx;
 466         /* The saved address of a sent-in-place packet/buffer, for skfree(). */
 467         struct ring_info tx_info[NUM_TX_DESC];
 468         unsigned char *tx_buf[NUM_TX_DESC];     /* Tx bounce buffers */
 469         unsigned char *tx_bufs; /* Tx bounce buffer region. */
 470         dma_addr_t rx_ring_dma;
 471         dma_addr_t tx_bufs_dma;
 472         char phys[4];           /* MII device addresses. */
 473         char twistie, twist_row, twist_col;     /* Twister tune state. */
 474         unsigned int full_duplex:1;     /* Full-duplex operation requested. */
 475         unsigned int duplex_lock:1;
 476         unsigned int default_port:4;    /* Last dev->if_port value. */
 477         unsigned int media2:4;  /* Secondary monitored media port. */
 478         unsigned int medialock:1;       /* Don't sense media type. */
 479         unsigned int mediasense:1;      /* Media sensing in progress. */
 480         spinlock_t lock;
 481         chip_t chipset;
 482 };
 483
 484 MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
 485 MODULE_DESCRIPTION ("Skeleton for a PCI Fast Ethernet driver");
 486 MODULE_LICENSE("GPL");
 487 module_param(multicast_filter_limit, int, 0);
 488 module_param(max_interrupt_work, int, 0);
 489 module_param_array(media, int, NULL, 0);
 490 MODULE_PARM_DESC (multicast_filter_limit, "pci-skeleton maximum number of filtered multicast addresses");
 491 MODULE_PARM_DESC (max_interrupt_work, "pci-skeleton maximum events handled per interrupt");
 492 MODULE_PARM_DESC (media, "pci-skeleton: Bits 0-3: media type, bit 17: full duplex");
 493
 494 static int read_eeprom (void *ioaddr, int location, int addr_len);
 495 static int netdrv_open (struct net_device *dev);
 496 static int mdio_read (struct net_device *dev, int phy_id, int location);
 497 static void mdio_write (struct net_device *dev, int phy_id, int location,
 498                         int val);
 499 static void netdrv_timer (unsigned long data);
 500 static void netdrv_tx_timeout (struct net_device *dev);
 501 static void netdrv_init_ring (struct net_device *dev);
 502 static int netdrv_start_xmit (struct sk_buff *skb,
 503                                struct net_device *dev);
 504 static irqreturn_t netdrv_interrupt (int irq, void *dev_instance);
 505 static int netdrv_close (struct net_device *dev);
 506 static int netdrv_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);
 507 static void netdrv_set_rx_mode (struct net_device *dev);
 508 static void netdrv_hw_start (struct net_device *dev);
 509
 510
 511 #ifdef USE_IO_OPS
 512
 513 #define NETDRV_R8(reg)          inb (((unsigned long)ioaddr) + (reg))
 514 #define NETDRV_R16(reg)         inw (((unsigned long)ioaddr) + (reg))
 515 #define NETDRV_R32(reg)         ((unsigned long) inl (((unsigned long)ioaddr) + (reg)))
 516 #define NETDRV_W8(reg, val8)    outb ((val8), ((unsigned long)ioaddr) + (reg))
 517 #define NETDRV_W16(reg, val16)  outw ((val16), ((unsigned long)ioaddr) + (reg))
 518 #define NETDRV_W32(reg, val32)  outl ((val32), ((unsigned long)ioaddr) + (reg))
 519 #define NETDRV_W8_F             NETDRV_W8
 520 #define NETDRV_W16_F            NETDRV_W16
 521 #define NETDRV_W32_F            NETDRV_W32
 522 #undef readb
 523 #undef readw
 524 #undef readl
 525 #undef writeb
 526 #undef writew
 527 #undef writel
 528 #define readb(addr) inb((unsigned long)(addr))
 529 #define readw(addr) inw((unsigned long)(addr))
 530 #define readl(addr) inl((unsigned long)(addr))
 531 #define writeb(val,addr) outb((val),(unsigned long)(addr))
 532 #define writew(val,addr) outw((val),(unsigned long)(addr))
 533 #define writel(val,addr) outl((val),(unsigned long)(addr))
 534
 535 #else
 536
 537 /* write MMIO register, with flush */
 538 /* Flush avoids rtl8139 bug w/ posted MMIO writes */
 539 #define NETDRV_W8_F(reg, val8)  do { writeb ((val8), ioaddr + (reg)); readb (ioaddr + (reg)); } while (0)
 540 #define NETDRV_W16_F(reg, val16)        do { writew ((val16), ioaddr + (reg)); readw (ioaddr + (reg)); } while (0)
 541 #define NETDRV_W32_F(reg, val32)        do { writel ((val32), ioaddr + (reg)); readl (ioaddr + (reg)); } while (0)
 542
 543
 544 #ifdef MMIO_FLUSH_AUDIT_COMPLETE
 545
 546 /* write MMIO register */
 547 #define NETDRV_W8(reg, val8)    writeb ((val8), ioaddr + (reg))
 548 #define NETDRV_W16(reg, val16)  writew ((val16), ioaddr + (reg))
 549 #define NETDRV_W32(reg, val32)  writel ((val32), ioaddr + (reg))
 550
 551 #else
 552
 553 /* write MMIO register, then flush */
 554 #define NETDRV_W8               NETDRV_W8_F
 555 #define NETDRV_W16              NETDRV_W16_F
 556 #define NETDRV_W32              NETDRV_W32_F
 557
 558 #endif /* MMIO_FLUSH_AUDIT_COMPLETE */
 559
 560 /* read MMIO register */
 561 #define NETDRV_R8(reg)          readb (ioaddr + (reg))
 562 #define NETDRV_R16(reg)         readw (ioaddr + (reg))
 563 #define NETDRV_R32(reg)         ((unsigned long) readl (ioaddr + (reg)))
 564
 565 #endif /* USE_IO_OPS */
 566
 567
 568 static const u16 netdrv_intr_mask =
 569         PCIErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver |
 570         TxErr | TxOK | RxErr | RxOK;
 571
 572 static const unsigned int netdrv_rx_config =
 573           RxCfgEarlyRxNone | RxCfgRcv32K | RxNoWrap |
 574           (RX_FIFO_THRESH << RxCfgFIFOShift) |
 575           (RX_DMA_BURST << RxCfgDMAShift);
 576
 577
 578 static int __devinit netdrv_init_board (struct pci_dev *pdev,
 579                                          struct net_device **dev_out,
 580                                          void **ioaddr_out)
 581 {
 582         void *ioaddr = NULL;
 583         struct net_device *dev;
 584         struct netdrv_private *tp;
 585         int rc, i;
 586         u32 pio_start, pio_end, pio_flags, pio_len;
 587         unsigned long mmio_start, mmio_end, mmio_flags, mmio_len;
 588         u32 tmp;
 589
 590         DPRINTK ("ENTER\n");
 591
 592         assert (pdev != NULL);
 593         assert (ioaddr_out != NULL);
 594
 595         *ioaddr_out = NULL;
 596         *dev_out = NULL;
 597
 598         /* dev zeroed in alloc_etherdev */
 599         dev = alloc_etherdev (sizeof (*tp));
 600         if (dev == NULL) {
 601                 dev_err(&pdev->dev, "unable to alloc new ethernet\n");
 602                 DPRINTK ("EXIT, returning -ENOMEM\n");
 603                 return -ENOMEM;
 604         }
 605         SET_NETDEV_DEV(dev, &pdev->dev);
 606         tp = netdev_priv(dev);
 607
 608         /* enable device (incl. PCI PM wakeup), and bus-mastering */
 609         rc = pci_enable_device (pdev);
 610         if (rc)
 611                 goto err_out;
 612
 613         pio_start = pci_resource_start (pdev, 0);
 614         pio_end = pci_resource_end (pdev, 0);
 615         pio_flags = pci_resource_flags (pdev, 0);
 616         pio_len = pci_resource_len (pdev, 0);
 617
 618         mmio_start = pci_resource_start (pdev, 1);
 619         mmio_end = pci_resource_end (pdev, 1);
 620         mmio_flags = pci_resource_flags (pdev, 1);
 621         mmio_len = pci_resource_len (pdev, 1);
 622
 623         /* set this immediately, we need to know before
 624          * we talk to the chip directly */
 625         DPRINTK("PIO region size == 0x%02X\n", pio_len);
 626         DPRINTK("MMIO region size == 0x%02lX\n", mmio_len);
 627
 628         /* make sure PCI base addr 0 is PIO */
 629         if (!(pio_flags & IORESOURCE_IO)) {
 630                 dev_err(&pdev->dev, "region #0 not a PIO resource, aborting\n");
 631                 rc = -ENODEV;
 632                 goto err_out;
 633         }
 634
 635         /* make sure PCI base addr 1 is MMIO */
 636         if (!(mmio_flags & IORESOURCE_MEM)) {
 637                 dev_err(&pdev->dev, "region #1 not an MMIO resource, aborting\n");
 638                 rc = -ENODEV;
 639                 goto err_out;
 640         }
 641
 642         /* check for weird/broken PCI region reporting */
 643         if ((pio_len < NETDRV_MIN_IO_SIZE) ||
 644             (mmio_len < NETDRV_MIN_IO_SIZE)) {
 645                 dev_err(&pdev->dev, "Invalid PCI region size(s), aborting\n");
 646                 rc = -ENODEV;
 647                 goto err_out;
 648         }
 649
 650         rc = pci_request_regions (pdev, MODNAME);
 651         if (rc)
 652                 goto err_out;
 653
 654         pci_set_master (pdev);
 655
 656 #ifdef USE_IO_OPS
 657         ioaddr = (void *) pio_start;
 658 #else
 659         /* ioremap MMIO region */
 660         ioaddr = ioremap (mmio_start, mmio_len);
 661         if (ioaddr == NULL) {
 662                 dev_err(&pdev->dev, "cannot remap MMIO, aborting\n");
 663                 rc = -EIO;
 664                 goto err_out_free_res;
 665         }
 666 #endif /* USE_IO_OPS */
 667
 668         /* Soft reset the chip. */
 669         NETDRV_W8 (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear) | CmdReset);
 670
 671         /* Check that the chip has finished the reset. */
 672         for (i = 1000; i > 0; i--)
 673                 if ((NETDRV_R8 (ChipCmd) & CmdReset) == 0)
 674                         break;
 675                 else
 676                         udelay (10);
 677
 678         /* Bring the chip out of low-power mode. */
 679         /* <insert device-specific code here> */
 680
 681 #ifndef USE_IO_OPS
 682         /* sanity checks -- ensure PIO and MMIO registers agree */
 683         assert (inb (pio_start+Config0) == readb (ioaddr+Config0));
 684         assert (inb (pio_start+Config1) == readb (ioaddr+Config1));
 685         assert (inb (pio_start+TxConfig) == readb (ioaddr+TxConfig));
 686         assert (inb (pio_start+RxConfig) == readb (ioaddr+RxConfig));
 687 #endif /* !USE_IO_OPS */
 688
 689         /* identify chip attached to board */
 690         tmp = NETDRV_R8 (ChipVersion);
 691         for (i = ARRAY_SIZE (rtl_chip_info) - 1; i >= 0; i--)
 692                 if (tmp == rtl_chip_info[i].version) {
 693                         tp->chipset = i;
 694                         goto match;
 695                 }
 696
 697         /* if unknown chip, assume array element #0, original RTL-8139 in this case */
 698         dev_printk (KERN_DEBUG, &pdev->dev,
 699                 "unknown chip version, assuming RTL-8139\n");
 700         dev_printk (KERN_DEBUG, &pdev->dev, "TxConfig = 0x%lx\n",
 701                 NETDRV_R32 (TxConfig));
 702         tp->chipset = 0;
 703
 704 match:
 705         DPRINTK ("chipset id (%d) == index %d, '%s'\n",
 706                 tmp,
 707                 tp->chipset,
 708                 rtl_chip_info[tp->chipset].name);
 709
 710         rc = register_netdev (dev);
 711         if (rc)
 712                 goto err_out_unmap;
 713
 714         DPRINTK ("EXIT, returning 0\n");
 715         *ioaddr_out = ioaddr;
 716         *dev_out = dev;
 717         return 0;
 718
 719 err_out_unmap:
 720 #ifndef USE_IO_OPS
 721         iounmap(ioaddr);
 722 err_out_free_res:
 723 #endif
 724         pci_release_regions (pdev);
 725 err_out:
 726         free_netdev (dev);
 727         DPRINTK ("EXIT, returning %d\n", rc);
 728         return rc;
 729 }
 730
 731
 732 static int __devinit netdrv_init_one (struct pci_dev *pdev,
 733                                        const struct pci_device_id *ent)
 734 {
 735         struct net_device *dev = NULL;
 736         struct netdrv_private *tp;
 737         int i, addr_len, option;
 738         void *ioaddr = NULL;
 739         static int board_idx = -1;
 740         DECLARE_MAC_BUF(mac);
 741
 742 /* when built into the kernel, we only print version if device is found */
 743 #ifndef MODULE
 744         static int printed_version;
 745         if (!printed_version++)
 746                 printk(version);
 747 #endif
 748
 749         DPRINTK ("ENTER\n");
 750
 751         assert (pdev != NULL);
 752         assert (ent != NULL);
 753
 754         board_idx++;
 755
 756         i = netdrv_init_board (pdev, &dev, &ioaddr);
 757         if (i < 0) {
 758                 DPRINTK ("EXIT, returning %d\n", i);
 759                 return i;
 760         }
 761
 762         tp = netdev_priv(dev);
 763
 764         assert (ioaddr != NULL);
 765         assert (dev != NULL);
 766         assert (tp != NULL);
 767
 768         addr_len = read_eeprom (ioaddr, 0, 8) == 0x8129 ? 8 : 6;
 769         for (i = 0; i < 3; i++)
 770                 ((u16 *) (dev->dev_addr))[i] =
 771                     le16_to_cpu (read_eeprom (ioaddr, i + 7, addr_len));
 772
 773         /* The Rtl8139-specific entries in the device structure. */
 774         dev->open = netdrv_open;
 775         dev->hard_start_xmit = netdrv_start_xmit;
 776         dev->stop = netdrv_close;
 777         dev->set_multicast_list = netdrv_set_rx_mode;
 778         dev->do_ioctl = netdrv_ioctl;
 779         dev->tx_timeout = netdrv_tx_timeout;
 780         dev->watchdog_timeo = TX_TIMEOUT;
 781
 782         dev->irq = pdev->irq;
 783         dev->base_addr = (unsigned long) ioaddr;
 784
 785         /* dev->priv/tp zeroed and aligned in alloc_etherdev */
 786         tp = netdev_priv(dev);
 787
 788         /* note: tp->chipset set in netdrv_init_board */
 789         tp->drv_flags = PCI_COMMAND_IO | PCI_COMMAND_MEMORY |
 790                         PCI_COMMAND_MASTER | NETDRV_CAPS;
 791         tp->pci_dev = pdev;
 792         tp->board = ent->driver_data;
 793         tp->mmio_addr = ioaddr;
 794         spin_lock_init(&tp->lock);
 795
 796         pci_set_drvdata(pdev, dev);
 797
 798         tp->phys[0] = 32;
 799
 800         printk (KERN_INFO "%s: %s at 0x%lx, %sIRQ %d\n",
 801                 dev->name,
 802                 board_info[ent->driver_data].name,
 803                 dev->base_addr,
 804                 print_mac(mac, dev->dev_addr),
 805                 dev->irq);
 806
 807         printk (KERN_DEBUG "%s:  Identified 8139 chip type '%s'\n",
 808                 dev->name, rtl_chip_info[tp->chipset].name);
 809
 810         /* Put the chip into low-power mode. */
 811         NETDRV_W8_F (Cfg9346, Cfg9346_Unlock);
 812
 813         /* The lower four bits are the media type. */
 814         option = (board_idx > 7) ? 0 : media[board_idx];
 815         if (option > 0) {
 816                 tp->full_duplex = (option & 0x200) ? 1 : 0;
 817                 tp->default_port = option & 15;
 818                 if (tp->default_port)
 819                         tp->medialock = 1;
 820         }
 821
 822         if (tp->full_duplex) {
 823                 printk (KERN_INFO
 824                         "%s: Media type forced to Full Duplex.\n",
 825                         dev->name);
 826                 mdio_write (dev, tp->phys[0], MII_ADVERTISE, ADVERTISE_FULL);
 827                 tp->duplex_lock = 1;
 828         }
 829
 830         DPRINTK ("EXIT - returning 0\n");
 831         return 0;
 832 }
 833
 834
 835 static void __devexit netdrv_remove_one (struct pci_dev *pdev)
 836 {
 837         struct net_device *dev = pci_get_drvdata (pdev);
 838         struct netdrv_private *np;
 839
 840         DPRINTK ("ENTER\n");
 841
 842         assert (dev != NULL);
 843
 844         np = netdev_priv(dev);
 845         assert (np != NULL);
 846
 847         unregister_netdev (dev);
 848
 849 #ifndef USE_IO_OPS
 850         iounmap (np->mmio_addr);
 851 #endif /* !USE_IO_OPS */
 852
 853         pci_release_regions (pdev);
 854
 855         free_netdev (dev);
 856
 857         pci_set_drvdata (pdev, NULL);
 858
 859         pci_disable_device (pdev);
 860
 861         DPRINTK ("EXIT\n");
 862 }
 863
 864
 865 /* Serial EEPROM section. */
 866
 867 /*  EEPROM_Ctrl bits. */
 868 #define EE_SHIFT_CLK    0x04    /* EEPROM shift clock. */
 869 #define EE_CS                   0x08    /* EEPROM chip select. */
 870 #define EE_DATA_WRITE   0x02    /* EEPROM chip data in. */
 871 #define EE_WRITE_0              0x00
 872 #define EE_WRITE_1              0x02
 873 #define EE_DATA_READ    0x01    /* EEPROM chip data out. */
 874 #define EE_ENB                  (0x80 | EE_CS)
 875
 876 /* Delay between EEPROM clock transitions.
 877    No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
 878  */
 879
 880 #define eeprom_delay()  readl(ee_addr)
 881
 882 /* The EEPROM commands include the alway-set leading bit. */
 883 #define EE_WRITE_CMD    (5)
 884 #define EE_READ_CMD             (6)
 885 #define EE_ERASE_CMD    (7)
 886
 887 static int __devinit read_eeprom (void *ioaddr, int location, int addr_len)
 888 {
 889         int i;
 890         unsigned retval = 0;
 891         void *ee_addr = ioaddr + Cfg9346;
 892         int read_cmd = location | (EE_READ_CMD << addr_len);
 893
 894         DPRINTK ("ENTER\n");
 895
 896         writeb (EE_ENB & ~EE_CS, ee_addr);
 897         writeb (EE_ENB, ee_addr);
 898         eeprom_delay ();
 899
 900         /* Shift the read command bits out. */
 901         for (i = 4 + addr_len; i >= 0; i--) {
 902                 int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
 903                 writeb (EE_ENB | dataval, ee_addr);
 904                 eeprom_delay ();
 905                 writeb (EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
 906                 eeprom_delay ();
 907         }
 908         writeb (EE_ENB, ee_addr);
 909         eeprom_delay ();
 910
 911         for (i = 16; i > 0; i--) {
 912                 writeb (EE_ENB | EE_SHIFT_CLK, ee_addr);
 913                 eeprom_delay ();
 914                 retval =
 915                     (retval << 1) | ((readb (ee_addr) & EE_DATA_READ) ? 1 :
 916                                      0);
 917                 writeb (EE_ENB, ee_addr);
 918                 eeprom_delay ();
 919         }
 920
 921         /* Terminate the EEPROM access. */
 922         writeb (~EE_CS, ee_addr);
 923         eeprom_delay ();
 924
 925         DPRINTK ("EXIT - returning %d\n", retval);
 926         return retval;
 927 }
 928
 929 /* MII serial management: mostly bogus for now. */
 930 /* Read and write the MII management registers using software-generated
 931    serial MDIO protocol.
 932    The maximum data clock rate is 2.5 Mhz.  The minimum timing is usually
 933    met by back-to-back PCI I/O cycles, but we insert a delay to avoid
 934    "overclocking" issues. */
 935 #define MDIO_DIR                0x80
 936 #define MDIO_DATA_OUT   0x04
 937 #define MDIO_DATA_IN    0x02
 938 #define MDIO_CLK                0x01
 939 #define MDIO_WRITE0 (MDIO_DIR)
 940 #define MDIO_WRITE1 (MDIO_DIR | MDIO_DATA_OUT)
 941
 942 #define mdio_delay()    readb(mdio_addr)
 943
 944
 945 static char mii_2_8139_map[8] = {
 946         BasicModeCtrl,
 947         BasicModeStatus,
 948         0,
 949         0,
 950         NWayAdvert,
 951         NWayLPAR,
 952         NWayExpansion,
 953         0
 954 };
 955
 956
 957 /* Syncronize the MII management interface by shifting 32 one bits out. */
 958 static void mdio_sync (void *mdio_addr)
 959 {
 960         int i;
 961
 962         DPRINTK ("ENTER\n");
 963
 964         for (i = 32; i >= 0; i--) {
 965                 writeb (MDIO_WRITE1, mdio_addr);
 966                 mdio_delay ();
 967                 writeb (MDIO_WRITE1 | MDIO_CLK, mdio_addr);
 968                 mdio_delay ();
 969         }
 970
 971         DPRINTK ("EXIT\n");
 972 }
 973
 974
 975 static int mdio_read (struct net_device *dev, int phy_id, int location)
 976 {
 977         struct netdrv_private *tp = netdev_priv(dev);
 978         void *mdio_addr = tp->mmio_addr + Config4;
 979         int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
 980         int retval = 0;
 981         int i;
 982
 983         DPRINTK ("ENTER\n");
 984
 985         if (phy_id > 31) {      /* Really a 8139.  Use internal registers. */
 986                 DPRINTK ("EXIT after directly using 8139 internal regs\n");
 987                 return location < 8 && mii_2_8139_map[location] ?
 988                     readw (tp->mmio_addr + mii_2_8139_map[location]) : 0;
 989         }
 990         mdio_sync (mdio_addr);
 991         /* Shift the read command bits out. */
 992         for (i = 15; i >= 0; i--) {
 993                 int dataval = (mii_cmd & (1 << i)) ? MDIO_DATA_OUT : 0;
 994
 995                 writeb (MDIO_DIR | dataval, mdio_addr);
 996                 mdio_delay ();
 997                 writeb (MDIO_DIR | dataval | MDIO_CLK, mdio_addr);
 998                 mdio_delay ();
 999         }
1000
1001         /* Read the two transition, 16 data, and wire-idle bits. */
1002         for (i = 19; i > 0; i--) {
1003                 writeb (0, mdio_addr);
1004                 mdio_delay ();
1005                 retval =
1006                     (retval << 1) | ((readb (mdio_addr) & MDIO_DATA_IN) ? 1
1007                                      : 0);
1008                 writeb (MDIO_CLK, mdio_addr);
1009                 mdio_delay ();
1010         }
1011
1012         DPRINTK ("EXIT, returning %d\n", (retval >> 1) & 0xffff);
1013         return (retval >> 1) & 0xffff;
1014 }
1015
1016
1017 static void mdio_write (struct net_device *dev, int phy_id, int location,
1018                         int value)
1019 {
1020         struct netdrv_private *tp = netdev_priv(dev);
1021         void *mdio_addr = tp->mmio_addr + Config4;
1022         int mii_cmd =
1023             (0x5002 << 16) | (phy_id << 23) | (location << 18) | value;
1024         int i;
1025
1026         DPRINTK ("ENTER\n");
1027
1028         if (phy_id > 31) {      /* Really a 8139.  Use internal registers. */
1029                 if (location < 8 && mii_2_8139_map[location]) {
1030                         writew (value,
1031                                 tp->mmio_addr + mii_2_8139_map[location]);
1032                         readw (tp->mmio_addr + mii_2_8139_map[location]);
1033                 }
1034                 DPRINTK ("EXIT after directly using 8139 internal regs\n");
1035                 return;
1036         }
1037         mdio_sync (mdio_addr);
1038
1039         /* Shift the command bits out. */
1040         for (i = 31; i >= 0; i--) {
1041                 int dataval =
1042                     (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
1043                 writeb (dataval, mdio_addr);
1044                 mdio_delay ();
1045                 writeb (dataval | MDIO_CLK, mdio_addr);
1046                 mdio_delay ();
1047         }
1048
1049         /* Clear out extra bits. */
1050         for (i = 2; i > 0; i--) {
1051                 writeb (0, mdio_addr);
1052                 mdio_delay ();
1053                 writeb (MDIO_CLK, mdio_addr);
1054                 mdio_delay ();
1055         }
1056
1057         DPRINTK ("EXIT\n");
1058 }
1059
1060
1061 static int netdrv_open (struct net_device *dev)
1062 {
1063         struct netdrv_private *tp = netdev_priv(dev);
1064         int retval;
1065 #ifdef NETDRV_DEBUG
1066         void *ioaddr = tp->mmio_addr;
1067 #endif
1068
1069         DPRINTK ("ENTER\n");
1070
1071         retval = request_irq (dev->irq, netdrv_interrupt, IRQF_SHARED, dev->name, dev);
1072         if (retval) {
1073                 DPRINTK ("EXIT, returning %d\n", retval);
1074                 return retval;
1075         }
1076
1077         tp->tx_bufs = pci_alloc_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1078                                            &tp->tx_bufs_dma);
1079         tp->rx_ring = pci_alloc_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1080                                            &tp->rx_ring_dma);
1081         if (tp->tx_bufs == NULL || tp->rx_ring == NULL) {
1082                 free_irq(dev->irq, dev);
1083
1084                 if (tp->tx_bufs)
1085                         pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1086                                             tp->tx_bufs, tp->tx_bufs_dma);
1087                 if (tp->rx_ring)
1088                         pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1089                                             tp->rx_ring, tp->rx_ring_dma);
1090
1091                 DPRINTK ("EXIT, returning -ENOMEM\n");
1092                 return -ENOMEM;
1093
1094         }
1095
1096         tp->full_duplex = tp->duplex_lock;
1097         tp->tx_flag = (TX_FIFO_THRESH << 11) & 0x003f0000;
1098
1099         netdrv_init_ring (dev);
1100         netdrv_hw_start (dev);
1101
1102         DPRINTK ("%s: netdrv_open() ioaddr %#lx IRQ %d"
1103                         " GP Pins %2.2x %s-duplex.\n",
1104                         dev->name, pci_resource_start (tp->pci_dev, 1),
1105                         dev->irq, NETDRV_R8 (MediaStatus),
1106                         tp->full_duplex ? "full" : "half");
1107
1108         /* Set the timer to switch to check for link beat and perhaps switch
1109            to an alternate media type. */
1110         init_timer (&tp->timer);
1111         tp->timer.expires = jiffies + 3 * HZ;
1112         tp->timer.data = (unsigned long) dev;
1113         tp->timer.function = &netdrv_timer;
1114         add_timer (&tp->timer);
1115
1116         DPRINTK ("EXIT, returning 0\n");
1117         return 0;
1118 }
1119
1120
1121 /* Start the hardware at open or resume. */
1122 static void netdrv_hw_start (struct net_device *dev)
1123 {
1124         struct netdrv_private *tp = netdev_priv(dev);
1125         void *ioaddr = tp->mmio_addr;
1126         u32 i;
1127
1128         DPRINTK ("ENTER\n");
1129
1130         /* Soft reset the chip. */
1131         NETDRV_W8 (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear) | CmdReset);
1132         udelay (100);
1133
1134         /* Check that the chip has finished the reset. */
1135         for (i = 1000; i > 0; i--)
1136                 if ((NETDRV_R8 (ChipCmd) & CmdReset) == 0)
1137                         break;
1138
1139         /* Restore our idea of the MAC address. */
1140         NETDRV_W32_F (MAC0 + 0, cpu_to_le32 (*(u32 *) (dev->dev_addr + 0)));
1141         NETDRV_W32_F (MAC0 + 4, cpu_to_le32 (*(u32 *) (dev->dev_addr + 4)));
1142
1143         /* Must enable Tx/Rx before setting transfer thresholds! */
1144         NETDRV_W8_F (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear) |
1145                            CmdRxEnb | CmdTxEnb);
1146
1147         i = netdrv_rx_config |
1148             (NETDRV_R32 (RxConfig) & rtl_chip_info[tp->chipset].RxConfigMask);
1149         NETDRV_W32_F (RxConfig, i);
1150
1151         /* Check this value: the documentation for IFG contradicts ifself. */
1152         NETDRV_W32 (TxConfig, (TX_DMA_BURST << TxDMAShift));
1153
1154         /* unlock Config[01234] and BMCR register writes */
1155         NETDRV_W8_F (Cfg9346, Cfg9346_Unlock);
1156         udelay (10);
1157
1158         tp->cur_rx = 0;
1159
1160         /* Lock Config[01234] and BMCR register writes */
1161         NETDRV_W8_F (Cfg9346, Cfg9346_Lock);
1162         udelay (10);
1163
1164         /* init Rx ring buffer DMA address */
1165         NETDRV_W32_F (RxBuf, tp->rx_ring_dma);
1166
1167         /* init Tx buffer DMA addresses */
1168         for (i = 0; i < NUM_TX_DESC; i++)
1169                 NETDRV_W32_F (TxAddr0 + (i * 4), tp->tx_bufs_dma + (tp->tx_buf[i] - tp->tx_bufs));
1170
1171         NETDRV_W32_F (RxMissed, 0);
1172
1173         netdrv_set_rx_mode (dev);
1174
1175         /* no early-rx interrupts */
1176         NETDRV_W16 (MultiIntr, NETDRV_R16 (MultiIntr) & MultiIntrClear);
1177
1178         /* make sure RxTx has started */
1179         NETDRV_W8_F (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear) |
1180                            CmdRxEnb | CmdTxEnb);
1181
1182         /* Enable all known interrupts by setting the interrupt mask. */
1183         NETDRV_W16_F (IntrMask, netdrv_intr_mask);
1184
1185         netif_start_queue (dev);
1186
1187         DPRINTK ("EXIT\n");
1188 }
1189
1190
1191 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
1192 static void netdrv_init_ring (struct net_device *dev)
1193 {
1194         struct netdrv_private *tp = netdev_priv(dev);
1195         int i;
1196
1197         DPRINTK ("ENTER\n");
1198
1199         tp->cur_rx = 0;
1200         atomic_set (&tp->cur_tx, 0);
1201         atomic_set (&tp->dirty_tx, 0);
1202
1203         for (i = 0; i < NUM_TX_DESC; i++) {
1204                 tp->tx_info[i].skb = NULL;
1205                 tp->tx_info[i].mapping = 0;
1206                 tp->tx_buf[i] = &tp->tx_bufs[i * TX_BUF_SIZE];
1207         }
1208
1209         DPRINTK ("EXIT\n");
1210 }
1211
1212
1213 static void netdrv_timer (unsigned long data)
1214 {
1215         struct net_device *dev = (struct net_device *) data;
1216         struct netdrv_private *tp = netdev_priv(dev);
1217         void *ioaddr = tp->mmio_addr;
1218         int next_tick = 60 * HZ;
1219         int mii_lpa;
1220
1221         mii_lpa = mdio_read (dev, tp->phys[0], MII_LPA);
1222
1223         if (!tp->duplex_lock && mii_lpa != 0xffff) {
1224                 int duplex = (mii_lpa & LPA_100FULL)
1225                     || (mii_lpa & 0x01C0) == 0x0040;
1226                 if (tp->full_duplex != duplex) {
1227                         tp->full_duplex = duplex;
1228                         printk (KERN_INFO
1229                                 "%s: Setting %s-duplex based on MII #%d link"
1230                                 " partner ability of %4.4x.\n", dev->name,
1231                                 tp->full_duplex ? "full" : "half",
1232                                 tp->phys[0], mii_lpa);
1233                         NETDRV_W8 (Cfg9346, Cfg9346_Unlock);
1234                         NETDRV_W8 (Config1, tp->full_duplex ? 0x60 : 0x20);
1235                         NETDRV_W8 (Cfg9346, Cfg9346_Lock);
1236                 }
1237         }
1238
1239         DPRINTK ("%s: Media selection tick, Link partner %4.4x.\n",
1240                  dev->name, NETDRV_R16 (NWayLPAR));
1241         DPRINTK ("%s:  Other registers are IntMask %4.4x IntStatus %4.4x"
1242                  " RxStatus %4.4x.\n", dev->name,
1243                  NETDRV_R16 (IntrMask),
1244                  NETDRV_R16 (IntrStatus),
1245                  NETDRV_R32 (RxEarlyStatus));
1246         DPRINTK ("%s:  Chip config %2.2x %2.2x.\n",
1247                  dev->name, NETDRV_R8 (Config0),
1248                  NETDRV_R8 (Config1));
1249
1250         tp->timer.expires = jiffies + next_tick;
1251         add_timer (&tp->timer);
1252 }
1253
1254
1255 static void netdrv_tx_clear (struct net_device *dev)
1256 {
1257         int i;
1258         struct netdrv_private *tp = netdev_priv(dev);
1259
1260         atomic_set (&tp->cur_tx, 0);
1261         atomic_set (&tp->dirty_tx, 0);
1262
1263         /* Dump the unsent Tx packets. */
1264         for (i = 0; i < NUM_TX_DESC; i++) {
1265                 struct ring_info *rp = &tp->tx_info[i];
1266                 if (rp->mapping != 0) {
1267                         pci_unmap_single (tp->pci_dev, rp->mapping,
1268                                           rp->skb->len, PCI_DMA_TODEVICE);
1269                         rp->mapping = 0;
1270                 }
1271                 if (rp->skb) {
1272                         dev_kfree_skb (rp->skb);
1273                         rp->skb = NULL;
1274                         dev->stats.tx_dropped++;
1275                 }
1276         }
1277 }
1278
1279
1280 static void netdrv_tx_timeout (struct net_device *dev)
1281 {
1282         struct netdrv_private *tp = netdev_priv(dev);
1283         void *ioaddr = tp->mmio_addr;
1284         int i;
1285         u8 tmp8;
1286         unsigned long flags;
1287
1288         DPRINTK ("%s: Transmit timeout, status %2.2x %4.4x "
1289                  "media %2.2x.\n", dev->name,
1290                  NETDRV_R8 (ChipCmd),
1291                  NETDRV_R16 (IntrStatus),
1292                  NETDRV_R8 (MediaStatus));
1293
1294         /* disable Tx ASAP, if not already */
1295         tmp8 = NETDRV_R8 (ChipCmd);
1296         if (tmp8 & CmdTxEnb)
1297                 NETDRV_W8 (ChipCmd, tmp8 & ~CmdTxEnb);
1298
1299         /* Disable interrupts by clearing the interrupt mask. */
1300         NETDRV_W16 (IntrMask, 0x0000);
1301
1302         /* Emit info to figure out what went wrong. */
1303         printk (KERN_DEBUG "%s: Tx queue start entry %d  dirty entry %d.\n",
1304                 dev->name, atomic_read (&tp->cur_tx),
1305                 atomic_read (&tp->dirty_tx));
1306         for (i = 0; i < NUM_TX_DESC; i++)
1307                 printk (KERN_DEBUG "%s:  Tx descriptor %d is %8.8lx.%s\n",
1308                         dev->name, i, NETDRV_R32 (TxStatus0 + (i * 4)),
1309                         i == atomic_read (&tp->dirty_tx) % NUM_TX_DESC ?
1310                                 " (queue head)" : "");
1311
1312         /* Stop a shared interrupt from scavenging while we are. */
1313         spin_lock_irqsave (&tp->lock, flags);
1314
1315         netdrv_tx_clear (dev);
1316
1317         spin_unlock_irqrestore (&tp->lock, flags);
1318
1319         /* ...and finally, reset everything */
1320         netdrv_hw_start (dev);
1321
1322         netif_wake_queue (dev);
1323 }
1324
1325
1326
1327 static int netdrv_start_xmit (struct sk_buff *skb, struct net_device *dev)
1328 {
1329         struct netdrv_private *tp = netdev_priv(dev);
1330         void *ioaddr = tp->mmio_addr;
1331         int entry;
1332
1333         /* Calculate the next Tx descriptor entry. */
1334         entry = atomic_read (&tp->cur_tx) % NUM_TX_DESC;
1335
1336         assert (tp->tx_info[entry].skb == NULL);
1337         assert (tp->tx_info[entry].mapping == 0);
1338
1339         tp->tx_info[entry].skb = skb;
1340         /* tp->tx_info[entry].mapping = 0; */
1341         skb_copy_from_linear_data(skb, tp->tx_buf[entry], skb->len);
1342
1343         /* Note: the chip doesn't have auto-pad! */
1344         NETDRV_W32 (TxStatus0 + (entry * sizeof(u32)),
1345                  tp->tx_flag | (skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN));
1346
1347         dev->trans_start = jiffies;
1348         atomic_inc (&tp->cur_tx);
1349         if ((atomic_read (&tp->cur_tx) - atomic_read (&tp->dirty_tx)) >= NUM_TX_DESC)
1350                 netif_stop_queue (dev);
1351
1352         DPRINTK ("%s: Queued Tx packet at %p size %u to slot %d.\n",
1353                  dev->name, skb->data, skb->len, entry);
1354
1355         return 0;
1356 }
1357
1358
1359 static void netdrv_tx_interrupt (struct net_device *dev,
1360                                   struct netdrv_private *tp,
1361                                   void *ioaddr)
1362 {
1363         int cur_tx, dirty_tx, tx_left;
1364
1365         assert (dev != NULL);
1366         assert (tp != NULL);
1367         assert (ioaddr != NULL);
1368
1369         dirty_tx = atomic_read (&tp->dirty_tx);
1370
1371         cur_tx = atomic_read (&tp->cur_tx);
1372         tx_left = cur_tx - dirty_tx;
1373         while (tx_left > 0) {
1374                 int entry = dirty_tx % NUM_TX_DESC;
1375                 int txstatus;
1376
1377                 txstatus = NETDRV_R32 (TxStatus0 + (entry * sizeof (u32)));
1378
1379                 if (!(txstatus & (TxStatOK | TxUnderrun | TxAborted)))
1380                         break;  /* It still hasn't been Txed */
1381
1382                 /* Note: TxCarrierLost is always asserted at 100mbps. */
1383                 if (txstatus & (TxOutOfWindow | TxAborted)) {
1384                         /* There was an major error, log it. */
1385                         DPRINTK ("%s: Transmit error, Tx status %8.8x.\n",
1386                                  dev->name, txstatus);
1387                         dev->stats.tx_errors++;
1388                         if (txstatus & TxAborted) {
1389                                 dev->stats.tx_aborted_errors++;
1390                                 NETDRV_W32 (TxConfig, TxClearAbt | (TX_DMA_BURST << TxDMAShift));
1391                         }
1392                         if (txstatus & TxCarrierLost)
1393                                 dev->stats.tx_carrier_errors++;
1394                         if (txstatus & TxOutOfWindow)
1395                                 dev->stats.tx_window_errors++;
1396                 } else {
1397                         if (txstatus & TxUnderrun) {
1398                                 /* Add 64 to the Tx FIFO threshold. */
1399                                 if (tp->tx_flag < 0x00300000)
1400                                         tp->tx_flag += 0x00020000;
1401                                 dev->stats.tx_fifo_errors++;
1402                         }
1403                         dev->stats.collisions += (txstatus >> 24) & 15;
1404                         dev->stats.tx_bytes += txstatus & 0x7ff;
1405                         dev->stats.tx_packets++;
1406                 }
1407
1408                 /* Free the original skb. */
1409                 if (tp->tx_info[entry].mapping != 0) {
1410                         pci_unmap_single(tp->pci_dev,
1411                                          tp->tx_info[entry].mapping,
1412                                          tp->tx_info[entry].skb->len,
1413                                          PCI_DMA_TODEVICE);
1414                         tp->tx_info[entry].mapping = 0;
1415                 }
1416                 dev_kfree_skb_irq (tp->tx_info[entry].skb);
1417                 tp->tx_info[entry].skb = NULL;
1418                 dirty_tx++;
1419                 if (dirty_tx < 0) { /* handle signed int overflow */
1420                         atomic_sub (cur_tx, &tp->cur_tx); /* XXX racy? */
1421                         dirty_tx = cur_tx - tx_left + 1;
1422                 }
1423                 if (netif_queue_stopped (dev))
1424                         netif_wake_queue (dev);
1425
1426                 cur_tx = atomic_read (&tp->cur_tx);
1427                 tx_left = cur_tx - dirty_tx;
1428
1429         }
1430
1431 #ifndef NETDRV_NDEBUG
1432         if (atomic_read (&tp->cur_tx) - dirty_tx > NUM_TX_DESC) {
1433                 printk (KERN_ERR
1434                   "%s: Out-of-sync dirty pointer, %d vs. %d.\n",
1435                      dev->name, dirty_tx, atomic_read (&tp->cur_tx));
1436                 dirty_tx += NUM_TX_DESC;
1437         }
1438 #endif /* NETDRV_NDEBUG */
1439
1440         atomic_set (&tp->dirty_tx, dirty_tx);
1441 }
1442
1443
1444 /* TODO: clean this up!  Rx reset need not be this intensive */
1445 static void netdrv_rx_err (u32 rx_status, struct net_device *dev,
1446                             struct netdrv_private *tp, void *ioaddr)
1447 {
1448         u8 tmp8;
1449         int tmp_work = 1000;
1450
1451         DPRINTK ("%s: Ethernet frame had errors, status %8.8x.\n",
1452                  dev->name, rx_status);
1453         if (rx_status & RxTooLong) {
1454                 DPRINTK ("%s: Oversized Ethernet frame, status %4.4x!\n",
1455                          dev->name, rx_status);
1456                 /* A.C.: The chip hangs here. */
1457         }
1458         dev->stats.rx_errors++;
1459         if (rx_status & (RxBadSymbol | RxBadAlign))
1460                 dev->stats.rx_frame_errors++;
1461         if (rx_status & (RxRunt | RxTooLong))
1462                 dev->stats.rx_length_errors++;
1463         if (rx_status & RxCRCErr)
1464                 dev->stats.rx_crc_errors++;
1465         /* Reset the receiver, based on RealTek recommendation. (Bug?) */
1466         tp->cur_rx = 0;
1467
1468         /* disable receive */
1469         tmp8 = NETDRV_R8 (ChipCmd) & ChipCmdClear;
1470         NETDRV_W8_F (ChipCmd, tmp8 | CmdTxEnb);
1471
1472         /* A.C.: Reset the multicast list. */
1473         netdrv_set_rx_mode (dev);
1474
1475         /* XXX potentially temporary hack to
1476          * restart hung receiver */
1477         while (--tmp_work > 0) {
1478                 tmp8 = NETDRV_R8 (ChipCmd);
1479                 if ((tmp8 & CmdRxEnb) && (tmp8 & CmdTxEnb))
1480                         break;
1481                 NETDRV_W8_F (ChipCmd,
1482                           (tmp8 & ChipCmdClear) | CmdRxEnb | CmdTxEnb);
1483         }
1484
1485         /* G.S.: Re-enable receiver */
1486         /* XXX temporary hack to work around receiver hang */
1487         netdrv_set_rx_mode (dev);
1488
1489         if (tmp_work <= 0)
1490                 printk (KERN_WARNING PFX "tx/rx enable wait too long\n");
1491 }
1492
1493
1494 /* The data sheet doesn't describe the Rx ring at all, so I'm guessing at the
1495    field alignments and semantics. */
1496 static void netdrv_rx_interrupt (struct net_device *dev,
1497                                   struct netdrv_private *tp, void *ioaddr)
1498 {
1499         unsigned char *rx_ring;
1500         u16 cur_rx;
1501
1502         assert (dev != NULL);
1503         assert (tp != NULL);
1504         assert (ioaddr != NULL);
1505
1506         rx_ring = tp->rx_ring;
1507         cur_rx = tp->cur_rx;
1508
1509         DPRINTK ("%s: In netdrv_rx(), current %4.4x BufAddr %4.4x,"
1510                  " free to %4.4x, Cmd %2.2x.\n", dev->name, cur_rx,
1511                  NETDRV_R16 (RxBufAddr),
1512                  NETDRV_R16 (RxBufPtr), NETDRV_R8 (ChipCmd));
1513
1514         while ((NETDRV_R8 (ChipCmd) & RxBufEmpty) == 0) {
1515                 int ring_offset = cur_rx % RX_BUF_LEN;
1516                 u32 rx_status;
1517                 unsigned int rx_size;
1518                 unsigned int pkt_size;
1519                 struct sk_buff *skb;
1520
1521                 /* read size+status of next frame from DMA ring buffer */
1522                 rx_status = le32_to_cpu (*(u32 *) (rx_ring + ring_offset));
1523                 rx_size = rx_status >> 16;
1524                 pkt_size = rx_size - 4;
1525
1526                 DPRINTK ("%s:  netdrv_rx() status %4.4x, size %4.4x,"
1527                          " cur %4.4x.\n", dev->name, rx_status,
1528                          rx_size, cur_rx);
1529 #if defined(NETDRV_DEBUG) && (NETDRV_DEBUG > 2)
1530                 {
1531                         int i;
1532                         DPRINTK ("%s: Frame contents ", dev->name);
1533                         for (i = 0; i < 70; i++)
1534                                 printk (" %2.2x",
1535                                         rx_ring[ring_offset + i]);
1536                         printk (".\n");
1537                 }
1538 #endif
1539
1540                 /* If Rx err or invalid rx_size/rx_status received
1541                  * (which happens if we get lost in the ring),
1542                  * Rx process gets reset, so we abort any further
1543                  * Rx processing.
1544                  */
1545                 if ((rx_size > (MAX_ETH_FRAME_SIZE+4)) ||
1546                     (!(rx_status & RxStatusOK))) {
1547                         netdrv_rx_err (rx_status, dev, tp, ioaddr);
1548                         return;
1549                 }
1550
1551                 /* Malloc up new buffer, compatible with net-2e. */
1552                 /* Omit the four octet CRC from the length. */
1553
1554                 /* TODO: consider allocating skb's outside of
1555                  * interrupt context, both to speed interrupt processing,
1556                  * and also to reduce the chances of having to
1557                  * drop packets here under memory pressure.
1558                  */
1559
1560                 skb = dev_alloc_skb (pkt_size + 2);
1561                 if (skb) {
1562                         skb_reserve (skb, 2);   /* 16 byte align the IP fields. */
1563
1564                         skb_copy_to_linear_data (skb, &rx_ring[ring_offset + 4], pkt_size);
1565                         skb_put (skb, pkt_size);
1566
1567                         skb->protocol = eth_type_trans (skb, dev);
1568                         netif_rx (skb);
1569                         dev->last_rx = jiffies;
1570                         dev->stats.rx_bytes += pkt_size;
1571                         dev->stats.rx_packets++;
1572                 } else {
1573                         printk (KERN_WARNING
1574                                 "%s: Memory squeeze, dropping packet.\n",
1575                                 dev->name);
1576                         dev->stats.rx_dropped++;
1577                 }
1578
1579                 cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
1580                 NETDRV_W16_F (RxBufPtr, cur_rx - 16);
1581         }
1582
1583         DPRINTK ("%s: Done netdrv_rx(), current %4.4x BufAddr %4.4x,"
1584                  " free to %4.4x, Cmd %2.2x.\n", dev->name, cur_rx,
1585                  NETDRV_R16 (RxBufAddr),
1586                  NETDRV_R16 (RxBufPtr), NETDRV_R8 (ChipCmd));
1587
1588         tp->cur_rx = cur_rx;
1589 }
1590
1591
1592 static void netdrv_weird_interrupt (struct net_device *dev,
1593                                      struct netdrv_private *tp,
1594                                      void *ioaddr,
1595                                      int status, int link_changed)
1596 {
1597         printk (KERN_DEBUG "%s: Abnormal interrupt, status %8.8x.\n",
1598                 dev->name, status);
1599
1600         assert (dev != NULL);
1601         assert (tp != NULL);
1602         assert (ioaddr != NULL);
1603
1604         /* Update the error count. */
1605         dev->stats.rx_missed_errors += NETDRV_R32 (RxMissed);
1606         NETDRV_W32 (RxMissed, 0);
1607
1608         if ((status & RxUnderrun) && link_changed &&
1609             (tp->drv_flags & HAS_LNK_CHNG)) {
1610                 /* Really link-change on new chips. */
1611                 int lpar = NETDRV_R16 (NWayLPAR);
1612                 int duplex = (lpar & 0x0100) || (lpar & 0x01C0) == 0x0040
1613                                 || tp->duplex_lock;
1614                 if (tp->full_duplex != duplex) {
1615                         tp->full_duplex = duplex;
1616                         NETDRV_W8 (Cfg9346, Cfg9346_Unlock);
1617                         NETDRV_W8 (Config1, tp->full_duplex ? 0x60 : 0x20);
1618                         NETDRV_W8 (Cfg9346, Cfg9346_Lock);
1619                 }
1620                 status &= ~RxUnderrun;
1621         }
1622
1623         /* XXX along with netdrv_rx_err, are we double-counting errors? */
1624         if (status &
1625             (RxUnderrun | RxOverflow | RxErr | RxFIFOOver))
1626                 dev->stats.rx_errors++;
1627
1628         if (status & (PCSTimeout))
1629                 dev->stats.rx_length_errors++;
1630         if (status & (RxUnderrun | RxFIFOOver))
1631                 dev->stats.rx_fifo_errors++;
1632         if (status & RxOverflow) {
1633                 dev->stats.rx_over_errors++;
1634                 tp->cur_rx = NETDRV_R16 (RxBufAddr) % RX_BUF_LEN;
1635                 NETDRV_W16_F (RxBufPtr, tp->cur_rx - 16);
1636         }
1637         if (status & PCIErr) {
1638                 u16 pci_cmd_status;
1639                 pci_read_config_word (tp->pci_dev, PCI_STATUS, &pci_cmd_status);
1640
1641                 printk (KERN_ERR "%s: PCI Bus error %4.4x.\n",
1642                         dev->name, pci_cmd_status);
1643         }
1644 }
1645
1646
1647 /* The interrupt handler does all of the Rx thread work and cleans up
1648    after the Tx thread. */
1649 static irqreturn_t netdrv_interrupt (int irq, void *dev_instance)
1650 {
1651         struct net_device *dev = (struct net_device *) dev_instance;
1652         struct netdrv_private *tp = netdev_priv(dev);
1653         int boguscnt = max_interrupt_work;
1654         void *ioaddr = tp->mmio_addr;
1655         int status = 0, link_changed = 0; /* avoid bogus "uninit" warning */
1656         int handled = 0;
1657
1658         spin_lock (&tp->lock);
1659
1660         do {
1661                 status = NETDRV_R16 (IntrStatus);
1662
1663                 /* h/w no longer present (hotplug?) or major error, bail */
1664                 if (status == 0xFFFF)
1665                         break;
1666
1667                 handled = 1;
1668                 /* Acknowledge all of the current interrupt sources ASAP */
1669                 NETDRV_W16_F (IntrStatus, status);
1670
1671                 DPRINTK ("%s: interrupt  status=%#4.4x new intstat=%#4.4x.\n",
1672                                 dev->name, status,
1673                                 NETDRV_R16 (IntrStatus));
1674
1675                 if ((status &
1676                      (PCIErr | PCSTimeout | RxUnderrun | RxOverflow |
1677                       RxFIFOOver | TxErr | TxOK | RxErr | RxOK)) == 0)
1678                         break;
1679
1680                 /* Check uncommon events with one test. */
1681                 if (status & (PCIErr | PCSTimeout | RxUnderrun | RxOverflow |
1682                               RxFIFOOver | TxErr | RxErr))
1683                         netdrv_weird_interrupt (dev, tp, ioaddr,
1684                                                  status, link_changed);
1685
1686                 if (status & (RxOK | RxUnderrun | RxOverflow | RxFIFOOver))     /* Rx interrupt */
1687                         netdrv_rx_interrupt (dev, tp, ioaddr);
1688
1689                 if (status & (TxOK | TxErr))
1690                         netdrv_tx_interrupt (dev, tp, ioaddr);
1691
1692                 boguscnt--;
1693         } while (boguscnt > 0);
1694
1695         if (boguscnt <= 0) {
1696                 printk (KERN_WARNING
1697                         "%s: Too much work at interrupt, "
1698                         "IntrStatus=0x%4.4x.\n", dev->name,
1699                         status);
1700
1701                 /* Clear all interrupt sources. */
1702                 NETDRV_W16 (IntrStatus, 0xffff);
1703         }
1704
1705         spin_unlock (&tp->lock);
1706
1707         DPRINTK ("%s: exiting interrupt, intr_status=%#4.4x.\n",
1708                  dev->name, NETDRV_R16 (IntrStatus));
1709         return IRQ_RETVAL(handled);
1710 }
1711
1712
1713 static int netdrv_close (struct net_device *dev)
1714 {
1715         struct netdrv_private *tp = netdev_priv(dev);
1716         void *ioaddr = tp->mmio_addr;
1717         unsigned long flags;
1718
1719         DPRINTK ("ENTER\n");
1720
1721         netif_stop_queue (dev);
1722
1723         DPRINTK ("%s: Shutting down ethercard, status was 0x%4.4x.\n",
1724                         dev->name, NETDRV_R16 (IntrStatus));
1725
1726         del_timer_sync (&tp->timer);
1727
1728         spin_lock_irqsave (&tp->lock, flags);
1729
1730         /* Stop the chip's Tx and Rx DMA processes. */
1731         NETDRV_W8 (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear));
1732
1733         /* Disable interrupts by clearing the interrupt mask. */
1734         NETDRV_W16 (IntrMask, 0x0000);
1735
1736         /* Update the error counts. */
1737         dev->stats.rx_missed_errors += NETDRV_R32 (RxMissed);
1738         NETDRV_W32 (RxMissed, 0);
1739
1740         spin_unlock_irqrestore (&tp->lock, flags);
1741
1742         synchronize_irq (dev->irq);
1743         free_irq (dev->irq, dev);
1744
1745         netdrv_tx_clear (dev);
1746
1747         pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1748                             tp->rx_ring, tp->rx_ring_dma);
1749         pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1750                             tp->tx_bufs, tp->tx_bufs_dma);
1751         tp->rx_ring = NULL;
1752         tp->tx_bufs = NULL;
1753
1754         /* Green! Put the chip in low-power mode. */
1755         NETDRV_W8 (Cfg9346, Cfg9346_Unlock);
1756         NETDRV_W8 (Config1, 0x03);
1757         NETDRV_W8 (Cfg9346, Cfg9346_Lock);
1758
1759         DPRINTK ("EXIT\n");
1760         return 0;
1761 }
1762
1763
1764 static int netdrv_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
1765 {
1766         struct netdrv_private *tp = netdev_priv(dev);
1767         struct mii_ioctl_data *data = if_mii(rq);
1768         unsigned long flags;
1769         int rc = 0;
1770
1771         DPRINTK ("ENTER\n");
1772
1773         switch (cmd) {
1774         case SIOCGMIIPHY:               /* Get address of MII PHY in use. */
1775                 data->phy_id = tp->phys[0] & 0x3f;
1776                 /* Fall Through */
1777
1778         case SIOCGMIIREG:               /* Read MII PHY register. */
1779                 spin_lock_irqsave (&tp->lock, flags);
1780                 data->val_out = mdio_read (dev, data->phy_id & 0x1f, data->reg_num & 0x1f);
1781                 spin_unlock_irqrestore (&tp->lock, flags);
1782                 break;
1783
1784         case SIOCSMIIREG:               /* Write MII PHY register. */
1785                 if (!capable (CAP_NET_ADMIN)) {
1786                         rc = -EPERM;
1787                         break;
1788                 }
1789
1790                 spin_lock_irqsave (&tp->lock, flags);
1791                 mdio_write (dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
1792                 spin_unlock_irqrestore (&tp->lock, flags);
1793                 break;
1794
1795         default:
1796                 rc = -EOPNOTSUPP;
1797                 break;
1798         }
1799
1800         DPRINTK ("EXIT, returning %d\n", rc);
1801         return rc;
1802 }
1803
1804 /* Set or clear the multicast filter for this adaptor.
1805    This routine is not state sensitive and need not be SMP locked. */
1806
1807 static void netdrv_set_rx_mode (struct net_device *dev)
1808 {
1809         struct netdrv_private *tp = netdev_priv(dev);
1810         void *ioaddr = tp->mmio_addr;
1811         u32 mc_filter[2];       /* Multicast hash filter */
1812         int i, rx_mode;
1813         u32 tmp;
1814
1815         DPRINTK ("ENTER\n");
1816
1817         DPRINTK ("%s:   netdrv_set_rx_mode(%4.4x) done -- Rx config %8.8x.\n",
1818                         dev->name, dev->flags, NETDRV_R32 (RxConfig));
1819
1820         /* Note: do not reorder, GCC is clever about common statements. */
1821         if (dev->flags & IFF_PROMISC) {
1822                 rx_mode =
1823                     AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
1824                     AcceptAllPhys;
1825                 mc_filter[1] = mc_filter[0] = 0xffffffff;
1826         } else if ((dev->mc_count > multicast_filter_limit)
1827                    || (dev->flags & IFF_ALLMULTI)) {
1828                 /* Too many to filter perfectly -- accept all multicasts. */
1829                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1830                 mc_filter[1] = mc_filter[0] = 0xffffffff;
1831         } else {
1832                 struct dev_mc_list *mclist;
1833                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1834                 mc_filter[1] = mc_filter[0] = 0;
1835                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1836                      i++, mclist = mclist->next) {
1837                         int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
1838
1839                         mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
1840                 }
1841         }
1842
1843         /* if called from irq handler, lock already acquired */
1844         if (!in_irq ())
1845                 spin_lock_irq (&tp->lock);
1846
1847         /* We can safely update without stopping the chip. */
1848         tmp = netdrv_rx_config | rx_mode |
1849                 (NETDRV_R32 (RxConfig) & rtl_chip_info[tp->chipset].RxConfigMask);
1850         NETDRV_W32_F (RxConfig, tmp);
1851         NETDRV_W32_F (MAR0 + 0, mc_filter[0]);
1852         NETDRV_W32_F (MAR0 + 4, mc_filter[1]);
1853
1854         if (!in_irq ())
1855                 spin_unlock_irq (&tp->lock);
1856
1857         DPRINTK ("EXIT\n");
1858 }
1859
1860
1861 #ifdef CONFIG_PM
1862
1863 static int netdrv_suspend (struct pci_dev *pdev, pm_message_t state)
1864 {
1865         struct net_device *dev = pci_get_drvdata (pdev);
1866         struct netdrv_private *tp = netdev_priv(dev);
1867         void *ioaddr = tp->mmio_addr;
1868         unsigned long flags;
1869
1870         if (!netif_running(dev))
1871                 return 0;
1872         netif_device_detach (dev);
1873
1874         spin_lock_irqsave (&tp->lock, flags);
1875
1876         /* Disable interrupts, stop Tx and Rx. */
1877         NETDRV_W16 (IntrMask, 0x0000);
1878         NETDRV_W8 (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear));
1879
1880         /* Update the error counts. */
1881         dev->stats.rx_missed_errors += NETDRV_R32 (RxMissed);
1882         NETDRV_W32 (RxMissed, 0);
1883
1884         spin_unlock_irqrestore (&tp->lock, flags);
1885
1886         pci_save_state (pdev);
1887         pci_set_power_state (pdev, PCI_D3hot);
1888
1889         return 0;
1890 }
1891
1892
1893 static int netdrv_resume (struct pci_dev *pdev)
1894 {
1895         struct net_device *dev = pci_get_drvdata (pdev);
1896         /*struct netdrv_private *tp = netdev_priv(dev);*/
1897
1898         if (!netif_running(dev))
1899                 return 0;
1900         pci_set_power_state (pdev, PCI_D0);
1901         pci_restore_state (pdev);
1902         netif_device_attach (dev);
1903         netdrv_hw_start (dev);
1904
1905         return 0;
1906 }
1907
1908 #endif /* CONFIG_PM */
1909
1910
1911 static struct pci_driver netdrv_pci_driver = {
1912         .name           = MODNAME,
1913         .id_table       = netdrv_pci_tbl,
1914         .probe          = netdrv_init_one,
1915         .remove         = __devexit_p(netdrv_remove_one),
1916 #ifdef CONFIG_PM
1917         .suspend        = netdrv_suspend,
1918         .resume         = netdrv_resume,
1919 #endif /* CONFIG_PM */
1920 };
1921
1922
1923 static int __init netdrv_init_module (void)
1924 {
1925 /* when a module, this is printed whether or not devices are found in probe */
1926 #ifdef MODULE
1927         printk(version);
1928 #endif
1929         return pci_register_driver(&netdrv_pci_driver);
1930 }
1931
1932
1933 static void __exit netdrv_cleanup_module (void)
1934 {
1935         pci_unregister_driver (&netdrv_pci_driver);
1936 }
1937
1938
1939 module_init(netdrv_init_module);
1940 module_exit(netdrv_cleanup_module);