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