drivers/net/ethernet/sis/sis190.c

   1 /*
   2    sis190.c: Silicon Integrated Systems SiS190 ethernet driver
   3
   4    Copyright (c) 2003 K.M. Liu <kmliu@sis.com>
   5    Copyright (c) 2003, 2004 Jeff Garzik <jgarzik@pobox.com>
   6    Copyright (c) 2003, 2004, 2005 Francois Romieu <romieu@fr.zoreil.com>
   7
   8    Based on r8169.c, tg3.c, 8139cp.c, skge.c, epic100.c and SiS 190/191
   9    genuine driver.
  10
  11    This software may be used and distributed according to the terms of
  12    the GNU General Public License (GPL), incorporated herein by reference.
  13    Drivers based on or derived from this code fall under the GPL and must
  14    retain the authorship, copyright and license notice.  This file is not
  15    a complete program and may only be used when the entire operating
  16    system is licensed under the GPL.
  17
  18    See the file COPYING in this distribution for more information.
  19
  20 */
  21
  22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  23
  24 #include <linux/interrupt.h>
  25 #include <linux/module.h>
  26 #include <linux/moduleparam.h>
  27 #include <linux/netdevice.h>
  28 #include <linux/rtnetlink.h>
  29 #include <linux/etherdevice.h>
  30 #include <linux/ethtool.h>
  31 #include <linux/pci.h>
  32 #include <linux/mii.h>
  33 #include <linux/delay.h>
  34 #include <linux/crc32.h>
  35 #include <linux/dma-mapping.h>
  36 #include <linux/slab.h>
  37 #include <asm/irq.h>
  38
  39 #define PHY_MAX_ADDR            32
  40 #define PHY_ID_ANY              0x1f
  41 #define MII_REG_ANY             0x1f
  42
  43 #define DRV_VERSION             "1.4"
  44 #define DRV_NAME                "sis190"
  45 #define SIS190_DRIVER_NAME      DRV_NAME " Gigabit Ethernet driver " DRV_VERSION
  46
  47 #define sis190_rx_skb                   netif_rx
  48 #define sis190_rx_quota(count, quota)   count
  49
  50 #define NUM_TX_DESC             64      /* [8..1024] */
  51 #define NUM_RX_DESC             64      /* [8..8192] */
  52 #define TX_RING_BYTES           (NUM_TX_DESC * sizeof(struct TxDesc))
  53 #define RX_RING_BYTES           (NUM_RX_DESC * sizeof(struct RxDesc))
  54 #define RX_BUF_SIZE             1536
  55 #define RX_BUF_MASK             0xfff8
  56
  57 #define SIS190_REGS_SIZE        0x80
  58 #define SIS190_TX_TIMEOUT       (6*HZ)
  59 #define SIS190_PHY_TIMEOUT      (10*HZ)
  60 #define SIS190_MSG_DEFAULT      (NETIF_MSG_DRV | NETIF_MSG_PROBE | \
  61                                  NETIF_MSG_LINK | NETIF_MSG_IFUP | \
  62                                  NETIF_MSG_IFDOWN)
  63
  64 /* Enhanced PHY access register bit definitions */
  65 #define EhnMIIread              0x0000
  66 #define EhnMIIwrite             0x0020
  67 #define EhnMIIdataShift         16
  68 #define EhnMIIpmdShift          6       /* 7016 only */
  69 #define EhnMIIregShift          11
  70 #define EhnMIIreq               0x0010
  71 #define EhnMIInotDone           0x0010
  72
  73 /* Write/read MMIO register */
  74 #define SIS_W8(reg, val)        writeb ((val), ioaddr + (reg))
  75 #define SIS_W16(reg, val)       writew ((val), ioaddr + (reg))
  76 #define SIS_W32(reg, val)       writel ((val), ioaddr + (reg))
  77 #define SIS_R8(reg)             readb (ioaddr + (reg))
  78 #define SIS_R16(reg)            readw (ioaddr + (reg))
  79 #define SIS_R32(reg)            readl (ioaddr + (reg))
  80
  81 #define SIS_PCI_COMMIT()        SIS_R32(IntrControl)
  82
  83 enum sis190_registers {
  84         TxControl               = 0x00,
  85         TxDescStartAddr         = 0x04,
  86         rsv0                    = 0x08, // reserved
  87         TxSts                   = 0x0c, // unused (Control/Status)
  88         RxControl               = 0x10,
  89         RxDescStartAddr         = 0x14,
  90         rsv1                    = 0x18, // reserved
  91         RxSts                   = 0x1c, // unused
  92         IntrStatus              = 0x20,
  93         IntrMask                = 0x24,
  94         IntrControl             = 0x28,
  95         IntrTimer               = 0x2c, // unused (Interrupt Timer)
  96         PMControl               = 0x30, // unused (Power Mgmt Control/Status)
  97         rsv2                    = 0x34, // reserved
  98         ROMControl              = 0x38,
  99         ROMInterface            = 0x3c,
 100         StationControl          = 0x40,
 101         GMIIControl             = 0x44,
 102         GIoCR                   = 0x48, // unused (GMAC IO Compensation)
 103         GIoCtrl                 = 0x4c, // unused (GMAC IO Control)
 104         TxMacControl            = 0x50,
 105         TxLimit                 = 0x54, // unused (Tx MAC Timer/TryLimit)
 106         RGDelay                 = 0x58, // unused (RGMII Tx Internal Delay)
 107         rsv3                    = 0x5c, // reserved
 108         RxMacControl            = 0x60,
 109         RxMacAddr               = 0x62,
 110         RxHashTable             = 0x68,
 111         // Undocumented         = 0x6c,
 112         RxWolCtrl               = 0x70,
 113         RxWolData               = 0x74, // unused (Rx WOL Data Access)
 114         RxMPSControl            = 0x78, // unused (Rx MPS Control)
 115         rsv4                    = 0x7c, // reserved
 116 };
 117
 118 enum sis190_register_content {
 119         /* IntrStatus */
 120         SoftInt                 = 0x40000000,   // unused
 121         Timeup                  = 0x20000000,   // unused
 122         PauseFrame              = 0x00080000,   // unused
 123         MagicPacket             = 0x00040000,   // unused
 124         WakeupFrame             = 0x00020000,   // unused
 125         LinkChange              = 0x00010000,
 126         RxQEmpty                = 0x00000080,
 127         RxQInt                  = 0x00000040,
 128         TxQ1Empty               = 0x00000020,   // unused
 129         TxQ1Int                 = 0x00000010,
 130         TxQ0Empty               = 0x00000008,   // unused
 131         TxQ0Int                 = 0x00000004,
 132         RxHalt                  = 0x00000002,
 133         TxHalt                  = 0x00000001,
 134
 135         /* {Rx/Tx}CmdBits */
 136         CmdReset                = 0x10,
 137         CmdRxEnb                = 0x08,         // unused
 138         CmdTxEnb                = 0x01,
 139         RxBufEmpty              = 0x01,         // unused
 140
 141         /* Cfg9346Bits */
 142         Cfg9346_Lock            = 0x00,         // unused
 143         Cfg9346_Unlock          = 0xc0,         // unused
 144
 145         /* RxMacControl */
 146         AcceptErr               = 0x20,         // unused
 147         AcceptRunt              = 0x10,         // unused
 148         AcceptBroadcast         = 0x0800,
 149         AcceptMulticast         = 0x0400,
 150         AcceptMyPhys            = 0x0200,
 151         AcceptAllPhys           = 0x0100,
 152
 153         /* RxConfigBits */
 154         RxCfgFIFOShift          = 13,
 155         RxCfgDMAShift           = 8,            // 0x1a in RxControl ?
 156
 157         /* TxConfigBits */
 158         TxInterFrameGapShift    = 24,
 159         TxDMAShift              = 8, /* DMA burst value (0-7) is shift this many bits */
 160
 161         LinkStatus              = 0x02,         // unused
 162         FullDup                 = 0x01,         // unused
 163
 164         /* TBICSRBit */
 165         TBILinkOK               = 0x02000000,   // unused
 166 };
 167
 168 struct TxDesc {
 169         __le32 PSize;
 170         __le32 status;
 171         __le32 addr;
 172         __le32 size;
 173 };
 174
 175 struct RxDesc {
 176         __le32 PSize;
 177         __le32 status;
 178         __le32 addr;
 179         __le32 size;
 180 };
 181
 182 enum _DescStatusBit {
 183         /* _Desc.status */
 184         OWNbit          = 0x80000000, // RXOWN/TXOWN
 185         INTbit          = 0x40000000, // RXINT/TXINT
 186         CRCbit          = 0x00020000, // CRCOFF/CRCEN
 187         PADbit          = 0x00010000, // PREADD/PADEN
 188         /* _Desc.size */
 189         RingEnd         = 0x80000000,
 190         /* TxDesc.status */
 191         LSEN            = 0x08000000, // TSO ? -- FR
 192         IPCS            = 0x04000000,
 193         TCPCS           = 0x02000000,
 194         UDPCS           = 0x01000000,
 195         BSTEN           = 0x00800000,
 196         EXTEN           = 0x00400000,
 197         DEFEN           = 0x00200000,
 198         BKFEN           = 0x00100000,
 199         CRSEN           = 0x00080000,
 200         COLEN           = 0x00040000,
 201         THOL3           = 0x30000000,
 202         THOL2           = 0x20000000,
 203         THOL1           = 0x10000000,
 204         THOL0           = 0x00000000,
 205
 206         WND             = 0x00080000,
 207         TABRT           = 0x00040000,
 208         FIFO            = 0x00020000,
 209         LINK            = 0x00010000,
 210         ColCountMask    = 0x0000ffff,
 211         /* RxDesc.status */
 212         IPON            = 0x20000000,
 213         TCPON           = 0x10000000,
 214         UDPON           = 0x08000000,
 215         Wakup           = 0x00400000,
 216         Magic           = 0x00200000,
 217         Pause           = 0x00100000,
 218         DEFbit          = 0x00200000,
 219         BCAST           = 0x000c0000,
 220         MCAST           = 0x00080000,
 221         UCAST           = 0x00040000,
 222         /* RxDesc.PSize */
 223         TAGON           = 0x80000000,
 224         RxDescCountMask = 0x7f000000, // multi-desc pkt when > 1 ? -- FR
 225         ABORT           = 0x00800000,
 226         SHORT           = 0x00400000,
 227         LIMIT           = 0x00200000,
 228         MIIER           = 0x00100000,
 229         OVRUN           = 0x00080000,
 230         NIBON           = 0x00040000,
 231         COLON           = 0x00020000,
 232         CRCOK           = 0x00010000,
 233         RxSizeMask      = 0x0000ffff
 234         /*
 235          * The asic could apparently do vlan, TSO, jumbo (sis191 only) and
 236          * provide two (unused with Linux) Tx queues. No publicly
 237          * available documentation alas.
 238          */
 239 };
 240
 241 enum sis190_eeprom_access_register_bits {
 242         EECS    = 0x00000001,   // unused
 243         EECLK   = 0x00000002,   // unused
 244         EEDO    = 0x00000008,   // unused
 245         EEDI    = 0x00000004,   // unused
 246         EEREQ   = 0x00000080,
 247         EEROP   = 0x00000200,
 248         EEWOP   = 0x00000100    // unused
 249 };
 250
 251 /* EEPROM Addresses */
 252 enum sis190_eeprom_address {
 253         EEPROMSignature = 0x00,
 254         EEPROMCLK       = 0x01, // unused
 255         EEPROMInfo      = 0x02,
 256         EEPROMMACAddr   = 0x03
 257 };
 258
 259 enum sis190_feature {
 260         F_HAS_RGMII     = 1,
 261         F_PHY_88E1111   = 2,
 262         F_PHY_BCM5461   = 4
 263 };
 264
 265 struct sis190_private {
 266         void __iomem *mmio_addr;
 267         struct pci_dev *pci_dev;
 268         struct net_device *dev;
 269         spinlock_t lock;
 270         u32 rx_buf_sz;
 271         u32 cur_rx;
 272         u32 cur_tx;
 273         u32 dirty_rx;
 274         u32 dirty_tx;
 275         dma_addr_t rx_dma;
 276         dma_addr_t tx_dma;
 277         struct RxDesc *RxDescRing;
 278         struct TxDesc *TxDescRing;
 279         struct sk_buff *Rx_skbuff[NUM_RX_DESC];
 280         struct sk_buff *Tx_skbuff[NUM_TX_DESC];
 281         struct work_struct phy_task;
 282         struct timer_list timer;
 283         u32 msg_enable;
 284         struct mii_if_info mii_if;
 285         struct list_head first_phy;
 286         u32 features;
 287         u32 negotiated_lpa;
 288         enum {
 289                 LNK_OFF,
 290                 LNK_ON,
 291                 LNK_AUTONEG,
 292         } link_status;
 293 };
 294
 295 struct sis190_phy {
 296         struct list_head list;
 297         int phy_id;
 298         u16 id[2];
 299         u16 status;
 300         u8  type;
 301 };
 302
 303 enum sis190_phy_type {
 304         UNKNOWN = 0x00,
 305         HOME    = 0x01,
 306         LAN     = 0x02,
 307         MIX     = 0x03
 308 };
 309
 310 static struct mii_chip_info {
 311         const char *name;
 312         u16 id[2];
 313         unsigned int type;
 314         u32 feature;
 315 } mii_chip_table[] = {
 316         { "Atheros PHY",          { 0x004d, 0xd010 }, LAN, 0 },
 317         { "Atheros PHY AR8012",   { 0x004d, 0xd020 }, LAN, 0 },
 318         { "Broadcom PHY BCM5461", { 0x0020, 0x60c0 }, LAN, F_PHY_BCM5461 },
 319         { "Broadcom PHY AC131",   { 0x0143, 0xbc70 }, LAN, 0 },
 320         { "Agere PHY ET1101B",    { 0x0282, 0xf010 }, LAN, 0 },
 321         { "Marvell PHY 88E1111",  { 0x0141, 0x0cc0 }, LAN, F_PHY_88E1111 },
 322         { "Realtek PHY RTL8201",  { 0x0000, 0x8200 }, LAN, 0 },
 323         { NULL, }
 324 };
 325
 326 static const struct {
 327         const char *name;
 328 } sis_chip_info[] = {
 329         { "SiS 190 PCI Fast Ethernet adapter" },
 330         { "SiS 191 PCI Gigabit Ethernet adapter" },
 331 };
 332
 333 static const struct pci_device_id sis190_pci_tbl[] = {
 334         { PCI_DEVICE(PCI_VENDOR_ID_SI, 0x0190), 0, 0, 0 },
 335         { PCI_DEVICE(PCI_VENDOR_ID_SI, 0x0191), 0, 0, 1 },
 336         { 0, },
 337 };
 338
 339 MODULE_DEVICE_TABLE(pci, sis190_pci_tbl);
 340
 341 static int rx_copybreak = 200;
 342
 343 static struct {
 344         u32 msg_enable;
 345 } debug = { -1 };
 346
 347 MODULE_DESCRIPTION("SiS sis190/191 Gigabit Ethernet driver");
 348 module_param(rx_copybreak, int, 0);
 349 MODULE_PARM_DESC(rx_copybreak, "Copy breakpoint for copy-only-tiny-frames");
 350 module_param_named(debug, debug.msg_enable, int, 0);
 351 MODULE_PARM_DESC(debug, "Debug verbosity level (0=none, ..., 16=all)");
 352 MODULE_AUTHOR("K.M. Liu <kmliu@sis.com>, Ueimor <romieu@fr.zoreil.com>");
 353 MODULE_VERSION(DRV_VERSION);
 354 MODULE_LICENSE("GPL");
 355
 356 static const u32 sis190_intr_mask =
 357         RxQEmpty | RxQInt | TxQ1Int | TxQ0Int | RxHalt | TxHalt | LinkChange;
 358
 359 /*
 360  * Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
 361  * The chips use a 64 element hash table based on the Ethernet CRC.
 362  */
 363 static const int multicast_filter_limit = 32;
 364
 365 static void __mdio_cmd(void __iomem *ioaddr, u32 ctl)
 366 {
 367         unsigned int i;
 368
 369         SIS_W32(GMIIControl, ctl);
 370
 371         msleep(1);
 372
 373         for (i = 0; i < 100; i++) {
 374                 if (!(SIS_R32(GMIIControl) & EhnMIInotDone))
 375                         break;
 376                 msleep(1);
 377         }
 378
 379         if (i > 99)
 380                 pr_err("PHY command failed !\n");
 381 }
 382
 383 static void mdio_write(void __iomem *ioaddr, int phy_id, int reg, int val)
 384 {
 385         __mdio_cmd(ioaddr, EhnMIIreq | EhnMIIwrite |
 386                 (((u32) reg) << EhnMIIregShift) | (phy_id << EhnMIIpmdShift) |
 387                 (((u32) val) << EhnMIIdataShift));
 388 }
 389
 390 static int mdio_read(void __iomem *ioaddr, int phy_id, int reg)
 391 {
 392         __mdio_cmd(ioaddr, EhnMIIreq | EhnMIIread |
 393                 (((u32) reg) << EhnMIIregShift) | (phy_id << EhnMIIpmdShift));
 394
 395         return (u16) (SIS_R32(GMIIControl) >> EhnMIIdataShift);
 396 }
 397
 398 static void __mdio_write(struct net_device *dev, int phy_id, int reg, int val)
 399 {
 400         struct sis190_private *tp = netdev_priv(dev);
 401
 402         mdio_write(tp->mmio_addr, phy_id, reg, val);
 403 }
 404
 405 static int __mdio_read(struct net_device *dev, int phy_id, int reg)
 406 {
 407         struct sis190_private *tp = netdev_priv(dev);
 408
 409         return mdio_read(tp->mmio_addr, phy_id, reg);
 410 }
 411
 412 static u16 mdio_read_latched(void __iomem *ioaddr, int phy_id, int reg)
 413 {
 414         mdio_read(ioaddr, phy_id, reg);
 415         return mdio_read(ioaddr, phy_id, reg);
 416 }
 417
 418 static u16 sis190_read_eeprom(void __iomem *ioaddr, u32 reg)
 419 {
 420         u16 data = 0xffff;
 421         unsigned int i;
 422
 423         if (!(SIS_R32(ROMControl) & 0x0002))
 424                 return 0;
 425
 426         SIS_W32(ROMInterface, EEREQ | EEROP | (reg << 10));
 427
 428         for (i = 0; i < 200; i++) {
 429                 if (!(SIS_R32(ROMInterface) & EEREQ)) {
 430                         data = (SIS_R32(ROMInterface) & 0xffff0000) >> 16;
 431                         break;
 432                 }
 433                 msleep(1);
 434         }
 435
 436         return data;
 437 }
 438
 439 static void sis190_irq_mask_and_ack(void __iomem *ioaddr)
 440 {
 441         SIS_W32(IntrMask, 0x00);
 442         SIS_W32(IntrStatus, 0xffffffff);
 443         SIS_PCI_COMMIT();
 444 }
 445
 446 static void sis190_asic_down(void __iomem *ioaddr)
 447 {
 448         /* Stop the chip's Tx and Rx DMA processes. */
 449
 450         SIS_W32(TxControl, 0x1a00);
 451         SIS_W32(RxControl, 0x1a00);
 452
 453         sis190_irq_mask_and_ack(ioaddr);
 454 }
 455
 456 static void sis190_mark_as_last_descriptor(struct RxDesc *desc)
 457 {
 458         desc->size |= cpu_to_le32(RingEnd);
 459 }
 460
 461 static inline void sis190_give_to_asic(struct RxDesc *desc, u32 rx_buf_sz)
 462 {
 463         u32 eor = le32_to_cpu(desc->size) & RingEnd;
 464
 465         desc->PSize = 0x0;
 466         desc->size = cpu_to_le32((rx_buf_sz & RX_BUF_MASK) | eor);
 467         wmb();
 468         desc->status = cpu_to_le32(OWNbit | INTbit);
 469 }
 470
 471 static inline void sis190_map_to_asic(struct RxDesc *desc, dma_addr_t mapping,
 472                                       u32 rx_buf_sz)
 473 {
 474         desc->addr = cpu_to_le32(mapping);
 475         sis190_give_to_asic(desc, rx_buf_sz);
 476 }
 477
 478 static inline void sis190_make_unusable_by_asic(struct RxDesc *desc)
 479 {
 480         desc->PSize = 0x0;
 481         desc->addr = cpu_to_le32(0xdeadbeef);
 482         desc->size &= cpu_to_le32(RingEnd);
 483         wmb();
 484         desc->status = 0x0;
 485 }
 486
 487 static struct sk_buff *sis190_alloc_rx_skb(struct sis190_private *tp,
 488                                            struct RxDesc *desc)
 489 {
 490         u32 rx_buf_sz = tp->rx_buf_sz;
 491         struct sk_buff *skb;
 492         dma_addr_t mapping;
 493
 494         skb = netdev_alloc_skb(tp->dev, rx_buf_sz);
 495         if (unlikely(!skb))
 496                 goto skb_alloc_failed;
 497         mapping = dma_map_single(&tp->pci_dev->dev, skb->data, tp->rx_buf_sz,
 498                                  DMA_FROM_DEVICE);
 499         if (dma_mapping_error(&tp->pci_dev->dev, mapping))
 500                 goto out;
 501         sis190_map_to_asic(desc, mapping, rx_buf_sz);
 502
 503         return skb;
 504
 505 out:
 506         dev_kfree_skb_any(skb);
 507 skb_alloc_failed:
 508         sis190_make_unusable_by_asic(desc);
 509         return NULL;
 510 }
 511
 512 static u32 sis190_rx_fill(struct sis190_private *tp, struct net_device *dev,
 513                           u32 start, u32 end)
 514 {
 515         u32 cur;
 516
 517         for (cur = start; cur < end; cur++) {
 518                 unsigned int i = cur % NUM_RX_DESC;
 519
 520                 if (tp->Rx_skbuff[i])
 521                         continue;
 522
 523                 tp->Rx_skbuff[i] = sis190_alloc_rx_skb(tp, tp->RxDescRing + i);
 524
 525                 if (!tp->Rx_skbuff[i])
 526                         break;
 527         }
 528         return cur - start;
 529 }
 530
 531 static bool sis190_try_rx_copy(struct sis190_private *tp,
 532                                struct sk_buff **sk_buff, int pkt_size,
 533                                dma_addr_t addr)
 534 {
 535         struct sk_buff *skb;
 536         bool done = false;
 537
 538         if (pkt_size >= rx_copybreak)
 539                 goto out;
 540
 541         skb = netdev_alloc_skb_ip_align(tp->dev, pkt_size);
 542         if (!skb)
 543                 goto out;
 544
 545         dma_sync_single_for_cpu(&tp->pci_dev->dev, addr, tp->rx_buf_sz,
 546                                 DMA_FROM_DEVICE);
 547         skb_copy_to_linear_data(skb, sk_buff[0]->data, pkt_size);
 548         *sk_buff = skb;
 549         done = true;
 550 out:
 551         return done;
 552 }
 553
 554 static inline int sis190_rx_pkt_err(u32 status, struct net_device_stats *stats)
 555 {
 556 #define ErrMask (OVRUN | SHORT | LIMIT | MIIER | NIBON | COLON | ABORT)
 557
 558         if ((status & CRCOK) && !(status & ErrMask))
 559                 return 0;
 560
 561         if (!(status & CRCOK))
 562                 stats->rx_crc_errors++;
 563         else if (status & OVRUN)
 564                 stats->rx_over_errors++;
 565         else if (status & (SHORT | LIMIT))
 566                 stats->rx_length_errors++;
 567         else if (status & (MIIER | NIBON | COLON))
 568                 stats->rx_frame_errors++;
 569
 570         stats->rx_errors++;
 571         return -1;
 572 }
 573
 574 static int sis190_rx_interrupt(struct net_device *dev,
 575                                struct sis190_private *tp, void __iomem *ioaddr)
 576 {
 577         struct net_device_stats *stats = &dev->stats;
 578         u32 rx_left, cur_rx = tp->cur_rx;
 579         u32 delta, count;
 580
 581         rx_left = NUM_RX_DESC + tp->dirty_rx - cur_rx;
 582         rx_left = sis190_rx_quota(rx_left, (u32) dev->quota);
 583
 584         for (; rx_left > 0; rx_left--, cur_rx++) {
 585                 unsigned int entry = cur_rx % NUM_RX_DESC;
 586                 struct RxDesc *desc = tp->RxDescRing + entry;
 587                 u32 status;
 588
 589                 if (le32_to_cpu(desc->status) & OWNbit)
 590                         break;
 591
 592                 status = le32_to_cpu(desc->PSize);
 593
 594                 //netif_info(tp, intr, dev, "Rx PSize = %08x\n", status);
 595
 596                 if (sis190_rx_pkt_err(status, stats) < 0)
 597                         sis190_give_to_asic(desc, tp->rx_buf_sz);
 598                 else {
 599                         struct sk_buff *skb = tp->Rx_skbuff[entry];
 600                         dma_addr_t addr = le32_to_cpu(desc->addr);
 601                         int pkt_size = (status & RxSizeMask) - 4;
 602                         struct pci_dev *pdev = tp->pci_dev;
 603
 604                         if (unlikely(pkt_size > tp->rx_buf_sz)) {
 605                                 netif_info(tp, intr, dev,
 606                                            "(frag) status = %08x\n", status);
 607                                 stats->rx_dropped++;
 608                                 stats->rx_length_errors++;
 609                                 sis190_give_to_asic(desc, tp->rx_buf_sz);
 610                                 continue;
 611                         }
 612
 613
 614                         if (sis190_try_rx_copy(tp, &skb, pkt_size, addr)) {
 615                                 dma_sync_single_for_device(&pdev->dev, addr,
 616                                                            tp->rx_buf_sz,
 617                                                            DMA_FROM_DEVICE);
 618                                 sis190_give_to_asic(desc, tp->rx_buf_sz);
 619                         } else {
 620                                 dma_unmap_single(&pdev->dev, addr,
 621                                                  tp->rx_buf_sz,
 622                                                  DMA_FROM_DEVICE);
 623                                 tp->Rx_skbuff[entry] = NULL;
 624                                 sis190_make_unusable_by_asic(desc);
 625                         }
 626
 627                         skb_put(skb, pkt_size);
 628                         skb->protocol = eth_type_trans(skb, dev);
 629
 630                         sis190_rx_skb(skb);
 631
 632                         stats->rx_packets++;
 633                         stats->rx_bytes += pkt_size;
 634                         if ((status & BCAST) == MCAST)
 635                                 stats->multicast++;
 636                 }
 637         }
 638         count = cur_rx - tp->cur_rx;
 639         tp->cur_rx = cur_rx;
 640
 641         delta = sis190_rx_fill(tp, dev, tp->dirty_rx, tp->cur_rx);
 642         if (!delta && count)
 643                 netif_info(tp, intr, dev, "no Rx buffer allocated\n");
 644         tp->dirty_rx += delta;
 645
 646         if ((tp->dirty_rx + NUM_RX_DESC) == tp->cur_rx)
 647                 netif_emerg(tp, intr, dev, "Rx buffers exhausted\n");
 648
 649         return count;
 650 }
 651
 652 static void sis190_unmap_tx_skb(struct pci_dev *pdev, struct sk_buff *skb,
 653                                 struct TxDesc *desc)
 654 {
 655         unsigned int len;
 656
 657         len = skb->len < ETH_ZLEN ? ETH_ZLEN : skb->len;
 658
 659         dma_unmap_single(&pdev->dev, le32_to_cpu(desc->addr), len,
 660                          DMA_TO_DEVICE);
 661
 662         memset(desc, 0x00, sizeof(*desc));
 663 }
 664
 665 static inline int sis190_tx_pkt_err(u32 status, struct net_device_stats *stats)
 666 {
 667 #define TxErrMask       (WND | TABRT | FIFO | LINK)
 668
 669         if (!unlikely(status & TxErrMask))
 670                 return 0;
 671
 672         if (status & WND)
 673                 stats->tx_window_errors++;
 674         if (status & TABRT)
 675                 stats->tx_aborted_errors++;
 676         if (status & FIFO)
 677                 stats->tx_fifo_errors++;
 678         if (status & LINK)
 679                 stats->tx_carrier_errors++;
 680
 681         stats->tx_errors++;
 682
 683         return -1;
 684 }
 685
 686 static void sis190_tx_interrupt(struct net_device *dev,
 687                                 struct sis190_private *tp, void __iomem *ioaddr)
 688 {
 689         struct net_device_stats *stats = &dev->stats;
 690         u32 pending, dirty_tx = tp->dirty_tx;
 691         /*
 692          * It would not be needed if queueing was allowed to be enabled
 693          * again too early (hint: think preempt and unclocked smp systems).
 694          */
 695         unsigned int queue_stopped;
 696
 697         smp_rmb();
 698         pending = tp->cur_tx - dirty_tx;
 699         queue_stopped = (pending == NUM_TX_DESC);
 700
 701         for (; pending; pending--, dirty_tx++) {
 702                 unsigned int entry = dirty_tx % NUM_TX_DESC;
 703                 struct TxDesc *txd = tp->TxDescRing + entry;
 704                 u32 status = le32_to_cpu(txd->status);
 705                 struct sk_buff *skb;
 706
 707                 if (status & OWNbit)
 708                         break;
 709
 710                 skb = tp->Tx_skbuff[entry];
 711
 712                 if (likely(sis190_tx_pkt_err(status, stats) == 0)) {
 713                         stats->tx_packets++;
 714                         stats->tx_bytes += skb->len;
 715                         stats->collisions += ((status & ColCountMask) - 1);
 716                 }
 717
 718                 sis190_unmap_tx_skb(tp->pci_dev, skb, txd);
 719                 tp->Tx_skbuff[entry] = NULL;
 720                 dev_consume_skb_irq(skb);
 721         }
 722
 723         if (tp->dirty_tx != dirty_tx) {
 724                 tp->dirty_tx = dirty_tx;
 725                 smp_wmb();
 726                 if (queue_stopped)
 727                         netif_wake_queue(dev);
 728         }
 729 }
 730
 731 /*
 732  * The interrupt handler does all of the Rx thread work and cleans up after
 733  * the Tx thread.
 734  */
 735 static irqreturn_t sis190_irq(int irq, void *__dev)
 736 {
 737         struct net_device *dev = __dev;
 738         struct sis190_private *tp = netdev_priv(dev);
 739         void __iomem *ioaddr = tp->mmio_addr;
 740         unsigned int handled = 0;
 741         u32 status;
 742
 743         status = SIS_R32(IntrStatus);
 744
 745         if ((status == 0xffffffff) || !status)
 746                 goto out;
 747
 748         handled = 1;
 749
 750         if (unlikely(!netif_running(dev))) {
 751                 sis190_asic_down(ioaddr);
 752                 goto out;
 753         }
 754
 755         SIS_W32(IntrStatus, status);
 756
 757 //      netif_info(tp, intr, dev, "status = %08x\n", status);
 758
 759         if (status & LinkChange) {
 760                 netif_info(tp, intr, dev, "link change\n");
 761                 del_timer(&tp->timer);
 762                 schedule_work(&tp->phy_task);
 763         }
 764
 765         if (status & RxQInt)
 766                 sis190_rx_interrupt(dev, tp, ioaddr);
 767
 768         if (status & TxQ0Int)
 769                 sis190_tx_interrupt(dev, tp, ioaddr);
 770 out:
 771         return IRQ_RETVAL(handled);
 772 }
 773
 774 #ifdef CONFIG_NET_POLL_CONTROLLER
 775 static void sis190_netpoll(struct net_device *dev)
 776 {
 777         struct sis190_private *tp = netdev_priv(dev);
 778         const int irq = tp->pci_dev->irq;
 779
 780         disable_irq(irq);
 781         sis190_irq(irq, dev);
 782         enable_irq(irq);
 783 }
 784 #endif
 785
 786 static void sis190_free_rx_skb(struct sis190_private *tp,
 787                                struct sk_buff **sk_buff, struct RxDesc *desc)
 788 {
 789         struct pci_dev *pdev = tp->pci_dev;
 790
 791         dma_unmap_single(&pdev->dev, le32_to_cpu(desc->addr), tp->rx_buf_sz,
 792                          DMA_FROM_DEVICE);
 793         dev_kfree_skb(*sk_buff);
 794         *sk_buff = NULL;
 795         sis190_make_unusable_by_asic(desc);
 796 }
 797
 798 static void sis190_rx_clear(struct sis190_private *tp)
 799 {
 800         unsigned int i;
 801
 802         for (i = 0; i < NUM_RX_DESC; i++) {
 803                 if (!tp->Rx_skbuff[i])
 804                         continue;
 805                 sis190_free_rx_skb(tp, tp->Rx_skbuff + i, tp->RxDescRing + i);
 806         }
 807 }
 808
 809 static void sis190_init_ring_indexes(struct sis190_private *tp)
 810 {
 811         tp->dirty_tx = tp->dirty_rx = tp->cur_tx = tp->cur_rx = 0;
 812 }
 813
 814 static int sis190_init_ring(struct net_device *dev)
 815 {
 816         struct sis190_private *tp = netdev_priv(dev);
 817
 818         sis190_init_ring_indexes(tp);
 819
 820         memset(tp->Tx_skbuff, 0x0, NUM_TX_DESC * sizeof(struct sk_buff *));
 821         memset(tp->Rx_skbuff, 0x0, NUM_RX_DESC * sizeof(struct sk_buff *));
 822
 823         if (sis190_rx_fill(tp, dev, 0, NUM_RX_DESC) != NUM_RX_DESC)
 824                 goto err_rx_clear;
 825
 826         sis190_mark_as_last_descriptor(tp->RxDescRing + NUM_RX_DESC - 1);
 827
 828         return 0;
 829
 830 err_rx_clear:
 831         sis190_rx_clear(tp);
 832         return -ENOMEM;
 833 }
 834
 835 static void sis190_set_rx_mode(struct net_device *dev)
 836 {
 837         struct sis190_private *tp = netdev_priv(dev);
 838         void __iomem *ioaddr = tp->mmio_addr;
 839         unsigned long flags;
 840         u32 mc_filter[2];       /* Multicast hash filter */
 841         u16 rx_mode;
 842
 843         if (dev->flags & IFF_PROMISC) {
 844                 rx_mode =
 845                         AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
 846                         AcceptAllPhys;
 847                 mc_filter[1] = mc_filter[0] = 0xffffffff;
 848         } else if ((netdev_mc_count(dev) > multicast_filter_limit) ||
 849                    (dev->flags & IFF_ALLMULTI)) {
 850                 /* Too many to filter perfectly -- accept all multicasts. */
 851                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
 852                 mc_filter[1] = mc_filter[0] = 0xffffffff;
 853         } else {
 854                 struct netdev_hw_addr *ha;
 855
 856                 rx_mode = AcceptBroadcast | AcceptMyPhys;
 857                 mc_filter[1] = mc_filter[0] = 0;
 858                 netdev_for_each_mc_addr(ha, dev) {
 859                         int bit_nr =
 860                                 ether_crc(ETH_ALEN, ha->addr) & 0x3f;
 861                         mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
 862                         rx_mode |= AcceptMulticast;
 863                 }
 864         }
 865
 866         spin_lock_irqsave(&tp->lock, flags);
 867
 868         SIS_W16(RxMacControl, rx_mode | 0x2);
 869         SIS_W32(RxHashTable, mc_filter[0]);
 870         SIS_W32(RxHashTable + 4, mc_filter[1]);
 871
 872         spin_unlock_irqrestore(&tp->lock, flags);
 873 }
 874
 875 static void sis190_soft_reset(void __iomem *ioaddr)
 876 {
 877         SIS_W32(IntrControl, 0x8000);
 878         SIS_PCI_COMMIT();
 879         SIS_W32(IntrControl, 0x0);
 880         sis190_asic_down(ioaddr);
 881 }
 882
 883 static void sis190_hw_start(struct net_device *dev)
 884 {
 885         struct sis190_private *tp = netdev_priv(dev);
 886         void __iomem *ioaddr = tp->mmio_addr;
 887
 888         sis190_soft_reset(ioaddr);
 889
 890         SIS_W32(TxDescStartAddr, tp->tx_dma);
 891         SIS_W32(RxDescStartAddr, tp->rx_dma);
 892
 893         SIS_W32(IntrStatus, 0xffffffff);
 894         SIS_W32(IntrMask, 0x0);
 895         SIS_W32(GMIIControl, 0x0);
 896         SIS_W32(TxMacControl, 0x60);
 897         SIS_W16(RxMacControl, 0x02);
 898         SIS_W32(RxHashTable, 0x0);
 899         SIS_W32(0x6c, 0x0);
 900         SIS_W32(RxWolCtrl, 0x0);
 901         SIS_W32(RxWolData, 0x0);
 902
 903         SIS_PCI_COMMIT();
 904
 905         sis190_set_rx_mode(dev);
 906
 907         /* Enable all known interrupts by setting the interrupt mask. */
 908         SIS_W32(IntrMask, sis190_intr_mask);
 909
 910         SIS_W32(TxControl, 0x1a00 | CmdTxEnb);
 911         SIS_W32(RxControl, 0x1a1d);
 912
 913         netif_start_queue(dev);
 914 }
 915
 916 static void sis190_phy_task(struct work_struct *work)
 917 {
 918         struct sis190_private *tp =
 919                 container_of(work, struct sis190_private, phy_task);
 920         struct net_device *dev = tp->dev;
 921         void __iomem *ioaddr = tp->mmio_addr;
 922         int phy_id = tp->mii_if.phy_id;
 923         u16 val;
 924
 925         rtnl_lock();
 926
 927         if (!netif_running(dev))
 928                 goto out_unlock;
 929
 930         val = mdio_read(ioaddr, phy_id, MII_BMCR);
 931         if (val & BMCR_RESET) {
 932                 // FIXME: needlessly high ?  -- FR 02/07/2005
 933                 mod_timer(&tp->timer, jiffies + HZ/10);
 934                 goto out_unlock;
 935         }
 936
 937         val = mdio_read_latched(ioaddr, phy_id, MII_BMSR);
 938         if (!(val & BMSR_ANEGCOMPLETE) && tp->link_status != LNK_AUTONEG) {
 939                 netif_carrier_off(dev);
 940                 netif_warn(tp, link, dev, "auto-negotiating...\n");
 941                 tp->link_status = LNK_AUTONEG;
 942         } else if ((val & BMSR_LSTATUS) && tp->link_status != LNK_ON) {
 943                 /* Rejoice ! */
 944                 struct {
 945                         int val;
 946                         u32 ctl;
 947                         const char *msg;
 948                 } reg31[] = {
 949                         { LPA_1000FULL, 0x07000c00 | 0x00001000,
 950                                 "1000 Mbps Full Duplex" },
 951                         { LPA_1000HALF, 0x07000c00,
 952                                 "1000 Mbps Half Duplex" },
 953                         { LPA_100FULL, 0x04000800 | 0x00001000,
 954                                 "100 Mbps Full Duplex" },
 955                         { LPA_100HALF, 0x04000800,
 956                                 "100 Mbps Half Duplex" },
 957                         { LPA_10FULL, 0x04000400 | 0x00001000,
 958                                 "10 Mbps Full Duplex" },
 959                         { LPA_10HALF, 0x04000400,
 960                                 "10 Mbps Half Duplex" },
 961                         { 0, 0x04000400, "unknown" }
 962                 }, *p = NULL;
 963                 u16 adv, autoexp, gigadv, gigrec;
 964
 965                 val = mdio_read(ioaddr, phy_id, 0x1f);
 966                 netif_info(tp, link, dev, "mii ext = %04x\n", val);
 967
 968                 val = mdio_read(ioaddr, phy_id, MII_LPA);
 969                 adv = mdio_read(ioaddr, phy_id, MII_ADVERTISE);
 970                 autoexp = mdio_read(ioaddr, phy_id, MII_EXPANSION);
 971                 netif_info(tp, link, dev, "mii lpa=%04x adv=%04x exp=%04x\n",
 972                            val, adv, autoexp);
 973
 974                 if (val & LPA_NPAGE && autoexp & EXPANSION_NWAY) {
 975                         /* check for gigabit speed */
 976                         gigadv = mdio_read(ioaddr, phy_id, MII_CTRL1000);
 977                         gigrec = mdio_read(ioaddr, phy_id, MII_STAT1000);
 978                         val = (gigadv & (gigrec >> 2));
 979                         if (val & ADVERTISE_1000FULL)
 980                                 p = reg31;
 981                         else if (val & ADVERTISE_1000HALF)
 982                                 p = reg31 + 1;
 983                 }
 984                 if (!p) {
 985                         val &= adv;
 986
 987                         for (p = reg31; p->val; p++) {
 988                                 if ((val & p->val) == p->val)
 989                                         break;
 990                         }
 991                 }
 992
 993                 p->ctl |= SIS_R32(StationControl) & ~0x0f001c00;
 994
 995                 if ((tp->features & F_HAS_RGMII) &&
 996                     (tp->features & F_PHY_BCM5461)) {
 997                         // Set Tx Delay in RGMII mode.
 998                         mdio_write(ioaddr, phy_id, 0x18, 0xf1c7);
 999                         udelay(200);
1000                         mdio_write(ioaddr, phy_id, 0x1c, 0x8c00);
1001                         p->ctl |= 0x03000000;
1002                 }
1003
1004                 SIS_W32(StationControl, p->ctl);
1005
1006                 if (tp->features & F_HAS_RGMII) {
1007                         SIS_W32(RGDelay, 0x0441);
1008                         SIS_W32(RGDelay, 0x0440);
1009                 }
1010
1011                 tp->negotiated_lpa = p->val;
1012
1013                 netif_info(tp, link, dev, "link on %s mode\n", p->msg);
1014                 netif_carrier_on(dev);
1015                 tp->link_status = LNK_ON;
1016         } else if (!(val & BMSR_LSTATUS) && tp->link_status != LNK_AUTONEG)
1017                 tp->link_status = LNK_OFF;
1018         mod_timer(&tp->timer, jiffies + SIS190_PHY_TIMEOUT);
1019
1020 out_unlock:
1021         rtnl_unlock();
1022 }
1023
1024 static void sis190_phy_timer(struct timer_list *t)
1025 {
1026         struct sis190_private *tp = from_timer(tp, t, timer);
1027         struct net_device *dev = tp->dev;
1028
1029         if (likely(netif_running(dev)))
1030                 schedule_work(&tp->phy_task);
1031 }
1032
1033 static inline void sis190_delete_timer(struct net_device *dev)
1034 {
1035         struct sis190_private *tp = netdev_priv(dev);
1036
1037         del_timer_sync(&tp->timer);
1038 }
1039
1040 static inline void sis190_request_timer(struct net_device *dev)
1041 {
1042         struct sis190_private *tp = netdev_priv(dev);
1043         struct timer_list *timer = &tp->timer;
1044
1045         timer_setup(timer, sis190_phy_timer, 0);
1046         timer->expires = jiffies + SIS190_PHY_TIMEOUT;
1047         add_timer(timer);
1048 }
1049
1050 static void sis190_set_rxbufsize(struct sis190_private *tp,
1051                                  struct net_device *dev)
1052 {
1053         unsigned int mtu = dev->mtu;
1054
1055         tp->rx_buf_sz = (mtu > RX_BUF_SIZE) ? mtu + ETH_HLEN + 8 : RX_BUF_SIZE;
1056         /* RxDesc->size has a licence to kill the lower bits */
1057         if (tp->rx_buf_sz & 0x07) {
1058                 tp->rx_buf_sz += 8;
1059                 tp->rx_buf_sz &= RX_BUF_MASK;
1060         }
1061 }
1062
1063 static int sis190_open(struct net_device *dev)
1064 {
1065         struct sis190_private *tp = netdev_priv(dev);
1066         struct pci_dev *pdev = tp->pci_dev;
1067         int rc = -ENOMEM;
1068
1069         sis190_set_rxbufsize(tp, dev);
1070
1071         /*
1072          * Rx and Tx descriptors need 256 bytes alignment.
1073          * pci_alloc_consistent() guarantees a stronger alignment.
1074          */
1075         tp->TxDescRing = dma_alloc_coherent(&pdev->dev, TX_RING_BYTES,
1076                                             &tp->tx_dma, GFP_KERNEL);
1077         if (!tp->TxDescRing)
1078                 goto out;
1079
1080         tp->RxDescRing = dma_alloc_coherent(&pdev->dev, RX_RING_BYTES,
1081                                             &tp->rx_dma, GFP_KERNEL);
1082         if (!tp->RxDescRing)
1083                 goto err_free_tx_0;
1084
1085         rc = sis190_init_ring(dev);
1086         if (rc < 0)
1087                 goto err_free_rx_1;
1088
1089         sis190_request_timer(dev);
1090
1091         rc = request_irq(pdev->irq, sis190_irq, IRQF_SHARED, dev->name, dev);
1092         if (rc < 0)
1093                 goto err_release_timer_2;
1094
1095         sis190_hw_start(dev);
1096 out:
1097         return rc;
1098
1099 err_release_timer_2:
1100         sis190_delete_timer(dev);
1101         sis190_rx_clear(tp);
1102 err_free_rx_1:
1103         dma_free_coherent(&pdev->dev, RX_RING_BYTES, tp->RxDescRing,
1104                           tp->rx_dma);
1105 err_free_tx_0:
1106         dma_free_coherent(&pdev->dev, TX_RING_BYTES, tp->TxDescRing,
1107                           tp->tx_dma);
1108         goto out;
1109 }
1110
1111 static void sis190_tx_clear(struct sis190_private *tp)
1112 {
1113         unsigned int i;
1114
1115         for (i = 0; i < NUM_TX_DESC; i++) {
1116                 struct sk_buff *skb = tp->Tx_skbuff[i];
1117
1118                 if (!skb)
1119                         continue;
1120
1121                 sis190_unmap_tx_skb(tp->pci_dev, skb, tp->TxDescRing + i);
1122                 tp->Tx_skbuff[i] = NULL;
1123                 dev_kfree_skb(skb);
1124
1125                 tp->dev->stats.tx_dropped++;
1126         }
1127         tp->cur_tx = tp->dirty_tx = 0;
1128 }
1129
1130 static void sis190_down(struct net_device *dev)
1131 {
1132         struct sis190_private *tp = netdev_priv(dev);
1133         void __iomem *ioaddr = tp->mmio_addr;
1134         unsigned int poll_locked = 0;
1135
1136         sis190_delete_timer(dev);
1137
1138         netif_stop_queue(dev);
1139
1140         do {
1141                 spin_lock_irq(&tp->lock);
1142
1143                 sis190_asic_down(ioaddr);
1144
1145                 spin_unlock_irq(&tp->lock);
1146
1147                 synchronize_irq(tp->pci_dev->irq);
1148
1149                 if (!poll_locked)
1150                         poll_locked++;
1151
1152                 synchronize_rcu();
1153
1154         } while (SIS_R32(IntrMask));
1155
1156         sis190_tx_clear(tp);
1157         sis190_rx_clear(tp);
1158 }
1159
1160 static int sis190_close(struct net_device *dev)
1161 {
1162         struct sis190_private *tp = netdev_priv(dev);
1163         struct pci_dev *pdev = tp->pci_dev;
1164
1165         sis190_down(dev);
1166
1167         free_irq(pdev->irq, dev);
1168
1169         dma_free_coherent(&pdev->dev, TX_RING_BYTES, tp->TxDescRing,
1170                           tp->tx_dma);
1171         dma_free_coherent(&pdev->dev, RX_RING_BYTES, tp->RxDescRing,
1172                           tp->rx_dma);
1173
1174         tp->TxDescRing = NULL;
1175         tp->RxDescRing = NULL;
1176
1177         return 0;
1178 }
1179
1180 static netdev_tx_t sis190_start_xmit(struct sk_buff *skb,
1181                                      struct net_device *dev)
1182 {
1183         struct sis190_private *tp = netdev_priv(dev);
1184         void __iomem *ioaddr = tp->mmio_addr;
1185         u32 len, entry, dirty_tx;
1186         struct TxDesc *desc;
1187         dma_addr_t mapping;
1188
1189         if (unlikely(skb->len < ETH_ZLEN)) {
1190                 if (skb_padto(skb, ETH_ZLEN)) {
1191                         dev->stats.tx_dropped++;
1192                         goto out;
1193                 }
1194                 len = ETH_ZLEN;
1195         } else {
1196                 len = skb->len;
1197         }
1198
1199         entry = tp->cur_tx % NUM_TX_DESC;
1200         desc = tp->TxDescRing + entry;
1201
1202         if (unlikely(le32_to_cpu(desc->status) & OWNbit)) {
1203                 netif_stop_queue(dev);
1204                 netif_err(tp, tx_err, dev,
1205                           "BUG! Tx Ring full when queue awake!\n");
1206                 return NETDEV_TX_BUSY;
1207         }
1208
1209         mapping = dma_map_single(&tp->pci_dev->dev, skb->data, len,
1210                                  DMA_TO_DEVICE);
1211         if (dma_mapping_error(&tp->pci_dev->dev, mapping)) {
1212                 netif_err(tp, tx_err, dev,
1213                                 "PCI mapping failed, dropping packet");
1214                 return NETDEV_TX_BUSY;
1215         }
1216
1217         tp->Tx_skbuff[entry] = skb;
1218
1219         desc->PSize = cpu_to_le32(len);
1220         desc->addr = cpu_to_le32(mapping);
1221
1222         desc->size = cpu_to_le32(len);
1223         if (entry == (NUM_TX_DESC - 1))
1224                 desc->size |= cpu_to_le32(RingEnd);
1225
1226         wmb();
1227
1228         desc->status = cpu_to_le32(OWNbit | INTbit | DEFbit | CRCbit | PADbit);
1229         if (tp->negotiated_lpa & (LPA_1000HALF | LPA_100HALF | LPA_10HALF)) {
1230                 /* Half Duplex */
1231                 desc->status |= cpu_to_le32(COLEN | CRSEN | BKFEN);
1232                 if (tp->negotiated_lpa & (LPA_1000HALF | LPA_1000FULL))
1233                         desc->status |= cpu_to_le32(EXTEN | BSTEN); /* gigabit HD */
1234         }
1235
1236         tp->cur_tx++;
1237
1238         smp_wmb();
1239
1240         SIS_W32(TxControl, 0x1a00 | CmdReset | CmdTxEnb);
1241
1242         dirty_tx = tp->dirty_tx;
1243         if ((tp->cur_tx - NUM_TX_DESC) == dirty_tx) {
1244                 netif_stop_queue(dev);
1245                 smp_rmb();
1246                 if (dirty_tx != tp->dirty_tx)
1247                         netif_wake_queue(dev);
1248         }
1249 out:
1250         return NETDEV_TX_OK;
1251 }
1252
1253 static void sis190_free_phy(struct list_head *first_phy)
1254 {
1255         struct sis190_phy *cur, *next;
1256
1257         list_for_each_entry_safe(cur, next, first_phy, list) {
1258                 kfree(cur);
1259         }
1260 }
1261
1262 /**
1263  *      sis190_default_phy - Select default PHY for sis190 mac.
1264  *      @dev: the net device to probe for
1265  *
1266  *      Select first detected PHY with link as default.
1267  *      If no one is link on, select PHY whose types is HOME as default.
1268  *      If HOME doesn't exist, select LAN.
1269  */
1270 static u16 sis190_default_phy(struct net_device *dev)
1271 {
1272         struct sis190_phy *phy, *phy_home, *phy_default, *phy_lan;
1273         struct sis190_private *tp = netdev_priv(dev);
1274         struct mii_if_info *mii_if = &tp->mii_if;
1275         void __iomem *ioaddr = tp->mmio_addr;
1276         u16 status;
1277
1278         phy_home = phy_default = phy_lan = NULL;
1279
1280         list_for_each_entry(phy, &tp->first_phy, list) {
1281                 status = mdio_read_latched(ioaddr, phy->phy_id, MII_BMSR);
1282
1283                 // Link ON & Not select default PHY & not ghost PHY.
1284                 if ((status & BMSR_LSTATUS) &&
1285                     !phy_default &&
1286                     (phy->type != UNKNOWN)) {
1287                         phy_default = phy;
1288                 } else {
1289                         status = mdio_read(ioaddr, phy->phy_id, MII_BMCR);
1290                         mdio_write(ioaddr, phy->phy_id, MII_BMCR,
1291                                    status | BMCR_ANENABLE | BMCR_ISOLATE);
1292                         if (phy->type == HOME)
1293                                 phy_home = phy;
1294                         else if (phy->type == LAN)
1295                                 phy_lan = phy;
1296                 }
1297         }
1298
1299         if (!phy_default) {
1300                 if (phy_home)
1301                         phy_default = phy_home;
1302                 else if (phy_lan)
1303                         phy_default = phy_lan;
1304                 else
1305                         phy_default = list_first_entry(&tp->first_phy,
1306                                                  struct sis190_phy, list);
1307         }
1308
1309         if (mii_if->phy_id != phy_default->phy_id) {
1310                 mii_if->phy_id = phy_default->phy_id;
1311                 if (netif_msg_probe(tp))
1312                         pr_info("%s: Using transceiver at address %d as default\n",
1313                                 pci_name(tp->pci_dev), mii_if->phy_id);
1314         }
1315
1316         status = mdio_read(ioaddr, mii_if->phy_id, MII_BMCR);
1317         status &= (~BMCR_ISOLATE);
1318
1319         mdio_write(ioaddr, mii_if->phy_id, MII_BMCR, status);
1320         status = mdio_read_latched(ioaddr, mii_if->phy_id, MII_BMSR);
1321
1322         return status;
1323 }
1324
1325 static void sis190_init_phy(struct net_device *dev, struct sis190_private *tp,
1326                             struct sis190_phy *phy, unsigned int phy_id,
1327                             u16 mii_status)
1328 {
1329         void __iomem *ioaddr = tp->mmio_addr;
1330         struct mii_chip_info *p;
1331
1332         INIT_LIST_HEAD(&phy->list);
1333         phy->status = mii_status;
1334         phy->phy_id = phy_id;
1335
1336         phy->id[0] = mdio_read(ioaddr, phy_id, MII_PHYSID1);
1337         phy->id[1] = mdio_read(ioaddr, phy_id, MII_PHYSID2);
1338
1339         for (p = mii_chip_table; p->type; p++) {
1340                 if ((p->id[0] == phy->id[0]) &&
1341                     (p->id[1] == (phy->id[1] & 0xfff0))) {
1342                         break;
1343                 }
1344         }
1345
1346         if (p->id[1]) {
1347                 phy->type = (p->type == MIX) ?
1348                         ((mii_status & (BMSR_100FULL | BMSR_100HALF)) ?
1349                                 LAN : HOME) : p->type;
1350                 tp->features |= p->feature;
1351                 if (netif_msg_probe(tp))
1352                         pr_info("%s: %s transceiver at address %d\n",
1353                                 pci_name(tp->pci_dev), p->name, phy_id);
1354         } else {
1355                 phy->type = UNKNOWN;
1356                 if (netif_msg_probe(tp))
1357                         pr_info("%s: unknown PHY 0x%x:0x%x transceiver at address %d\n",
1358                                 pci_name(tp->pci_dev),
1359                                 phy->id[0], (phy->id[1] & 0xfff0), phy_id);
1360         }
1361 }
1362
1363 static void sis190_mii_probe_88e1111_fixup(struct sis190_private *tp)
1364 {
1365         if (tp->features & F_PHY_88E1111) {
1366                 void __iomem *ioaddr = tp->mmio_addr;
1367                 int phy_id = tp->mii_if.phy_id;
1368                 u16 reg[2][2] = {
1369                         { 0x808b, 0x0ce1 },
1370                         { 0x808f, 0x0c60 }
1371                 }, *p;
1372
1373                 p = (tp->features & F_HAS_RGMII) ? reg[0] : reg[1];
1374
1375                 mdio_write(ioaddr, phy_id, 0x1b, p[0]);
1376                 udelay(200);
1377                 mdio_write(ioaddr, phy_id, 0x14, p[1]);
1378                 udelay(200);
1379         }
1380 }
1381
1382 /**
1383  *      sis190_mii_probe - Probe MII PHY for sis190
1384  *      @dev: the net device to probe for
1385  *
1386  *      Search for total of 32 possible mii phy addresses.
1387  *      Identify and set current phy if found one,
1388  *      return error if it failed to found.
1389  */
1390 static int sis190_mii_probe(struct net_device *dev)
1391 {
1392         struct sis190_private *tp = netdev_priv(dev);
1393         struct mii_if_info *mii_if = &tp->mii_if;
1394         void __iomem *ioaddr = tp->mmio_addr;
1395         int phy_id;
1396         int rc = 0;
1397
1398         INIT_LIST_HEAD(&tp->first_phy);
1399
1400         for (phy_id = 0; phy_id < PHY_MAX_ADDR; phy_id++) {
1401                 struct sis190_phy *phy;
1402                 u16 status;
1403
1404                 status = mdio_read_latched(ioaddr, phy_id, MII_BMSR);
1405
1406                 // Try next mii if the current one is not accessible.
1407                 if (status == 0xffff || status == 0x0000)
1408                         continue;
1409
1410                 phy = kmalloc(sizeof(*phy), GFP_KERNEL);
1411                 if (!phy) {
1412                         sis190_free_phy(&tp->first_phy);
1413                         rc = -ENOMEM;
1414                         goto out;
1415                 }
1416
1417                 sis190_init_phy(dev, tp, phy, phy_id, status);
1418
1419                 list_add(&tp->first_phy, &phy->list);
1420         }
1421
1422         if (list_empty(&tp->first_phy)) {
1423                 if (netif_msg_probe(tp))
1424                         pr_info("%s: No MII transceivers found!\n",
1425                                 pci_name(tp->pci_dev));
1426                 rc = -EIO;
1427                 goto out;
1428         }
1429
1430         /* Select default PHY for mac */
1431         sis190_default_phy(dev);
1432
1433         sis190_mii_probe_88e1111_fixup(tp);
1434
1435         mii_if->dev = dev;
1436         mii_if->mdio_read = __mdio_read;
1437         mii_if->mdio_write = __mdio_write;
1438         mii_if->phy_id_mask = PHY_ID_ANY;
1439         mii_if->reg_num_mask = MII_REG_ANY;
1440 out:
1441         return rc;
1442 }
1443
1444 static void sis190_mii_remove(struct net_device *dev)
1445 {
1446         struct sis190_private *tp = netdev_priv(dev);
1447
1448         sis190_free_phy(&tp->first_phy);
1449 }
1450
1451 static void sis190_release_board(struct pci_dev *pdev)
1452 {
1453         struct net_device *dev = pci_get_drvdata(pdev);
1454         struct sis190_private *tp = netdev_priv(dev);
1455
1456         iounmap(tp->mmio_addr);
1457         pci_release_regions(pdev);
1458         pci_disable_device(pdev);
1459         free_netdev(dev);
1460 }
1461
1462 static struct net_device *sis190_init_board(struct pci_dev *pdev)
1463 {
1464         struct sis190_private *tp;
1465         struct net_device *dev;
1466         void __iomem *ioaddr;
1467         int rc;
1468
1469         dev = alloc_etherdev(sizeof(*tp));
1470         if (!dev) {
1471                 rc = -ENOMEM;
1472                 goto err_out_0;
1473         }
1474
1475         SET_NETDEV_DEV(dev, &pdev->dev);
1476
1477         tp = netdev_priv(dev);
1478         tp->dev = dev;
1479         tp->msg_enable = netif_msg_init(debug.msg_enable, SIS190_MSG_DEFAULT);
1480
1481         rc = pci_enable_device(pdev);
1482         if (rc < 0) {
1483                 if (netif_msg_probe(tp))
1484                         pr_err("%s: enable failure\n", pci_name(pdev));
1485                 goto err_free_dev_1;
1486         }
1487
1488         rc = -ENODEV;
1489
1490         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
1491                 if (netif_msg_probe(tp))
1492                         pr_err("%s: region #0 is no MMIO resource\n",
1493                                pci_name(pdev));
1494                 goto err_pci_disable_2;
1495         }
1496         if (pci_resource_len(pdev, 0) < SIS190_REGS_SIZE) {
1497                 if (netif_msg_probe(tp))
1498                         pr_err("%s: invalid PCI region size(s)\n",
1499                                pci_name(pdev));
1500                 goto err_pci_disable_2;
1501         }
1502
1503         rc = pci_request_regions(pdev, DRV_NAME);
1504         if (rc < 0) {
1505                 if (netif_msg_probe(tp))
1506                         pr_err("%s: could not request regions\n",
1507                                pci_name(pdev));
1508                 goto err_pci_disable_2;
1509         }
1510
1511         rc = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
1512         if (rc < 0) {
1513                 if (netif_msg_probe(tp))
1514                         pr_err("%s: DMA configuration failed\n",
1515                                pci_name(pdev));
1516                 goto err_free_res_3;
1517         }
1518
1519         pci_set_master(pdev);
1520
1521         ioaddr = ioremap(pci_resource_start(pdev, 0), SIS190_REGS_SIZE);
1522         if (!ioaddr) {
1523                 if (netif_msg_probe(tp))
1524                         pr_err("%s: cannot remap MMIO, aborting\n",
1525                                pci_name(pdev));
1526                 rc = -EIO;
1527                 goto err_free_res_3;
1528         }
1529
1530         tp->pci_dev = pdev;
1531         tp->mmio_addr = ioaddr;
1532         tp->link_status = LNK_OFF;
1533
1534         sis190_irq_mask_and_ack(ioaddr);
1535
1536         sis190_soft_reset(ioaddr);
1537 out:
1538         return dev;
1539
1540 err_free_res_3:
1541         pci_release_regions(pdev);
1542 err_pci_disable_2:
1543         pci_disable_device(pdev);
1544 err_free_dev_1:
1545         free_netdev(dev);
1546 err_out_0:
1547         dev = ERR_PTR(rc);
1548         goto out;
1549 }
1550
1551 static void sis190_tx_timeout(struct net_device *dev, unsigned int txqueue)
1552 {
1553         struct sis190_private *tp = netdev_priv(dev);
1554         void __iomem *ioaddr = tp->mmio_addr;
1555         u8 tmp8;
1556
1557         /* Disable Tx, if not already */
1558         tmp8 = SIS_R8(TxControl);
1559         if (tmp8 & CmdTxEnb)
1560                 SIS_W8(TxControl, tmp8 & ~CmdTxEnb);
1561
1562         netif_info(tp, tx_err, dev, "Transmit timeout, status %08x %08x\n",
1563                    SIS_R32(TxControl), SIS_R32(TxSts));
1564
1565         /* Disable interrupts by clearing the interrupt mask. */
1566         SIS_W32(IntrMask, 0x0000);
1567
1568         /* Stop a shared interrupt from scavenging while we are. */
1569         spin_lock_irq(&tp->lock);
1570         sis190_tx_clear(tp);
1571         spin_unlock_irq(&tp->lock);
1572
1573         /* ...and finally, reset everything. */
1574         sis190_hw_start(dev);
1575
1576         netif_wake_queue(dev);
1577 }
1578
1579 static void sis190_set_rgmii(struct sis190_private *tp, u8 reg)
1580 {
1581         tp->features |= (reg & 0x80) ? F_HAS_RGMII : 0;
1582 }
1583
1584 static int sis190_get_mac_addr_from_eeprom(struct pci_dev *pdev,
1585                                            struct net_device *dev)
1586 {
1587         struct sis190_private *tp = netdev_priv(dev);
1588         void __iomem *ioaddr = tp->mmio_addr;
1589         u16 sig;
1590         int i;
1591
1592         if (netif_msg_probe(tp))
1593                 pr_info("%s: Read MAC address from EEPROM\n", pci_name(pdev));
1594
1595         /* Check to see if there is a sane EEPROM */
1596         sig = (u16) sis190_read_eeprom(ioaddr, EEPROMSignature);
1597
1598         if ((sig == 0xffff) || (sig == 0x0000)) {
1599                 if (netif_msg_probe(tp))
1600                         pr_info("%s: Error EEPROM read %x\n",
1601                                 pci_name(pdev), sig);
1602                 return -EIO;
1603         }
1604
1605         /* Get MAC address from EEPROM */
1606         for (i = 0; i < ETH_ALEN / 2; i++) {
1607                 u16 w = sis190_read_eeprom(ioaddr, EEPROMMACAddr + i);
1608
1609                 ((__le16 *)dev->dev_addr)[i] = cpu_to_le16(w);
1610         }
1611
1612         sis190_set_rgmii(tp, sis190_read_eeprom(ioaddr, EEPROMInfo));
1613
1614         return 0;
1615 }
1616
1617 /**
1618  *      sis190_get_mac_addr_from_apc - Get MAC address for SiS96x model
1619  *      @pdev: PCI device
1620  *      @dev:  network device to get address for
1621  *
1622  *      SiS96x model, use APC CMOS RAM to store MAC address.
1623  *      APC CMOS RAM is accessed through ISA bridge.
1624  *      MAC address is read into @net_dev->dev_addr.
1625  */
1626 static int sis190_get_mac_addr_from_apc(struct pci_dev *pdev,
1627                                         struct net_device *dev)
1628 {
1629         static const u16 ids[] = { 0x0965, 0x0966, 0x0968 };
1630         struct sis190_private *tp = netdev_priv(dev);
1631         struct pci_dev *isa_bridge;
1632         u8 reg, tmp8;
1633         unsigned int i;
1634
1635         if (netif_msg_probe(tp))
1636                 pr_info("%s: Read MAC address from APC\n", pci_name(pdev));
1637
1638         for (i = 0; i < ARRAY_SIZE(ids); i++) {
1639                 isa_bridge = pci_get_device(PCI_VENDOR_ID_SI, ids[i], NULL);
1640                 if (isa_bridge)
1641                         break;
1642         }
1643
1644         if (!isa_bridge) {
1645                 if (netif_msg_probe(tp))
1646                         pr_info("%s: Can not find ISA bridge\n",
1647                                 pci_name(pdev));
1648                 return -EIO;
1649         }
1650
1651         /* Enable port 78h & 79h to access APC Registers. */
1652         pci_read_config_byte(isa_bridge, 0x48, &tmp8);
1653         reg = (tmp8 & ~0x02);
1654         pci_write_config_byte(isa_bridge, 0x48, reg);
1655         udelay(50);
1656         pci_read_config_byte(isa_bridge, 0x48, &reg);
1657
1658         for (i = 0; i < ETH_ALEN; i++) {
1659                 outb(0x9 + i, 0x78);
1660                 dev->dev_addr[i] = inb(0x79);
1661         }
1662
1663         outb(0x12, 0x78);
1664         reg = inb(0x79);
1665
1666         sis190_set_rgmii(tp, reg);
1667
1668         /* Restore the value to ISA Bridge */
1669         pci_write_config_byte(isa_bridge, 0x48, tmp8);
1670         pci_dev_put(isa_bridge);
1671
1672         return 0;
1673 }
1674
1675 /**
1676  *      sis190_init_rxfilter - Initialize the Rx filter
1677  *      @dev: network device to initialize
1678  *
1679  *      Set receive filter address to our MAC address
1680  *      and enable packet filtering.
1681  */
1682 static inline void sis190_init_rxfilter(struct net_device *dev)
1683 {
1684         struct sis190_private *tp = netdev_priv(dev);
1685         void __iomem *ioaddr = tp->mmio_addr;
1686         u16 ctl;
1687         int i;
1688
1689         ctl = SIS_R16(RxMacControl);
1690         /*
1691          * Disable packet filtering before setting filter.
1692          * Note: SiS's driver writes 32 bits but RxMacControl is 16 bits
1693          * only and followed by RxMacAddr (6 bytes). Strange. -- FR
1694          */
1695         SIS_W16(RxMacControl, ctl & ~0x0f00);
1696
1697         for (i = 0; i < ETH_ALEN; i++)
1698                 SIS_W8(RxMacAddr + i, dev->dev_addr[i]);
1699
1700         SIS_W16(RxMacControl, ctl);
1701         SIS_PCI_COMMIT();
1702 }
1703
1704 static int sis190_get_mac_addr(struct pci_dev *pdev, struct net_device *dev)
1705 {
1706         int rc;
1707
1708         rc = sis190_get_mac_addr_from_eeprom(pdev, dev);
1709         if (rc < 0) {
1710                 u8 reg;
1711
1712                 pci_read_config_byte(pdev, 0x73, &reg);
1713
1714                 if (reg & 0x00000001)
1715                         rc = sis190_get_mac_addr_from_apc(pdev, dev);
1716         }
1717         return rc;
1718 }
1719
1720 static void sis190_set_speed_auto(struct net_device *dev)
1721 {
1722         struct sis190_private *tp = netdev_priv(dev);
1723         void __iomem *ioaddr = tp->mmio_addr;
1724         int phy_id = tp->mii_if.phy_id;
1725         int val;
1726
1727         netif_info(tp, link, dev, "Enabling Auto-negotiation\n");
1728
1729         val = mdio_read(ioaddr, phy_id, MII_ADVERTISE);
1730
1731         // Enable 10/100 Full/Half Mode, leave MII_ADVERTISE bit4:0
1732         // unchanged.
1733         mdio_write(ioaddr, phy_id, MII_ADVERTISE, (val & ADVERTISE_SLCT) |
1734                    ADVERTISE_100FULL | ADVERTISE_10FULL |
1735                    ADVERTISE_100HALF | ADVERTISE_10HALF);
1736
1737         // Enable 1000 Full Mode.
1738         mdio_write(ioaddr, phy_id, MII_CTRL1000, ADVERTISE_1000FULL);
1739
1740         // Enable auto-negotiation and restart auto-negotiation.
1741         mdio_write(ioaddr, phy_id, MII_BMCR,
1742                    BMCR_ANENABLE | BMCR_ANRESTART | BMCR_RESET);
1743 }
1744
1745 static int sis190_get_link_ksettings(struct net_device *dev,
1746                                      struct ethtool_link_ksettings *cmd)
1747 {
1748         struct sis190_private *tp = netdev_priv(dev);
1749
1750         mii_ethtool_get_link_ksettings(&tp->mii_if, cmd);
1751
1752         return 0;
1753 }
1754
1755 static int sis190_set_link_ksettings(struct net_device *dev,
1756                                      const struct ethtool_link_ksettings *cmd)
1757 {
1758         struct sis190_private *tp = netdev_priv(dev);
1759
1760         return mii_ethtool_set_link_ksettings(&tp->mii_if, cmd);
1761 }
1762
1763 static void sis190_get_drvinfo(struct net_device *dev,
1764                                struct ethtool_drvinfo *info)
1765 {
1766         struct sis190_private *tp = netdev_priv(dev);
1767
1768         strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1769         strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1770         strlcpy(info->bus_info, pci_name(tp->pci_dev),
1771                 sizeof(info->bus_info));
1772 }
1773
1774 static int sis190_get_regs_len(struct net_device *dev)
1775 {
1776         return SIS190_REGS_SIZE;
1777 }
1778
1779 static void sis190_get_regs(struct net_device *dev, struct ethtool_regs *regs,
1780                             void *p)
1781 {
1782         struct sis190_private *tp = netdev_priv(dev);
1783         unsigned long flags;
1784
1785         spin_lock_irqsave(&tp->lock, flags);
1786         memcpy_fromio(p, tp->mmio_addr, regs->len);
1787         spin_unlock_irqrestore(&tp->lock, flags);
1788 }
1789
1790 static int sis190_nway_reset(struct net_device *dev)
1791 {
1792         struct sis190_private *tp = netdev_priv(dev);
1793
1794         return mii_nway_restart(&tp->mii_if);
1795 }
1796
1797 static u32 sis190_get_msglevel(struct net_device *dev)
1798 {
1799         struct sis190_private *tp = netdev_priv(dev);
1800
1801         return tp->msg_enable;
1802 }
1803
1804 static void sis190_set_msglevel(struct net_device *dev, u32 value)
1805 {
1806         struct sis190_private *tp = netdev_priv(dev);
1807
1808         tp->msg_enable = value;
1809 }
1810
1811 static const struct ethtool_ops sis190_ethtool_ops = {
1812         .get_drvinfo    = sis190_get_drvinfo,
1813         .get_regs_len   = sis190_get_regs_len,
1814         .get_regs       = sis190_get_regs,
1815         .get_link       = ethtool_op_get_link,
1816         .get_msglevel   = sis190_get_msglevel,
1817         .set_msglevel   = sis190_set_msglevel,
1818         .nway_reset     = sis190_nway_reset,
1819         .get_link_ksettings = sis190_get_link_ksettings,
1820         .set_link_ksettings = sis190_set_link_ksettings,
1821 };
1822
1823 static int sis190_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1824 {
1825         struct sis190_private *tp = netdev_priv(dev);
1826
1827         return !netif_running(dev) ? -EINVAL :
1828                 generic_mii_ioctl(&tp->mii_if, if_mii(ifr), cmd, NULL);
1829 }
1830
1831 static int sis190_mac_addr(struct net_device  *dev, void *p)
1832 {
1833         int rc;
1834
1835         rc = eth_mac_addr(dev, p);
1836         if (!rc)
1837                 sis190_init_rxfilter(dev);
1838         return rc;
1839 }
1840
1841 static const struct net_device_ops sis190_netdev_ops = {
1842         .ndo_open               = sis190_open,
1843         .ndo_stop               = sis190_close,
1844         .ndo_do_ioctl           = sis190_ioctl,
1845         .ndo_start_xmit         = sis190_start_xmit,
1846         .ndo_tx_timeout         = sis190_tx_timeout,
1847         .ndo_set_rx_mode        = sis190_set_rx_mode,
1848         .ndo_set_mac_address    = sis190_mac_addr,
1849         .ndo_validate_addr      = eth_validate_addr,
1850 #ifdef CONFIG_NET_POLL_CONTROLLER
1851         .ndo_poll_controller     = sis190_netpoll,
1852 #endif
1853 };
1854
1855 static int sis190_init_one(struct pci_dev *pdev,
1856                            const struct pci_device_id *ent)
1857 {
1858         static int printed_version = 0;
1859         struct sis190_private *tp;
1860         struct net_device *dev;
1861         void __iomem *ioaddr;
1862         int rc;
1863
1864         if (!printed_version) {
1865                 if (netif_msg_drv(&debug))
1866                         pr_info(SIS190_DRIVER_NAME " loaded\n");
1867                 printed_version = 1;
1868         }
1869
1870         dev = sis190_init_board(pdev);
1871         if (IS_ERR(dev)) {
1872                 rc = PTR_ERR(dev);
1873                 goto out;
1874         }
1875
1876         pci_set_drvdata(pdev, dev);
1877
1878         tp = netdev_priv(dev);
1879         ioaddr = tp->mmio_addr;
1880
1881         rc = sis190_get_mac_addr(pdev, dev);
1882         if (rc < 0)
1883                 goto err_release_board;
1884
1885         sis190_init_rxfilter(dev);
1886
1887         INIT_WORK(&tp->phy_task, sis190_phy_task);
1888
1889         dev->netdev_ops = &sis190_netdev_ops;
1890
1891         dev->ethtool_ops = &sis190_ethtool_ops;
1892         dev->watchdog_timeo = SIS190_TX_TIMEOUT;
1893
1894         spin_lock_init(&tp->lock);
1895
1896         rc = sis190_mii_probe(dev);
1897         if (rc < 0)
1898                 goto err_release_board;
1899
1900         rc = register_netdev(dev);
1901         if (rc < 0)
1902                 goto err_remove_mii;
1903
1904         if (netif_msg_probe(tp)) {
1905                 netdev_info(dev, "%s: %s at %p (IRQ: %d), %pM\n",
1906                             pci_name(pdev),
1907                             sis_chip_info[ent->driver_data].name,
1908                             ioaddr, pdev->irq, dev->dev_addr);
1909                 netdev_info(dev, "%s mode.\n",
1910                             (tp->features & F_HAS_RGMII) ? "RGMII" : "GMII");
1911         }
1912
1913         netif_carrier_off(dev);
1914
1915         sis190_set_speed_auto(dev);
1916 out:
1917         return rc;
1918
1919 err_remove_mii:
1920         sis190_mii_remove(dev);
1921 err_release_board:
1922         sis190_release_board(pdev);
1923         goto out;
1924 }
1925
1926 static void sis190_remove_one(struct pci_dev *pdev)
1927 {
1928         struct net_device *dev = pci_get_drvdata(pdev);
1929         struct sis190_private *tp = netdev_priv(dev);
1930
1931         sis190_mii_remove(dev);
1932         cancel_work_sync(&tp->phy_task);
1933         unregister_netdev(dev);
1934         sis190_release_board(pdev);
1935 }
1936
1937 static struct pci_driver sis190_pci_driver = {
1938         .name           = DRV_NAME,
1939         .id_table       = sis190_pci_tbl,
1940         .probe          = sis190_init_one,
1941         .remove         = sis190_remove_one,
1942 };
1943
1944 module_pci_driver(sis190_pci_driver);