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 and probably even epic100.c.
   9
  10    This software may be used and distributed according to the terms of
  11    the GNU General Public License (GPL), incorporated herein by reference.
  12    Drivers based on or derived from this code fall under the GPL and must
  13    retain the authorship, copyright and license notice.  This file is not
  14    a complete program and may only be used when the entire operating
  15    system is licensed under the GPL.
  16
  17    See the file COPYING in this distribution for more information.
  18
  19  */
  20
  21 #include <linux/module.h>
  22 #include <linux/moduleparam.h>
  23 #include <linux/netdevice.h>
  24 #include <linux/rtnetlink.h>
  25 #include <linux/etherdevice.h>
  26 #include <linux/ethtool.h>
  27 #include <linux/pci.h>
  28 #include <linux/mii.h>
  29 #include <linux/delay.h>
  30 #include <linux/crc32.h>
  31 #include <linux/dma-mapping.h>
  32 #include <asm/irq.h>
  33
  34 #define net_drv(p, arg...)      if (netif_msg_drv(p)) \
  35                                         printk(arg)
  36 #define net_probe(p, arg...)    if (netif_msg_probe(p)) \
  37                                         printk(arg)
  38 #define net_link(p, arg...)     if (netif_msg_link(p)) \
  39                                         printk(arg)
  40 #define net_intr(p, arg...)     if (netif_msg_intr(p)) \
  41                                         printk(arg)
  42 #define net_tx_err(p, arg...)   if (netif_msg_tx_err(p)) \
  43                                         printk(arg)
  44
  45 #ifdef CONFIG_SIS190_NAPI
  46 #define NAPI_SUFFIX     "-NAPI"
  47 #else
  48 #define NAPI_SUFFIX     ""
  49 #endif
  50
  51 #define DRV_VERSION             "1.2" NAPI_SUFFIX
  52 #define DRV_NAME                "sis190"
  53 #define SIS190_DRIVER_NAME      DRV_NAME " Gigabit Ethernet driver " DRV_VERSION
  54 #define PFX DRV_NAME ": "
  55
  56 #ifdef CONFIG_SIS190_NAPI
  57 #define sis190_rx_skb                   netif_receive_skb
  58 #define sis190_rx_quota(count, quota)   min(count, quota)
  59 #else
  60 #define sis190_rx_skb                   netif_rx
  61 #define sis190_rx_quota(count, quota)   count
  62 #endif
  63
  64 #define MAC_ADDR_LEN            6
  65
  66 #define NUM_TX_DESC             64
  67 #define NUM_RX_DESC             64
  68 #define TX_RING_BYTES           (NUM_TX_DESC * sizeof(struct TxDesc))
  69 #define RX_RING_BYTES           (NUM_RX_DESC * sizeof(struct RxDesc))
  70 #define RX_BUF_SIZE             1536
  71
  72 #define SIS190_REGS_SIZE        0x80
  73 #define SIS190_TX_TIMEOUT       (6*HZ)
  74 #define SIS190_PHY_TIMEOUT      (10*HZ)
  75 #define SIS190_MSG_DEFAULT      (NETIF_MSG_DRV | NETIF_MSG_PROBE | \
  76                                  NETIF_MSG_LINK | NETIF_MSG_IFUP | \
  77                                  NETIF_MSG_IFDOWN)
  78
  79 /* Enhanced PHY access register bit definitions */
  80 #define EhnMIIread              0x0000
  81 #define EhnMIIwrite             0x0020
  82 #define EhnMIIdataShift         16
  83 #define EhnMIIpmdShift          6       /* 7016 only */
  84 #define EhnMIIregShift          11
  85 #define EhnMIIreq               0x0010
  86 #define EhnMIInotDone           0x0010
  87
  88 /* Write/read MMIO register */
  89 #define SIS_W8(reg, val)        writeb ((val), ioaddr + (reg))
  90 #define SIS_W16(reg, val)       writew ((val), ioaddr + (reg))
  91 #define SIS_W32(reg, val)       writel ((val), ioaddr + (reg))
  92 #define SIS_R8(reg)             readb (ioaddr + (reg))
  93 #define SIS_R16(reg)            readw (ioaddr + (reg))
  94 #define SIS_R32(reg)            readl (ioaddr + (reg))
  95
  96 #define SIS_PCI_COMMIT()        SIS_R32(IntrControl)
  97
  98 enum sis190_registers {
  99         TxControl               = 0x00,
 100         TxDescStartAddr         = 0x04,
 101         TxNextDescAddr          = 0x0c, // unused
 102         RxControl               = 0x10,
 103         RxDescStartAddr         = 0x14,
 104         RxNextDescAddr          = 0x1c, // unused
 105         IntrStatus              = 0x20,
 106         IntrMask                = 0x24,
 107         IntrControl             = 0x28,
 108         IntrTimer               = 0x2c, // unused
 109         PMControl               = 0x30, // unused
 110         ROMControl              = 0x38,
 111         ROMInterface            = 0x3c,
 112         StationControl          = 0x40,
 113         GMIIControl             = 0x44,
 114         TxMacControl            = 0x50,
 115         RxMacControl            = 0x60,
 116         RxMacAddr               = 0x62,
 117         RxHashTable             = 0x68,
 118         // Undocumented         = 0x6c,
 119         RxWakeOnLan             = 0x70,
 120         // Undocumented         = 0x74,
 121         RxMPSControl            = 0x78, // unused
 122 };
 123
 124 enum sis190_register_content {
 125         /* IntrStatus */
 126         SoftInt                 = 0x40000000,   // unused
 127         Timeup                  = 0x20000000,   // unused
 128         PauseFrame              = 0x00080000,   // unused
 129         MagicPacket             = 0x00040000,   // unused
 130         WakeupFrame             = 0x00020000,   // unused
 131         LinkChange              = 0x00010000,
 132         RxQEmpty                = 0x00000080,
 133         RxQInt                  = 0x00000040,
 134         TxQ1Empty               = 0x00000020,   // unused
 135         TxQ1Int                 = 0x00000010,
 136         TxQ0Empty               = 0x00000008,   // unused
 137         TxQ0Int                 = 0x00000004,
 138         RxHalt                  = 0x00000002,
 139         TxHalt                  = 0x00000001,
 140
 141         /* RxStatusDesc */
 142         RxRES                   = 0x00200000,   // unused
 143         RxCRC                   = 0x00080000,
 144         RxRUNT                  = 0x00100000,   // unused
 145         RxRWT                   = 0x00400000,   // unused
 146
 147         /* {Rx/Tx}CmdBits */
 148         CmdReset                = 0x10,
 149         CmdRxEnb                = 0x08,         // unused
 150         CmdTxEnb                = 0x01,
 151         RxBufEmpty              = 0x01,         // unused
 152
 153         /* Cfg9346Bits */
 154         Cfg9346_Lock            = 0x00,         // unused
 155         Cfg9346_Unlock          = 0xc0,         // unused
 156
 157         /* RxMacControl */
 158         AcceptErr               = 0x20,         // unused
 159         AcceptRunt              = 0x10,         // unused
 160         AcceptBroadcast         = 0x0800,
 161         AcceptMulticast         = 0x0400,
 162         AcceptMyPhys            = 0x0200,
 163         AcceptAllPhys           = 0x0100,
 164
 165         /* RxConfigBits */
 166         RxCfgFIFOShift          = 13,
 167         RxCfgDMAShift           = 8,            // 0x1a in RxControl ?
 168
 169         /* TxConfigBits */
 170         TxInterFrameGapShift    = 24,
 171         TxDMAShift              = 8, /* DMA burst value (0-7) is shift this many bits */
 172
 173         /* StationControl */
 174         _1000bpsF               = 0x1c00,
 175         _1000bpsH               = 0x0c00,
 176         _100bpsF                = 0x1800,
 177         _100bpsH                = 0x0800,
 178         _10bpsF                 = 0x1400,
 179         _10bpsH                 = 0x0400,
 180
 181         LinkStatus              = 0x02,         // unused
 182         FullDup                 = 0x01,         // unused
 183
 184         /* TBICSRBit */
 185         TBILinkOK               = 0x02000000,   // unused
 186 };
 187
 188 struct TxDesc {
 189         u32 PSize;
 190         u32 status;
 191         u32 addr;
 192         u32 size;
 193 };
 194
 195 struct RxDesc {
 196         u32 PSize;
 197         u32 status;
 198         u32 addr;
 199         u32 size;
 200 };
 201
 202 enum _DescStatusBit {
 203         /* _Desc.status */
 204         OWNbit          = 0x80000000,
 205         INTbit          = 0x40000000,
 206         DEFbit          = 0x00200000,
 207         CRCbit          = 0x00020000,
 208         PADbit          = 0x00010000,
 209         /* _Desc.size */
 210         RingEnd         = (1 << 31),
 211         /* _Desc.PSize */
 212         RxSizeMask      = 0x0000ffff
 213 };
 214
 215 struct sis190_private {
 216         void __iomem *mmio_addr;
 217         struct pci_dev *pci_dev;
 218         struct net_device_stats stats;
 219         spinlock_t lock;
 220         u32 rx_buf_sz;
 221         u32 cur_rx;
 222         u32 cur_tx;
 223         u32 dirty_rx;
 224         u32 dirty_tx;
 225         dma_addr_t rx_dma;
 226         dma_addr_t tx_dma;
 227         struct RxDesc *RxDescRing;
 228         struct TxDesc *TxDescRing;
 229         struct sk_buff *Rx_skbuff[NUM_RX_DESC];
 230         struct sk_buff *Tx_skbuff[NUM_TX_DESC];
 231         struct work_struct phy_task;
 232         struct timer_list timer;
 233         u32 msg_enable;
 234         struct mii_if_info mii_if;
 235 };
 236
 237 const static struct {
 238         const char *name;
 239         u8 version;             /* depend on docs */
 240         u32 RxConfigMask;       /* clear the bits supported by this chip */
 241 } sis_chip_info[] = {
 242         { DRV_NAME, 0x00, 0xff7e1880, },
 243 };
 244
 245 static struct pci_device_id sis190_pci_tbl[] __devinitdata = {
 246         { PCI_DEVICE(PCI_VENDOR_ID_SI, 0x0190), 0, 0, 0 },
 247         { 0, },
 248 };
 249
 250 MODULE_DEVICE_TABLE(pci, sis190_pci_tbl);
 251
 252 static int rx_copybreak = 200;
 253
 254 static struct {
 255         u32 msg_enable;
 256 } debug = { -1 };
 257
 258 MODULE_DESCRIPTION("SiS sis190 Gigabit Ethernet driver");
 259 module_param(rx_copybreak, int, 0);
 260 MODULE_PARM_DESC(rx_copybreak, "Copy breakpoint for copy-only-tiny-frames");
 261 module_param_named(debug, debug.msg_enable, int, 0);
 262 MODULE_PARM_DESC(debug, "Debug verbosity level (0=none, ..., 16=all)");
 263 MODULE_AUTHOR("K.M. Liu <kmliu@sis.com>, Ueimor <romieu@fr.zoreil.com>");
 264 MODULE_VERSION(DRV_VERSION);
 265 MODULE_LICENSE("GPL");
 266
 267 static const u32 sis190_intr_mask =
 268         RxQEmpty | RxQInt | TxQ1Int | TxQ0Int | RxHalt | TxHalt;
 269
 270 /*
 271  * Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
 272  * The chips use a 64 element hash table based on the Ethernet CRC.
 273  */
 274 static int multicast_filter_limit = 32;
 275
 276 static void __mdio_cmd(void __iomem *ioaddr, u32 ctl)
 277 {
 278         unsigned int i;
 279
 280         SIS_W32(GMIIControl, ctl);
 281
 282         msleep(1);
 283
 284         for (i = 0; i < 100; i++) {
 285                 if (!(SIS_R32(GMIIControl) & EhnMIInotDone))
 286                         break;
 287                 msleep(1);
 288         }
 289
 290         if (i > 999)
 291                 printk(KERN_ERR PFX "PHY command failed !\n");
 292 }
 293
 294 static void mdio_write(void __iomem *ioaddr, int reg, int val)
 295 {
 296         u32 pmd = 1;
 297
 298         __mdio_cmd(ioaddr, EhnMIIreq | EhnMIIwrite |
 299                 (((u32) reg) << EhnMIIregShift) | (pmd << EhnMIIpmdShift) |
 300                 (((u32) val) << EhnMIIdataShift));
 301 }
 302
 303 static int mdio_read(void __iomem *ioaddr, int reg)
 304 {
 305         u32 pmd = 1;
 306
 307         __mdio_cmd(ioaddr, EhnMIIreq | EhnMIIread |
 308                 (((u32) reg) << EhnMIIregShift) | (pmd << EhnMIIpmdShift));
 309
 310         return (u16) (SIS_R32(GMIIControl) >> EhnMIIdataShift);
 311 }
 312
 313 static void __mdio_write(struct net_device *dev, int phy_id, int reg, int val)
 314 {
 315         struct sis190_private *tp = netdev_priv(dev);
 316
 317         mdio_write(tp->mmio_addr, reg, val);
 318 }
 319
 320 static int __mdio_read(struct net_device *dev, int phy_id, int reg)
 321 {
 322         struct sis190_private *tp = netdev_priv(dev);
 323
 324         return mdio_read(tp->mmio_addr, reg);
 325 }
 326
 327 static int sis190_read_eeprom(void __iomem *ioaddr, u32 reg)
 328 {
 329         unsigned int i;
 330         u16 data;
 331         u32 val;
 332
 333         if (!(SIS_R32(ROMControl) & 0x0002))
 334                 return 0;
 335
 336         val = (0x0080 | (0x2 << 8) | (reg << 10));
 337
 338         SIS_W32(ROMInterface, val);
 339
 340         for (i = 0; i < 200; i++) {
 341                 if (!(SIS_R32(ROMInterface) & 0x0080))
 342                         break;
 343                 msleep(1);
 344         }
 345
 346         data = (u16) ((SIS_R32(ROMInterface) & 0xffff0000) >> 16);
 347
 348         return data;
 349 }
 350
 351 static void sis190_irq_mask_and_ack(void __iomem *ioaddr)
 352 {
 353         SIS_W32(IntrMask, 0x00);
 354         SIS_W32(IntrStatus, 0xffffffff);
 355         SIS_PCI_COMMIT();
 356 }
 357
 358 static void sis190_asic_down(void __iomem *ioaddr)
 359 {
 360         /* Stop the chip's Tx and Rx DMA processes. */
 361
 362         SIS_W32(TxControl, 0x1a00);
 363         SIS_W32(RxControl, 0x1a00);
 364
 365         sis190_irq_mask_and_ack(ioaddr);
 366 }
 367
 368 static void sis190_mark_as_last_descriptor(struct RxDesc *desc)
 369 {
 370         desc->size |= cpu_to_le32(RingEnd);
 371 }
 372
 373 static inline void sis190_give_to_asic(struct RxDesc *desc, u32 rx_buf_sz)
 374 {
 375         u32 eor = le32_to_cpu(desc->size) & RingEnd;
 376
 377         desc->PSize = 0x0;
 378         desc->size = cpu_to_le32(rx_buf_sz | eor);
 379         wmb();
 380         desc->status = cpu_to_le32(OWNbit | INTbit);
 381 }
 382
 383 static inline void sis190_map_to_asic(struct RxDesc *desc, dma_addr_t mapping,
 384                                       u32 rx_buf_sz)
 385 {
 386         desc->addr = cpu_to_le32(mapping);
 387         sis190_give_to_asic(desc, rx_buf_sz);
 388 }
 389
 390 static inline void sis190_make_unusable_by_asic(struct RxDesc *desc)
 391 {
 392         desc->PSize = 0x0;
 393         desc->addr = 0xdeadbeef;
 394         desc->size &= cpu_to_le32(RingEnd);
 395         wmb();
 396         desc->status = 0x0;
 397 }
 398
 399 static int sis190_alloc_rx_skb(struct pci_dev *pdev, struct sk_buff **sk_buff,
 400                                struct RxDesc *desc, u32 rx_buf_sz)
 401 {
 402         struct sk_buff *skb;
 403         dma_addr_t mapping;
 404         int ret = 0;
 405
 406         skb = dev_alloc_skb(rx_buf_sz);
 407         if (!skb)
 408                 goto err_out;
 409
 410         *sk_buff = skb;
 411
 412         mapping = pci_map_single(pdev, skb->data, rx_buf_sz,
 413                                  PCI_DMA_FROMDEVICE);
 414
 415         sis190_map_to_asic(desc, mapping, rx_buf_sz);
 416 out:
 417         return ret;
 418
 419 err_out:
 420         ret = -ENOMEM;
 421         sis190_make_unusable_by_asic(desc);
 422         goto out;
 423 }
 424
 425 static u32 sis190_rx_fill(struct sis190_private *tp, struct net_device *dev,
 426                           u32 start, u32 end)
 427 {
 428         u32 cur;
 429
 430         for (cur = start; cur < end; cur++) {
 431                 int ret, i = cur % NUM_RX_DESC;
 432
 433                 if (tp->Rx_skbuff[i])
 434                         continue;
 435
 436                 ret = sis190_alloc_rx_skb(tp->pci_dev, tp->Rx_skbuff + i,
 437                                           tp->RxDescRing + i, tp->rx_buf_sz);
 438                 if (ret < 0)
 439                         break;
 440         }
 441         return cur - start;
 442 }
 443
 444 static inline int sis190_try_rx_copy(struct sk_buff **sk_buff, int pkt_size,
 445                                      struct RxDesc *desc, int rx_buf_sz)
 446 {
 447         int ret = -1;
 448
 449         if (pkt_size < rx_copybreak) {
 450                 struct sk_buff *skb;
 451
 452                 skb = dev_alloc_skb(pkt_size + NET_IP_ALIGN);
 453                 if (skb) {
 454                         skb_reserve(skb, NET_IP_ALIGN);
 455                         eth_copy_and_sum(skb, sk_buff[0]->data, pkt_size, 0);
 456                         *sk_buff = skb;
 457                         sis190_give_to_asic(desc, rx_buf_sz);
 458                         ret = 0;
 459                 }
 460         }
 461         return ret;
 462 }
 463
 464 static int sis190_rx_interrupt(struct net_device *dev,
 465                                struct sis190_private *tp, void __iomem *ioaddr)
 466 {
 467         struct net_device_stats *stats = &tp->stats;
 468         u32 rx_left, cur_rx = tp->cur_rx;
 469         u32 delta, count;
 470
 471         rx_left = NUM_RX_DESC + tp->dirty_rx - cur_rx;
 472         rx_left = sis190_rx_quota(rx_left, (u32) dev->quota);
 473
 474         for (; rx_left > 0; rx_left--, cur_rx++) {
 475                 unsigned int entry = cur_rx % NUM_RX_DESC;
 476                 struct RxDesc *desc = tp->RxDescRing + entry;
 477                 u32 status;
 478
 479                 if (desc->status & OWNbit)
 480                         break;
 481
 482                 status = le32_to_cpu(desc->PSize);
 483
 484                 // net_intr(tp, KERN_INFO "%s: Rx PSize = %08x.\n", dev->name,
 485                 //       status);
 486
 487                 if (status & RxCRC) {
 488                         net_intr(tp, KERN_INFO "%s: bad crc. status = %08x.\n",
 489                                  dev->name, status);
 490                         stats->rx_errors++;
 491                         stats->rx_crc_errors++;
 492                         sis190_give_to_asic(desc, tp->rx_buf_sz);
 493                 } else if (!(status & PADbit)) {
 494                         net_intr(tp, KERN_INFO "%s: bad pad. status = %08x.\n",
 495                                  dev->name, status);
 496                         stats->rx_errors++;
 497                         stats->rx_length_errors++;
 498                         sis190_give_to_asic(desc, tp->rx_buf_sz);
 499                 } else {
 500                         struct sk_buff *skb = tp->Rx_skbuff[entry];
 501                         int pkt_size = (status & RxSizeMask) - 4;
 502                         void (*pci_action)(struct pci_dev *, dma_addr_t,
 503                                 size_t, int) = pci_dma_sync_single_for_device;
 504
 505                         if (unlikely(pkt_size > tp->rx_buf_sz)) {
 506                                 net_intr(tp, KERN_INFO
 507                                          "%s: (frag) status = %08x.\n",
 508                                          dev->name, status);
 509                                 stats->rx_dropped++;
 510                                 stats->rx_length_errors++;
 511                                 sis190_give_to_asic(desc, tp->rx_buf_sz);
 512                                 continue;
 513                         }
 514
 515                         pci_dma_sync_single_for_cpu(tp->pci_dev,
 516                                 le32_to_cpu(desc->addr), tp->rx_buf_sz,
 517                                 PCI_DMA_FROMDEVICE);
 518
 519                         if (sis190_try_rx_copy(&skb, pkt_size, desc,
 520                                                tp->rx_buf_sz)) {
 521                                 pci_action = pci_unmap_single;
 522                                 tp->Rx_skbuff[entry] = NULL;
 523                                 sis190_make_unusable_by_asic(desc);
 524                         }
 525
 526                         pci_action(tp->pci_dev, le32_to_cpu(desc->addr),
 527                                    tp->rx_buf_sz, PCI_DMA_FROMDEVICE);
 528
 529                         skb->dev = dev;
 530                         skb_put(skb, pkt_size);
 531                         skb->protocol = eth_type_trans(skb, dev);
 532
 533                         sis190_rx_skb(skb);
 534
 535                         dev->last_rx = jiffies;
 536                         stats->rx_bytes += pkt_size;
 537                         stats->rx_packets++;
 538                 }
 539         }
 540         count = cur_rx - tp->cur_rx;
 541         tp->cur_rx = cur_rx;
 542
 543         delta = sis190_rx_fill(tp, dev, tp->dirty_rx, tp->cur_rx);
 544         if (!delta && count && netif_msg_intr(tp))
 545                 printk(KERN_INFO "%s: no Rx buffer allocated.\n", dev->name);
 546         tp->dirty_rx += delta;
 547
 548         if (((tp->dirty_rx + NUM_RX_DESC) == tp->cur_rx) && netif_msg_intr(tp))
 549                 printk(KERN_EMERG "%s: Rx buffers exhausted.\n", dev->name);
 550
 551         return count;
 552 }
 553
 554 static void sis190_unmap_tx_skb(struct pci_dev *pdev, struct sk_buff *skb,
 555                                 struct TxDesc *desc)
 556 {
 557         unsigned int len;
 558
 559         len = skb->len < ETH_ZLEN ? ETH_ZLEN : skb->len;
 560
 561         pci_unmap_single(pdev, le32_to_cpu(desc->addr), len, PCI_DMA_TODEVICE);
 562
 563         memset(desc, 0x00, sizeof(*desc));
 564 }
 565
 566 static void sis190_tx_interrupt(struct net_device *dev,
 567                                 struct sis190_private *tp, void __iomem *ioaddr)
 568 {
 569         u32 pending, dirty_tx = tp->dirty_tx;
 570         /*
 571          * It would not be needed if queueing was allowed to be enabled
 572          * again too early (hint: think preempt and unclocked smp systems).
 573          */
 574         unsigned int queue_stopped;
 575
 576         smp_rmb();
 577         pending = tp->cur_tx - dirty_tx;
 578         queue_stopped = (pending == NUM_TX_DESC);
 579
 580         for (; pending; pending--, dirty_tx++) {
 581                 unsigned int entry = dirty_tx % NUM_TX_DESC;
 582                 struct TxDesc *txd = tp->TxDescRing + entry;
 583                 struct sk_buff *skb;
 584
 585                 if (le32_to_cpu(txd->status) & OWNbit)
 586                         break;
 587
 588                 skb = tp->Tx_skbuff[entry];
 589
 590                 tp->stats.tx_packets++;
 591                 tp->stats.tx_bytes += skb->len;
 592
 593                 sis190_unmap_tx_skb(tp->pci_dev, skb, txd);
 594                 tp->Tx_skbuff[entry] = NULL;
 595                 dev_kfree_skb_irq(skb);
 596         }
 597
 598         if (tp->dirty_tx != dirty_tx) {
 599                 tp->dirty_tx = dirty_tx;
 600                 smp_wmb();
 601                 if (queue_stopped)
 602                         netif_wake_queue(dev);
 603         }
 604 }
 605
 606 /*
 607  * The interrupt handler does all of the Rx thread work and cleans up after
 608  * the Tx thread.
 609  */
 610 static irqreturn_t sis190_interrupt(int irq, void *__dev, struct pt_regs *regs)
 611 {
 612         struct net_device *dev = __dev;
 613         struct sis190_private *tp = netdev_priv(dev);
 614         void __iomem *ioaddr = tp->mmio_addr;
 615         unsigned int handled = 0;
 616         u32 status;
 617
 618         status = SIS_R32(IntrStatus);
 619
 620         if ((status == 0xffffffff) || !status)
 621                 goto out;
 622
 623         handled = 1;
 624
 625         if (unlikely(!netif_running(dev))) {
 626                 sis190_asic_down(ioaddr);
 627                 goto out;
 628         }
 629
 630         SIS_W32(IntrStatus, status);
 631
 632         // net_intr(tp, KERN_INFO "%s: status = %08x.\n", dev->name, status);
 633
 634         if (status & LinkChange) {
 635                 net_intr(tp, KERN_INFO "%s: link change.\n", dev->name);
 636                 schedule_work(&tp->phy_task);
 637         }
 638
 639         if (status & RxQInt)
 640                 sis190_rx_interrupt(dev, tp, ioaddr);
 641
 642         if (status & TxQ0Int)
 643                 sis190_tx_interrupt(dev, tp, ioaddr);
 644 out:
 645         return IRQ_RETVAL(handled);
 646 }
 647
 648 #ifdef CONFIG_NET_POLL_CONTROLLER
 649 static void sis190_netpoll(struct net_device *dev)
 650 {
 651         struct sis190_private *tp = netdev_priv(dev);
 652         struct pci_dev *pdev = tp->pci_dev;
 653
 654         disable_irq(pdev->irq);
 655         sis190_interrupt(pdev->irq, dev, NULL);
 656         enable_irq(pdev->irq);
 657 }
 658 #endif
 659
 660 static void sis190_free_rx_skb(struct sis190_private *tp,
 661                                struct sk_buff **sk_buff, struct RxDesc *desc)
 662 {
 663         struct pci_dev *pdev = tp->pci_dev;
 664
 665         pci_unmap_single(pdev, le32_to_cpu(desc->addr), tp->rx_buf_sz,
 666                          PCI_DMA_FROMDEVICE);
 667         dev_kfree_skb(*sk_buff);
 668         *sk_buff = NULL;
 669         sis190_make_unusable_by_asic(desc);
 670 }
 671
 672 static void sis190_rx_clear(struct sis190_private *tp)
 673 {
 674         unsigned int i;
 675
 676         for (i = 0; i < NUM_RX_DESC; i++) {
 677                 if (!tp->Rx_skbuff[i])
 678                         continue;
 679                 sis190_free_rx_skb(tp, tp->Rx_skbuff + i, tp->RxDescRing + i);
 680         }
 681 }
 682
 683 static void sis190_init_ring_indexes(struct sis190_private *tp)
 684 {
 685         tp->dirty_tx = tp->dirty_rx = tp->cur_tx = tp->cur_rx = 0;
 686 }
 687
 688 static int sis190_init_ring(struct net_device *dev)
 689 {
 690         struct sis190_private *tp = netdev_priv(dev);
 691
 692         sis190_init_ring_indexes(tp);
 693
 694         memset(tp->Tx_skbuff, 0x0, NUM_TX_DESC * sizeof(struct sk_buff *));
 695         memset(tp->Rx_skbuff, 0x0, NUM_RX_DESC * sizeof(struct sk_buff *));
 696
 697         if (sis190_rx_fill(tp, dev, 0, NUM_RX_DESC) != NUM_RX_DESC)
 698                 goto err_rx_clear;
 699
 700         sis190_mark_as_last_descriptor(tp->RxDescRing + NUM_RX_DESC - 1);
 701
 702         return 0;
 703
 704 err_rx_clear:
 705         sis190_rx_clear(tp);
 706         return -ENOMEM;
 707 }
 708
 709 static void sis190_set_rx_mode(struct net_device *dev)
 710 {
 711         struct sis190_private *tp = netdev_priv(dev);
 712         void __iomem *ioaddr = tp->mmio_addr;
 713         unsigned long flags;
 714         u32 mc_filter[2];       /* Multicast hash filter */
 715         u16 rx_mode;
 716
 717         if (dev->flags & IFF_PROMISC) {
 718                 /* Unconditionally log net taps. */
 719                 net_drv(tp, KERN_NOTICE "%s: Promiscuous mode enabled.\n",
 720                         dev->name);
 721                 rx_mode =
 722                         AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
 723                         AcceptAllPhys;
 724                 mc_filter[1] = mc_filter[0] = 0xffffffff;
 725         } else if ((dev->mc_count > multicast_filter_limit) ||
 726                    (dev->flags & IFF_ALLMULTI)) {
 727                 /* Too many to filter perfectly -- accept all multicasts. */
 728                 rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
 729                 mc_filter[1] = mc_filter[0] = 0xffffffff;
 730         } else {
 731                 struct dev_mc_list *mclist;
 732                 unsigned int i;
 733
 734                 rx_mode = AcceptBroadcast | AcceptMyPhys;
 735                 mc_filter[1] = mc_filter[0] = 0;
 736                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
 737                      i++, mclist = mclist->next) {
 738                         int bit_nr =
 739                                 ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
 740                         mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
 741                         rx_mode |= AcceptMulticast;
 742                 }
 743         }
 744
 745         spin_lock_irqsave(&tp->lock, flags);
 746
 747         SIS_W16(RxMacControl, rx_mode | 0x2);
 748         SIS_W32(RxHashTable, mc_filter[0]);
 749         SIS_W32(RxHashTable + 4, mc_filter[1]);
 750
 751         spin_unlock_irqrestore(&tp->lock, flags);
 752 }
 753
 754 static void sis190_soft_reset(void __iomem *ioaddr)
 755 {
 756         SIS_W32(IntrControl, 0x8000);
 757         SIS_PCI_COMMIT();
 758         msleep(1);
 759         SIS_W32(IntrControl, 0x0);
 760         sis190_asic_down(ioaddr);
 761         msleep(1);
 762 }
 763
 764 static void sis190_hw_start(struct net_device *dev)
 765 {
 766         struct sis190_private *tp = netdev_priv(dev);
 767         void __iomem *ioaddr = tp->mmio_addr;
 768
 769         sis190_soft_reset(ioaddr);
 770
 771         SIS_W32(TxDescStartAddr, tp->tx_dma);
 772         SIS_W32(RxDescStartAddr, tp->rx_dma);
 773
 774         SIS_W32(IntrStatus, 0xffffffff);
 775         SIS_W32(IntrMask, 0x0);
 776         /*
 777          * Default is 100Mbps.
 778          * A bit strange: 100Mbps is 0x1801 elsewhere -- FR 2005/06/09
 779          */
 780         SIS_W16(StationControl, 0x1901);
 781         SIS_W32(GMIIControl, 0x0);
 782         SIS_W32(TxMacControl, 0x60);
 783         SIS_W16(RxMacControl, 0x02);
 784         SIS_W32(RxHashTable, 0x0);
 785         SIS_W32(0x6c, 0x0);
 786         SIS_W32(RxWakeOnLan, 0x0);
 787         SIS_W32(0x74, 0x0);
 788
 789         SIS_PCI_COMMIT();
 790
 791         sis190_set_rx_mode(dev);
 792
 793         /* Enable all known interrupts by setting the interrupt mask. */
 794         SIS_W32(IntrMask, sis190_intr_mask);
 795
 796         SIS_W32(TxControl, 0x1a00 | CmdTxEnb);
 797         SIS_W32(RxControl, 0x1a1d);
 798
 799         netif_start_queue(dev);
 800 }
 801
 802 static void sis190_phy_task(void * data)
 803 {
 804         struct net_device *dev = data;
 805         struct sis190_private *tp = netdev_priv(dev);
 806         void __iomem *ioaddr = tp->mmio_addr;
 807         u16 val;
 808
 809         rtnl_lock();
 810
 811         val = mdio_read(ioaddr, MII_BMCR);
 812         if (val & BMCR_RESET) {
 813                 // FIXME: needlessly high ?  -- FR 02/07/2005
 814                 mod_timer(&tp->timer, jiffies + HZ/10);
 815         } else if (!(mdio_read(ioaddr, MII_BMSR) & BMSR_ANEGCOMPLETE)) {
 816                 net_link(tp, KERN_WARNING "%s: PHY reset until link up.\n",
 817                          dev->name);
 818                 mdio_write(ioaddr, MII_BMCR, val | BMCR_RESET);
 819                 mod_timer(&tp->timer, jiffies + SIS190_PHY_TIMEOUT);
 820         } else {
 821                 /* Rejoice ! */
 822                 struct {
 823                         int val;
 824                         const char *msg;
 825                         u16 ctl;
 826                 } reg31[] = {
 827                         { LPA_1000XFULL | LPA_SLCT,
 828                                 "1000 Mbps Full Duplex",
 829                                 0x01 | _1000bpsF },
 830                         { LPA_1000XHALF | LPA_SLCT,
 831                                 "1000 Mbps Half Duplex",
 832                                 0x01 | _1000bpsH },
 833                         { LPA_100FULL,
 834                                 "100 Mbps Full Duplex",
 835                                 0x01 | _100bpsF },
 836                         { LPA_100HALF,
 837                                 "100 Mbps Half Duplex",
 838                                 0x01 | _100bpsH },
 839                         { LPA_10FULL,
 840                                 "10 Mbps Full Duplex",
 841                                 0x01 | _10bpsF },
 842                         { LPA_10HALF,
 843                                 "10 Mbps Half Duplex",
 844                                 0x01 | _10bpsH },
 845                         { 0, "unknown", 0x0000 }
 846                 }, *p;
 847
 848                 val = mdio_read(ioaddr, 0x1f);
 849                 net_link(tp, KERN_INFO "%s: mii ext = %04x.\n", dev->name, val);
 850
 851                 val = mdio_read(ioaddr, MII_LPA);
 852                 net_link(tp, KERN_INFO "%s: mii lpa = %04x.\n", dev->name, val);
 853
 854                 for (p = reg31; p->ctl; p++) {
 855                         if ((val & p->val) == p->val)
 856                                 break;
 857                 }
 858                 if (p->ctl)
 859                         SIS_W16(StationControl, p->ctl);
 860                 net_link(tp, KERN_INFO "%s: link on %s mode.\n", dev->name,
 861                          p->msg);
 862                 netif_carrier_on(dev);
 863         }
 864
 865         rtnl_unlock();
 866 }
 867
 868 static void sis190_phy_timer(unsigned long __opaque)
 869 {
 870         struct net_device *dev = (struct net_device *)__opaque;
 871         struct sis190_private *tp = netdev_priv(dev);
 872
 873         if (likely(netif_running(dev)))
 874                 schedule_work(&tp->phy_task);
 875 }
 876
 877 static inline void sis190_delete_timer(struct net_device *dev)
 878 {
 879         struct sis190_private *tp = netdev_priv(dev);
 880
 881         del_timer_sync(&tp->timer);
 882 }
 883
 884 static inline void sis190_request_timer(struct net_device *dev)
 885 {
 886         struct sis190_private *tp = netdev_priv(dev);
 887         struct timer_list *timer = &tp->timer;
 888
 889         init_timer(timer);
 890         timer->expires = jiffies + SIS190_PHY_TIMEOUT;
 891         timer->data = (unsigned long)dev;
 892         timer->function = sis190_phy_timer;
 893         add_timer(timer);
 894 }
 895
 896 static void sis190_set_rxbufsize(struct sis190_private *tp,
 897                                  struct net_device *dev)
 898 {
 899         unsigned int mtu = dev->mtu;
 900
 901         tp->rx_buf_sz = (mtu > RX_BUF_SIZE) ? mtu + ETH_HLEN + 8 : RX_BUF_SIZE;
 902 }
 903
 904 static int sis190_open(struct net_device *dev)
 905 {
 906         struct sis190_private *tp = netdev_priv(dev);
 907         struct pci_dev *pdev = tp->pci_dev;
 908         int rc = -ENOMEM;
 909
 910         sis190_set_rxbufsize(tp, dev);
 911
 912         /*
 913          * Rx and Tx descriptors need 256 bytes alignment.
 914          * pci_alloc_consistent() guarantees a stronger alignment.
 915          */
 916         tp->TxDescRing = pci_alloc_consistent(pdev, TX_RING_BYTES, &tp->tx_dma);
 917         if (!tp->TxDescRing)
 918                 goto out;
 919
 920         tp->RxDescRing = pci_alloc_consistent(pdev, RX_RING_BYTES, &tp->rx_dma);
 921         if (!tp->RxDescRing)
 922                 goto err_free_tx_0;
 923
 924         rc = sis190_init_ring(dev);
 925         if (rc < 0)
 926                 goto err_free_rx_1;
 927
 928         INIT_WORK(&tp->phy_task, sis190_phy_task, dev);
 929
 930         sis190_request_timer(dev);
 931
 932         rc = request_irq(dev->irq, sis190_interrupt, SA_SHIRQ, dev->name, dev);
 933         if (rc < 0)
 934                 goto err_release_timer_2;
 935
 936         sis190_hw_start(dev);
 937 out:
 938         return rc;
 939
 940 err_release_timer_2:
 941         sis190_delete_timer(dev);
 942         sis190_rx_clear(tp);
 943 err_free_rx_1:
 944         pci_free_consistent(tp->pci_dev, RX_RING_BYTES, tp->RxDescRing,
 945                 tp->rx_dma);
 946 err_free_tx_0:
 947         pci_free_consistent(tp->pci_dev, TX_RING_BYTES, tp->TxDescRing,
 948                 tp->tx_dma);
 949         goto out;
 950 }
 951
 952 static void sis190_tx_clear(struct sis190_private *tp)
 953 {
 954         unsigned int i;
 955
 956         for (i = 0; i < NUM_TX_DESC; i++) {
 957                 struct sk_buff *skb = tp->Tx_skbuff[i];
 958
 959                 if (!skb)
 960                         continue;
 961
 962                 sis190_unmap_tx_skb(tp->pci_dev, skb, tp->TxDescRing + i);
 963                 tp->Tx_skbuff[i] = NULL;
 964                 dev_kfree_skb(skb);
 965
 966                 tp->stats.tx_dropped++;
 967         }
 968         tp->cur_tx = tp->dirty_tx = 0;
 969 }
 970
 971 static void sis190_down(struct net_device *dev)
 972 {
 973         struct sis190_private *tp = netdev_priv(dev);
 974         void __iomem *ioaddr = tp->mmio_addr;
 975         unsigned int poll_locked = 0;
 976
 977         sis190_delete_timer(dev);
 978
 979         netif_stop_queue(dev);
 980
 981         flush_scheduled_work();
 982
 983         do {
 984                 spin_lock_irq(&tp->lock);
 985
 986                 sis190_asic_down(ioaddr);
 987
 988                 spin_unlock_irq(&tp->lock);
 989
 990                 synchronize_irq(dev->irq);
 991
 992                 if (!poll_locked) {
 993                         netif_poll_disable(dev);
 994                         poll_locked++;
 995                 }
 996
 997                 synchronize_sched();
 998
 999         } while (SIS_R32(IntrMask));
1000
1001         sis190_tx_clear(tp);
1002         sis190_rx_clear(tp);
1003 }
1004
1005 static int sis190_close(struct net_device *dev)
1006 {
1007         struct sis190_private *tp = netdev_priv(dev);
1008         struct pci_dev *pdev = tp->pci_dev;
1009
1010         sis190_down(dev);
1011
1012         free_irq(dev->irq, dev);
1013
1014         netif_poll_enable(dev);
1015
1016         pci_free_consistent(pdev, TX_RING_BYTES, tp->TxDescRing, tp->tx_dma);
1017         pci_free_consistent(pdev, RX_RING_BYTES, tp->RxDescRing, tp->rx_dma);
1018
1019         tp->TxDescRing = NULL;
1020         tp->RxDescRing = NULL;
1021
1022         return 0;
1023 }
1024
1025 static int sis190_start_xmit(struct sk_buff *skb, struct net_device *dev)
1026 {
1027         struct sis190_private *tp = netdev_priv(dev);
1028         void __iomem *ioaddr = tp->mmio_addr;
1029         u32 len, entry, dirty_tx;
1030         struct TxDesc *desc;
1031         dma_addr_t mapping;
1032
1033         if (unlikely(skb->len < ETH_ZLEN)) {
1034                 skb = skb_padto(skb, ETH_ZLEN);
1035                 if (!skb) {
1036                         tp->stats.tx_dropped++;
1037                         goto out;
1038                 }
1039                 len = ETH_ZLEN;
1040         } else {
1041                 len = skb->len;
1042         }
1043
1044         entry = tp->cur_tx % NUM_TX_DESC;
1045         desc = tp->TxDescRing + entry;
1046
1047         if (unlikely(le32_to_cpu(desc->status) & OWNbit)) {
1048                 netif_stop_queue(dev);
1049                 net_tx_err(tp, KERN_ERR PFX
1050                            "%s: BUG! Tx Ring full when queue awake!\n",
1051                            dev->name);
1052                 return NETDEV_TX_BUSY;
1053         }
1054
1055         mapping = pci_map_single(tp->pci_dev, skb->data, len, PCI_DMA_TODEVICE);
1056
1057         tp->Tx_skbuff[entry] = skb;
1058
1059         desc->PSize = cpu_to_le32(len);
1060         desc->addr = cpu_to_le32(mapping);
1061
1062         desc->size = cpu_to_le32(len);
1063         if (entry == (NUM_TX_DESC - 1))
1064                 desc->size |= cpu_to_le32(RingEnd);
1065
1066         wmb();
1067
1068         desc->status = cpu_to_le32(OWNbit | INTbit | DEFbit | CRCbit | PADbit);
1069
1070         tp->cur_tx++;
1071
1072         smp_wmb();
1073
1074         SIS_W32(TxControl, 0x1a00 | CmdReset | CmdTxEnb);
1075
1076         dev->trans_start = jiffies;
1077
1078         dirty_tx = tp->dirty_tx;
1079         if ((tp->cur_tx - NUM_TX_DESC) == dirty_tx) {
1080                 netif_stop_queue(dev);
1081                 smp_rmb();
1082                 if (dirty_tx != tp->dirty_tx)
1083                         netif_wake_queue(dev);
1084         }
1085 out:
1086         return NETDEV_TX_OK;
1087 }
1088
1089 static struct net_device_stats *sis190_get_stats(struct net_device *dev)
1090 {
1091         struct sis190_private *tp = netdev_priv(dev);
1092
1093         return &tp->stats;
1094 }
1095
1096 static void sis190_release_board(struct pci_dev *pdev)
1097 {
1098         struct net_device *dev = pci_get_drvdata(pdev);
1099         struct sis190_private *tp = netdev_priv(dev);
1100
1101         iounmap(tp->mmio_addr);
1102         pci_release_regions(pdev);
1103         pci_disable_device(pdev);
1104         free_netdev(dev);
1105 }
1106
1107 static struct net_device * __devinit sis190_init_board(struct pci_dev *pdev)
1108 {
1109         struct sis190_private *tp;
1110         struct net_device *dev;
1111         void __iomem *ioaddr;
1112         int rc;
1113
1114         dev = alloc_etherdev(sizeof(*tp));
1115         if (!dev) {
1116                 net_drv(&debug, KERN_ERR PFX "unable to alloc new ethernet\n");
1117                 rc = -ENOMEM;
1118                 goto err_out_0;
1119         }
1120
1121         SET_MODULE_OWNER(dev);
1122         SET_NETDEV_DEV(dev, &pdev->dev);
1123
1124         tp = netdev_priv(dev);
1125         tp->msg_enable = netif_msg_init(debug.msg_enable, SIS190_MSG_DEFAULT);
1126
1127         rc = pci_enable_device(pdev);
1128         if (rc < 0) {
1129                 net_probe(tp, KERN_ERR "%s: enable failure\n", pci_name(pdev));
1130                 goto err_free_dev_1;
1131         }
1132
1133         rc = -ENODEV;
1134
1135         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
1136                 net_probe(tp, KERN_ERR "%s: region #0 is no MMIO resource.\n",
1137                           pci_name(pdev));
1138                 goto err_pci_disable_2;
1139         }
1140         if (pci_resource_len(pdev, 0) < SIS190_REGS_SIZE) {
1141                 net_probe(tp, KERN_ERR "%s: invalid PCI region size(s).\n",
1142                           pci_name(pdev));
1143                 goto err_pci_disable_2;
1144         }
1145
1146         rc = pci_request_regions(pdev, DRV_NAME);
1147         if (rc < 0) {
1148                 net_probe(tp, KERN_ERR PFX "%s: could not request regions.\n",
1149                           pci_name(pdev));
1150                 goto err_pci_disable_2;
1151         }
1152
1153         rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
1154         if (rc < 0) {
1155                 net_probe(tp, KERN_ERR "%s: DMA configuration failed.\n",
1156                           pci_name(pdev));
1157                 goto err_free_res_3;
1158         }
1159
1160         pci_set_master(pdev);
1161
1162         ioaddr = ioremap(pci_resource_start(pdev, 0), SIS190_REGS_SIZE);
1163         if (!ioaddr) {
1164                 net_probe(tp, KERN_ERR "%s: cannot remap MMIO, aborting\n",
1165                           pci_name(pdev));
1166                 rc = -EIO;
1167                 goto err_free_res_3;
1168         }
1169
1170         tp->pci_dev = pdev;
1171         tp->mmio_addr = ioaddr;
1172
1173         tp->mii_if.dev = dev;
1174         tp->mii_if.mdio_read = __mdio_read;
1175         tp->mii_if.mdio_write = __mdio_write;
1176         // tp->mii_if.phy_id = XXX;
1177         tp->mii_if.phy_id_mask = 0x1f;
1178         tp->mii_if.reg_num_mask = 0x1f;
1179
1180         sis190_irq_mask_and_ack(ioaddr);
1181
1182         sis190_soft_reset(ioaddr);
1183 out:
1184         return dev;
1185
1186 err_free_res_3:
1187         pci_release_regions(pdev);
1188 err_pci_disable_2:
1189         pci_disable_device(pdev);
1190 err_free_dev_1:
1191         free_netdev(dev);
1192 err_out_0:
1193         dev = ERR_PTR(rc);
1194         goto out;
1195 }
1196
1197 static void sis190_tx_timeout(struct net_device *dev)
1198 {
1199         struct sis190_private *tp = netdev_priv(dev);
1200         void __iomem *ioaddr = tp->mmio_addr;
1201         u8 tmp8;
1202
1203         /* Disable Tx, if not already */
1204         tmp8 = SIS_R8(TxControl);
1205         if (tmp8 & CmdTxEnb)
1206                 SIS_W8(TxControl, tmp8 & ~CmdTxEnb);
1207
1208         /* Disable interrupts by clearing the interrupt mask. */
1209         SIS_W32(IntrMask, 0x0000);
1210
1211         /* Stop a shared interrupt from scavenging while we are. */
1212         spin_lock_irq(&tp->lock);
1213         sis190_tx_clear(tp);
1214         spin_unlock_irq(&tp->lock);
1215
1216         /* ...and finally, reset everything. */
1217         sis190_hw_start(dev);
1218
1219         netif_wake_queue(dev);
1220 }
1221
1222 static void sis190_set_speed_auto(struct net_device *dev)
1223 {
1224         struct sis190_private *tp = netdev_priv(dev);
1225         void __iomem *ioaddr = tp->mmio_addr;
1226         int val;
1227
1228         net_link(tp, KERN_INFO "%s: Enabling Auto-negotiation.\n", dev->name);
1229
1230         val = mdio_read(ioaddr, MII_ADVERTISE);
1231
1232         // Enable 10/100 Full/Half Mode, leave MII_ADVERTISE bit4:0
1233         // unchanged.
1234         mdio_write(ioaddr, MII_ADVERTISE, (val & ADVERTISE_SLCT) |
1235                    ADVERTISE_100FULL | ADVERTISE_10FULL |
1236                    ADVERTISE_100HALF | ADVERTISE_10HALF);
1237
1238         // Enable 1000 Full Mode.
1239         mdio_write(ioaddr, MII_CTRL1000, ADVERTISE_1000FULL);
1240
1241         // Enable auto-negotiation and restart auto-negotiation.
1242         mdio_write(ioaddr, MII_BMCR,
1243                    BMCR_ANENABLE | BMCR_ANRESTART | BMCR_RESET);
1244 }
1245
1246 static int sis190_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1247 {
1248         struct sis190_private *tp = netdev_priv(dev);
1249
1250         return mii_ethtool_gset(&tp->mii_if, cmd);
1251 }
1252
1253 static int sis190_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1254 {
1255         struct sis190_private *tp = netdev_priv(dev);
1256
1257         return mii_ethtool_sset(&tp->mii_if, cmd);
1258 }
1259
1260 static void sis190_get_drvinfo(struct net_device *dev,
1261                                struct ethtool_drvinfo *info)
1262 {
1263         struct sis190_private *tp = netdev_priv(dev);
1264
1265         strcpy(info->driver, DRV_NAME);
1266         strcpy(info->version, DRV_VERSION);
1267         strcpy(info->bus_info, pci_name(tp->pci_dev));
1268 }
1269
1270 static int sis190_get_regs_len(struct net_device *dev)
1271 {
1272         return SIS190_REGS_SIZE;
1273 }
1274
1275 static void sis190_get_regs(struct net_device *dev, struct ethtool_regs *regs,
1276                             void *p)
1277 {
1278         struct sis190_private *tp = netdev_priv(dev);
1279         unsigned long flags;
1280
1281         if (regs->len > SIS190_REGS_SIZE)
1282                 regs->len = SIS190_REGS_SIZE;
1283
1284         spin_lock_irqsave(&tp->lock, flags);
1285         memcpy_fromio(p, tp->mmio_addr, regs->len);
1286         spin_unlock_irqrestore(&tp->lock, flags);
1287 }
1288
1289 static int sis190_nway_reset(struct net_device *dev)
1290 {
1291         struct sis190_private *tp = netdev_priv(dev);
1292
1293         return mii_nway_restart(&tp->mii_if);
1294 }
1295
1296 static u32 sis190_get_msglevel(struct net_device *dev)
1297 {
1298         struct sis190_private *tp = netdev_priv(dev);
1299
1300         return tp->msg_enable;
1301 }
1302
1303 static void sis190_set_msglevel(struct net_device *dev, u32 value)
1304 {
1305         struct sis190_private *tp = netdev_priv(dev);
1306
1307         tp->msg_enable = value;
1308 }
1309
1310 static struct ethtool_ops sis190_ethtool_ops = {
1311         .get_settings   = sis190_get_settings,
1312         .set_settings   = sis190_set_settings,
1313         .get_drvinfo    = sis190_get_drvinfo,
1314         .get_regs_len   = sis190_get_regs_len,
1315         .get_regs       = sis190_get_regs,
1316         .get_link       = ethtool_op_get_link,
1317         .get_msglevel   = sis190_get_msglevel,
1318         .set_msglevel   = sis190_set_msglevel,
1319         .nway_reset     = sis190_nway_reset,
1320 };
1321
1322 static int sis190_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1323 {
1324         struct sis190_private *tp = netdev_priv(dev);
1325
1326         return !netif_running(dev) ? -EINVAL :
1327                 generic_mii_ioctl(&tp->mii_if, if_mii(ifr), cmd, NULL);
1328 }
1329
1330 static int __devinit sis190_init_one(struct pci_dev *pdev,
1331                                      const struct pci_device_id *ent)
1332 {
1333         static int printed_version = 0;
1334         struct sis190_private *tp;
1335         struct net_device *dev;
1336         void __iomem *ioaddr;
1337         int i, rc;
1338
1339         if (!printed_version) {
1340                 net_drv(&debug, KERN_INFO SIS190_DRIVER_NAME " loaded.\n");
1341                 printed_version = 1;
1342         }
1343
1344         dev = sis190_init_board(pdev);
1345         if (IS_ERR(dev)) {
1346                 rc = PTR_ERR(dev);
1347                 goto out;
1348         }
1349
1350         tp = netdev_priv(dev);
1351         ioaddr = tp->mmio_addr;
1352
1353         /* Get MAC address */
1354         /* Read node address from the EEPROM */
1355
1356         if (SIS_R32(ROMControl) & 0x4) {
1357                 for (i = 0; i < 3; i++) {
1358                         SIS_W16(RxMacAddr + 2*i,
1359                                 sis190_read_eeprom(ioaddr, 3 + i));
1360                 }
1361         }
1362
1363         for (i = 0; i < MAC_ADDR_LEN; i++)
1364                 dev->dev_addr[i] = SIS_R8(RxMacAddr + i);
1365
1366         INIT_WORK(&tp->phy_task, sis190_phy_task, dev);
1367
1368         dev->open = sis190_open;
1369         dev->stop = sis190_close;
1370         dev->do_ioctl = sis190_ioctl;
1371         dev->get_stats = sis190_get_stats;
1372         dev->tx_timeout = sis190_tx_timeout;
1373         dev->watchdog_timeo = SIS190_TX_TIMEOUT;
1374         dev->hard_start_xmit = sis190_start_xmit;
1375 #ifdef CONFIG_NET_POLL_CONTROLLER
1376         dev->poll_controller = sis190_netpoll;
1377 #endif
1378         dev->set_multicast_list = sis190_set_rx_mode;
1379         SET_ETHTOOL_OPS(dev, &sis190_ethtool_ops);
1380         dev->irq = pdev->irq;
1381         dev->base_addr = (unsigned long) 0xdead;
1382
1383         spin_lock_init(&tp->lock);
1384         rc = register_netdev(dev);
1385         if (rc < 0) {
1386                 sis190_release_board(pdev);
1387                 goto out;
1388         }
1389
1390         pci_set_drvdata(pdev, dev);
1391
1392         net_probe(tp, KERN_INFO "%s: %s at %p (IRQ: %d), "
1393                "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x\n",
1394                pci_name(pdev), sis_chip_info[ent->driver_data].name,
1395                ioaddr, dev->irq,
1396                dev->dev_addr[0], dev->dev_addr[1],
1397                dev->dev_addr[2], dev->dev_addr[3],
1398                dev->dev_addr[4], dev->dev_addr[5]);
1399
1400         netif_carrier_off(dev);
1401
1402         sis190_set_speed_auto(dev);
1403 out:
1404         return rc;
1405 }
1406
1407 static void __devexit sis190_remove_one(struct pci_dev *pdev)
1408 {
1409         struct net_device *dev = pci_get_drvdata(pdev);
1410
1411         unregister_netdev(dev);
1412         sis190_release_board(pdev);
1413         pci_set_drvdata(pdev, NULL);
1414 }
1415
1416 static struct pci_driver sis190_pci_driver = {
1417         .name           = DRV_NAME,
1418         .id_table       = sis190_pci_tbl,
1419         .probe          = sis190_init_one,
1420         .remove         = __devexit_p(sis190_remove_one),
1421 };
1422
1423 static int __init sis190_init_module(void)
1424 {
1425         return pci_module_init(&sis190_pci_driver);
1426 }
1427
1428 static void __exit sis190_cleanup_module(void)
1429 {
1430         pci_unregister_driver(&sis190_pci_driver);
1431 }
1432
1433 module_init(sis190_init_module);
1434 module_exit(sis190_cleanup_module);