?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / net / sis900.c
blob2dc0c1cfdca42a1be43040ec062c4ee2ffd36aee
1
2
3 #include <linux/module.h>
4 #include <linux/moduleparam.h>
5 #include <linux/kernel.h>
6 #include <linux/sched.h>
7 #include <linux/string.h>
8 #include <linux/timer.h>
9 #include <linux/errno.h>
10 #include <linux/ioport.h>
11 #include <linux/slab.h>
12 #include <linux/interrupt.h>
13 #include <linux/pci.h>
14 #include <linux/netdevice.h>
15 #include <linux/init.h>
16 #include <linux/mii.h>
17 #include <linux/etherdevice.h>
18 #include <linux/skbuff.h>
19 #include <linux/delay.h>
20 #include <linux/ethtool.h>
21 #include <linux/crc32.h>
22 #include <linux/bitops.h>
23 #include <linux/dma-mapping.h>
24
25 #include <asm/processor.h> /* Processor type for cache alignment. */
26 #include <asm/io.h>
27 #include <asm/irq.h>
28 #include <asm/uaccess.h> /* User space memory access functions */
29
30 #include "sis900.h"
31
32 #define SIS900_MODULE_NAME "sis900"
33 #define SIS900_DRV_VERSION "v1.08.10 Apr. 2 2006"
34
35 static const char version[] __devinitconst =
36 KERN_INFO "sis900.c: " SIS900_DRV_VERSION "\n";
37
38 static int max_interrupt_work = 40;
39 static int multicast_filter_limit = 128;
40
41 static int sis900_debug = -1; /* Use SIS900_DEF_MSG as value */
42
43 #define SIS900_DEF_MSG \
44 (NETIF_MSG_DRV | \
45 NETIF_MSG_LINK | \
46 NETIF_MSG_RX_ERR | \
47 NETIF_MSG_TX_ERR)
48
49 /* Time in jiffies before concluding the transmitter is hung. */
50 #define TX_TIMEOUT (4*HZ)
51
52 enum {
53 SIS_900 = 0,
54 SIS_7016
55 };
56 static const char * card_names[] = {
57 "SiS 900 PCI Fast Ethernet",
58 "SiS 7016 PCI Fast Ethernet"
59 };
60 static DEFINE_PCI_DEVICE_TABLE(sis900_pci_tbl) = {
61 {PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_900,
62 PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_900},
63 {PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_7016,
64 PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_7016},
65 {0,}
66 };
67 MODULE_DEVICE_TABLE (pci, sis900_pci_tbl);
68
69 static void sis900_read_mode(struct net_device *net_dev, int *speed, int *duplex);
70
71 static const struct mii_chip_info {
72 const char * name;
73 u16 phy_id0;
74 u16 phy_id1;
75 u8 phy_types;
76 #define HOME 0x0001
77 #define LAN 0x0002
78 #define MIX 0x0003
79 #define UNKNOWN 0x0
80 } mii_chip_table[] = {
81 { "SiS 900 Internal MII PHY", 0x001d, 0x8000, LAN },
82 { "SiS 7014 Physical Layer Solution", 0x0016, 0xf830, LAN },
83 { "SiS 900 on Foxconn 661 7MI", 0x0143, 0xBC70, LAN },
84 { "Altimata AC101LF PHY", 0x0022, 0x5520, LAN },
85 { "ADM 7001 LAN PHY", 0x002e, 0xcc60, LAN },
86 { "AMD 79C901 10BASE-T PHY", 0x0000, 0x6B70, LAN },
87 { "AMD 79C901 HomePNA PHY", 0x0000, 0x6B90, HOME},
88 { "ICS LAN PHY", 0x0015, 0xF440, LAN },
89 { "ICS LAN PHY", 0x0143, 0xBC70, LAN },
90 { "NS 83851 PHY", 0x2000, 0x5C20, MIX },
91 { "NS 83847 PHY", 0x2000, 0x5C30, MIX },
92 { "Realtek RTL8201 PHY", 0x0000, 0x8200, LAN },
93 { "VIA 6103 PHY", 0x0101, 0x8f20, LAN },
94 {NULL,},
95 };
96
97 struct mii_phy {
98 struct mii_phy * next;
99 int phy_addr;
100 u16 phy_id0;
101 u16 phy_id1;
102 u16 status;
103 u8 phy_types;
104 };
105
106 typedef struct _BufferDesc {
107 u32 link;
108 u32 cmdsts;
109 u32 bufptr;
110 } BufferDesc;
111
112 struct sis900_private {
113 struct pci_dev * pci_dev;
114
115 spinlock_t lock;
116
117 struct mii_phy * mii;
118 struct mii_phy * first_mii; /* record the first mii structure */
119 unsigned int cur_phy;
120 struct mii_if_info mii_info;
121
122 struct timer_list timer; /* Link status detection timer. */
123 u8 autong_complete; /* 1: auto-negotiate complete */
124
125 u32 msg_enable;
126
127 unsigned int cur_rx, dirty_rx; /* producer/comsumer pointers for Tx/Rx ring */
128 unsigned int cur_tx, dirty_tx;
129
130 /* The saved address of a sent/receive-in-place packet buffer */
131 struct sk_buff *tx_skbuff[NUM_TX_DESC];
132 struct sk_buff *rx_skbuff[NUM_RX_DESC];
133 BufferDesc *tx_ring;
134 BufferDesc *rx_ring;
135
136 dma_addr_t tx_ring_dma;
137 dma_addr_t rx_ring_dma;
138
139 unsigned int tx_full; /* The Tx queue is full. */
140 u8 host_bridge_rev;
141 u8 chipset_rev;
142 };
143
144 MODULE_AUTHOR("Jim Huang <cmhuang@sis.com.tw>, Ollie Lho <ollie@sis.com.tw>");
145 MODULE_DESCRIPTION("SiS 900 PCI Fast Ethernet driver");
146 MODULE_LICENSE("GPL");
147
148 module_param(multicast_filter_limit, int, 0444);
149 module_param(max_interrupt_work, int, 0444);
150 module_param(sis900_debug, int, 0444);
151 MODULE_PARM_DESC(multicast_filter_limit, "SiS 900/7016 maximum number of filtered multicast addresses");
152 MODULE_PARM_DESC(max_interrupt_work, "SiS 900/7016 maximum events handled per interrupt");
153 MODULE_PARM_DESC(sis900_debug, "SiS 900/7016 bitmapped debugging message level");
154
155 #ifdef CONFIG_NET_POLL_CONTROLLER
156 static void sis900_poll(struct net_device *dev);
157 #endif
158 static int sis900_open(struct net_device *net_dev);
159 static int sis900_mii_probe (struct net_device * net_dev);
160 static void sis900_init_rxfilter (struct net_device * net_dev);
161 static u16 read_eeprom(long ioaddr, int location);
162 static int mdio_read(struct net_device *net_dev, int phy_id, int location);
163 static void mdio_write(struct net_device *net_dev, int phy_id, int location, int val);
164 static void sis900_timer(unsigned long data);
165 static void sis900_check_mode (struct net_device *net_dev, struct mii_phy *mii_phy);
166 static void sis900_tx_timeout(struct net_device *net_dev);
167 static void sis900_init_tx_ring(struct net_device *net_dev);
168 static void sis900_init_rx_ring(struct net_device *net_dev);
169 static netdev_tx_t sis900_start_xmit(struct sk_buff *skb,
170 struct net_device *net_dev);
171 static int sis900_rx(struct net_device *net_dev);
172 static void sis900_finish_xmit (struct net_device *net_dev);
173 static irqreturn_t sis900_interrupt(int irq, void *dev_instance);
174 static int sis900_close(struct net_device *net_dev);
175 static int mii_ioctl(struct net_device *net_dev, struct ifreq *rq, int cmd);
176 static u16 sis900_mcast_bitnr(u8 *addr, u8 revision);
177 static void set_rx_mode(struct net_device *net_dev);
178 static void sis900_reset(struct net_device *net_dev);
179 static void sis630_set_eq(struct net_device *net_dev, u8 revision);
180 static int sis900_set_config(struct net_device *dev, struct ifmap *map);
181 static u16 sis900_default_phy(struct net_device * net_dev);
182 static void sis900_set_capability( struct net_device *net_dev ,struct mii_phy *phy);
183 static u16 sis900_reset_phy(struct net_device *net_dev, int phy_addr);
184 static void sis900_auto_negotiate(struct net_device *net_dev, int phy_addr);
185 static void sis900_set_mode (long ioaddr, int speed, int duplex);
186 static const struct ethtool_ops sis900_ethtool_ops;
187
188 /**
189 * sis900_get_mac_addr - Get MAC address for stand alone SiS900 model
190 * @pci_dev: the sis900 pci device
191 * @net_dev: the net device to get address for
192 *
193 * Older SiS900 and friends, use EEPROM to store MAC address.
194 * MAC address is read from read_eeprom() into @net_dev->dev_addr.
195 */
196
197 static int __devinit sis900_get_mac_addr(struct pci_dev * pci_dev, struct net_device *net_dev)
198 {
199 long ioaddr = pci_resource_start(pci_dev, 0);
200 u16 signature;
201 int i;
202
203 /* check to see if we have sane EEPROM */
204 signature = (u16) read_eeprom(ioaddr, EEPROMSignature);
205 if (signature == 0xffff || signature == 0x0000) {
206 printk (KERN_WARNING "%s: Error EERPOM read %x\n",
207 pci_name(pci_dev), signature);
208 return 0;
209 }
210
211 /* get MAC address from EEPROM */
212 for (i = 0; i < 3; i++)
213 ((u16 *)(net_dev->dev_addr))[i] = read_eeprom(ioaddr, i+EEPROMMACAddr);
214
215 return 1;
216 }
217
218 /**
219 * sis630e_get_mac_addr - Get MAC address for SiS630E model
220 * @pci_dev: the sis900 pci device
221 * @net_dev: the net device to get address for
222 *
223 * SiS630E model, use APC CMOS RAM to store MAC address.
224 * APC CMOS RAM is accessed through ISA bridge.
225 * MAC address is read into @net_dev->dev_addr.
226 */
227
228 static int __devinit sis630e_get_mac_addr(struct pci_dev * pci_dev,
229 struct net_device *net_dev)
230 {
231 struct pci_dev *isa_bridge = NULL;
232 u8 reg;
233 int i;
234
235 isa_bridge = pci_get_device(PCI_VENDOR_ID_SI, 0x0008, isa_bridge);
236 if (!isa_bridge)
237 isa_bridge = pci_get_device(PCI_VENDOR_ID_SI, 0x0018, isa_bridge);
238 if (!isa_bridge) {
239 printk(KERN_WARNING "%s: Can not find ISA bridge\n",
240 pci_name(pci_dev));
241 return 0;
242 }
243 pci_read_config_byte(isa_bridge, 0x48, &reg);
244 pci_write_config_byte(isa_bridge, 0x48, reg | 0x40);
245
246 for (i = 0; i < 6; i++) {
247 outb(0x09 + i, 0x70);
248 ((u8 *)(net_dev->dev_addr))[i] = inb(0x71);
249 }
250 pci_write_config_byte(isa_bridge, 0x48, reg & ~0x40);
251 pci_dev_put(isa_bridge);
252
253 return 1;
254 }
255
256
257 /**
258 * sis635_get_mac_addr - Get MAC address for SIS635 model
259 * @pci_dev: the sis900 pci device
260 * @net_dev: the net device to get address for
261 *
262 * SiS635 model, set MAC Reload Bit to load Mac address from APC
263 * to rfdr. rfdr is accessed through rfcr. MAC address is read into
264 * @net_dev->dev_addr.
265 */
266
267 static int __devinit sis635_get_mac_addr(struct pci_dev * pci_dev,
268 struct net_device *net_dev)
269 {
270 long ioaddr = net_dev->base_addr;
271 u32 rfcrSave;
272 u32 i;
273
274 rfcrSave = inl(rfcr + ioaddr);
275
276 outl(rfcrSave | RELOAD, ioaddr + cr);
277 outl(0, ioaddr + cr);
278
279 /* disable packet filtering before setting filter */
280 outl(rfcrSave & ~RFEN, rfcr + ioaddr);
281
282 /* load MAC addr to filter data register */
283 for (i = 0 ; i < 3 ; i++) {
284 outl((i << RFADDR_shift), ioaddr + rfcr);
285 *( ((u16 *)net_dev->dev_addr) + i) = inw(ioaddr + rfdr);
286 }
287
288 /* enable packet filtering */
289 outl(rfcrSave | RFEN, rfcr + ioaddr);
290
291 return 1;
292 }
293
294 /**
295 * sis96x_get_mac_addr - Get MAC address for SiS962 or SiS963 model
296 * @pci_dev: the sis900 pci device
297 * @net_dev: the net device to get address for
298 *
299 * SiS962 or SiS963 model, use EEPROM to store MAC address. And EEPROM
300 * is shared by
301 * LAN and 1394. When access EEPROM, send EEREQ signal to hardware first
302 * and wait for EEGNT. If EEGNT is ON, EEPROM is permitted to be access
303 * by LAN, otherwise is not. After MAC address is read from EEPROM, send
304 * EEDONE signal to refuse EEPROM access by LAN.
305 * The EEPROM map of SiS962 or SiS963 is different to SiS900.
306 * The signature field in SiS962 or SiS963 spec is meaningless.
307 * MAC address is read into @net_dev->dev_addr.
308 */
309
310 static int __devinit sis96x_get_mac_addr(struct pci_dev * pci_dev,
311 struct net_device *net_dev)
312 {
313 long ioaddr = net_dev->base_addr;
314 long ee_addr = ioaddr + mear;
315 u32 waittime = 0;
316 int i;
317
318 outl(EEREQ, ee_addr);
319 while(waittime < 2000) {
320 if(inl(ee_addr) & EEGNT) {
321
322 /* get MAC address from EEPROM */
323 for (i = 0; i < 3; i++)
324 ((u16 *)(net_dev->dev_addr))[i] = read_eeprom(ioaddr, i+EEPROMMACAddr);
325
326 outl(EEDONE, ee_addr);
327 return 1;
328 } else {
329 udelay(1);
330 waittime ++;
331 }
332 }
333 outl(EEDONE, ee_addr);
334 return 0;
335 }
336
337 static const struct net_device_ops sis900_netdev_ops = {
338 .ndo_open = sis900_open,
339 .ndo_stop = sis900_close,
340 .ndo_start_xmit = sis900_start_xmit,
341 .ndo_set_config = sis900_set_config,
342 .ndo_set_multicast_list = set_rx_mode,
343 .ndo_change_mtu = eth_change_mtu,
344 .ndo_validate_addr = eth_validate_addr,
345 .ndo_set_mac_address = eth_mac_addr,
346 .ndo_do_ioctl = mii_ioctl,
347 .ndo_tx_timeout = sis900_tx_timeout,
348 #ifdef CONFIG_NET_POLL_CONTROLLER
349 .ndo_poll_controller = sis900_poll,
350 #endif
351 };
352
353 /**
354 * sis900_probe - Probe for sis900 device
355 * @pci_dev: the sis900 pci device
356 * @pci_id: the pci device ID
357 *
358 * Check and probe sis900 net device for @pci_dev.
359 * Get mac address according to the chip revision,
360 * and assign SiS900-specific entries in the device structure.
361 * ie: sis900_open(), sis900_start_xmit(), sis900_close(), etc.
362 */
363
364 static int __devinit sis900_probe(struct pci_dev *pci_dev,
365 const struct pci_device_id *pci_id)
366 {
367 struct sis900_private *sis_priv;
368 struct net_device *net_dev;
369 struct pci_dev *dev;
370 dma_addr_t ring_dma;
371 void *ring_space;
372 long ioaddr;
373 int i, ret;
374 const char *card_name = card_names[pci_id->driver_data];
375 const char *dev_name = pci_name(pci_dev);
376
377 /* when built into the kernel, we only print version if device is found */
378 #ifndef MODULE
379 static int printed_version;
380 if (!printed_version++)
381 printk(version);
382 #endif
383
384 /* setup various bits in PCI command register */
385 ret = pci_enable_device(pci_dev);
386 if(ret) return ret;
387
388 i = pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32));
389 if(i){
390 printk(KERN_ERR "sis900.c: architecture does not support "
391 "32bit PCI busmaster DMA\n");
392 return i;
393 }
394
395 pci_set_master(pci_dev);
396
397 net_dev = alloc_etherdev(sizeof(struct sis900_private));
398 if (!net_dev)
399 return -ENOMEM;
400 SET_NETDEV_DEV(net_dev, &pci_dev->dev);
401
402 /* We do a request_region() to register /proc/ioports info. */
403 ioaddr = pci_resource_start(pci_dev, 0);
404 ret = pci_request_regions(pci_dev, "sis900");
405 if (ret)
406 goto err_out;
407
408 sis_priv = netdev_priv(net_dev);
409 net_dev->base_addr = ioaddr;
410 net_dev->irq = pci_dev->irq;
411 sis_priv->pci_dev = pci_dev;
412 spin_lock_init(&sis_priv->lock);
413
414 pci_set_drvdata(pci_dev, net_dev);
415
416 ring_space = pci_alloc_consistent(pci_dev, TX_TOTAL_SIZE, &ring_dma);
417 if (!ring_space) {
418 ret = -ENOMEM;
419 goto err_out_cleardev;
420 }
421 sis_priv->tx_ring = (BufferDesc *)ring_space;
422 sis_priv->tx_ring_dma = ring_dma;
423
424 ring_space = pci_alloc_consistent(pci_dev, RX_TOTAL_SIZE, &ring_dma);
425 if (!ring_space) {
426 ret = -ENOMEM;
427 goto err_unmap_tx;
428 }
429 sis_priv->rx_ring = (BufferDesc *)ring_space;
430 sis_priv->rx_ring_dma = ring_dma;
431
432 /* The SiS900-specific entries in the device structure. */
433 net_dev->netdev_ops = &sis900_netdev_ops;
434 net_dev->watchdog_timeo = TX_TIMEOUT;
435 net_dev->ethtool_ops = &sis900_ethtool_ops;
436
437 if (sis900_debug > 0)
438 sis_priv->msg_enable = sis900_debug;
439 else
440 sis_priv->msg_enable = SIS900_DEF_MSG;
441
442 sis_priv->mii_info.dev = net_dev;
443 sis_priv->mii_info.mdio_read = mdio_read;
444 sis_priv->mii_info.mdio_write = mdio_write;
445 sis_priv->mii_info.phy_id_mask = 0x1f;
446 sis_priv->mii_info.reg_num_mask = 0x1f;
447
448 /* Get Mac address according to the chip revision */
449 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &(sis_priv->chipset_rev));
450 if(netif_msg_probe(sis_priv))
451 printk(KERN_DEBUG "%s: detected revision %2.2x, "
452 "trying to get MAC address...\n",
453 dev_name, sis_priv->chipset_rev);
454
455 ret = 0;
456 if (sis_priv->chipset_rev == SIS630E_900_REV)
457 ret = sis630e_get_mac_addr(pci_dev, net_dev);
458 else if ((sis_priv->chipset_rev > 0x81) && (sis_priv->chipset_rev <= 0x90) )
459 ret = sis635_get_mac_addr(pci_dev, net_dev);
460 else if (sis_priv->chipset_rev == SIS96x_900_REV)
461 ret = sis96x_get_mac_addr(pci_dev, net_dev);
462 else
463 ret = sis900_get_mac_addr(pci_dev, net_dev);
464
465 if (!ret || !is_valid_ether_addr(net_dev->dev_addr)) {
466 random_ether_addr(net_dev->dev_addr);
467 printk(KERN_WARNING "%s: Unreadable or invalid MAC address,"
468 "using random generated one\n", dev_name);
469 }
470
471 /* 630ET : set the mii access mode as software-mode */
472 if (sis_priv->chipset_rev == SIS630ET_900_REV)
473 outl(ACCESSMODE | inl(ioaddr + cr), ioaddr + cr);
474
475 /* probe for mii transceiver */
476 if (sis900_mii_probe(net_dev) == 0) {
477 printk(KERN_WARNING "%s: Error probing MII device.\n",
478 dev_name);
479 ret = -ENODEV;
480 goto err_unmap_rx;
481 }
482
483 /* save our host bridge revision */
484 dev = pci_get_device(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_630, NULL);
485 if (dev) {
486 pci_read_config_byte(dev, PCI_CLASS_REVISION, &sis_priv->host_bridge_rev);
487 pci_dev_put(dev);
488 }
489
490 ret = register_netdev(net_dev);
491 if (ret)
492 goto err_unmap_rx;
493
494 /* print some information about our NIC */
495 printk(KERN_INFO "%s: %s at %#lx, IRQ %d, %pM\n",
496 net_dev->name, card_name, ioaddr, net_dev->irq,
497 net_dev->dev_addr);
498
499 /* Detect Wake on Lan support */
500 ret = (inl(net_dev->base_addr + CFGPMC) & PMESP) >> 27;
501 if (netif_msg_probe(sis_priv) && (ret & PME_D3C) == 0)
502 printk(KERN_INFO "%s: Wake on LAN only available from suspend to RAM.", net_dev->name);
503
504 return 0;
505
506 err_unmap_rx:
507 pci_free_consistent(pci_dev, RX_TOTAL_SIZE, sis_priv->rx_ring,
508 sis_priv->rx_ring_dma);
509 err_unmap_tx:
510 pci_free_consistent(pci_dev, TX_TOTAL_SIZE, sis_priv->tx_ring,
511 sis_priv->tx_ring_dma);
512 err_out_cleardev:
513 pci_set_drvdata(pci_dev, NULL);
514 pci_release_regions(pci_dev);
515 err_out:
516 free_netdev(net_dev);
517 return ret;
518 }
519
520 /**
521 * sis900_mii_probe - Probe MII PHY for sis900
522 * @net_dev: the net device to probe for
523 *
524 * Search for total of 32 possible mii phy addresses.
525 * Identify and set current phy if found one,
526 * return error if it failed to found.
527 */
528
529 static int __devinit sis900_mii_probe(struct net_device * net_dev)
530 {
531 struct sis900_private *sis_priv = netdev_priv(net_dev);
532 const char *dev_name = pci_name(sis_priv->pci_dev);
533 u16 poll_bit = MII_STAT_LINK, status = 0;
534 unsigned long timeout = jiffies + 5 * HZ;
535 int phy_addr;
536
537 sis_priv->mii = NULL;
538
539 /* search for total of 32 possible mii phy addresses */
540 for (phy_addr = 0; phy_addr < 32; phy_addr++) {
541 struct mii_phy * mii_phy = NULL;
542 u16 mii_status;
543 int i;
544
545 mii_phy = NULL;
546 for(i = 0; i < 2; i++)
547 mii_status = mdio_read(net_dev, phy_addr, MII_STATUS);
548
549 if (mii_status == 0xffff || mii_status == 0x0000) {
550 if (netif_msg_probe(sis_priv))
551 printk(KERN_DEBUG "%s: MII at address %d"
552 " not accessible\n",
553 dev_name, phy_addr);
554 continue;
555 }
556
557 if ((mii_phy = kmalloc(sizeof(struct mii_phy), GFP_KERNEL)) == NULL) {
558 printk(KERN_WARNING "Cannot allocate mem for struct mii_phy\n");
559 mii_phy = sis_priv->first_mii;
560 while (mii_phy) {
561 struct mii_phy *phy;
562 phy = mii_phy;
563 mii_phy = mii_phy->next;
564 kfree(phy);
565 }
566 return 0;
567 }
568
569 mii_phy->phy_id0 = mdio_read(net_dev, phy_addr, MII_PHY_ID0);
570 mii_phy->phy_id1 = mdio_read(net_dev, phy_addr, MII_PHY_ID1);
571 mii_phy->phy_addr = phy_addr;
572 mii_phy->status = mii_status;
573 mii_phy->next = sis_priv->mii;
574 sis_priv->mii = mii_phy;
575 sis_priv->first_mii = mii_phy;
576
577 for (i = 0; mii_chip_table[i].phy_id1; i++)
578 if ((mii_phy->phy_id0 == mii_chip_table[i].phy_id0 ) &&
579 ((mii_phy->phy_id1 & 0xFFF0) == mii_chip_table[i].phy_id1)){
580 mii_phy->phy_types = mii_chip_table[i].phy_types;
581 if (mii_chip_table[i].phy_types == MIX)
582 mii_phy->phy_types =
583 (mii_status & (MII_STAT_CAN_TX_FDX | MII_STAT_CAN_TX)) ? LAN : HOME;
584 printk(KERN_INFO "%s: %s transceiver found "
585 "at address %d.\n",
586 dev_name,
587 mii_chip_table[i].name,
588 phy_addr);
589 break;
590 }
591
592 if( !mii_chip_table[i].phy_id1 ) {
593 printk(KERN_INFO "%s: Unknown PHY transceiver found at address %d.\n",
594 dev_name, phy_addr);
595 mii_phy->phy_types = UNKNOWN;
596 }
597 }
598
599 if (sis_priv->mii == NULL) {
600 printk(KERN_INFO "%s: No MII transceivers found!\n", dev_name);
601 return 0;
602 }
603
604 /* select default PHY for mac */
605 sis_priv->mii = NULL;
606 sis900_default_phy( net_dev );
607
608 /* Reset phy if default phy is internal sis900 */
609 if ((sis_priv->mii->phy_id0 == 0x001D) &&
610 ((sis_priv->mii->phy_id1&0xFFF0) == 0x8000))
611 status = sis900_reset_phy(net_dev, sis_priv->cur_phy);
612
613 if ((sis_priv->mii->phy_id0 == 0x0015) &&
614 ((sis_priv->mii->phy_id1&0xFFF0) == 0xF440))
615 mdio_write(net_dev, sis_priv->cur_phy, 0x0018, 0xD200);
616
617 if(status & MII_STAT_LINK){
618 while (poll_bit) {
619 yield();
620
621 poll_bit ^= (mdio_read(net_dev, sis_priv->cur_phy, MII_STATUS) & poll_bit);
622 if (time_after_eq(jiffies, timeout)) {
623 printk(KERN_WARNING "%s: reset phy and link down now\n",
624 dev_name);
625 return -ETIME;
626 }
627 }
628 }
629
630 if (sis_priv->chipset_rev == SIS630E_900_REV) {
631 /* SiS 630E has some bugs on default value of PHY registers */
632 mdio_write(net_dev, sis_priv->cur_phy, MII_ANADV, 0x05e1);
633 mdio_write(net_dev, sis_priv->cur_phy, MII_CONFIG1, 0x22);
634 mdio_write(net_dev, sis_priv->cur_phy, MII_CONFIG2, 0xff00);
635 mdio_write(net_dev, sis_priv->cur_phy, MII_MASK, 0xffc0);
636 //mdio_write(net_dev, sis_priv->cur_phy, MII_CONTROL, 0x1000);
637 }
638
639 if (sis_priv->mii->status & MII_STAT_LINK)
640 netif_carrier_on(net_dev);
641 else
642 netif_carrier_off(net_dev);
643
644 return 1;
645 }
646
647 /**
648 * sis900_default_phy - Select default PHY for sis900 mac.
649 * @net_dev: the net device to probe for
650 *
651 * Select first detected PHY with link as default.
652 * If no one is link on, select PHY whose types is HOME as default.
653 * If HOME doesn't exist, select LAN.
654 */
655
656 static u16 sis900_default_phy(struct net_device * net_dev)
657 {
658 struct sis900_private *sis_priv = netdev_priv(net_dev);
659 struct mii_phy *phy = NULL, *phy_home = NULL,
660 *default_phy = NULL, *phy_lan = NULL;
661 u16 status;
662
663 for (phy=sis_priv->first_mii; phy; phy=phy->next) {
664 status = mdio_read(net_dev, phy->phy_addr, MII_STATUS);
665 status = mdio_read(net_dev, phy->phy_addr, MII_STATUS);
666
667 /* Link ON & Not select default PHY & not ghost PHY */
668 if ((status & MII_STAT_LINK) && !default_phy &&
669 (phy->phy_types != UNKNOWN))
670 default_phy = phy;
671 else {
672 status = mdio_read(net_dev, phy->phy_addr, MII_CONTROL);
673 mdio_write(net_dev, phy->phy_addr, MII_CONTROL,
674 status | MII_CNTL_AUTO | MII_CNTL_ISOLATE);
675 if (phy->phy_types == HOME)
676 phy_home = phy;
677 else if(phy->phy_types == LAN)
678 phy_lan = phy;
679 }
680 }
681
682 if (!default_phy && phy_home)
683 default_phy = phy_home;
684 else if (!default_phy && phy_lan)
685 default_phy = phy_lan;
686 else if (!default_phy)
687 default_phy = sis_priv->first_mii;
688
689 if (sis_priv->mii != default_phy) {
690 sis_priv->mii = default_phy;
691 sis_priv->cur_phy = default_phy->phy_addr;
692 printk(KERN_INFO "%s: Using transceiver found at address %d as default\n",
693 pci_name(sis_priv->pci_dev), sis_priv->cur_phy);
694 }
695
696 sis_priv->mii_info.phy_id = sis_priv->cur_phy;
697
698 status = mdio_read(net_dev, sis_priv->cur_phy, MII_CONTROL);
699 status &= (~MII_CNTL_ISOLATE);
700
701 mdio_write(net_dev, sis_priv->cur_phy, MII_CONTROL, status);
702 status = mdio_read(net_dev, sis_priv->cur_phy, MII_STATUS);
703 status = mdio_read(net_dev, sis_priv->cur_phy, MII_STATUS);
704
705 return status;
706 }
707
708
709 /**
710 * sis900_set_capability - set the media capability of network adapter.
711 * @net_dev : the net device to probe for
712 * @phy : default PHY
713 *
714 * Set the media capability of network adapter according to
715 * mii status register. It's necessary before auto-negotiate.
716 */
717
718 static void sis900_set_capability(struct net_device *net_dev, struct mii_phy *phy)
719 {
720 u16 cap;
721 u16 status;
722
723 status = mdio_read(net_dev, phy->phy_addr, MII_STATUS);
724 status = mdio_read(net_dev, phy->phy_addr, MII_STATUS);
725
726 cap = MII_NWAY_CSMA_CD |
727 ((phy->status & MII_STAT_CAN_TX_FDX)? MII_NWAY_TX_FDX:0) |
728 ((phy->status & MII_STAT_CAN_TX) ? MII_NWAY_TX:0) |
729 ((phy->status & MII_STAT_CAN_T_FDX) ? MII_NWAY_T_FDX:0)|
730 ((phy->status & MII_STAT_CAN_T) ? MII_NWAY_T:0);
731
732 mdio_write(net_dev, phy->phy_addr, MII_ANADV, cap);
733 }
734
735
736 /* Delay between EEPROM clock transitions. */
737 #define eeprom_delay() inl(ee_addr)
738
739 /**
740 * read_eeprom - Read Serial EEPROM
741 * @ioaddr: base i/o address
742 * @location: the EEPROM location to read
743 *
744 * Read Serial EEPROM through EEPROM Access Register.
745 * Note that location is in word (16 bits) unit
746 */
747
748 static u16 __devinit read_eeprom(long ioaddr, int location)
749 {
750 int i;
751 u16 retval = 0;
752 long ee_addr = ioaddr + mear;
753 u32 read_cmd = location | EEread;
754
755 outl(0, ee_addr);
756 eeprom_delay();
757 outl(EECS, ee_addr);
758 eeprom_delay();
759
760 /* Shift the read command (9) bits out. */
761 for (i = 8; i >= 0; i--) {
762 u32 dataval = (read_cmd & (1 << i)) ? EEDI | EECS : EECS;
763 outl(dataval, ee_addr);
764 eeprom_delay();
765 outl(dataval | EECLK, ee_addr);
766 eeprom_delay();
767 }
768 outl(EECS, ee_addr);
769 eeprom_delay();
770
771 /* read the 16-bits data in */
772 for (i = 16; i > 0; i--) {
773 outl(EECS, ee_addr);
774 eeprom_delay();
775 outl(EECS | EECLK, ee_addr);
776 eeprom_delay();
777 retval = (retval << 1) | ((inl(ee_addr) & EEDO) ? 1 : 0);
778 eeprom_delay();
779 }
780
781 /* Terminate the EEPROM access. */
782 outl(0, ee_addr);
783 eeprom_delay();
784
785 return (retval);
786 }
787
788 /* Read and write the MII management registers using software-generated
789 serial MDIO protocol. Note that the command bits and data bits are
790 send out separately */
791 #define mdio_delay() inl(mdio_addr)
792
793 static void mdio_idle(long mdio_addr)
794 {
795 outl(MDIO | MDDIR, mdio_addr);
796 mdio_delay();
797 outl(MDIO | MDDIR | MDC, mdio_addr);
798 }
799
800 /* Syncronize the MII management interface by shifting 32 one bits out. */
801 static void mdio_reset(long mdio_addr)
802 {
803 int i;
804
805 for (i = 31; i >= 0; i--) {
806 outl(MDDIR | MDIO, mdio_addr);
807 mdio_delay();
808 outl(MDDIR | MDIO | MDC, mdio_addr);
809 mdio_delay();
810 }
811 }
812
813 /**
814 * mdio_read - read MII PHY register
815 * @net_dev: the net device to read
816 * @phy_id: the phy address to read
817 * @location: the phy regiester id to read
818 *
819 * Read MII registers through MDIO and MDC
820 * using MDIO management frame structure and protocol(defined by ISO/IEC).
821 * Please see SiS7014 or ICS spec
822 */
823
824 static int mdio_read(struct net_device *net_dev, int phy_id, int location)
825 {
826 long mdio_addr = net_dev->base_addr + mear;
827 int mii_cmd = MIIread|(phy_id<<MIIpmdShift)|(location<<MIIregShift);
828 u16 retval = 0;
829 int i;
830
831 mdio_reset(mdio_addr);
832 mdio_idle(mdio_addr);
833
834 for (i = 15; i >= 0; i--) {
835 int dataval = (mii_cmd & (1 << i)) ? MDDIR | MDIO : MDDIR;
836 outl(dataval, mdio_addr);
837 mdio_delay();
838 outl(dataval | MDC, mdio_addr);
839 mdio_delay();
840 }
841
842 /* Read the 16 data bits. */
843 for (i = 16; i > 0; i--) {
844 outl(0, mdio_addr);
845 mdio_delay();
846 retval = (retval << 1) | ((inl(mdio_addr) & MDIO) ? 1 : 0);
847 outl(MDC, mdio_addr);
848 mdio_delay();
849 }
850 outl(0x00, mdio_addr);
851
852 return retval;
853 }
854
855 /**
856 * mdio_write - write MII PHY register
857 * @net_dev: the net device to write
858 * @phy_id: the phy address to write
859 * @location: the phy regiester id to write
860 * @value: the register value to write with
861 *
862 * Write MII registers with @value through MDIO and MDC
863 * using MDIO management frame structure and protocol(defined by ISO/IEC)
864 * please see SiS7014 or ICS spec
865 */
866
867 static void mdio_write(struct net_device *net_dev, int phy_id, int location,
868 int value)
869 {
870 long mdio_addr = net_dev->base_addr + mear;
871 int mii_cmd = MIIwrite|(phy_id<<MIIpmdShift)|(location<<MIIregShift);
872 int i;
873
874 mdio_reset(mdio_addr);
875 mdio_idle(mdio_addr);
876
877 /* Shift the command bits out. */
878 for (i = 15; i >= 0; i--) {
879 int dataval = (mii_cmd & (1 << i)) ? MDDIR | MDIO : MDDIR;
880 outb(dataval, mdio_addr);
881 mdio_delay();
882 outb(dataval | MDC, mdio_addr);
883 mdio_delay();
884 }
885 mdio_delay();
886
887 /* Shift the value bits out. */
888 for (i = 15; i >= 0; i--) {
889 int dataval = (value & (1 << i)) ? MDDIR | MDIO : MDDIR;
890 outl(dataval, mdio_addr);
891 mdio_delay();
892 outl(dataval | MDC, mdio_addr);
893 mdio_delay();
894 }
895 mdio_delay();
896
897 /* Clear out extra bits. */
898 for (i = 2; i > 0; i--) {
899 outb(0, mdio_addr);
900 mdio_delay();
901 outb(MDC, mdio_addr);
902 mdio_delay();
903 }
904 outl(0x00, mdio_addr);
905 }
906
907
908 /**
909 * sis900_reset_phy - reset sis900 mii phy.
910 * @net_dev: the net device to write
911 * @phy_addr: default phy address
912 *
913 * Some specific phy can't work properly without reset.
914 * This function will be called during initialization and
915 * link status change from ON to DOWN.
916 */
917
918 static u16 sis900_reset_phy(struct net_device *net_dev, int phy_addr)
919 {
920 int i;
921 u16 status;
922
923 for (i = 0; i < 2; i++)
924 status = mdio_read(net_dev, phy_addr, MII_STATUS);
925
926 mdio_write( net_dev, phy_addr, MII_CONTROL, MII_CNTL_RESET );
927
928 return status;
929 }
930
931 #ifdef CONFIG_NET_POLL_CONTROLLER
932 /*
933 * Polling 'interrupt' - used by things like netconsole to send skbs
934 * without having to re-enable interrupts. It's not called while
935 * the interrupt routine is executing.
936 */
937 static void sis900_poll(struct net_device *dev)
938 {
939 disable_irq(dev->irq);
940 sis900_interrupt(dev->irq, dev);
941 enable_irq(dev->irq);
942 }
943 #endif
944
945 /**
946 * sis900_open - open sis900 device
947 * @net_dev: the net device to open
948 *
949 * Do some initialization and start net interface.
950 * enable interrupts and set sis900 timer.
951 */
952
953 static int
954 sis900_open(struct net_device *net_dev)
955 {
956 struct sis900_private *sis_priv = netdev_priv(net_dev);
957 long ioaddr = net_dev->base_addr;
958 int ret;
959
960 /* Soft reset the chip. */
961 sis900_reset(net_dev);
962
963 sis630_set_eq(net_dev, sis_priv->chipset_rev);
964
965 ret = request_irq(net_dev->irq, sis900_interrupt, IRQF_SHARED,
966 net_dev->name, net_dev);
967 if (ret)
968 return ret;
969
970 sis900_init_rxfilter(net_dev);
971
972 sis900_init_tx_ring(net_dev);
973 sis900_init_rx_ring(net_dev);
974
975 set_rx_mode(net_dev);
976
977 netif_start_queue(net_dev);
978
979 sis900_set_mode(ioaddr, HW_SPEED_10_MBPS, FDX_CAPABLE_HALF_SELECTED);
980
981 /* Enable all known interrupts by setting the interrupt mask. */
982 outl((RxSOVR|RxORN|RxERR|RxOK|TxURN|TxERR|TxIDLE), ioaddr + imr);
983 outl(RxENA | inl(ioaddr + cr), ioaddr + cr);
984 outl(IE, ioaddr + ier);
985
986 sis900_check_mode(net_dev, sis_priv->mii);
987
988 /* Set the timer to switch to check for link beat and perhaps switch
989 to an alternate media type. */
990 init_timer(&sis_priv->timer);
991 sis_priv->timer.expires = jiffies + HZ;
992 sis_priv->timer.data = (unsigned long)net_dev;
993 sis_priv->timer.function = &sis900_timer;
994 add_timer(&sis_priv->timer);
995
996 return 0;
997 }
998
999 /**
1000 * sis900_init_rxfilter - Initialize the Rx filter
1001 * @net_dev: the net device to initialize for
1002 *
1003 * Set receive filter address to our MAC address
1004 * and enable packet filtering.
1005 */
1006
1007 static void
1008 sis900_init_rxfilter (struct net_device * net_dev)
1009 {
1010 struct sis900_private *sis_priv = netdev_priv(net_dev);
1011 long ioaddr = net_dev->base_addr;
1012 u32 rfcrSave;
1013 u32 i;
1014
1015 rfcrSave = inl(rfcr + ioaddr);
1016
1017 /* disable packet filtering before setting filter */
1018 outl(rfcrSave & ~RFEN, rfcr + ioaddr);
1019
1020 /* load MAC addr to filter data register */
1021 for (i = 0 ; i < 3 ; i++) {
1022 u32 w;
1023
1024 w = (u32) *((u16 *)(net_dev->dev_addr)+i);
1025 outl((i << RFADDR_shift), ioaddr + rfcr);
1026 outl(w, ioaddr + rfdr);
1027
1028 if (netif_msg_hw(sis_priv)) {
1029 printk(KERN_DEBUG "%s: Receive Filter Addrss[%d]=%x\n",
1030 net_dev->name, i, inl(ioaddr + rfdr));
1031 }
1032 }
1033
1034 /* enable packet filtering */
1035 outl(rfcrSave | RFEN, rfcr + ioaddr);
1036 }
1037
1038 /**
1039 * sis900_init_tx_ring - Initialize the Tx descriptor ring
1040 * @net_dev: the net device to initialize for
1041 *
1042 * Initialize the Tx descriptor ring,
1043 */
1044
1045 static void
1046 sis900_init_tx_ring(struct net_device *net_dev)
1047 {
1048 struct sis900_private *sis_priv = netdev_priv(net_dev);
1049 long ioaddr = net_dev->base_addr;
1050 int i;
1051
1052 sis_priv->tx_full = 0;
1053 sis_priv->dirty_tx = sis_priv->cur_tx = 0;
1054
1055 for (i = 0; i < NUM_TX_DESC; i++) {
1056 sis_priv->tx_skbuff[i] = NULL;
1057
1058 sis_priv->tx_ring[i].link = sis_priv->tx_ring_dma +
1059 ((i+1)%NUM_TX_DESC)*sizeof(BufferDesc);
1060 sis_priv->tx_ring[i].cmdsts = 0;
1061 sis_priv->tx_ring[i].bufptr = 0;
1062 }
1063
1064 /* load Transmit Descriptor Register */
1065 outl(sis_priv->tx_ring_dma, ioaddr + txdp);
1066 if (netif_msg_hw(sis_priv))
1067 printk(KERN_DEBUG "%s: TX descriptor register loaded with: %8.8x\n",
1068 net_dev->name, inl(ioaddr + txdp));
1069 }
1070
1071 /**
1072 * sis900_init_rx_ring - Initialize the Rx descriptor ring
1073 * @net_dev: the net device to initialize for
1074 *
1075 * Initialize the Rx descriptor ring,
1076 * and pre-allocate recevie buffers (socket buffer)
1077 */
1078
1079 static void
1080 sis900_init_rx_ring(struct net_device *net_dev)
1081 {
1082 struct sis900_private *sis_priv = netdev_priv(net_dev);
1083 long ioaddr = net_dev->base_addr;
1084 int i;
1085
1086 sis_priv->cur_rx = 0;
1087 sis_priv->dirty_rx = 0;
1088
1089 /* init RX descriptor */
1090 for (i = 0; i < NUM_RX_DESC; i++) {
1091 sis_priv->rx_skbuff[i] = NULL;
1092
1093 sis_priv->rx_ring[i].link = sis_priv->rx_ring_dma +
1094 ((i+1)%NUM_RX_DESC)*sizeof(BufferDesc);
1095 sis_priv->rx_ring[i].cmdsts = 0;
1096 sis_priv->rx_ring[i].bufptr = 0;
1097 }
1098
1099 /* allocate sock buffers */
1100 for (i = 0; i < NUM_RX_DESC; i++) {
1101 struct sk_buff *skb;
1102
1103 if ((skb = dev_alloc_skb(RX_BUF_SIZE)) == NULL) {
1104 /* not enough memory for skbuff, this makes a "hole"
1105 on the buffer ring, it is not clear how the
1106 hardware will react to this kind of degenerated
1107 buffer */
1108 break;
1109 }
1110 sis_priv->rx_skbuff[i] = skb;
1111 sis_priv->rx_ring[i].cmdsts = RX_BUF_SIZE;
1112 sis_priv->rx_ring[i].bufptr = pci_map_single(sis_priv->pci_dev,
1113 skb->data, RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
1114 }
1115 sis_priv->dirty_rx = (unsigned int) (i - NUM_RX_DESC);
1116
1117 /* load Receive Descriptor Register */
1118 outl(sis_priv->rx_ring_dma, ioaddr + rxdp);
1119 if (netif_msg_hw(sis_priv))
1120 printk(KERN_DEBUG "%s: RX descriptor register loaded with: %8.8x\n",
1121 net_dev->name, inl(ioaddr + rxdp));
1122 }
1123
1124
1125 static void sis630_set_eq(struct net_device *net_dev, u8 revision)
1126 {
1127 struct sis900_private *sis_priv = netdev_priv(net_dev);
1128 u16 reg14h, eq_value=0, max_value=0, min_value=0;
1129 int i, maxcount=10;
1130
1131 if ( !(revision == SIS630E_900_REV || revision == SIS630EA1_900_REV ||
1132 revision == SIS630A_900_REV || revision == SIS630ET_900_REV) )
1133 return;
1134
1135 if (netif_carrier_ok(net_dev)) {
1136 reg14h = mdio_read(net_dev, sis_priv->cur_phy, MII_RESV);
1137 mdio_write(net_dev, sis_priv->cur_phy, MII_RESV,
1138 (0x2200 | reg14h) & 0xBFFF);
1139 for (i=0; i < maxcount; i++) {
1140 eq_value = (0x00F8 & mdio_read(net_dev,
1141 sis_priv->cur_phy, MII_RESV)) >> 3;
1142 if (i == 0)
1143 max_value=min_value=eq_value;
1144 max_value = (eq_value > max_value) ?
1145 eq_value : max_value;
1146 min_value = (eq_value < min_value) ?
1147 eq_value : min_value;
1148 }
1149 /* 630E rule to determine the equalizer value */
1150 if (revision == SIS630E_900_REV || revision == SIS630EA1_900_REV ||
1151 revision == SIS630ET_900_REV) {
1152 if (max_value < 5)
1153 eq_value = max_value;
1154 else if (max_value >= 5 && max_value < 15)
1155 eq_value = (max_value == min_value) ?
1156 max_value+2 : max_value+1;
1157 else if (max_value >= 15)
1158 eq_value=(max_value == min_value) ?
1159 max_value+6 : max_value+5;
1160 }
1161 /* 630B0&B1 rule to determine the equalizer value */
1162 if (revision == SIS630A_900_REV &&
1163 (sis_priv->host_bridge_rev == SIS630B0 ||
1164 sis_priv->host_bridge_rev == SIS630B1)) {
1165 if (max_value == 0)
1166 eq_value = 3;
1167 else
1168 eq_value = (max_value + min_value + 1)/2;
1169 }
1170 /* write equalizer value and setting */
1171 reg14h = mdio_read(net_dev, sis_priv->cur_phy, MII_RESV);
1172 reg14h = (reg14h & 0xFF07) | ((eq_value << 3) & 0x00F8);
1173 reg14h = (reg14h | 0x6000) & 0xFDFF;
1174 mdio_write(net_dev, sis_priv->cur_phy, MII_RESV, reg14h);
1175 } else {
1176 reg14h = mdio_read(net_dev, sis_priv->cur_phy, MII_RESV);
1177 if (revision == SIS630A_900_REV &&
1178 (sis_priv->host_bridge_rev == SIS630B0 ||
1179 sis_priv->host_bridge_rev == SIS630B1))
1180 mdio_write(net_dev, sis_priv->cur_phy, MII_RESV,
1181 (reg14h | 0x2200) & 0xBFFF);
1182 else
1183 mdio_write(net_dev, sis_priv->cur_phy, MII_RESV,
1184 (reg14h | 0x2000) & 0xBFFF);
1185 }
1186 }
1187
1188 /**
1189 * sis900_timer - sis900 timer routine
1190 * @data: pointer to sis900 net device
1191 *
1192 * On each timer ticks we check two things,
1193 * link status (ON/OFF) and link mode (10/100/Full/Half)
1194 */
1195
1196 static void sis900_timer(unsigned long data)
1197 {
1198 struct net_device *net_dev = (struct net_device *)data;
1199 struct sis900_private *sis_priv = netdev_priv(net_dev);
1200 struct mii_phy *mii_phy = sis_priv->mii;
1201 static const int next_tick = 5*HZ;
1202 u16 status;
1203
1204 if (!sis_priv->autong_complete){
1205 int uninitialized_var(speed), duplex = 0;
1206
1207 sis900_read_mode(net_dev, &speed, &duplex);
1208 if (duplex){
1209 sis900_set_mode(net_dev->base_addr, speed, duplex);
1210 sis630_set_eq(net_dev, sis_priv->chipset_rev);
1211 netif_start_queue(net_dev);
1212 }
1213
1214 sis_priv->timer.expires = jiffies + HZ;
1215 add_timer(&sis_priv->timer);
1216 return;
1217 }
1218
1219 status = mdio_read(net_dev, sis_priv->cur_phy, MII_STATUS);
1220 status = mdio_read(net_dev, sis_priv->cur_phy, MII_STATUS);
1221
1222 /* Link OFF -> ON */
1223 if (!netif_carrier_ok(net_dev)) {
1224 LookForLink:
1225 /* Search for new PHY */
1226 status = sis900_default_phy(net_dev);
1227 mii_phy = sis_priv->mii;
1228
1229 if (status & MII_STAT_LINK){
1230 sis900_check_mode(net_dev, mii_phy);
1231 netif_carrier_on(net_dev);
1232 }
1233 } else {
1234 /* Link ON -> OFF */
1235 if (!(status & MII_STAT_LINK)){
1236 netif_carrier_off(net_dev);
1237 if(netif_msg_link(sis_priv))
1238 printk(KERN_INFO "%s: Media Link Off\n", net_dev->name);
1239
1240 /* Change mode issue */
1241 if ((mii_phy->phy_id0 == 0x001D) &&
1242 ((mii_phy->phy_id1 & 0xFFF0) == 0x8000))
1243 sis900_reset_phy(net_dev, sis_priv->cur_phy);
1244
1245 sis630_set_eq(net_dev, sis_priv->chipset_rev);
1246
1247 goto LookForLink;
1248 }
1249 }
1250
1251 sis_priv->timer.expires = jiffies + next_tick;
1252 add_timer(&sis_priv->timer);
1253 }
1254
1255 /**
1256 * sis900_check_mode - check the media mode for sis900
1257 * @net_dev: the net device to be checked
1258 * @mii_phy: the mii phy
1259 *
1260 * Older driver gets the media mode from mii status output
1261 * register. Now we set our media capability and auto-negotiate
1262 * to get the upper bound of speed and duplex between two ends.
1263 * If the types of mii phy is HOME, it doesn't need to auto-negotiate
1264 * and autong_complete should be set to 1.
1265 */
1266
1267 static void sis900_check_mode(struct net_device *net_dev, struct mii_phy *mii_phy)
1268 {
1269 struct sis900_private *sis_priv = netdev_priv(net_dev);
1270 long ioaddr = net_dev->base_addr;
1271 int speed, duplex;
1272
1273 if (mii_phy->phy_types == LAN) {
1274 outl(~EXD & inl(ioaddr + cfg), ioaddr + cfg);
1275 sis900_set_capability(net_dev , mii_phy);
1276 sis900_auto_negotiate(net_dev, sis_priv->cur_phy);
1277 } else {
1278 outl(EXD | inl(ioaddr + cfg), ioaddr + cfg);
1279 speed = HW_SPEED_HOME;
1280 duplex = FDX_CAPABLE_HALF_SELECTED;
1281 sis900_set_mode(ioaddr, speed, duplex);
1282 sis_priv->autong_complete = 1;
1283 }
1284 }
1285
1286 /**
1287 * sis900_set_mode - Set the media mode of mac register.
1288 * @ioaddr: the address of the device
1289 * @speed : the transmit speed to be determined
1290 * @duplex: the duplex mode to be determined
1291 *
1292 * Set the media mode of mac register txcfg/rxcfg according to
1293 * speed and duplex of phy. Bit EDB_MASTER_EN indicates the EDB
1294 * bus is used instead of PCI bus. When this bit is set 1, the
1295 * Max DMA Burst Size for TX/RX DMA should be no larger than 16
1296 * double words.
1297 */
1298
1299 static void sis900_set_mode (long ioaddr, int speed, int duplex)
1300 {
1301 u32 tx_flags = 0, rx_flags = 0;
1302
1303 if (inl(ioaddr + cfg) & EDB_MASTER_EN) {
1304 tx_flags = TxATP | (DMA_BURST_64 << TxMXDMA_shift) |
1305 (TX_FILL_THRESH << TxFILLT_shift);
1306 rx_flags = DMA_BURST_64 << RxMXDMA_shift;
1307 } else {
1308 tx_flags = TxATP | (DMA_BURST_512 << TxMXDMA_shift) |
1309 (TX_FILL_THRESH << TxFILLT_shift);
1310 rx_flags = DMA_BURST_512 << RxMXDMA_shift;
1311 }
1312
1313 if (speed == HW_SPEED_HOME || speed == HW_SPEED_10_MBPS) {
1314 rx_flags |= (RxDRNT_10 << RxDRNT_shift);
1315 tx_flags |= (TxDRNT_10 << TxDRNT_shift);
1316 } else {
1317 rx_flags |= (RxDRNT_100 << RxDRNT_shift);
1318 tx_flags |= (TxDRNT_100 << TxDRNT_shift);
1319 }
1320
1321 if (duplex == FDX_CAPABLE_FULL_SELECTED) {
1322 tx_flags |= (TxCSI | TxHBI);
1323 rx_flags |= RxATX;
1324 }
1325
1326 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
1327 /* Can accept Jumbo packet */
1328 rx_flags |= RxAJAB;
1329 #endif
1330
1331 outl (tx_flags, ioaddr + txcfg);
1332 outl (rx_flags, ioaddr + rxcfg);
1333 }
1334
1335 /**
1336 * sis900_auto_negotiate - Set the Auto-Negotiation Enable/Reset bit.
1337 * @net_dev: the net device to read mode for
1338 * @phy_addr: mii phy address
1339 *
1340 * If the adapter is link-on, set the auto-negotiate enable/reset bit.
1341 * autong_complete should be set to 0 when starting auto-negotiation.
1342 * autong_complete should be set to 1 if we didn't start auto-negotiation.
1343 * sis900_timer will wait for link on again if autong_complete = 0.
1344 */
1345
1346 static void sis900_auto_negotiate(struct net_device *net_dev, int phy_addr)
1347 {
1348 struct sis900_private *sis_priv = netdev_priv(net_dev);
1349 int i = 0;
1350 u32 status;
1351
1352 for (i = 0; i < 2; i++)
1353 status = mdio_read(net_dev, phy_addr, MII_STATUS);
1354
1355 if (!(status & MII_STAT_LINK)){
1356 if(netif_msg_link(sis_priv))
1357 printk(KERN_INFO "%s: Media Link Off\n", net_dev->name);
1358 sis_priv->autong_complete = 1;
1359 netif_carrier_off(net_dev);
1360 return;
1361 }
1362
1363 /* (Re)start AutoNegotiate */
1364 mdio_write(net_dev, phy_addr, MII_CONTROL,
1365 MII_CNTL_AUTO | MII_CNTL_RST_AUTO);
1366 sis_priv->autong_complete = 0;
1367 }
1368
1369
1370 /**
1371 * sis900_read_mode - read media mode for sis900 internal phy
1372 * @net_dev: the net device to read mode for
1373 * @speed : the transmit speed to be determined
1374 * @duplex : the duplex mode to be determined
1375 *
1376 * The capability of remote end will be put in mii register autorec
1377 * after auto-negotiation. Use AND operation to get the upper bound
1378 * of speed and duplex between two ends.
1379 */
1380
1381 static void sis900_read_mode(struct net_device *net_dev, int *speed, int *duplex)
1382 {
1383 struct sis900_private *sis_priv = netdev_priv(net_dev);
1384 struct mii_phy *phy = sis_priv->mii;
1385 int phy_addr = sis_priv->cur_phy;
1386 u32 status;
1387 u16 autoadv, autorec;
1388 int i;
1389
1390 for (i = 0; i < 2; i++)
1391 status = mdio_read(net_dev, phy_addr, MII_STATUS);
1392
1393 if (!(status & MII_STAT_LINK))
1394 return;
1395
1396 /* AutoNegotiate completed */
1397 autoadv = mdio_read(net_dev, phy_addr, MII_ANADV);
1398 autorec = mdio_read(net_dev, phy_addr, MII_ANLPAR);
1399 status = autoadv & autorec;
1400
1401 *speed = HW_SPEED_10_MBPS;
1402 *duplex = FDX_CAPABLE_HALF_SELECTED;
1403
1404 if (status & (MII_NWAY_TX | MII_NWAY_TX_FDX))
1405 *speed = HW_SPEED_100_MBPS;
1406 if (status & ( MII_NWAY_TX_FDX | MII_NWAY_T_FDX))
1407 *duplex = FDX_CAPABLE_FULL_SELECTED;
1408
1409 sis_priv->autong_complete = 1;
1410
1411 if ((phy->phy_id0 == 0x0000) && ((phy->phy_id1 & 0xFFF0) == 0x8200)) {
1412 if (mdio_read(net_dev, phy_addr, MII_CONTROL) & MII_CNTL_FDX)
1413 *duplex = FDX_CAPABLE_FULL_SELECTED;
1414 if (mdio_read(net_dev, phy_addr, 0x0019) & 0x01)
1415 *speed = HW_SPEED_100_MBPS;
1416 }
1417
1418 if(netif_msg_link(sis_priv))
1419 printk(KERN_INFO "%s: Media Link On %s %s-duplex\n",
1420 net_dev->name,
1421 *speed == HW_SPEED_100_MBPS ?
1422 "100mbps" : "10mbps",
1423 *duplex == FDX_CAPABLE_FULL_SELECTED ?
1424 "full" : "half");
1425 }
1426
1427 /**
1428 * sis900_tx_timeout - sis900 transmit timeout routine
1429 * @net_dev: the net device to transmit
1430 *
1431 * print transmit timeout status
1432 * disable interrupts and do some tasks
1433 */
1434
1435 static void sis900_tx_timeout(struct net_device *net_dev)
1436 {
1437 struct sis900_private *sis_priv = netdev_priv(net_dev);
1438 long ioaddr = net_dev->base_addr;
1439 unsigned long flags;
1440 int i;
1441
1442 if(netif_msg_tx_err(sis_priv))
1443 printk(KERN_INFO "%s: Transmit timeout, status %8.8x %8.8x\n",
1444 net_dev->name, inl(ioaddr + cr), inl(ioaddr + isr));
1445
1446 /* Disable interrupts by clearing the interrupt mask. */
1447 outl(0x0000, ioaddr + imr);
1448
1449 /* use spinlock to prevent interrupt handler accessing buffer ring */
1450 spin_lock_irqsave(&sis_priv->lock, flags);
1451
1452 /* discard unsent packets */
1453 sis_priv->dirty_tx = sis_priv->cur_tx = 0;
1454 for (i = 0; i < NUM_TX_DESC; i++) {
1455 struct sk_buff *skb = sis_priv->tx_skbuff[i];
1456
1457 if (skb) {
1458 pci_unmap_single(sis_priv->pci_dev,
1459 sis_priv->tx_ring[i].bufptr, skb->len,
1460 PCI_DMA_TODEVICE);
1461 dev_kfree_skb_irq(skb);
1462 sis_priv->tx_skbuff[i] = NULL;
1463 sis_priv->tx_ring[i].cmdsts = 0;
1464 sis_priv->tx_ring[i].bufptr = 0;
1465 net_dev->stats.tx_dropped++;
1466 }
1467 }
1468 sis_priv->tx_full = 0;
1469 netif_wake_queue(net_dev);
1470
1471 spin_unlock_irqrestore(&sis_priv->lock, flags);
1472
1473 net_dev->trans_start = jiffies; /* prevent tx timeout */
1474
1475 /* load Transmit Descriptor Register */
1476 outl(sis_priv->tx_ring_dma, ioaddr + txdp);
1477
1478 /* Enable all known interrupts by setting the interrupt mask. */
1479 outl((RxSOVR|RxORN|RxERR|RxOK|TxURN|TxERR|TxIDLE), ioaddr + imr);
1480 }
1481
1482 /**
1483 * sis900_start_xmit - sis900 start transmit routine
1484 * @skb: socket buffer pointer to put the data being transmitted
1485 * @net_dev: the net device to transmit with
1486 *
1487 * Set the transmit buffer descriptor,
1488 * and write TxENA to enable transmit state machine.
1489 * tell upper layer if the buffer is full
1490 */
1491
1492 static netdev_tx_t
1493 sis900_start_xmit(struct sk_buff *skb, struct net_device *net_dev)
1494 {
1495 struct sis900_private *sis_priv = netdev_priv(net_dev);
1496 long ioaddr = net_dev->base_addr;
1497 unsigned int entry;
1498 unsigned long flags;
1499 unsigned int index_cur_tx, index_dirty_tx;
1500 unsigned int count_dirty_tx;
1501
1502 /* Don't transmit data before the complete of auto-negotiation */
1503 if(!sis_priv->autong_complete){
1504 netif_stop_queue(net_dev);
1505 return NETDEV_TX_BUSY;
1506 }
1507
1508 spin_lock_irqsave(&sis_priv->lock, flags);
1509
1510 /* Calculate the next Tx descriptor entry. */
1511 entry = sis_priv->cur_tx % NUM_TX_DESC;
1512 sis_priv->tx_skbuff[entry] = skb;
1513
1514 /* set the transmit buffer descriptor and enable Transmit State Machine */
1515 sis_priv->tx_ring[entry].bufptr = pci_map_single(sis_priv->pci_dev,
1516 skb->data, skb->len, PCI_DMA_TODEVICE);
1517 sis_priv->tx_ring[entry].cmdsts = (OWN | skb->len);
1518 outl(TxENA | inl(ioaddr + cr), ioaddr + cr);
1519
1520 sis_priv->cur_tx ++;
1521 index_cur_tx = sis_priv->cur_tx;
1522 index_dirty_tx = sis_priv->dirty_tx;
1523
1524 for (count_dirty_tx = 0; index_cur_tx != index_dirty_tx; index_dirty_tx++)
1525 count_dirty_tx ++;
1526
1527 if (index_cur_tx == index_dirty_tx) {
1528 /* dirty_tx is met in the cycle of cur_tx, buffer full */
1529 sis_priv->tx_full = 1;
1530 netif_stop_queue(net_dev);
1531 } else if (count_dirty_tx < NUM_TX_DESC) {
1532 /* Typical path, tell upper layer that more transmission is possible */
1533 netif_start_queue(net_dev);
1534 } else {
1535 /* buffer full, tell upper layer no more transmission */
1536 sis_priv->tx_full = 1;
1537 netif_stop_queue(net_dev);
1538 }
1539
1540 spin_unlock_irqrestore(&sis_priv->lock, flags);
1541
1542 if (netif_msg_tx_queued(sis_priv))
1543 printk(KERN_DEBUG "%s: Queued Tx packet at %p size %d "
1544 "to slot %d.\n",
1545 net_dev->name, skb->data, (int)skb->len, entry);
1546
1547 return NETDEV_TX_OK;
1548 }
1549
1550 /**
1551 * sis900_interrupt - sis900 interrupt handler
1552 * @irq: the irq number
1553 * @dev_instance: the client data object
1554 *
1555 * The interrupt handler does all of the Rx thread work,
1556 * and cleans up after the Tx thread
1557 */
1558
1559 static irqreturn_t sis900_interrupt(int irq, void *dev_instance)
1560 {
1561 struct net_device *net_dev = dev_instance;
1562 struct sis900_private *sis_priv = netdev_priv(net_dev);
1563 int boguscnt = max_interrupt_work;
1564 long ioaddr = net_dev->base_addr;
1565 u32 status;
1566 unsigned int handled = 0;
1567
1568 spin_lock (&sis_priv->lock);
1569
1570 do {
1571 status = inl(ioaddr + isr);
1572
1573 if ((status & (HIBERR|TxURN|TxERR|TxIDLE|RxORN|RxERR|RxOK)) == 0)
1574 /* nothing intresting happened */
1575 break;
1576 handled = 1;
1577
1578 /* why dow't we break after Tx/Rx case ?? keyword: full-duplex */
1579 if (status & (RxORN | RxERR | RxOK))
1580 /* Rx interrupt */
1581 sis900_rx(net_dev);
1582
1583 if (status & (TxURN | TxERR | TxIDLE))
1584 /* Tx interrupt */
1585 sis900_finish_xmit(net_dev);
1586
1587 /* something strange happened !!! */
1588 if (status & HIBERR) {
1589 if(netif_msg_intr(sis_priv))
1590 printk(KERN_INFO "%s: Abnormal interrupt, "
1591 "status %#8.8x.\n", net_dev->name, status);
1592 break;
1593 }
1594 if (--boguscnt < 0) {
1595 if(netif_msg_intr(sis_priv))
1596 printk(KERN_INFO "%s: Too much work at interrupt, "
1597 "interrupt status = %#8.8x.\n",
1598 net_dev->name, status);
1599 break;
1600 }
1601 } while (1);
1602
1603 if(netif_msg_intr(sis_priv))
1604 printk(KERN_DEBUG "%s: exiting interrupt, "
1605 "interrupt status = 0x%#8.8x.\n",
1606 net_dev->name, inl(ioaddr + isr));
1607
1608 spin_unlock (&sis_priv->lock);
1609 return IRQ_RETVAL(handled);
1610 }
1611
1612 /**
1613 * sis900_rx - sis900 receive routine
1614 * @net_dev: the net device which receives data
1615 *
1616 * Process receive interrupt events,
1617 * put buffer to higher layer and refill buffer pool
1618 * Note: This function is called by interrupt handler,
1619 * don't do "too much" work here
1620 */
1621
1622 static int sis900_rx(struct net_device *net_dev)
1623 {
1624 struct sis900_private *sis_priv = netdev_priv(net_dev);
1625 long ioaddr = net_dev->base_addr;
1626 unsigned int entry = sis_priv->cur_rx % NUM_RX_DESC;
1627 u32 rx_status = sis_priv->rx_ring[entry].cmdsts;
1628 int rx_work_limit;
1629
1630 if (netif_msg_rx_status(sis_priv))
1631 printk(KERN_DEBUG "sis900_rx, cur_rx:%4.4d, dirty_rx:%4.4d "
1632 "status:0x%8.8x\n",
1633 sis_priv->cur_rx, sis_priv->dirty_rx, rx_status);
1634 rx_work_limit = sis_priv->dirty_rx + NUM_RX_DESC - sis_priv->cur_rx;
1635
1636 while (rx_status & OWN) {
1637 unsigned int rx_size;
1638 unsigned int data_size;
1639
1640 if (--rx_work_limit < 0)
1641 break;
1642
1643 data_size = rx_status & DSIZE;
1644 rx_size = data_size - CRC_SIZE;
1645
1646 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
1647 /* ``TOOLONG'' flag means jumbo packet recived. */
1648 if ((rx_status & TOOLONG) && data_size <= MAX_FRAME_SIZE)
1649 rx_status &= (~ ((unsigned int)TOOLONG));
1650 #endif
1651
1652 if (rx_status & (ABORT|OVERRUN|TOOLONG|RUNT|RXISERR|CRCERR|FAERR)) {
1653 /* corrupted packet received */
1654 if (netif_msg_rx_err(sis_priv))
1655 printk(KERN_DEBUG "%s: Corrupted packet "
1656 "received, buffer status = 0x%8.8x/%d.\n",
1657 net_dev->name, rx_status, data_size);
1658 net_dev->stats.rx_errors++;
1659 if (rx_status & OVERRUN)
1660 net_dev->stats.rx_over_errors++;
1661 if (rx_status & (TOOLONG|RUNT))
1662 net_dev->stats.rx_length_errors++;
1663 if (rx_status & (RXISERR | FAERR))
1664 net_dev->stats.rx_frame_errors++;
1665 if (rx_status & CRCERR)
1666 net_dev->stats.rx_crc_errors++;
1667 /* reset buffer descriptor state */
1668 sis_priv->rx_ring[entry].cmdsts = RX_BUF_SIZE;
1669 } else {
1670 struct sk_buff * skb;
1671 struct sk_buff * rx_skb;
1672
1673 pci_unmap_single(sis_priv->pci_dev,
1674 sis_priv->rx_ring[entry].bufptr, RX_BUF_SIZE,
1675 PCI_DMA_FROMDEVICE);
1676
1677 /* refill the Rx buffer, what if there is not enough
1678 * memory for new socket buffer ?? */
1679 if ((skb = dev_alloc_skb(RX_BUF_SIZE)) == NULL) {
1680 /*
1681 * Not enough memory to refill the buffer
1682 * so we need to recycle the old one so
1683 * as to avoid creating a memory hole
1684 * in the rx ring
1685 */
1686 skb = sis_priv->rx_skbuff[entry];
1687 net_dev->stats.rx_dropped++;
1688 goto refill_rx_ring;
1689 }
1690
1691 /* This situation should never happen, but due to
1692 some unknown bugs, it is possible that
1693 we are working on NULL sk_buff :-( */
1694 if (sis_priv->rx_skbuff[entry] == NULL) {
1695 if (netif_msg_rx_err(sis_priv))
1696 printk(KERN_WARNING "%s: NULL pointer "
1697 "encountered in Rx ring\n"
1698 "cur_rx:%4.4d, dirty_rx:%4.4d\n",
1699 net_dev->name, sis_priv->cur_rx,
1700 sis_priv->dirty_rx);
1701 break;
1702 }
1703
1704 /* give the socket buffer to upper layers */
1705 rx_skb = sis_priv->rx_skbuff[entry];
1706 skb_put(rx_skb, rx_size);
1707 rx_skb->protocol = eth_type_trans(rx_skb, net_dev);
1708 netif_rx(rx_skb);
1709
1710 /* some network statistics */
1711 if ((rx_status & BCAST) == MCAST)
1712 net_dev->stats.multicast++;
1713 net_dev->stats.rx_bytes += rx_size;
1714 net_dev->stats.rx_packets++;
1715 sis_priv->dirty_rx++;
1716 refill_rx_ring:
1717 sis_priv->rx_skbuff[entry] = skb;
1718 sis_priv->rx_ring[entry].cmdsts = RX_BUF_SIZE;
1719 sis_priv->rx_ring[entry].bufptr =
1720 pci_map_single(sis_priv->pci_dev, skb->data,
1721 RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
1722 }
1723 sis_priv->cur_rx++;
1724 entry = sis_priv->cur_rx % NUM_RX_DESC;
1725 rx_status = sis_priv->rx_ring[entry].cmdsts;
1726 } // while
1727
1728 /* refill the Rx buffer, what if the rate of refilling is slower
1729 * than consuming ?? */
1730 for (; sis_priv->cur_rx != sis_priv->dirty_rx; sis_priv->dirty_rx++) {
1731 struct sk_buff *skb;
1732
1733 entry = sis_priv->dirty_rx % NUM_RX_DESC;
1734
1735 if (sis_priv->rx_skbuff[entry] == NULL) {
1736 if ((skb = dev_alloc_skb(RX_BUF_SIZE)) == NULL) {
1737 /* not enough memory for skbuff, this makes a
1738 * "hole" on the buffer ring, it is not clear
1739 * how the hardware will react to this kind
1740 * of degenerated buffer */
1741 if (netif_msg_rx_err(sis_priv))
1742 printk(KERN_INFO "%s: Memory squeeze, "
1743 "deferring packet.\n",
1744 net_dev->name);
1745 net_dev->stats.rx_dropped++;
1746 break;
1747 }
1748 sis_priv->rx_skbuff[entry] = skb;
1749 sis_priv->rx_ring[entry].cmdsts = RX_BUF_SIZE;
1750 sis_priv->rx_ring[entry].bufptr =
1751 pci_map_single(sis_priv->pci_dev, skb->data,
1752 RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
1753 }
1754 }
1755 /* re-enable the potentially idle receive state matchine */
1756 outl(RxENA | inl(ioaddr + cr), ioaddr + cr );
1757
1758 return 0;
1759 }
1760
1761 /**
1762 * sis900_finish_xmit - finish up transmission of packets
1763 * @net_dev: the net device to be transmitted on
1764 *
1765 * Check for error condition and free socket buffer etc
1766 * schedule for more transmission as needed
1767 * Note: This function is called by interrupt handler,
1768 * don't do "too much" work here
1769 */
1770
1771 static void sis900_finish_xmit (struct net_device *net_dev)
1772 {
1773 struct sis900_private *sis_priv = netdev_priv(net_dev);
1774
1775 for (; sis_priv->dirty_tx != sis_priv->cur_tx; sis_priv->dirty_tx++) {
1776 struct sk_buff *skb;
1777 unsigned int entry;
1778 u32 tx_status;
1779
1780 entry = sis_priv->dirty_tx % NUM_TX_DESC;
1781 tx_status = sis_priv->tx_ring[entry].cmdsts;
1782
1783 if (tx_status & OWN) {
1784 /* The packet is not transmitted yet (owned by hardware) !
1785 * Note: the interrupt is generated only when Tx Machine
1786 * is idle, so this is an almost impossible case */
1787 break;
1788 }
1789
1790 if (tx_status & (ABORT | UNDERRUN | OWCOLL)) {
1791 /* packet unsuccessfully transmitted */
1792 if (netif_msg_tx_err(sis_priv))
1793 printk(KERN_DEBUG "%s: Transmit "
1794 "error, Tx status %8.8x.\n",
1795 net_dev->name, tx_status);
1796 net_dev->stats.tx_errors++;
1797 if (tx_status & UNDERRUN)
1798 net_dev->stats.tx_fifo_errors++;
1799 if (tx_status & ABORT)
1800 net_dev->stats.tx_aborted_errors++;
1801 if (tx_status & NOCARRIER)
1802 net_dev->stats.tx_carrier_errors++;
1803 if (tx_status & OWCOLL)
1804 net_dev->stats.tx_window_errors++;
1805 } else {
1806 /* packet successfully transmitted */
1807 net_dev->stats.collisions += (tx_status & COLCNT) >> 16;
1808 net_dev->stats.tx_bytes += tx_status & DSIZE;
1809 net_dev->stats.tx_packets++;
1810 }
1811 /* Free the original skb. */
1812 skb = sis_priv->tx_skbuff[entry];
1813 pci_unmap_single(sis_priv->pci_dev,
1814 sis_priv->tx_ring[entry].bufptr, skb->len,
1815 PCI_DMA_TODEVICE);
1816 dev_kfree_skb_irq(skb);
1817 sis_priv->tx_skbuff[entry] = NULL;
1818 sis_priv->tx_ring[entry].bufptr = 0;
1819 sis_priv->tx_ring[entry].cmdsts = 0;
1820 }
1821
1822 if (sis_priv->tx_full && netif_queue_stopped(net_dev) &&
1823 sis_priv->cur_tx - sis_priv->dirty_tx < NUM_TX_DESC - 4) {
1824 /* The ring is no longer full, clear tx_full and schedule
1825 * more transmission by netif_wake_queue(net_dev) */
1826 sis_priv->tx_full = 0;
1827 netif_wake_queue (net_dev);
1828 }
1829 }
1830
1831 /**
1832 * sis900_close - close sis900 device
1833 * @net_dev: the net device to be closed
1834 *
1835 * Disable interrupts, stop the Tx and Rx Status Machine
1836 * free Tx and RX socket buffer
1837 */
1838
1839 static int sis900_close(struct net_device *net_dev)
1840 {
1841 long ioaddr = net_dev->base_addr;
1842 struct sis900_private *sis_priv = netdev_priv(net_dev);
1843 struct sk_buff *skb;
1844 int i;
1845
1846 netif_stop_queue(net_dev);
1847
1848 /* Disable interrupts by clearing the interrupt mask. */
1849 outl(0x0000, ioaddr + imr);
1850 outl(0x0000, ioaddr + ier);
1851
1852 /* Stop the chip's Tx and Rx Status Machine */
1853 outl(RxDIS | TxDIS | inl(ioaddr + cr), ioaddr + cr);
1854
1855 del_timer(&sis_priv->timer);
1856
1857 free_irq(net_dev->irq, net_dev);
1858
1859 /* Free Tx and RX skbuff */
1860 for (i = 0; i < NUM_RX_DESC; i++) {
1861 skb = sis_priv->rx_skbuff[i];
1862 if (skb) {
1863 pci_unmap_single(sis_priv->pci_dev,
1864 sis_priv->rx_ring[i].bufptr,
1865 RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
1866 dev_kfree_skb(skb);
1867 sis_priv->rx_skbuff[i] = NULL;
1868 }
1869 }
1870 for (i = 0; i < NUM_TX_DESC; i++) {
1871 skb = sis_priv->tx_skbuff[i];
1872 if (skb) {
1873 pci_unmap_single(sis_priv->pci_dev,
1874 sis_priv->tx_ring[i].bufptr, skb->len,
1875 PCI_DMA_TODEVICE);
1876 dev_kfree_skb(skb);
1877 sis_priv->tx_skbuff[i] = NULL;
1878 }
1879 }
1880
1881 /* Green! Put the chip in low-power mode. */
1882
1883 return 0;
1884 }
1885
1886 /**
1887 * sis900_get_drvinfo - Return information about driver
1888 * @net_dev: the net device to probe
1889 * @info: container for info returned
1890 *
1891 * Process ethtool command such as "ehtool -i" to show information
1892 */
1893
1894 static void sis900_get_drvinfo(struct net_device *net_dev,
1895 struct ethtool_drvinfo *info)
1896 {
1897 struct sis900_private *sis_priv = netdev_priv(net_dev);
1898
1899 strcpy (info->driver, SIS900_MODULE_NAME);
1900 strcpy (info->version, SIS900_DRV_VERSION);
1901 strcpy (info->bus_info, pci_name(sis_priv->pci_dev));
1902 }
1903
1904 static u32 sis900_get_msglevel(struct net_device *net_dev)
1905 {
1906 struct sis900_private *sis_priv = netdev_priv(net_dev);
1907 return sis_priv->msg_enable;
1908 }
1909
1910 static void sis900_set_msglevel(struct net_device *net_dev, u32 value)
1911 {
1912 struct sis900_private *sis_priv = netdev_priv(net_dev);
1913 sis_priv->msg_enable = value;
1914 }
1915
1916 static u32 sis900_get_link(struct net_device *net_dev)
1917 {
1918 struct sis900_private *sis_priv = netdev_priv(net_dev);
1919 return mii_link_ok(&sis_priv->mii_info);
1920 }
1921
1922 static int sis900_get_settings(struct net_device *net_dev,
1923 struct ethtool_cmd *cmd)
1924 {
1925 struct sis900_private *sis_priv = netdev_priv(net_dev);
1926 spin_lock_irq(&sis_priv->lock);
1927 mii_ethtool_gset(&sis_priv->mii_info, cmd);
1928 spin_unlock_irq(&sis_priv->lock);
1929 return 0;
1930 }
1931
1932 static int sis900_set_settings(struct net_device *net_dev,
1933 struct ethtool_cmd *cmd)
1934 {
1935 struct sis900_private *sis_priv = netdev_priv(net_dev);
1936 int rt;
1937 spin_lock_irq(&sis_priv->lock);
1938 rt = mii_ethtool_sset(&sis_priv->mii_info, cmd);
1939 spin_unlock_irq(&sis_priv->lock);
1940 return rt;
1941 }
1942
1943 static int sis900_nway_reset(struct net_device *net_dev)
1944 {
1945 struct sis900_private *sis_priv = netdev_priv(net_dev);
1946 return mii_nway_restart(&sis_priv->mii_info);
1947 }
1948
1949 /**
1950 * sis900_set_wol - Set up Wake on Lan registers
1951 * @net_dev: the net device to probe
1952 * @wol: container for info passed to the driver
1953 *
1954 * Process ethtool command "wol" to setup wake on lan features.
1955 * SiS900 supports sending WoL events if a correct packet is received,
1956 * but there is no simple way to filter them to only a subset (broadcast,
1957 * multicast, unicast or arp).
1958 */
1959
1960 static int sis900_set_wol(struct net_device *net_dev, struct ethtool_wolinfo *wol)
1961 {
1962 struct sis900_private *sis_priv = netdev_priv(net_dev);
1963 long pmctrl_addr = net_dev->base_addr + pmctrl;
1964 u32 cfgpmcsr = 0, pmctrl_bits = 0;
1965
1966 if (wol->wolopts == 0) {
1967 pci_read_config_dword(sis_priv->pci_dev, CFGPMCSR, &cfgpmcsr);
1968 cfgpmcsr &= ~PME_EN;
1969 pci_write_config_dword(sis_priv->pci_dev, CFGPMCSR, cfgpmcsr);
1970 outl(pmctrl_bits, pmctrl_addr);
1971 if (netif_msg_wol(sis_priv))
1972 printk(KERN_DEBUG "%s: Wake on LAN disabled\n", net_dev->name);
1973 return 0;
1974 }
1975
1976 if (wol->wolopts & (WAKE_MAGICSECURE | WAKE_UCAST | WAKE_MCAST
1977 | WAKE_BCAST | WAKE_ARP))
1978 return -EINVAL;
1979
1980 if (wol->wolopts & WAKE_MAGIC)
1981 pmctrl_bits |= MAGICPKT;
1982 if (wol->wolopts & WAKE_PHY)
1983 pmctrl_bits |= LINKON;
1984
1985 outl(pmctrl_bits, pmctrl_addr);
1986
1987 pci_read_config_dword(sis_priv->pci_dev, CFGPMCSR, &cfgpmcsr);
1988 cfgpmcsr |= PME_EN;
1989 pci_write_config_dword(sis_priv->pci_dev, CFGPMCSR, cfgpmcsr);
1990 if (netif_msg_wol(sis_priv))
1991 printk(KERN_DEBUG "%s: Wake on LAN enabled\n", net_dev->name);
1992
1993 return 0;
1994 }
1995
1996 static void sis900_get_wol(struct net_device *net_dev, struct ethtool_wolinfo *wol)
1997 {
1998 long pmctrl_addr = net_dev->base_addr + pmctrl;
1999 u32 pmctrl_bits;
2000
2001 pmctrl_bits = inl(pmctrl_addr);
2002 if (pmctrl_bits & MAGICPKT)
2003 wol->wolopts |= WAKE_MAGIC;
2004 if (pmctrl_bits & LINKON)
2005 wol->wolopts |= WAKE_PHY;
2006
2007 wol->supported = (WAKE_PHY | WAKE_MAGIC);
2008 }
2009
2010 static const struct ethtool_ops sis900_ethtool_ops = {
2011 .get_drvinfo = sis900_get_drvinfo,
2012 .get_msglevel = sis900_get_msglevel,
2013 .set_msglevel = sis900_set_msglevel,
2014 .get_link = sis900_get_link,
2015 .get_settings = sis900_get_settings,
2016 .set_settings = sis900_set_settings,
2017 .nway_reset = sis900_nway_reset,
2018 .get_wol = sis900_get_wol,
2019 .set_wol = sis900_set_wol
2020 };
2021
2022 /**
2023 * mii_ioctl - process MII i/o control command
2024 * @net_dev: the net device to command for
2025 * @rq: parameter for command
2026 * @cmd: the i/o command
2027 *
2028 * Process MII command like read/write MII register
2029 */
2030
2031 static int mii_ioctl(struct net_device *net_dev, struct ifreq *rq, int cmd)
2032 {
2033 struct sis900_private *sis_priv = netdev_priv(net_dev);
2034 struct mii_ioctl_data *data = if_mii(rq);
2035
2036 switch(cmd) {
2037 case SIOCGMIIPHY: /* Get address of MII PHY in use. */
2038 data->phy_id = sis_priv->mii->phy_addr;
2039 /* Fall Through */
2040
2041 case SIOCGMIIREG: /* Read MII PHY register. */
2042 data->val_out = mdio_read(net_dev, data->phy_id & 0x1f, data->reg_num & 0x1f);
2043 return 0;
2044
2045 case SIOCSMIIREG: /* Write MII PHY register. */
2046 mdio_write(net_dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
2047 return 0;
2048 default:
2049 return -EOPNOTSUPP;
2050 }
2051 }
2052
2053 /**
2054 * sis900_set_config - Set media type by net_device.set_config
2055 * @dev: the net device for media type change
2056 * @map: ifmap passed by ifconfig
2057 *
2058 * Set media type to 10baseT, 100baseT or 0(for auto) by ifconfig
2059 * we support only port changes. All other runtime configuration
2060 * changes will be ignored
2061 */
2062
2063 static int sis900_set_config(struct net_device *dev, struct ifmap *map)
2064 {
2065 struct sis900_private *sis_priv = netdev_priv(dev);
2066 struct mii_phy *mii_phy = sis_priv->mii;
2067
2068 u16 status;
2069
2070 if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
2071 /* we switch on the ifmap->port field. I couldn't find anything
2072 * like a definition or standard for the values of that field.
2073 * I think the meaning of those values is device specific. But
2074 * since I would like to change the media type via the ifconfig
2075 * command I use the definition from linux/netdevice.h
2076 * (which seems to be different from the ifport(pcmcia) definition) */
2077 switch(map->port){
2078 case IF_PORT_UNKNOWN: /* use auto here */
2079 dev->if_port = map->port;
2080 /* we are going to change the media type, so the Link
2081 * will be temporary down and we need to reflect that
2082 * here. When the Link comes up again, it will be
2083 * sensed by the sis_timer procedure, which also does
2084 * all the rest for us */
2085 netif_carrier_off(dev);
2086
2087 /* read current state */
2088 status = mdio_read(dev, mii_phy->phy_addr, MII_CONTROL);
2089
2090 /* enable auto negotiation and reset the negotioation
2091 * (I don't really know what the auto negatiotiation
2092 * reset really means, but it sounds for me right to
2093 * do one here) */
2094 mdio_write(dev, mii_phy->phy_addr,
2095 MII_CONTROL, status | MII_CNTL_AUTO | MII_CNTL_RST_AUTO);
2096
2097 break;
2098
2099 case IF_PORT_10BASET: /* 10BaseT */
2100 dev->if_port = map->port;
2101
2102 /* we are going to change the media type, so the Link
2103 * will be temporary down and we need to reflect that
2104 * here. When the Link comes up again, it will be
2105 * sensed by the sis_timer procedure, which also does
2106 * all the rest for us */
2107 netif_carrier_off(dev);
2108
2109 /* set Speed to 10Mbps */
2110 /* read current state */
2111 status = mdio_read(dev, mii_phy->phy_addr, MII_CONTROL);
2112
2113 /* disable auto negotiation and force 10MBit mode*/
2114 mdio_write(dev, mii_phy->phy_addr,
2115 MII_CONTROL, status & ~(MII_CNTL_SPEED |
2116 MII_CNTL_AUTO));
2117 break;
2118
2119 case IF_PORT_100BASET: /* 100BaseT */
2120 case IF_PORT_100BASETX: /* 100BaseTx */
2121 dev->if_port = map->port;
2122
2123 /* we are going to change the media type, so the Link
2124 * will be temporary down and we need to reflect that
2125 * here. When the Link comes up again, it will be
2126 * sensed by the sis_timer procedure, which also does
2127 * all the rest for us */
2128 netif_carrier_off(dev);
2129
2130 /* set Speed to 100Mbps */
2131 /* disable auto negotiation and enable 100MBit Mode */
2132 status = mdio_read(dev, mii_phy->phy_addr, MII_CONTROL);
2133 mdio_write(dev, mii_phy->phy_addr,
2134 MII_CONTROL, (status & ~MII_CNTL_SPEED) |
2135 MII_CNTL_SPEED);
2136
2137 break;
2138
2139 case IF_PORT_10BASE2: /* 10Base2 */
2140 case IF_PORT_AUI: /* AUI */
2141 case IF_PORT_100BASEFX: /* 100BaseFx */
2142 /* These Modes are not supported (are they?)*/
2143 return -EOPNOTSUPP;
2144 break;
2145
2146 default:
2147 return -EINVAL;
2148 }
2149 }
2150 return 0;
2151 }
2152
2153 /**
2154 * sis900_mcast_bitnr - compute hashtable index
2155 * @addr: multicast address
2156 * @revision: revision id of chip
2157 *
2158 * SiS 900 uses the most sigificant 7 bits to index a 128 bits multicast
2159 * hash table, which makes this function a little bit different from other drivers
2160 * SiS 900 B0 & 635 M/B uses the most significat 8 bits to index 256 bits
2161 * multicast hash table.
2162 */
2163
2164 static inline u16 sis900_mcast_bitnr(u8 *addr, u8 revision)
2165 {
2166
2167 u32 crc = ether_crc(6, addr);
2168
2169 /* leave 8 or 7 most siginifant bits */
2170 if ((revision >= SIS635A_900_REV) || (revision == SIS900B_900_REV))
2171 return ((int)(crc >> 24));
2172 else
2173 return ((int)(crc >> 25));
2174 }
2175
2176 /**
2177 * set_rx_mode - Set SiS900 receive mode
2178 * @net_dev: the net device to be set
2179 *
2180 * Set SiS900 receive mode for promiscuous, multicast, or broadcast mode.
2181 * And set the appropriate multicast filter.
2182 * Multicast hash table changes from 128 to 256 bits for 635M/B & 900B0.
2183 */
2184
2185 static void set_rx_mode(struct net_device *net_dev)
2186 {
2187 long ioaddr = net_dev->base_addr;
2188 struct sis900_private *sis_priv = netdev_priv(net_dev);
2189 u16 mc_filter[16] = {0}; /* 256/128 bits multicast hash table */
2190 int i, table_entries;
2191 u32 rx_mode;
2192
2193 /* 635 Hash Table entries = 256(2^16) */
2194 if((sis_priv->chipset_rev >= SIS635A_900_REV) ||
2195 (sis_priv->chipset_rev == SIS900B_900_REV))
2196 table_entries = 16;
2197 else
2198 table_entries = 8;
2199
2200 if (net_dev->flags & IFF_PROMISC) {
2201 /* Accept any kinds of packets */
2202 rx_mode = RFPromiscuous;
2203 for (i = 0; i < table_entries; i++)
2204 mc_filter[i] = 0xffff;
2205 } else if ((netdev_mc_count(net_dev) > multicast_filter_limit) ||
2206 (net_dev->flags & IFF_ALLMULTI)) {
2207 /* too many multicast addresses or accept all multicast packet */
2208 rx_mode = RFAAB | RFAAM;
2209 for (i = 0; i < table_entries; i++)
2210 mc_filter[i] = 0xffff;
2211 } else {
2212 /* Accept Broadcast packet, destination address matchs our
2213 * MAC address, use Receive Filter to reject unwanted MCAST
2214 * packets */
2215 struct netdev_hw_addr *ha;
2216 rx_mode = RFAAB;
2217
2218 netdev_for_each_mc_addr(ha, net_dev) {
2219 unsigned int bit_nr;
2220
2221 bit_nr = sis900_mcast_bitnr(ha->addr,
2222 sis_priv->chipset_rev);
2223 mc_filter[bit_nr >> 4] |= (1 << (bit_nr & 0xf));
2224 }
2225 }
2226
2227 /* update Multicast Hash Table in Receive Filter */
2228 for (i = 0; i < table_entries; i++) {
2229 /* why plus 0x04 ??, That makes the correct value for hash table. */
2230 outl((u32)(0x00000004+i) << RFADDR_shift, ioaddr + rfcr);
2231 outl(mc_filter[i], ioaddr + rfdr);
2232 }
2233
2234 outl(RFEN | rx_mode, ioaddr + rfcr);
2235
2236 /* sis900 is capable of looping back packets at MAC level for
2237 * debugging purpose */
2238 if (net_dev->flags & IFF_LOOPBACK) {
2239 u32 cr_saved;
2240 /* We must disable Tx/Rx before setting loopback mode */
2241 cr_saved = inl(ioaddr + cr);
2242 outl(cr_saved | TxDIS | RxDIS, ioaddr + cr);
2243 /* enable loopback */
2244 outl(inl(ioaddr + txcfg) | TxMLB, ioaddr + txcfg);
2245 outl(inl(ioaddr + rxcfg) | RxATX, ioaddr + rxcfg);
2246 /* restore cr */
2247 outl(cr_saved, ioaddr + cr);
2248 }
2249 }
2250
2251 /**
2252 * sis900_reset - Reset sis900 MAC
2253 * @net_dev: the net device to reset
2254 *
2255 * reset sis900 MAC and wait until finished
2256 * reset through command register
2257 * change backoff algorithm for 900B0 & 635 M/B
2258 */
2259
2260 static void sis900_reset(struct net_device *net_dev)
2261 {
2262 struct sis900_private *sis_priv = netdev_priv(net_dev);
2263 long ioaddr = net_dev->base_addr;
2264 int i = 0;
2265 u32 status = TxRCMP | RxRCMP;
2266
2267 outl(0, ioaddr + ier);
2268 outl(0, ioaddr + imr);
2269 outl(0, ioaddr + rfcr);
2270
2271 outl(RxRESET | TxRESET | RESET | inl(ioaddr + cr), ioaddr + cr);
2272
2273 /* Check that the chip has finished the reset. */
2274 while (status && (i++ < 1000)) {
2275 status ^= (inl(isr + ioaddr) & status);
2276 }
2277
2278 if( (sis_priv->chipset_rev >= SIS635A_900_REV) ||
2279 (sis_priv->chipset_rev == SIS900B_900_REV) )
2280 outl(PESEL | RND_CNT, ioaddr + cfg);
2281 else
2282 outl(PESEL, ioaddr + cfg);
2283 }
2284
2285 /**
2286 * sis900_remove - Remove sis900 device
2287 * @pci_dev: the pci device to be removed
2288 *
2289 * remove and release SiS900 net device
2290 */
2291
2292 static void __devexit sis900_remove(struct pci_dev *pci_dev)
2293 {
2294 struct net_device *net_dev = pci_get_drvdata(pci_dev);
2295 struct sis900_private *sis_priv = netdev_priv(net_dev);
2296 struct mii_phy *phy = NULL;
2297
2298 while (sis_priv->first_mii) {
2299 phy = sis_priv->first_mii;
2300 sis_priv->first_mii = phy->next;
2301 kfree(phy);
2302 }
2303
2304 pci_free_consistent(pci_dev, RX_TOTAL_SIZE, sis_priv->rx_ring,
2305 sis_priv->rx_ring_dma);
2306 pci_free_consistent(pci_dev, TX_TOTAL_SIZE, sis_priv->tx_ring,
2307 sis_priv->tx_ring_dma);
2308 unregister_netdev(net_dev);
2309 free_netdev(net_dev);
2310 pci_release_regions(pci_dev);
2311 pci_set_drvdata(pci_dev, NULL);
2312 }
2313
2314 #ifdef CONFIG_PM
2315
2316 static int sis900_suspend(struct pci_dev *pci_dev, pm_message_t state)
2317 {
2318 struct net_device *net_dev = pci_get_drvdata(pci_dev);
2319 long ioaddr = net_dev->base_addr;
2320
2321 if(!netif_running(net_dev))
2322 return 0;
2323
2324 netif_stop_queue(net_dev);
2325 netif_device_detach(net_dev);
2326
2327 /* Stop the chip's Tx and Rx Status Machine */
2328 outl(RxDIS | TxDIS | inl(ioaddr + cr), ioaddr + cr);
2329
2330 pci_set_power_state(pci_dev, PCI_D3hot);
2331 pci_save_state(pci_dev);
2332
2333 return 0;
2334 }
2335
2336 static int sis900_resume(struct pci_dev *pci_dev)
2337 {
2338 struct net_device *net_dev = pci_get_drvdata(pci_dev);
2339 struct sis900_private *sis_priv = netdev_priv(net_dev);
2340 long ioaddr = net_dev->base_addr;
2341
2342 if(!netif_running(net_dev))
2343 return 0;
2344 pci_restore_state(pci_dev);
2345 pci_set_power_state(pci_dev, PCI_D0);
2346
2347 sis900_init_rxfilter(net_dev);
2348
2349 sis900_init_tx_ring(net_dev);
2350 sis900_init_rx_ring(net_dev);
2351
2352 set_rx_mode(net_dev);
2353
2354 netif_device_attach(net_dev);
2355 netif_start_queue(net_dev);
2356
2357 sis900_set_mode(ioaddr, HW_SPEED_10_MBPS, FDX_CAPABLE_HALF_SELECTED);
2358
2359 /* Enable all known interrupts by setting the interrupt mask. */
2360 outl((RxSOVR|RxORN|RxERR|RxOK|TxURN|TxERR|TxIDLE), ioaddr + imr);
2361 outl(RxENA | inl(ioaddr + cr), ioaddr + cr);
2362 outl(IE, ioaddr + ier);
2363
2364 sis900_check_mode(net_dev, sis_priv->mii);
2365
2366 return 0;
2367 }
2368 #endif /* CONFIG_PM */
2369
2370 static struct pci_driver sis900_pci_driver = {
2371 .name = SIS900_MODULE_NAME,
2372 .id_table = sis900_pci_tbl,
2373 .probe = sis900_probe,
2374 .remove = __devexit_p(sis900_remove),
2375 #ifdef CONFIG_PM
2376 .suspend = sis900_suspend,
2377 .resume = sis900_resume,
2378 #endif /* CONFIG_PM */
2379 };
2380
2381 static int __init sis900_init_module(void)
2382 {
2383 /* when a module, this is printed whether or not devices are found in probe */
2384 #ifdef MODULE
2385 printk(version);
2386 #endif
2387
2388 return pci_register_driver(&sis900_pci_driver);
2389 }
2390
2391 static void __exit sis900_cleanup_module(void)
2392 {
2393 pci_unregister_driver(&sis900_pci_driver);
2394 }
2395
2396 module_init(sis900_init_module);
2397 module_exit(sis900_cleanup_module);
Tomato firmware and modifications.