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

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

Linux/Unix编程

开发平台：

Unix_Linux

dmfe.c：源码内容
  1. /*
  2.     A Davicom DM9102/DM9102A/DM9102A+DM9801/DM9102A+DM9802 NIC fast
  3.     ethernet driver for Linux.
  4.     Copyright (C) 1997  Sten Wang
  6.     This program is free software; you can redistribute it and/or
  7.     modify it under the terms of the GNU General Public License
  8.     as published by the Free Software Foundation; either version 2
  9.     of the License, or (at your option) any later version.
  11.     This program is distributed in the hope that it will be useful,
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  16.     DAVICOM Web-Site: www.davicom.com.tw
  18.     Author: Sten Wang, 886-3-5798797-8517, E-mail: sten_wang@davicom.com.tw
  19.     Maintainer: Tobias Ringstrom <tori@unhappy.mine.nu>
  21.     (C)Copyright 1997-1998 DAVICOM Semiconductor,Inc. All Rights Reserved.
  23.     Marcelo Tosatti <marcelo@conectiva.com.br> :
  24.     Made it compile in 2.3 (device to net_device)
  26.     Alan Cox <alan@redhat.com> :
  27.     Cleaned up for kernel merge.
  28.     Removed the back compatibility support
  29.     Reformatted, fixing spelling etc as I went
  30.     Removed IRQ 0-15 assumption
  32.     Jeff Garzik <jgarzik@mandrakesoft.com> :
  33.     Updated to use new PCI driver API.
  34.     Resource usage cleanups.
  35.     Report driver version to user.
  37.     Tobias Ringstrom <tori@unhappy.mine.nu> :
  38.     Cleaned up and added SMP safety.  Thanks go to Jeff Garzik,
  39.     Andrew Morton and Frank Davis for the SMP safety fixes.
  41.     Vojtech Pavlik <vojtech@suse.cz> :
  42.     Cleaned up pointer arithmetics.
  43.     Fixed a lot of 64bit issues.
  44.     Cleaned up printk()s a bit.
  45.     Fixed some obvious big endian problems.
  47.     Tobias Ringstrom <tori@unhappy.mine.nu> :
  48.     Use time_after for jiffies calculation.  Added ethtool
  49.     support.  Updated PCI resource allocation.  Do not
  50.     forget to unmap PCI mapped skbs.
  52.     TODO
  54.     Implement pci_driver::suspend() and pci_driver::resume()
  55.     power management methods.
  57.     Check on 64 bit boxes.
  58.     Check and fix on big endian boxes.
  60.     Test and make sure PCI latency is now correct for all cases.
  61. */
  63. #define DRV_NAME "dmfe"
  64. #define DRV_VERSION "1.36.4"
  65. #define DRV_RELDATE "2002-01-17"
  67. #include <linux/module.h>
  69. #include <linux/kernel.h>
  70. #include <linux/sched.h>
  71. #include <linux/string.h>
  72. #include <linux/timer.h>
  73. #include <linux/ptrace.h>
  74. #include <linux/errno.h>
  75. #include <linux/ioport.h>
  76. #include <linux/slab.h>
  77. #include <linux/interrupt.h>
  78. #include <linux/pci.h>
  79. #include <linux/init.h>
  80. #include <linux/version.h>
  81. #include <linux/netdevice.h>
  82. #include <linux/etherdevice.h>
  83. #include <linux/ethtool.h>
  84. #include <linux/skbuff.h>
  85. #include <linux/delay.h>
  86. #include <linux/spinlock.h>
  87. #include <linux/crc32.h>
  89. #include <asm/processor.h>
  90. #include <asm/bitops.h>
  91. #include <asm/io.h>
  92. #include <asm/dma.h>
  93. #include <asm/uaccess.h>
  96. /* Board/System/Debug information/definition ---------------- */
  97. #define PCI_DM9132_ID   0x91321282      /* Davicom DM9132 ID */
  98. #define PCI_DM9102_ID   0x91021282      /* Davicom DM9102 ID */
  99. #define PCI_DM9100_ID   0x91001282      /* Davicom DM9100 ID */
  100. #define PCI_DM9009_ID   0x90091282      /* Davicom DM9009 ID */
  102. #define DM9102_IO_SIZE  0x80
  103. #define DM9102A_IO_SIZE 0x100
  104. #define TX_MAX_SEND_CNT 0x1             /* Maximum tx packet per time */
  105. #define TX_DESC_CNT     0x10            /* Allocated Tx descriptors */
  106. #define RX_DESC_CNT     0x20            /* Allocated Rx descriptors */
  107. #define TX_FREE_DESC_CNT (TX_DESC_CNT - 2) /* Max TX packet count */
  108. #define TX_WAKE_DESC_CNT (TX_DESC_CNT - 3) /* TX wakeup count */
  109. #define DESC_ALL_CNT    (TX_DESC_CNT + RX_DESC_CNT)
  110. #define TX_BUF_ALLOC    0x600
  111. #define RX_ALLOC_SIZE   0x620
  112. #define DM910X_RESET    1
  113. #define CR0_DEFAULT     0x00E00000      /* TX & RX burst mode */
  114. #define CR6_DEFAULT     0x00080000      /* HD */
  115. #define CR7_DEFAULT     0x180c1
  116. #define CR15_DEFAULT    0x06            /* TxJabber RxWatchdog */
  117. #define TDES0_ERR_MASK  0x4302          /* TXJT, LC, EC, FUE */
  118. #define MAX_PACKET_SIZE 1514
  119. #define DMFE_MAX_MULTICAST 14
  120. #define RX_COPY_SIZE 100
  121. #define MAX_CHECK_PACKET 0x8000
  122. #define DM9801_NOISE_FLOOR 8
  123. #define DM9802_NOISE_FLOOR 5
  125. #define DMFE_10MHF      0
  126. #define DMFE_100MHF     1
  127. #define DMFE_10MFD      4
  128. #define DMFE_100MFD     5
  129. #define DMFE_AUTO       8
  130. #define DMFE_1M_HPNA    0x10
  132. #define DMFE_TXTH_72 0x400000 /* TX TH 72 byte */
  133. #define DMFE_TXTH_96 0x404000 /* TX TH 96 byte */
  134. #define DMFE_TXTH_128 0x0000 /* TX TH 128 byte */
  135. #define DMFE_TXTH_256 0x4000 /* TX TH 256 byte */
  136. #define DMFE_TXTH_512 0x8000 /* TX TH 512 byte */
  137. #define DMFE_TXTH_1K 0xC000 /* TX TH 1K  byte */
  139. #define DMFE_TIMER_WUT  (jiffies + HZ * 1)/* timer wakeup time : 1 second */
  140. #define DMFE_TX_TIMEOUT ((3*HZ)/2) /* tx packet time-out time 1.5 s" */
  141. #define DMFE_TX_KICK  (HZ/2) /* tx packet Kick-out time 0.5 s" */
  143. #define DMFE_DBUG(dbug_now, msg, value) if (dmfe_debug || (dbug_now)) printk(KERN_ERR DRV_NAME ": %s %lxn", (msg), (long) (value))
  145. #define SHOW_MEDIA_TYPE(mode) printk(KERN_ERR DRV_NAME ": Change Speed to %sMhz %s duplexn",mode & 1 ?"100":"10", mode & 4 ? "full":"half");
  148. /* CR9 definition: SROM/MII */
  149. #define CR9_SROM_READ   0x4800
  150. #define CR9_SRCS        0x1
  151. #define CR9_SRCLK       0x2
  152. #define CR9_CRDOUT      0x8
  153. #define SROM_DATA_0     0x0
  154. #define SROM_DATA_1     0x4
  155. #define PHY_DATA_1      0x20000
  156. #define PHY_DATA_0      0x00000
  157. #define MDCLKH          0x10000
  159. #define PHY_POWER_DOWN 0x800
  161. #define SROM_V41_CODE   0x14
  163. #define SROM_CLK_WRITE(data, ioaddr) outl(data|CR9_SROM_READ|CR9_SRCS,ioaddr);udelay(5);outl(data|CR9_SROM_READ|CR9_SRCS|CR9_SRCLK,ioaddr);udelay(5);outl(data|CR9_SROM_READ|CR9_SRCS,ioaddr);udelay(5);
  165. #define __CHK_IO_SIZE(pci_id, dev_rev) ( ((pci_id)==PCI_DM9132_ID) || ((dev_rev) >= 0x02000030) ) ? DM9102A_IO_SIZE: DM9102_IO_SIZE
  166. #define CHK_IO_SIZE(pci_dev, dev_rev) __CHK_IO_SIZE(((pci_dev)->device << 16) | (pci_dev)->vendor, dev_rev)
  168. /* Sten Check */
  169. #define DEVICE net_device
  171. /* Structure/enum declaration ------------------------------- */
  172. struct tx_desc {
  173.         u32 tdes0, tdes1, tdes2, tdes3; /* Data for the card */
  174.         char *tx_buf_ptr;               /* Data for us */
  175.         struct tx_desc *next_tx_desc;
  176. } __attribute__(( aligned(32) ));
  178. struct rx_desc {
  179. u32 rdes0, rdes1, rdes2, rdes3; /* Data for the card */
  180. struct sk_buff *rx_skb_ptr; /* Data for us */
  181. struct rx_desc *next_rx_desc;
  182. } __attribute__(( aligned(32) ));
  184. struct dmfe_board_info {
  185. u32 chip_id; /* Chip vendor/Device ID */
  186. u32 chip_revision; /* Chip revision */
  187. struct DEVICE *next_dev; /* next device */
  188. struct pci_dev *pdev; /* PCI device */
  189. spinlock_t lock;
  191. long ioaddr; /* I/O base address */
  192. u32 cr0_data;
  193. u32 cr5_data;
  194. u32 cr6_data;
  195. u32 cr7_data;
  196. u32 cr15_data;
  198. /* pointer for memory physical address */
  199. dma_addr_t buf_pool_dma_ptr; /* Tx buffer pool memory */
  200. dma_addr_t buf_pool_dma_start; /* Tx buffer pool align dword */
  201. dma_addr_t desc_pool_dma_ptr; /* descriptor pool memory */
  202. dma_addr_t first_tx_desc_dma;
  203. dma_addr_t first_rx_desc_dma;
  205. /* descriptor pointer */
  206. unsigned char *buf_pool_ptr; /* Tx buffer pool memory */
  207. unsigned char *buf_pool_start; /* Tx buffer pool align dword */
  208. unsigned char *desc_pool_ptr; /* descriptor pool memory */
  209. struct tx_desc *first_tx_desc;
  210. struct tx_desc *tx_insert_ptr;
  211. struct tx_desc *tx_remove_ptr;
  212. struct rx_desc *first_rx_desc;
  213. struct rx_desc *rx_insert_ptr;
  214. struct rx_desc *rx_ready_ptr; /* packet come pointer */
  215. unsigned long tx_packet_cnt; /* transmitted packet count */
  216. unsigned long tx_queue_cnt; /* wait to send packet count */
  217. unsigned long rx_avail_cnt; /* available rx descriptor count */
  218. unsigned long interval_rx_cnt; /* rx packet count a callback time */
  220. u16 HPNA_command; /* For HPNA register 16 */
  221. u16 HPNA_timer; /* For HPNA remote device check */
  222. u16 dbug_cnt;
  223. u16 NIC_capability; /* NIC media capability */
  224. u16 PHY_reg4; /* Saved Phyxcer register 4 value */
  226. u8 HPNA_present; /* 0:none, 1:DM9801, 2:DM9802 */
  227. u8 chip_type; /* Keep DM9102A chip type */
  228. u8 media_mode; /* user specify media mode */
  229. u8 op_mode; /* real work media mode */
  230. u8 phy_addr;
  231. u8 link_failed; /* Ever link failed */
  232. u8 wait_reset; /* Hardware failed, need to reset */
  233. u8 dm910x_chk_mode; /* Operating mode check */
  234. u8 first_in_callback; /* Flag to record state */
  235. struct timer_list timer;
  237. /* System defined statistic counter */
  238. struct net_device_stats stats;
  240. /* Driver defined statistic counter */
  241. unsigned long tx_fifo_underrun;
  242. unsigned long tx_loss_carrier;
  243. unsigned long tx_no_carrier;
  244. unsigned long tx_late_collision;
  245. unsigned long tx_excessive_collision;
  246. unsigned long tx_jabber_timeout;
  247. unsigned long reset_count;
  248. unsigned long reset_cr8;
  249. unsigned long reset_fatal;
  250. unsigned long reset_TXtimeout;
  252. /* NIC SROM data */
  253. unsigned char srom[128];
  254. };
  256. enum dmfe_offsets {
  257. DCR0 = 0x00, DCR1 = 0x08, DCR2 = 0x10, DCR3 = 0x18, DCR4 = 0x20,
  258. DCR5 = 0x28, DCR6 = 0x30, DCR7 = 0x38, DCR8 = 0x40, DCR9 = 0x48,
  259. DCR10 = 0x50, DCR11 = 0x58, DCR12 = 0x60, DCR13 = 0x68, DCR14 = 0x70,
  260. DCR15 = 0x78
  261. };
  263. enum dmfe_CR6_bits {
  264. CR6_RXSC = 0x2, CR6_PBF = 0x8, CR6_PM = 0x40, CR6_PAM = 0x80,
  265. CR6_FDM = 0x200, CR6_TXSC = 0x2000, CR6_STI = 0x100000,
  266. CR6_SFT = 0x200000, CR6_RXA = 0x40000000, CR6_NO_PURGE = 0x20000000
  267. };
  269. /* Global variable declaration ----------------------------- */
  270. static int __devinitdata printed_version;
  271. static char version[] __devinitdata =
  272. KERN_INFO DRV_NAME ": Davicom DM9xxx net driver, version "
  273. DRV_VERSION " (" DRV_RELDATE ")n";
  275. static int dmfe_debug;
  276. static unsigned char dmfe_media_mode = DMFE_AUTO;
  277. static u32 dmfe_cr6_user_set;
  279. /* For module input parameter */
  280. static int debug;
  281. static u32 cr6set;
  282. static unsigned char mode = 8;
  283. static u8 chkmode = 1;
  284. static u8 HPNA_mode; /* Default: Low Power/High Speed */
  285. static u8 HPNA_rx_cmd; /* Default: Disable Rx remote command */
  286. static u8 HPNA_tx_cmd; /* Default: Don't issue remote command */
  287. static u8 HPNA_NoiseFloor; /* Default: HPNA NoiseFloor */
  288. static u8 SF_mode; /* Special Function: 1:VLAN, 2:RX Flow Control
  289.    4: TX pause packet */
  292. /* function declaration ------------------------------------- */
  293. static int dmfe_open(struct DEVICE *);
  294. static int dmfe_start_xmit(struct sk_buff *, struct DEVICE *);
  295. static int dmfe_stop(struct DEVICE *);
  296. static struct net_device_stats * dmfe_get_stats(struct DEVICE *);
  297. static void dmfe_set_filter_mode(struct DEVICE *);
  298. static int dmfe_do_ioctl(struct DEVICE *, struct ifreq *, int);
  299. static u16 read_srom_word(long ,int);
  300. static void dmfe_interrupt(int , void *, struct pt_regs *);
  301. static void dmfe_descriptor_init(struct dmfe_board_info *, unsigned long);
  302. static void allocate_rx_buffer(struct dmfe_board_info *);
  303. static void update_cr6(u32, unsigned long);
  304. static void send_filter_frame(struct DEVICE * ,int);
  305. static void dm9132_id_table(struct DEVICE * ,int);
  306. static u16 phy_read(unsigned long, u8, u8, u32);
  307. static void phy_write(unsigned long, u8, u8, u16, u32);
  308. static void phy_write_1bit(unsigned long, u32);
  309. static u16 phy_read_1bit(unsigned long);
  310. static u8 dmfe_sense_speed(struct dmfe_board_info *);
  311. static void dmfe_process_mode(struct dmfe_board_info *);
  312. static void dmfe_timer(unsigned long);
  313. static void dmfe_rx_packet(struct DEVICE *, struct dmfe_board_info *);
  314. static void dmfe_free_tx_pkt(struct DEVICE *, struct dmfe_board_info *);
  315. static void dmfe_reuse_skb(struct dmfe_board_info *, struct sk_buff *);
  316. static void dmfe_dynamic_reset(struct DEVICE *);
  317. static void dmfe_free_rxbuffer(struct dmfe_board_info *);
  318. static void dmfe_init_dm910x(struct DEVICE *);
  319. static inline u32 cal_CRC(unsigned char *, unsigned int, u8);
  320. static void dmfe_parse_srom(struct dmfe_board_info *);
  321. static void dmfe_program_DM9801(struct dmfe_board_info *, int);
  322. static void dmfe_program_DM9802(struct dmfe_board_info *);
  323. static void dmfe_HPNA_remote_cmd_chk(struct dmfe_board_info * );
  324. static void dmfe_set_phyxcer(struct dmfe_board_info *);
  326. /* DM910X network baord routine ---------------------------- */
  328. /*
  329.  * Search DM910X board ,allocate space and register it
  330.  */
  332. static int __devinit dmfe_init_one (struct pci_dev *pdev,
  333.     const struct pci_device_id *ent)
  334. {
  335. struct dmfe_board_info *db; /* board information structure */
  336. struct net_device *dev;
  337. u32 dev_rev, pci_pmr;
  338. int i, err;
  340. DMFE_DBUG(0, "dmfe_init_one()", 0);
  342. if (!printed_version++)
  343. printk(version);
  345. /* Init network device */
  346. dev = alloc_etherdev(sizeof(*db));
  347. if (dev == NULL)
  348. return -ENOMEM;
  349. SET_MODULE_OWNER(dev);
  351. if (pci_set_dma_mask(pdev, 0xffffffff)) {
  352. printk(KERN_WARNING DRV_NAME ": 32-bit PCI DMA not available.n");
  353. err = -ENODEV;
  354. goto err_out_free;
  355. }
  357. /* Enable Master/IO access, Disable memory access */
  358. err = pci_enable_device(pdev);
  359. if (err)
  360. goto err_out_free;
  362. if (!pci_resource_start(pdev, 0)) {
  363. printk(KERN_ERR DRV_NAME ": I/O base is zeron");
  364. err = -ENODEV;
  365. goto err_out_disable;
  366. }
  368. /* Read Chip revision */
  369. pci_read_config_dword(pdev, PCI_REVISION_ID, &dev_rev);
  371. if (pci_resource_len(pdev, 0) < (CHK_IO_SIZE(pdev, dev_rev)) ) {
  372. printk(KERN_ERR DRV_NAME ": Allocated I/O size too smalln");
  373. err = -ENODEV;
  374. goto err_out_disable;
  375. }
  377. #if 0 /* pci_{enable_device,set_master} sets minimum latency for us now */
  379. /* Set Latency Timer 80h */
  380. /* FIXME: setting values > 32 breaks some SiS 559x stuff.
  381.    Need a PCI quirk.. */
  383. pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 0x80);
  384. #endif
  386. if (pci_request_regions(pdev, DRV_NAME)) {
  387. printk(KERN_ERR DRV_NAME ": Failed to request PCI regionsn");
  388. err = -ENODEV;
  389. goto err_out_disable;
  390. }
  392. /* Init system & device */
  393. db = dev->priv;
  395. /* Allocate Tx/Rx descriptor memory */
  396. db->desc_pool_ptr = pci_alloc_consistent(pdev, sizeof(struct tx_desc) * DESC_ALL_CNT + 0x20, &db->desc_pool_dma_ptr);
  397. db->buf_pool_ptr = pci_alloc_consistent(pdev, TX_BUF_ALLOC * TX_DESC_CNT + 4, &db->buf_pool_dma_ptr);
  399. db->first_tx_desc = (struct tx_desc *) db->desc_pool_ptr;
  400. db->first_tx_desc_dma = db->desc_pool_dma_ptr;
  401. db->buf_pool_start = db->buf_pool_ptr;
  402. db->buf_pool_dma_start = db->buf_pool_dma_ptr;
  404. db->chip_id = ent->driver_data;
  405. db->ioaddr = pci_resource_start(pdev, 0);
  406. db->chip_revision = dev_rev;
  408. db->pdev = pdev;
  410. dev->base_addr = db->ioaddr;
  411. dev->irq = pdev->irq;
  412. pci_set_drvdata(pdev, dev);
  413. dev->open = &dmfe_open;
  414. dev->hard_start_xmit = &dmfe_start_xmit;
  415. dev->stop = &dmfe_stop;
  416. dev->get_stats = &dmfe_get_stats;
  417. dev->set_multicast_list = &dmfe_set_filter_mode;
  418. dev->do_ioctl = &dmfe_do_ioctl;
  419. spin_lock_init(&db->lock);
  421. pci_read_config_dword(pdev, 0x50, &pci_pmr);
  422. pci_pmr &= 0x70000;
  423. if ( (pci_pmr == 0x10000) && (dev_rev == 0x02000031) )
  424. db->chip_type = 1; /* DM9102A E3 */
  425. else
  426. db->chip_type = 0;
  428. /* read 64 word srom data */
  429. for (i = 0; i < 64; i++)
  430. ((u16 *) db->srom)[i] = cpu_to_le16(read_srom_word(db->ioaddr, i));
  432. /* Set Node address */
  433. for (i = 0; i < 6; i++)
  434. dev->dev_addr[i] = db->srom[20 + i];
  436. err = register_netdev (dev);
  437. if (err)
  438. goto err_out_res;
  440. printk(KERN_INFO "%s: Davicom DM%04lx at pci%s,",
  441. dev->name,
  442. ent->driver_data >> 16,
  443. pdev->slot_name);
  444. for (i = 0; i < 6; i++)
  445. printk("%c%02x", i ? ':' : ' ', dev->dev_addr[i]);
  446. printk(", irq %d.n", dev->irq);
  448. pci_set_master(pdev);
  450. return 0;
  452. err_out_res:
  453. pci_release_regions(pdev);
  454. err_out_disable:
  455. pci_disable_device(pdev);
  456. err_out_free:
  457. pci_set_drvdata(pdev, NULL);
  458. kfree(dev);
  460. return err;
  461. }
  464. static void __devexit dmfe_remove_one (struct pci_dev *pdev)
  465. {
  466. struct net_device *dev = pci_get_drvdata(pdev);
  467. struct dmfe_board_info *db = dev->priv;
  469. DMFE_DBUG(0, "dmfe_remove_one()", 0);
  471.   if (dev) {
  472. pci_free_consistent(db->pdev, sizeof(struct tx_desc) *
  473. DESC_ALL_CNT + 0x20, db->desc_pool_ptr,
  474.   db->desc_pool_dma_ptr);
  475. pci_free_consistent(db->pdev, TX_BUF_ALLOC * TX_DESC_CNT + 4,
  476. db->buf_pool_ptr, db->buf_pool_dma_ptr);
  477. unregister_netdev(dev);
  478. pci_release_regions(pdev);
  479. kfree(dev); /* free board information */
  480. pci_set_drvdata(pdev, NULL);
  481. }
  483. DMFE_DBUG(0, "dmfe_remove_one() exit", 0);
  484. }
  487. /*
  488.  * Open the interface.
  489.  * The interface is opened whenever "ifconfig" actives it.
  490.  */
  492. static int dmfe_open(struct DEVICE *dev)
  493. {
  494. int ret;
  495. struct dmfe_board_info *db = dev->priv;
  497. DMFE_DBUG(0, "dmfe_open", 0);
  499. ret = request_irq(dev->irq, &dmfe_interrupt, SA_SHIRQ, dev->name, dev);
  500. if (ret)
  501. return ret;
  503. /* system variable init */
  504. db->cr6_data = CR6_DEFAULT | dmfe_cr6_user_set;
  505. db->tx_packet_cnt = 0;
  506. db->tx_queue_cnt = 0;
  507. db->rx_avail_cnt = 0;
  508. db->link_failed = 1;
  509. db->wait_reset = 0;
  511. db->first_in_callback = 0;
  512. db->NIC_capability = 0xf; /* All capability*/
  513. db->PHY_reg4 = 0x1e0;
  515. /* CR6 operation mode decision */
  516. if ( !chkmode || (db->chip_id == PCI_DM9132_ID) ||
  517. (db->chip_revision >= 0x02000030) ) {
  518.      db->cr6_data |= DMFE_TXTH_256;
  519. db->cr0_data = CR0_DEFAULT;
  520. db->dm910x_chk_mode=4; /* Enter the normal mode */
  521.   } else {
  522. db->cr6_data |= CR6_SFT; /* Store & Forward mode */
  523. db->cr0_data = 0;
  524. db->dm910x_chk_mode = 1; /* Enter the check mode */
  525. }
  527. /* Initilize DM910X board */
  528. dmfe_init_dm910x(dev);
  530. /* Active System Interface */
  531. netif_wake_queue(dev);
  533. /* set and active a timer process */
  534. init_timer(&db->timer);
  535. db->timer.expires = DMFE_TIMER_WUT + HZ * 2;
  536. db->timer.data = (unsigned long)dev;
  537. db->timer.function = &dmfe_timer;
  538. add_timer(&db->timer);
  540. return 0;
  541. }
  544. /* Initilize DM910X board
  545.  * Reset DM910X board
  546.  * Initilize TX/Rx descriptor chain structure
  547.  * Send the set-up frame
  548.  * Enable Tx/Rx machine
  549.  */
  551. static void dmfe_init_dm910x(struct DEVICE *dev)
  552. {
  553. struct dmfe_board_info *db = dev->priv;
  554. unsigned long ioaddr = db->ioaddr;
  556. DMFE_DBUG(0, "dmfe_init_dm910x()", 0);
  558. /* Reset DM910x MAC controller */
  559. outl(DM910X_RESET, ioaddr + DCR0); /* RESET MAC */
  560. udelay(100);
  561. outl(db->cr0_data, ioaddr + DCR0);
  562. udelay(5);
  564. /* Phy addr : DM910(A)2/DM9132/9801, phy address = 1 */
  565. db->phy_addr = 1;
  567. /* Parser SROM and media mode */
  568. dmfe_parse_srom(db);
  569. db->media_mode = dmfe_media_mode;
  571. /* RESET Phyxcer Chip by GPR port bit 7 */
  572. outl(0x180, ioaddr + DCR12); /* Let bit 7 output port */
  573. if (db->chip_id == PCI_DM9009_ID) {
  574. outl(0x80, ioaddr + DCR12); /* Issue RESET signal */
  575. mdelay(300); /* Delay 300 ms */
  576. }
  577. outl(0x0, ioaddr + DCR12); /* Clear RESET signal */
  579. /* Process Phyxcer Media Mode */
  580. if ( !(db->media_mode & 0x10) ) /* Force 1M mode */
  581. dmfe_set_phyxcer(db);
  583. /* Media Mode Process */
  584. if ( !(db->media_mode & DMFE_AUTO) )
  585. db->op_mode = db->media_mode;  /* Force Mode */
  587. /* Initiliaze Transmit/Receive decriptor and CR3/4 */
  588. dmfe_descriptor_init(db, ioaddr);
  590. /* Init CR6 to program DM910x operation */
  591. update_cr6(db->cr6_data, ioaddr);
  593. /* Send setup frame */
  594. if (db->chip_id == PCI_DM9132_ID)
  595. dm9132_id_table(dev, dev->mc_count); /* DM9132 */
  596. else
  597. send_filter_frame(dev, dev->mc_count); /* DM9102/DM9102A */
  599. /* Init CR7, interrupt active bit */
  600. db->cr7_data = CR7_DEFAULT;
  601. outl(db->cr7_data, ioaddr + DCR7);
  603. /* Init CR15, Tx jabber and Rx watchdog timer */
  604. outl(db->cr15_data, ioaddr + DCR15);
  606. /* Enable DM910X Tx/Rx function */
  607. db->cr6_data |= CR6_RXSC | CR6_TXSC | 0x40000;
  608. update_cr6(db->cr6_data, ioaddr);
  609. }
  612. /*
  613.  * Hardware start transmission.
  614.  * Send a packet to media from the upper layer.
  615.  */
  617. static int dmfe_start_xmit(struct sk_buff *skb, struct DEVICE *dev)
  618. {
  619. struct dmfe_board_info *db = dev->priv;
  620. struct tx_desc *txptr;
  621. unsigned long flags;
  623. DMFE_DBUG(0, "dmfe_start_xmit", 0);
  625. /* Resource flag check */
  626. netif_stop_queue(dev);
  628. /* Too large packet check */
  629. if (skb->len > MAX_PACKET_SIZE) {
  630. printk(KERN_ERR DRV_NAME ": big packet = %dn", (u16)skb->len);
  631. dev_kfree_skb(skb);
  632. return 0;
  633. }
  635. spin_lock_irqsave(&db->lock, flags);
  637. /* No Tx resource check, it never happen nromally */
  638. if (db->tx_queue_cnt >= TX_FREE_DESC_CNT) {
  639. spin_unlock_irqrestore(&db->lock, flags);
  640. printk(KERN_ERR DRV_NAME ": No Tx resource %ldn", db->tx_queue_cnt);
  641. return 1;
  642. }
  644. /* Disable NIC interrupt */
  645. outl(0, dev->base_addr + DCR7);
  647. /* transmit this packet */
  648. txptr = db->tx_insert_ptr;
  649. memcpy(txptr->tx_buf_ptr, skb->data, skb->len);
  650. txptr->tdes1 = cpu_to_le32(0xe1000000 | skb->len);
  652. /* Point to next transmit free descriptor */
  653. db->tx_insert_ptr = txptr->next_tx_desc;
  655. /* Transmit Packet Process */
  656. if ( (!db->tx_queue_cnt) && (db->tx_packet_cnt < TX_MAX_SEND_CNT) ) {
  657. txptr->tdes0 = cpu_to_le32(0x80000000); /* Set owner bit */
  658. db->tx_packet_cnt++; /* Ready to send */
  659. outl(0x1, dev->base_addr + DCR1); /* Issue Tx polling */
  660. dev->trans_start = jiffies; /* saved time stamp */
  661. } else {
  662. db->tx_queue_cnt++; /* queue TX packet */
  663. outl(0x1, dev->base_addr + DCR1); /* Issue Tx polling */
  664. }
  666. /* Tx resource check */
  667. if ( db->tx_queue_cnt < TX_FREE_DESC_CNT )
  668. netif_wake_queue(dev);
  670. /* free this SKB */
  671. dev_kfree_skb(skb);
  673. /* Restore CR7 to enable interrupt */
  674. spin_unlock_irqrestore(&db->lock, flags);
  675. outl(db->cr7_data, dev->base_addr + DCR7);
  677. return 0;
  678. }
  681. /*
  682.  * Stop the interface.
  683.  * The interface is stopped when it is brought.
  684.  */
  686. static int dmfe_stop(struct DEVICE *dev)
  687. {
  688. struct dmfe_board_info *db = dev->priv;
  689. unsigned long ioaddr = dev->base_addr;
  691. DMFE_DBUG(0, "dmfe_stop", 0);
  693. /* disable system */
  694. netif_stop_queue(dev);
  696. /* deleted timer */
  697. del_timer_sync(&db->timer);
  699. /* Reset & stop DM910X board */
  700. outl(DM910X_RESET, ioaddr + DCR0);
  701. udelay(5);
  702. phy_write(db->ioaddr, db->phy_addr, 0, 0x8000, db->chip_id);
  704. /* free interrupt */
  705. free_irq(dev->irq, dev);
  707. /* free allocated rx buffer */
  708. dmfe_free_rxbuffer(db);
  710. #if 0
  711. /* show statistic counter */
  712. printk(DRV_NAME ": FU:%lx EC:%lx LC:%lx NC:%lx LOC:%lx TXJT:%lx RESET:%lx RCR8:%lx FAL:%lx TT:%lxn",
  713. db->tx_fifo_underrun, db->tx_excessive_collision,
  714. db->tx_late_collision, db->tx_no_carrier, db->tx_loss_carrier,
  715. db->tx_jabber_timeout, db->reset_count, db->reset_cr8,
  716. db->reset_fatal, db->reset_TXtimeout);
  717. #endif
  719. return 0;
  720. }
  723. /*
  724.  * DM9102 insterrupt handler
  725.  * receive the packet to upper layer, free the transmitted packet
  726.  */
  728. static void dmfe_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  729. {
  730. struct DEVICE *dev = dev_id;
  731. struct dmfe_board_info *db = (struct dmfe_board_info *) dev->priv;
  732. unsigned long ioaddr = dev->base_addr;
  733. unsigned long flags;
  735. DMFE_DBUG(0, "dmfe_interrupt()", 0);
  737. if (!dev) {
  738. DMFE_DBUG(1, "dmfe_interrupt() without DEVICE arg", 0);
  739. return;
  740. }
  742. spin_lock_irqsave(&db->lock, flags);
  744. /* Got DM910X status */
  745. db->cr5_data = inl(ioaddr + DCR5);
  746. outl(db->cr5_data, ioaddr + DCR5);
  747. if ( !(db->cr5_data & 0xc1) ) {
  748. spin_unlock_irqrestore(&db->lock, flags);
  749. return;
  750. }
  752. /* Disable all interrupt in CR7 to solve the interrupt edge problem */
  753. outl(0, ioaddr + DCR7);
  755. /* Check system status */
  756. if (db->cr5_data & 0x2000) {
  757. /* system bus error happen */
  758. DMFE_DBUG(1, "System bus error happen. CR5=", db->cr5_data);
  759. db->reset_fatal++;
  760. db->wait_reset = 1; /* Need to RESET */
  761. spin_unlock_irqrestore(&db->lock, flags);
  762. return;
  763. }
  765.  /* Received the coming packet */
  766. if ( (db->cr5_data & 0x40) && db->rx_avail_cnt )
  767. dmfe_rx_packet(dev, db);
  769. /* reallocate rx descriptor buffer */
  770. if (db->rx_avail_cnt<RX_DESC_CNT)
  771. allocate_rx_buffer(db);
  773. /* Free the transmitted descriptor */
  774. if ( db->cr5_data & 0x01)
  775. dmfe_free_tx_pkt(dev, db);
  777. /* Mode Check */
  778. if (db->dm910x_chk_mode & 0x2) {
  779. db->dm910x_chk_mode = 0x4;
  780. db->cr6_data |= 0x100;
  781. update_cr6(db->cr6_data, db->ioaddr);
  782. }
  784. /* Restore CR7 to enable interrupt mask */
  785. outl(db->cr7_data, ioaddr + DCR7);
  787. spin_unlock_irqrestore(&db->lock, flags);
  788. }
  791. /*
  792.  * Free TX resource after TX complete
  793.  */
  795. static void dmfe_free_tx_pkt(struct DEVICE *dev, struct dmfe_board_info * db)
  796. {
  797. struct tx_desc *txptr;
  798. unsigned long ioaddr = dev->base_addr;
  799. u32 tdes0;
  801. txptr = db->tx_remove_ptr;
  802. while(db->tx_packet_cnt) {
  803. tdes0 = le32_to_cpu(txptr->tdes0);
  804. /* printk(DRV_NAME ": tdes0=%xn", tdes0); */
  805. if (tdes0 & 0x80000000)
  806. break;
  808. /* A packet sent completed */
  809. db->tx_packet_cnt--;
  810. db->stats.tx_packets++;
  812. /* Transmit statistic counter */
  813. if ( tdes0 != 0x7fffffff ) {
  814. /* printk(DRV_NAME ": tdes0=%xn", tdes0); */
  815. db->stats.collisions += (tdes0 >> 3) & 0xf;
  816. db->stats.tx_bytes += le32_to_cpu(txptr->tdes1) & 0x7ff;
  817. if (tdes0 & TDES0_ERR_MASK) {
  818. db->stats.tx_errors++;
  820. if (tdes0 & 0x0002) { /* UnderRun */
  821. db->tx_fifo_underrun++;
  822. if ( !(db->cr6_data & CR6_SFT) ) {
  823. db->cr6_data = db->cr6_data | CR6_SFT;
  824. update_cr6(db->cr6_data, db->ioaddr);
  825. }
  826. }
  827. if (tdes0 & 0x0100)
  828. db->tx_excessive_collision++;
  829. if (tdes0 & 0x0200)
  830. db->tx_late_collision++;
  831. if (tdes0 & 0x0400)
  832. db->tx_no_carrier++;
  833. if (tdes0 & 0x0800)
  834. db->tx_loss_carrier++;
  835. if (tdes0 & 0x4000)
  836. db->tx_jabber_timeout++;
  837. }
  838. }
  840.      txptr = txptr->next_tx_desc;
  841. }/* End of while */
  843. /* Update TX remove pointer to next */
  844. db->tx_remove_ptr = txptr;
  846. /* Send the Tx packet in queue */
  847. if ( (db->tx_packet_cnt < TX_MAX_SEND_CNT) && db->tx_queue_cnt ) {
  848. txptr->tdes0 = cpu_to_le32(0x80000000); /* Set owner bit */
  849. db->tx_packet_cnt++; /* Ready to send */
  850. db->tx_queue_cnt--;
  851. outl(0x1, ioaddr + DCR1); /* Issue Tx polling */
  852. dev->trans_start = jiffies; /* saved time stamp */
  853. }
  855. /* Resource available check */
  856. if ( db->tx_queue_cnt < TX_WAKE_DESC_CNT )
  857. netif_wake_queue(dev); /* Active upper layer, send again */
  858. }
  861. /*
  862.  * Receive the come packet and pass to upper layer
  863.  */
  865. static void dmfe_rx_packet(struct DEVICE *dev, struct dmfe_board_info * db)
  866. {
  867. struct rx_desc *rxptr;
  868. struct sk_buff *skb;
  869. int rxlen;
  870. u32 rdes0;
  872. rxptr = db->rx_ready_ptr;
  874. while(db->rx_avail_cnt) {
  875. rdes0 = le32_to_cpu(rxptr->rdes0);
  876. if (rdes0 & 0x80000000) /* packet owner check */
  877. break;
  879. db->rx_avail_cnt--;
  880. db->interval_rx_cnt++;
  882. pci_unmap_single(db->pdev, le32_to_cpu(rxptr->rdes2), RX_ALLOC_SIZE, PCI_DMA_FROMDEVICE);
  883. if ( (rdes0 & 0x300) != 0x300) {
  884. /* A packet without First/Last flag */
  885. /* reuse this SKB */
  886. DMFE_DBUG(0, "Reuse SK buffer, rdes0", rdes0);
  887. dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
  888. } else {
  889. /* A packet with First/Last flag */
  890. rxlen = ( (rdes0 >> 16) & 0x3fff) - 4;
  892. /* error summary bit check */
  893. if (rdes0 & 0x8000) {
  894. /* This is a error packet */
  895. //printk(DRV_NAME ": rdes0: %lxn", rdes0);
  896. db->stats.rx_errors++;
  897. if (rdes0 & 1)
  898. db->stats.rx_fifo_errors++;
  899. if (rdes0 & 2)
  900. db->stats.rx_crc_errors++;
  901. if (rdes0 & 0x80)
  902. db->stats.rx_length_errors++;
  903. }
  905. if ( !(rdes0 & 0x8000) ||
  906. ((db->cr6_data & CR6_PM) && (rxlen>6)) ) {
  907. skb = rxptr->rx_skb_ptr;
  909. /* Received Packet CRC check need or not */
  910. if ( (db->dm910x_chk_mode & 1) &&
  911. (cal_CRC(skb->tail, rxlen, 1) !=
  912. (*(u32 *) (skb->tail+rxlen) ))) { /* FIXME (?) */
  913. /* Found a error received packet */
  914. dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
  915. db->dm910x_chk_mode = 3;
  916. } else {
  917. /* Good packet, send to upper layer */
  918. /* Shorst packet used new SKB */
  919. if ( (rxlen < RX_COPY_SIZE) &&
  920. ( (skb = dev_alloc_skb(rxlen + 2) )
  921. != NULL) ) {
  922. /* size less than COPY_SIZE, allocate a rxlen SKB */
  923. skb->dev = dev;
  924. skb_reserve(skb, 2); /* 16byte align */
  925. memcpy(skb_put(skb, rxlen), rxptr->rx_skb_ptr->tail, rxlen);
  926. dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
  927. } else {
  928. skb->dev = dev;
  929. skb_put(skb, rxlen);
  930. }
  931. skb->protocol = eth_type_trans(skb, dev);
  932. netif_rx(skb);
  933. dev->last_rx = jiffies;
  934. db->stats.rx_packets++;
  935. db->stats.rx_bytes += rxlen;
  936. }
  937. } else {
  938. /* Reuse SKB buffer when the packet is error */
  939. DMFE_DBUG(0, "Reuse SK buffer, rdes0", rdes0);
  940. dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
  941. }
  942. }
  944. rxptr = rxptr->next_rx_desc;
  945. }
  947. db->rx_ready_ptr = rxptr;
  948. }
  951. /*
  952.  * Get statistics from driver.
  953.  */
  955. static struct net_device_stats * dmfe_get_stats(struct DEVICE *dev)
  956. {
  957. struct dmfe_board_info *db = (struct dmfe_board_info *)dev->priv;
  959. DMFE_DBUG(0, "dmfe_get_stats", 0);
  960. return &db->stats;
  961. }
  964. /*
  965.  * Set DM910X multicast address
  966.  */
  968. static void dmfe_set_filter_mode(struct DEVICE * dev)
  969. {
  970. struct dmfe_board_info *db = dev->priv;
  971. unsigned long flags;
  973. DMFE_DBUG(0, "dmfe_set_filter_mode()", 0);
  974. spin_lock_irqsave(&db->lock, flags);
  976. if (dev->flags & IFF_PROMISC) {
  977. DMFE_DBUG(0, "Enable PROM Mode", 0);
  978. db->cr6_data |= CR6_PM | CR6_PBF;
  979. update_cr6(db->cr6_data, db->ioaddr);
  980. spin_unlock_irqrestore(&db->lock, flags);
  981. return;
  982. }
  984. if (dev->flags & IFF_ALLMULTI || dev->mc_count > DMFE_MAX_MULTICAST) {
  985. DMFE_DBUG(0, "Pass all multicast address", dev->mc_count);
  986. db->cr6_data &= ~(CR6_PM | CR6_PBF);
  987. db->cr6_data |= CR6_PAM;
  988. spin_unlock_irqrestore(&db->lock, flags);
  989. return;
  990. }
  992. DMFE_DBUG(0, "Set multicast address", dev->mc_count);
  993. if (db->chip_id == PCI_DM9132_ID)
  994. dm9132_id_table(dev, dev->mc_count); /* DM9132 */
  995. else
  996. send_filter_frame(dev, dev->mc_count);  /* DM9102/DM9102A */
  997. spin_unlock_irqrestore(&db->lock, flags);
  998. }
  1001. /*
  1002.  * Process the ethtool ioctl command
  1003.  */
  1005. static int dmfe_ethtool_ioctl(struct net_device *dev, void *useraddr)
  1006. {
  1007. struct dmfe_board_info *db = dev->priv;
  1008. struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
  1009. u32 ethcmd;
  1011. if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
  1012. return -EFAULT;
  1014.         switch (ethcmd) {
  1015.         case ETHTOOL_GDRVINFO:
  1016. strcpy(info.driver, DRV_NAME);
  1017. strcpy(info.version, DRV_VERSION);
  1018. if (db->pdev)
  1019. strcpy(info.bus_info, db->pdev->slot_name);
  1020. else
  1021. sprintf(info.bus_info, "EISA 0x%lx %d",
  1022. dev->base_addr, dev->irq);
  1023. if (copy_to_user(useraddr, &info, sizeof(info)))
  1024. return -EFAULT;
  1025. return 0;
  1026.         }
  1028. return -EOPNOTSUPP;
  1029. }
  1032. /*
  1033.  * Process the upper socket ioctl command
  1034.  */
  1036. static int dmfe_do_ioctl(struct DEVICE *dev, struct ifreq *ifr, int cmd)
  1037. {
  1038. int retval = -EOPNOTSUPP;
  1039. DMFE_DBUG(0, "dmfe_do_ioctl()", 0);
  1041. switch(cmd) {
  1042. case SIOCETHTOOL:
  1043. return dmfe_ethtool_ioctl(dev, (void*)ifr->ifr_data);
  1044. }
  1046. return retval;
  1047. }
  1050. /*
  1051.  * A periodic timer routine
  1052.  * Dynamic media sense, allocate Rx buffer...
  1053.  */
  1055. static void dmfe_timer(unsigned long data)
  1056. {
  1057. u32 tmp_cr8;
  1058. unsigned char tmp_cr12;
  1059. struct DEVICE *dev = (struct DEVICE *) data;
  1060. struct dmfe_board_info *db = (struct dmfe_board_info *) dev->priv;
  1061.   unsigned long flags;
  1063. DMFE_DBUG(0, "dmfe_timer()", 0);
  1064. spin_lock_irqsave(&db->lock, flags);
  1066. /* Media mode process when Link OK before enter this route */
  1067. if (db->first_in_callback == 0) {
  1068. db->first_in_callback = 1;
  1069. if (db->chip_type && (db->chip_id==PCI_DM9102_ID)) {
  1070. db->cr6_data &= ~0x40000;
  1071. update_cr6(db->cr6_data, db->ioaddr);
  1072. phy_write(db->ioaddr, db->phy_addr, 0, 0x1000, db->chip_id);
  1073. db->cr6_data |= 0x40000;
  1074. update_cr6(db->cr6_data, db->ioaddr);
  1075. db->timer.expires = DMFE_TIMER_WUT + HZ * 2;
  1076. add_timer(&db->timer);
  1077. spin_unlock_irqrestore(&db->lock, flags);
  1078. return;
  1079. }
  1080. }
  1083. /* Operating Mode Check */
  1084. if ( (db->dm910x_chk_mode & 0x1) &&
  1085. (db->stats.rx_packets > MAX_CHECK_PACKET) )
  1086. db->dm910x_chk_mode = 0x4;
  1088. /* Dynamic reset DM910X : system error or transmit time-out */
  1089. tmp_cr8 = inl(db->ioaddr + DCR8);
  1090. if ( (db->interval_rx_cnt==0) && (tmp_cr8) ) {
  1091. db->reset_cr8++;
  1092. db->wait_reset = 1;
  1093. }
  1094. db->interval_rx_cnt = 0;
  1096. /* TX polling kick monitor */
  1097. if ( db->tx_packet_cnt &&
  1098.      time_after(jiffies, dev->trans_start + DMFE_TX_KICK) ) {
  1099. outl(0x1, dev->base_addr + DCR1);   /* Tx polling again */
  1101. /* TX Timeout */
  1102. if ( time_after(jiffies, dev->trans_start + DMFE_TX_TIMEOUT) ) {
  1103. db->reset_TXtimeout++;
  1104. db->wait_reset = 1;
  1105. printk(KERN_WARNING "%s: Tx timeout - resettingn",
  1106.        dev->name);
  1107. }
  1108. }
  1110. if (db->wait_reset) {
  1111. DMFE_DBUG(0, "Dynamic Reset device", db->tx_packet_cnt);
  1112. db->reset_count++;
  1113. dmfe_dynamic_reset(dev);
  1114. db->first_in_callback = 0;
  1115. db->timer.expires = DMFE_TIMER_WUT;
  1116. add_timer(&db->timer);
  1117. spin_unlock_irqrestore(&db->lock, flags);
  1118. return;
  1119. }
  1121. /* Link status check, Dynamic media type change */
  1122. if (db->chip_id == PCI_DM9132_ID)
  1123. tmp_cr12 = inb(db->ioaddr + DCR9 + 3); /* DM9132 */
  1124. else
  1125. tmp_cr12 = inb(db->ioaddr + DCR12); /* DM9102/DM9102A */
  1127. if ( ((db->chip_id == PCI_DM9102_ID) &&
  1128. (db->chip_revision == 0x02000030)) ||
  1129. ((db->chip_id == PCI_DM9132_ID) &&
  1130. (db->chip_revision == 0x02000010)) ) {
  1131. /* DM9102A Chip */
  1132. if (tmp_cr12 & 2)
  1133. tmp_cr12 = 0x0; /* Link failed */
  1134. else
  1135. tmp_cr12 = 0x3; /* Link OK */
  1136. }
  1138. if ( !(tmp_cr12 & 0x3) && !db->link_failed ) {
  1139. /* Link Failed */
  1140. DMFE_DBUG(0, "Link Failed", tmp_cr12);
  1141. db->link_failed = 1;
  1143. /* For Force 10/100M Half/Full mode: Enable Auto-Nego mode */
  1144. /* AUTO or force 1M Homerun/Longrun don't need */
  1145. if ( !(db->media_mode & 0x38) )
  1146. phy_write(db->ioaddr, db->phy_addr, 0, 0x1000, db->chip_id);
  1148. /* AUTO mode, if INT phyxcer link failed, select EXT device */
  1149. if (db->media_mode & DMFE_AUTO) {
  1150. /* 10/100M link failed, used 1M Home-Net */
  1151. db->cr6_data|=0x00040000; /* bit18=1, MII */
  1152. db->cr6_data&=~0x00000200; /* bit9=0, HD mode */
  1153. update_cr6(db->cr6_data, db->ioaddr);
  1154. }
  1155. } else
  1156. if ((tmp_cr12 & 0x3) && db->link_failed) {
  1157. DMFE_DBUG(0, "Link link OK", tmp_cr12);
  1158. db->link_failed = 0;
  1160. /* Auto Sense Speed */
  1161. if ( (db->media_mode & DMFE_AUTO) &&
  1162. dmfe_sense_speed(db) )
  1163. db->link_failed = 1;
  1164. dmfe_process_mode(db);
  1165. /* SHOW_MEDIA_TYPE(db->op_mode); */
  1166. }
  1168. /* HPNA remote command check */
  1169. if (db->HPNA_command & 0xf00) {
  1170. db->HPNA_timer--;
  1171. if (!db->HPNA_timer)
  1172. dmfe_HPNA_remote_cmd_chk(db);
  1173. }
  1175. /* Timer active again */
  1176. db->timer.expires = DMFE_TIMER_WUT;
  1177. add_timer(&db->timer);
  1178. spin_unlock_irqrestore(&db->lock, flags);
  1179. }
  1182. /*
  1183.  * Dynamic reset the DM910X board
  1184.  * Stop DM910X board
  1185.  * Free Tx/Rx allocated memory
  1186.  * Reset DM910X board
  1187.  * Re-initilize DM910X board
  1188.  */
  1190. static void dmfe_dynamic_reset(struct DEVICE *dev)
  1191. {
  1192. struct dmfe_board_info *db = dev->priv;
  1194. DMFE_DBUG(0, "dmfe_dynamic_reset()", 0);
  1196. /* Sopt MAC controller */
  1197. db->cr6_data &= ~(CR6_RXSC | CR6_TXSC); /* Disable Tx/Rx */
  1198. update_cr6(db->cr6_data, dev->base_addr);
  1199. outl(0, dev->base_addr + DCR7); /* Disable Interrupt */
  1200. outl(inl(dev->base_addr + DCR5), dev->base_addr + DCR5);
  1202. /* Disable upper layer interface */
  1203. netif_stop_queue(dev);
  1205. /* Free Rx Allocate buffer */
  1206. dmfe_free_rxbuffer(db);
  1208. /* system variable init */
  1209. db->tx_packet_cnt = 0;
  1210. db->tx_queue_cnt = 0;
  1211. db->rx_avail_cnt = 0;
  1212. db->link_failed = 1;
  1213. db->wait_reset = 0;
  1215. /* Re-initilize DM910X board */
  1216. dmfe_init_dm910x(dev);
  1218. /* Restart upper layer interface */
  1219. netif_wake_queue(dev);
  1220. }
  1223. /*
  1224.  * free all allocated rx buffer
  1225.  */
  1227. static void dmfe_free_rxbuffer(struct dmfe_board_info * db)
  1228. {
  1229. DMFE_DBUG(0, "dmfe_free_rxbuffer()", 0);
  1231. /* free allocated rx buffer */
  1232. while (db->rx_avail_cnt) {
  1233. dev_kfree_skb(db->rx_ready_ptr->rx_skb_ptr);
  1234. db->rx_ready_ptr = db->rx_ready_ptr->next_rx_desc;
  1235. db->rx_avail_cnt--;
  1236. }
  1237. }
  1240. /*
  1241.  * Reuse the SK buffer
  1242.  */
  1244. static void dmfe_reuse_skb(struct dmfe_board_info *db, struct sk_buff * skb)
  1245. {
  1246. struct rx_desc *rxptr = db->rx_insert_ptr;
  1248. if (!(rxptr->rdes0 & cpu_to_le32(0x80000000))) {
  1249. rxptr->rx_skb_ptr = skb;
  1250. rxptr->rdes2 = cpu_to_le32( pci_map_single(db->pdev, skb->tail, RX_ALLOC_SIZE, PCI_DMA_FROMDEVICE) );
  1251. wmb();
  1252. rxptr->rdes0 = cpu_to_le32(0x80000000);
  1253. db->rx_avail_cnt++;
  1254. db->rx_insert_ptr = rxptr->next_rx_desc;
  1255. } else
  1256. DMFE_DBUG(0, "SK Buffer reuse method error", db->rx_avail_cnt);
  1257. }
  1260. /*
  1261.  * Initialize transmit/Receive descriptor
  1262.  * Using Chain structure, and allocate Tx/Rx buffer
  1263.  */
  1265. static void dmfe_descriptor_init(struct dmfe_board_info *db, unsigned long ioaddr)
  1266. {
  1267. struct tx_desc *tmp_tx;
  1268. struct rx_desc *tmp_rx;
  1269. unsigned char *tmp_buf;
  1270. dma_addr_t tmp_tx_dma, tmp_rx_dma;
  1271. dma_addr_t tmp_buf_dma;
  1272. int i;
  1274. DMFE_DBUG(0, "dmfe_descriptor_init()", 0);
  1276. /* tx descriptor start pointer */
  1277. db->tx_insert_ptr = db->first_tx_desc;
  1278. db->tx_remove_ptr = db->first_tx_desc;
  1279. outl(db->first_tx_desc_dma, ioaddr + DCR4);     /* TX DESC address */
  1281. /* rx descriptor start pointer */
  1282. db->first_rx_desc = (void *)db->first_tx_desc + sizeof(struct tx_desc) * TX_DESC_CNT;
  1283. db->first_rx_desc_dma =  db->first_tx_desc_dma + sizeof(struct tx_desc) * TX_DESC_CNT;
  1284. db->rx_insert_ptr = db->first_rx_desc;
  1285. db->rx_ready_ptr = db->first_rx_desc;
  1286. outl(db->first_rx_desc_dma, ioaddr + DCR3); /* RX DESC address */
  1288. /* Init Transmit chain */
  1289. tmp_buf = db->buf_pool_start;
  1290. tmp_buf_dma = db->buf_pool_dma_start;
  1291. tmp_tx_dma = db->first_tx_desc_dma;
  1292. for (tmp_tx = db->first_tx_desc, i = 0; i < TX_DESC_CNT; i++, tmp_tx++) {
  1293. tmp_tx->tx_buf_ptr = tmp_buf;
  1294. tmp_tx->tdes0 = cpu_to_le32(0);
  1295. tmp_tx->tdes1 = cpu_to_le32(0x81000000); /* IC, chain */
  1296. tmp_tx->tdes2 = cpu_to_le32(tmp_buf_dma);
  1297. tmp_tx_dma += sizeof(struct tx_desc);
  1298. tmp_tx->tdes3 = cpu_to_le32(tmp_tx_dma);
  1299. tmp_tx->next_tx_desc = tmp_tx + 1;
  1300. tmp_buf = tmp_buf + TX_BUF_ALLOC;
  1301. tmp_buf_dma = tmp_buf_dma + TX_BUF_ALLOC;
  1302. }
  1303. (--tmp_tx)->tdes3 = cpu_to_le32(db->first_tx_desc_dma);
  1304. tmp_tx->next_tx_desc = db->first_tx_desc;
  1306.  /* Init Receive descriptor chain */
  1307. tmp_rx_dma=db->first_rx_desc_dma;
  1308. for (tmp_rx = db->first_rx_desc, i = 0; i < RX_DESC_CNT; i++, tmp_rx++) {
  1309. tmp_rx->rdes0 = cpu_to_le32(0);
  1310. tmp_rx->rdes1 = cpu_to_le32(0x01000600);
  1311. tmp_rx_dma += sizeof(struct rx_desc);
  1312. tmp_rx->rdes3 = cpu_to_le32(tmp_rx_dma);
  1313. tmp_rx->next_rx_desc = tmp_rx + 1;
  1314. }
  1315. (--tmp_rx)->rdes3 = cpu_to_le32(db->first_rx_desc_dma);
  1316. tmp_rx->next_rx_desc = db->first_rx_desc;
  1318. /* pre-allocate Rx buffer */
  1319. allocate_rx_buffer(db);
  1320. }
  1323. /*
  1324.  * Update CR6 value
  1325.  * Firstly stop DM910X , then written value and start
  1326.  */
  1328. static void update_cr6(u32 cr6_data, unsigned long ioaddr)
  1329. {
  1330. u32 cr6_tmp;
  1332. cr6_tmp = cr6_data & ~0x2002;           /* stop Tx/Rx */
  1333. outl(cr6_tmp, ioaddr + DCR6);
  1334. udelay(5);
  1335. outl(cr6_data, ioaddr + DCR6);
  1336. udelay(5);
  1337. }
  1340. /*
  1341.  * Send a setup frame for DM9132
  1342.  * This setup frame initilize DM910X addres filter mode
  1343. */
  1345. static void dm9132_id_table(struct DEVICE *dev, int mc_cnt)
  1346. {
  1347. struct dev_mc_list *mcptr;
  1348. u16 * addrptr;
  1349. unsigned long ioaddr = dev->base_addr+0xc0; /* ID Table */
  1350. u32 hash_val;
  1351. u16 i, hash_table[4];
  1353. DMFE_DBUG(0, "dm9132_id_table()", 0);
  1355. /* Node address */
  1356. addrptr = (u16 *) dev->dev_addr;
  1357. outw(addrptr[0], ioaddr);
  1358. ioaddr += 4;
  1359. outw(addrptr[1], ioaddr);
  1360. ioaddr += 4;
  1361. outw(addrptr[2], ioaddr);
  1362. ioaddr += 4;
  1364. /* Clear Hash Table */
  1365. for (i = 0; i < 4; i++)
  1366. hash_table[i] = 0x0;
  1368. /* broadcast address */
  1369. hash_table[3] = 0x8000;
  1371. /* the multicast address in Hash Table : 64 bits */
  1372. for (mcptr = dev->mc_list, i = 0; i < mc_cnt; i++, mcptr = mcptr->next) {
  1373. hash_val = cal_CRC( (char *) mcptr->dmi_addr, 6, 0) & 0x3f;
  1374. hash_table[hash_val / 16] |= (u16) 1 << (hash_val % 16);
  1375. }
  1377. /* Write the hash table to MAC MD table */
  1378. for (i = 0; i < 4; i++, ioaddr += 4)
  1379. outw(hash_table[i], ioaddr);
  1380. }
  1383. /*
  1384.  * Send a setup frame for DM9102/DM9102A
  1385.  * This setup frame initilize DM910X addres filter mode
  1386.  */
  1388. static void send_filter_frame(struct DEVICE *dev, int mc_cnt)
  1389. {
  1390. struct dmfe_board_info *db = dev->priv;
  1391. struct dev_mc_list *mcptr;
  1392. struct tx_desc *txptr;
  1393. u16 * addrptr;
  1394. u32 * suptr;
  1395. int i;
  1397. DMFE_DBUG(0, "send_filter_frame()", 0);
  1399. txptr = db->tx_insert_ptr;
  1400. suptr = (u32 *) txptr->tx_buf_ptr;
  1402. /* Node address */
  1403. addrptr = (u16 *) dev->dev_addr;
  1404. *suptr++ = addrptr[0];
  1405. *suptr++ = addrptr[1];
  1406. *suptr++ = addrptr[2];
  1408. /* broadcast address */
  1409. *suptr++ = 0xffff;
  1410. *suptr++ = 0xffff;
  1411. *suptr++ = 0xffff;
  1413. /* fit the multicast address */
  1414. for (mcptr = dev->mc_list, i = 0; i < mc_cnt; i++, mcptr = mcptr->next) {
  1415. addrptr = (u16 *) mcptr->dmi_addr;
  1416. *suptr++ = addrptr[0];
  1417. *suptr++ = addrptr[1];
  1418. *suptr++ = addrptr[2];
  1419. }
  1421. for (; i<14; i++) {
  1422. *suptr++ = 0xffff;
  1423. *suptr++ = 0xffff;
  1424. *suptr++ = 0xffff;
  1425. }
  1427. /* prepare the setup frame */
  1428. db->tx_insert_ptr = txptr->next_tx_desc;
  1429. txptr->tdes1 = cpu_to_le32(0x890000c0);
  1431. /* Resource Check and Send the setup packet */
  1432. if (!db->tx_packet_cnt) {
  1433. /* Resource Empty */
  1434. db->tx_packet_cnt++;
  1435. txptr->tdes0 = cpu_to_le32(0x80000000);
  1436. update_cr6(db->cr6_data | 0x2000, dev->base_addr);
  1437. outl(0x1, dev->base_addr + DCR1); /* Issue Tx polling */
  1438. update_cr6(db->cr6_data, dev->base_addr);
  1439. dev->trans_start = jiffies;
  1440. } else
  1441. db->tx_queue_cnt++; /* Put in TX queue */
  1442. }
  1445. /*
  1446.  * Allocate rx buffer,
  1447.  * As possible as allocate maxiumn Rx buffer
  1448.  */
  1450. static void allocate_rx_buffer(struct dmfe_board_info *db)
  1451. {
  1452. struct rx_desc *rxptr;
  1453. struct sk_buff *skb;
  1455. rxptr = db->rx_insert_ptr;
  1457. while(db->rx_avail_cnt < RX_DESC_CNT) {
  1458. if ( ( skb = dev_alloc_skb(RX_ALLOC_SIZE) ) == NULL )
  1459. break;
  1460. rxptr->rx_skb_ptr = skb; /* FIXME (?) */
  1461. rxptr->rdes2 = cpu_to_le32( pci_map_single(db->pdev, skb->tail, RX_ALLOC_SIZE, PCI_DMA_FROMDEVICE) );
  1462. wmb();
  1463. rxptr->rdes0 = cpu_to_le32(0x80000000);
  1464. rxptr = rxptr->next_rx_desc;
  1465. db->rx_avail_cnt++;
  1466. }
  1468. db->rx_insert_ptr = rxptr;
  1469. }
  1472. /*
  1473.  * Read one word data from the serial ROM
  1474.  */
  1476. static u16 read_srom_word(long ioaddr, int offset)
  1477. {
  1478. int i;
  1479. u16 srom_data = 0;
  1480. long cr9_ioaddr = ioaddr + DCR9;
  1482. outl(CR9_SROM_READ, cr9_ioaddr);
  1483. outl(CR9_SROM_READ | CR9_SRCS, cr9_ioaddr);
  1485. /* Send the Read Command 110b */
  1486. SROM_CLK_WRITE(SROM_DATA_1, cr9_ioaddr);
  1487. SROM_CLK_WRITE(SROM_DATA_1, cr9_ioaddr);
  1488. SROM_CLK_WRITE(SROM_DATA_0, cr9_ioaddr);
  1490. /* Send the offset */
  1491. for (i = 5; i >= 0; i--) {
  1492. srom_data = (offset & (1 << i)) ? SROM_DATA_1 : SROM_DATA_0;
  1493. SROM_CLK_WRITE(srom_data, cr9_ioaddr);
  1494. }
  1496. outl(CR9_SROM_READ | CR9_SRCS, cr9_ioaddr);
  1498. for (i = 16; i > 0; i--) {
  1499. outl(CR9_SROM_READ | CR9_SRCS | CR9_SRCLK, cr9_ioaddr);
  1500. udelay(5);
  1501. srom_data = (srom_data << 1) | ((inl(cr9_ioaddr) & CR9_CRDOUT) ? 1 : 0);
  1502. outl(CR9_SROM_READ | CR9_SRCS, cr9_ioaddr);
  1503. udelay(5);
  1504. }
  1506. outl(CR9_SROM_READ, cr9_ioaddr);
  1507. return srom_data;
  1508. }
  1511. /*
  1512.  * Auto sense the media mode
  1513.  */
  1515. static u8 dmfe_sense_speed(struct dmfe_board_info * db)
  1516. {
  1517. u8 ErrFlag = 0;
  1518. u16 phy_mode;
  1520. /* CR6 bit18=0, select 10/100M */
  1521. update_cr6( (db->cr6_data & ~0x40000), db->ioaddr);
  1523. phy_mode = phy_read(db->ioaddr, db->phy_addr, 1, db->chip_id);
  1524. phy_mode = phy_read(db->ioaddr, db->phy_addr, 1, db->chip_id);
  1526. if ( (phy_mode & 0x24) == 0x24 ) {
  1527. if (db->chip_id == PCI_DM9132_ID) /* DM9132 */
  1528. phy_mode = phy_read(db->ioaddr, db->phy_addr, 7, db->chip_id) & 0xf000;
  1529. else  /* DM9102/DM9102A */
  1530. phy_mode = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id) & 0xf000;
  1531. /* printk(DRV_NAME ": Phy_mode %x ",phy_mode); */
  1532. switch (phy_mode) {
  1533. case 0x1000: db->op_mode = DMFE_10MHF; break;
  1534. case 0x2000: db->op_mode = DMFE_10MFD; break;
  1535. case 0x4000: db->op_mode = DMFE_100MHF; break;
  1536. case 0x8000: db->op_mode = DMFE_100MFD; break;
  1537. default: db->op_mode = DMFE_10MHF;
  1538. ErrFlag = 1;
  1539. break;
  1540. }
  1541. } else {
  1542. db->op_mode = DMFE_10MHF;
  1543. DMFE_DBUG(0, "Link Failed :", phy_mode);
  1544. ErrFlag = 1;
  1545. }
  1547. return ErrFlag;
  1548. }
  1551. /*
  1552.  * Set 10/100 phyxcer capability
  1553.  * AUTO mode : phyxcer register4 is NIC capability
  1554.  * Force mode: phyxcer register4 is the force media
  1555.  */
  1557. static void dmfe_set_phyxcer(struct dmfe_board_info *db)
  1558. {
  1559. u16 phy_reg;
  1561. /* Select 10/100M phyxcer */
  1562. db->cr6_data &= ~0x40000;
  1563. update_cr6(db->cr6_data, db->ioaddr);
  1565. /* DM9009 Chip: Phyxcer reg18 bit12=0 */
  1566. if (db->chip_id == PCI_DM9009_ID) {
  1567. phy_reg = phy_read(db->ioaddr, db->phy_addr, 18, db->chip_id) & ~0x1000;
  1568. phy_write(db->ioaddr, db->phy_addr, 18, phy_reg, db->chip_id);
  1569. }
  1571. /* Phyxcer capability setting */
  1572. phy_reg = phy_read(db->ioaddr, db->phy_addr, 4, db->chip_id) & ~0x01e0;
  1574. if (db->media_mode & DMFE_AUTO) {
  1575. /* AUTO Mode */
  1576. phy_reg |= db->PHY_reg4;
  1577. } else {
  1578. /* Force Mode */
  1579. switch(db->media_mode) {
  1580. case DMFE_10MHF: phy_reg |= 0x20; break;
  1581. case DMFE_10MFD: phy_reg |= 0x40; break;
  1582. case DMFE_100MHF: phy_reg |= 0x80; break;
  1583. case DMFE_100MFD: phy_reg |= 0x100; break;
  1584. }
  1585. if (db->chip_id == PCI_DM9009_ID) phy_reg &= 0x61;
  1586. }
  1588.    /* Write new capability to Phyxcer Reg4 */
  1589. if ( !(phy_reg & 0x01e0)) {
  1590. phy_reg|=db->PHY_reg4;
  1591. db->media_mode|=DMFE_AUTO;
  1592. }
  1593. phy_write(db->ioaddr, db->phy_addr, 4, phy_reg, db->chip_id);
  1595.   /* Restart Auto-Negotiation */
  1596. if ( db->chip_type && (db->chip_id == PCI_DM9102_ID) )
  1597. phy_write(db->ioaddr, db->phy_addr, 0, 0x1800, db->chip_id);
  1598. if ( !db->chip_type )
  1599. phy_write(db->ioaddr, db->phy_addr, 0, 0x1200, db->chip_id);
  1600. }
  1603. /*
  1604.  * Process op-mode
  1605.  * AUTO mode : PHY controller in Auto-negotiation Mode
  1606.  * Force mode: PHY controller in force mode with HUB
  1607.  * N-way force capability with SWITCH
  1608.  */
  1610. static void dmfe_process_mode(struct dmfe_board_info *db)
  1611. {
  1612. u16 phy_reg;
  1614. /* Full Duplex Mode Check */
  1615. if (db->op_mode & 0x4)
  1616. db->cr6_data |= CR6_FDM; /* Set Full Duplex Bit */
  1617. else
  1618. db->cr6_data &= ~CR6_FDM; /* Clear Full Duplex Bit */
  1620. /* Transciver Selection */
  1621. if (db->op_mode & 0x10) /* 1M HomePNA */
  1622. db->cr6_data |= 0x40000;/* External MII select */
  1623. else
  1624. db->cr6_data &= ~0x40000;/* Internal 10/100 transciver */
  1626. update_cr6(db->cr6_data, db->ioaddr);
  1628. /* 10/100M phyxcer force mode need */
  1629. if ( !(db->media_mode & 0x18)) {
  1630. /* Forece Mode */
  1631. phy_reg = phy_read(db->ioaddr, db->phy_addr, 6, db->chip_id);
  1632. if ( !(phy_reg & 0x1) ) {
  1633. /* parter without N-Way capability */
  1634. phy_reg = 0x0;
  1635. switch(db->op_mode) {
  1636. case DMFE_10MHF: phy_reg = 0x0; break;
  1637. case DMFE_10MFD: phy_reg = 0x100; break;
  1638. case DMFE_100MHF: phy_reg = 0x2000; break;
  1639. case DMFE_100MFD: phy_reg = 0x2100; break;
  1640. }
  1641. phy_write(db->ioaddr, db->phy_addr, 0, phy_reg, db->chip_id);
  1642.         if ( db->chip_type && (db->chip_id == PCI_DM9102_ID) )
  1643. mdelay(20);
  1644. phy_write(db->ioaddr, db->phy_addr, 0, phy_reg, db->chip_id);
  1645. }
  1646. }
  1647. }
  1650. /*
  1651.  * Write a word to Phy register
  1652.  */
  1654. static void phy_write(unsigned long iobase, u8 phy_addr, u8 offset, u16 phy_data, u32 chip_id)
  1655. {
  1656. u16 i;
  1657. unsigned long ioaddr;
  1659. if (chip_id == PCI_DM9132_ID) {
  1660. ioaddr = iobase + 0x80 + offset * 4;
  1661. outw(phy_data, ioaddr);
  1662. } else {
  1663. /* DM9102/DM9102A Chip */
  1664. ioaddr = iobase + DCR9;
  1666. /* Send 33 synchronization clock to Phy controller */
  1667. for (i = 0; i < 35; i++)
  1668. phy_write_1bit(ioaddr, PHY_DATA_1);
  1670. /* Send start command(01) to Phy */
  1671. phy_write_1bit(ioaddr, PHY_DATA_0);
  1672. phy_write_1bit(ioaddr, PHY_DATA_1);
  1674. /* Send write command(01) to Phy */
  1675. phy_write_1bit(ioaddr, PHY_DATA_0);
  1676. phy_write_1bit(ioaddr, PHY_DATA_1);
  1678. /* Send Phy addres */
  1679. for (i = 0x10; i > 0; i = i >> 1)
  1680. phy_write_1bit(ioaddr, phy_addr & i ? PHY_DATA_1 : PHY_DATA_0);
  1682. /* Send register addres */
  1683. for (i = 0x10; i > 0; i = i >> 1)
  1684. phy_write_1bit(ioaddr, offset & i ? PHY_DATA_1 : PHY_DATA_0);
  1686. /* written trasnition */
  1687. phy_write_1bit(ioaddr, PHY_DATA_1);
  1688. phy_write_1bit(ioaddr, PHY_DATA_0);
  1690. /* Write a word data to PHY controller */
  1691. for ( i = 0x8000; i > 0; i >>= 1)
  1692. phy_write_1bit(ioaddr, phy_data & i ? PHY_DATA_1 : PHY_DATA_0);
  1693. }
  1694. }
  1697. /*
  1698.  * Read a word data from phy register
  1699.  */
  1701. static u16 phy_read(unsigned long iobase, u8 phy_addr, u8 offset, u32 chip_id)
  1702. {
  1703. int i;
  1704. u16 phy_data;
  1705. unsigned long ioaddr;
  1707. if (chip_id == PCI_DM9132_ID) {
  1708. /* DM9132 Chip */
  1709. ioaddr = iobase + 0x80 + offset * 4;
  1710. phy_data = inw(ioaddr);
  1711. } else {
  1712. /* DM9102/DM9102A Chip */
  1713. ioaddr = iobase + DCR9;
  1715. /* Send 33 synchronization clock to Phy controller */
  1716. for (i = 0; i < 35; i++)
  1717. phy_write_1bit(ioaddr, PHY_DATA_1);
  1719. /* Send start command(01) to Phy */
  1720. phy_write_1bit(ioaddr, PHY_DATA_0);
  1721. phy_write_1bit(ioaddr, PHY_DATA_1);
  1723. /* Send read command(10) to Phy */
  1724. phy_write_1bit(ioaddr, PHY_DATA_1);
  1725. phy_write_1bit(ioaddr, PHY_DATA_0);
  1727. /* Send Phy addres */
  1728. for (i = 0x10; i > 0; i = i >> 1)
  1729. phy_write_1bit(ioaddr, phy_addr & i ? PHY_DATA_1 : PHY_DATA_0);
  1731. /* Send register addres */
  1732. for (i = 0x10; i > 0; i = i >> 1)
  1733. phy_write_1bit(ioaddr, offset & i ? PHY_DATA_1 : PHY_DATA_0);
  1735. /* Skip transition state */
  1736. phy_read_1bit(ioaddr);
  1738. /* read 16bit data */
  1739. for (phy_data = 0, i = 0; i < 16; i++) {
  1740. phy_data <<= 1;
  1741. phy_data |= phy_read_1bit(ioaddr);
  1742. }
  1743. }
  1745. return phy_data;
  1746. }
  1749. /*
  1750.  * Write one bit data to Phy Controller
  1751.  */
  1753. static void phy_write_1bit(unsigned long ioaddr, u32 phy_data)
  1754. {
  1755. outl(phy_data, ioaddr); /* MII Clock Low */
  1756. udelay(1);
  1757. outl(phy_data | MDCLKH, ioaddr); /* MII Clock High */
  1758. udelay(1);
  1759. outl(phy_data, ioaddr); /* MII Clock Low */
  1760. udelay(1);
  1761. }
  1764. /*
  1765.  * Read one bit phy data from PHY controller
  1766.  */
  1768. static u16 phy_read_1bit(unsigned long ioaddr)
  1769. {
  1770. u16 phy_data;
  1772. outl(0x50000, ioaddr);
  1773. udelay(1);
  1774. phy_data = ( inl(ioaddr) >> 19 ) & 0x1;
  1775. outl(0x40000, ioaddr);
  1776. udelay(1);
  1778. return phy_data;
  1779. }
  1782. /*
  1783.  * Calculate the CRC valude of the Rx packet
  1784.  * flag =  1 : return the reverse CRC (for the received packet CRC)
  1785.  * 0 : return the normal CRC (for Hash Table index)
  1786.  */
  1788. static inline u32 cal_CRC(unsigned char * Data, unsigned int Len, u8 flag)
  1789. {
  1790. u32 crc = ether_crc_le(Len, Data);
  1791. if (flag) crc = ~crc;
  1792. return crc;
  1793. }
  1796. /*
  1797.  * Parser SROM and media mode
  1798.  */
  1800. static void dmfe_parse_srom(struct dmfe_board_info * db)
  1801. {
  1802. char * srom = db->srom;
  1803. int dmfe_mode, tmp_reg;
  1805. DMFE_DBUG(0, "dmfe_parse_srom() ", 0);
  1807. /* Init CR15 */
  1808. db->cr15_data = CR15_DEFAULT;
  1810. /* Check SROM Version */
  1811. if ( ( (int) srom[18] & 0xff) == SROM_V41_CODE) {
  1812. /* SROM V4.01 */
  1813. /* Get NIC support media mode */
  1814. db->NIC_capability = le16_to_cpup(srom + 34);
  1815. db->PHY_reg4 = 0;
  1816. for (tmp_reg = 1; tmp_reg < 0x10; tmp_reg <<= 1) {
  1817. switch( db->NIC_capability & tmp_reg ) {
  1818. case 0x1: db->PHY_reg4 |= 0x0020; break;
  1819. case 0x2: db->PHY_reg4 |= 0x0040; break;
  1820. case 0x4: db->PHY_reg4 |= 0x0080; break;
  1821. case 0x8: db->PHY_reg4 |= 0x0100; break;
  1822. }
  1823. }
  1825. /* Media Mode Force or not check */
  1826. dmfe_mode = le32_to_cpup(srom + 34) & le32_to_cpup(srom + 36);
  1827. switch(dmfe_mode) {
  1828. case 0x4: dmfe_media_mode = DMFE_100MHF; break; /* 100MHF */
  1829. case 0x2: dmfe_media_mode = DMFE_10MFD; break; /* 10MFD */
  1830. case 0x8: dmfe_media_mode = DMFE_100MFD; break; /* 100MFD */
  1831. case 0x100:
  1832. case 0x200: dmfe_media_mode = DMFE_1M_HPNA; break;/* HomePNA */
  1833. }
  1835. /* Special Function setting */
  1836. /* VLAN function */
  1837. if ( (SF_mode & 0x1) || (srom[43] & 0x80) )
  1838. db->cr15_data |= 0x40;
  1840. /* Flow Control */
  1841. if ( (SF_mode & 0x2) || (srom[40] & 0x1) )
  1842. db->cr15_data |= 0x400;
  1844. /* TX pause packet */
  1845. if ( (SF_mode & 0x4) || (srom[40] & 0xe) )
  1846. db->cr15_data |= 0x9800;
  1847. }
  1849. /* Parse HPNA parameter */
  1850. db->HPNA_command = 1;
  1852. /* Accept remote command or not */
  1853. if (HPNA_rx_cmd == 0)
  1854. db->HPNA_command |= 0x8000;
  1856.  /* Issue remote command & operation mode */
  1857. if (HPNA_tx_cmd == 1)
  1858. switch(HPNA_mode) { /* Issue Remote Command */
  1859. case 0: db->HPNA_command |= 0x0904; break;
  1860. case 1: db->HPNA_command |= 0x0a00; break;
  1861. case 2: db->HPNA_command |= 0x0506; break;
  1862. case 3: db->HPNA_command |= 0x0602; break;
  1863. }
  1864. else
  1865. switch(HPNA_mode) { /* Don't Issue */
  1866. case 0: db->HPNA_command |= 0x0004; break;
  1867. case 1: db->HPNA_command |= 0x0000; break;
  1868. case 2: db->HPNA_command |= 0x0006; break;
  1869. case 3: db->HPNA_command |= 0x0002; break;
  1870. }
  1872. /* Check DM9801 or DM9802 present or not */
  1873. db->HPNA_present = 0;
  1874. update_cr6(db->cr6_data|0x40000, db->ioaddr);
  1875. tmp_reg = phy_read(db->ioaddr, db->phy_addr, 3, db->chip_id);
  1876. if ( ( tmp_reg & 0xfff0 ) == 0xb900 ) {
  1877. /* DM9801 or DM9802 present */
  1878. db->HPNA_timer = 8;
  1879. if ( phy_read(db->ioaddr, db->phy_addr, 31, db->chip_id) == 0x4404) {
  1880. /* DM9801 HomeRun */
  1881. db->HPNA_present = 1;
  1882. dmfe_program_DM9801(db, tmp_reg);
  1883. } else {
  1884. /* DM9802 LongRun */
  1885. db->HPNA_present = 2;
  1886. dmfe_program_DM9802(db);
  1887. }
  1888. }
  1890. }
  1893. /*
  1894.  * Init HomeRun DM9801
  1895.  */
  1897. static void dmfe_program_DM9801(struct dmfe_board_info * db, int HPNA_rev)
  1898. {
  1899. uint reg17, reg25;
  1901. if ( !HPNA_NoiseFloor ) HPNA_NoiseFloor = DM9801_NOISE_FLOOR;
  1902. switch(HPNA_rev) {
  1903. case 0xb900: /* DM9801 E3 */
  1904. db->HPNA_command |= 0x1000;
  1905. reg25 = phy_read(db->ioaddr, db->phy_addr, 24, db->chip_id);
  1906. reg25 = ( (reg25 + HPNA_NoiseFloor) & 0xff) | 0xf000;
  1907. reg17 = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id);
  1908. break;
  1909. case 0xb901: /* DM9801 E4 */
  1910. reg25 = phy_read(db->ioaddr, db->phy_addr, 25, db->chip_id);
  1911. reg25 = (reg25 & 0xff00) + HPNA_NoiseFloor;
  1912. reg17 = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id);
  1913. reg17 = (reg17 & 0xfff0) + HPNA_NoiseFloor + 3;
  1914. break;
  1915. case 0xb902: /* DM9801 E5 */
  1916. case 0xb903: /* DM9801 E6 */
  1917. default:
  1918. db->HPNA_command |= 0x1000;
  1919. reg25 = phy_read(db->ioaddr, db->phy_addr, 25, db->chip_id);
  1920. reg25 = (reg25 & 0xff00) + HPNA_NoiseFloor - 5;
  1921. reg17 = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id);
  1922. reg17 = (reg17 & 0xfff0) + HPNA_NoiseFloor;
  1923. break;
  1924. }
  1925. phy_write(db->ioaddr, db->phy_addr, 16, db->HPNA_command, db->chip_id);
  1926. phy_write(db->ioaddr, db->phy_addr, 17, reg17, db->chip_id);
  1927. phy_write(db->ioaddr, db->phy_addr, 25, reg25, db->chip_id);
  1928. }
  1931. /*
  1932.  * Init HomeRun DM9802
  1933.  */
  1935. static void dmfe_program_DM9802(struct dmfe_board_info * db)
  1936. {
  1937. uint phy_reg;
  1939. if ( !HPNA_NoiseFloor ) HPNA_NoiseFloor = DM9802_NOISE_FLOOR;
  1940. phy_write(db->ioaddr, db->phy_addr, 16, db->HPNA_command, db->chip_id);
  1941. phy_reg = phy_read(db->ioaddr, db->phy_addr, 25, db->chip_id);
  1942. phy_reg = ( phy_reg & 0xff00) + HPNA_NoiseFloor;
  1943. phy_write(db->ioaddr, db->phy_addr, 25, phy_reg, db->chip_id);
  1944. }
  1947. /*
  1948.  * Check remote HPNA power and speed status. If not correct,
  1949.  * issue command again.
  1950. */
  1952. static void dmfe_HPNA_remote_cmd_chk(struct dmfe_board_info * db)
  1953. {
  1954. uint phy_reg;
  1956. /* Got remote device status */
  1957. phy_reg = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id) & 0x60;
  1958. switch(phy_reg) {
  1959. case 0x00: phy_reg = 0x0a00;break; /* LP/LS */
  1960. case 0x20: phy_reg = 0x0900;break; /* LP/HS */
  1961. case 0x40: phy_reg = 0x0600;break; /* HP/LS */
  1962. case 0x60: phy_reg = 0x0500;break; /* HP/HS */
  1963. }
  1965. /* Check remote device status match our setting ot not */
  1966. if ( phy_reg != (db->HPNA_command & 0x0f00) ) {
  1967. phy_write(db->ioaddr, db->phy_addr, 16, db->HPNA_command, db->chip_id);
  1968. db->HPNA_timer=8;
  1969. } else
  1970. db->HPNA_timer=600; /* Match, every 10 minutes, check */
  1971. }
  1975. static struct pci_device_id dmfe_pci_tbl[] __devinitdata = {
  1976. { 0x1282, 0x9132, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9132_ID },
  1977. { 0x1282, 0x9102, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9102_ID },
  1978. { 0x1282, 0x9100, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9100_ID },
  1979. { 0x1282, 0x9009, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9009_ID },
  1980. { 0, }
  1981. };
  1982. MODULE_DEVICE_TABLE(pci, dmfe_pci_tbl);
  1985. static struct pci_driver dmfe_driver = {
  1986. name: "dmfe",
  1987. id_table: dmfe_pci_tbl,
  1988. probe: dmfe_init_one,
  1989. remove: __devexit_p(dmfe_remove_one),
  1990. };
  1992. MODULE_AUTHOR("Sten Wang, sten_wang@davicom.com.tw");
  1993. MODULE_DESCRIPTION("Davicom DM910X fast ethernet driver");
  1994. MODULE_LICENSE("GPL");
  1996. MODULE_PARM(debug, "i");
  1997. MODULE_PARM(mode, "i");
  1998. MODULE_PARM(cr6set, "i");
  1999. MODULE_PARM(chkmode, "i");
  2000. MODULE_PARM(HPNA_mode, "i");
  2001. MODULE_PARM(HPNA_rx_cmd, "i");
  2002. MODULE_PARM(HPNA_tx_cmd, "i");
  2003. MODULE_PARM(HPNA_NoiseFloor, "i");
  2004. MODULE_PARM(SF_mode, "i");
  2005. MODULE_PARM_DESC(debug, "Davicom DM9xxx enable debugging (0-1)");
  2006. MODULE_PARM_DESC(mode, "Davicom DM9xxx: Bit 0: 10/100Mbps, bit 2: duplex, bit 8: HomePNA");
  2007. MODULE_PARM_DESC(SF_mode, "Davicom DM9xxx special function (bit 0: VLAN, bit 1 Flow Control, bit 2: TX pause packet)");
  2009. /* Description:
  2010.  * when user used insmod to add module, system invoked init_module()
  2011.  * to initilize and register.
  2012.  */
  2014. static int __init dmfe_init_module(void)
  2015. {
  2016. int rc;
  2018. printk(version);
  2019. printed_version = 1;
  2021. DMFE_DBUG(0, "init_module() ", debug);
  2023. if (debug)
  2024. dmfe_debug = debug; /* set debug flag */
  2025. if (cr6set)
  2026. dmfe_cr6_user_set = cr6set;
  2028.   switch(mode) {
  2029.     case DMFE_10MHF:
  2030. case DMFE_100MHF:
  2031. case DMFE_10MFD:
  2032. case DMFE_100MFD:
  2033. case DMFE_1M_HPNA:
  2034. dmfe_media_mode = mode;
  2035. break;
  2036. default:dmfe_media_mode = DMFE_AUTO;
  2037. break;
  2038. }
  2040. if (HPNA_mode > 4)
  2041. HPNA_mode = 0; /* Default: LP/HS */
  2042. if (HPNA_rx_cmd > 1)
  2043. HPNA_rx_cmd = 0; /* Default: Ignored remote cmd */
  2044. if (HPNA_tx_cmd > 1)
  2045. HPNA_tx_cmd = 0; /* Default: Don't issue remote cmd */
  2046. if (HPNA_NoiseFloor > 15)
  2047. HPNA_NoiseFloor = 0;
  2049. rc = pci_module_init(&dmfe_driver);
  2050. if (rc < 0)
  2051. return rc;
  2053. return 0;
  2054. }
  2057. /*
  2058.  * Description:
  2059.  * when user used rmmod to delete module, system invoked clean_module()
  2060.  * to un-register all registered services.
  2061.  */
  2063. static void __exit dmfe_cleanup_module(void)
  2064. {
  2065. DMFE_DBUG(0, "dmfe_clean_module() ", debug);
  2066. pci_unregister_driver(&dmfe_driver);
  2067. }
  2069. module_init(dmfe_init_module);
  2070. module_exit(dmfe_cleanup_module);