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