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

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

Linux/Unix编程

开发平台：

Unix_Linux

fealnx.c：源码内容
  1. /*
  2. Written 1998-2000 by Donald Becker.
  4. This software may be used and distributed according to the terms of
  5. the GNU General Public License (GPL), incorporated herein by reference.
  6. Drivers based on or derived from this code fall under the GPL and must
  7. retain the authorship, copyright and license notice.  This file is not
  8. a complete program and may only be used when the entire operating
  9. system is licensed under the GPL.
  11. The author may be reached as becker@scyld.com, or C/O
  12. Scyld Computing Corporation
  13. 410 Severn Ave., Suite 210
  14. Annapolis MD 21403
  16. Support information and updates available at
  17. http://www.scyld.com/network/pci-skeleton.html
  19. Linux kernel updates:
  21. Version 2.51, Nov 17, 2001 (jgarzik):
  22. - Add ethtool support
  23. - Replace some MII-related magic numbers with constants
  25. */
  27. #define DRV_NAME "fealnx"
  28. #define DRV_VERSION "2.51"
  29. #define DRV_RELDATE "Nov-17-2001"
  31. static int debug; /* 1-> print debug message */
  32. static int max_interrupt_work = 20;
  34. /* Maximum number of multicast addresses to filter (vs. Rx-all-multicast). */
  35. static int multicast_filter_limit = 32;
  37. /* Set the copy breakpoint for the copy-only-tiny-frames scheme. */
  38. /* Setting to > 1518 effectively disables this feature.          */
  39. static int rx_copybreak;
  41. /* Used to pass the media type, etc.                            */
  42. /* Both 'options[]' and 'full_duplex[]' should exist for driver */
  43. /* interoperability.                                            */
  44. /* The media type is usually passed in 'options[]'.             */
  45. #define MAX_UNITS 8 /* More are supported, limit only on options */
  46. static int options[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1 };
  47. static int full_duplex[MAX_UNITS] = { -1, -1, -1, -1, -1, -1, -1, -1 };
  49. /* Operational parameters that are set at compile time.                 */
  50. /* Keep the ring sizes a power of two for compile efficiency.           */
  51. /* The compiler will convert <unsigned>'%'<2^N> into a bit mask.        */
  52. /* Making the Tx ring too large decreases the effectiveness of channel  */
  53. /* bonding and packet priority.                                         */
  54. /* There are no ill effects from too-large receive rings.               */
  55. // 88-12-9 modify,
  56. // #define TX_RING_SIZE    16
  57. // #define RX_RING_SIZE    32
  58. #define TX_RING_SIZE    6
  59. #define RX_RING_SIZE    12
  60. #define TX_TOTAL_SIZE TX_RING_SIZE*sizeof(struct fealnx_desc)
  61. #define RX_TOTAL_SIZE RX_RING_SIZE*sizeof(struct fealnx_desc)
  63. /* Operational parameters that usually are not changed. */
  64. /* Time in jiffies before concluding the transmitter is hung. */
  65. #define TX_TIMEOUT      (2*HZ)
  67. #define PKT_BUF_SZ      1536 /* Size of each temporary Rx buffer. */
  70. /* Include files, designed to support most kernel versions 2.0.0 and later. */
  71. #include <linux/module.h>
  72. #include <linux/kernel.h>
  73. #include <linux/sched.h>
  74. #include <linux/string.h>
  75. #include <linux/timer.h>
  76. #include <linux/errno.h>
  77. #include <linux/ioport.h>
  78. #include <linux/slab.h>
  79. #include <linux/interrupt.h>
  80. #include <linux/pci.h>
  81. #include <linux/netdevice.h>
  82. #include <linux/etherdevice.h>
  83. #include <linux/skbuff.h>
  84. #include <linux/init.h>
  85. #include <linux/mii.h>
  86. #include <linux/ethtool.h>
  87. #include <linux/crc32.h>
  88. #include <asm/processor.h> /* Processor type for cache alignment. */
  89. #include <asm/bitops.h>
  90. #include <asm/io.h>
  91. #include <asm/uaccess.h>
  93. /* These identify the driver base version and may not be removed. */
  94. static char version[] __devinitdata =
  95. KERN_INFO DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE "n";
  98. /* This driver was written to use PCI memory space, however some x86 systems
  99.    work only with I/O space accesses. */
  100. #ifndef __alpha__
  101. #define USE_IO_OPS
  102. #endif
  104. #ifdef USE_IO_OPS
  105. #undef readb
  106. #undef readw
  107. #undef readl
  108. #undef writeb
  109. #undef writew
  110. #undef writel
  111. #define readb inb
  112. #define readw inw
  113. #define readl inl
  114. #define writeb outb
  115. #define writew outw
  116. #define writel outl
  117. #endif
  119. /* Kernel compatibility defines, some common to David Hinds' PCMCIA package. */
  120. /* This is only in the support-all-kernels source code. */
  122. #define RUN_AT(x) (jiffies + (x))
  124. MODULE_AUTHOR("Myson or whoever");
  125. MODULE_DESCRIPTION("Myson MTD-8xx 100/10M Ethernet PCI Adapter Driver");
  126. MODULE_LICENSE("GPL");
  127. MODULE_PARM(max_interrupt_work, "i");
  128. //MODULE_PARM(min_pci_latency, "i");
  129. MODULE_PARM(debug, "i");
  130. MODULE_PARM(rx_copybreak, "i");
  131. MODULE_PARM(multicast_filter_limit, "i");
  132. MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i");
  133. MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");
  134. MODULE_PARM_DESC(max_interrupt_work, "fealnx maximum events handled per interrupt");
  135. MODULE_PARM_DESC(debug, "fealnx enable debugging (0-1)");
  136. MODULE_PARM_DESC(rx_copybreak, "fealnx copy breakpoint for copy-only-tiny-frames");
  137. MODULE_PARM_DESC(multicast_filter_limit, "fealnx maximum number of filtered multicast addresses");
  138. MODULE_PARM_DESC(options, "fealnx: Bits 0-3: media type, bit 17: full duplex");
  139. MODULE_PARM_DESC(full_duplex, "fealnx full duplex setting(s) (1)");
  141. #define MIN_REGION_SIZE 136
  143. enum pci_flags_bit {
  144. PCI_USES_IO = 1,
  145. PCI_USES_MEM = 2,
  146. PCI_USES_MASTER = 4,
  147. PCI_ADDR0 = 0x10 << 0,
  148. PCI_ADDR1 = 0x10 << 1,
  149. PCI_ADDR2 = 0x10 << 2,
  150. PCI_ADDR3 = 0x10 << 3,
  151. };
  153. /* A chip capabilities table, matching the entries in pci_tbl[] above. */
  154. enum chip_capability_flags {
  155. HAS_MII_XCVR,
  156. HAS_CHIP_XCVR,
  157. };
  159. /* 89/6/13 add, */
  160. /* for different PHY */
  161. enum phy_type_flags {
  162. MysonPHY = 1,
  163. AhdocPHY = 2,
  164. SeeqPHY = 3,
  165. MarvellPHY = 4,
  166. Myson981 = 5,
  167. LevelOnePHY = 6,
  168. OtherPHY = 10,
  169. };
  171. struct chip_info {
  172. char *chip_name;
  173. int io_size;
  174. int flags;
  175. };
  177. static struct chip_info skel_netdrv_tbl[] = {
  178. {"100/10M Ethernet PCI Adapter", 136, HAS_MII_XCVR},
  179. {"100/10M Ethernet PCI Adapter", 136, HAS_CHIP_XCVR},
  180. {"1000/100/10M Ethernet PCI Adapter", 136, HAS_MII_XCVR},
  181. };
  183. /* Offsets to the Command and Status Registers. */
  184. enum fealnx_offsets {
  185. PAR0 = 0x0, /* physical address 0-3 */
  186. PAR1 = 0x04, /* physical address 4-5 */
  187. MAR0 = 0x08, /* multicast address 0-3 */
  188. MAR1 = 0x0C, /* multicast address 4-7 */
  189. FAR0 = 0x10, /* flow-control address 0-3 */
  190. FAR1 = 0x14, /* flow-control address 4-5 */
  191. TCRRCR = 0x18, /* receive & transmit configuration */
  192. BCR = 0x1C, /* bus command */
  193. TXPDR = 0x20, /* transmit polling demand */
  194. RXPDR = 0x24, /* receive polling demand */
  195. RXCWP = 0x28, /* receive current word pointer */
  196. TXLBA = 0x2C, /* transmit list base address */
  197. RXLBA = 0x30, /* receive list base address */
  198. ISR = 0x34, /* interrupt status */
  199. IMR = 0x38, /* interrupt mask */
  200. FTH = 0x3C, /* flow control high/low threshold */
  201. MANAGEMENT = 0x40, /* bootrom/eeprom and mii management */
  202. TALLY = 0x44, /* tally counters for crc and mpa */
  203. TSR = 0x48, /* tally counter for transmit status */
  204. BMCRSR = 0x4c, /* basic mode control and status */
  205. PHYIDENTIFIER = 0x50, /* phy identifier */
  206. ANARANLPAR = 0x54, /* auto-negotiation advertisement and link
  207.    partner ability */
  208. ANEROCR = 0x58, /* auto-negotiation expansion and pci conf. */
  209. BPREMRPSR = 0x5c, /* bypass & receive error mask and phy status */
  210. };
  212. /* Bits in the interrupt status/enable registers. */
  213. /* The bits in the Intr Status/Enable registers, mostly interrupt sources. */
  214. enum intr_status_bits {
  215. RFCON = 0x00020000, /* receive flow control xon packet */
  216. RFCOFF = 0x00010000, /* receive flow control xoff packet */
  217. LSCStatus = 0x00008000, /* link status change */
  218. ANCStatus = 0x00004000, /* autonegotiation completed */
  219. FBE = 0x00002000, /* fatal bus error */
  220. FBEMask = 0x00001800, /* mask bit12-11 */
  221. ParityErr = 0x00000000, /* parity error */
  222. TargetErr = 0x00001000, /* target abort */
  223. MasterErr = 0x00000800, /* master error */
  224. TUNF = 0x00000400, /* transmit underflow */
  225. ROVF = 0x00000200, /* receive overflow */
  226. ETI = 0x00000100, /* transmit early int */
  227. ERI = 0x00000080, /* receive early int */
  228. CNTOVF = 0x00000040, /* counter overflow */
  229. RBU = 0x00000020, /* receive buffer unavailable */
  230. TBU = 0x00000010, /* transmit buffer unavilable */
  231. TI = 0x00000008, /* transmit interrupt */
  232. RI = 0x00000004, /* receive interrupt */
  233. RxErr = 0x00000002, /* receive error */
  234. };
  236. /* Bits in the NetworkConfig register. */
  237. enum rx_mode_bits {
  238. RxModeMask = 0xe0,
  239. PROM = 0x80, /* promiscuous mode */
  240. AB = 0x40, /* accept broadcast */
  241. AM = 0x20, /* accept mutlicast */
  242. ARP = 0x08, /* receive runt pkt */
  243. ALP = 0x04, /* receive long pkt */
  244. SEP = 0x02, /* receive error pkt */
  245. };
  247. /* The Tulip Rx and Tx buffer descriptors. */
  248. struct fealnx_desc {
  249. s32 status;
  250. s32 control;
  251. u32 buffer;
  252. u32 next_desc;
  253. struct fealnx_desc *next_desc_logical;
  254. struct sk_buff *skbuff;
  255. u32 reserved1;
  256. u32 reserved2;
  257. };
  259. /* Bits in network_desc.status */
  260. enum rx_desc_status_bits {
  261. RXOWN = 0x80000000, /* own bit */
  262. FLNGMASK = 0x0fff0000, /* frame length */
  263. FLNGShift = 16,
  264. MARSTATUS = 0x00004000, /* multicast address received */
  265. BARSTATUS = 0x00002000, /* broadcast address received */
  266. PHYSTATUS = 0x00001000, /* physical address received */
  267. RXFSD = 0x00000800, /* first descriptor */
  268. RXLSD = 0x00000400, /* last descriptor */
  269. ErrorSummary = 0x80, /* error summary */
  270. RUNT = 0x40, /* runt packet received */
  271. LONG = 0x20, /* long packet received */
  272. FAE = 0x10, /* frame align error */
  273. CRC = 0x08, /* crc error */
  274. RXER = 0x04, /* receive error */
  275. };
  277. enum rx_desc_control_bits {
  278. RXIC = 0x00800000, /* interrupt control */
  279. RBSShift = 0,
  280. };
  282. enum tx_desc_status_bits {
  283. TXOWN = 0x80000000, /* own bit */
  284. JABTO = 0x00004000, /* jabber timeout */
  285. CSL = 0x00002000, /* carrier sense lost */
  286. LC = 0x00001000, /* late collision */
  287. EC = 0x00000800, /* excessive collision */
  288. UDF = 0x00000400, /* fifo underflow */
  289. DFR = 0x00000200, /* deferred */
  290. HF = 0x00000100, /* heartbeat fail */
  291. NCRMask = 0x000000ff, /* collision retry count */
  292. NCRShift = 0,
  293. };
  295. enum tx_desc_control_bits {
  296. TXIC = 0x80000000, /* interrupt control */
  297. ETIControl = 0x40000000, /* early transmit interrupt */
  298. TXLD = 0x20000000, /* last descriptor */
  299. TXFD = 0x10000000, /* first descriptor */
  300. CRCEnable = 0x08000000, /* crc control */
  301. PADEnable = 0x04000000, /* padding control */
  302. RetryTxLC = 0x02000000, /* retry late collision */
  303. PKTSMask = 0x3ff800, /* packet size bit21-11 */
  304. PKTSShift = 11,
  305. TBSMask = 0x000007ff, /* transmit buffer bit 10-0 */
  306. TBSShift = 0,
  307. };
  309. /* BootROM/EEPROM/MII Management Register */
  310. #define MASK_MIIR_MII_READ       0x00000000
  311. #define MASK_MIIR_MII_WRITE      0x00000008
  312. #define MASK_MIIR_MII_MDO        0x00000004
  313. #define MASK_MIIR_MII_MDI        0x00000002
  314. #define MASK_MIIR_MII_MDC        0x00000001
  316. /* ST+OP+PHYAD+REGAD+TA */
  317. #define OP_READ             0x6000 /* ST:01+OP:10+PHYAD+REGAD+TA:Z0 */
  318. #define OP_WRITE            0x5002 /* ST:01+OP:01+PHYAD+REGAD+TA:10 */
  320. /* ------------------------------------------------------------------------- */
  321. /*      Constants for Myson PHY                                              */
  322. /* ------------------------------------------------------------------------- */
  323. #define MysonPHYID      0xd0000302
  324. /* 89-7-27 add, (begin) */
  325. #define MysonPHYID0     0x0302
  326. #define StatusRegister  18
  327. #define SPEED100        0x0400 // bit10
  328. #define FULLMODE        0x0800 // bit11
  329. /* 89-7-27 add, (end) */
  331. /* ------------------------------------------------------------------------- */
  332. /*      Constants for Seeq 80225 PHY                                         */
  333. /* ------------------------------------------------------------------------- */
  334. #define SeeqPHYID0      0x0016
  336. #define MIIRegister18   18
  337. #define SPD_DET_100     0x80
  338. #define DPLX_DET_FULL   0x40
  340. /* ------------------------------------------------------------------------- */
  341. /*      Constants for Ahdoc 101 PHY                                          */
  342. /* ------------------------------------------------------------------------- */
  343. #define AhdocPHYID0     0x0022
  345. #define DiagnosticReg   18
  346. #define DPLX_FULL       0x0800
  347. #define Speed_100       0x0400
  349. /* 89/6/13 add, */
  350. /* -------------------------------------------------------------------------- */
  351. /*      Constants                                                             */
  352. /* -------------------------------------------------------------------------- */
  353. #define MarvellPHYID0           0x0141
  354. #define LevelOnePHYID0 0x0013
  356. #define MII1000BaseTControlReg  9
  357. #define MII1000BaseTStatusReg   10
  358. #define SpecificReg 17
  360. /* for 1000BaseT Control Register */
  361. #define PHYAbletoPerform1000FullDuplex  0x0200
  362. #define PHYAbletoPerform1000HalfDuplex  0x0100
  363. #define PHY1000AbilityMask              0x300
  365. // for phy specific status register, marvell phy.
  366. #define SpeedMask       0x0c000
  367. #define Speed_1000M     0x08000
  368. #define Speed_100M      0x4000
  369. #define Speed_10M       0
  370. #define Full_Duplex     0x2000
  372. // 89/12/29 add, for phy specific status register, levelone phy, (begin)
  373. #define LXT1000_100M    0x08000
  374. #define LXT1000_1000M   0x0c000
  375. #define LXT1000_Full    0x200
  376. // 89/12/29 add, for phy specific status register, levelone phy, (end)
  378. /* for 3-in-1 case */
  379. #define PS10            0x00080000
  380. #define FD              0x00100000
  381. #define PS1000          0x00010000
  382. #define LinkIsUp2 0x00040000
  384. /* for PHY */
  385. #define LinkIsUp        0x0004
  388. struct netdev_private {
  389. /* Descriptor rings first for alignment. */
  390. struct fealnx_desc *rx_ring;
  391. struct fealnx_desc *tx_ring;
  393. dma_addr_t rx_ring_dma;
  394. dma_addr_t tx_ring_dma;
  396. spinlock_t lock;
  398. struct net_device_stats stats;
  400. /* Media monitoring timer. */
  401. struct timer_list timer;
  403. /* Frequently used values: keep some adjacent for cache effect. */
  404. int flags;
  405. struct pci_dev *pci_dev;
  406. unsigned long crvalue;
  407. unsigned long bcrvalue;
  408. unsigned long imrvalue;
  409. struct fealnx_desc *cur_rx;
  410. struct fealnx_desc *lack_rxbuf;
  411. int really_rx_count;
  412. struct fealnx_desc *cur_tx;
  413. struct fealnx_desc *cur_tx_copy;
  414. int really_tx_count;
  415. int free_tx_count;
  416. unsigned int rx_buf_sz; /* Based on MTU+slack. */
  418. /* These values are keep track of the transceiver/media in use. */
  419. unsigned int linkok;
  420. unsigned int line_speed;
  421. unsigned int duplexmode;
  422. unsigned int default_port:4; /* Last dev->if_port value. */
  423. unsigned int PHYType;
  425. /* MII transceiver section. */
  426. int mii_cnt; /* MII device addresses. */
  427. unsigned char phys[2]; /* MII device addresses. */
  428. struct mii_if_info mii;
  429. };
  432. static int mdio_read(struct net_device *dev, int phy_id, int location);
  433. static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
  434. static int netdev_open(struct net_device *dev);
  435. static void getlinktype(struct net_device *dev);
  436. static void getlinkstatus(struct net_device *dev);
  437. static void netdev_timer(unsigned long data);
  438. static void tx_timeout(struct net_device *dev);
  439. static void init_ring(struct net_device *dev);
  440. static int start_tx(struct sk_buff *skb, struct net_device *dev);
  441. static void intr_handler(int irq, void *dev_instance, struct pt_regs *regs);
  442. static int netdev_rx(struct net_device *dev);
  443. static void set_rx_mode(struct net_device *dev);
  444. static struct net_device_stats *get_stats(struct net_device *dev);
  445. static int mii_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
  446. static int netdev_close(struct net_device *dev);
  447. static void reset_rx_descriptors(struct net_device *dev);
  449. void stop_nic_tx(long ioaddr, long crvalue)
  450. {
  451. writel(crvalue & (~0x40000), ioaddr + TCRRCR);
  453. /* wait for tx stop */
  454. {
  455. int i = 0, delay = 0x1000;
  457. while ((!(readl(ioaddr + TCRRCR) & 0x04000000)) && (i < delay)) {
  458. ++i;
  459. }
  460. }
  461. }
  464. void stop_nic_rx(long ioaddr, long crvalue)
  465. {
  466. writel(crvalue & (~0x1), ioaddr + TCRRCR);
  468. /* wait for rx stop */
  469. {
  470. int i = 0, delay = 0x1000;
  472. while ((!(readl(ioaddr + TCRRCR) & 0x00008000)) && (i < delay)) {
  473. ++i;
  474. }
  475. }
  476. }
  480. static int __devinit fealnx_init_one(struct pci_dev *pdev,
  481.      const struct pci_device_id *ent)
  482. {
  483. struct netdev_private *np;
  484. int i, option, err, irq;
  485. static int card_idx = -1;
  486. char boardname[12];
  487. long ioaddr;
  488. unsigned int chip_id = ent->driver_data;
  489. struct net_device *dev;
  490. void *ring_space;
  491. dma_addr_t ring_dma;
  493. /* when built into the kernel, we only print version if device is found */
  494. #ifndef MODULE
  495. static int printed_version;
  496. if (!printed_version++)
  497. printk (version);
  498. #endif
  500. card_idx++;
  501. sprintf(boardname, "fealnx%d", card_idx);
  503. option = card_idx < MAX_UNITS ? options[card_idx] : 0;
  505. i = pci_enable_device(pdev);
  506. if (i) return i;
  507. pci_set_master(pdev);
  509. #ifdef USE_IO_OPS
  510. ioaddr = pci_resource_len(pdev, 0);
  511. #else
  512. ioaddr = pci_resource_len(pdev, 1);
  513. #endif
  514. if (ioaddr < MIN_REGION_SIZE) {
  515. printk(KERN_ERR "%s: region size %ld too small, abortingn",
  516.        boardname, ioaddr);
  517. return -ENODEV;
  518. }
  520. i = pci_request_regions(pdev, boardname);
  521. if (i) return i;
  523. irq = pdev->irq;
  525. #ifdef USE_IO_OPS
  526. ioaddr = pci_resource_start(pdev, 0);
  527. #else
  528. ioaddr = (long) ioremap(pci_resource_start(pdev, 1),
  529. pci_resource_len(pdev, 1));
  530. if (!ioaddr) {
  531. err = -ENOMEM;
  532. goto err_out_res;
  533. }
  534. #endif
  536. dev = alloc_etherdev(sizeof(struct netdev_private));
  537. if (!dev) {
  538. err = -ENOMEM;
  539. goto err_out_unmap;
  540. }
  541. SET_MODULE_OWNER(dev);
  543. /* read ethernet id */
  544. for (i = 0; i < 6; ++i)
  545. dev->dev_addr[i] = readb(ioaddr + PAR0 + i);
  547. /* Reset the chip to erase previous misconfiguration. */
  548. writel(0x00000001, ioaddr + BCR);
  550. dev->base_addr = ioaddr;
  551. dev->irq = irq;
  553. /* Make certain the descriptor lists are aligned. */
  554. np = dev->priv;
  555. spin_lock_init(&np->lock);
  556. np->pci_dev = pdev;
  557. np->flags = skel_netdrv_tbl[chip_id].flags;
  558. pci_set_drvdata(pdev, dev);
  559. np->mii.dev = dev;
  560. np->mii.mdio_read = mdio_read;
  561. np->mii.mdio_write = mdio_write;
  562. np->mii.phy_id_mask = 0x1f;
  563. np->mii.reg_num_mask = 0x1f;
  565. ring_space = pci_alloc_consistent(pdev, RX_TOTAL_SIZE, &ring_dma);
  566. if (!ring_space) {
  567. err = -ENOMEM;
  568. goto err_out_free_dev;
  569. }
  570. np->rx_ring = (struct fealnx_desc *)ring_space;
  571. np->rx_ring_dma = ring_dma;
  573. ring_space = pci_alloc_consistent(pdev, TX_TOTAL_SIZE, &ring_dma);
  574. if (!ring_space) {
  575. err = -ENOMEM;
  576. goto err_out_free_rx;
  577. }
  578. np->tx_ring = (struct fealnx_desc *)ring_space;
  579. np->tx_ring_dma = ring_dma;
  581. /* find the connected MII xcvrs */
  582. if (np->flags == HAS_MII_XCVR) {
  583. int phy, phy_idx = 0;
  585. for (phy = 1; phy < 32 && phy_idx < 4; phy++) {
  586. int mii_status = mdio_read(dev, phy, 1);
  588. if (mii_status != 0xffff && mii_status != 0x0000) {
  589. np->phys[phy_idx++] = phy;
  590. printk(KERN_INFO
  591.        "%s: MII PHY found at address %d, status "
  592.        "0x%4.4x.n", dev->name, phy, mii_status);
  593. /* get phy type */
  594. {
  595. unsigned int data;
  597. data = mdio_read(dev, np->phys[0], 2);
  598. if (data == SeeqPHYID0)
  599. np->PHYType = SeeqPHY;
  600. else if (data == AhdocPHYID0)
  601. np->PHYType = AhdocPHY;
  602. else if (data == MarvellPHYID0)
  603. np->PHYType = MarvellPHY;
  604. else if (data == MysonPHYID0)
  605. np->PHYType = Myson981;
  606. else if (data == LevelOnePHYID0)
  607. np->PHYType = LevelOnePHY;
  608. else
  609. np->PHYType = OtherPHY;
  610. }
  611. }
  612. }
  614. np->mii_cnt = phy_idx;
  615. if (phy_idx == 0) {
  616. printk(KERN_WARNING "%s: MII PHY not found -- this device may "
  617.        "not operate correctly.n", dev->name);
  618. }
  619. } else {
  620. np->phys[0] = 32;
  621. /* 89/6/23 add, (begin) */
  622. /* get phy type */
  623. if (readl(dev->base_addr + PHYIDENTIFIER) == MysonPHYID)
  624. np->PHYType = MysonPHY;
  625. else
  626. np->PHYType = OtherPHY;
  627. }
  628. np->mii.phy_id = np->phys[0];
  630. if (dev->mem_start)
  631. option = dev->mem_start;
  633. /* The lower four bits are the media type. */
  634. if (option > 0) {
  635. if (option & 0x200)
  636. np->mii.full_duplex = 1;
  637. np->default_port = option & 15;
  638. }
  640. if (card_idx < MAX_UNITS && full_duplex[card_idx] > 0)
  641. np->mii.full_duplex = full_duplex[card_idx];
  643. if (np->mii.full_duplex) {
  644. printk(KERN_INFO "%s: Media type forced to Full Duplex.n", dev->name);
  645. /* 89/6/13 add, (begin) */
  646. //      if (np->PHYType==MarvellPHY)
  647. if ((np->PHYType == MarvellPHY) || (np->PHYType == LevelOnePHY)) {
  648. unsigned int data;
  650. data = mdio_read(dev, np->phys[0], 9);
  651. data = (data & 0xfcff) | 0x0200;
  652. mdio_write(dev, np->phys[0], 9, data);
  653. }
  654. /* 89/6/13 add, (end) */
  655. if (np->flags == HAS_MII_XCVR)
  656. mdio_write(dev, np->phys[0], MII_ADVERTISE, ADVERTISE_FULL);
  657. else
  658. writel(ADVERTISE_FULL, dev->base_addr + ANARANLPAR);
  659. np->mii.force_media = 1;
  660. }
  662. /* The chip-specific entries in the device structure. */
  663. dev->open = &netdev_open;
  664. dev->hard_start_xmit = &start_tx;
  665. dev->stop = &netdev_close;
  666. dev->get_stats = &get_stats;
  667. dev->set_multicast_list = &set_rx_mode;
  668. dev->do_ioctl = &mii_ioctl;
  669. dev->tx_timeout = tx_timeout;
  670. dev->watchdog_timeo = TX_TIMEOUT;
  672. err = register_netdev(dev);
  673. if (err)
  674. goto err_out_free_tx;
  676. printk(KERN_INFO "%s: %s at 0x%lx, ",
  677.        dev->name, skel_netdrv_tbl[chip_id].chip_name, ioaddr);
  678. for (i = 0; i < 5; i++)
  679. printk("%2.2x:", dev->dev_addr[i]);
  680. printk("%2.2x, IRQ %d.n", dev->dev_addr[i], irq);
  682. return 0;
  684. err_out_free_tx:
  685. pci_free_consistent(pdev, TX_TOTAL_SIZE, np->tx_ring, np->tx_ring_dma);
  686. err_out_free_rx:
  687. pci_free_consistent(pdev, RX_TOTAL_SIZE, np->rx_ring, np->rx_ring_dma);
  688. err_out_free_dev:
  689. kfree(dev);
  690. err_out_unmap:
  691. #ifndef USE_IO_OPS
  692. iounmap((void *)ioaddr);
  693. err_out_res:
  694. #endif
  695. pci_release_regions(pdev);
  696. return err;
  697. }
  699. static void __devexit fealnx_remove_one(struct pci_dev *pdev)
  700. {
  701. struct net_device *dev = pci_get_drvdata(pdev);
  703. if (dev) {
  704. struct netdev_private *np = dev->priv;
  706. pci_free_consistent(pdev, TX_TOTAL_SIZE, np->tx_ring,
  707. np->tx_ring_dma);
  708. pci_free_consistent(pdev, RX_TOTAL_SIZE, np->rx_ring,
  709. np->rx_ring_dma);
  710. unregister_netdev(dev);
  711. #ifndef USE_IO_OPS
  712. iounmap((void *)dev->base_addr);
  713. #endif
  714. kfree(dev);
  715. pci_release_regions(pdev);
  716. pci_set_drvdata(pdev, NULL);
  717. } else
  718. printk(KERN_ERR "fealnx: remove for unknown devicen");
  719. }
  721. unsigned int m80x_read_tick(void)
  722. /* function: Reads the Timer tick count register which decrements by 2 from  */
  723. /*           65536 to 0 every 1/36.414 of a second. Each 2 decrements of the *//*           count represents 838 nsec's.                                    */
  724. /* input   : none.                                                           */
  725. /* output  : none.                                                           */
  726. {
  727. unsigned char tmp;
  728. int value;
  730. writeb((char) 0x06, 0x43); // Command 8254 to latch T0's count
  732. // now read the count.
  733. tmp = (unsigned char) readb(0x40);
  734. value = ((int) tmp) << 8;
  735. tmp = (unsigned char) readb(0x40);
  736. value |= (((int) tmp) & 0xff);
  737. return (value);
  738. }
  741. void m80x_delay(unsigned int interval)
  742. /* function: to wait for a specified time.                                   */
  743. /* input   : interval ... the specified time.                                */
  744. /* output  : none.                                                           */
  745. {
  746. unsigned int interval1, interval2, i = 0;
  748. interval1 = m80x_read_tick(); // get initial value
  749. do {
  750. interval2 = m80x_read_tick();
  751. if (interval1 < interval2)
  752. interval1 = interval2;
  753. ++i;
  754. } while (((interval1 - interval2) < (ushort) interval) && (i < 65535));
  755. }
  758. static ulong m80x_send_cmd_to_phy(long miiport, int opcode, int phyad, int regad)
  759. {
  760. ulong miir;
  761. int i;
  762. unsigned int mask, data;
  764. /* enable MII output */
  765. miir = (ulong) readl(miiport);
  766. miir &= 0xfffffff0;
  768. miir |= MASK_MIIR_MII_WRITE + MASK_MIIR_MII_MDO;
  770. /* send 32 1's preamble */
  771. for (i = 0; i < 32; i++) {
  772. /* low MDC; MDO is already high (miir) */
  773. miir &= ~MASK_MIIR_MII_MDC;
  774. writel(miir, miiport);
  776. /* high MDC */
  777. miir |= MASK_MIIR_MII_MDC;
  778. writel(miir, miiport);
  779. }
  781. /* calculate ST+OP+PHYAD+REGAD+TA */
  782. data = opcode | (phyad << 7) | (regad << 2);
  784. /* sent out */
  785. mask = 0x8000;
  786. while (mask) {
  787. /* low MDC, prepare MDO */
  788. miir &= ~(MASK_MIIR_MII_MDC + MASK_MIIR_MII_MDO);
  789. if (mask & data)
  790. miir |= MASK_MIIR_MII_MDO;
  792. writel(miir, miiport);
  793. /* high MDC */
  794. miir |= MASK_MIIR_MII_MDC;
  795. writel(miir, miiport);
  796. m80x_delay(30);
  798. /* next */
  799. mask >>= 1;
  800. if (mask == 0x2 && opcode == OP_READ)
  801. miir &= ~MASK_MIIR_MII_WRITE;
  802. }
  803. return miir;
  804. }
  807. static int mdio_read(struct net_device *dev, int phyad, int regad)
  808. {
  809. long miiport = dev->base_addr + MANAGEMENT;
  810. ulong miir;
  811. unsigned int mask, data;
  813. miir = m80x_send_cmd_to_phy(miiport, OP_READ, phyad, regad);
  815. /* read data */
  816. mask = 0x8000;
  817. data = 0;
  818. while (mask) {
  819. /* low MDC */
  820. miir &= ~MASK_MIIR_MII_MDC;
  821. writel(miir, miiport);
  823. /* read MDI */
  824. miir = readl(miiport);
  825. if (miir & MASK_MIIR_MII_MDI)
  826. data |= mask;
  828. /* high MDC, and wait */
  829. miir |= MASK_MIIR_MII_MDC;
  830. writel(miir, miiport);
  831. m80x_delay((int) 30);
  833. /* next */
  834. mask >>= 1;
  835. }
  837. /* low MDC */
  838. miir &= ~MASK_MIIR_MII_MDC;
  839. writel(miir, miiport);
  841. return data & 0xffff;
  842. }
  845. static void mdio_write(struct net_device *dev, int phyad, int regad, int data)
  846. {
  847. long miiport = dev->base_addr + MANAGEMENT;
  848. ulong miir;
  849. unsigned int mask;
  851. miir = m80x_send_cmd_to_phy(miiport, OP_WRITE, phyad, regad);
  853. /* write data */
  854. mask = 0x8000;
  855. while (mask) {
  856. /* low MDC, prepare MDO */
  857. miir &= ~(MASK_MIIR_MII_MDC + MASK_MIIR_MII_MDO);
  858. if (mask & data)
  859. miir |= MASK_MIIR_MII_MDO;
  860. writel(miir, miiport);
  862. /* high MDC */
  863. miir |= MASK_MIIR_MII_MDC;
  864. writel(miir, miiport);
  866. /* next */
  867. mask >>= 1;
  868. }
  870. /* low MDC */
  871. miir &= ~MASK_MIIR_MII_MDC;
  872. writel(miir, miiport);
  874. return;
  875. }
  878. static int netdev_open(struct net_device *dev)
  879. {
  880. struct netdev_private *np = dev->priv;
  881. long ioaddr = dev->base_addr;
  883. writel(0x00000001, ioaddr + BCR); /* Reset */
  885. if (request_irq(dev->irq, &intr_handler, SA_SHIRQ, dev->name, dev))
  886. return -EAGAIN;
  888. init_ring(dev);
  890. writel(np->rx_ring_dma, ioaddr + RXLBA);
  891. writel(np->tx_ring_dma, ioaddr + TXLBA);
  893. /* Initialize other registers. */
  894. /* Configure the PCI bus bursts and FIFO thresholds.
  895.    486: Set 8 longword burst.
  896.    586: no burst limit.
  897.    Burst length 5:3
  898.    0 0 0   1
  899.    0 0 1   4
  900.    0 1 0   8
  901.    0 1 1   16
  902.    1 0 0   32
  903.    1 0 1   64
  904.    1 1 0   128
  905.    1 1 1   256
  906.    Wait the specified 50 PCI cycles after a reset by initializing
  907.    Tx and Rx queues and the address filter list.
  908.    FIXME (Ueimor): optimistic for alpha + posted writes ? */
  909. #if defined(__powerpc__) || defined(__sparc__)
  910. // 89/9/1 modify, 
  911. //   np->bcrvalue=0x04 | 0x0x38;  /* big-endian, 256 burst length */
  912. np->bcrvalue = 0x04 | 0x10; /* big-endian, tx 8 burst length */
  913. np->crvalue = 0xe00; /* rx 128 burst length */
  914. #elif defined(__alpha__) || defined(__x86_64__)
  915. // 89/9/1 modify, 
  916. //   np->bcrvalue=0x38;           /* little-endian, 256 burst length */
  917. np->bcrvalue = 0x10; /* little-endian, 8 burst length */
  918. np->crvalue = 0xe00; /* rx 128 burst length */
  919. #elif defined(__i386__)
  920. #if defined(MODULE)
  921. // 89/9/1 modify, 
  922. //   np->bcrvalue=0x38;           /* little-endian, 256 burst length */
  923. np->bcrvalue = 0x10; /* little-endian, 8 burst length */
  924. np->crvalue = 0xe00; /* rx 128 burst length */
  925. #else
  926. /* When not a module we can work around broken '486 PCI boards. */
  927. #define x86 boot_cpu_data.x86
  928. // 89/9/1 modify, 
  929. //   np->bcrvalue=(x86 <= 4 ? 0x10 : 0x38);
  930. np->bcrvalue = 0x10;
  931. np->crvalue = (x86 <= 4 ? 0xa00 : 0xe00);
  932. if (x86 <= 4)
  933. printk(KERN_INFO "%s: This is a 386/486 PCI system, setting burst "
  934.        "length to %x.n", dev->name, (x86 <= 4 ? 0x10 : 0x38));
  935. #endif
  936. #else
  937. // 89/9/1 modify,
  938. //   np->bcrvalue=0x38;
  939. np->bcrvalue = 0x10;
  940. np->cralue = 0xe00; /* rx 128 burst length */
  941. #warning Processor architecture undefined!
  942. #endif
  943. // 89/12/29 add,
  944. // 90/1/16 modify,
  945. //   np->imrvalue=FBE|TUNF|CNTOVF|RBU|TI|RI;
  946. np->imrvalue = TUNF | CNTOVF | RBU | TI | RI;
  947. if (np->pci_dev->device == 0x891) {
  948. np->bcrvalue |= 0x200; /* set PROG bit */
  949. np->crvalue |= 0x02000000; /* set enhanced bit */
  950. np->imrvalue |= ETI;
  951. }
  952. writel(np->bcrvalue, ioaddr + BCR);
  954. if (dev->if_port == 0)
  955. dev->if_port = np->default_port;
  957. writel(0, dev->base_addr + RXPDR);
  958. // 89/9/1 modify,
  959. //   np->crvalue = 0x00e40001;    /* tx store and forward, tx/rx enable */
  960. np->crvalue |= 0x00e40001; /* tx store and forward, tx/rx enable */
  961. np->mii.full_duplex = np->mii.force_media;
  962. getlinkstatus(dev);
  963. if (np->linkok)
  964. getlinktype(dev);
  965. set_rx_mode(dev);
  967. netif_start_queue(dev);
  969. /* Clear and Enable interrupts by setting the interrupt mask. */
  970. writel(FBE | TUNF | CNTOVF | RBU | TI | RI, ioaddr + ISR);
  971. writel(np->imrvalue, ioaddr + IMR);
  973. if (debug)
  974. printk(KERN_DEBUG "%s: Done netdev_open().n", dev->name);
  976. /* Set the timer to check for link beat. */
  977. init_timer(&np->timer);
  978. np->timer.expires = RUN_AT(3 * HZ);
  979. np->timer.data = (unsigned long) dev;
  980. np->timer.function = &netdev_timer;
  982. /* timer handler */
  983. add_timer(&np->timer);
  985. return 0;
  986. }
  989. static void getlinkstatus(struct net_device *dev)
  990. /* function: Routine will read MII Status Register to get link status.       */
  991. /* input   : dev... pointer to the adapter block.                            */
  992. /* output  : none.                                                           */
  993. {
  994. struct netdev_private *np = dev->priv;
  995. unsigned int i, DelayTime = 0x1000;
  997. np->linkok = 0;
  999. if (np->PHYType == MysonPHY) {
  1000. for (i = 0; i < DelayTime; ++i) {
  1001. if (readl(dev->base_addr + BMCRSR) & LinkIsUp2) {
  1002. np->linkok = 1;
  1003. return;
  1004. }
  1005. // delay
  1006. m80x_delay(100);
  1007. }
  1008. } else {
  1009. for (i = 0; i < DelayTime; ++i) {
  1010. if (mdio_read(dev, np->phys[0], MII_BMSR) & BMSR_LSTATUS) {
  1011. np->linkok = 1;
  1012. return;
  1013. }
  1014. // delay
  1015. m80x_delay(100);
  1016. }
  1017. }
  1018. }
  1021. static void getlinktype(struct net_device *dev)
  1022. {
  1023. struct netdev_private *np = dev->priv;
  1025. if (np->PHYType == MysonPHY) { /* 3-in-1 case */
  1026. if (readl(dev->base_addr + TCRRCR) & FD)
  1027. np->duplexmode = 2; /* full duplex */
  1028. else
  1029. np->duplexmode = 1; /* half duplex */
  1030. if (readl(dev->base_addr + TCRRCR) & PS10)
  1031. np->line_speed = 1; /* 10M */
  1032. else
  1033. np->line_speed = 2; /* 100M */
  1034. } else {
  1035. if (np->PHYType == SeeqPHY) { /* this PHY is SEEQ 80225 */
  1036. unsigned int data;
  1038. data = mdio_read(dev, np->phys[0], MIIRegister18);
  1039. if (data & SPD_DET_100)
  1040. np->line_speed = 2; /* 100M */
  1041. else
  1042. np->line_speed = 1; /* 10M */
  1043. if (data & DPLX_DET_FULL)
  1044. np->duplexmode = 2; /* full duplex mode */
  1045. else
  1046. np->duplexmode = 1; /* half duplex mode */
  1047. } else if (np->PHYType == AhdocPHY) {
  1048. unsigned int data;
  1050. data = mdio_read(dev, np->phys[0], DiagnosticReg);
  1051. if (data & Speed_100)
  1052. np->line_speed = 2; /* 100M */
  1053. else
  1054. np->line_speed = 1; /* 10M */
  1055. if (data & DPLX_FULL)
  1056. np->duplexmode = 2; /* full duplex mode */
  1057. else
  1058. np->duplexmode = 1; /* half duplex mode */
  1059. }
  1060. /* 89/6/13 add, (begin) */
  1061. else if (np->PHYType == MarvellPHY) {
  1062. unsigned int data;
  1064. data = mdio_read(dev, np->phys[0], SpecificReg);
  1065. if (data & Full_Duplex)
  1066. np->duplexmode = 2; /* full duplex mode */
  1067. else
  1068. np->duplexmode = 1; /* half duplex mode */
  1069. data &= SpeedMask;
  1070. if (data == Speed_1000M)
  1071. np->line_speed = 3; /* 1000M */
  1072. else if (data == Speed_100M)
  1073. np->line_speed = 2; /* 100M */
  1074. else
  1075. np->line_speed = 1; /* 10M */
  1076. }
  1077. /* 89/6/13 add, (end) */
  1078. /* 89/7/27 add, (begin) */
  1079. else if (np->PHYType == Myson981) {
  1080. unsigned int data;
  1082. data = mdio_read(dev, np->phys[0], StatusRegister);
  1084. if (data & SPEED100)
  1085. np->line_speed = 2;
  1086. else
  1087. np->line_speed = 1;
  1089. if (data & FULLMODE)
  1090. np->duplexmode = 2;
  1091. else
  1092. np->duplexmode = 1;
  1093. }
  1094. /* 89/7/27 add, (end) */
  1095. /* 89/12/29 add */
  1096. else if (np->PHYType == LevelOnePHY) {
  1097. unsigned int data;
  1099. data = mdio_read(dev, np->phys[0], SpecificReg);
  1100. if (data & LXT1000_Full)
  1101. np->duplexmode = 2; /* full duplex mode */
  1102. else
  1103. np->duplexmode = 1; /* half duplex mode */
  1104. data &= SpeedMask;
  1105. if (data == LXT1000_1000M)
  1106. np->line_speed = 3; /* 1000M */
  1107. else if (data == LXT1000_100M)
  1108. np->line_speed = 2; /* 100M */
  1109. else
  1110. np->line_speed = 1; /* 10M */
  1111. }
  1112. // chage crvalue
  1113. // np->crvalue&=(~PS10)&(~FD);
  1114. np->crvalue &= (~PS10) & (~FD) & (~PS1000);
  1115. if (np->line_speed == 1)
  1116. np->crvalue |= PS10;
  1117. else if (np->line_speed == 3)
  1118. np->crvalue |= PS1000;
  1119. if (np->duplexmode == 2)
  1120. np->crvalue |= FD;
  1121. }
  1122. }
  1125. static void allocate_rx_buffers(struct net_device *dev)
  1126. {
  1127. struct netdev_private *np = dev->priv;
  1129. /*  allocate skb for rx buffers */
  1130. while (np->really_rx_count != RX_RING_SIZE) {
  1131. struct sk_buff *skb;
  1133. skb = dev_alloc_skb(np->rx_buf_sz);
  1134. np->lack_rxbuf->skbuff = skb;
  1136. if (skb == NULL)
  1137. break; /* Better luck next round. */
  1139. skb->dev = dev; /* Mark as being used by this device. */
  1140. np->lack_rxbuf->buffer = pci_map_single(np->pci_dev, skb->tail,
  1141. np->rx_buf_sz, PCI_DMA_FROMDEVICE);
  1142. np->lack_rxbuf = np->lack_rxbuf->next_desc_logical;
  1143. ++np->really_rx_count;
  1144. }
  1145. }
  1148. static void netdev_timer(unsigned long data)
  1149. {
  1150. struct net_device *dev = (struct net_device *) data;
  1151. struct netdev_private *np = dev->priv;
  1152. long ioaddr = dev->base_addr;
  1153. int next_tick = 10 * HZ;
  1154. int old_crvalue = np->crvalue;
  1155. unsigned int old_linkok = np->linkok;
  1157. if (debug)
  1158. printk(KERN_DEBUG "%s: Media selection timer tick, status %8.8x "
  1159.        "config %8.8x.n", dev->name, readl(ioaddr + ISR),
  1160.        readl(ioaddr + TCRRCR));
  1162. if (np->flags == HAS_MII_XCVR) {
  1163. getlinkstatus(dev);
  1164. if ((old_linkok == 0) && (np->linkok == 1)) { /* we need to detect the media type again */
  1165. getlinktype(dev);
  1166. if (np->crvalue != old_crvalue) {
  1167. stop_nic_tx(ioaddr, np->crvalue);
  1168. stop_nic_rx(ioaddr, np->crvalue & (~0x40000));
  1169. writel(np->crvalue, ioaddr + TCRRCR);
  1170. }
  1171. }
  1172. }
  1174. allocate_rx_buffers(dev);
  1176. np->timer.expires = RUN_AT(next_tick);
  1177. add_timer(&np->timer);
  1178. }
  1181. static void tx_timeout(struct net_device *dev)
  1182. {
  1183. struct netdev_private *np = dev->priv;
  1184. long ioaddr = dev->base_addr;
  1185. int i;
  1187. printk(KERN_WARNING "%s: Transmit timed out, status %8.8x,"
  1188.        " resetting...n", dev->name, readl(ioaddr + ISR));
  1190. {
  1192. printk(KERN_DEBUG "  Rx ring %p: ", np->rx_ring);
  1193. for (i = 0; i < RX_RING_SIZE; i++)
  1194. printk(" %8.8x", (unsigned int) np->rx_ring[i].status);
  1195. printk("n" KERN_DEBUG "  Tx ring %p: ", np->tx_ring);
  1196. for (i = 0; i < TX_RING_SIZE; i++)
  1197. printk(" %4.4x", np->tx_ring[i].status);
  1198. printk("n");
  1199. }
  1201.    + dev->if_port = np->default_port;
  1202. /* Reinit. Gross */
  1204. /* Reset the chip's Tx and Rx processes. */
  1205. stop_nic_tx(ioaddr, 0);
  1206. reset_rx_descriptors(dev);
  1208. /* Disable interrupts by clearing the interrupt mask. */
  1209. writel(0x0000, ioaddr + IMR);
  1211. /* Reset the chip to erase previous misconfiguration. */
  1212. writel(0x00000001, ioaddr + BCR);
  1214. /* Ueimor: wait for 50 PCI cycles (and flush posted writes btw). 
  1215.    We surely wait too long (address+data phase). Who cares ? */
  1216. for (i = 0; i < 50; i++) {
  1217. readl(ioaddr + BCR);
  1218. rmb();
  1219. }
  1221. writel((np->cur_tx - np->tx_ring)*sizeof(struct fealnx_desc) +
  1222. np->tx_ring_dma, ioaddr + TXLBA);
  1223. writel((np->cur_rx - np->rx_ring)*sizeof(struct fealnx_desc) +
  1224. np->rx_ring_dma, ioaddr + RXLBA);
  1226. writel(np->bcrvalue, ioaddr + BCR);
  1228. writel(0, dev->base_addr + RXPDR);
  1229. set_rx_mode(dev);
  1230. /* Clear and Enable interrupts by setting the interrupt mask. */
  1231. writel(FBE | TUNF | CNTOVF | RBU | TI | RI, ioaddr + ISR);
  1232. writel(np->imrvalue, ioaddr + IMR);
  1234. writel(0, dev->base_addr + TXPDR);
  1236. dev->trans_start = jiffies;
  1237. np->stats.tx_errors++;
  1239. return;
  1240. }
  1243. /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
  1244. static void init_ring(struct net_device *dev)
  1245. {
  1246. struct netdev_private *np = dev->priv;
  1247. int i;
  1249. /* initialize rx variables */
  1250. np->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
  1251. np->cur_rx = &np->rx_ring[0];
  1252. np->lack_rxbuf = NULL;
  1253. np->really_rx_count = 0;
  1255. /* initial rx descriptors. */
  1256. for (i = 0; i < RX_RING_SIZE; i++) {
  1257. np->rx_ring[i].status = 0;
  1258. np->rx_ring[i].control = np->rx_buf_sz << RBSShift;
  1259. np->rx_ring[i].next_desc = np->rx_ring_dma +
  1260. (i + 1)*sizeof(struct fealnx_desc);
  1261. np->rx_ring[i].next_desc_logical = &np->rx_ring[i + 1];
  1262. np->rx_ring[i].skbuff = NULL;
  1263. }
  1265. /* for the last rx descriptor */
  1266. np->rx_ring[i - 1].next_desc = np->rx_ring_dma;
  1267. np->rx_ring[i - 1].next_desc_logical = np->rx_ring;
  1269. /* allocate skb for rx buffers */
  1270. for (i = 0; i < RX_RING_SIZE; i++) {
  1271. struct sk_buff *skb = dev_alloc_skb(np->rx_buf_sz);
  1273. if (skb == NULL) {
  1274. np->lack_rxbuf = &np->rx_ring[i];
  1275. break;
  1276. }
  1278. ++np->really_rx_count;
  1279. np->rx_ring[i].skbuff = skb;
  1280. skb->dev = dev; /* Mark as being used by this device. */
  1281. np->rx_ring[i].buffer = pci_map_single(np->pci_dev, skb->tail,
  1282. np->rx_buf_sz, PCI_DMA_FROMDEVICE);
  1283. np->rx_ring[i].status = RXOWN;
  1284. np->rx_ring[i].control |= RXIC;
  1285. }
  1287. /* initialize tx variables */
  1288. np->cur_tx = &np->tx_ring[0];
  1289. np->cur_tx_copy = &np->tx_ring[0];
  1290. np->really_tx_count = 0;
  1291. np->free_tx_count = TX_RING_SIZE;
  1293. for (i = 0; i < TX_RING_SIZE; i++) {
  1294. np->tx_ring[i].status = 0;
  1295. np->tx_ring[i].next_desc = np->tx_ring_dma +
  1296. (i + 1)*sizeof(struct fealnx_desc);
  1297. np->tx_ring[i].next_desc_logical = &np->tx_ring[i + 1];
  1298. np->tx_ring[i].skbuff = NULL;
  1299. }
  1301. /* for the last tx descriptor */
  1302. np->tx_ring[i - 1].next_desc = np->tx_ring_dma;
  1303. np->tx_ring[i - 1].next_desc_logical = &np->tx_ring[0];
  1305. return;
  1306. }
  1309. static int start_tx(struct sk_buff *skb, struct net_device *dev)
  1310. {
  1311. struct netdev_private *np = dev->priv;
  1313. np->cur_tx_copy->skbuff = skb;
  1315. #define one_buffer
  1316. #define BPT 1022
  1317. #if defined(one_buffer)
  1318. np->cur_tx_copy->buffer = pci_map_single(np->pci_dev, skb->data,
  1319. skb->len, PCI_DMA_TODEVICE);
  1320. np->cur_tx_copy->control = TXIC | TXLD | TXFD | CRCEnable | PADEnable;
  1321. np->cur_tx_copy->control |= (skb->len << PKTSShift); /* pkt size */
  1322. np->cur_tx_copy->control |= (skb->len << TBSShift); /* buffer size */
  1323. // 89/12/29 add,
  1324. if (np->pci_dev->device == 0x891)
  1325. np->cur_tx_copy->control |= ETIControl | RetryTxLC;
  1326. np->cur_tx_copy->status = TXOWN;
  1327. np->cur_tx_copy = np->cur_tx_copy->next_desc_logical;
  1328. --np->free_tx_count;
  1329. #elif defined(two_buffer)
  1330. if (skb->len > BPT) {
  1331. struct fealnx_desc *next;
  1333. /* for the first descriptor */
  1334. np->cur_tx_copy->buffer = pci_map_single(np->pci_dev, skb->data,
  1335. BPT, PCI_DMA_TODEVICE);
  1336. np->cur_tx_copy->control = TXIC | TXFD | CRCEnable | PADEnable;
  1337. np->cur_tx_copy->control |= (skb->len << PKTSShift); /* pkt size */
  1338. np->cur_tx_copy->control |= (BPT << TBSShift); /* buffer size */
  1340. /* for the last descriptor */
  1341. next = (struct fealnx *) np->cur_tx_copy.next_desc_logical;
  1342. next->skbuff = skb;
  1343. next->control = TXIC | TXLD | CRCEnable | PADEnable;
  1344. next->control |= (skb->len << PKTSShift); /* pkt size */
  1345. next->control |= ((skb->len - BPT) << TBSShift); /* buf size */
  1346. // 89/12/29 add,
  1347. if (np->pci_dev->device == 0x891)
  1348. np->cur_tx_copy->control |= ETIControl | RetryTxLC;
  1349. next->buffer = pci_map_single(ep->pci_dev, skb->data + BPT,
  1350.                                 skb->len - BPT, PCI_DMA_TODEVICE);
  1352. next->status = TXOWN;
  1353. np->cur_tx_copy->status = TXOWN;
  1355. np->cur_tx_copy = next->next_desc_logical;
  1356. np->free_tx_count -= 2;
  1357. } else {
  1358. np->cur_tx_copy->buffer = pci_map_single(np->pci_dev, skb->data,
  1359. skb->len, PCI_DMA_TODEVICE);
  1360. np->cur_tx_copy->control = TXIC | TXLD | TXFD | CRCEnable | PADEnable;
  1361. np->cur_tx_copy->control |= (skb->len << PKTSShift); /* pkt size */
  1362. np->cur_tx_copy->control |= (skb->len << TBSShift); /* buffer size */
  1363. // 89/12/29 add,
  1364. if (np->pci_dev->device == 0x891)
  1365. np->cur_tx_copy->control |= ETIControl | RetryTxLC;
  1366. np->cur_tx_copy->status = TXOWN;
  1367. np->cur_tx_copy = np->cur_tx_copy->next_desc_logical;
  1368. --np->free_tx_count;
  1369. }
  1370. #endif
  1372. if (np->free_tx_count < 2)
  1373. netif_stop_queue(dev);
  1374. ++np->really_tx_count;
  1375. writel(0, dev->base_addr + TXPDR);
  1376. dev->trans_start = jiffies;
  1378. return 0;
  1379. }
  1382. void free_one_rx_descriptor(struct netdev_private *np)
  1383. {
  1384. if (np->really_rx_count == RX_RING_SIZE)
  1385. np->cur_rx->status = RXOWN;
  1386. else {
  1387. np->lack_rxbuf->skbuff = np->cur_rx->skbuff;
  1388. np->lack_rxbuf->buffer = np->cur_rx->buffer;
  1389. np->lack_rxbuf->status = RXOWN;
  1390. ++np->really_rx_count;
  1391. np->lack_rxbuf = np->lack_rxbuf->next_desc_logical;
  1392. }
  1393. np->cur_rx = np->cur_rx->next_desc_logical;
  1394. }
  1397. void reset_rx_descriptors(struct net_device *dev)
  1398. {
  1399. struct netdev_private *np = dev->priv;
  1401. stop_nic_rx(dev->base_addr, np->crvalue);
  1403. while (!(np->cur_rx->status & RXOWN))
  1404. free_one_rx_descriptor(np);
  1406. allocate_rx_buffers(dev);
  1408. writel(np->rx_ring_dma + (np->cur_rx - np->rx_ring),
  1409. dev->base_addr + RXLBA);
  1410. writel(np->crvalue, dev->base_addr + TCRRCR);
  1411. }
  1414. /* The interrupt handler does all of the Rx thread work and cleans up
  1415.    after the Tx thread. */
  1416. static void intr_handler(int irq, void *dev_instance, struct pt_regs *rgs)
  1417. {
  1418. struct net_device *dev = (struct net_device *) dev_instance;
  1419. struct netdev_private *np = dev->priv;
  1420. long ioaddr, boguscnt = max_interrupt_work;
  1421. unsigned int num_tx = 0;
  1423. writel(0, dev->base_addr + IMR);
  1425. ioaddr = dev->base_addr;
  1426. np = (struct netdev_private *) dev->priv;
  1428. do {
  1429. u32 intr_status = readl(ioaddr + ISR);
  1431. /* Acknowledge all of the current interrupt sources ASAP. */
  1432. writel(intr_status, ioaddr + ISR);
  1434. if (debug)
  1435. printk(KERN_DEBUG "%s: Interrupt, status %4.4x.n", dev->name,
  1436.        intr_status);
  1438. if (!(intr_status & np->imrvalue))
  1439. break;
  1441. // 90/1/16 delete,
  1442. //
  1443. //      if (intr_status & FBE)
  1444. //      {   /* fatal error */
  1445. //          stop_nic_tx(ioaddr, 0);
  1446. //          stop_nic_rx(ioaddr, 0);
  1447. //          break;
  1448. //      };
  1450. if (intr_status & TUNF)
  1451. writel(0, ioaddr + TXPDR);
  1453. if (intr_status & CNTOVF) {
  1454. /* missed pkts */
  1455. np->stats.rx_missed_errors += readl(ioaddr + TALLY) & 0x7fff;
  1457. /* crc error */
  1458. np->stats.rx_crc_errors +=
  1459.     (readl(ioaddr + TALLY) & 0x7fff0000) >> 16;
  1460. }
  1462. if (intr_status & (RI | RBU)) {
  1463. if (intr_status & RI)
  1464. netdev_rx(dev);
  1465. else
  1466. reset_rx_descriptors(dev);
  1467. }
  1469. while (np->really_tx_count) {
  1470. long tx_status = np->cur_tx->status;
  1471. long tx_control = np->cur_tx->control;
  1473. if (!(tx_control & TXLD)) { /* this pkt is combined by two tx descriptors */
  1474. struct fealnx_desc *next;
  1476. next = np->cur_tx->next_desc_logical;
  1477. tx_status = next->status;
  1478. tx_control = next->control;
  1479. }
  1481. if (tx_status & TXOWN)
  1482. break;
  1484. if (!(np->crvalue & 0x02000000)) {
  1485. if (tx_status & (CSL | LC | EC | UDF | HF)) {
  1486. np->stats.tx_errors++;
  1487. if (tx_status & EC)
  1488. np->stats.tx_aborted_errors++;
  1489. if (tx_status & CSL)
  1490. np->stats.tx_carrier_errors++;
  1491. if (tx_status & LC)
  1492. np->stats.tx_window_errors++;
  1493. if (tx_status & UDF)
  1494. np->stats.tx_fifo_errors++;
  1495. if ((tx_status & HF) && np->mii.full_duplex == 0)
  1496. np->stats.tx_heartbeat_errors++;
  1498. } else {
  1499. np->stats.tx_bytes +=
  1500.     ((tx_control & PKTSMask) >> PKTSShift);
  1502. np->stats.collisions +=
  1503.     ((tx_status & NCRMask) >> NCRShift);
  1504. np->stats.tx_packets++;
  1505. }
  1506. } else {
  1507. np->stats.tx_bytes +=
  1508.     ((tx_control & PKTSMask) >> PKTSShift);
  1509. np->stats.tx_packets++;
  1510. }
  1512. /* Free the original skb. */
  1513. pci_unmap_single(np->pci_dev, np->cur_tx->buffer,
  1514. np->cur_tx->skbuff->len, PCI_DMA_TODEVICE);
  1515. dev_kfree_skb_irq(np->cur_tx->skbuff);
  1516. np->cur_tx->skbuff = NULL;
  1517. --np->really_tx_count;
  1518. if (np->cur_tx->control & TXLD) {
  1519. np->cur_tx = np->cur_tx->next_desc_logical;
  1520. ++np->free_tx_count;
  1521. } else {
  1522. np->cur_tx = np->cur_tx->next_desc_logical;
  1523. np->cur_tx = np->cur_tx->next_desc_logical;
  1524. np->free_tx_count += 2;
  1525. }
  1526. num_tx++;
  1527. } /* end of for loop */
  1529. if (num_tx && np->free_tx_count >= 2)
  1530. netif_wake_queue(dev);
  1532. /* read transmit status for enhanced mode only */
  1533. if (np->crvalue & 0x02000000) {
  1534. long data;
  1536. data = readl(ioaddr + TSR);
  1537. np->stats.tx_errors += (data & 0xff000000) >> 24;
  1538. np->stats.tx_aborted_errors += (data & 0xff000000) >> 24;
  1539. np->stats.tx_window_errors += (data & 0x00ff0000) >> 16;
  1540. np->stats.collisions += (data & 0x0000ffff);
  1541. }
  1543. if (--boguscnt < 0) {
  1544. printk(KERN_WARNING "%s: Too much work at interrupt, "
  1545.        "status=0x%4.4x.n", dev->name, intr_status);
  1546. break;
  1547. }
  1548. } while (1);
  1550. /* read the tally counters */
  1551. /* missed pkts */
  1552. np->stats.rx_missed_errors += readl(ioaddr + TALLY) & 0x7fff;
  1554. /* crc error */
  1555. np->stats.rx_crc_errors += (readl(ioaddr + TALLY) & 0x7fff0000) >> 16;
  1557. if (debug)
  1558. printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.n",
  1559.        dev->name, readl(ioaddr + ISR));
  1561. writel(np->imrvalue, ioaddr + IMR);
  1563. return;
  1564. }
  1567. /* This routine is logically part of the interrupt handler, but seperated
  1568.    for clarity and better register allocation. */
  1569. static int netdev_rx(struct net_device *dev)
  1570. {
  1571. struct netdev_private *np = dev->priv;
  1573. /* If EOP is set on the next entry, it's a new packet. Send it up. */
  1574. while (!(np->cur_rx->status & RXOWN)) {
  1575. s32 rx_status = np->cur_rx->status;
  1577. if (np->really_rx_count == 0)
  1578. break;
  1580. if (debug)
  1581. printk(KERN_DEBUG "  netdev_rx() status was %8.8x.n", rx_status);
  1583. if ((!((rx_status & RXFSD) && (rx_status & RXLSD)))
  1584.     || (rx_status & ErrorSummary)) {
  1585. if (rx_status & ErrorSummary) { /* there was a fatal error */
  1586. if (debug)
  1587. printk(KERN_DEBUG
  1588.        "%s: Receive error, Rx status %8.8x.n",
  1589.        dev->name, rx_status);
  1591. np->stats.rx_errors++; /* end of a packet. */
  1592. if (rx_status & (LONG | RUNT))
  1593. np->stats.rx_length_errors++;
  1594. if (rx_status & RXER)
  1595. np->stats.rx_frame_errors++;
  1596. if (rx_status & CRC)
  1597. np->stats.rx_crc_errors++;
  1598. } else {
  1599. int need_to_reset = 0;
  1600. int desno = 0;
  1602. if (rx_status & RXFSD) { /* this pkt is too long, over one rx buffer */
  1603. struct fealnx_desc *cur;
  1605. /* check this packet is received completely? */
  1606. cur = np->cur_rx;
  1607. while (desno <= np->really_rx_count) {
  1608. ++desno;
  1609. if ((!(cur->status & RXOWN))
  1610.     && (cur->status & RXLSD))
  1611. break;
  1612. /* goto next rx descriptor */
  1613. cur = cur->next_desc_logical;
  1614. }
  1615. if (desno > np->really_rx_count)
  1616. need_to_reset = 1;
  1617. } else /* RXLSD did not find, something error */
  1618. need_to_reset = 1;
  1620. if (need_to_reset == 0) {
  1621. int i;
  1623. np->stats.rx_length_errors++;
  1625. /* free all rx descriptors related this long pkt */
  1626. for (i = 0; i < desno; ++i)
  1627. free_one_rx_descriptor(np);
  1628. continue;
  1629. } else { /* something error, need to reset this chip */
  1630. reset_rx_descriptors(dev);
  1631. }
  1632. break; /* exit the while loop */
  1633. }
  1634. } else { /* this received pkt is ok */
  1636. struct sk_buff *skb;
  1637. /* Omit the four octet CRC from the length. */
  1638. short pkt_len = ((rx_status & FLNGMASK) >> FLNGShift) - 4;
  1640. #ifndef final_version
  1641. if (debug)
  1642. printk(KERN_DEBUG "  netdev_rx() normal Rx pkt length %d"
  1643.        " status %x.n", pkt_len, rx_status);
  1644. #endif
  1645. pci_dma_sync_single(np->pci_dev, np->cur_rx->buffer,
  1646. np->rx_buf_sz, PCI_DMA_FROMDEVICE);
  1647. pci_unmap_single(np->pci_dev, np->cur_rx->buffer,
  1648. np->rx_buf_sz, PCI_DMA_FROMDEVICE);
  1650. /* Check if the packet is long enough to accept without copying
  1651.    to a minimally-sized skbuff. */
  1652. if (pkt_len < rx_copybreak &&
  1653.     (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
  1654. skb->dev = dev;
  1655. skb_reserve(skb, 2); /* 16 byte align the IP header */
  1656. /* Call copy + cksum if available. */
  1658. #if ! defined(__alpha__)
  1659. eth_copy_and_sum(skb, 
  1660. np->cur_rx->skbuff->tail, pkt_len, 0);
  1661. skb_put(skb, pkt_len);
  1662. #else
  1663. memcpy(skb_put(skb, pkt_len),
  1664. np->cur_rx->skbuff->tail, pkt_len);
  1665. #endif
  1666. } else {
  1667. skb_put(skb = np->cur_rx->skbuff, pkt_len);
  1668. np->cur_rx->skbuff = NULL;
  1669. if (np->really_rx_count == RX_RING_SIZE)
  1670. np->lack_rxbuf = np->cur_rx;
  1671. --np->really_rx_count;
  1672. }
  1673. skb->protocol = eth_type_trans(skb, dev);
  1674. netif_rx(skb);
  1675. dev->last_rx = jiffies;
  1676. np->stats.rx_packets++;
  1677. np->stats.rx_bytes += pkt_len;
  1678. }
  1680. if (np->cur_rx->skbuff == NULL) {
  1681. struct sk_buff *skb;
  1683. skb = dev_alloc_skb(np->rx_buf_sz);
  1685. if (skb != NULL) {
  1686. skb->dev = dev; /* Mark as being used by this device. */
  1687. np->cur_rx->buffer = pci_map_single(np->pci_dev, skb->tail,
  1688. np->rx_buf_sz, PCI_DMA_FROMDEVICE);
  1689. np->cur_rx->skbuff = skb;
  1690. ++np->really_rx_count;
  1691. }
  1692. }
  1694. if (np->cur_rx->skbuff != NULL)
  1695. free_one_rx_descriptor(np);
  1696. } /* end of while loop */
  1698. /*  allocate skb for rx buffers */
  1699. allocate_rx_buffers(dev);
  1701. return 0;
  1702. }
  1705. static struct net_device_stats *get_stats(struct net_device *dev)
  1706. {
  1707. long ioaddr = dev->base_addr;
  1708. struct netdev_private *np = dev->priv;
  1710. /* The chip only need report frame silently dropped. */
  1711. if (netif_running(dev)) {
  1712. np->stats.rx_missed_errors += readl(ioaddr + TALLY) & 0x7fff;
  1713. np->stats.rx_crc_errors += (readl(ioaddr + TALLY) & 0x7fff0000) >> 16;
  1714. }
  1716. return &np->stats;
  1717. }
  1719. static void set_rx_mode(struct net_device *dev)
  1720. {
  1721. struct netdev_private *np = dev->priv;
  1722. long ioaddr = dev->base_addr;
  1723. u32 mc_filter[2]; /* Multicast hash filter */
  1724. u32 rx_mode;
  1726. if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
  1727. /* Unconditionally log net taps. */
  1728. printk(KERN_NOTICE "%s: Promiscuous mode enabled.n", dev->name);
  1729. memset(mc_filter, 0xff, sizeof(mc_filter));
  1730. rx_mode = PROM | AB | AM;
  1731. } else if ((dev->mc_count > multicast_filter_limit)
  1732.    || (dev->flags & IFF_ALLMULTI)) {
  1733. /* Too many to match, or accept all multicasts. */
  1734. memset(mc_filter, 0xff, sizeof(mc_filter));
  1735. rx_mode = AB | AM;
  1736. } else {
  1737. struct dev_mc_list *mclist;
  1738. int i;
  1740. memset(mc_filter, 0, sizeof(mc_filter));
  1741. for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
  1742.      i++, mclist = mclist->next) {
  1743. set_bit((ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26) ^ 0x3F,
  1744. mc_filter);
  1745. }
  1746. rx_mode = AB | AM;
  1747. }
  1749. stop_nic_tx(ioaddr, np->crvalue);
  1750. stop_nic_rx(ioaddr, np->crvalue & (~0x40000));
  1752. writel(mc_filter[0], ioaddr + MAR0);
  1753. writel(mc_filter[1], ioaddr + MAR1);
  1754. np->crvalue &= ~RxModeMask;
  1755. np->crvalue |= rx_mode;
  1756. writel(np->crvalue, ioaddr + TCRRCR);
  1757. }
  1759. static int netdev_ethtool_ioctl (struct net_device *dev, void *useraddr)
  1760. {
  1761. struct netdev_private *np = dev->priv;
  1762. u32 ethcmd;
  1764. if (copy_from_user (&ethcmd, useraddr, sizeof (ethcmd)))
  1765. return -EFAULT;
  1767. switch (ethcmd) {
  1768. case ETHTOOL_GDRVINFO: {
  1769. struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
  1770. strcpy (info.driver, DRV_NAME);
  1771. strcpy (info.version, DRV_VERSION);
  1772. strcpy (info.bus_info, np->pci_dev->slot_name);
  1773. if (copy_to_user (useraddr, &info, sizeof (info)))
  1774. return -EFAULT;
  1775. return 0;
  1776. }
  1778. /* get settings */
  1779. case ETHTOOL_GSET: {
  1780. struct ethtool_cmd ecmd = { ETHTOOL_GSET };
  1781. spin_lock_irq(&np->lock);
  1782. mii_ethtool_gset(&np->mii, &ecmd);
  1783. spin_unlock_irq(&np->lock);
  1784. if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
  1785. return -EFAULT;
  1786. return 0;
  1787. }
  1788. /* set settings */
  1789. case ETHTOOL_SSET: {
  1790. int r;
  1791. struct ethtool_cmd ecmd;
  1792. if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
  1793. return -EFAULT;
  1794. spin_lock_irq(&np->lock);
  1795. r = mii_ethtool_sset(&np->mii, &ecmd);
  1796. spin_unlock_irq(&np->lock);
  1797. return r;
  1798. }
  1799. /* restart autonegotiation */
  1800. case ETHTOOL_NWAY_RST: {
  1801. return mii_nway_restart(&np->mii);
  1802. }
  1803. /* get link status */
  1804. case ETHTOOL_GLINK: {
  1805. struct ethtool_value edata = {ETHTOOL_GLINK};
  1806. edata.data = mii_link_ok(&np->mii);
  1807. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  1808. return -EFAULT;
  1809. return 0;
  1810. }
  1812. /* get message-level */
  1813. case ETHTOOL_GMSGLVL: {
  1814. struct ethtool_value edata = {ETHTOOL_GMSGLVL};
  1815. edata.data = debug;
  1816. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  1817. return -EFAULT;
  1818. return 0;
  1819. }
  1820. /* set message-level */
  1821. case ETHTOOL_SMSGLVL: {
  1822. struct ethtool_value edata;
  1823. if (copy_from_user(&edata, useraddr, sizeof(edata)))
  1824. return -EFAULT;
  1825. debug = edata.data;
  1826. return 0;
  1827. }
  1828. default:
  1829. break;
  1830. }
  1832. return -EOPNOTSUPP;
  1833. }
  1836. static int mii_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  1837. {
  1838. struct netdev_private *np = dev->priv;
  1839. struct mii_ioctl_data *data = (struct mii_ioctl_data *) & rq->ifr_data;
  1840. int rc;
  1842. if (!netif_running(dev))
  1843. return -EINVAL;
  1845. if (cmd == SIOCETHTOOL)
  1846. rc = netdev_ethtool_ioctl(dev, (void *) rq->ifr_data);
  1848. else {
  1849. spin_lock_irq(&np->lock);
  1850. rc = generic_mii_ioctl(&np->mii, data, cmd, NULL);
  1851. spin_unlock_irq(&np->lock);
  1852. }
  1854. return rc;
  1855. }
  1858. static int netdev_close(struct net_device *dev)
  1859. {
  1860. long ioaddr = dev->base_addr;
  1861. struct netdev_private *np = dev->priv;
  1862. int i;
  1864. netif_stop_queue(dev);
  1866. /* Disable interrupts by clearing the interrupt mask. */
  1867. writel(0x0000, ioaddr + IMR);
  1869. /* Stop the chip's Tx and Rx processes. */
  1870. stop_nic_tx(ioaddr, 0);
  1871. stop_nic_rx(ioaddr, 0);
  1873. del_timer_sync(&np->timer);
  1875. free_irq(dev->irq, dev);
  1877. /* Free all the skbuffs in the Rx queue. */
  1878. for (i = 0; i < RX_RING_SIZE; i++) {
  1879. struct sk_buff *skb = np->rx_ring[i].skbuff;
  1881. np->rx_ring[i].status = 0;
  1882. if (skb) {
  1883. pci_unmap_single(np->pci_dev, np->rx_ring[i].buffer,
  1884. np->rx_buf_sz, PCI_DMA_FROMDEVICE);
  1885. dev_kfree_skb(skb);
  1886. np->rx_ring[i].skbuff = NULL;
  1887. }
  1888. }
  1890. for (i = 0; i < TX_RING_SIZE; i++) {
  1891. struct sk_buff *skb = np->tx_ring[i].skbuff;
  1893. if (skb) {
  1894. pci_unmap_single(np->pci_dev, np->tx_ring[i].buffer,
  1895. skb->len, PCI_DMA_TODEVICE);
  1896. dev_kfree_skb(skb);
  1897. np->tx_ring[i].skbuff = NULL;
  1898. }
  1899. }
  1901. return 0;
  1902. }
  1904. static struct pci_device_id fealnx_pci_tbl[] __devinitdata = {
  1905. {0x1516, 0x0800, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
  1906. {0x1516, 0x0803, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
  1907. {0x1516, 0x0891, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
  1908. {} /* terminate list */
  1909. };
  1910. MODULE_DEVICE_TABLE(pci, fealnx_pci_tbl);
  1913. static struct pci_driver fealnx_driver = {
  1914. name: "fealnx",
  1915. id_table: fealnx_pci_tbl,
  1916. probe: fealnx_init_one,
  1917. remove: __devexit_p(fealnx_remove_one),
  1918. };
  1920. static int __init fealnx_init(void)
  1921. {
  1922. /* when a module, this is printed whether or not devices are found in probe */
  1923. #ifdef MODULE
  1924. printk (version);
  1925. #endif
  1927. return pci_module_init(&fealnx_driver);
  1928. }
  1930. static void __exit fealnx_exit(void)
  1931. {
  1932. pci_unregister_driver(&fealnx_driver);
  1933. }
  1935. module_init(fealnx_init);
  1936. module_exit(fealnx_exit);