drivers/net/r8169.c

   1 /*
   2 =========================================================================
   3  r8169.c: A RealTek RTL-8169 Gigabit Ethernet driver for Linux kernel 2.4.x.
   4  --------------------------------------------------------------------
   5
   6  History:
   7  Feb  4 2002    - created initially by ShuChen <shuchen@realtek.com.tw>.
   8  May 20 2002    - Add link status force-mode and TBI mode support.
   9 =========================================================================
  10   1. The media can be forced in 5 modes.
  11          Command: 'insmod r8169 media = SET_MEDIA'
  12          Ex:      'insmod r8169 media = 0x04' will force PHY to operate in 100Mpbs Half-duplex.
  13
  14          SET_MEDIA can be:
  15                 _10_Half        = 0x01
  16                 _10_Full        = 0x02
  17                 _100_Half       = 0x04
  18                 _100_Full       = 0x08
  19                 _1000_Full      = 0x10
  20
  21   2. Support TBI mode.
  22 =========================================================================
  23 VERSION 1.1     <2002/10/4>
  24
  25         The bit4:0 of MII register 4 is called "selector field", and have to be
  26         00001b to indicate support of IEEE std 802.3 during NWay process of
  27         exchanging Link Code Word (FLP).
  28
  29 VERSION 1.2     <2002/11/30>
  30
  31         - Large style cleanup
  32         - Use ether_crc in stock kernel (linux/crc32.h)
  33         - Copy mc_filter setup code from 8139cp
  34           (includes an optimization, and avoids set_bit use)
  35
  36 */
  37
  38 #include <linux/module.h>
  39 #include <linux/pci.h>
  40 #include <linux/netdevice.h>
  41 #include <linux/etherdevice.h>
  42 #include <linux/delay.h>
  43 #include <linux/crc32.h>
  44
  45 #define RTL8169_VERSION "1.2"
  46 #define MODULENAME "r8169"
  47 #define RTL8169_DRIVER_NAME   MODULENAME " Gigabit Ethernet driver " RTL8169_VERSION
  48 #define PFX MODULENAME ": "
  49
  50 #ifdef RTL8169_DEBUG
  51 #define assert(expr) \
  52         if(!(expr)) {                                   \
  53                 printk( "Assertion failed! %s,%s,%s,line=%d\n", \
  54                 #expr,__FILE__,__FUNCTION__,__LINE__);          \
  55         }
  56 #else
  57 #define assert(expr) do {} while (0)
  58 #endif
  59
  60 /* media options */
  61 #define MAX_UNITS 8
  62 static int media[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1 };
  63
  64 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
  65 static int max_interrupt_work = 20;
  66
  67 /* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
  68    The RTL chips use a 64 element hash table based on the Ethernet CRC.  */
  69 static int multicast_filter_limit = 32;
  70
  71 /* MAC address length*/
  72 #define MAC_ADDR_LEN    6
  73
  74 /* max supported gigabit ethernet frame size -- must be at least (dev->mtu+14+4).*/
  75 #define MAX_ETH_FRAME_SIZE      1536
  76
  77 #define TX_FIFO_THRESH 256      /* In bytes */
  78
  79 #define RX_FIFO_THRESH  7       /* 7 means NO threshold, Rx buffer level before first PCI xfer.  */
  80 #define RX_DMA_BURST    6       /* Maximum PCI burst, '6' is 1024 */
  81 #define TX_DMA_BURST    6       /* Maximum PCI burst, '6' is 1024 */
  82 #define EarlyTxThld     0x3F    /* 0x3F means NO early transmit */
  83 #define RxPacketMaxSize 0x0800  /* Maximum size supported is 16K-1 */
  84 #define InterFrameGap   0x03    /* 3 means InterFrameGap = the shortest one */
  85
  86 #define NUM_TX_DESC     64      /* Number of Tx descriptor registers */
  87 #define NUM_RX_DESC     64      /* Number of Rx descriptor registers */
  88 #define RX_BUF_SIZE     1536    /* Rx Buffer size */
  89
  90 #define RTL_MIN_IO_SIZE 0x80
  91 #define TX_TIMEOUT  (6*HZ)
  92
  93 /* write/read MMIO register */
  94 #define RTL_W8(reg, val8)       writeb ((val8), ioaddr + (reg))
  95 #define RTL_W16(reg, val16)     writew ((val16), ioaddr + (reg))
  96 #define RTL_W32(reg, val32)     writel ((val32), ioaddr + (reg))
  97 #define RTL_R8(reg)             readb (ioaddr + (reg))
  98 #define RTL_R16(reg)            readw (ioaddr + (reg))
  99 #define RTL_R32(reg)            ((unsigned long) readl (ioaddr + (reg)))
 100
 101 static struct {
 102         const char *name;
 103 } board_info[] __devinitdata = {
 104         {
 105 "RealTek RTL8169 Gigabit Ethernet"},};
 106
 107 static struct pci_device_id rtl8169_pci_tbl[] __devinitdata = {
 108         {0x10ec, 0x8169, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 109         {0,},
 110 };
 111
 112 MODULE_DEVICE_TABLE(pci, rtl8169_pci_tbl);
 113
 114 enum RTL8169_registers {
 115         MAC0 = 0,               /* Ethernet hardware address. */
 116         MAR0 = 8,               /* Multicast filter. */
 117         TxDescStartAddr = 0x20,
 118         TxHDescStartAddr = 0x28,
 119         FLASH = 0x30,
 120         ERSR = 0x36,
 121         ChipCmd = 0x37,
 122         TxPoll = 0x38,
 123         IntrMask = 0x3C,
 124         IntrStatus = 0x3E,
 125         TxConfig = 0x40,
 126         RxConfig = 0x44,
 127         RxMissed = 0x4C,
 128         Cfg9346 = 0x50,
 129         Config0 = 0x51,
 130         Config1 = 0x52,
 131         Config2 = 0x53,
 132         Config3 = 0x54,
 133         Config4 = 0x55,
 134         Config5 = 0x56,
 135         MultiIntr = 0x5C,
 136         PHYAR = 0x60,
 137         TBICSR = 0x64,
 138         TBI_ANAR = 0x68,
 139         TBI_LPAR = 0x6A,
 140         PHYstatus = 0x6C,
 141         RxMaxSize = 0xDA,
 142         CPlusCmd = 0xE0,
 143         RxDescStartAddr = 0xE4,
 144         EarlyTxThres = 0xEC,
 145         FuncEvent = 0xF0,
 146         FuncEventMask = 0xF4,
 147         FuncPresetState = 0xF8,
 148         FuncForceEvent = 0xFC,
 149 };
 150
 151 enum RTL8169_register_content {
 152         /*InterruptStatusBits */
 153         SYSErr = 0x8000,
 154         PCSTimeout = 0x4000,
 155         SWInt = 0x0100,
 156         TxDescUnavail = 0x80,
 157         RxFIFOOver = 0x40,
 158         RxUnderrun = 0x20,
 159         RxOverflow = 0x10,
 160         TxErr = 0x08,
 161         TxOK = 0x04,
 162         RxErr = 0x02,
 163         RxOK = 0x01,
 164
 165         /*RxStatusDesc */
 166         RxRES = 0x00200000,
 167         RxCRC = 0x00080000,
 168         RxRUNT = 0x00100000,
 169         RxRWT = 0x00400000,
 170
 171         /*ChipCmdBits */
 172         CmdReset = 0x10,
 173         CmdRxEnb = 0x08,
 174         CmdTxEnb = 0x04,
 175         RxBufEmpty = 0x01,
 176
 177         /*Cfg9346Bits */
 178         Cfg9346_Lock = 0x00,
 179         Cfg9346_Unlock = 0xC0,
 180
 181         /*rx_mode_bits */
 182         AcceptErr = 0x20,
 183         AcceptRunt = 0x10,
 184         AcceptBroadcast = 0x08,
 185         AcceptMulticast = 0x04,
 186         AcceptMyPhys = 0x02,
 187         AcceptAllPhys = 0x01,
 188
 189         /*RxConfigBits */
 190         RxCfgFIFOShift = 13,
 191         RxCfgDMAShift = 8,
 192
 193         /*TxConfigBits */
 194         TxInterFrameGapShift = 24,
 195         TxDMAShift = 8,         /* DMA burst value (0-7) is shift this many bits */
 196
 197         /*rtl8169_PHYstatus */
 198         TBI_Enable = 0x80,
 199         TxFlowCtrl = 0x40,
 200         RxFlowCtrl = 0x20,
 201         _1000bpsF = 0x10,
 202         _100bps = 0x08,
 203         _10bps = 0x04,
 204         LinkStatus = 0x02,
 205         FullDup = 0x01,
 206
 207         /*GIGABIT_PHY_registers */
 208         PHY_CTRL_REG = 0,
 209         PHY_STAT_REG = 1,
 210         PHY_AUTO_NEGO_REG = 4,
 211         PHY_1000_CTRL_REG = 9,
 212
 213         /*GIGABIT_PHY_REG_BIT */
 214         PHY_Restart_Auto_Nego = 0x0200,
 215         PHY_Enable_Auto_Nego = 0x1000,
 216
 217         //PHY_STAT_REG = 1;
 218         PHY_Auto_Neco_Comp = 0x0020,
 219
 220         //PHY_AUTO_NEGO_REG = 4;
 221         PHY_Cap_10_Half = 0x0020,
 222         PHY_Cap_10_Full = 0x0040,
 223         PHY_Cap_100_Half = 0x0080,
 224         PHY_Cap_100_Full = 0x0100,
 225
 226         //PHY_1000_CTRL_REG = 9;
 227         PHY_Cap_1000_Full = 0x0200,
 228
 229         PHY_Cap_Null = 0x0,
 230
 231         /*_MediaType*/
 232         _10_Half = 0x01,
 233         _10_Full = 0x02,
 234         _100_Half = 0x04,
 235         _100_Full = 0x08,
 236         _1000_Full = 0x10,
 237
 238         /*_TBICSRBit*/
 239         TBILinkOK = 0x02000000,
 240 };
 241
 242 const static struct {
 243         const char *name;
 244         u8 version;             /* depend on RTL8169 docs */
 245         u32 RxConfigMask;       /* should clear the bits supported by this chip */
 246 } rtl_chip_info[] = {
 247         {
 248 "RTL-8169", 0x00, 0xff7e1880,},};
 249
 250 enum _DescStatusBit {
 251         OWNbit = 0x80000000,
 252         EORbit = 0x40000000,
 253         FSbit = 0x20000000,
 254         LSbit = 0x10000000,
 255 };
 256
 257 struct TxDesc {
 258         u32 status;
 259         u32 vlan_tag;
 260         u32 buf_addr;
 261         u32 buf_Haddr;
 262 };
 263
 264 struct RxDesc {
 265         u32 status;
 266         u32 vlan_tag;
 267         u32 buf_addr;
 268         u32 buf_Haddr;
 269 };
 270
 271 struct rtl8169_private {
 272         void *mmio_addr;        /* memory map physical address */
 273         struct pci_dev *pci_dev;        /* Index of PCI device  */
 274         struct net_device_stats stats;  /* statistics of net device */
 275         spinlock_t lock;        /* spin lock flag */
 276         int chipset;
 277         unsigned long cur_rx;   /* Index into the Rx descriptor buffer of next Rx pkt. */
 278         unsigned long cur_tx;   /* Index into the Tx descriptor buffer of next Rx pkt. */
 279         unsigned long dirty_tx;
 280         unsigned char *TxDescArrays;    /* Index of Tx Descriptor buffer */
 281         unsigned char *RxDescArrays;    /* Index of Rx Descriptor buffer */
 282         struct TxDesc *TxDescArray;     /* Index of 256-alignment Tx Descriptor buffer */
 283         struct RxDesc *RxDescArray;     /* Index of 256-alignment Rx Descriptor buffer */
 284         unsigned char *RxBufferRings;   /* Index of Rx Buffer  */
 285         unsigned char *RxBufferRing[NUM_RX_DESC];       /* Index of Rx Buffer array */
 286         struct sk_buff *Tx_skbuff[NUM_TX_DESC]; /* Index of Transmit data buffer */
 287 };
 288
 289 MODULE_AUTHOR("Realtek");
 290 MODULE_DESCRIPTION("RealTek RTL-8169 Gigabit Ethernet driver");
 291 MODULE_PARM(media, "1-" __MODULE_STRING(MAX_UNITS) "i");
 292
 293 static int rtl8169_open(struct net_device *dev);
 294 static int rtl8169_start_xmit(struct sk_buff *skb, struct net_device *dev);
 295 static void rtl8169_interrupt(int irq, void *dev_instance,
 296                               struct pt_regs *regs);
 297 static void rtl8169_init_ring(struct net_device *dev);
 298 static void rtl8169_hw_start(struct net_device *dev);
 299 static int rtl8169_close(struct net_device *dev);
 300 static void rtl8169_set_rx_mode(struct net_device *dev);
 301 static void rtl8169_tx_timeout(struct net_device *dev);
 302 static struct net_device_stats *rtl8169_get_stats(struct net_device *netdev);
 303
 304 static const u16 rtl8169_intr_mask =
 305     SYSErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver | TxErr | TxOK |
 306     RxErr | RxOK;
 307 static const unsigned int rtl8169_rx_config =
 308     (RX_FIFO_THRESH << RxCfgFIFOShift) | (RX_DMA_BURST << RxCfgDMAShift);
 309
 310 void
 311 mdio_write(void *ioaddr, int RegAddr, int value)
 312 {
 313         int i;
 314
 315         RTL_W32(PHYAR, 0x80000000 | (RegAddr & 0xFF) << 16 | value);
 316         udelay(1000);
 317
 318         for (i = 2000; i > 0; i--) {
 319                 // Check if the RTL8169 has completed writing to the specified MII register
 320                 if (!(RTL_R32(PHYAR) & 0x80000000)) {
 321                         break;
 322                 } else {
 323                         udelay(100);
 324                 }
 325         }
 326 }
 327
 328 int
 329 mdio_read(void *ioaddr, int RegAddr)
 330 {
 331         int i, value = -1;
 332
 333         RTL_W32(PHYAR, 0x0 | (RegAddr & 0xFF) << 16);
 334         udelay(1000);
 335
 336         for (i = 2000; i > 0; i--) {
 337                 // Check if the RTL8169 has completed retrieving data from the specified MII register
 338                 if (RTL_R32(PHYAR) & 0x80000000) {
 339                         value = (int) (RTL_R32(PHYAR) & 0xFFFF);
 340                         break;
 341                 } else {
 342                         udelay(100);
 343                 }
 344         }
 345         return value;
 346 }
 347
 348 static int __devinit
 349 rtl8169_init_board(struct pci_dev *pdev, struct net_device **dev_out,
 350                    void **ioaddr_out)
 351 {
 352         void *ioaddr = NULL;
 353         struct net_device *dev;
 354         struct rtl8169_private *tp;
 355         int rc, i;
 356         unsigned long mmio_start, mmio_end, mmio_flags, mmio_len;
 357         u32 tmp;
 358
 359         assert(pdev != NULL);
 360         assert(ioaddr_out != NULL);
 361
 362         *ioaddr_out = NULL;
 363         *dev_out = NULL;
 364
 365         // dev zeroed in init_etherdev
 366         dev = init_etherdev(NULL, sizeof (*tp));
 367         if (dev == NULL) {
 368                 printk(KERN_ERR PFX "unable to alloc new ethernet\n");
 369                 return -ENOMEM;
 370         }
 371
 372         SET_MODULE_OWNER(dev);
 373         tp = dev->priv;
 374
 375         // enable device (incl. PCI PM wakeup and hotplug setup)
 376         rc = pci_enable_device(pdev);
 377         if (rc)
 378                 goto err_out;
 379
 380         mmio_start = pci_resource_start(pdev, 1);
 381         mmio_end = pci_resource_end(pdev, 1);
 382         mmio_flags = pci_resource_flags(pdev, 1);
 383         mmio_len = pci_resource_len(pdev, 1);
 384
 385         // make sure PCI base addr 1 is MMIO
 386         if (!(mmio_flags & IORESOURCE_MEM)) {
 387                 printk(KERN_ERR PFX
 388                        "region #1 not an MMIO resource, aborting\n");
 389                 rc = -ENODEV;
 390                 goto err_out;
 391         }
 392         // check for weird/broken PCI region reporting
 393         if (mmio_len < RTL_MIN_IO_SIZE) {
 394                 printk(KERN_ERR PFX "Invalid PCI region size(s), aborting\n");
 395                 rc = -ENODEV;
 396                 goto err_out;
 397         }
 398
 399         rc = pci_request_regions(pdev, dev->name);
 400         if (rc)
 401                 goto err_out;
 402
 403         // enable PCI bus-mastering
 404         pci_set_master(pdev);
 405
 406         // ioremap MMIO region
 407         ioaddr = ioremap(mmio_start, mmio_len);
 408         if (ioaddr == NULL) {
 409                 printk(KERN_ERR PFX "cannot remap MMIO, aborting\n");
 410                 rc = -EIO;
 411                 goto err_out_free_res;
 412         }
 413
 414         // Soft reset the chip.
 415         RTL_W8(ChipCmd, CmdReset);
 416
 417         // Check that the chip has finished the reset.
 418         for (i = 1000; i > 0; i--)
 419                 if ((RTL_R8(ChipCmd) & CmdReset) == 0)
 420                         break;
 421                 else
 422                         udelay(10);
 423
 424         // identify chip attached to board
 425         tmp = RTL_R32(TxConfig);
 426         tmp = ((tmp & 0x7c000000) + ((tmp & 0x00800000) << 2)) >> 24;
 427
 428         for (i = ARRAY_SIZE(rtl_chip_info) - 1; i >= 0; i--)
 429                 if (tmp == rtl_chip_info[i].version) {
 430                         tp->chipset = i;
 431                         goto match;
 432                 }
 433         //if unknown chip, assume array element #0, original RTL-8169 in this case
 434         printk(KERN_DEBUG PFX
 435                "PCI device %s: unknown chip version, assuming RTL-8169\n",
 436                pdev->slot_name);
 437         printk(KERN_DEBUG PFX "PCI device %s: TxConfig = 0x%lx\n",
 438                pdev->slot_name, (unsigned long) RTL_R32(TxConfig));
 439         tp->chipset = 0;
 440
 441 match:
 442         *ioaddr_out = ioaddr;
 443         *dev_out = dev;
 444         return 0;
 445
 446 err_out_free_res:
 447         pci_release_regions(pdev);
 448
 449 err_out:
 450         unregister_netdev(dev);
 451         kfree(dev);
 452         return rc;
 453 }
 454
 455 static int __devinit
 456 rtl8169_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 457 {
 458         struct net_device *dev = NULL;
 459         struct rtl8169_private *tp = NULL;
 460         void *ioaddr = NULL;
 461         static int board_idx = -1;
 462         static int printed_version = 0;
 463         int i;
 464         int option = -1, Cap10_100 = 0, Cap1000 = 0;
 465
 466         assert(pdev != NULL);
 467         assert(ent != NULL);
 468
 469         board_idx++;
 470
 471         if (!printed_version) {
 472                 printk(KERN_INFO RTL8169_DRIVER_NAME " loaded\n");
 473                 printed_version = 1;
 474         }
 475
 476         i = rtl8169_init_board(pdev, &dev, &ioaddr);
 477         if (i < 0) {
 478                 return i;
 479         }
 480
 481         tp = dev->priv;
 482         assert(ioaddr != NULL);
 483         assert(dev != NULL);
 484         assert(tp != NULL);
 485
 486         // Get MAC address //
 487         for (i = 0; i < MAC_ADDR_LEN; i++) {
 488                 dev->dev_addr[i] = RTL_R8(MAC0 + i);
 489         }
 490
 491         dev->open = rtl8169_open;
 492         dev->hard_start_xmit = rtl8169_start_xmit;
 493         dev->get_stats = rtl8169_get_stats;
 494         dev->stop = rtl8169_close;
 495         dev->tx_timeout = rtl8169_tx_timeout;
 496         dev->set_multicast_list = rtl8169_set_rx_mode;
 497         dev->watchdog_timeo = TX_TIMEOUT;
 498         dev->irq = pdev->irq;
 499         dev->base_addr = (unsigned long) ioaddr;
 500 //      dev->do_ioctl           = mii_ioctl;
 501
 502         tp = dev->priv;         // private data //
 503         tp->pci_dev = pdev;
 504         tp->mmio_addr = ioaddr;
 505
 506         printk(KERN_DEBUG "%s: Identified chip type is '%s'.\n", dev->name,
 507                rtl_chip_info[tp->chipset].name);
 508
 509         spin_lock_init(&tp->lock);
 510
 511         pci_set_drvdata(pdev, dev);
 512
 513         printk(KERN_INFO "%s: %s at 0x%lx, "
 514                "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x, "
 515                "IRQ %d\n",
 516                dev->name,
 517                board_info[ent->driver_data].name,
 518                dev->base_addr,
 519                dev->dev_addr[0], dev->dev_addr[1],
 520                dev->dev_addr[2], dev->dev_addr[3],
 521                dev->dev_addr[4], dev->dev_addr[5], dev->irq);
 522
 523         // if TBI is not endbled
 524         if (!(RTL_R8(PHYstatus) & TBI_Enable)) {
 525                 int val = mdio_read(ioaddr, PHY_AUTO_NEGO_REG);
 526
 527                 option = (board_idx >= MAX_UNITS) ? 0 : media[board_idx];
 528                 // Force RTL8169 in 10/100/1000 Full/Half mode.
 529                 if (option > 0) {
 530                         printk(KERN_INFO "%s: Force-mode Enabled.\n",
 531                                dev->name);
 532                         Cap10_100 = 0, Cap1000 = 0;
 533                         switch (option) {
 534                         case _10_Half:
 535                                 Cap10_100 = PHY_Cap_10_Half;
 536                                 Cap1000 = PHY_Cap_Null;
 537                                 break;
 538                         case _10_Full:
 539                                 Cap10_100 = PHY_Cap_10_Full;
 540                                 Cap1000 = PHY_Cap_Null;
 541                                 break;
 542                         case _100_Half:
 543                                 Cap10_100 = PHY_Cap_100_Half;
 544                                 Cap1000 = PHY_Cap_Null;
 545                                 break;
 546                         case _100_Full:
 547                                 Cap10_100 = PHY_Cap_100_Full;
 548                                 Cap1000 = PHY_Cap_Null;
 549                                 break;
 550                         case _1000_Full:
 551                                 Cap10_100 = PHY_Cap_Null;
 552                                 Cap1000 = PHY_Cap_1000_Full;
 553                                 break;
 554                         default:
 555                                 break;
 556                         }
 557                         mdio_write(ioaddr, PHY_AUTO_NEGO_REG, Cap10_100 | (val & 0x1F));        //leave PHY_AUTO_NEGO_REG bit4:0 unchanged
 558                         mdio_write(ioaddr, PHY_1000_CTRL_REG, Cap1000);
 559                 } else {
 560                         printk(KERN_INFO "%s: Auto-negotiation Enabled.\n",
 561                                dev->name);
 562
 563                         // enable 10/100 Full/Half Mode, leave PHY_AUTO_NEGO_REG bit4:0 unchanged
 564                         mdio_write(ioaddr, PHY_AUTO_NEGO_REG,
 565                                    PHY_Cap_10_Half | PHY_Cap_10_Full |
 566                                    PHY_Cap_100_Half | PHY_Cap_100_Full | (val &
 567                                                                           0x1F));
 568
 569                         // enable 1000 Full Mode
 570                         mdio_write(ioaddr, PHY_1000_CTRL_REG,
 571                                    PHY_Cap_1000_Full);
 572
 573                 }
 574
 575                 // Enable auto-negotiation and restart auto-nigotiation
 576                 mdio_write(ioaddr, PHY_CTRL_REG,
 577                            PHY_Enable_Auto_Nego | PHY_Restart_Auto_Nego);
 578                 udelay(100);
 579
 580                 // wait for auto-negotiation process
 581                 for (i = 10000; i > 0; i--) {
 582                         //check if auto-negotiation complete
 583                         if (mdio_read(ioaddr, PHY_STAT_REG) &
 584                             PHY_Auto_Neco_Comp) {
 585                                 udelay(100);
 586                                 option = RTL_R8(PHYstatus);
 587                                 if (option & _1000bpsF) {
 588                                         printk(KERN_INFO
 589                                                "%s: 1000Mbps Full-duplex operation.\n",
 590                                                dev->name);
 591                                 } else {
 592                                         printk(KERN_INFO
 593                                                "%s: %sMbps %s-duplex operation.\n",
 594                                                dev->name,
 595                                                (option & _100bps) ? "100" :
 596                                                "10",
 597                                                (option & FullDup) ? "Full" :
 598                                                "Half");
 599                                 }
 600                                 break;
 601                         } else {
 602                                 udelay(100);
 603                         }
 604                 }               // end for-loop to wait for auto-negotiation process
 605
 606         } else {
 607                 udelay(100);
 608                 printk(KERN_INFO
 609                        "%s: 1000Mbps Full-duplex operation, TBI Link %s!\n",
 610                        dev->name,
 611                        (RTL_R32(TBICSR) & TBILinkOK) ? "OK" : "Failed");
 612
 613         }
 614
 615         return 0;
 616 }
 617
 618 static void __devexit
 619 rtl8169_remove_one(struct pci_dev *pdev)
 620 {
 621         struct net_device *dev = pci_get_drvdata(pdev);
 622         struct rtl8169_private *tp = (struct rtl8169_private *) (dev->priv);
 623
 624         assert(dev != NULL);
 625         assert(tp != NULL);
 626
 627         unregister_netdev(dev);
 628         iounmap(tp->mmio_addr);
 629         pci_release_regions(pdev);
 630
 631         // poison memory before freeing
 632         memset(dev, 0xBC,
 633                sizeof (struct net_device) + sizeof (struct rtl8169_private));
 634
 635         kfree(dev);
 636         pci_set_drvdata(pdev, NULL);
 637 }
 638
 639 static int
 640 rtl8169_open(struct net_device *dev)
 641 {
 642         struct rtl8169_private *tp = dev->priv;
 643         int retval;
 644         u8 diff;
 645         u32 TxPhyAddr, RxPhyAddr;
 646
 647         retval =
 648             request_irq(dev->irq, rtl8169_interrupt, SA_SHIRQ, dev->name, dev);
 649         if (retval) {
 650                 return retval;
 651         }
 652
 653         tp->TxDescArrays =
 654             kmalloc(NUM_TX_DESC * sizeof (struct TxDesc) + 256, GFP_KERNEL);
 655         // Tx Desscriptor needs 256 bytes alignment;
 656         TxPhyAddr = virt_to_bus(tp->TxDescArrays);
 657         diff = 256 - (TxPhyAddr - ((TxPhyAddr >> 8) << 8));
 658         TxPhyAddr += diff;
 659         tp->TxDescArray = (struct TxDesc *) (tp->TxDescArrays + diff);
 660
 661         tp->RxDescArrays =
 662             kmalloc(NUM_RX_DESC * sizeof (struct RxDesc) + 256, GFP_KERNEL);
 663         // Rx Desscriptor needs 256 bytes alignment;
 664         RxPhyAddr = virt_to_bus(tp->RxDescArrays);
 665         diff = 256 - (RxPhyAddr - ((RxPhyAddr >> 8) << 8));
 666         RxPhyAddr += diff;
 667         tp->RxDescArray = (struct RxDesc *) (tp->RxDescArrays + diff);
 668
 669         if (tp->TxDescArrays == NULL || tp->RxDescArrays == NULL) {
 670                 printk(KERN_INFO
 671                        "Allocate RxDescArray or TxDescArray failed\n");
 672                 free_irq(dev->irq, dev);
 673                 if (tp->TxDescArrays)
 674                         kfree(tp->TxDescArrays);
 675                 if (tp->RxDescArrays)
 676                         kfree(tp->RxDescArrays);
 677                 return -ENOMEM;
 678         }
 679         tp->RxBufferRings = kmalloc(RX_BUF_SIZE * NUM_RX_DESC, GFP_KERNEL);
 680         if (tp->RxBufferRings == NULL) {
 681                 printk(KERN_INFO "Allocate RxBufferRing failed\n");
 682         }
 683
 684         rtl8169_init_ring(dev);
 685         rtl8169_hw_start(dev);
 686
 687         return 0;
 688
 689 }
 690
 691 static void
 692 rtl8169_hw_start(struct net_device *dev)
 693 {
 694         struct rtl8169_private *tp = dev->priv;
 695         void *ioaddr = tp->mmio_addr;
 696         u32 i;
 697
 698         /* Soft reset the chip. */
 699         RTL_W8(ChipCmd, CmdReset);
 700
 701         /* Check that the chip has finished the reset. */
 702         for (i = 1000; i > 0; i--) {
 703                 if ((RTL_R8(ChipCmd) & CmdReset) == 0)
 704                         break;
 705                 else
 706                         udelay(10);
 707         }
 708
 709         RTL_W8(Cfg9346, Cfg9346_Unlock);
 710         RTL_W8(ChipCmd, CmdTxEnb | CmdRxEnb);
 711         RTL_W8(EarlyTxThres, EarlyTxThld);
 712
 713         // For gigabit rtl8169
 714         RTL_W16(RxMaxSize, RxPacketMaxSize);
 715
 716         // Set Rx Config register
 717         i = rtl8169_rx_config | (RTL_R32(RxConfig) & rtl_chip_info[tp->chipset].
 718                                  RxConfigMask);
 719         RTL_W32(RxConfig, i);
 720
 721         /* Set DMA burst size and Interframe Gap Time */
 722         RTL_W32(TxConfig,
 723                 (TX_DMA_BURST << TxDMAShift) | (InterFrameGap <<
 724                                                 TxInterFrameGapShift));
 725
 726         tp->cur_rx = 0;
 727
 728         RTL_W32(TxDescStartAddr, virt_to_bus(tp->TxDescArray));
 729         RTL_W32(RxDescStartAddr, virt_to_bus(tp->RxDescArray));
 730         RTL_W8(Cfg9346, Cfg9346_Lock);
 731         udelay(10);
 732
 733         RTL_W32(RxMissed, 0);
 734
 735         rtl8169_set_rx_mode(dev);
 736
 737         /* no early-rx interrupts */
 738         RTL_W16(MultiIntr, RTL_R16(MultiIntr) & 0xF000);
 739
 740         /* Enable all known interrupts by setting the interrupt mask. */
 741         RTL_W16(IntrMask, rtl8169_intr_mask);
 742
 743         netif_start_queue(dev);
 744
 745 }
 746
 747 static void
 748 rtl8169_init_ring(struct net_device *dev)
 749 {
 750         struct rtl8169_private *tp = dev->priv;
 751         int i;
 752
 753         tp->cur_rx = 0;
 754         tp->cur_tx = 0;
 755         tp->dirty_tx = 0;
 756         memset(tp->TxDescArray, 0x0, NUM_TX_DESC * sizeof (struct TxDesc));
 757         memset(tp->RxDescArray, 0x0, NUM_RX_DESC * sizeof (struct RxDesc));
 758
 759         for (i = 0; i < NUM_TX_DESC; i++) {
 760                 tp->Tx_skbuff[i] = NULL;
 761         }
 762         for (i = 0; i < NUM_RX_DESC; i++) {
 763                 if (i == (NUM_RX_DESC - 1))
 764                         tp->RxDescArray[i].status =
 765                             (OWNbit | EORbit) + RX_BUF_SIZE;
 766                 else
 767                         tp->RxDescArray[i].status = OWNbit + RX_BUF_SIZE;
 768
 769                 tp->RxBufferRing[i] = &(tp->RxBufferRings[i * RX_BUF_SIZE]);
 770                 tp->RxDescArray[i].buf_addr = virt_to_bus(tp->RxBufferRing[i]);
 771         }
 772 }
 773
 774 static void
 775 rtl8169_tx_clear(struct rtl8169_private *tp)
 776 {
 777         int i;
 778
 779         tp->cur_tx = 0;
 780         for (i = 0; i < NUM_TX_DESC; i++) {
 781                 if (tp->Tx_skbuff[i] != NULL) {
 782                         dev_kfree_skb(tp->Tx_skbuff[i]);
 783                         tp->Tx_skbuff[i] = NULL;
 784                         tp->stats.tx_dropped++;
 785                 }
 786         }
 787 }
 788
 789 static void
 790 rtl8169_tx_timeout(struct net_device *dev)
 791 {
 792         struct rtl8169_private *tp = dev->priv;
 793         void *ioaddr = tp->mmio_addr;
 794         u8 tmp8;
 795
 796         /* disable Tx, if not already */
 797         tmp8 = RTL_R8(ChipCmd);
 798         if (tmp8 & CmdTxEnb)
 799                 RTL_W8(ChipCmd, tmp8 & ~CmdTxEnb);
 800
 801         /* Disable interrupts by clearing the interrupt mask. */
 802         RTL_W16(IntrMask, 0x0000);
 803
 804         /* Stop a shared interrupt from scavenging while we are. */
 805         spin_lock_irq(&tp->lock);
 806         rtl8169_tx_clear(tp);
 807         spin_unlock_irq(&tp->lock);
 808
 809         /* ...and finally, reset everything */
 810         rtl8169_hw_start(dev);
 811
 812         netif_wake_queue(dev);
 813 }
 814
 815 static int
 816 rtl8169_start_xmit(struct sk_buff *skb, struct net_device *dev)
 817 {
 818         struct rtl8169_private *tp = dev->priv;
 819         void *ioaddr = tp->mmio_addr;
 820         int entry = tp->cur_tx % NUM_TX_DESC;
 821
 822         spin_lock_irq(&tp->lock);
 823
 824         if ((tp->TxDescArray[entry].status & OWNbit) == 0) {
 825                 tp->Tx_skbuff[entry] = skb;
 826                 tp->TxDescArray[entry].buf_addr = virt_to_bus(skb->data);
 827                 if (entry != (NUM_TX_DESC - 1))
 828                         tp->TxDescArray[entry].status =
 829                             (OWNbit | FSbit | LSbit) | ((skb->len > ETH_ZLEN) ?
 830                                                         skb->len : ETH_ZLEN);
 831                 else
 832                         tp->TxDescArray[entry].status =
 833                             (OWNbit | EORbit | FSbit | LSbit) |
 834                             ((skb->len > ETH_ZLEN) ? skb->len : ETH_ZLEN);
 835
 836                 RTL_W8(TxPoll, 0x40);   //set polling bit
 837
 838                 dev->trans_start = jiffies;
 839
 840                 tp->cur_tx++;
 841         }
 842
 843         spin_unlock_irq(&tp->lock);
 844
 845         if ((tp->cur_tx - NUM_TX_DESC) == tp->dirty_tx) {
 846                 netif_stop_queue(dev);
 847         }
 848
 849         return 0;
 850 }
 851
 852 static void
 853 rtl8169_tx_interrupt(struct net_device *dev, struct rtl8169_private *tp,
 854                      void *ioaddr)
 855 {
 856         unsigned long dirty_tx, tx_left = 0;
 857         int entry = tp->cur_tx % NUM_TX_DESC;
 858
 859         assert(dev != NULL);
 860         assert(tp != NULL);
 861         assert(ioaddr != NULL);
 862
 863         dirty_tx = tp->dirty_tx;
 864         tx_left = tp->cur_tx - dirty_tx;
 865
 866         while (tx_left > 0) {
 867                 if ((tp->TxDescArray[entry].status & OWNbit) == 0) {
 868                         dev_kfree_skb_irq(tp->
 869                                           Tx_skbuff[dirty_tx % NUM_TX_DESC]);
 870                         tp->Tx_skbuff[dirty_tx % NUM_TX_DESC] = NULL;
 871                         tp->stats.tx_packets++;
 872                         dirty_tx++;
 873                         tx_left--;
 874                         entry++;
 875                 }
 876         }
 877
 878         if (tp->dirty_tx != dirty_tx) {
 879                 tp->dirty_tx = dirty_tx;
 880                 if (netif_queue_stopped(dev))
 881                         netif_wake_queue(dev);
 882         }
 883 }
 884
 885 static void
 886 rtl8169_rx_interrupt(struct net_device *dev, struct rtl8169_private *tp,
 887                      void *ioaddr)
 888 {
 889         int cur_rx;
 890         struct sk_buff *skb;
 891         int pkt_size = 0;
 892
 893         assert(dev != NULL);
 894         assert(tp != NULL);
 895         assert(ioaddr != NULL);
 896
 897         cur_rx = tp->cur_rx;
 898
 899         while ((tp->RxDescArray[cur_rx].status & OWNbit) == 0) {
 900
 901                 if (tp->RxDescArray[cur_rx].status & RxRES) {
 902                         printk(KERN_INFO "%s: Rx ERROR!!!\n", dev->name);
 903                         tp->stats.rx_errors++;
 904                         if (tp->RxDescArray[cur_rx].status & (RxRWT | RxRUNT))
 905                                 tp->stats.rx_length_errors++;
 906                         if (tp->RxDescArray[cur_rx].status & RxCRC)
 907                                 tp->stats.rx_crc_errors++;
 908                 } else {
 909                         pkt_size =
 910                             (int) (tp->RxDescArray[cur_rx].
 911                                    status & 0x00001FFF) - 4;
 912                         skb = dev_alloc_skb(pkt_size + 2);
 913                         if (skb != NULL) {
 914                                 skb->dev = dev;
 915                                 skb_reserve(skb, 2);    // 16 byte align the IP fields. //
 916                                 eth_copy_and_sum(skb, tp->RxBufferRing[cur_rx],
 917                                                  pkt_size, 0);
 918                                 skb_put(skb, pkt_size);
 919                                 skb->protocol = eth_type_trans(skb, dev);
 920                                 netif_rx(skb);
 921
 922                                 if (cur_rx == (NUM_RX_DESC - 1))
 923                                         tp->RxDescArray[cur_rx].status =
 924                                             (OWNbit | EORbit) + RX_BUF_SIZE;
 925                                 else
 926                                         tp->RxDescArray[cur_rx].status =
 927                                             OWNbit + RX_BUF_SIZE;
 928
 929                                 tp->RxDescArray[cur_rx].buf_addr =
 930                                     virt_to_bus(tp->RxBufferRing[cur_rx]);
 931                                 dev->last_rx = jiffies;
 932                                 tp->stats.rx_bytes += pkt_size;
 933                                 tp->stats.rx_packets++;
 934                         } else {
 935                                 printk(KERN_WARNING
 936                                        "%s: Memory squeeze, deferring packet.\n",
 937                                        dev->name);
 938                                 /* We should check that some rx space is free.
 939                                    If not, free one and mark stats->rx_dropped++. */
 940                                 tp->stats.rx_dropped++;
 941                         }
 942                 }
 943
 944                 cur_rx = (cur_rx + 1) % NUM_RX_DESC;
 945
 946         }
 947
 948         tp->cur_rx = cur_rx;
 949 }
 950
 951 /* The interrupt handler does all of the Rx thread work and cleans up after the Tx thread. */
 952 static void
 953 rtl8169_interrupt(int irq, void *dev_instance, struct pt_regs *regs)
 954 {
 955         struct net_device *dev = (struct net_device *) dev_instance;
 956         struct rtl8169_private *tp = dev->priv;
 957         int boguscnt = max_interrupt_work;
 958         void *ioaddr = tp->mmio_addr;
 959         int status = 0;
 960
 961         do {
 962                 status = RTL_R16(IntrStatus);
 963
 964                 /* h/w no longer present (hotplug?) or major error, bail */
 965                 if (status == 0xFFFF)
 966                         break;
 967
 968 /*
 969                 if (status & RxUnderrun)
 970                         link_changed = RTL_R16 (CSCR) & CSCR_LinkChangeBit;
 971 */
 972                 RTL_W16(IntrStatus,
 973                         (status & RxFIFOOver) ? (status | RxOverflow) : status);
 974
 975                 if ((status &
 976                      (SYSErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver
 977                       | TxErr | TxOK | RxErr | RxOK)) == 0)
 978                         break;
 979
 980                 // Rx interrupt
 981                 if (status & (RxOK | RxUnderrun | RxOverflow | RxFIFOOver)) {
 982                         rtl8169_rx_interrupt(dev, tp, ioaddr);
 983                 }
 984                 // Tx interrupt
 985                 if (status & (TxOK | TxErr)) {
 986                         spin_lock(&tp->lock);
 987                         rtl8169_tx_interrupt(dev, tp, ioaddr);
 988                         spin_unlock(&tp->lock);
 989                 }
 990
 991                 boguscnt--;
 992         } while (boguscnt > 0);
 993
 994         if (boguscnt <= 0) {
 995                 printk(KERN_WARNING "%s: Too much work at interrupt!\n",
 996                        dev->name);
 997                 /* Clear all interrupt sources. */
 998                 RTL_W16(IntrStatus, 0xffff);
 999         }
1000 }
1001
1002 static int
1003 rtl8169_close(struct net_device *dev)
1004 {
1005         struct rtl8169_private *tp = dev->priv;
1006         void *ioaddr = tp->mmio_addr;
1007         int i;
1008
1009         netif_stop_queue(dev);
1010
1011         spin_lock_irq(&tp->lock);
1012
1013         /* Stop the chip's Tx and Rx DMA processes. */
1014         RTL_W8(ChipCmd, 0x00);
1015
1016         /* Disable interrupts by clearing the interrupt mask. */
1017         RTL_W16(IntrMask, 0x0000);
1018
1019         /* Update the error counts. */
1020         tp->stats.rx_missed_errors += RTL_R32(RxMissed);
1021         RTL_W32(RxMissed, 0);
1022
1023         spin_unlock_irq(&tp->lock);
1024
1025         synchronize_irq();
1026         free_irq(dev->irq, dev);
1027
1028         rtl8169_tx_clear(tp);
1029         kfree(tp->TxDescArrays);
1030         kfree(tp->RxDescArrays);
1031         tp->TxDescArrays = NULL;
1032         tp->RxDescArrays = NULL;
1033         tp->TxDescArray = NULL;
1034         tp->RxDescArray = NULL;
1035         kfree(tp->RxBufferRings);
1036         for (i = 0; i < NUM_RX_DESC; i++) {
1037                 tp->RxBufferRing[i] = NULL;
1038         }
1039
1040         return 0;
1041 }
1042
1043 static void
1044 rtl8169_set_rx_mode(struct net_device *dev)
1045 {
1046         struct rtl8169_private *tp = dev->priv;
1047         void *ioaddr = tp->mmio_addr;
1048         unsigned long flags;
1049         u32 mc_filter[2];       /* Multicast hash filter */
1050         int i, rx_mode;
1051         u32 tmp = 0;
1052
1053         if (dev->flags & IFF_PROMISC) {
1054                 /* Unconditionally log net taps. */
1055                 printk(KERN_NOTICE "%s: Promiscuous mode enabled.\n",
1056                        dev->name);
1057                 rx_mode =
1058                     AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
1059                     AcceptAllPhys;
1060                 mc_filter[1] = mc_filter[0] = 0xffffffff;
1061         } else if ((dev->mc_count > multicast_filter_limit)
1062                    || (dev->flags & IFF_ALLMULTI)) {
1063                 /* Too many to filter perfectly -- accept all multicasts. */
1064                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1065                 mc_filter[1] = mc_filter[0] = 0xffffffff;
1066         } else {
1067                 struct dev_mc_list *mclist;
1068                 rx_mode = AcceptBroadcast | AcceptMyPhys;
1069                 mc_filter[1] = mc_filter[0] = 0;
1070                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
1071                      i++, mclist = mclist->next) {
1072                         int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
1073                         mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
1074                         rx_mode |= AcceptMulticast;
1075                 }
1076         }
1077
1078         spin_lock_irqsave(&tp->lock, flags);
1079
1080         tmp =
1081             rtl8169_rx_config | rx_mode | (RTL_R32(RxConfig) &
1082                                            rtl_chip_info[tp->chipset].
1083                                            RxConfigMask);
1084
1085         RTL_W32(RxConfig, tmp);
1086         RTL_W32(MAR0 + 0, mc_filter[0]);
1087         RTL_W32(MAR0 + 4, mc_filter[1]);
1088
1089         spin_unlock_irqrestore(&tp->lock, flags);
1090 }
1091
1092 struct net_device_stats *
1093 rtl8169_get_stats(struct net_device *dev)
1094 {
1095         struct rtl8169_private *tp = dev->priv;
1096
1097         return &tp->stats;
1098 }
1099
1100 static struct pci_driver rtl8169_pci_driver = {
1101         .name           = MODULENAME,
1102         .id_table       = rtl8169_pci_tbl,
1103         .probe          = rtl8169_init_one,
1104         .remove         = rtl8169_remove_one,
1105         .suspend        = NULL,
1106         .resume         = NULL,
1107 };
1108
1109 static int __init
1110 rtl8169_init_module(void)
1111 {
1112         return pci_module_init(&rtl8169_pci_driver);
1113 }
1114
1115 static void __exit
1116 rtl8169_cleanup_module(void)
1117 {
1118         pci_unregister_driver(&rtl8169_pci_driver);
1119 }
1120
1121 module_init(rtl8169_init_module);
1122 module_exit(rtl8169_cleanup_module);