git.oblomov.eu Git - linux-2.6/blob - drivers/net/sis900.c

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