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