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