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