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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
sis900.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：63k
源码类别：

嵌入式Linux

开发平台：

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