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