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