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 net_device_stats stats;
 461         struct timer_list timer;        /* Media selection timer. */
 462         unsigned char *rx_ring;
 463         unsigned int cur_rx;    /* Index into the Rx buffer of next Rx pkt. */
 464         unsigned int tx_flag;
 465         atomic_t cur_tx;
 466         atomic_t dirty_tx;
 467         /* The saved address of a sent-in-place packet/buffer, for skfree(). */
 468         struct ring_info tx_info[NUM_TX_DESC];
 469         unsigned char *tx_buf[NUM_TX_DESC];     /* Tx bounce buffers */
 470         unsigned char *tx_bufs; /* Tx bounce buffer region. */
 471         dma_addr_t rx_ring_dma;
 472         dma_addr_t tx_bufs_dma;
 473         char phys[4];           /* MII device addresses. */
 474         char twistie, twist_row, twist_col;     /* Twister tune state. */
 475         unsigned int full_duplex:1;     /* Full-duplex operation requested. */
 476         unsigned int duplex_lock:1;
 477         unsigned int default_port:4;    /* Last dev->if_port value. */
 478         unsigned int media2:4;  /* Secondary monitored media port. */
 479         unsigned int medialock:1;       /* Don't sense media type. */
 480         unsigned int mediasense:1;      /* Media sensing in progress. */
 481         spinlock_t lock;
 482         chip_t chipset;
 483 };
 484
 485 MODULE_AUTHOR ("Jeff Garzik <jgarzik@pobox.com>");
 486 MODULE_DESCRIPTION ("Skeleton for a PCI Fast Ethernet driver");
 487 MODULE_LICENSE("GPL");
 488 module_param(multicast_filter_limit, int, 0);
 489 module_param(max_interrupt_work, int, 0);
 490 module_param_array(media, int, NULL, 0);
 491 MODULE_PARM_DESC (multicast_filter_limit, "pci-skeleton maximum number of filtered multicast addresses");
 492 MODULE_PARM_DESC (max_interrupt_work, "pci-skeleton maximum events handled per interrupt");
 493 MODULE_PARM_DESC (media, "pci-skeleton: Bits 0-3: media type, bit 17: full duplex");
 494
 495 static int read_eeprom (void *ioaddr, int location, int addr_len);
 496 static int netdrv_open (struct net_device *dev);
 497 static int mdio_read (struct net_device *dev, int phy_id, int location);
 498 static void mdio_write (struct net_device *dev, int phy_id, int location,
 499                         int val);
 500 static void netdrv_timer (unsigned long data);
 501 static void netdrv_tx_timeout (struct net_device *dev);
 502 static void netdrv_init_ring (struct net_device *dev);
 503 static int netdrv_start_xmit (struct sk_buff *skb,
 504                                struct net_device *dev);
 505 static irqreturn_t netdrv_interrupt (int irq, void *dev_instance);
 506 static int netdrv_close (struct net_device *dev);
 507 static int netdrv_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);
 508 static struct net_device_stats *netdrv_get_stats (struct net_device *dev);
 509 static void netdrv_set_rx_mode (struct net_device *dev);
 510 static void netdrv_hw_start (struct net_device *dev);
 511
 512
 513 #ifdef USE_IO_OPS
 514
 515 #define NETDRV_R8(reg)          inb (((unsigned long)ioaddr) + (reg))
 516 #define NETDRV_R16(reg)         inw (((unsigned long)ioaddr) + (reg))
 517 #define NETDRV_R32(reg)         ((unsigned long) inl (((unsigned long)ioaddr) + (reg)))
 518 #define NETDRV_W8(reg, val8)    outb ((val8), ((unsigned long)ioaddr) + (reg))
 519 #define NETDRV_W16(reg, val16)  outw ((val16), ((unsigned long)ioaddr) + (reg))
 520 #define NETDRV_W32(reg, val32)  outl ((val32), ((unsigned long)ioaddr) + (reg))
 521 #define NETDRV_W8_F             NETDRV_W8
 522 #define NETDRV_W16_F            NETDRV_W16
 523 #define NETDRV_W32_F            NETDRV_W32
 524 #undef readb
 525 #undef readw
 526 #undef readl
 527 #undef writeb
 528 #undef writew
 529 #undef writel
 530 #define readb(addr) inb((unsigned long)(addr))
 531 #define readw(addr) inw((unsigned long)(addr))
 532 #define readl(addr) inl((unsigned long)(addr))
 533 #define writeb(val,addr) outb((val),(unsigned long)(addr))
 534 #define writew(val,addr) outw((val),(unsigned long)(addr))
 535 #define writel(val,addr) outl((val),(unsigned long)(addr))
 536
 537 #else
 538
 539 /* write MMIO register, with flush */
 540 /* Flush avoids rtl8139 bug w/ posted MMIO writes */
 541 #define NETDRV_W8_F(reg, val8)  do { writeb ((val8), ioaddr + (reg)); readb (ioaddr + (reg)); } while (0)
 542 #define NETDRV_W16_F(reg, val16)        do { writew ((val16), ioaddr + (reg)); readw (ioaddr + (reg)); } while (0)
 543 #define NETDRV_W32_F(reg, val32)        do { writel ((val32), ioaddr + (reg)); readl (ioaddr + (reg)); } while (0)
 544
 545
 546 #if MMIO_FLUSH_AUDIT_COMPLETE
 547
 548 /* write MMIO register */
 549 #define NETDRV_W8(reg, val8)    writeb ((val8), ioaddr + (reg))
 550 #define NETDRV_W16(reg, val16)  writew ((val16), ioaddr + (reg))
 551 #define NETDRV_W32(reg, val32)  writel ((val32), ioaddr + (reg))
 552
 553 #else
 554
 555 /* write MMIO register, then flush */
 556 #define NETDRV_W8               NETDRV_W8_F
 557 #define NETDRV_W16              NETDRV_W16_F
 558 #define NETDRV_W32              NETDRV_W32_F
 559
 560 #endif /* MMIO_FLUSH_AUDIT_COMPLETE */
 561
 562 /* read MMIO register */
 563 #define NETDRV_R8(reg)          readb (ioaddr + (reg))
 564 #define NETDRV_R16(reg)         readw (ioaddr + (reg))
 565 #define NETDRV_R32(reg)         ((unsigned long) readl (ioaddr + (reg)))
 566
 567 #endif /* USE_IO_OPS */
 568
 569
 570 static const u16 netdrv_intr_mask =
 571         PCIErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver |
 572         TxErr | TxOK | RxErr | RxOK;
 573
 574 static const unsigned int netdrv_rx_config =
 575           RxCfgEarlyRxNone | RxCfgRcv32K | RxNoWrap |
 576           (RX_FIFO_THRESH << RxCfgFIFOShift) |
 577           (RX_DMA_BURST << RxCfgDMAShift);
 578
 579
 580 static int __devinit netdrv_init_board (struct pci_dev *pdev,
 581                                          struct net_device **dev_out,
 582                                          void **ioaddr_out)
 583 {
 584         void *ioaddr = NULL;
 585         struct net_device *dev;
 586         struct netdrv_private *tp;
 587         int rc, i;
 588         u32 pio_start, pio_end, pio_flags, pio_len;
 589         unsigned long mmio_start, mmio_end, mmio_flags, mmio_len;
 590         u32 tmp;
 591
 592         DPRINTK ("ENTER\n");
 593
 594         assert (pdev != NULL);
 595         assert (ioaddr_out != NULL);
 596
 597         *ioaddr_out = NULL;
 598         *dev_out = NULL;
 599
 600         /* dev zeroed in alloc_etherdev */
 601         dev = alloc_etherdev (sizeof (*tp));
 602         if (dev == NULL) {
 603                 dev_err(&pdev->dev, "unable to alloc new ethernet\n");
 604                 DPRINTK ("EXIT, returning -ENOMEM\n");
 605                 return -ENOMEM;
 606         }
 607         SET_MODULE_OWNER(dev);
 608         SET_NETDEV_DEV(dev, &pdev->dev);
 609         tp = dev->priv;
 610
 611         /* enable device (incl. PCI PM wakeup), and bus-mastering */
 612         rc = pci_enable_device (pdev);
 613         if (rc)
 614                 goto err_out;
 615
 616         pio_start = pci_resource_start (pdev, 0);
 617         pio_end = pci_resource_end (pdev, 0);
 618         pio_flags = pci_resource_flags (pdev, 0);
 619         pio_len = pci_resource_len (pdev, 0);
 620
 621         mmio_start = pci_resource_start (pdev, 1);
 622         mmio_end = pci_resource_end (pdev, 1);
 623         mmio_flags = pci_resource_flags (pdev, 1);
 624         mmio_len = pci_resource_len (pdev, 1);
 625
 626         /* set this immediately, we need to know before
 627          * we talk to the chip directly */
 628         DPRINTK("PIO region size == 0x%02X\n", pio_len);
 629         DPRINTK("MMIO region size == 0x%02lX\n", mmio_len);
 630
 631         /* make sure PCI base addr 0 is PIO */
 632         if (!(pio_flags & IORESOURCE_IO)) {
 633                 dev_err(&pdev->dev, "region #0 not a PIO resource, aborting\n");
 634                 rc = -ENODEV;
 635                 goto err_out;
 636         }
 637
 638         /* make sure PCI base addr 1 is MMIO */
 639         if (!(mmio_flags & IORESOURCE_MEM)) {
 640                 dev_err(&pdev->dev, "region #1 not an MMIO resource, aborting\n");
 641                 rc = -ENODEV;
 642                 goto err_out;
 643         }
 644
 645         /* check for weird/broken PCI region reporting */
 646         if ((pio_len < NETDRV_MIN_IO_SIZE) ||
 647             (mmio_len < NETDRV_MIN_IO_SIZE)) {
 648                 dev_err(&pdev->dev, "Invalid PCI region size(s), aborting\n");
 649                 rc = -ENODEV;
 650                 goto err_out;
 651         }
 652
 653         rc = pci_request_regions (pdev, MODNAME);
 654         if (rc)
 655                 goto err_out;
 656
 657         pci_set_master (pdev);
 658
 659 #ifdef USE_IO_OPS
 660         ioaddr = (void *) pio_start;
 661 #else
 662         /* ioremap MMIO region */
 663         ioaddr = ioremap (mmio_start, mmio_len);
 664         if (ioaddr == NULL) {
 665                 dev_err(&pdev->dev, "cannot remap MMIO, aborting\n");
 666                 rc = -EIO;
 667                 goto err_out_free_res;
 668         }
 669 #endif /* USE_IO_OPS */
 670
 671         /* Soft reset the chip. */
 672         NETDRV_W8 (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear) | CmdReset);
 673
 674         /* Check that the chip has finished the reset. */
 675         for (i = 1000; i > 0; i--)
 676                 if ((NETDRV_R8 (ChipCmd) & CmdReset) == 0)
 677                         break;
 678                 else
 679                         udelay (10);
 680
 681         /* Bring the chip out of low-power mode. */
 682         /* <insert device-specific code here> */
 683
 684 #ifndef USE_IO_OPS
 685         /* sanity checks -- ensure PIO and MMIO registers agree */
 686         assert (inb (pio_start+Config0) == readb (ioaddr+Config0));
 687         assert (inb (pio_start+Config1) == readb (ioaddr+Config1));
 688         assert (inb (pio_start+TxConfig) == readb (ioaddr+TxConfig));
 689         assert (inb (pio_start+RxConfig) == readb (ioaddr+RxConfig));
 690 #endif /* !USE_IO_OPS */
 691
 692         /* identify chip attached to board */
 693         tmp = NETDRV_R8 (ChipVersion);
 694         for (i = ARRAY_SIZE (rtl_chip_info) - 1; i >= 0; i--)
 695                 if (tmp == rtl_chip_info[i].version) {
 696                         tp->chipset = i;
 697                         goto match;
 698                 }
 699
 700         /* if unknown chip, assume array element #0, original RTL-8139 in this case */
 701         dev_printk (KERN_DEBUG, &pdev->dev,
 702                 "unknown chip version, assuming RTL-8139\n");
 703         dev_printk (KERN_DEBUG, &pdev->dev, "TxConfig = 0x%lx\n",
 704                 NETDRV_R32 (TxConfig));
 705         tp->chipset = 0;
 706
 707 match:
 708         DPRINTK ("chipset id (%d) == index %d, '%s'\n",
 709                 tmp,
 710                 tp->chipset,
 711                 rtl_chip_info[tp->chipset].name);
 712
 713         rc = register_netdev (dev);
 714         if (rc)
 715                 goto err_out_unmap;
 716
 717         DPRINTK ("EXIT, returning 0\n");
 718         *ioaddr_out = ioaddr;
 719         *dev_out = dev;
 720         return 0;
 721
 722 err_out_unmap:
 723 #ifndef USE_IO_OPS
 724         iounmap(ioaddr);
 725 err_out_free_res:
 726 #endif
 727         pci_release_regions (pdev);
 728 err_out:
 729         free_netdev (dev);
 730         DPRINTK ("EXIT, returning %d\n", rc);
 731         return rc;
 732 }
 733
 734
 735 static int __devinit netdrv_init_one (struct pci_dev *pdev,
 736                                        const struct pci_device_id *ent)
 737 {
 738         struct net_device *dev = NULL;
 739         struct netdrv_private *tp;
 740         int i, addr_len, option;
 741         void *ioaddr = NULL;
 742         static int board_idx = -1;
 743
 744 /* when built into the kernel, we only print version if device is found */
 745 #ifndef MODULE
 746         static int printed_version;
 747         if (!printed_version++)
 748                 printk(version);
 749 #endif
 750
 751         DPRINTK ("ENTER\n");
 752
 753         assert (pdev != NULL);
 754         assert (ent != NULL);
 755
 756         board_idx++;
 757
 758         i = netdrv_init_board (pdev, &dev, &ioaddr);
 759         if (i < 0) {
 760                 DPRINTK ("EXIT, returning %d\n", i);
 761                 return i;
 762         }
 763
 764         tp = dev->priv;
 765
 766         assert (ioaddr != NULL);
 767         assert (dev != NULL);
 768         assert (tp != NULL);
 769
 770         addr_len = read_eeprom (ioaddr, 0, 8) == 0x8129 ? 8 : 6;
 771         for (i = 0; i < 3; i++)
 772                 ((u16 *) (dev->dev_addr))[i] =
 773                     le16_to_cpu (read_eeprom (ioaddr, i + 7, addr_len));
 774
 775         /* The Rtl8139-specific entries in the device structure. */
 776         dev->open = netdrv_open;
 777         dev->hard_start_xmit = netdrv_start_xmit;
 778         dev->stop = netdrv_close;
 779         dev->get_stats = netdrv_get_stats;
 780         dev->set_multicast_list = netdrv_set_rx_mode;
 781         dev->do_ioctl = netdrv_ioctl;
 782         dev->tx_timeout = netdrv_tx_timeout;
 783         dev->watchdog_timeo = TX_TIMEOUT;
 784
 785         dev->irq = pdev->irq;
 786         dev->base_addr = (unsigned long) ioaddr;
 787
 788         /* dev->priv/tp zeroed and aligned in alloc_etherdev */
 789         tp = dev->priv;
 790
 791         /* note: tp->chipset set in netdrv_init_board */
 792         tp->drv_flags = PCI_COMMAND_IO | PCI_COMMAND_MEMORY |
 793                         PCI_COMMAND_MASTER | NETDRV_CAPS;
 794         tp->pci_dev = pdev;
 795         tp->board = ent->driver_data;
 796         tp->mmio_addr = ioaddr;
 797         spin_lock_init(&tp->lock);
 798
 799         pci_set_drvdata(pdev, dev);
 800
 801         tp->phys[0] = 32;
 802
 803         printk (KERN_INFO "%s: %s at 0x%lx, "
 804                 "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x, "
 805                 "IRQ %d\n",
 806                 dev->name,
 807                 board_info[ent->driver_data].name,
 808                 dev->base_addr,
 809                 dev->dev_addr[0], dev->dev_addr[1],
 810                 dev->dev_addr[2], dev->dev_addr[3],
 811                 dev->dev_addr[4], dev->dev_addr[5],
 812                 dev->irq);
 813
 814         printk (KERN_DEBUG "%s:  Identified 8139 chip type '%s'\n",
 815                 dev->name, rtl_chip_info[tp->chipset].name);
 816
 817         /* Put the chip into low-power mode. */
 818         NETDRV_W8_F (Cfg9346, Cfg9346_Unlock);
 819
 820         /* The lower four bits are the media type. */
 821         option = (board_idx > 7) ? 0 : media[board_idx];
 822         if (option > 0) {
 823                 tp->full_duplex = (option & 0x200) ? 1 : 0;
 824                 tp->default_port = option & 15;
 825                 if (tp->default_port)
 826                         tp->medialock = 1;
 827         }
 828
 829         if (tp->full_duplex) {
 830                 printk (KERN_INFO
 831                         "%s: Media type forced to Full Duplex.\n",
 832                         dev->name);
 833                 mdio_write (dev, tp->phys[0], MII_ADVERTISE, ADVERTISE_FULL);
 834                 tp->duplex_lock = 1;
 835         }
 836
 837         DPRINTK ("EXIT - returning 0\n");
 838         return 0;
 839 }
 840
 841
 842 static void __devexit netdrv_remove_one (struct pci_dev *pdev)
 843 {
 844         struct net_device *dev = pci_get_drvdata (pdev);
 845         struct netdrv_private *np;
 846
 847         DPRINTK ("ENTER\n");
 848
 849         assert (dev != NULL);
 850
 851         np = dev->priv;
 852         assert (np != NULL);
 853
 854         unregister_netdev (dev);
 855
 856 #ifndef USE_IO_OPS
 857         iounmap (np->mmio_addr);
 858 #endif /* !USE_IO_OPS */
 859
 860         pci_release_regions (pdev);
 861
 862         free_netdev (dev);
 863
 864         pci_set_drvdata (pdev, NULL);
 865
 866         pci_disable_device (pdev);
 867
 868         DPRINTK ("EXIT\n");
 869 }
 870
 871
 872 /* Serial EEPROM section. */
 873
 874 /*  EEPROM_Ctrl bits. */
 875 #define EE_SHIFT_CLK    0x04    /* EEPROM shift clock. */
 876 #define EE_CS                   0x08    /* EEPROM chip select. */
 877 #define EE_DATA_WRITE   0x02    /* EEPROM chip data in. */
 878 #define EE_WRITE_0              0x00
 879 #define EE_WRITE_1              0x02
 880 #define EE_DATA_READ    0x01    /* EEPROM chip data out. */
 881 #define EE_ENB                  (0x80 | EE_CS)
 882
 883 /* Delay between EEPROM clock transitions.
 884    No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
 885  */
 886
 887 #define eeprom_delay()  readl(ee_addr)
 888
 889 /* The EEPROM commands include the alway-set leading bit. */
 890 #define EE_WRITE_CMD    (5)
 891 #define EE_READ_CMD             (6)
 892 #define EE_ERASE_CMD    (7)
 893
 894 static int __devinit read_eeprom (void *ioaddr, int location, int addr_len)
 895 {
 896         int i;
 897         unsigned retval = 0;
 898         void *ee_addr = ioaddr + Cfg9346;
 899         int read_cmd = location | (EE_READ_CMD << addr_len);
 900
 901         DPRINTK ("ENTER\n");
 902
 903         writeb (EE_ENB & ~EE_CS, ee_addr);
 904         writeb (EE_ENB, ee_addr);
 905         eeprom_delay ();
 906
 907         /* Shift the read command bits out. */
 908         for (i = 4 + addr_len; i >= 0; i--) {
 909                 int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
 910                 writeb (EE_ENB | dataval, ee_addr);
 911                 eeprom_delay ();
 912                 writeb (EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
 913                 eeprom_delay ();
 914         }
 915         writeb (EE_ENB, ee_addr);
 916         eeprom_delay ();
 917
 918         for (i = 16; i > 0; i--) {
 919                 writeb (EE_ENB | EE_SHIFT_CLK, ee_addr);
 920                 eeprom_delay ();
 921                 retval =
 922                     (retval << 1) | ((readb (ee_addr) & EE_DATA_READ) ? 1 :
 923                                      0);
 924                 writeb (EE_ENB, ee_addr);
 925                 eeprom_delay ();
 926         }
 927
 928         /* Terminate the EEPROM access. */
 929         writeb (~EE_CS, ee_addr);
 930         eeprom_delay ();
 931
 932         DPRINTK ("EXIT - returning %d\n", retval);
 933         return retval;
 934 }
 935
 936 /* MII serial management: mostly bogus for now. */
 937 /* Read and write the MII management registers using software-generated
 938    serial MDIO protocol.
 939    The maximum data clock rate is 2.5 Mhz.  The minimum timing is usually
 940    met by back-to-back PCI I/O cycles, but we insert a delay to avoid
 941    "overclocking" issues. */
 942 #define MDIO_DIR                0x80
 943 #define MDIO_DATA_OUT   0x04
 944 #define MDIO_DATA_IN    0x02
 945 #define MDIO_CLK                0x01
 946 #define MDIO_WRITE0 (MDIO_DIR)
 947 #define MDIO_WRITE1 (MDIO_DIR | MDIO_DATA_OUT)
 948
 949 #define mdio_delay()    readb(mdio_addr)
 950
 951
 952 static char mii_2_8139_map[8] = {
 953         BasicModeCtrl,
 954         BasicModeStatus,
 955         0,
 956         0,
 957         NWayAdvert,
 958         NWayLPAR,
 959         NWayExpansion,
 960         0
 961 };
 962
 963
 964 /* Syncronize the MII management interface by shifting 32 one bits out. */
 965 static void mdio_sync (void *mdio_addr)
 966 {
 967         int i;
 968
 969         DPRINTK ("ENTER\n");
 970
 971         for (i = 32; i >= 0; i--) {
 972                 writeb (MDIO_WRITE1, mdio_addr);
 973                 mdio_delay ();
 974                 writeb (MDIO_WRITE1 | MDIO_CLK, mdio_addr);
 975                 mdio_delay ();
 976         }
 977
 978         DPRINTK ("EXIT\n");
 979 }
 980
 981
 982 static int mdio_read (struct net_device *dev, int phy_id, int location)
 983 {
 984         struct netdrv_private *tp = dev->priv;
 985         void *mdio_addr = tp->mmio_addr + Config4;
 986         int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
 987         int retval = 0;
 988         int i;
 989
 990         DPRINTK ("ENTER\n");
 991
 992         if (phy_id > 31) {      /* Really a 8139.  Use internal registers. */
 993                 DPRINTK ("EXIT after directly using 8139 internal regs\n");
 994                 return location < 8 && mii_2_8139_map[location] ?
 995                     readw (tp->mmio_addr + mii_2_8139_map[location]) : 0;
 996         }
 997         mdio_sync (mdio_addr);
 998         /* Shift the read command bits out. */
 999         for (i = 15; i >= 0; i--) {
1000                 int dataval = (mii_cmd & (1 << i)) ? MDIO_DATA_OUT : 0;
1001
1002                 writeb (MDIO_DIR | dataval, mdio_addr);
1003                 mdio_delay ();
1004                 writeb (MDIO_DIR | dataval | MDIO_CLK, mdio_addr);
1005                 mdio_delay ();
1006         }
1007
1008         /* Read the two transition, 16 data, and wire-idle bits. */
1009         for (i = 19; i > 0; i--) {
1010                 writeb (0, mdio_addr);
1011                 mdio_delay ();
1012                 retval =
1013                     (retval << 1) | ((readb (mdio_addr) & MDIO_DATA_IN) ? 1
1014                                      : 0);
1015                 writeb (MDIO_CLK, mdio_addr);
1016                 mdio_delay ();
1017         }
1018
1019         DPRINTK ("EXIT, returning %d\n", (retval >> 1) & 0xffff);
1020         return (retval >> 1) & 0xffff;
1021 }
1022
1023
1024 static void mdio_write (struct net_device *dev, int phy_id, int location,
1025                         int value)
1026 {
1027         struct netdrv_private *tp = dev->priv;
1028         void *mdio_addr = tp->mmio_addr + Config4;
1029         int mii_cmd =
1030             (0x5002 << 16) | (phy_id << 23) | (location << 18) | value;
1031         int i;
1032
1033         DPRINTK ("ENTER\n");
1034
1035         if (phy_id > 31) {      /* Really a 8139.  Use internal registers. */
1036                 if (location < 8 && mii_2_8139_map[location]) {
1037                         writew (value,
1038                                 tp->mmio_addr + mii_2_8139_map[location]);
1039                         readw (tp->mmio_addr + mii_2_8139_map[location]);
1040                 }
1041                 DPRINTK ("EXIT after directly using 8139 internal regs\n");
1042                 return;
1043         }
1044         mdio_sync (mdio_addr);
1045
1046         /* Shift the command bits out. */
1047         for (i = 31; i >= 0; i--) {
1048                 int dataval =
1049                     (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
1050                 writeb (dataval, mdio_addr);
1051                 mdio_delay ();
1052                 writeb (dataval | MDIO_CLK, mdio_addr);
1053                 mdio_delay ();
1054         }
1055
1056         /* Clear out extra bits. */
1057         for (i = 2; i > 0; i--) {
1058                 writeb (0, mdio_addr);
1059                 mdio_delay ();
1060                 writeb (MDIO_CLK, mdio_addr);
1061                 mdio_delay ();
1062         }
1063
1064         DPRINTK ("EXIT\n");
1065 }
1066
1067
1068 static int netdrv_open (struct net_device *dev)
1069 {
1070         struct netdrv_private *tp = dev->priv;
1071         int retval;
1072 #ifdef NETDRV_DEBUG
1073         void *ioaddr = tp->mmio_addr;
1074 #endif
1075
1076         DPRINTK ("ENTER\n");
1077
1078         retval = request_irq (dev->irq, netdrv_interrupt, IRQF_SHARED, dev->name, dev);
1079         if (retval) {
1080                 DPRINTK ("EXIT, returning %d\n", retval);
1081                 return retval;
1082         }
1083
1084         tp->tx_bufs = pci_alloc_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1085                                            &tp->tx_bufs_dma);
1086         tp->rx_ring = pci_alloc_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1087                                            &tp->rx_ring_dma);
1088         if (tp->tx_bufs == NULL || tp->rx_ring == NULL) {
1089                 free_irq(dev->irq, dev);
1090
1091                 if (tp->tx_bufs)
1092                         pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1093                                             tp->tx_bufs, tp->tx_bufs_dma);
1094                 if (tp->rx_ring)
1095                         pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1096                                             tp->rx_ring, tp->rx_ring_dma);
1097
1098                 DPRINTK ("EXIT, returning -ENOMEM\n");
1099                 return -ENOMEM;
1100
1101         }
1102
1103         tp->full_duplex = tp->duplex_lock;
1104         tp->tx_flag = (TX_FIFO_THRESH << 11) & 0x003f0000;
1105
1106         netdrv_init_ring (dev);
1107         netdrv_hw_start (dev);
1108
1109         DPRINTK ("%s: netdrv_open() ioaddr %#lx IRQ %d"
1110                         " GP Pins %2.2x %s-duplex.\n",
1111                         dev->name, pci_resource_start (tp->pci_dev, 1),
1112                         dev->irq, NETDRV_R8 (MediaStatus),
1113                         tp->full_duplex ? "full" : "half");
1114
1115         /* Set the timer to switch to check for link beat and perhaps switch
1116            to an alternate media type. */
1117         init_timer (&tp->timer);
1118         tp->timer.expires = jiffies + 3 * HZ;
1119         tp->timer.data = (unsigned long) dev;
1120         tp->timer.function = &netdrv_timer;
1121         add_timer (&tp->timer);
1122
1123         DPRINTK ("EXIT, returning 0\n");
1124         return 0;
1125 }
1126
1127
1128 /* Start the hardware at open or resume. */
1129 static void netdrv_hw_start (struct net_device *dev)
1130 {
1131         struct netdrv_private *tp = dev->priv;
1132         void *ioaddr = tp->mmio_addr;
1133         u32 i;
1134
1135         DPRINTK ("ENTER\n");
1136
1137         /* Soft reset the chip. */
1138         NETDRV_W8 (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear) | CmdReset);
1139         udelay (100);
1140
1141         /* Check that the chip has finished the reset. */
1142         for (i = 1000; i > 0; i--)
1143                 if ((NETDRV_R8 (ChipCmd) & CmdReset) == 0)
1144                         break;
1145
1146         /* Restore our idea of the MAC address. */
1147         NETDRV_W32_F (MAC0 + 0, cpu_to_le32 (*(u32 *) (dev->dev_addr + 0)));
1148         NETDRV_W32_F (MAC0 + 4, cpu_to_le32 (*(u32 *) (dev->dev_addr + 4)));
1149
1150         /* Must enable Tx/Rx before setting transfer thresholds! */
1151         NETDRV_W8_F (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear) |
1152                            CmdRxEnb | CmdTxEnb);
1153
1154         i = netdrv_rx_config |
1155             (NETDRV_R32 (RxConfig) & rtl_chip_info[tp->chipset].RxConfigMask);
1156         NETDRV_W32_F (RxConfig, i);
1157
1158         /* Check this value: the documentation for IFG contradicts ifself. */
1159         NETDRV_W32 (TxConfig, (TX_DMA_BURST << TxDMAShift));
1160
1161         /* unlock Config[01234] and BMCR register writes */
1162         NETDRV_W8_F (Cfg9346, Cfg9346_Unlock);
1163         udelay (10);
1164
1165         tp->cur_rx = 0;
1166
1167         /* Lock Config[01234] and BMCR register writes */
1168         NETDRV_W8_F (Cfg9346, Cfg9346_Lock);
1169         udelay (10);
1170
1171         /* init Rx ring buffer DMA address */
1172         NETDRV_W32_F (RxBuf, tp->rx_ring_dma);
1173
1174         /* init Tx buffer DMA addresses */
1175         for (i = 0; i < NUM_TX_DESC; i++)
1176                 NETDRV_W32_F (TxAddr0 + (i * 4), tp->tx_bufs_dma + (tp->tx_buf[i] - tp->tx_bufs));
1177
1178         NETDRV_W32_F (RxMissed, 0);
1179
1180         netdrv_set_rx_mode (dev);
1181
1182         /* no early-rx interrupts */
1183         NETDRV_W16 (MultiIntr, NETDRV_R16 (MultiIntr) & MultiIntrClear);
1184
1185         /* make sure RxTx has started */
1186         NETDRV_W8_F (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear) |
1187                            CmdRxEnb | CmdTxEnb);
1188
1189         /* Enable all known interrupts by setting the interrupt mask. */
1190         NETDRV_W16_F (IntrMask, netdrv_intr_mask);
1191
1192         netif_start_queue (dev);
1193
1194         DPRINTK ("EXIT\n");
1195 }
1196
1197
1198 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
1199 static void netdrv_init_ring (struct net_device *dev)
1200 {
1201         struct netdrv_private *tp = dev->priv;
1202         int i;
1203
1204         DPRINTK ("ENTER\n");
1205
1206         tp->cur_rx = 0;
1207         atomic_set (&tp->cur_tx, 0);
1208         atomic_set (&tp->dirty_tx, 0);
1209
1210         for (i = 0; i < NUM_TX_DESC; i++) {
1211                 tp->tx_info[i].skb = NULL;
1212                 tp->tx_info[i].mapping = 0;
1213                 tp->tx_buf[i] = &tp->tx_bufs[i * TX_BUF_SIZE];
1214         }
1215
1216         DPRINTK ("EXIT\n");
1217 }
1218
1219
1220 static void netdrv_timer (unsigned long data)
1221 {
1222         struct net_device *dev = (struct net_device *) data;
1223         struct netdrv_private *tp = dev->priv;
1224         void *ioaddr = tp->mmio_addr;
1225         int next_tick = 60 * HZ;
1226         int mii_lpa;
1227
1228         mii_lpa = mdio_read (dev, tp->phys[0], MII_LPA);
1229
1230         if (!tp->duplex_lock && mii_lpa != 0xffff) {
1231                 int duplex = (mii_lpa & LPA_100FULL)
1232                     || (mii_lpa & 0x01C0) == 0x0040;
1233                 if (tp->full_duplex != duplex) {
1234                         tp->full_duplex = duplex;
1235                         printk (KERN_INFO
1236                                 "%s: Setting %s-duplex based on MII #%d link"
1237                                 " partner ability of %4.4x.\n", dev->name,
1238                                 tp->full_duplex ? "full" : "half",
1239                                 tp->phys[0], mii_lpa);
1240                         NETDRV_W8 (Cfg9346, Cfg9346_Unlock);
1241                         NETDRV_W8 (Config1, tp->full_duplex ? 0x60 : 0x20);
1242                         NETDRV_W8 (Cfg9346, Cfg9346_Lock);
1243                 }
1244         }
1245
1246         DPRINTK ("%s: Media selection tick, Link partner %4.4x.\n",
1247                  dev->name, NETDRV_R16 (NWayLPAR));
1248         DPRINTK ("%s:  Other registers are IntMask %4.4x IntStatus %4.4x"
1249                  " RxStatus %4.4x.\n", dev->name,
1250                  NETDRV_R16 (IntrMask),
1251                  NETDRV_R16 (IntrStatus),
1252                  NETDRV_R32 (RxEarlyStatus));
1253         DPRINTK ("%s:  Chip config %2.2x %2.2x.\n",
1254                  dev->name, NETDRV_R8 (Config0),
1255                  NETDRV_R8 (Config1));
1256
1257         tp->timer.expires = jiffies + next_tick;
1258         add_timer (&tp->timer);
1259 }
1260
1261
1262 static void netdrv_tx_clear (struct netdrv_private *tp)
1263 {
1264         int i;
1265
1266         atomic_set (&tp->cur_tx, 0);
1267         atomic_set (&tp->dirty_tx, 0);
1268
1269         /* Dump the unsent Tx packets. */
1270         for (i = 0; i < NUM_TX_DESC; i++) {
1271                 struct ring_info *rp = &tp->tx_info[i];
1272                 if (rp->mapping != 0) {
1273                         pci_unmap_single (tp->pci_dev, rp->mapping,
1274                                           rp->skb->len, PCI_DMA_TODEVICE);
1275                         rp->mapping = 0;
1276                 }
1277                 if (rp->skb) {
1278                         dev_kfree_skb (rp->skb);
1279                         rp->skb = NULL;
1280                         tp->stats.tx_dropped++;
1281                 }
1282         }
1283 }
1284
1285
1286 static void netdrv_tx_timeout (struct net_device *dev)
1287 {
1288         struct netdrv_private *tp = dev->priv;
1289         void *ioaddr = tp->mmio_addr;
1290         int i;
1291         u8 tmp8;
1292         unsigned long flags;
1293
1294         DPRINTK ("%s: Transmit timeout, status %2.2x %4.4x "
1295                  "media %2.2x.\n", dev->name,
1296                  NETDRV_R8 (ChipCmd),
1297                  NETDRV_R16 (IntrStatus),
1298                  NETDRV_R8 (MediaStatus));
1299
1300         /* disable Tx ASAP, if not already */
1301         tmp8 = NETDRV_R8 (ChipCmd);
1302         if (tmp8 & CmdTxEnb)
1303                 NETDRV_W8 (ChipCmd, tmp8 & ~CmdTxEnb);
1304
1305         /* Disable interrupts by clearing the interrupt mask. */
1306         NETDRV_W16 (IntrMask, 0x0000);
1307
1308         /* Emit info to figure out what went wrong. */
1309         printk (KERN_DEBUG "%s: Tx queue start entry %d  dirty entry %d.\n",
1310                 dev->name, atomic_read (&tp->cur_tx),
1311                 atomic_read (&tp->dirty_tx));
1312         for (i = 0; i < NUM_TX_DESC; i++)
1313                 printk (KERN_DEBUG "%s:  Tx descriptor %d is %8.8lx.%s\n",
1314                         dev->name, i, NETDRV_R32 (TxStatus0 + (i * 4)),
1315                         i == atomic_read (&tp->dirty_tx) % NUM_TX_DESC ?
1316                                 " (queue head)" : "");
1317
1318         /* Stop a shared interrupt from scavenging while we are. */
1319         spin_lock_irqsave (&tp->lock, flags);
1320
1321         netdrv_tx_clear (tp);
1322
1323         spin_unlock_irqrestore (&tp->lock, flags);
1324
1325         /* ...and finally, reset everything */
1326         netdrv_hw_start (dev);
1327
1328         netif_wake_queue (dev);
1329 }
1330
1331
1332
1333 static int netdrv_start_xmit (struct sk_buff *skb, struct net_device *dev)
1334 {
1335         struct netdrv_private *tp = dev->priv;
1336         void *ioaddr = tp->mmio_addr;
1337         int entry;
1338
1339         /* Calculate the next Tx descriptor entry. */
1340         entry = atomic_read (&tp->cur_tx) % NUM_TX_DESC;
1341
1342         assert (tp->tx_info[entry].skb == NULL);
1343         assert (tp->tx_info[entry].mapping == 0);
1344
1345         tp->tx_info[entry].skb = skb;
1346         /* tp->tx_info[entry].mapping = 0; */
1347         skb_copy_from_linear_data(skb, tp->tx_buf[entry], skb->len);
1348
1349         /* Note: the chip doesn't have auto-pad! */
1350         NETDRV_W32 (TxStatus0 + (entry * sizeof(u32)),
1351                  tp->tx_flag | (skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN));
1352
1353         dev->trans_start = jiffies;
1354         atomic_inc (&tp->cur_tx);
1355         if ((atomic_read (&tp->cur_tx) - atomic_read (&tp->dirty_tx)) >= NUM_TX_DESC)
1356                 netif_stop_queue (dev);
1357
1358         DPRINTK ("%s: Queued Tx packet at %p size %u to slot %d.\n",
1359                  dev->name, skb->data, skb->len, entry);
1360
1361         return 0;
1362 }
1363
1364
1365 static void netdrv_tx_interrupt (struct net_device *dev,
1366                                   struct netdrv_private *tp,
1367                                   void *ioaddr)
1368 {
1369         int cur_tx, dirty_tx, tx_left;
1370
1371         assert (dev != NULL);
1372         assert (tp != NULL);
1373         assert (ioaddr != NULL);
1374
1375         dirty_tx = atomic_read (&tp->dirty_tx);
1376
1377         cur_tx = atomic_read (&tp->cur_tx);
1378         tx_left = cur_tx - dirty_tx;
1379         while (tx_left > 0) {
1380                 int entry = dirty_tx % NUM_TX_DESC;
1381                 int txstatus;
1382
1383                 txstatus = NETDRV_R32 (TxStatus0 + (entry * sizeof (u32)));
1384
1385                 if (!(txstatus & (TxStatOK | TxUnderrun | TxAborted)))
1386                         break;  /* It still hasn't been Txed */
1387
1388                 /* Note: TxCarrierLost is always asserted at 100mbps. */
1389                 if (txstatus & (TxOutOfWindow | TxAborted)) {
1390                         /* There was an major error, log it. */
1391                         DPRINTK ("%s: Transmit error, Tx status %8.8x.\n",
1392                                  dev->name, txstatus);
1393                         tp->stats.tx_errors++;
1394                         if (txstatus & TxAborted) {
1395                                 tp->stats.tx_aborted_errors++;
1396                                 NETDRV_W32 (TxConfig, TxClearAbt | (TX_DMA_BURST << TxDMAShift));
1397                         }
1398                         if (txstatus & TxCarrierLost)
1399                                 tp->stats.tx_carrier_errors++;
1400                         if (txstatus & TxOutOfWindow)
1401                                 tp->stats.tx_window_errors++;
1402                 } else {
1403                         if (txstatus & TxUnderrun) {
1404                                 /* Add 64 to the Tx FIFO threshold. */
1405                                 if (tp->tx_flag < 0x00300000)
1406                                         tp->tx_flag += 0x00020000;
1407                                 tp->stats.tx_fifo_errors++;
1408                         }
1409                         tp->stats.collisions += (txstatus >> 24) & 15;
1410                         tp->stats.tx_bytes += txstatus & 0x7ff;
1411                         tp->stats.tx_packets++;
1412                 }
1413
1414                 /* Free the original skb. */
1415                 if (tp->tx_info[entry].mapping != 0) {
1416                         pci_unmap_single(tp->pci_dev,
1417                                          tp->tx_info[entry].mapping,
1418                                          tp->tx_info[entry].skb->len,
1419                                          PCI_DMA_TODEVICE);
1420                         tp->tx_info[entry].mapping = 0;
1421                 }
1422                 dev_kfree_skb_irq (tp->tx_info[entry].skb);
1423                 tp->tx_info[entry].skb = NULL;
1424                 dirty_tx++;
1425                 if (dirty_tx < 0) { /* handle signed int overflow */
1426                         atomic_sub (cur_tx, &tp->cur_tx); /* XXX racy? */
1427                         dirty_tx = cur_tx - tx_left + 1;
1428                 }
1429                 if (netif_queue_stopped (dev))
1430                         netif_wake_queue (dev);
1431
1432                 cur_tx = atomic_read (&tp->cur_tx);
1433                 tx_left = cur_tx - dirty_tx;
1434
1435         }
1436
1437 #ifndef NETDRV_NDEBUG
1438         if (atomic_read (&tp->cur_tx) - dirty_tx > NUM_TX_DESC) {
1439                 printk (KERN_ERR
1440                   "%s: Out-of-sync dirty pointer, %d vs. %d.\n",
1441                      dev->name, dirty_tx, atomic_read (&tp->cur_tx));
1442                 dirty_tx += NUM_TX_DESC;
1443         }
1444 #endif /* NETDRV_NDEBUG */
1445
1446         atomic_set (&tp->dirty_tx, dirty_tx);
1447 }
1448
1449
1450 /* TODO: clean this up!  Rx reset need not be this intensive */
1451 static void netdrv_rx_err (u32 rx_status, struct net_device *dev,
1452                             struct netdrv_private *tp, void *ioaddr)
1453 {
1454         u8 tmp8;
1455         int tmp_work = 1000;
1456
1457         DPRINTK ("%s: Ethernet frame had errors, status %8.8x.\n",
1458                  dev->name, rx_status);
1459         if (rx_status & RxTooLong) {
1460                 DPRINTK ("%s: Oversized Ethernet frame, status %4.4x!\n",
1461                          dev->name, rx_status);
1462                 /* A.C.: The chip hangs here. */
1463         }
1464         tp->stats.rx_errors++;
1465         if (rx_status & (RxBadSymbol | RxBadAlign))
1466                 tp->stats.rx_frame_errors++;
1467         if (rx_status & (RxRunt | RxTooLong))
1468                 tp->stats.rx_length_errors++;
1469         if (rx_status & RxCRCErr)
1470                 tp->stats.rx_crc_errors++;
1471         /* Reset the receiver, based on RealTek recommendation. (Bug?) */
1472         tp->cur_rx = 0;
1473
1474         /* disable receive */
1475         tmp8 = NETDRV_R8 (ChipCmd) & ChipCmdClear;
1476         NETDRV_W8_F (ChipCmd, tmp8 | CmdTxEnb);
1477
1478         /* A.C.: Reset the multicast list. */
1479         netdrv_set_rx_mode (dev);
1480
1481         /* XXX potentially temporary hack to
1482          * restart hung receiver */
1483         while (--tmp_work > 0) {
1484                 tmp8 = NETDRV_R8 (ChipCmd);
1485                 if ((tmp8 & CmdRxEnb) && (tmp8 & CmdTxEnb))
1486                         break;
1487                 NETDRV_W8_F (ChipCmd,
1488                           (tmp8 & ChipCmdClear) | CmdRxEnb | CmdTxEnb);
1489         }
1490
1491         /* G.S.: Re-enable receiver */
1492         /* XXX temporary hack to work around receiver hang */
1493         netdrv_set_rx_mode (dev);
1494
1495         if (tmp_work <= 0)
1496                 printk (KERN_WARNING PFX "tx/rx enable wait too long\n");
1497 }
1498
1499
1500 /* The data sheet doesn't describe the Rx ring at all, so I'm guessing at the
1501    field alignments and semantics. */
1502 static void netdrv_rx_interrupt (struct net_device *dev,
1503                                   struct netdrv_private *tp, void *ioaddr)
1504 {
1505         unsigned char *rx_ring;
1506         u16 cur_rx;
1507
1508         assert (dev != NULL);
1509         assert (tp != NULL);
1510         assert (ioaddr != NULL);
1511
1512         rx_ring = tp->rx_ring;
1513         cur_rx = tp->cur_rx;
1514
1515         DPRINTK ("%s: In netdrv_rx(), current %4.4x BufAddr %4.4x,"
1516                  " free to %4.4x, Cmd %2.2x.\n", dev->name, cur_rx,
1517                  NETDRV_R16 (RxBufAddr),
1518                  NETDRV_R16 (RxBufPtr), NETDRV_R8 (ChipCmd));
1519
1520         while ((NETDRV_R8 (ChipCmd) & RxBufEmpty) == 0) {
1521                 int ring_offset = cur_rx % RX_BUF_LEN;
1522                 u32 rx_status;
1523                 unsigned int rx_size;
1524                 unsigned int pkt_size;
1525                 struct sk_buff *skb;
1526
1527                 /* read size+status of next frame from DMA ring buffer */
1528                 rx_status = le32_to_cpu (*(u32 *) (rx_ring + ring_offset));
1529                 rx_size = rx_status >> 16;
1530                 pkt_size = rx_size - 4;
1531
1532                 DPRINTK ("%s:  netdrv_rx() status %4.4x, size %4.4x,"
1533                          " cur %4.4x.\n", dev->name, rx_status,
1534                          rx_size, cur_rx);
1535 #if NETDRV_DEBUG > 2
1536                 {
1537                         int i;
1538                         DPRINTK ("%s: Frame contents ", dev->name);
1539                         for (i = 0; i < 70; i++)
1540                                 printk (" %2.2x",
1541                                         rx_ring[ring_offset + i]);
1542                         printk (".\n");
1543                 }
1544 #endif
1545
1546                 /* If Rx err or invalid rx_size/rx_status received
1547                  * (which happens if we get lost in the ring),
1548                  * Rx process gets reset, so we abort any further
1549                  * Rx processing.
1550                  */
1551                 if ((rx_size > (MAX_ETH_FRAME_SIZE+4)) ||
1552                     (!(rx_status & RxStatusOK))) {
1553                         netdrv_rx_err (rx_status, dev, tp, ioaddr);
1554                         return;
1555                 }
1556
1557                 /* Malloc up new buffer, compatible with net-2e. */
1558                 /* Omit the four octet CRC from the length. */
1559
1560                 /* TODO: consider allocating skb's outside of
1561                  * interrupt context, both to speed interrupt processing,
1562                  * and also to reduce the chances of having to
1563                  * drop packets here under memory pressure.
1564                  */
1565
1566                 skb = dev_alloc_skb (pkt_size + 2);
1567                 if (skb) {
1568                         skb_reserve (skb, 2);   /* 16 byte align the IP fields. */
1569
1570                         skb_copy_to_linear_data (skb, &rx_ring[ring_offset + 4], pkt_size);
1571                         skb_put (skb, pkt_size);
1572
1573                         skb->protocol = eth_type_trans (skb, dev);
1574                         netif_rx (skb);
1575                         dev->last_rx = jiffies;
1576                         tp->stats.rx_bytes += pkt_size;
1577                         tp->stats.rx_packets++;
1578                 } else {
1579                         printk (KERN_WARNING
1580                                 "%s: Memory squeeze, dropping packet.\n",
1581                                 dev->name);
1582                         tp->stats.rx_dropped++;
1583                 }
1584
1585                 cur_rx = (cur_rx + rx_size + 4 + 3) & ~3;
1586                 NETDRV_W16_F (RxBufPtr, cur_rx - 16);
1587         }
1588
1589         DPRINTK ("%s: Done netdrv_rx(), current %4.4x BufAddr %4.4x,"
1590                  " free to %4.4x, Cmd %2.2x.\n", dev->name, cur_rx,
1591                  NETDRV_R16 (RxBufAddr),
1592                  NETDRV_R16 (RxBufPtr), NETDRV_R8 (ChipCmd));
1593
1594         tp->cur_rx = cur_rx;
1595 }
1596
1597
1598 static void netdrv_weird_interrupt (struct net_device *dev,
1599                                      struct netdrv_private *tp,
1600                                      void *ioaddr,
1601                                      int status, int link_changed)
1602 {
1603         printk (KERN_DEBUG "%s: Abnormal interrupt, status %8.8x.\n",
1604                 dev->name, status);
1605
1606         assert (dev != NULL);
1607         assert (tp != NULL);
1608         assert (ioaddr != NULL);
1609
1610         /* Update the error count. */
1611         tp->stats.rx_missed_errors += NETDRV_R32 (RxMissed);
1612         NETDRV_W32 (RxMissed, 0);
1613
1614         if ((status & RxUnderrun) && link_changed &&
1615             (tp->drv_flags & HAS_LNK_CHNG)) {
1616                 /* Really link-change on new chips. */
1617                 int lpar = NETDRV_R16 (NWayLPAR);
1618                 int duplex = (lpar & 0x0100) || (lpar & 0x01C0) == 0x0040
1619                                 || tp->duplex_lock;
1620                 if (tp->full_duplex != duplex) {
1621                         tp->full_duplex = duplex;
1622                         NETDRV_W8 (Cfg9346, Cfg9346_Unlock);
1623                         NETDRV_W8 (Config1, tp->full_duplex ? 0x60 : 0x20);
1624                         NETDRV_W8 (Cfg9346, Cfg9346_Lock);
1625                 }
1626                 status &= ~RxUnderrun;
1627         }
1628
1629         /* XXX along with netdrv_rx_err, are we double-counting errors? */
1630         if (status &
1631             (RxUnderrun | RxOverflow | RxErr | RxFIFOOver))
1632                 tp->stats.rx_errors++;
1633
1634         if (status & (PCSTimeout))
1635                 tp->stats.rx_length_errors++;
1636         if (status & (RxUnderrun | RxFIFOOver))
1637                 tp->stats.rx_fifo_errors++;
1638         if (status & RxOverflow) {
1639                 tp->stats.rx_over_errors++;
1640                 tp->cur_rx = NETDRV_R16 (RxBufAddr) % RX_BUF_LEN;
1641                 NETDRV_W16_F (RxBufPtr, tp->cur_rx - 16);
1642         }
1643         if (status & PCIErr) {
1644                 u16 pci_cmd_status;
1645                 pci_read_config_word (tp->pci_dev, PCI_STATUS, &pci_cmd_status);
1646
1647                 printk (KERN_ERR "%s: PCI Bus error %4.4x.\n",
1648                         dev->name, pci_cmd_status);
1649         }
1650 }
1651
1652
1653 /* The interrupt handler does all of the Rx thread work and cleans up
1654    after the Tx thread. */
1655 static irqreturn_t netdrv_interrupt (int irq, void *dev_instance)
1656 {
1657         struct net_device *dev = (struct net_device *) dev_instance;
1658         struct netdrv_private *tp = dev->priv;
1659         int boguscnt = max_interrupt_work;
1660         void *ioaddr = tp->mmio_addr;
1661         int status = 0, link_changed = 0; /* avoid bogus "uninit" warning */
1662         int handled = 0;
1663
1664         spin_lock (&tp->lock);
1665
1666         do {
1667                 status = NETDRV_R16 (IntrStatus);
1668
1669                 /* h/w no longer present (hotplug?) or major error, bail */
1670                 if (status == 0xFFFF)
1671                         break;
1672
1673                 handled = 1;
1674                 /* Acknowledge all of the current interrupt sources ASAP */
1675                 NETDRV_W16_F (IntrStatus, status);
1676
1677                 DPRINTK ("%s: interrupt  status=%#4.4x new intstat=%#4.4x.\n",
1678                                 dev->name, status,
1679                                 NETDRV_R16 (IntrStatus));
1680
1681                 if ((status &
1682                      (PCIErr | PCSTimeout | RxUnderrun | RxOverflow |
1683                       RxFIFOOver | TxErr | TxOK | RxErr | RxOK)) == 0)
1684                         break;
1685
1686                 /* Check uncommon events with one test. */
1687                 if (status & (PCIErr | PCSTimeout | RxUnderrun | RxOverflow |
1688                               RxFIFOOver | TxErr | RxErr))
1689                         netdrv_weird_interrupt (dev, tp, ioaddr,
1690                                                  status, link_changed);
1691
1692                 if (status & (RxOK | RxUnderrun | RxOverflow | RxFIFOOver))     /* Rx interrupt */
1693                         netdrv_rx_interrupt (dev, tp, ioaddr);
1694
1695                 if (status & (TxOK | TxErr))
1696                         netdrv_tx_interrupt (dev, tp, ioaddr);
1697
1698                 boguscnt--;
1699         } while (boguscnt > 0);
1700
1701         if (boguscnt <= 0) {
1702                 printk (KERN_WARNING
1703                         "%s: Too much work at interrupt, "
1704                         "IntrStatus=0x%4.4x.\n", dev->name,
1705                         status);
1706
1707                 /* Clear all interrupt sources. */
1708                 NETDRV_W16 (IntrStatus, 0xffff);
1709         }
1710
1711         spin_unlock (&tp->lock);
1712
1713         DPRINTK ("%s: exiting interrupt, intr_status=%#4.4x.\n",
1714                  dev->name, NETDRV_R16 (IntrStatus));
1715         return IRQ_RETVAL(handled);
1716 }
1717
1718
1719 static int netdrv_close (struct net_device *dev)
1720 {
1721         struct netdrv_private *tp = dev->priv;
1722         void *ioaddr = tp->mmio_addr;
1723         unsigned long flags;
1724
1725         DPRINTK ("ENTER\n");
1726
1727         netif_stop_queue (dev);
1728
1729         DPRINTK ("%s: Shutting down ethercard, status was 0x%4.4x.\n",
1730                         dev->name, NETDRV_R16 (IntrStatus));
1731
1732         del_timer_sync (&tp->timer);
1733
1734         spin_lock_irqsave (&tp->lock, flags);
1735
1736         /* Stop the chip's Tx and Rx DMA processes. */
1737         NETDRV_W8 (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear));
1738
1739         /* Disable interrupts by clearing the interrupt mask. */
1740         NETDRV_W16 (IntrMask, 0x0000);
1741
1742         /* Update the error counts. */
1743         tp->stats.rx_missed_errors += NETDRV_R32 (RxMissed);
1744         NETDRV_W32 (RxMissed, 0);
1745
1746         spin_unlock_irqrestore (&tp->lock, flags);
1747
1748         synchronize_irq ();
1749         free_irq (dev->irq, dev);
1750
1751         netdrv_tx_clear (tp);
1752
1753         pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN,
1754                             tp->rx_ring, tp->rx_ring_dma);
1755         pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN,
1756                             tp->tx_bufs, tp->tx_bufs_dma);
1757         tp->rx_ring = NULL;
1758         tp->tx_bufs = NULL;
1759
1760         /* Green! Put the chip in low-power mode. */
1761         NETDRV_W8 (Cfg9346, Cfg9346_Unlock);
1762         NETDRV_W8 (Config1, 0x03);
1763         NETDRV_W8 (Cfg9346, Cfg9346_Lock);
1764
1765         DPRINTK ("EXIT\n");
1766         return 0;
1767 }
1768
1769
1770 static int netdrv_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
1771 {
1772         struct netdrv_private *tp = dev->priv;
1773         struct mii_ioctl_data *data = if_mii(rq);
1774         unsigned long flags;
1775         int rc = 0;
1776
1777         DPRINTK ("ENTER\n");
1778
1779         switch (cmd) {
1780         case SIOCGMIIPHY:               /* Get address of MII PHY in use. */
1781                 data->phy_id = tp->phys[0] & 0x3f;
1782                 /* Fall Through */
1783
1784         case SIOCGMIIREG:               /* Read MII PHY register. */
1785                 spin_lock_irqsave (&tp->lock, flags);
1786                 data->val_out = mdio_read (dev, data->phy_id & 0x1f, data->reg_num & 0x1f);
1787                 spin_unlock_irqrestore (&tp->lock, flags);
1788                 break;
1789
1790         case SIOCSMIIREG:               /* Write MII PHY register. */
1791                 if (!capable (CAP_NET_ADMIN)) {
1792                         rc = -EPERM;
1793                         break;
1794                 }
1795
1796                 spin_lock_irqsave (&tp->lock, flags);
1797                 mdio_write (dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
1798                 spin_unlock_irqrestore (&tp->lock, flags);
1799                 break;
1800
1801         default:
1802                 rc = -EOPNOTSUPP;
1803                 break;
1804         }
1805
1806         DPRINTK ("EXIT, returning %d\n", rc);
1807         return rc;
1808 }
1809
1810
1811 static struct net_device_stats *netdrv_get_stats (struct net_device *dev)
1812 {
1813         struct netdrv_private *tp = dev->priv;
1814         void *ioaddr = tp->mmio_addr;
1815
1816         DPRINTK ("ENTER\n");
1817
1818         assert (tp != NULL);
1819
1820         if (netif_running(dev)) {
1821                 unsigned long flags;
1822
1823                 spin_lock_irqsave (&tp->lock, flags);
1824
1825                 tp->stats.rx_missed_errors += NETDRV_R32 (RxMissed);
1826                 NETDRV_W32 (RxMissed, 0);
1827
1828                 spin_unlock_irqrestore (&tp->lock, flags);
1829         }
1830
1831         DPRINTK ("EXIT\n");
1832         return &tp->stats;
1833 }
1834
1835 /* Set or clear the multicast filter for this adaptor.
1836    This routine is not state sensitive and need not be SMP locked. */
1837
1838 static void netdrv_set_rx_mode (struct net_device *dev)
1839 {
1840         struct netdrv_private *tp = dev->priv;
1841         void *ioaddr = tp->mmio_addr;
1842         u32 mc_filter[2];       /* Multicast hash filter */
1843         int i, rx_mode;
1844         u32 tmp;
1845
1846         DPRINTK ("ENTER\n");
1847
1848         DPRINTK ("%s:   netdrv_set_rx_mode(%4.4x) done -- Rx config %8.8x.\n",
1849                         dev->name, dev->flags, NETDRV_R32 (RxConfig));
1850
1851         /* Note: do not reorder, GCC is clever about common statements. */
1852         if (dev->flags & IFF_PROMISC) {
1853                 rx_mode =
1854                     AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
1855                     AcceptAllPhys;
1856                 mc_filter[1] = mc_filter[0] = 0xffffffff;
1857         } else if ((dev->mc_count > multicast_filter_limit)
1858                    || (dev->flags & IFF_ALLMULTI)) {
1859                 /* Too many to filter perfectly -- accept all multicasts. */
1860                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1861                 mc_filter[1] = mc_filter[0] = 0xffffffff;
1862         } else {
1863                 struct dev_mc_list *mclist;
1864                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1865                 mc_filter[1] = mc_filter[0] = 0;
1866                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1867                      i++, mclist = mclist->next) {
1868                         int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
1869
1870                         mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
1871                 }
1872         }
1873
1874         /* if called from irq handler, lock already acquired */
1875         if (!in_irq ())
1876                 spin_lock_irq (&tp->lock);
1877
1878         /* We can safely update without stopping the chip. */
1879         tmp = netdrv_rx_config | rx_mode |
1880                 (NETDRV_R32 (RxConfig) & rtl_chip_info[tp->chipset].RxConfigMask);
1881         NETDRV_W32_F (RxConfig, tmp);
1882         NETDRV_W32_F (MAR0 + 0, mc_filter[0]);
1883         NETDRV_W32_F (MAR0 + 4, mc_filter[1]);
1884
1885         if (!in_irq ())
1886                 spin_unlock_irq (&tp->lock);
1887
1888         DPRINTK ("EXIT\n");
1889 }
1890
1891
1892 #ifdef CONFIG_PM
1893
1894 static int netdrv_suspend (struct pci_dev *pdev, pm_message_t state)
1895 {
1896         struct net_device *dev = pci_get_drvdata (pdev);
1897         struct netdrv_private *tp = dev->priv;
1898         void *ioaddr = tp->mmio_addr;
1899         unsigned long flags;
1900
1901         if (!netif_running(dev))
1902                 return 0;
1903         netif_device_detach (dev);
1904
1905         spin_lock_irqsave (&tp->lock, flags);
1906
1907         /* Disable interrupts, stop Tx and Rx. */
1908         NETDRV_W16 (IntrMask, 0x0000);
1909         NETDRV_W8 (ChipCmd, (NETDRV_R8 (ChipCmd) & ChipCmdClear));
1910
1911         /* Update the error counts. */
1912         tp->stats.rx_missed_errors += NETDRV_R32 (RxMissed);
1913         NETDRV_W32 (RxMissed, 0);
1914
1915         spin_unlock_irqrestore (&tp->lock, flags);
1916
1917         pci_save_state (pdev);
1918         pci_set_power_state (pdev, PCI_D3hot);
1919
1920         return 0;
1921 }
1922
1923
1924 static int netdrv_resume (struct pci_dev *pdev)
1925 {
1926         struct net_device *dev = pci_get_drvdata (pdev);
1927         struct netdrv_private *tp = dev->priv;
1928
1929         if (!netif_running(dev))
1930                 return 0;
1931         pci_set_power_state (pdev, PCI_D0);
1932         pci_restore_state (pdev);
1933         netif_device_attach (dev);
1934         netdrv_hw_start (dev);
1935
1936         return 0;
1937 }
1938
1939 #endif /* CONFIG_PM */
1940
1941
1942 static struct pci_driver netdrv_pci_driver = {
1943         .name           = MODNAME,
1944         .id_table       = netdrv_pci_tbl,
1945         .probe          = netdrv_init_one,
1946         .remove         = __devexit_p(netdrv_remove_one),
1947 #ifdef CONFIG_PM
1948         .suspend        = netdrv_suspend,
1949         .resume         = netdrv_resume,
1950 #endif /* CONFIG_PM */
1951 };
1952
1953
1954 static int __init netdrv_init_module (void)
1955 {
1956 /* when a module, this is printed whether or not devices are found in probe */
1957 #ifdef MODULE
1958         printk(version);
1959 #endif
1960         return pci_register_driver(&netdrv_pci_driver);
1961 }
1962
1963
1964 static void __exit netdrv_cleanup_module (void)
1965 {
1966         pci_unregister_driver (&netdrv_pci_driver);
1967 }
1968
1969
1970 module_init(netdrv_init_module);
1971 module_exit(netdrv_cleanup_module);