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