开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
sis900.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：65k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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.06 Sep. 24 2002
  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.    http://www.sis.com.tw/support/databook.htm
  21.    Rev 1.08.06 Sep. 24 2002 Mufasa Yang bug fix for Tx timeout & add SiS963 support
  22.    Rev 1.08.05 Jun. 6 2002 Mufasa Yang bug fix for read_eeprom & Tx descriptor over-boundary 
  23.    Rev 1.08.04 Apr. 25 2002 Mufasa Yang <mufasa@sis.com.tw> added SiS962 support
  24.    Rev 1.08.03 Feb. 1 2002 Matt Domsch <Matt_Domsch@dell.com> update to use library crc32 function
  25.    Rev 1.08.02 Nov. 30 2001 Hui-Fen Hsu workaround for EDB & bug fix for dhcp problem
  26.    Rev 1.08.01 Aug. 25 2001 Hui-Fen Hsu update for 630ET & workaround for ICS1893 PHY
  27.    Rev 1.08.00 Jun. 11 2001 Hui-Fen Hsu workaround for RTL8201 PHY and some bug fix
  28.    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
  29.    Rev 1.07.10 Mar.  1 2001 Hui-Fen Hsu <hfhsu@sis.com.tw> some bug fix & 635M/B support 
  30.    Rev 1.07.09 Feb.  9 2001 Dave Jones <davej@suse.de> PCI enable cleanup
  31.    Rev 1.07.08 Jan.  8 2001 Lei-Chun Chang added RTL8201 PHY support
  32.    Rev 1.07.07 Nov. 29 2000 Lei-Chun Chang added kernel-doc extractable documentation and 630 workaround fix
  33.    Rev 1.07.06 Nov.  7 2000 Jeff Garzik <jgarzik@mandrakesoft.com> some bug fix and cleaning
  34.    Rev 1.07.05 Nov.  6 2000 metapirat<metapirat@gmx.de> contribute media type select by ifconfig
  35.    Rev 1.07.04 Sep.  6 2000 Lei-Chun Chang added ICS1893 PHY support
  36.    Rev 1.07.03 Aug. 24 2000 Lei-Chun Chang (lcchang@sis.com.tw) modified 630E eqaulizer workaround rule
  37.    Rev 1.07.01 Aug. 08 2000 Ollie Lho minor update for SiS 630E and SiS 630E A1
  38.    Rev 1.07    Mar. 07 2000 Ollie Lho bug fix in Rx buffer ring
  39.    Rev 1.06.04 Feb. 11 2000 Jeff Garzik <jgarzik@mandrakesoft.com> softnet and init for kernel 2.4
  40.    Rev 1.06.03 Dec. 23 1999 Ollie Lho Third release
  41.    Rev 1.06.02 Nov. 23 1999 Ollie Lho bug in mac probing fixed
  42.    Rev 1.06.01 Nov. 16 1999 Ollie Lho CRC calculation provide by Joseph Zbiciak (im14u2c@primenet.com)
  43.    Rev 1.06 Nov. 4 1999 Ollie Lho (ollie@sis.com.tw) Second release
  44.    Rev 1.05.05 Oct. 29 1999 Ollie Lho (ollie@sis.com.tw) Single buffer Tx/Rx
  45.    Chin-Shan Li (lcs@sis.com.tw) Added AMD Am79c901 HomePNA PHY support
  46.    Rev 1.05 Aug. 7 1999 Jim Huang (cmhuang@sis.com.tw) Initial release
  47. */
  49. #include <linux/module.h>
  50. #include <linux/version.h>
  51. #include <linux/kernel.h>
  52. #include <linux/sched.h>
  53. #include <linux/string.h>
  54. #include <linux/timer.h>
  55. #include <linux/errno.h>
  56. #include <linux/ioport.h>
  57. #include <linux/slab.h>
  58. #include <linux/interrupt.h>
  59. #include <linux/pci.h>
  60. #include <linux/netdevice.h>
  61. #include <linux/init.h>
  62. #include <linux/mii.h>
  63. #include <linux/etherdevice.h>
  64. #include <linux/skbuff.h>
  65. #include <linux/delay.h>
  66. #include <linux/ethtool.h>
  67. #include <linux/crc32.h>
  69. #include <asm/processor.h>      /* Processor type for cache alignment. */
  70. #include <asm/bitops.h>
  71. #include <asm/io.h>
  72. #include <asm/uaccess.h> /* User space memory access functions */
  74. #include "sis900.h"
  76. #define SIS900_MODULE_NAME "sis900"
  77. #define SIS900_DRV_VERSION "v1.08.06 9/24/2002"
  79. static char version[] __devinitdata =
  80. KERN_INFO "sis900.c: " SIS900_DRV_VERSION "n";
  82. static int max_interrupt_work = 40;
  83. static int multicast_filter_limit = 128;
  85. #define sis900_debug debug
  86. static int sis900_debug;
  88. /* Time in jiffies before concluding the transmitter is hung. */
  89. #define TX_TIMEOUT  (4*HZ)
  90. /* SiS 900 is capable of 32 bits BM DMA */
  91. #define SIS900_DMA_MASK 0xffffffff
  93. enum {
  94. SIS_900 = 0,
  95. SIS_7016
  96. };
  97. static char * card_names[] = {
  98. "SiS 900 PCI Fast Ethernet",
  99. "SiS 7016 PCI Fast Ethernet"
  100. };
  101. static struct pci_device_id sis900_pci_tbl [] __devinitdata = {
  102. {PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_900,
  103.  PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_900},
  104. {PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_7016,
  105.  PCI_ANY_ID, PCI_ANY_ID, 0, 0, SIS_7016},
  106. {0,}
  107. };
  108. MODULE_DEVICE_TABLE (pci, sis900_pci_tbl);
  110. static void sis900_read_mode(struct net_device *net_dev, int *speed, int *duplex);
  112. static struct mii_chip_info {
  113. const char * name;
  114. u16 phy_id0;
  115. u16 phy_id1;
  116. u8  phy_types;
  117. #define HOME  0x0001
  118. #define LAN 0x0002
  119. #define MIX 0x0003
  120. } mii_chip_table[] = {
  121. { "SiS 900 Internal MII PHY",  0x001d, 0x8000, LAN },
  122. { "SiS 7014 Physical Layer Solution",  0x0016, 0xf830, LAN },
  123. { "AMD 79C901 10BASE-T PHY",   0x0000, 0x6B70, LAN },
  124. { "AMD 79C901 HomePNA PHY", 0x0000, 0x6B90, HOME},
  125. { "ICS LAN PHY", 0x0015, 0xF440, LAN },
  126. { "NS 83851 PHY", 0x2000, 0x5C20, MIX },
  127. { "Realtek RTL8201 PHY", 0x0000, 0x8200, LAN },
  128. {0,},
  129. };
  131. struct mii_phy {
  132. struct mii_phy * next;
  133. int phy_addr;
  134. u16 phy_id0;
  135. u16 phy_id1;
  136. u16 status;
  137. u8  phy_types;
  138. };
  140. typedef struct _BufferDesc {
  141. u32 link;
  142. u32 cmdsts;
  143. u32 bufptr;
  144. } BufferDesc;
  146. struct sis900_private {
  147. struct net_device_stats stats;
  148. struct pci_dev * pci_dev;
  150. spinlock_t lock;
  152. struct mii_phy * mii;
  153. struct mii_phy * first_mii; /* record the first mii structure */
  154. unsigned int cur_phy;
  156. struct timer_list timer; /* Link status detection timer. */
  157. u8     autong_complete; /* 1: auto-negotiate complete  */
  159. unsigned int cur_rx, dirty_rx; /* producer/comsumer pointers for Tx/Rx ring */
  160. unsigned int cur_tx, dirty_tx;
  162. /* The saved address of a sent/receive-in-place packet buffer */
  163. struct sk_buff *tx_skbuff[NUM_TX_DESC];
  164. struct sk_buff *rx_skbuff[NUM_RX_DESC];
  165. BufferDesc *tx_ring;
  166. BufferDesc *rx_ring;
  168. dma_addr_t tx_ring_dma;
  169. dma_addr_t rx_ring_dma;
  171. unsigned int tx_full; /* The Tx queue is full.    */
  172. };
  174. MODULE_AUTHOR("Jim Huang <cmhuang@sis.com.tw>, Ollie Lho <ollie@sis.com.tw>");
  175. MODULE_DESCRIPTION("SiS 900 PCI Fast Ethernet driver");
  176. MODULE_LICENSE("GPL");
  178. MODULE_PARM(multicast_filter_limit, "i");
  179. MODULE_PARM(max_interrupt_work, "i");
  180. MODULE_PARM(debug, "i");
  181. MODULE_PARM_DESC(multicast_filter_limit, "SiS 900/7016 maximum number of filtered multicast addresses");
  182. MODULE_PARM_DESC(max_interrupt_work, "SiS 900/7016 maximum events handled per interrupt");
  183. MODULE_PARM_DESC(debug, "SiS 900/7016 debug level (2-4)");
  185. static int sis900_open(struct net_device *net_dev);
  186. static int sis900_mii_probe (struct net_device * net_dev);
  187. static void sis900_init_rxfilter (struct net_device * net_dev);
  188. static u16 read_eeprom(long ioaddr, int location);
  189. static u16 mdio_read(struct net_device *net_dev, int phy_id, int location);
  190. static void mdio_write(struct net_device *net_dev, int phy_id, int location, int val);
  191. static void sis900_timer(unsigned long data);
  192. static void sis900_check_mode (struct net_device *net_dev, struct mii_phy *mii_phy);
  193. static void sis900_tx_timeout(struct net_device *net_dev);
  194. static void sis900_init_tx_ring(struct net_device *net_dev);
  195. static void sis900_init_rx_ring(struct net_device *net_dev);
  196. static int sis900_start_xmit(struct sk_buff *skb, struct net_device *net_dev);
  197. static int sis900_rx(struct net_device *net_dev);
  198. static void sis900_finish_xmit (struct net_device *net_dev);
  199. static void sis900_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
  200. static int sis900_close(struct net_device *net_dev);
  201. static int mii_ioctl(struct net_device *net_dev, struct ifreq *rq, int cmd);
  202. static struct net_device_stats *sis900_get_stats(struct net_device *net_dev);
  203. static u16 sis900_compute_hashtable_index(u8 *addr, u8 revision);
  204. static void set_rx_mode(struct net_device *net_dev);
  205. static void sis900_reset(struct net_device *net_dev);
  206. static void sis630_set_eq(struct net_device *net_dev, u8 revision);
  207. static int sis900_set_config(struct net_device *dev, struct ifmap *map);
  208. static u16 sis900_default_phy(struct net_device * net_dev);
  209. static void sis900_set_capability( struct net_device *net_dev ,struct mii_phy *phy);
  210. static u16 sis900_reset_phy(struct net_device *net_dev, int phy_addr);
  211. static void sis900_auto_negotiate(struct net_device *net_dev, int phy_addr);
  212. static void sis900_set_mode (long ioaddr, int speed, int duplex);
  214. /**
  215.  * sis900_get_mac_addr: - Get MAC address for stand alone SiS900 model
  216.  * @pci_dev: the sis900 pci device
  217.  * @net_dev: the net device to get address for 
  218.  *
  219.  * Older SiS900 and friends, use EEPROM to store MAC address.
  220.  * MAC address is read from read_eeprom() into @net_dev->dev_addr.
  221.  */
  223. static int __devinit sis900_get_mac_addr(struct pci_dev * pci_dev, struct net_device *net_dev)
  224. {
  225. long ioaddr = pci_resource_start(pci_dev, 0);
  226. u16 signature;
  227. int i;
  229. /* check to see if we have sane EEPROM */
  230. signature = (u16) read_eeprom(ioaddr, EEPROMSignature);    
  231. if (signature == 0xffff || signature == 0x0000) {
  232. printk (KERN_INFO "%s: Error EERPOM read %xn", 
  233. net_dev->name, signature);
  234. return 0;
  235. }
  237. /* get MAC address from EEPROM */
  238. for (i = 0; i < 3; i++)
  239.         ((u16 *)(net_dev->dev_addr))[i] = read_eeprom(ioaddr, i+EEPROMMACAddr);
  241. return 1;
  242. }
  244. /**
  245.  * sis630e_get_mac_addr: - Get MAC address for SiS630E model
  246.  * @pci_dev: the sis900 pci device
  247.  * @net_dev: the net device to get address for 
  248.  *
  249.  * SiS630E model, use APC CMOS RAM to store MAC address.
  250.  * APC CMOS RAM is accessed through ISA bridge.
  251.  * MAC address is read into @net_dev->dev_addr.
  252.  */
  254. static int __devinit sis630e_get_mac_addr(struct pci_dev * pci_dev, struct net_device *net_dev)
  255. {
  256. struct pci_dev *isa_bridge = NULL;
  257. u8 reg;
  258. int i;
  260. if ((isa_bridge = pci_find_device(0x1039, 0x0008, isa_bridge)) == NULL) {
  261. printk("%s: Can not find ISA bridgen", net_dev->name);
  262. return 0;
  263. }
  264. pci_read_config_byte(isa_bridge, 0x48, &reg);
  265. pci_write_config_byte(isa_bridge, 0x48, reg | 0x40);
  267. for (i = 0; i < 6; i++) {
  268. outb(0x09 + i, 0x70);
  269. ((u8 *)(net_dev->dev_addr))[i] = inb(0x71); 
  270. }
  271. pci_write_config_byte(isa_bridge, 0x48, reg & ~0x40);
  273. return 1;
  274. }
  277. /**
  278.  * sis635_get_mac_addr: - Get MAC address for SIS635 model
  279.  * @pci_dev: the sis900 pci device
  280.  * @net_dev: the net device to get address for 
  281.  *
  282.  * SiS635 model, set MAC Reload Bit to load Mac address from APC
  283.  * to rfdr. rfdr is accessed through rfcr. MAC address is read into 
  284.  * @net_dev->dev_addr.
  285.  */
  287. static int __devinit sis635_get_mac_addr(struct pci_dev * pci_dev, struct net_device *net_dev)
  288. {
  289. long ioaddr = net_dev->base_addr;
  290. u32 rfcrSave;
  291. u32 i;
  293. rfcrSave = inl(rfcr + ioaddr);
  295. outl(rfcrSave | RELOAD, ioaddr + cr);
  296. outl(0, ioaddr + cr);
  298. /* disable packet filtering before setting filter */
  299. outl(rfcrSave & ~RFEN, rfcr + ioaddr);
  301. /* load MAC addr to filter data register */
  302. for (i = 0 ; i < 3 ; i++) {
  303. outl((i << RFADDR_shift), ioaddr + rfcr);
  304. *( ((u16 *)net_dev->dev_addr) + i) = inw(ioaddr + rfdr);
  305. }
  307. /* enable packet filitering */
  308. outl(rfcrSave | RFEN, rfcr + ioaddr);
  310. return 1;
  311. }
  313. /**
  314.  * sis96x_get_mac_addr: - Get MAC address for SiS962 or SiS963 model
  315.  * @pci_dev: the sis900 pci device
  316.  * @net_dev: the net device to get address for 
  317.  *
  318.  * SiS962 or SiS963 model, use EEPROM to store MAC address. And EEPROM 
  319.  * is shared by
  320.  * LAN and 1394. When access EEPROM, send EEREQ signal to hardware first 
  321.  * and wait for EEGNT. If EEGNT is ON, EEPROM is permitted to be access 
  322.  * by LAN, otherwise is not. After MAC address is read from EEPROM, send
  323.  * EEDONE signal to refuse EEPROM access by LAN. 
  324.  * The EEPROM map of SiS962 or SiS963 is different to SiS900. 
  325.  * The signature field in SiS962 or SiS963 spec is meaningless. 
  326.  * MAC address is read into @net_dev->dev_addr.
  327.  */
  329. static int __devinit sis96x_get_mac_addr(struct pci_dev * pci_dev, struct net_device *net_dev)
  330. {
  331. long ioaddr = net_dev->base_addr;
  332. long ee_addr = ioaddr + mear;
  333. u32 waittime = 0;
  334. int i;
  336. outl(EEREQ, ee_addr);
  337. while(waittime < 2000) {
  338. if(inl(ee_addr) & EEGNT) {
  340. /* get MAC address from EEPROM */
  341. for (i = 0; i < 3; i++)
  342.         ((u16 *)(net_dev->dev_addr))[i] = read_eeprom(ioaddr, i+EEPROMMACAddr);
  344. outl(EEDONE, ee_addr);
  345. return 1;
  346. } else {
  347. udelay(1);
  348. waittime ++;
  349. }
  350. }
  351. outl(EEDONE, ee_addr);
  352. return 0;
  353. }
  355. /**
  356.  * sis900_probe: - Probe for sis900 device
  357.  * @pci_dev: the sis900 pci device
  358.  * @pci_id: the pci device ID
  359.  *
  360.  * Check and probe sis900 net device for @pci_dev.
  361.  * Get mac address according to the chip revision, 
  362.  * and assign SiS900-specific entries in the device structure.
  363.  * ie: sis900_open(), sis900_start_xmit(), sis900_close(), etc.
  364.  */
  366. static int __devinit sis900_probe (struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
  367. {
  368. struct sis900_private *sis_priv;
  369. struct net_device *net_dev;
  370. dma_addr_t ring_dma;
  371. void *ring_space;
  372. long ioaddr;
  373. int i, ret;
  374. u8 revision;
  375. char *card_name = card_names[pci_id->driver_data];
  377. /* when built into the kernel, we only print version if device is found */
  378. #ifndef MODULE
  379. static int printed_version;
  380. if (!printed_version++)
  381. printk(version);
  382. #endif
  384. /* setup various bits in PCI command register */
  385. ret = pci_enable_device(pci_dev);
  386. if(ret) return ret;
  388. i = pci_set_dma_mask(pci_dev, SIS900_DMA_MASK);
  389. if(i){
  390. printk(KERN_ERR "sis900.c: architecture does not support"
  391. "32bit PCI busmaster DMAn");
  392. return i;
  393. }
  395. pci_set_master(pci_dev);
  397. net_dev = alloc_etherdev(sizeof(struct sis900_private));
  398. if (!net_dev)
  399. return -ENOMEM;
  400. SET_MODULE_OWNER(net_dev);
  402. /* We do a request_region() to register /proc/ioports info. */
  403. ioaddr = pci_resource_start(pci_dev, 0);
  404. ret = pci_request_regions(pci_dev, "sis900");
  405. if (ret)
  406. goto err_out;
  408. sis_priv = net_dev->priv;
  409. net_dev->base_addr = ioaddr;
  410. net_dev->irq = pci_dev->irq;
  411. sis_priv->pci_dev = pci_dev;
  412. spin_lock_init(&sis_priv->lock);
  414. pci_set_drvdata(pci_dev, net_dev);
  416. ring_space = pci_alloc_consistent(pci_dev, TX_TOTAL_SIZE, &ring_dma);
  417. if (!ring_space) {
  418. ret = -ENOMEM;
  419. goto err_out_cleardev;
  420. }
  421. sis_priv->tx_ring = (BufferDesc *)ring_space;
  422. sis_priv->tx_ring_dma = ring_dma;
  424. ring_space = pci_alloc_consistent(pci_dev, RX_TOTAL_SIZE, &ring_dma);
  425. if (!ring_space) {
  426. ret = -ENOMEM;
  427. goto err_unmap_tx;
  428. }
  429. sis_priv->rx_ring = (BufferDesc *)ring_space;
  430. sis_priv->rx_ring_dma = ring_dma;
  432. /* The SiS900-specific entries in the device structure. */
  433. net_dev->open = &sis900_open;
  434. net_dev->hard_start_xmit = &sis900_start_xmit;
  435. net_dev->stop = &sis900_close;
  436. net_dev->get_stats = &sis900_get_stats;
  437. net_dev->set_config = &sis900_set_config;
  438. net_dev->set_multicast_list = &set_rx_mode;
  439. net_dev->do_ioctl = &mii_ioctl;
  440. net_dev->tx_timeout = sis900_tx_timeout;
  441. net_dev->watchdog_timeo = TX_TIMEOUT;
  443. ret = register_netdev(net_dev);
  444. if (ret)
  445. goto err_unmap_rx;
  447. /* Get Mac address according to the chip revision */
  448. pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &revision);
  449. ret = 0;
  451. if (revision == SIS630E_900_REV)
  452. ret = sis630e_get_mac_addr(pci_dev, net_dev);
  453. else if ((revision > 0x81) && (revision <= 0x90) )
  454. ret = sis635_get_mac_addr(pci_dev, net_dev);
  455. else if (revision == SIS96x_900_REV)
  456. ret = sis96x_get_mac_addr(pci_dev, net_dev);
  457. else
  458. ret = sis900_get_mac_addr(pci_dev, net_dev);
  460. if (ret == 0) {
  461. ret = -ENODEV;
  462. goto err_out_unregister;
  463. }
  465. /* 630ET : set the mii access mode as software-mode */
  466. if (revision == SIS630ET_900_REV)
  467. outl(ACCESSMODE | inl(ioaddr + cr), ioaddr + cr);
  469. /* probe for mii transceiver */
  470. if (sis900_mii_probe(net_dev) == 0) {
  471. ret = -ENODEV;
  472. goto err_out_unregister;
  473. }
  475. /* print some information about our NIC */
  476. printk(KERN_INFO "%s: %s at %#lx, IRQ %d, ", net_dev->name,
  477.        card_name, ioaddr, net_dev->irq);
  478. for (i = 0; i < 5; i++)
  479. printk("%2.2x:", (u8)net_dev->dev_addr[i]);
  480. printk("%2.2x.n", net_dev->dev_addr[i]);
  482. return 0;
  484.  err_out_unregister:
  485.   unregister_netdev(net_dev);
  486.  err_unmap_rx:
  487. pci_free_consistent(pci_dev, RX_TOTAL_SIZE, sis_priv->rx_ring,
  488. sis_priv->rx_ring_dma);
  489.  err_unmap_tx:
  490. pci_free_consistent(pci_dev, TX_TOTAL_SIZE, sis_priv->tx_ring,
  491. sis_priv->tx_ring_dma);
  492.  err_out_cleardev:
  493.   pci_set_drvdata(pci_dev, NULL);
  494. pci_release_regions(pci_dev);
  495.  err_out:
  496. kfree(net_dev);
  497. return ret;
  498. }
  500. /**
  501.  * sis900_mii_probe: - Probe MII PHY for sis900
  502.  * @net_dev: the net device to probe for
  503.  *
  504.  * Search for total of 32 possible mii phy addresses.
  505.  * Identify and set current phy if found one,
  506.  * return error if it failed to found.
  507.  */
  509. static int __init sis900_mii_probe (struct net_device * net_dev)
  510. {
  511. struct sis900_private * sis_priv = net_dev->priv;
  512. u16 poll_bit = MII_STAT_LINK, status = 0;
  513. unsigned int timeout = jiffies + 5 * HZ;
  514. int phy_addr;
  515. u8 revision;
  517. sis_priv->mii = NULL;
  519. /* search for total of 32 possible mii phy addresses */
  520. for (phy_addr = 0; phy_addr < 32; phy_addr++) {
  521. struct mii_phy * mii_phy = NULL;
  522. u16 mii_status;
  523. int i;
  525. mii_phy = NULL;
  526. for(i = 0; i < 2; i++)
  527. mii_status = mdio_read(net_dev, phy_addr, MII_STATUS);
  529. if (mii_status == 0xffff || mii_status == 0x0000)
  530. /* the mii is not accessable, try next one */
  531. continue;
  533. if ((mii_phy = kmalloc(sizeof(struct mii_phy), GFP_KERNEL)) == NULL) {
  534. printk(KERN_INFO "Cannot allocate mem for struct mii_phyn");
  535. return 0;
  536. }
  538. mii_phy->phy_id0 = mdio_read(net_dev, phy_addr, MII_PHY_ID0);
  539. mii_phy->phy_id1 = mdio_read(net_dev, phy_addr, MII_PHY_ID1);
  540. mii_phy->phy_addr = phy_addr;
  541. mii_phy->status = mii_status;
  542. mii_phy->next = sis_priv->mii;
  543. sis_priv->mii = mii_phy;
  544. sis_priv->first_mii = mii_phy;
  546. for (i = 0; mii_chip_table[i].phy_id1; i++)
  547. if ((mii_phy->phy_id0 == mii_chip_table[i].phy_id0 ) &&
  548.     ((mii_phy->phy_id1 & 0xFFF0) == mii_chip_table[i].phy_id1)){
  549. mii_phy->phy_types = mii_chip_table[i].phy_types;
  550. if (mii_chip_table[i].phy_types == MIX)
  551. mii_phy->phy_types =
  552. (mii_status & (MII_STAT_CAN_TX_FDX | MII_STAT_CAN_TX)) ? LAN : HOME;
  553. printk(KERN_INFO "%s: %s transceiver found at address %d.n",
  554.        net_dev->name, mii_chip_table[i].name, phy_addr);
  555. break;
  556. }
  558. if( !mii_chip_table[i].phy_id1 )
  559. printk(KERN_INFO "%s: Unknown PHY transceiver found at address %d.n",
  560.        net_dev->name, phy_addr);
  561. }
  563. if (sis_priv->mii == NULL) {
  564. printk(KERN_INFO "%s: No MII transceivers found!n",
  565.        net_dev->name);
  566. return 0;
  567. }
  569. /* select default PHY for mac */
  570. sis_priv->mii = NULL;
  571. sis900_default_phy( net_dev );
  573. /* Reset phy if default phy is internal sis900 */
  574.         if ((sis_priv->mii->phy_id0 == 0x001D) &&
  575.     ((sis_priv->mii->phy_id1&0xFFF0) == 0x8000))
  576.          status = sis900_reset_phy(net_dev, sis_priv->cur_phy);
  577.         
  578.         /* workaround for ICS1893 PHY */
  579.         if ((sis_priv->mii->phy_id0 == 0x0015) &&
  580.             ((sis_priv->mii->phy_id1&0xFFF0) == 0xF440))
  581.              mdio_write(net_dev, sis_priv->cur_phy, 0x0018, 0xD200);
  583. if(status & MII_STAT_LINK){
  584. while (poll_bit) {
  585. current->state = TASK_INTERRUPTIBLE;
  586. schedule_timeout(0);
  587. poll_bit ^= (mdio_read(net_dev, sis_priv->cur_phy, MII_STATUS) & poll_bit);
  588. if (jiffies >= timeout) {
  589. printk(KERN_WARNING "%s: reset phy and link down nown", net_dev->name);
  590. return -ETIME;
  591. }
  592. }
  593. }
  595. pci_read_config_byte(sis_priv->pci_dev, PCI_CLASS_REVISION, &revision);
  596. if (revision == SIS630E_900_REV) {
  597. /* SiS 630E has some bugs on default value of PHY registers */
  598. mdio_write(net_dev, sis_priv->cur_phy, MII_ANADV, 0x05e1);
  599. mdio_write(net_dev, sis_priv->cur_phy, MII_CONFIG1, 0x22);
  600. mdio_write(net_dev, sis_priv->cur_phy, MII_CONFIG2, 0xff00);
  601. mdio_write(net_dev, sis_priv->cur_phy, MII_MASK, 0xffc0);
  602. //mdio_write(net_dev, sis_priv->cur_phy, MII_CONTROL, 0x1000);
  603. }
  605. if (sis_priv->mii->status & MII_STAT_LINK)
  606. netif_carrier_on(net_dev);
  607. else
  608. netif_carrier_off(net_dev);
  610. return 1;
  611. }
  613. /**
  614.  * sis900_default_phy: - Select default PHY for sis900 mac.
  615.  * @net_dev: the net device to probe for
  616.  *
  617.  * Select first detected PHY with link as default.
  618.  * If no one is link on, select PHY whose types is HOME as default.
  619.  * If HOME doesn't exist, select LAN.
  620.  */
  622. static u16 sis900_default_phy(struct net_device * net_dev)
  623. {
  624. struct sis900_private * sis_priv = net_dev->priv;
  625.   struct mii_phy *phy = NULL, *phy_home = NULL, *default_phy = NULL;
  626. u16 status;
  628.         for( phy=sis_priv->first_mii; phy; phy=phy->next ){
  629. status = mdio_read(net_dev, phy->phy_addr, MII_STATUS);
  630. status = mdio_read(net_dev, phy->phy_addr, MII_STATUS);
  632. /* Link ON & Not select deafalut PHY */
  633.  if ( (status & MII_STAT_LINK) && !(default_phy) )
  634.   default_phy = phy;
  635.  else{
  636. status = mdio_read(net_dev, phy->phy_addr, MII_CONTROL);
  637. mdio_write(net_dev, phy->phy_addr, MII_CONTROL,
  638. status | MII_CNTL_AUTO | MII_CNTL_ISOLATE);
  639. if( phy->phy_types == HOME )
  640. phy_home = phy;
  641.  }
  642. }
  644. if( (!default_phy) && phy_home )
  645. default_phy = phy_home;
  646. else if(!default_phy)
  647. default_phy = sis_priv->first_mii;
  649. if( sis_priv->mii != default_phy ){
  650. sis_priv->mii = default_phy;
  651. sis_priv->cur_phy = default_phy->phy_addr;
  652. printk(KERN_INFO "%s: Using transceiver found at address %d as defaultn", net_dev->name,sis_priv->cur_phy);
  653. }
  655. status = mdio_read(net_dev, sis_priv->cur_phy, MII_CONTROL);
  656. status &= (~MII_CNTL_ISOLATE);
  658. mdio_write(net_dev, sis_priv->cur_phy, MII_CONTROL, status);
  659. status = mdio_read(net_dev, sis_priv->cur_phy, MII_STATUS);
  660. status = mdio_read(net_dev, sis_priv->cur_phy, MII_STATUS);
  662. return status;
  663. }
  666. /**
  667.  *  sis900_set_capability: - set the media capability of network adapter.
  668.  * @net_dev : the net device to probe for
  669.  * @phy : default PHY
  670.  *
  671.  * Set the media capability of network adapter according to
  672.  * mii status register. It's necessary before auto-negotiate.
  673.  */
  674.  
  675. static void sis900_set_capability( struct net_device *net_dev , struct mii_phy *phy )
  676. {
  677. u16 cap;
  678. u16 status;
  680. status = mdio_read(net_dev, phy->phy_addr, MII_STATUS);
  681. status = mdio_read(net_dev, phy->phy_addr, MII_STATUS);
  683. cap = MII_NWAY_CSMA_CD |
  684. ((phy->status & MII_STAT_CAN_TX_FDX)? MII_NWAY_TX_FDX:0) |
  685. ((phy->status & MII_STAT_CAN_TX)    ? MII_NWAY_TX:0) |
  686. ((phy->status & MII_STAT_CAN_T_FDX) ? MII_NWAY_T_FDX:0)|
  687. ((phy->status & MII_STAT_CAN_T)     ? MII_NWAY_T:0);
  689. mdio_write(net_dev, phy->phy_addr, MII_ANADV, cap);
  690. }
  693. /* Delay between EEPROM clock transitions. */
  694. #define eeprom_delay()  inl(ee_addr)
  696. /**
  697.  * read_eeprom: - Read Serial EEPROM
  698.  * @ioaddr: base i/o address
  699.  * @location: the EEPROM location to read
  700.  *
  701.  * Read Serial EEPROM through EEPROM Access Register.
  702.  * Note that location is in word (16 bits) unit
  703.  */
  705. static u16 __devinit read_eeprom(long ioaddr, int location)
  706. {
  707. int i;
  708. u16 retval = 0;
  709. long ee_addr = ioaddr + mear;
  710. u32 read_cmd = location | EEread;
  712. outl(0, ee_addr);
  713. eeprom_delay();
  714. outl(EECS, ee_addr);
  715. eeprom_delay();
  717. /* Shift the read command (9) bits out. */
  718. for (i = 8; i >= 0; i--) {
  719. u32 dataval = (read_cmd & (1 << i)) ? EEDI | EECS : EECS;
  720. outl(dataval, ee_addr);
  721. eeprom_delay();
  722. outl(dataval | EECLK, ee_addr);
  723. eeprom_delay();
  724. }
  725. outl(EECS, ee_addr);
  726. eeprom_delay();
  728. /* read the 16-bits data in */
  729. for (i = 16; i > 0; i--) {
  730. outl(EECS, ee_addr);
  731. eeprom_delay();
  732. outl(EECS | EECLK, ee_addr);
  733. eeprom_delay();
  734. retval = (retval << 1) | ((inl(ee_addr) & EEDO) ? 1 : 0);
  735. eeprom_delay();
  736. }
  738. /* Terminate the EEPROM access. */
  739. outl(0, ee_addr);
  740. eeprom_delay();
  742. return (retval);
  743. }
  745. /* Read and write the MII management registers using software-generated
  746.    serial MDIO protocol. Note that the command bits and data bits are
  747.    send out seperately */
  748. #define mdio_delay()    inl(mdio_addr)
  750. static void mdio_idle(long mdio_addr)
  751. {
  752. outl(MDIO | MDDIR, mdio_addr);
  753. mdio_delay();
  754. outl(MDIO | MDDIR | MDC, mdio_addr);
  755. }
  757. /* Syncronize the MII management interface by shifting 32 one bits out. */
  758. static void mdio_reset(long mdio_addr)
  759. {
  760. int i;
  762. for (i = 31; i >= 0; i--) {
  763. outl(MDDIR | MDIO, mdio_addr);
  764. mdio_delay();
  765. outl(MDDIR | MDIO | MDC, mdio_addr);
  766. mdio_delay();
  767. }
  768. return;
  769. }
  771. /**
  772.  * mdio_read: - read MII PHY register
  773.  * @net_dev: the net device to read
  774.  * @phy_id: the phy address to read
  775.  * @location: the phy regiester id to read
  776.  *
  777.  * Read MII registers through MDIO and MDC
  778.  * using MDIO management frame structure and protocol(defined by ISO/IEC).
  779.  * Please see SiS7014 or ICS spec
  780.  */
  782. static u16 mdio_read(struct net_device *net_dev, int phy_id, int location)
  783. {
  784. long mdio_addr = net_dev->base_addr + mear;
  785. int mii_cmd = MIIread|(phy_id<<MIIpmdShift)|(location<<MIIregShift);
  786. u16 retval = 0;
  787. int i;
  789. mdio_reset(mdio_addr);
  790. mdio_idle(mdio_addr);
  792. for (i = 15; i >= 0; i--) {
  793. int dataval = (mii_cmd & (1 << i)) ? MDDIR | MDIO : MDDIR;
  794. outl(dataval, mdio_addr);
  795. mdio_delay();
  796. outl(dataval | MDC, mdio_addr);
  797. mdio_delay();
  798. }
  800. /* Read the 16 data bits. */
  801. for (i = 16; i > 0; i--) {
  802. outl(0, mdio_addr);
  803. mdio_delay();
  804. retval = (retval << 1) | ((inl(mdio_addr) & MDIO) ? 1 : 0);
  805. outl(MDC, mdio_addr);
  806. mdio_delay();
  807. }
  808. outl(0x00, mdio_addr);
  810. return retval;
  811. }
  813. /**
  814.  * mdio_write: - write MII PHY register
  815.  * @net_dev: the net device to write
  816.  * @phy_id: the phy address to write
  817.  * @location: the phy regiester id to write
  818.  * @value: the register value to write with
  819.  *
  820.  * Write MII registers with @value through MDIO and MDC
  821.  * using MDIO management frame structure and protocol(defined by ISO/IEC)
  822.  * please see SiS7014 or ICS spec
  823.  */
  825. static void mdio_write(struct net_device *net_dev, int phy_id, int location, int value)
  826. {
  827. long mdio_addr = net_dev->base_addr + mear;
  828. int mii_cmd = MIIwrite|(phy_id<<MIIpmdShift)|(location<<MIIregShift);
  829. int i;
  831. mdio_reset(mdio_addr);
  832. mdio_idle(mdio_addr);
  834. /* Shift the command bits out. */
  835. for (i = 15; i >= 0; i--) {
  836. int dataval = (mii_cmd & (1 << i)) ? MDDIR | MDIO : MDDIR;
  837. outb(dataval, mdio_addr);
  838. mdio_delay();
  839. outb(dataval | MDC, mdio_addr);
  840. mdio_delay();
  841. }
  842. mdio_delay();
  844. /* Shift the value bits out. */
  845. for (i = 15; i >= 0; i--) {
  846. int dataval = (value & (1 << i)) ? MDDIR | MDIO : MDDIR;
  847. outl(dataval, mdio_addr);
  848. mdio_delay();
  849. outl(dataval | MDC, mdio_addr);
  850. mdio_delay();
  851. }
  852. mdio_delay();
  854. /* Clear out extra bits. */
  855. for (i = 2; i > 0; i--) {
  856. outb(0, mdio_addr);
  857. mdio_delay();
  858. outb(MDC, mdio_addr);
  859. mdio_delay();
  860. }
  861. outl(0x00, mdio_addr);
  863. return;
  864. }
  867. /**
  868.  * sis900_reset_phy: - reset sis900 mii phy.
  869.  * @net_dev: the net device to write
  870.  * @phy_addr: default phy address
  871.  *
  872.  * Some specific phy can't work properly without reset.
  873.  * This function will be called during initialization and
  874.  * link status change from ON to DOWN.
  875.  */
  877. static u16 sis900_reset_phy(struct net_device *net_dev, int phy_addr)
  878. {
  879. int i = 0;
  880. u16 status;
  882. while (i++ < 2)
  883. status = mdio_read(net_dev, phy_addr, MII_STATUS);
  885. mdio_write( net_dev, phy_addr, MII_CONTROL, MII_CNTL_RESET );
  887. return status;
  888. }
  890. /**
  891.  * sis900_open: - open sis900 device
  892.  * @net_dev: the net device to open
  893.  *
  894.  * Do some initialization and start net interface.
  895.  * enable interrupts and set sis900 timer.
  896.  */
  898. static int
  899. sis900_open(struct net_device *net_dev)
  900. {
  901. struct sis900_private *sis_priv = net_dev->priv;
  902. long ioaddr = net_dev->base_addr;
  903. u8 revision;
  904. int ret;
  906. /* Soft reset the chip. */
  907. sis900_reset(net_dev);
  909. /* Equalizer workaround Rule */
  910. pci_read_config_byte(sis_priv->pci_dev, PCI_CLASS_REVISION, &revision);
  911. sis630_set_eq(net_dev, revision);
  913. ret = request_irq(net_dev->irq, &sis900_interrupt, SA_SHIRQ, net_dev->name, net_dev);
  914. if (ret)
  915. return ret;
  917. sis900_init_rxfilter(net_dev);
  919. sis900_init_tx_ring(net_dev);
  920. sis900_init_rx_ring(net_dev);
  922. set_rx_mode(net_dev);
  924. netif_start_queue(net_dev);
  926. /* Workaround for EDB */
  927. sis900_set_mode(ioaddr, HW_SPEED_10_MBPS, FDX_CAPABLE_HALF_SELECTED);
  929. /* Enable all known interrupts by setting the interrupt mask. */
  930. outl((RxSOVR|RxORN|RxERR|RxOK|TxURN|TxERR|TxIDLE), ioaddr + imr);
  931. outl(RxENA | inl(ioaddr + cr), ioaddr + cr);
  932. outl(IE, ioaddr + ier);
  934. sis900_check_mode(net_dev, sis_priv->mii);
  936. /* Set the timer to switch to check for link beat and perhaps switch
  937.    to an alternate media type. */
  938. init_timer(&sis_priv->timer);
  939. sis_priv->timer.expires = jiffies + HZ;
  940. sis_priv->timer.data = (unsigned long)net_dev;
  941. sis_priv->timer.function = &sis900_timer;
  942. add_timer(&sis_priv->timer);
  944. return 0;
  945. }
  947. /**
  948.  * sis900_init_rxfilter: - Initialize the Rx filter
  949.  * @net_dev: the net device to initialize for
  950.  *
  951.  * Set receive filter address to our MAC address
  952.  * and enable packet filtering.
  953.  */
  955. static void
  956. sis900_init_rxfilter (struct net_device * net_dev)
  957. {
  958. long ioaddr = net_dev->base_addr;
  959. u32 rfcrSave;
  960. u32 i;
  962. rfcrSave = inl(rfcr + ioaddr);
  964. /* disable packet filtering before setting filter */
  965. outl(rfcrSave & ~RFEN, rfcr + ioaddr);
  967. /* load MAC addr to filter data register */
  968. for (i = 0 ; i < 3 ; i++) {
  969. u32 w;
  971. w = (u32) *((u16 *)(net_dev->dev_addr)+i);
  972. outl((i << RFADDR_shift), ioaddr + rfcr);
  973. outl(w, ioaddr + rfdr);
  975. if (sis900_debug > 2) {
  976. printk(KERN_INFO "%s: Receive Filter Addrss[%d]=%xn",
  977.        net_dev->name, i, inl(ioaddr + rfdr));
  978. }
  979. }
  981. /* enable packet filitering */
  982. outl(rfcrSave | RFEN, rfcr + ioaddr);
  983. }
  985. /**
  986.  * sis900_init_tx_ring: - Initialize the Tx descriptor ring
  987.  * @net_dev: the net device to initialize for
  988.  *
  989.  * Initialize the Tx descriptor ring, 
  990.  */
  992. static void
  993. sis900_init_tx_ring(struct net_device *net_dev)
  994. {
  995. struct sis900_private *sis_priv = net_dev->priv;
  996. long ioaddr = net_dev->base_addr;
  997. int i;
  999. sis_priv->tx_full = 0;
  1000. sis_priv->dirty_tx = sis_priv->cur_tx = 0;
  1002. for (i = 0; i < NUM_TX_DESC; i++) {
  1003. sis_priv->tx_skbuff[i] = NULL;
  1005. sis_priv->tx_ring[i].link = sis_priv->tx_ring_dma +
  1006. ((i+1)%NUM_TX_DESC)*sizeof(BufferDesc);
  1007. sis_priv->tx_ring[i].cmdsts = 0;
  1008. sis_priv->tx_ring[i].bufptr = 0;
  1009. }
  1011. /* load Transmit Descriptor Register */
  1012. outl(sis_priv->tx_ring_dma, ioaddr + txdp);
  1013. if (sis900_debug > 2)
  1014. printk(KERN_INFO "%s: TX descriptor register loaded with: %8.8xn",
  1015.        net_dev->name, inl(ioaddr + txdp));
  1016. }
  1018. /**
  1019.  * sis900_init_rx_ring: - Initialize the Rx descriptor ring
  1020.  * @net_dev: the net device to initialize for
  1021.  *
  1022.  * Initialize the Rx descriptor ring, 
  1023.  * and pre-allocate recevie buffers (socket buffer)
  1024.  */
  1026. static void 
  1027. sis900_init_rx_ring(struct net_device *net_dev)
  1028. {
  1029. struct sis900_private *sis_priv = net_dev->priv;
  1030. long ioaddr = net_dev->base_addr;
  1031. int i;
  1033. sis_priv->cur_rx = 0;
  1034. sis_priv->dirty_rx = 0;
  1036. /* init RX descriptor */
  1037. for (i = 0; i < NUM_RX_DESC; i++) {
  1038. sis_priv->rx_skbuff[i] = NULL;
  1040. sis_priv->rx_ring[i].link = sis_priv->rx_ring_dma +
  1041. ((i+1)%NUM_RX_DESC)*sizeof(BufferDesc);
  1042. sis_priv->rx_ring[i].cmdsts = 0;
  1043. sis_priv->rx_ring[i].bufptr = 0;
  1044. }
  1046. /* allocate sock buffers */
  1047. for (i = 0; i < NUM_RX_DESC; i++) {
  1048. struct sk_buff *skb;
  1050. if ((skb = dev_alloc_skb(RX_BUF_SIZE)) == NULL) {
  1051. /* not enough memory for skbuff, this makes a "hole"
  1052.    on the buffer ring, it is not clear how the
  1053.    hardware will react to this kind of degenerated
  1054.    buffer */
  1055. break;
  1056. }
  1057. skb->dev = net_dev;
  1058. sis_priv->rx_skbuff[i] = skb;
  1059. sis_priv->rx_ring[i].cmdsts = RX_BUF_SIZE;
  1060.                 sis_priv->rx_ring[i].bufptr = pci_map_single(sis_priv->pci_dev,
  1061.                         skb->tail, RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
  1062. }
  1063. sis_priv->dirty_rx = (unsigned int) (i - NUM_RX_DESC);
  1065. /* load Receive Descriptor Register */
  1066. outl(sis_priv->rx_ring_dma, ioaddr + rxdp);
  1067. if (sis900_debug > 2)
  1068. printk(KERN_INFO "%s: RX descriptor register loaded with: %8.8xn",
  1069.        net_dev->name, inl(ioaddr + rxdp));
  1070. }
  1072. /**
  1073.  * sis630_set_eq: - set phy equalizer value for 630 LAN
  1074.  * @net_dev: the net device to set equalizer value
  1075.  * @revision: 630 LAN revision number
  1076.  *
  1077.  * 630E equalizer workaround rule(Cyrus Huang 08/15)
  1078.  * PHY register 14h(Test)
  1079.  * Bit 14: 0 -- Automatically dectect (default)
  1080.  * 1 -- Manually set Equalizer filter
  1081.  * Bit 13: 0 -- (Default)
  1082.  * 1 -- Speed up convergence of equalizer setting
  1083.  * Bit 9 : 0 -- (Default)
  1084.  * 1 -- Disable Baseline Wander
  1085.  * Bit 3~7   -- Equalizer filter setting
  1086.  * Link ON: Set Bit 9, 13 to 1, Bit 14 to 0
  1087.  * Then calculate equalizer value
  1088.  * Then set equalizer value, and set Bit 14 to 1, Bit 9 to 0
  1089.  * Link Off:Set Bit 13 to 1, Bit 14 to 0
  1090.  * Calculate Equalizer value:
  1091.  * When Link is ON and Bit 14 is 0, SIS900PHY will auto-dectect proper equalizer value.
  1092.  * When the equalizer is stable, this value is not a fixed value. It will be within
  1093.  * a small range(eg. 7~9). Then we get a minimum and a maximum value(eg. min=7, max=9)
  1094.  * 0 <= max <= 4  --> set equalizer to max
  1095.  * 5 <= max <= 14 --> set equalizer to max+1 or set equalizer to max+2 if max == min
  1096.  * max >= 15      --> set equalizer to max+5 or set equalizer to max+6 if max == min
  1097.  */
  1099. static void sis630_set_eq(struct net_device *net_dev, u8 revision)
  1100. {
  1101. struct sis900_private *sis_priv = net_dev->priv;
  1102. u16 reg14h, eq_value=0, max_value=0, min_value=0;
  1103. u8 host_bridge_rev;
  1104. int i, maxcount=10;
  1105. struct pci_dev *dev=NULL;
  1107. if ( !(revision == SIS630E_900_REV || revision == SIS630EA1_900_REV ||
  1108.        revision == SIS630A_900_REV || revision ==  SIS630ET_900_REV) )
  1109. return;
  1111. dev = pci_find_device(PCI_VENDOR_ID_SI, PCI_DEVICE_ID_SI_630, dev);
  1112. if (dev)
  1113. pci_read_config_byte(dev, PCI_CLASS_REVISION, &host_bridge_rev);
  1115. if (netif_carrier_ok(net_dev)) {
  1116. reg14h=mdio_read(net_dev, sis_priv->cur_phy, MII_RESV);
  1117. mdio_write(net_dev, sis_priv->cur_phy, MII_RESV, (0x2200 | reg14h) & 0xBFFF);
  1118. for (i=0; i < maxcount; i++) {
  1119. eq_value=(0x00F8 & mdio_read(net_dev, sis_priv->cur_phy, MII_RESV)) >> 3;
  1120. if (i == 0)
  1121. max_value=min_value=eq_value;
  1122. max_value=(eq_value > max_value) ? eq_value : max_value;
  1123. min_value=(eq_value < min_value) ? eq_value : min_value;
  1124. }
  1125. /* 630E rule to determine the equalizer value */
  1126. if (revision == SIS630E_900_REV || revision == SIS630EA1_900_REV ||
  1127.     revision == SIS630ET_900_REV) {
  1128. if (max_value < 5)
  1129. eq_value=max_value;
  1130. else if (max_value >= 5 && max_value < 15)
  1131. eq_value=(max_value == min_value) ? max_value+2 : max_value+1;
  1132. else if (max_value >= 15)
  1133. eq_value=(max_value == min_value) ? max_value+6 : max_value+5;
  1134. }
  1135. /* 630B0&B1 rule to determine the equalizer value */
  1136. if (revision == SIS630A_900_REV && 
  1137.     (host_bridge_rev == SIS630B0 || host_bridge_rev == SIS630B1)) {
  1138. if (max_value == 0)
  1139. eq_value=3;
  1140. else
  1141. eq_value=(max_value+min_value+1)/2;
  1142. }
  1143. /* write equalizer value and setting */
  1144. reg14h=mdio_read(net_dev, sis_priv->cur_phy, MII_RESV);
  1145. reg14h=(reg14h & 0xFF07) | ((eq_value << 3) & 0x00F8);
  1146. reg14h=(reg14h | 0x6000) & 0xFDFF;
  1147. mdio_write(net_dev, sis_priv->cur_phy, MII_RESV, reg14h);
  1148. }
  1149. else {
  1150. reg14h=mdio_read(net_dev, sis_priv->cur_phy, MII_RESV);
  1151. if (revision == SIS630A_900_REV && 
  1152.     (host_bridge_rev == SIS630B0 || host_bridge_rev == SIS630B1)) 
  1153. mdio_write(net_dev, sis_priv->cur_phy, MII_RESV, (reg14h | 0x2200) & 0xBFFF);
  1154. else
  1155. mdio_write(net_dev, sis_priv->cur_phy, MII_RESV, (reg14h | 0x2000) & 0xBFFF);
  1156. }
  1157. return;
  1158. }
  1160. /**
  1161.  * sis900_timer: - sis900 timer routine
  1162.  * @data: pointer to sis900 net device
  1163.  *
  1164.  * On each timer ticks we check two things, 
  1165.  * link status (ON/OFF) and link mode (10/100/Full/Half)
  1166.  */
  1168. static void sis900_timer(unsigned long data)
  1169. {
  1170. struct net_device *net_dev = (struct net_device *)data;
  1171. struct sis900_private *sis_priv = net_dev->priv;
  1172. struct mii_phy *mii_phy = sis_priv->mii;
  1173. static int next_tick = 5*HZ;
  1174. u16 status;
  1175. u8 revision;
  1177. if (!sis_priv->autong_complete){
  1178. int speed, duplex = 0;
  1180. sis900_read_mode(net_dev, &speed, &duplex);
  1181. if (duplex){
  1182. sis900_set_mode(net_dev->base_addr, speed, duplex);
  1183. pci_read_config_byte(sis_priv->pci_dev, PCI_CLASS_REVISION, &revision);
  1184. sis630_set_eq(net_dev, revision);
  1185. netif_start_queue(net_dev);
  1186. }
  1188. sis_priv->timer.expires = jiffies + HZ;
  1189. add_timer(&sis_priv->timer);
  1190. return;
  1191. }
  1193. status = mdio_read(net_dev, sis_priv->cur_phy, MII_STATUS);
  1194. status = mdio_read(net_dev, sis_priv->cur_phy, MII_STATUS);
  1196. /* Link OFF -> ON */
  1197. if (!netif_carrier_ok(net_dev)) {
  1198. LookForLink:
  1199. /* Search for new PHY */
  1200. status = sis900_default_phy(net_dev);
  1201. mii_phy = sis_priv->mii;
  1203. if (status & MII_STAT_LINK){
  1204. sis900_check_mode(net_dev, mii_phy);
  1205. netif_carrier_on(net_dev);
  1206. }
  1207. }
  1208. /* Link ON -> OFF */
  1209. else {
  1210.                 if (!(status & MII_STAT_LINK)){
  1211.                  netif_carrier_off(net_dev);
  1212.                  printk(KERN_INFO "%s: Media Link Offn", net_dev->name);
  1214.                  /* Change mode issue */
  1215.                  if ((mii_phy->phy_id0 == 0x001D) && 
  1216.     ((mii_phy->phy_id1 & 0xFFF0) == 0x8000))
  1217.                 sis900_reset_phy(net_dev,  sis_priv->cur_phy);
  1218.   
  1219.                  pci_read_config_byte(sis_priv->pci_dev, PCI_CLASS_REVISION, &revision);
  1220. sis630_set_eq(net_dev, revision);
  1221.   
  1222.                  goto LookForLink;
  1223.                 }
  1224. }
  1226. sis_priv->timer.expires = jiffies + next_tick;
  1227. add_timer(&sis_priv->timer);
  1228. }
  1230. /**
  1231.  * sis900_check_mode: - check the media mode for sis900
  1232.  * @net_dev: the net device to be checked
  1233.  * @mii_phy: the mii phy
  1234.  *
  1235.  * Older driver gets the media mode from mii status output
  1236.  * register. Now we set our media capability and auto-negotiate
  1237.  * to get the upper bound of speed and duplex between two ends.
  1238.  * If the types of mii phy is HOME, it doesn't need to auto-negotiate
  1239.  * and autong_complete should be set to 1.
  1240.  */
  1242. static void sis900_check_mode (struct net_device *net_dev, struct mii_phy *mii_phy)
  1243. {
  1244. struct sis900_private *sis_priv = net_dev->priv;
  1245. long ioaddr = net_dev->base_addr;
  1246. int speed, duplex;
  1248. if( mii_phy->phy_types == LAN  ){
  1249. outl( ~EXD & inl( ioaddr + cfg ), ioaddr + cfg);
  1250. sis900_set_capability(net_dev , mii_phy);
  1251. sis900_auto_negotiate(net_dev, sis_priv->cur_phy);
  1252. }else{
  1253. outl(EXD | inl( ioaddr + cfg ), ioaddr + cfg);
  1254. speed = HW_SPEED_HOME;
  1255. duplex = FDX_CAPABLE_HALF_SELECTED;
  1256. sis900_set_mode(ioaddr, speed, duplex);
  1257. sis_priv->autong_complete = 1;
  1258. }
  1259. }
  1261. /**
  1262.  * sis900_set_mode: - Set the media mode of mac register.
  1263.  * @ioaddr: the address of the device
  1264.  * @speed : the transmit speed to be determined
  1265.  * @duplex: the duplex mode to be determined
  1266.  *
  1267.  * Set the media mode of mac register txcfg/rxcfg according to
  1268.  * speed and duplex of phy. Bit EDB_MASTER_EN indicates the EDB
  1269.  * bus is used instead of PCI bus. When this bit is set 1, the
  1270.  * Max DMA Burst Size for TX/RX DMA should be no larger than 16
  1271.  * double words.
  1272.  */
  1274. static void sis900_set_mode (long ioaddr, int speed, int duplex)
  1275. {
  1276. u32 tx_flags = 0, rx_flags = 0;
  1278. if( inl(ioaddr + cfg) & EDB_MASTER_EN ){
  1279. tx_flags = TxATP | (DMA_BURST_64 << TxMXDMA_shift) | (TX_FILL_THRESH << TxFILLT_shift);
  1280. rx_flags = DMA_BURST_64 << RxMXDMA_shift;
  1281. }
  1282. else{
  1283. tx_flags = TxATP | (DMA_BURST_512 << TxMXDMA_shift) | (TX_FILL_THRESH << TxFILLT_shift);
  1284. rx_flags = DMA_BURST_512 << RxMXDMA_shift;
  1285. }
  1287. if (speed == HW_SPEED_HOME || speed == HW_SPEED_10_MBPS ) {
  1288. rx_flags |= (RxDRNT_10 << RxDRNT_shift);
  1289. tx_flags |= (TxDRNT_10 << TxDRNT_shift);
  1290. }
  1291. else {
  1292. rx_flags |= (RxDRNT_100 << RxDRNT_shift);
  1293. tx_flags |= (TxDRNT_100 << TxDRNT_shift);
  1294. }
  1296. if (duplex == FDX_CAPABLE_FULL_SELECTED) {
  1297. tx_flags |= (TxCSI | TxHBI);
  1298. rx_flags |= RxATX;
  1299. }
  1301. outl (tx_flags, ioaddr + txcfg);
  1302. outl (rx_flags, ioaddr + rxcfg);
  1303. }
  1305. /**
  1306.  * sis900_auto_negotiate:  Set the Auto-Negotiation Enable/Reset bit.
  1307.  * @net_dev: the net device to read mode for
  1308.  * @phy_addr: mii phy address
  1309.  *
  1310.  * If the adapter is link-on, set the auto-negotiate enable/reset bit.
  1311.  * autong_complete should be set to 0 when starting auto-negotiation.
  1312.  * autong_complete should be set to 1 if we didn't start auto-negotiation.
  1313.  * sis900_timer will wait for link on again if autong_complete = 0.
  1314.  */
  1316. static void sis900_auto_negotiate(struct net_device *net_dev, int phy_addr)
  1317. {
  1318. struct sis900_private *sis_priv = net_dev->priv;
  1319. int i = 0;
  1320. u32 status;
  1322. while (i++ < 2)
  1323. status = mdio_read(net_dev, phy_addr, MII_STATUS);
  1325. if (!(status & MII_STAT_LINK)){
  1326. printk(KERN_INFO "%s: Media Link Offn", net_dev->name);
  1327. sis_priv->autong_complete = 1;
  1328. netif_carrier_off(net_dev);
  1329. return;
  1330. }
  1332. /* (Re)start AutoNegotiate */
  1333. mdio_write(net_dev, phy_addr, MII_CONTROL,
  1334.    MII_CNTL_AUTO | MII_CNTL_RST_AUTO);
  1335. sis_priv->autong_complete = 0;
  1336. }
  1339. /**
  1340.  * sis900_read_mode: - read media mode for sis900 internal phy
  1341.  * @net_dev: the net device to read mode for
  1342.  * @speed  : the transmit speed to be determined
  1343.  * @duplex : the duplex mode to be determined
  1344.  *
  1345.  * The capability of remote end will be put in mii register autorec
  1346.  * after auto-negotiation. Use AND operation to get the upper bound
  1347.  * of speed and duplex between two ends.
  1348.  */
  1350. static void sis900_read_mode(struct net_device *net_dev, int *speed, int *duplex)
  1351. {
  1352. struct sis900_private *sis_priv = net_dev->priv;
  1353. struct mii_phy *phy = sis_priv->mii;
  1354. int phy_addr = sis_priv->cur_phy;
  1355. u32 status;
  1356. u16 autoadv, autorec;
  1357. int i = 0;
  1359. while (i++ < 2)
  1360. status = mdio_read(net_dev, phy_addr, MII_STATUS);
  1362. if (!(status & MII_STAT_LINK))
  1363. return;
  1365. /* AutoNegotiate completed */
  1366. autoadv = mdio_read(net_dev, phy_addr, MII_ANADV);
  1367. autorec = mdio_read(net_dev, phy_addr, MII_ANLPAR);
  1368. status = autoadv & autorec;
  1370. *speed = HW_SPEED_10_MBPS;
  1371. *duplex = FDX_CAPABLE_HALF_SELECTED;
  1373. if (status & (MII_NWAY_TX | MII_NWAY_TX_FDX))
  1374. *speed = HW_SPEED_100_MBPS;
  1375. if (status & ( MII_NWAY_TX_FDX | MII_NWAY_T_FDX))
  1376. *duplex = FDX_CAPABLE_FULL_SELECTED;
  1378. sis_priv->autong_complete = 1;
  1380. /* Workaround for Realtek RTL8201 PHY issue */
  1381. if((phy->phy_id0 == 0x0000) && ((phy->phy_id1 & 0xFFF0) == 0x8200)){
  1382. if(mdio_read(net_dev, phy_addr, MII_CONTROL) & MII_CNTL_FDX)
  1383. *duplex = FDX_CAPABLE_FULL_SELECTED;
  1384. if(mdio_read(net_dev, phy_addr, 0x0019) & 0x01)
  1385. *speed = HW_SPEED_100_MBPS;
  1386. }
  1388. printk(KERN_INFO "%s: Media Link On %s %s-duplex n",
  1389.        net_dev->name,
  1390.        *speed == HW_SPEED_100_MBPS ?
  1391.        "100mbps" : "10mbps",
  1392.        *duplex == FDX_CAPABLE_FULL_SELECTED ?
  1393.        "full" : "half");
  1394. }
  1396. /**
  1397.  * sis900_tx_timeout: - sis900 transmit timeout routine
  1398.  * @net_dev: the net device to transmit
  1399.  *
  1400.  * print transmit timeout status
  1401.  * disable interrupts and do some tasks
  1402.  */
  1404. static void sis900_tx_timeout(struct net_device *net_dev)
  1405. {
  1406. struct sis900_private *sis_priv = net_dev->priv;
  1407. long ioaddr = net_dev->base_addr;
  1408. unsigned long flags;
  1409. int i;
  1411. printk(KERN_INFO "%s: Transmit timeout, status %8.8x %8.8x n",
  1412.        net_dev->name, inl(ioaddr + cr), inl(ioaddr + isr));
  1414. /* Disable interrupts by clearing the interrupt mask. */
  1415. outl(0x0000, ioaddr + imr);
  1417. /* use spinlock to prevent interrupt handler accessing buffer ring */
  1418. spin_lock_irqsave(&sis_priv->lock, flags);
  1420. /* discard unsent packets */
  1421. sis_priv->dirty_tx = sis_priv->cur_tx = 0;
  1422. for (i = 0; i < NUM_TX_DESC; i++) {
  1423. struct sk_buff *skb = sis_priv->tx_skbuff[i];
  1425. if (skb) {
  1426. pci_unmap_single(sis_priv->pci_dev, 
  1427. sis_priv->tx_ring[i].bufptr, skb->len,
  1428. PCI_DMA_TODEVICE);
  1429. dev_kfree_skb(skb);
  1430. sis_priv->tx_skbuff[i] = 0;
  1431. sis_priv->tx_ring[i].cmdsts = 0;
  1432. sis_priv->tx_ring[i].bufptr = 0;
  1433. sis_priv->stats.tx_dropped++;
  1434. }
  1435. }
  1436. sis_priv->tx_full = 0;
  1437. netif_wake_queue(net_dev);
  1439. spin_unlock_irqrestore(&sis_priv->lock, flags);
  1441. net_dev->trans_start = jiffies;
  1443. /* load Transmit Descriptor Register */
  1444. outl(sis_priv->tx_ring_dma, ioaddr + txdp);
  1446. /* Enable all known interrupts by setting the interrupt mask. */
  1447. outl((RxSOVR|RxORN|RxERR|RxOK|TxURN|TxERR|TxIDLE), ioaddr + imr);
  1448. return;
  1449. }
  1451. /**
  1452.  * sis900_start_xmit: - sis900 start transmit routine
  1453.  * @skb: socket buffer pointer to put the data being transmitted
  1454.  * @net_dev: the net device to transmit with
  1455.  *
  1456.  * Set the transmit buffer descriptor, 
  1457.  * and write TxENA to enable transimt state machine.
  1458.  * tell upper layer if the buffer is full
  1459.  */
  1461. static int
  1462. sis900_start_xmit(struct sk_buff *skb, struct net_device *net_dev)
  1463. {
  1464. struct sis900_private *sis_priv = net_dev->priv;
  1465. long ioaddr = net_dev->base_addr;
  1466. unsigned int  entry;
  1467. unsigned long flags;
  1468. unsigned int  index_cur_tx, index_dirty_tx;
  1469. unsigned int  count_dirty_tx;
  1471. /* Don't transmit data before the complete of auto-negotiation */
  1472. if(!sis_priv->autong_complete){
  1473. netif_stop_queue(net_dev);
  1474. return 1;
  1475. }
  1477. spin_lock_irqsave(&sis_priv->lock, flags);
  1479. /* Calculate the next Tx descriptor entry. */
  1480. entry = sis_priv->cur_tx % NUM_TX_DESC;
  1481. sis_priv->tx_skbuff[entry] = skb;
  1483. /* set the transmit buffer descriptor and enable Transmit State Machine */
  1484. sis_priv->tx_ring[entry].bufptr = pci_map_single(sis_priv->pci_dev,
  1485. skb->data, skb->len, PCI_DMA_TODEVICE);
  1486. sis_priv->tx_ring[entry].cmdsts = (OWN | skb->len);
  1487. outl(TxENA | inl(ioaddr + cr), ioaddr + cr);
  1489. sis_priv->cur_tx ++;
  1490. index_cur_tx = sis_priv->cur_tx;
  1491. index_dirty_tx = sis_priv->dirty_tx;
  1493. for (count_dirty_tx = 0; index_cur_tx != index_dirty_tx; index_dirty_tx++)
  1494. count_dirty_tx ++;
  1496. if (index_cur_tx == index_dirty_tx) {
  1497. /* dirty_tx is met in the cycle of cur_tx, buffer full */
  1498. sis_priv->tx_full = 1;
  1499. netif_stop_queue(net_dev);
  1500. } else if (count_dirty_tx < NUM_TX_DESC) { 
  1501. /* Typical path, tell upper layer that more transmission is possible */
  1502. netif_start_queue(net_dev);
  1503. } else {
  1504. /* buffer full, tell upper layer no more transmission */
  1505. sis_priv->tx_full = 1;
  1506. netif_stop_queue(net_dev);
  1507. }
  1509. spin_unlock_irqrestore(&sis_priv->lock, flags);
  1511. net_dev->trans_start = jiffies;
  1513. if (sis900_debug > 3)
  1514. printk(KERN_INFO "%s: Queued Tx packet at %p size %d "
  1515.        "to slot %d.n",
  1516.        net_dev->name, skb->data, (int)skb->len, entry);
  1518. return 0;
  1519. }
  1521. /**
  1522.  * sis900_interrupt: - sis900 interrupt handler
  1523.  * @irq: the irq number
  1524.  * @dev_instance: the client data object
  1525.  * @regs: snapshot of processor context
  1526.  *
  1527.  * The interrupt handler does all of the Rx thread work, 
  1528.  * and cleans up after the Tx thread
  1529.  */
  1531. static void sis900_interrupt(int irq, void *dev_instance, struct pt_regs *regs)
  1532. {
  1533. struct net_device *net_dev = dev_instance;
  1534. struct sis900_private *sis_priv = net_dev->priv;
  1535. int boguscnt = max_interrupt_work;
  1536. long ioaddr = net_dev->base_addr;
  1537. u32 status;
  1539. spin_lock (&sis_priv->lock);
  1541. do {
  1542. status = inl(ioaddr + isr);
  1544. if ((status & (HIBERR|TxURN|TxERR|TxIDLE|RxORN|RxERR|RxOK)) == 0)
  1545. /* nothing intresting happened */
  1546. break;
  1548. /* why dow't we break after Tx/Rx case ?? keyword: full-duplex */
  1549. if (status & (RxORN | RxERR | RxOK))
  1550. /* Rx interrupt */
  1551. sis900_rx(net_dev);
  1553. if (status & (TxURN | TxERR | TxIDLE))
  1554. /* Tx interrupt */
  1555. sis900_finish_xmit(net_dev);
  1557. /* something strange happened !!! */
  1558. if (status & HIBERR) {
  1559. printk(KERN_INFO "%s: Abnormal interrupt,"
  1560.        "status %#8.8x.n", net_dev->name, status);
  1561. break;
  1562. }
  1563. if (--boguscnt < 0) {
  1564. printk(KERN_INFO "%s: Too much work at interrupt, "
  1565.        "interrupt status = %#8.8x.n",
  1566.        net_dev->name, status);
  1567. break;
  1568. }
  1569. } while (1);
  1571. if (sis900_debug > 3)
  1572. printk(KERN_INFO "%s: exiting interrupt, "
  1573.        "interrupt status = 0x%#8.8x.n",
  1574.        net_dev->name, inl(ioaddr + isr));
  1576. spin_unlock (&sis_priv->lock);
  1577. return;
  1578. }
  1580. /**
  1581.  * sis900_rx: - sis900 receive routine
  1582.  * @net_dev: the net device which receives data
  1583.  *
  1584.  * Process receive interrupt events, 
  1585.  * put buffer to higher layer and refill buffer pool
  1586.  * Note: This fucntion is called by interrupt handler, 
  1587.  * don't do "too much" work here
  1588.  */
  1590. static int sis900_rx(struct net_device *net_dev)
  1591. {
  1592. struct sis900_private *sis_priv = net_dev->priv;
  1593. long ioaddr = net_dev->base_addr;
  1594. unsigned int entry = sis_priv->cur_rx % NUM_RX_DESC;
  1595. u32 rx_status = sis_priv->rx_ring[entry].cmdsts;
  1597. if (sis900_debug > 3)
  1598. printk(KERN_INFO "sis900_rx, cur_rx:%4.4d, dirty_rx:%4.4d "
  1599.        "status:0x%8.8xn",
  1600.        sis_priv->cur_rx, sis_priv->dirty_rx, rx_status);
  1602. while (rx_status & OWN) {
  1603. unsigned int rx_size;
  1605. rx_size = (rx_status & DSIZE) - CRC_SIZE;
  1607. if (rx_status & (ABORT|OVERRUN|TOOLONG|RUNT|RXISERR|CRCERR|FAERR)) {
  1608. /* corrupted packet received */
  1609. if (sis900_debug > 3)
  1610. printk(KERN_INFO "%s: Corrupted packet "
  1611.        "received, buffer status = 0x%8.8x.n",
  1612.        net_dev->name, rx_status);
  1613. sis_priv->stats.rx_errors++;
  1614. if (rx_status & OVERRUN)
  1615. sis_priv->stats.rx_over_errors++;
  1616. if (rx_status & (TOOLONG|RUNT))
  1617. sis_priv->stats.rx_length_errors++;
  1618. if (rx_status & (RXISERR | FAERR))
  1619. sis_priv->stats.rx_frame_errors++;
  1620. if (rx_status & CRCERR) 
  1621. sis_priv->stats.rx_crc_errors++;
  1622. /* reset buffer descriptor state */
  1623. sis_priv->rx_ring[entry].cmdsts = RX_BUF_SIZE;
  1624. } else {
  1625. struct sk_buff * skb;
  1627. /* This situation should never happen, but due to
  1628.    some unknow bugs, it is possible that
  1629.    we are working on NULL sk_buff :-( */
  1630. if (sis_priv->rx_skbuff[entry] == NULL) {
  1631. printk(KERN_INFO "%s: NULL pointer " 
  1632.        "encountered in Rx ring, skippingn",
  1633.        net_dev->name);
  1634. break;
  1635. }
  1637. pci_dma_sync_single(sis_priv->pci_dev, 
  1638. sis_priv->rx_ring[entry].bufptr, RX_BUF_SIZE, 
  1639. PCI_DMA_FROMDEVICE);
  1640. pci_unmap_single(sis_priv->pci_dev, 
  1641. sis_priv->rx_ring[entry].bufptr, RX_BUF_SIZE, 
  1642. PCI_DMA_FROMDEVICE);
  1643. /* give the socket buffer to upper layers */
  1644. skb = sis_priv->rx_skbuff[entry];
  1645. skb_put(skb, rx_size);
  1646. skb->protocol = eth_type_trans(skb, net_dev);
  1647. netif_rx(skb);
  1649. /* some network statistics */
  1650. if ((rx_status & BCAST) == MCAST)
  1651. sis_priv->stats.multicast++;
  1652. net_dev->last_rx = jiffies;
  1653. sis_priv->stats.rx_bytes += rx_size;
  1654. sis_priv->stats.rx_packets++;
  1656. /* refill the Rx buffer, what if there is not enought memory for
  1657.    new socket buffer ?? */
  1658. if ((skb = dev_alloc_skb(RX_BUF_SIZE)) == NULL) {
  1659. /* not enough memory for skbuff, this makes a "hole"
  1660.    on the buffer ring, it is not clear how the
  1661.    hardware will react to this kind of degenerated
  1662.    buffer */
  1663. printk(KERN_INFO "%s: Memory squeeze,"
  1664.        "deferring packet.n",
  1665.        net_dev->name);
  1666. sis_priv->rx_skbuff[entry] = NULL;
  1667. /* reset buffer descriptor state */
  1668. sis_priv->rx_ring[entry].cmdsts = 0;
  1669. sis_priv->rx_ring[entry].bufptr = 0;
  1670. sis_priv->stats.rx_dropped++;
  1671. break;
  1672. }
  1673. skb->dev = net_dev;
  1674. sis_priv->rx_skbuff[entry] = skb;
  1675. sis_priv->rx_ring[entry].cmdsts = RX_BUF_SIZE;
  1676.                  sis_priv->rx_ring[entry].bufptr = 
  1677. pci_map_single(sis_priv->pci_dev, skb->tail, 
  1678. RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
  1679. sis_priv->dirty_rx++;
  1680. }
  1681. sis_priv->cur_rx++;
  1682. entry = sis_priv->cur_rx % NUM_RX_DESC;
  1683. rx_status = sis_priv->rx_ring[entry].cmdsts;
  1684. } // while
  1686. /* refill the Rx buffer, what if the rate of refilling is slower than 
  1687.    consuming ?? */
  1688. for (;sis_priv->cur_rx - sis_priv->dirty_rx > 0; sis_priv->dirty_rx++) {
  1689. struct sk_buff *skb;
  1691. entry = sis_priv->dirty_rx % NUM_RX_DESC;
  1693. if (sis_priv->rx_skbuff[entry] == NULL) {
  1694. if ((skb = dev_alloc_skb(RX_BUF_SIZE)) == NULL) {
  1695. /* not enough memory for skbuff, this makes a "hole"
  1696.    on the buffer ring, it is not clear how the 
  1697.    hardware will react to this kind of degenerated 
  1698.    buffer */
  1699. printk(KERN_INFO "%s: Memory squeeze,"
  1700.        "deferring packet.n",
  1701.        net_dev->name);
  1702. sis_priv->stats.rx_dropped++;
  1703. break;
  1704. }
  1705. skb->dev = net_dev;
  1706. sis_priv->rx_skbuff[entry] = skb;
  1707. sis_priv->rx_ring[entry].cmdsts = RX_BUF_SIZE;
  1708.                  sis_priv->rx_ring[entry].bufptr =
  1709. pci_map_single(sis_priv->pci_dev, skb->tail,
  1710. RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
  1711. }
  1712. }
  1713. /* re-enable the potentially idle receive state matchine */
  1714. outl(RxENA | inl(ioaddr + cr), ioaddr + cr );
  1716. return 0;
  1717. }
  1719. /**
  1720.  * sis900_finish_xmit: - finish up transmission of packets
  1721.  * @net_dev: the net device to be transmitted on
  1722.  *
  1723.  * Check for error condition and free socket buffer etc 
  1724.  * schedule for more transmission as needed
  1725.  * Note: This fucntion is called by interrupt handler, 
  1726.  * don't do "too much" work here
  1727.  */
  1729. static void sis900_finish_xmit (struct net_device *net_dev)
  1730. {
  1731. struct sis900_private *sis_priv = net_dev->priv;
  1733. for (; sis_priv->dirty_tx != sis_priv->cur_tx; sis_priv->dirty_tx++) {
  1734. struct sk_buff *skb;
  1735. unsigned int entry;
  1736. u32 tx_status;
  1738. entry = sis_priv->dirty_tx % NUM_TX_DESC;
  1739. tx_status = sis_priv->tx_ring[entry].cmdsts;
  1741. if (tx_status & OWN) {
  1742. /* The packet is not transmitted yet (owned by hardware) !
  1743.    Note: the interrupt is generated only when Tx Machine
  1744.    is idle, so this is an almost impossible case */
  1745. break;
  1746. }
  1748. if (tx_status & (ABORT | UNDERRUN | OWCOLL)) {
  1749. /* packet unsuccessfully transmitted */
  1750. if (sis900_debug > 3)
  1751. printk(KERN_INFO "%s: Transmit "
  1752.        "error, Tx status %8.8x.n",
  1753.        net_dev->name, tx_status);
  1754. sis_priv->stats.tx_errors++;
  1755. if (tx_status & UNDERRUN)
  1756. sis_priv->stats.tx_fifo_errors++;
  1757. if (tx_status & ABORT)
  1758. sis_priv->stats.tx_aborted_errors++;
  1759. if (tx_status & NOCARRIER)
  1760. sis_priv->stats.tx_carrier_errors++;
  1761. if (tx_status & OWCOLL)
  1762. sis_priv->stats.tx_window_errors++;
  1763. } else {
  1764. /* packet successfully transmitted */
  1765. sis_priv->stats.collisions += (tx_status & COLCNT) >> 16;
  1766. sis_priv->stats.tx_bytes += tx_status & DSIZE;
  1767. sis_priv->stats.tx_packets++;
  1768. }
  1769. /* Free the original skb. */
  1770. skb = sis_priv->tx_skbuff[entry];
  1771. pci_unmap_single(sis_priv->pci_dev, 
  1772. sis_priv->tx_ring[entry].bufptr, skb->len,
  1773. PCI_DMA_TODEVICE);
  1774. dev_kfree_skb_irq(skb);
  1775. sis_priv->tx_skbuff[entry] = NULL;
  1776. sis_priv->tx_ring[entry].bufptr = 0;
  1777. sis_priv->tx_ring[entry].cmdsts = 0;
  1778. }
  1780. if (sis_priv->tx_full && netif_queue_stopped(net_dev) &&
  1781.     sis_priv->cur_tx - sis_priv->dirty_tx < NUM_TX_DESC - 4) {
  1782. /* The ring is no longer full, clear tx_full and schedule more transmission
  1783.    by netif_wake_queue(net_dev) */
  1784. sis_priv->tx_full = 0;
  1785. netif_wake_queue (net_dev);
  1786. }
  1787. }
  1789. /**
  1790.  * sis900_close: - close sis900 device 
  1791.  * @net_dev: the net device to be closed
  1792.  *
  1793.  * Disable interrupts, stop the Tx and Rx Status Machine 
  1794.  * free Tx and RX socket buffer
  1795.  */
  1797. static int
  1798. sis900_close(struct net_device *net_dev)
  1799. {
  1800. long ioaddr = net_dev->base_addr;
  1801. struct sis900_private *sis_priv = net_dev->priv;
  1802. struct sk_buff *skb;
  1803. int i;
  1805. netif_stop_queue(net_dev);
  1807. /* Disable interrupts by clearing the interrupt mask. */
  1808. outl(0x0000, ioaddr + imr);
  1809. outl(0x0000, ioaddr + ier);
  1811. /* Stop the chip's Tx and Rx Status Machine */
  1812. outl(RxDIS | TxDIS | inl(ioaddr + cr), ioaddr + cr);
  1814. del_timer(&sis_priv->timer);
  1816. free_irq(net_dev->irq, net_dev);
  1818. /* Free Tx and RX skbuff */
  1819. for (i = 0; i < NUM_RX_DESC; i++) {
  1820. skb = sis_priv->rx_skbuff[i];
  1821. if (skb) {
  1822. pci_unmap_single(sis_priv->pci_dev, 
  1823. sis_priv->rx_ring[i].bufptr,
  1824. RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
  1825. dev_kfree_skb(skb);
  1826. sis_priv->rx_skbuff[i] = 0;
  1827. }
  1828. }
  1829. for (i = 0; i < NUM_TX_DESC; i++) {
  1830. skb = sis_priv->tx_skbuff[i];
  1831. if (skb) {
  1832. pci_unmap_single(sis_priv->pci_dev, 
  1833. sis_priv->tx_ring[i].bufptr, skb->len,
  1834. PCI_DMA_TODEVICE);
  1835. dev_kfree_skb(skb);
  1836. sis_priv->tx_skbuff[i] = 0;
  1837. }
  1838. }
  1840. /* Green! Put the chip in low-power mode. */
  1842. return 0;
  1843. }
  1845. /**
  1846.  * netdev_ethtool_ioctl: - For the basic support of ethtool
  1847.  * @net_dev: the net device to command for
  1848.  * @useraddr: start address of interface request
  1849.  *
  1850.  * Process ethtool command such as "ehtool -i" to show information
  1851.  */
  1853. static int netdev_ethtool_ioctl (struct net_device *net_dev, void *useraddr)
  1854. {
  1855.   struct sis900_private *sis_priv = net_dev->priv;
  1856.   u32 ethcmd;
  1858. if (copy_from_user (&ethcmd, useraddr, sizeof (ethcmd)))
  1859. return -EFAULT;
  1861. switch (ethcmd) {
  1862. case ETHTOOL_GDRVINFO:
  1863. {
  1864. struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
  1865. strcpy (info.driver, SIS900_MODULE_NAME);
  1866. strcpy (info.version, SIS900_DRV_VERSION);
  1867. strcpy (info.bus_info, sis_priv->pci_dev->slot_name);
  1868. if (copy_to_user (useraddr, &info, sizeof (info)))
  1869. return -EFAULT;
  1870. return 0;
  1871. }
  1872. default:
  1873. break;
  1874. }
  1876. return -EOPNOTSUPP;
  1877. }
  1879. /**
  1880.  * mii_ioctl: - process MII i/o control command 
  1881.  * @net_dev: the net device to command for
  1882.  * @rq: parameter for command
  1883.  * @cmd: the i/o command
  1884.  *
  1885.  * Process MII command like read/write MII register
  1886.  */
  1888. static int mii_ioctl(struct net_device *net_dev, struct ifreq *rq, int cmd)
  1889. {
  1890. struct sis900_private *sis_priv = net_dev->priv;
  1891. struct mii_ioctl_data *data = (struct mii_ioctl_data *)&rq->ifr_data;
  1893. switch(cmd) {
  1894. case SIOCETHTOOL:
  1895. return netdev_ethtool_ioctl(net_dev, (void *) rq->ifr_data);
  1897. case SIOCGMIIPHY: /* Get address of MII PHY in use. */
  1898. case SIOCDEVPRIVATE: /* for binary compat, remove in 2.5 */
  1899. data->phy_id = sis_priv->mii->phy_addr;
  1900. /* Fall Through */
  1902. case SIOCGMIIREG: /* Read MII PHY register. */
  1903. case SIOCDEVPRIVATE+1: /* for binary compat, remove in 2.5 */
  1904. data->val_out = mdio_read(net_dev, data->phy_id & 0x1f, data->reg_num & 0x1f);
  1905. return 0;
  1907. case SIOCSMIIREG: /* Write MII PHY register. */
  1908. case SIOCDEVPRIVATE+2: /* for binary compat, remove in 2.5 */
  1909. if (!capable(CAP_NET_ADMIN))
  1910. return -EPERM;
  1911. mdio_write(net_dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
  1912. return 0;
  1913. default:
  1914. return -EOPNOTSUPP;
  1915. }
  1916. }
  1918. /**
  1919.  * sis900_get_stats: - Get sis900 read/write statistics 
  1920.  * @net_dev: the net device to get statistics for
  1921.  *
  1922.  * get tx/rx statistics for sis900
  1923.  */
  1925. static struct net_device_stats *
  1926. sis900_get_stats(struct net_device *net_dev)
  1927. {
  1928. struct sis900_private *sis_priv = net_dev->priv;
  1930. return &sis_priv->stats;
  1931. }
  1933. /**
  1934.  * sis900_set_config: - Set media type by net_device.set_config 
  1935.  * @dev: the net device for media type change
  1936.  * @map: ifmap passed by ifconfig
  1937.  *
  1938.  * Set media type to 10baseT, 100baseT or 0(for auto) by ifconfig
  1939.  * we support only port changes. All other runtime configuration
  1940.  * changes will be ignored
  1941.  */
  1943. static int sis900_set_config(struct net_device *dev, struct ifmap *map)
  1944. {    
  1945. struct sis900_private *sis_priv = dev->priv;
  1946. struct mii_phy *mii_phy = sis_priv->mii;
  1947.         
  1948. u16 status;
  1950. if ((map->port != (u_char)(-1)) && (map->port != dev->if_port)) {
  1951. /* we switch on the ifmap->port field. I couldn't find anything
  1952.    like a definition or standard for the values of that field.
  1953.    I think the meaning of those values is device specific. But
  1954.    since I would like to change the media type via the ifconfig
  1955.    command I use the definition from linux/netdevice.h 
  1956.    (which seems to be different from the ifport(pcmcia) definition) 
  1957. */
  1958. switch(map->port){
  1959. case IF_PORT_UNKNOWN: /* use auto here */   
  1960. dev->if_port = map->port;
  1961. /* we are going to change the media type, so the Link will
  1962.    be temporary down and we need to reflect that here. When
  1963.    the Link comes up again, it will be sensed by the sis_timer
  1964.    procedure, which also does all the rest for us */
  1965. netif_carrier_off(dev);
  1966.                 
  1967. /* read current state */
  1968. status = mdio_read(dev, mii_phy->phy_addr, MII_CONTROL);
  1969.                 
  1970. /* enable auto negotiation and reset the negotioation
  1971.    (I dont really know what the auto negatiotiation reset
  1972.    really means, but it sounds for me right to do one here)*/
  1973. mdio_write(dev, mii_phy->phy_addr,
  1974.    MII_CONTROL, status | MII_CNTL_AUTO | MII_CNTL_RST_AUTO);
  1976. break;
  1977.             
  1978. case IF_PORT_10BASET: /* 10BaseT */         
  1979. dev->if_port = map->port;
  1980.                 
  1981. /* we are going to change the media type, so the Link will
  1982.    be temporary down and we need to reflect that here. When
  1983.    the Link comes up again, it will be sensed by the sis_timer
  1984.    procedure, which also does all the rest for us */
  1985. netif_carrier_off(dev);
  1986.         
  1987. /* set Speed to 10Mbps */
  1988. /* read current state */
  1989. status = mdio_read(dev, mii_phy->phy_addr, MII_CONTROL);
  1990.                 
  1991. /* disable auto negotiation and force 10MBit mode*/
  1992. mdio_write(dev, mii_phy->phy_addr,
  1993.    MII_CONTROL, status & ~(MII_CNTL_SPEED | MII_CNTL_AUTO));
  1994. break;
  1995.             
  1996. case IF_PORT_100BASET: /* 100BaseT */
  1997. case IF_PORT_100BASETX: /* 100BaseTx */ 
  1998. dev->if_port = map->port;
  1999.                 
  2000. /* we are going to change the media type, so the Link will
  2001.    be temporary down and we need to reflect that here. When
  2002.    the Link comes up again, it will be sensed by the sis_timer
  2003.    procedure, which also does all the rest for us */
  2004. netif_carrier_off(dev);
  2005.                 
  2006. /* set Speed to 100Mbps */
  2007. /* disable auto negotiation and enable 100MBit Mode */
  2008. status = mdio_read(dev, mii_phy->phy_addr, MII_CONTROL);
  2009. mdio_write(dev, mii_phy->phy_addr,
  2010.    MII_CONTROL, (status & ~MII_CNTL_SPEED) | MII_CNTL_SPEED);
  2011.                 
  2012. break;
  2013.             
  2014. case IF_PORT_10BASE2: /* 10Base2 */
  2015. case IF_PORT_AUI: /* AUI */
  2016. case IF_PORT_100BASEFX: /* 100BaseFx */
  2017.                  /* These Modes are not supported (are they?)*/
  2018. printk(KERN_INFO "Not supported");
  2019. return -EOPNOTSUPP;
  2020. break;
  2021.             
  2022. default:
  2023. printk(KERN_INFO "Invalid");
  2024. return -EINVAL;
  2025. }
  2026. }
  2027. return 0;
  2028. }
  2030. /**
  2031.  * sis900_compute_hashtable_index: - compute hashtable index 
  2032.  * @addr: multicast address
  2033.  * @revision: revision id of chip
  2034.  *
  2035.  * SiS 900 uses the most sigificant 7 bits to index a 128 bits multicast
  2036.  * hash table, which makes this function a little bit different from other drivers
  2037.  * SiS 900 B0 & 635 M/B uses the most significat 8 bits to index 256 bits
  2038.  *    multicast hash table. 
  2039.  */
  2041. static u16 sis900_compute_hashtable_index(u8 *addr, u8 revision)
  2042. {
  2044. u32 crc = ether_crc(6, addr);
  2046. /* leave 8 or 7 most siginifant bits */
  2047. if ((revision >= SIS635A_900_REV) || (revision == SIS900B_900_REV))
  2048. return ((int)(crc >> 24));
  2049. else
  2050. return ((int)(crc >> 25));
  2051. }
  2053. /**
  2054.  * set_rx_mode: - Set SiS900 receive mode 
  2055.  * @net_dev: the net device to be set
  2056.  *
  2057.  * Set SiS900 receive mode for promiscuous, multicast, or broadcast mode.
  2058.  * And set the appropriate multicast filter.
  2059.  * Multicast hash table changes from 128 to 256 bits for 635M/B & 900B0.
  2060.  */
  2062. static void set_rx_mode(struct net_device *net_dev)
  2063. {
  2064. long ioaddr = net_dev->base_addr;
  2065. struct sis900_private * sis_priv = net_dev->priv;
  2066. u16 mc_filter[16] = {0}; /* 256/128 bits multicast hash table */
  2067. int i, table_entries;
  2068. u32 rx_mode;
  2069. u8 revision;
  2071. /* 635 Hash Table entires = 256(2^16) */
  2072. pci_read_config_byte(sis_priv->pci_dev, PCI_CLASS_REVISION, &revision);
  2073. if((revision >= SIS635A_900_REV) || (revision == SIS900B_900_REV))
  2074. table_entries = 16;
  2075. else
  2076. table_entries = 8;
  2078. if (net_dev->flags & IFF_PROMISC) {
  2079. /* Accept any kinds of packets */
  2080. rx_mode = RFPromiscuous;
  2081. for (i = 0; i < table_entries; i++)
  2082. mc_filter[i] = 0xffff;
  2083. } else if ((net_dev->mc_count > multicast_filter_limit) ||
  2084.    (net_dev->flags & IFF_ALLMULTI)) {
  2085. /* too many multicast addresses or accept all multicast packet */
  2086. rx_mode = RFAAB | RFAAM;
  2087. for (i = 0; i < table_entries; i++)
  2088. mc_filter[i] = 0xffff;
  2089. } else {
  2090. /* Accept Broadcast packet, destination address matchs our MAC address,
  2091.    use Receive Filter to reject unwanted MCAST packet */
  2092. struct dev_mc_list *mclist;
  2093. rx_mode = RFAAB;
  2094. for (i = 0, mclist = net_dev->mc_list; mclist && i < net_dev->mc_count;
  2095.      i++, mclist = mclist->next)
  2096. set_bit(sis900_compute_hashtable_index(mclist->dmi_addr, revision),
  2097. mc_filter);
  2098. }
  2100. /* update Multicast Hash Table in Receive Filter */
  2101. for (i = 0; i < table_entries; i++) {
  2102.                 /* why plus 0x04 ??, That makes the correct value for hash table. */
  2103. outl((u32)(0x00000004+i) << RFADDR_shift, ioaddr + rfcr);
  2104. outl(mc_filter[i], ioaddr + rfdr);
  2105. }
  2107. outl(RFEN | rx_mode, ioaddr + rfcr);
  2109. /* sis900 is capatable of looping back packet at MAC level for debugging purpose */
  2110. if (net_dev->flags & IFF_LOOPBACK) {
  2111. u32 cr_saved;
  2112. /* We must disable Tx/Rx before setting loopback mode */
  2113. cr_saved = inl(ioaddr + cr);
  2114. outl(cr_saved | TxDIS | RxDIS, ioaddr + cr);
  2115. /* enable loopback */
  2116. outl(inl(ioaddr + txcfg) | TxMLB, ioaddr + txcfg);
  2117. outl(inl(ioaddr + rxcfg) | RxATX, ioaddr + rxcfg);
  2118. /* restore cr */
  2119. outl(cr_saved, ioaddr + cr);
  2120. }
  2122. return;
  2123. }
  2125. /**
  2126.  * sis900_reset: - Reset sis900 MAC 
  2127.  * @net_dev: the net device to reset
  2128.  *
  2129.  * reset sis900 MAC and wait until finished
  2130.  * reset through command register
  2131.  * change backoff algorithm for 900B0 & 635 M/B
  2132.  */
  2134. static void sis900_reset(struct net_device *net_dev)
  2135. {
  2136. struct sis900_private * sis_priv = net_dev->priv;
  2137. long ioaddr = net_dev->base_addr;
  2138. int i = 0;
  2139. u32 status = TxRCMP | RxRCMP;
  2140. u8  revision;
  2142. outl(0, ioaddr + ier);
  2143. outl(0, ioaddr + imr);
  2144. outl(0, ioaddr + rfcr);
  2146. outl(RxRESET | TxRESET | RESET | inl(ioaddr + cr), ioaddr + cr);
  2148. /* Check that the chip has finished the reset. */
  2149. while (status && (i++ < 1000)) {
  2150. status ^= (inl(isr + ioaddr) & status);
  2151. }
  2153. pci_read_config_byte(sis_priv->pci_dev, PCI_CLASS_REVISION, &revision);
  2154. if( (revision >= SIS635A_900_REV) || (revision == SIS900B_900_REV) )
  2155. outl(PESEL | RND_CNT, ioaddr + cfg);
  2156. else
  2157. outl(PESEL, ioaddr + cfg);
  2158. }
  2160. /**
  2161.  * sis900_remove: - Remove sis900 device 
  2162.  * @pci_dev: the pci device to be removed
  2163.  *
  2164.  * remove and release SiS900 net device
  2165.  */
  2167. static void __devexit sis900_remove(struct pci_dev *pci_dev)
  2168. {
  2169. struct net_device *net_dev = pci_get_drvdata(pci_dev);
  2170. struct sis900_private * sis_priv = net_dev->priv;
  2171. struct mii_phy *phy = NULL;
  2173. while (sis_priv->first_mii) {
  2174. phy = sis_priv->first_mii;
  2175. sis_priv->first_mii = phy->next;
  2176. kfree(phy);
  2177. }
  2179. pci_free_consistent(pci_dev, RX_TOTAL_SIZE, sis_priv->rx_ring,
  2180. sis_priv->rx_ring_dma);
  2181. pci_free_consistent(pci_dev, TX_TOTAL_SIZE, sis_priv->tx_ring,
  2182. sis_priv->tx_ring_dma);
  2183. unregister_netdev(net_dev);
  2184. kfree(net_dev);
  2185. pci_release_regions(pci_dev);
  2186. pci_set_drvdata(pci_dev, NULL);
  2187. }
  2189. static struct pci_driver sis900_pci_driver = {
  2190. name: SIS900_MODULE_NAME,
  2191. id_table: sis900_pci_tbl,
  2192. probe: sis900_probe,
  2193. remove: __devexit_p(sis900_remove),
  2194. };
  2196. static int __init sis900_init_module(void)
  2197. {
  2198. /* when a module, this is printed whether or not devices are found in probe */
  2199. #ifdef MODULE
  2200. printk(version);
  2201. #endif
  2203. return pci_module_init(&sis900_pci_driver);
  2204. }
  2206. static void __exit sis900_cleanup_module(void)
  2207. {
  2208. pci_unregister_driver(&sis900_pci_driver);
  2209. }
  2211. module_init(sis900_init_module);
  2212. module_exit(sis900_cleanup_module);