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

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

嵌入式Linux

开发平台：

Unix_Linux

yellowfin.c：源码内容
  1. /* yellowfin.c: A Packet Engines G-NIC ethernet driver for linux. */
  2. /*
  3. Written 1997-2001 by Donald Becker.
  5. This software may be used and distributed according to the terms of
  6. the GNU General Public License (GPL), incorporated herein by reference.
  7. Drivers based on or derived from this code fall under the GPL and must
  8. retain the authorship, copyright and license notice.  This file is not
  9. a complete program and may only be used when the entire operating
  10. system is licensed under the GPL.
  12. This driver is for the Packet Engines G-NIC PCI Gigabit Ethernet adapter.
  13. It also supports the Symbios Logic version of the same chip core.
  15. The author may be reached as becker@scyld.com, or C/O
  16. Scyld Computing Corporation
  17. 410 Severn Ave., Suite 210
  18. Annapolis MD 21403
  20. Support and updates available at
  21. http://www.scyld.com/network/yellowfin.html
  24. Linux kernel changelog:
  25. -----------------------
  27. LK1.1.1 (jgarzik): Port to 2.4 kernel
  29. LK1.1.2 (jgarzik):
  30. * Merge in becker version 1.05
  32. LK1.1.3 (jgarzik):
  33. * Various cleanups
  34. * Update yellowfin_timer to correctly calculate duplex.
  35. (suggested by Manfred Spraul)
  37. LK1.1.4 (val@nmt.edu):
  38. * Fix three endian-ness bugs
  39. * Support dual function SYM53C885E ethernet chip
  41. LK1.1.5 (val@nmt.edu):
  42. * Fix forced full-duplex bug I introduced
  44. */
  46. #define DRV_NAME "yellowfin"
  47. #define DRV_VERSION "1.05+LK1.1.5"
  48. #define DRV_RELDATE "May 10, 2001"
  50. #define PFX DRV_NAME ": "
  52. /* The user-configurable values.
  53.    These may be modified when a driver module is loaded.*/
  55. static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */
  56. /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
  57. static int max_interrupt_work = 20;
  58. static int mtu;
  59. #ifdef YF_PROTOTYPE /* Support for prototype hardware errata. */
  60. /* System-wide count of bogus-rx frames. */
  61. static int bogus_rx;
  62. static int dma_ctrl = 0x004A0263;  /* Constrained by errata */
  63. static int fifo_cfg = 0x0020; /* Bypass external Tx FIFO. */
  64. #elif YF_NEW /* A future perfect board :->.  */
  65. static int dma_ctrl = 0x00CAC277; /* Override when loading module! */
  66. static int fifo_cfg = 0x0028;
  67. #else
  68. static int dma_ctrl = 0x004A0263;  /* Constrained by errata */
  69. static int fifo_cfg = 0x0020; /* Bypass external Tx FIFO. */
  70. #endif
  72. /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
  73.    Setting to > 1514 effectively disables this feature. */
  74. static int rx_copybreak;
  76. /* Used to pass the media type, etc.
  77.    No media types are currently defined.  These exist for driver
  78.    interoperability.
  79. */
  80. #define MAX_UNITS 8 /* More are supported, limit only on options */
  81. static int options[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
  82. static int full_duplex[MAX_UNITS] = {-1, -1, -1, -1, -1, -1, -1, -1};
  84. /* Do ugly workaround for GX server chipset errata. */
  85. static int gx_fix;
  87. /* Operational parameters that are set at compile time. */
  89. /* Keep the ring sizes a power of two for efficiency.
  90.    Making the Tx ring too long decreases the effectiveness of channel
  91.    bonding and packet priority.
  92.    There are no ill effects from too-large receive rings. */
  93. #define TX_RING_SIZE 16
  94. #define TX_QUEUE_SIZE 12 /* Must be > 4 && <= TX_RING_SIZE */
  95. #define RX_RING_SIZE 64
  96. #define STATUS_TOTAL_SIZE TX_RING_SIZE*sizeof(struct tx_status_words)
  97. #define TX_TOTAL_SIZE 2*TX_RING_SIZE*sizeof(struct yellowfin_desc)
  98. #define RX_TOTAL_SIZE RX_RING_SIZE*sizeof(struct yellowfin_desc)
  100. /* Operational parameters that usually are not changed. */
  101. /* Time in jiffies before concluding the transmitter is hung. */
  102. #define TX_TIMEOUT  (2*HZ)
  103. #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/
  105. #define yellowfin_debug debug
  107. #if !defined(__OPTIMIZE__)
  108. #warning  You must compile this file with the correct options!
  109. #warning  See the last lines of the source file.
  110. #error You must compile this driver with "-O".
  111. #endif
  113. #include <linux/module.h>
  114. #include <linux/kernel.h>
  115. #include <linux/string.h>
  116. #include <linux/timer.h>
  117. #include <linux/errno.h>
  118. #include <linux/ioport.h>
  119. #include <linux/slab.h>
  120. #include <linux/interrupt.h>
  121. #include <linux/pci.h>
  122. #include <linux/init.h>
  123. #include <linux/mii.h>
  124. #include <linux/netdevice.h>
  125. #include <linux/etherdevice.h>
  126. #include <linux/skbuff.h>
  127. #include <linux/ethtool.h>
  128. #include <asm/uaccess.h>
  129. #include <asm/processor.h> /* Processor type for cache alignment. */
  130. #include <asm/unaligned.h>
  131. #include <asm/bitops.h>
  132. #include <asm/io.h>
  134. /* These identify the driver base version and may not be removed. */
  135. static char version[] __devinitdata =
  136. KERN_INFO DRV_NAME ".c:v1.05  1/09/2001  Written by Donald Becker <becker@scyld.com>n"
  137. KERN_INFO "  http://www.scyld.com/network/yellowfin.htmln"
  138. KERN_INFO "  (unofficial 2.4.x port, " DRV_VERSION ", " DRV_RELDATE ")n";
  140. #ifndef USE_IO_OPS
  141. #undef inb
  142. #undef inw
  143. #undef inl
  144. #undef outb
  145. #undef outw
  146. #undef outl
  147. #define inb readb
  148. #define inw readw
  149. #define inl readl
  150. #define outb writeb
  151. #define outw writew
  152. #define outl writel
  153. #endif /* !USE_IO_OPS */
  154. MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
  155. MODULE_DESCRIPTION("Packet Engines Yellowfin G-NIC Gigabit Ethernet driver");
  156. MODULE_LICENSE("GPL");
  158. MODULE_PARM(max_interrupt_work, "i");
  159. MODULE_PARM(mtu, "i");
  160. MODULE_PARM(debug, "i");
  161. MODULE_PARM(rx_copybreak, "i");
  162. MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i");
  163. MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");
  164. MODULE_PARM(gx_fix, "i");
  165. MODULE_PARM_DESC(max_interrupt_work, "G-NIC maximum events handled per interrupt");
  166. MODULE_PARM_DESC(mtu, "G-NIC MTU (all boards)");
  167. MODULE_PARM_DESC(debug, "G-NIC debug level (0-7)");
  168. MODULE_PARM_DESC(rx_copybreak, "G-NIC copy breakpoint for copy-only-tiny-frames");
  169. MODULE_PARM_DESC(options, "G-NIC: Bits 0-3: media type, bit 17: full duplex");
  170. MODULE_PARM_DESC(full_duplex, "G-NIC full duplex setting(s) (1)");
  171. MODULE_PARM_DESC(gx_fix, "G-NIC: enable GX server chipset bug workaround (0-1)");
  173. /*
  174. Theory of Operation
  176. I. Board Compatibility
  178. This device driver is designed for the Packet Engines "Yellowfin" Gigabit
  179. Ethernet adapter.  The only PCA currently supported is the G-NIC 64-bit
  180. PCI card.
  182. II. Board-specific settings
  184. PCI bus devices are configured by the system at boot time, so no jumpers
  185. need to be set on the board.  The system BIOS preferably should assign the
  186. PCI INTA signal to an otherwise unused system IRQ line.
  187. Note: Kernel versions earlier than 1.3.73 do not support shared PCI
  188. interrupt lines.
  190. III. Driver operation
  192. IIIa. Ring buffers
  194. The Yellowfin uses the Descriptor Based DMA Architecture specified by Apple.
  195. This is a descriptor list scheme similar to that used by the EEPro100 and
  196. Tulip.  This driver uses two statically allocated fixed-size descriptor lists
  197. formed into rings by a branch from the final descriptor to the beginning of
  198. the list.  The ring sizes are set at compile time by RX/TX_RING_SIZE.
  200. The driver allocates full frame size skbuffs for the Rx ring buffers at
  201. open() time and passes the skb->data field to the Yellowfin as receive data
  202. buffers.  When an incoming frame is less than RX_COPYBREAK bytes long,
  203. a fresh skbuff is allocated and the frame is copied to the new skbuff.
  204. When the incoming frame is larger, the skbuff is passed directly up the
  205. protocol stack and replaced by a newly allocated skbuff.
  207. The RX_COPYBREAK value is chosen to trade-off the memory wasted by
  208. using a full-sized skbuff for small frames vs. the copying costs of larger
  209. frames.  For small frames the copying cost is negligible (esp. considering
  210. that we are pre-loading the cache with immediately useful header
  211. information).  For large frames the copying cost is non-trivial, and the
  212. larger copy might flush the cache of useful data.
  214. IIIC. Synchronization
  216. The driver runs as two independent, single-threaded flows of control.  One
  217. is the send-packet routine, which enforces single-threaded use by the
  218. dev->tbusy flag.  The other thread is the interrupt handler, which is single
  219. threaded by the hardware and other software.
  221. The send packet thread has partial control over the Tx ring and 'dev->tbusy'
  222. flag.  It sets the tbusy flag whenever it's queuing a Tx packet. If the next
  223. queue slot is empty, it clears the tbusy flag when finished otherwise it sets
  224. the 'yp->tx_full' flag.
  226. The interrupt handler has exclusive control over the Rx ring and records stats
  227. from the Tx ring.  After reaping the stats, it marks the Tx queue entry as
  228. empty by incrementing the dirty_tx mark. Iff the 'yp->tx_full' flag is set, it
  229. clears both the tx_full and tbusy flags.
  231. IV. Notes
  233. Thanks to Kim Stearns of Packet Engines for providing a pair of G-NIC boards.
  234. Thanks to Bruce Faust of Digitalscape for providing both their SYM53C885 board
  235. and an AlphaStation to verifty the Alpha port!
  237. IVb. References
  239. Yellowfin Engineering Design Specification, 4/23/97 Preliminary/Confidential
  240. Symbios SYM53C885 PCI-SCSI/Fast Ethernet Multifunction Controller Preliminary
  241.    Data Manual v3.0
  242. http://cesdis.gsfc.nasa.gov/linux/misc/NWay.html
  243. http://cesdis.gsfc.nasa.gov/linux/misc/100mbps.html
  245. IVc. Errata
  247. See Packet Engines confidential appendix (prototype chips only).
  248. */
  252. enum pci_id_flags_bits {
  253. /* Set PCI command register bits before calling probe1(). */
  254. PCI_USES_IO=1, PCI_USES_MEM=2, PCI_USES_MASTER=4,
  255. /* Read and map the single following PCI BAR. */
  256. PCI_ADDR0=0<<4, PCI_ADDR1=1<<4, PCI_ADDR2=2<<4, PCI_ADDR3=3<<4,
  257. PCI_ADDR_64BITS=0x100, PCI_NO_ACPI_WAKE=0x200, PCI_NO_MIN_LATENCY=0x400,
  258. PCI_UNUSED_IRQ=0x800,
  259. };
  260. enum capability_flags {
  261. HasMII=1, FullTxStatus=2, IsGigabit=4, HasMulticastBug=8, FullRxStatus=16,
  262. HasMACAddrBug=32, DontUseEeprom=64, /* Only on early revs.  */
  263. };
  264. /* The PCI I/O space extent. */
  265. #define YELLOWFIN_SIZE 0x100
  266. #ifdef USE_IO_OPS
  267. #define PCI_IOTYPE (PCI_USES_MASTER | PCI_USES_IO  | PCI_ADDR0)
  268. #else
  269. #define PCI_IOTYPE (PCI_USES_MASTER | PCI_USES_MEM | PCI_ADDR1)
  270. #endif
  272. struct pci_id_info {
  273.         const char *name;
  274.         struct match_info {
  275.                 int     pci, pci_mask, subsystem, subsystem_mask;
  276.                 int revision, revision_mask;                            /* Only 8 bits. */
  277.         } id;
  278.         enum pci_id_flags_bits pci_flags;
  279.         int io_size;                            /* Needed for I/O region check or ioremap(). */
  280.         int drv_flags;                          /* Driver use, intended as capability flags. */
  281. };
  283. static struct pci_id_info pci_id_tbl[] = {
  284. {"Yellowfin G-NIC Gigabit Ethernet", { 0x07021000, 0xffffffff},
  285.  PCI_IOTYPE, YELLOWFIN_SIZE,
  286.  FullTxStatus | IsGigabit | HasMulticastBug | HasMACAddrBug},
  287. {"Symbios SYM83C885", { 0x07011000, 0xffffffff},
  288.  PCI_IOTYPE, YELLOWFIN_SIZE, HasMII | DontUseEeprom },
  289. {0,},
  290. };
  292. static struct pci_device_id yellowfin_pci_tbl[] __devinitdata = {
  293. { 0x1000, 0x0702, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
  294. { 0x1000, 0x0701, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
  295. { 0, }
  296. };
  297. MODULE_DEVICE_TABLE (pci, yellowfin_pci_tbl);
  300. /* Offsets to the Yellowfin registers.  Various sizes and alignments. */
  301. enum yellowfin_offsets {
  302. TxCtrl=0x00, TxStatus=0x04, TxPtr=0x0C,
  303. TxIntrSel=0x10, TxBranchSel=0x14, TxWaitSel=0x18,
  304. RxCtrl=0x40, RxStatus=0x44, RxPtr=0x4C,
  305. RxIntrSel=0x50, RxBranchSel=0x54, RxWaitSel=0x58,
  306. EventStatus=0x80, IntrEnb=0x82, IntrClear=0x84, IntrStatus=0x86,
  307. ChipRev=0x8C, DMACtrl=0x90, TxThreshold=0x94,
  308. Cnfg=0xA0, FrameGap0=0xA2, FrameGap1=0xA4,
  309. MII_Cmd=0xA6, MII_Addr=0xA8, MII_Wr_Data=0xAA, MII_Rd_Data=0xAC,
  310. MII_Status=0xAE,
  311. RxDepth=0xB8, FlowCtrl=0xBC,
  312. AddrMode=0xD0, StnAddr=0xD2, HashTbl=0xD8, FIFOcfg=0xF8,
  313. EEStatus=0xF0, EECtrl=0xF1, EEAddr=0xF2, EERead=0xF3, EEWrite=0xF4,
  314. EEFeature=0xF5,
  315. };
  317. /* The Yellowfin Rx and Tx buffer descriptors.
  318.    Elements are written as 32 bit for endian portability. */
  319. struct yellowfin_desc {
  320. u32 dbdma_cmd;
  321. u32 addr;
  322. u32 branch_addr;
  323. u32 result_status;
  324. };
  326. struct tx_status_words {
  327. #ifdef __BIG_ENDIAN
  328. u16 tx_errs;
  329. u16 tx_cnt;
  330. u16 paused;
  331. u16 total_tx_cnt;
  332. #else  /* Little endian chips. */
  333. u16 tx_cnt;
  334. u16 tx_errs;
  335. u16 total_tx_cnt;
  336. u16 paused;
  337. #endif /* __BIG_ENDIAN */
  338. };
  340. /* Bits in yellowfin_desc.cmd */
  341. enum desc_cmd_bits {
  342. CMD_TX_PKT=0x10000000, CMD_RX_BUF=0x20000000, CMD_TXSTATUS=0x30000000,
  343. CMD_NOP=0x60000000, CMD_STOP=0x70000000,
  344. BRANCH_ALWAYS=0x0C0000, INTR_ALWAYS=0x300000, WAIT_ALWAYS=0x030000,
  345. BRANCH_IFTRUE=0x040000,
  346. };
  348. /* Bits in yellowfin_desc.status */
  349. enum desc_status_bits { RX_EOP=0x0040, };
  351. /* Bits in the interrupt status/mask registers. */
  352. enum intr_status_bits {
  353. IntrRxDone=0x01, IntrRxInvalid=0x02, IntrRxPCIFault=0x04,IntrRxPCIErr=0x08,
  354. IntrTxDone=0x10, IntrTxInvalid=0x20, IntrTxPCIFault=0x40,IntrTxPCIErr=0x80,
  355. IntrEarlyRx=0x100, IntrWakeup=0x200, };
  357. #define PRIV_ALIGN 31  /* Required alignment mask */
  358. #define MII_CNT 4
  359. struct yellowfin_private {
  360. /* Descriptor rings first for alignment.
  361.    Tx requires a second descriptor for status. */
  362. struct yellowfin_desc *rx_ring;
  363. struct yellowfin_desc *tx_ring;
  364. struct sk_buff* rx_skbuff[RX_RING_SIZE];
  365. struct sk_buff* tx_skbuff[TX_RING_SIZE];
  366. dma_addr_t rx_ring_dma;
  367. dma_addr_t tx_ring_dma;
  369. struct tx_status_words *tx_status;
  370. dma_addr_t tx_status_dma;
  372. struct timer_list timer; /* Media selection timer. */
  373. struct net_device_stats stats;
  374. /* Frequently used and paired value: keep adjacent for cache effect. */
  375. int chip_id, drv_flags;
  376. struct pci_dev *pci_dev;
  377. unsigned int cur_rx, dirty_rx; /* Producer/consumer ring indices */
  378. unsigned int rx_buf_sz; /* Based on MTU+slack. */
  379. struct tx_status_words *tx_tail_desc;
  380. unsigned int cur_tx, dirty_tx;
  381. int tx_threshold;
  382. unsigned int tx_full:1; /* The Tx queue is full. */
  383. unsigned int full_duplex:1; /* Full-duplex operation requested. */
  384. unsigned int duplex_lock:1;
  385. unsigned int medialock:1; /* Do not sense media. */
  386. unsigned int default_port:4; /* Last dev->if_port value. */
  387. /* MII transceiver section. */
  388. int mii_cnt; /* MII device addresses. */
  389. u16 advertising; /* NWay media advertisement */
  390. unsigned char phys[MII_CNT]; /* MII device addresses, only first one used */
  391. spinlock_t lock;
  392. };
  394. static int read_eeprom(long ioaddr, int location);
  395. static int mdio_read(long ioaddr, int phy_id, int location);
  396. static void mdio_write(long ioaddr, int phy_id, int location, int value);
  397. static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
  398. static int yellowfin_open(struct net_device *dev);
  399. static void yellowfin_timer(unsigned long data);
  400. static void yellowfin_tx_timeout(struct net_device *dev);
  401. static void yellowfin_init_ring(struct net_device *dev);
  402. static int yellowfin_start_xmit(struct sk_buff *skb, struct net_device *dev);
  403. static void yellowfin_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
  404. static int yellowfin_rx(struct net_device *dev);
  405. static void yellowfin_error(struct net_device *dev, int intr_status);
  406. static int yellowfin_close(struct net_device *dev);
  407. static struct net_device_stats *yellowfin_get_stats(struct net_device *dev);
  408. static void set_rx_mode(struct net_device *dev);
  411. static int __devinit yellowfin_init_one(struct pci_dev *pdev,
  412. const struct pci_device_id *ent)
  413. {
  414. struct net_device *dev;
  415. struct yellowfin_private *np;
  416. int irq;
  417. int chip_idx = ent->driver_data;
  418. static int find_cnt;
  419. long ioaddr, real_ioaddr;
  420. int i, option = find_cnt < MAX_UNITS ? options[find_cnt] : 0;
  421. int drv_flags = pci_id_tbl[chip_idx].drv_flags;
  422.         void *ring_space;
  423.         dma_addr_t ring_dma;
  425. /* when built into the kernel, we only print version if device is found */
  426. #ifndef MODULE
  427. static int printed_version;
  428. if (!printed_version++)
  429. printk(version);
  430. #endif
  432. i = pci_enable_device(pdev);
  433. if (i) return i;
  435. dev = alloc_etherdev(sizeof(*np));
  436. if (!dev) {
  437. printk (KERN_ERR PFX "cannot allocate ethernet devicen");
  438. return -ENOMEM;
  439. }
  440. SET_MODULE_OWNER(dev);
  442. np = dev->priv;
  444. if (pci_request_regions(pdev, dev->name))
  445. goto err_out_free_netdev;
  447. pci_set_master (pdev);
  449. #ifdef USE_IO_OPS
  450. real_ioaddr = ioaddr = pci_resource_start (pdev, 0);
  451. #else
  452. real_ioaddr = ioaddr = pci_resource_start (pdev, 1);
  453. ioaddr = (long) ioremap(ioaddr, YELLOWFIN_SIZE);
  454. if (!ioaddr)
  455. goto err_out_free_res;
  456. #endif
  457. irq = pdev->irq;
  459. if (drv_flags & DontUseEeprom)
  460. for (i = 0; i < 6; i++)
  461. dev->dev_addr[i] = inb(ioaddr + StnAddr + i);
  462. else {
  463. int ee_offset = (read_eeprom(ioaddr, 6) == 0xff ? 0x100 : 0);
  464. for (i = 0; i < 6; i++)
  465. dev->dev_addr[i] = read_eeprom(ioaddr, ee_offset + i);
  466. }
  468. /* Reset the chip. */
  469. outl(0x80000000, ioaddr + DMACtrl);
  471. dev->base_addr = ioaddr;
  472. dev->irq = irq;
  474. pci_set_drvdata(pdev, dev);
  475. spin_lock_init(&np->lock);
  477. np->pci_dev = pdev;
  478. np->chip_id = chip_idx;
  479. np->drv_flags = drv_flags;
  481. ring_space = pci_alloc_consistent(pdev, TX_TOTAL_SIZE, &ring_dma);
  482. if (!ring_space)
  483. goto err_out_cleardev;
  484. np->tx_ring = (struct yellowfin_desc *)ring_space;
  485. np->tx_ring_dma = ring_dma;
  487. ring_space = pci_alloc_consistent(pdev, RX_TOTAL_SIZE, &ring_dma);
  488. if (!ring_space)
  489. goto err_out_unmap_tx;
  490. np->rx_ring = (struct yellowfin_desc *)ring_space;
  491. np->rx_ring_dma = ring_dma;
  493. ring_space = pci_alloc_consistent(pdev, STATUS_TOTAL_SIZE, &ring_dma);
  494. if (!ring_space)
  495. goto err_out_unmap_rx;
  496. np->tx_status = (struct tx_status_words *)ring_space;
  497. np->tx_status_dma = ring_dma;
  499. if (dev->mem_start)
  500. option = dev->mem_start;
  502. /* The lower four bits are the media type. */
  503. if (option > 0) {
  504. if (option & 0x200)
  505. np->full_duplex = 1;
  506. np->default_port = option & 15;
  507. if (np->default_port)
  508. np->medialock = 1;
  509. }
  510. if (find_cnt < MAX_UNITS  &&  full_duplex[find_cnt] > 0)
  511. np->full_duplex = 1;
  513. if (np->full_duplex)
  514. np->duplex_lock = 1;
  516. /* The Yellowfin-specific entries in the device structure. */
  517. dev->open = &yellowfin_open;
  518. dev->hard_start_xmit = &yellowfin_start_xmit;
  519. dev->stop = &yellowfin_close;
  520. dev->get_stats = &yellowfin_get_stats;
  521. dev->set_multicast_list = &set_rx_mode;
  522. dev->do_ioctl = &netdev_ioctl;
  523. dev->tx_timeout = yellowfin_tx_timeout;
  524. dev->watchdog_timeo = TX_TIMEOUT;
  526. if (mtu)
  527. dev->mtu = mtu;
  529. i = register_netdev(dev);
  530. if (i)
  531. goto err_out_unmap_status;
  533. printk(KERN_INFO "%s: %s type %8x at 0x%lx, ",
  534.    dev->name, pci_id_tbl[chip_idx].name, inl(ioaddr + ChipRev), ioaddr);
  535. for (i = 0; i < 5; i++)
  536. printk("%2.2x:", dev->dev_addr[i]);
  537. printk("%2.2x, IRQ %d.n", dev->dev_addr[i], irq);
  539. if (np->drv_flags & HasMII) {
  540. int phy, phy_idx = 0;
  541. for (phy = 0; phy < 32 && phy_idx < MII_CNT; phy++) {
  542. int mii_status = mdio_read(ioaddr, phy, 1);
  543. if (mii_status != 0xffff  &&  mii_status != 0x0000) {
  544. np->phys[phy_idx++] = phy;
  545. np->advertising = mdio_read(ioaddr, phy, 4);
  546. printk(KERN_INFO "%s: MII PHY found at address %d, status "
  547.    "0x%4.4x advertising %4.4x.n",
  548.    dev->name, phy, mii_status, np->advertising);
  549. }
  550. }
  551. np->mii_cnt = phy_idx;
  552. }
  554. find_cnt++;
  556. return 0;
  558. err_out_unmap_status:
  559.         pci_free_consistent(pdev, STATUS_TOTAL_SIZE, np->tx_status, 
  560. np->tx_status_dma);
  561. err_out_unmap_rx:
  562.         pci_free_consistent(pdev, RX_TOTAL_SIZE, np->rx_ring, np->rx_ring_dma);
  563. err_out_unmap_tx:
  564.         pci_free_consistent(pdev, TX_TOTAL_SIZE, np->tx_ring, np->tx_ring_dma);
  565. err_out_cleardev:
  566. pci_set_drvdata(pdev, NULL);
  567. #ifndef USE_IO_OPS
  568. iounmap((void *)ioaddr);
  569. err_out_free_res:
  570. #endif
  571. pci_release_regions(pdev);
  572. err_out_free_netdev:
  573. kfree (dev);
  574. return -ENODEV;
  575. }
  577. static int __devinit read_eeprom(long ioaddr, int location)
  578. {
  579. int bogus_cnt = 10000; /* Typical 33Mhz: 1050 ticks */
  581. outb(location, ioaddr + EEAddr);
  582. outb(0x30 | ((location >> 8) & 7), ioaddr + EECtrl);
  583. while ((inb(ioaddr + EEStatus) & 0x80)  &&  --bogus_cnt > 0)
  584. ;
  585. return inb(ioaddr + EERead);
  586. }
  588. /* MII Managemen Data I/O accesses.
  589.    These routines assume the MDIO controller is idle, and do not exit until
  590.    the command is finished. */
  592. static int mdio_read(long ioaddr, int phy_id, int location)
  593. {
  594. int i;
  596. outw((phy_id<<8) + location, ioaddr + MII_Addr);
  597. outw(1, ioaddr + MII_Cmd);
  598. for (i = 10000; i >= 0; i--)
  599. if ((inw(ioaddr + MII_Status) & 1) == 0)
  600. break;
  601. return inw(ioaddr + MII_Rd_Data);
  602. }
  604. static void mdio_write(long ioaddr, int phy_id, int location, int value)
  605. {
  606. int i;
  608. outw((phy_id<<8) + location, ioaddr + MII_Addr);
  609. outw(value, ioaddr + MII_Wr_Data);
  611. /* Wait for the command to finish. */
  612. for (i = 10000; i >= 0; i--)
  613. if ((inw(ioaddr + MII_Status) & 1) == 0)
  614. break;
  615. return;
  616. }
  619. static int yellowfin_open(struct net_device *dev)
  620. {
  621. struct yellowfin_private *yp = dev->priv;
  622. long ioaddr = dev->base_addr;
  623. int i;
  625. /* Reset the chip. */
  626. outl(0x80000000, ioaddr + DMACtrl);
  628. i = request_irq(dev->irq, &yellowfin_interrupt, SA_SHIRQ, dev->name, dev);
  629. if (i) return i;
  631. if (yellowfin_debug > 1)
  632. printk(KERN_DEBUG "%s: yellowfin_open() irq %d.n",
  633.    dev->name, dev->irq);
  635. yellowfin_init_ring(dev);
  637. outl(yp->rx_ring_dma, ioaddr + RxPtr);
  638. outl(yp->tx_ring_dma, ioaddr + TxPtr);
  640. for (i = 0; i < 6; i++)
  641. outb(dev->dev_addr[i], ioaddr + StnAddr + i);
  643. /* Set up various condition 'select' registers.
  644.    There are no options here. */
  645. outl(0x00800080, ioaddr + TxIntrSel);  /* Interrupt on Tx abort */
  646. outl(0x00800080, ioaddr + TxBranchSel); /* Branch on Tx abort */
  647. outl(0x00400040, ioaddr + TxWaitSel);  /* Wait on Tx status */
  648. outl(0x00400040, ioaddr + RxIntrSel); /* Interrupt on Rx done */
  649. outl(0x00400040, ioaddr + RxBranchSel); /* Branch on Rx error */
  650. outl(0x00400040, ioaddr + RxWaitSel); /* Wait on Rx done */
  652. /* Initialize other registers: with so many this eventually this will
  653.    converted to an offset/value list. */
  654. outl(dma_ctrl, ioaddr + DMACtrl);
  655. outw(fifo_cfg, ioaddr + FIFOcfg);
  656. /* Enable automatic generation of flow control frames, period 0xffff. */
  657. outl(0x0030FFFF, ioaddr + FlowCtrl);
  659. yp->tx_threshold = 32;
  660. outl(yp->tx_threshold, ioaddr + TxThreshold);
  662. if (dev->if_port == 0)
  663. dev->if_port = yp->default_port;
  665. netif_start_queue(dev);
  667. /* Setting the Rx mode will start the Rx process. */
  668. if (yp->drv_flags & IsGigabit) {
  669. /* We are always in full-duplex mode with gigabit! */
  670. yp->full_duplex = 1;
  671. outw(0x01CF, ioaddr + Cnfg);
  672. } else {
  673. outw(0x0018, ioaddr + FrameGap0); /* 0060/4060 for non-MII 10baseT */
  674. outw(0x1018, ioaddr + FrameGap1);
  675. outw(0x101C | (yp->full_duplex ? 2 : 0), ioaddr + Cnfg);
  676. }
  677. set_rx_mode(dev);
  679. /* Enable interrupts by setting the interrupt mask. */
  680. outw(0x81ff, ioaddr + IntrEnb); /* See enum intr_status_bits */
  681. outw(0x0000, ioaddr + EventStatus); /* Clear non-interrupting events */
  682. outl(0x80008000, ioaddr + RxCtrl); /* Start Rx and Tx channels. */
  683. outl(0x80008000, ioaddr + TxCtrl);
  685. if (yellowfin_debug > 2) {
  686. printk(KERN_DEBUG "%s: Done yellowfin_open().n",
  687.    dev->name);
  688. }
  690. /* Set the timer to check for link beat. */
  691. init_timer(&yp->timer);
  692. yp->timer.expires = jiffies + 3*HZ;
  693. yp->timer.data = (unsigned long)dev;
  694. yp->timer.function = &yellowfin_timer; /* timer handler */
  695. add_timer(&yp->timer);
  697. return 0;
  698. }
  700. static void yellowfin_timer(unsigned long data)
  701. {
  702. struct net_device *dev = (struct net_device *)data;
  703. struct yellowfin_private *yp = dev->priv;
  704. long ioaddr = dev->base_addr;
  705. int next_tick = 60*HZ;
  707. if (yellowfin_debug > 3) {
  708. printk(KERN_DEBUG "%s: Yellowfin timer tick, status %8.8x.n",
  709.    dev->name, inw(ioaddr + IntrStatus));
  710. }
  712. if (yp->mii_cnt) {
  713. int bmsr = mdio_read(ioaddr, yp->phys[0], MII_BMSR);
  714. int lpa = mdio_read(ioaddr, yp->phys[0], MII_LPA);
  715. int negotiated = lpa & yp->advertising;
  716. if (yellowfin_debug > 1)
  717. printk(KERN_DEBUG "%s: MII #%d status register is %4.4x, "
  718.    "link partner capability %4.4x.n",
  719.    dev->name, yp->phys[0], bmsr, lpa);
  721. yp->full_duplex = mii_duplex(yp->duplex_lock, negotiated);
  723. outw(0x101C | (yp->full_duplex ? 2 : 0), ioaddr + Cnfg);
  725. if (bmsr & BMSR_LSTATUS)
  726. next_tick = 60*HZ;
  727. else
  728. next_tick = 3*HZ;
  729. }
  731. yp->timer.expires = jiffies + next_tick;
  732. add_timer(&yp->timer);
  733. }
  735. static void yellowfin_tx_timeout(struct net_device *dev)
  736. {
  737. struct yellowfin_private *yp = dev->priv;
  738. long ioaddr = dev->base_addr;
  740. printk(KERN_WARNING "%s: Yellowfin transmit timed out at %d/%d Tx "
  741.    "status %4.4x, Rx status %4.4x, resetting...n",
  742.    dev->name, yp->cur_tx, yp->dirty_tx,
  743.    inl(ioaddr + TxStatus), inl(ioaddr + RxStatus));
  745. /* Note: these should be KERN_DEBUG. */
  746. if (yellowfin_debug) {
  747. int i;
  748. printk(KERN_WARNING "  Rx ring %p: ", yp->rx_ring);
  749. for (i = 0; i < RX_RING_SIZE; i++)
  750. printk(" %8.8x", yp->rx_ring[i].result_status);
  751. printk("n"KERN_WARNING"  Tx ring %p: ", yp->tx_ring);
  752. for (i = 0; i < TX_RING_SIZE; i++)
  753. printk(" %4.4x /%8.8x", yp->tx_status[i].tx_errs,
  754.    yp->tx_ring[i].result_status);
  755. printk("n");
  756. }
  758. /* If the hardware is found to hang regularly, we will update the code
  759.    to reinitialize the chip here. */
  760. dev->if_port = 0;
  762. /* Wake the potentially-idle transmit channel. */
  763. outl(0x10001000, dev->base_addr + TxCtrl);
  764. if (yp->cur_tx - yp->dirty_tx < TX_QUEUE_SIZE)
  765. netif_wake_queue (dev); /* Typical path */
  767. dev->trans_start = jiffies;
  768. yp->stats.tx_errors++;
  769. }
  771. /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
  772. static void yellowfin_init_ring(struct net_device *dev)
  773. {
  774. struct yellowfin_private *yp = dev->priv;
  775. int i;
  777. yp->tx_full = 0;
  778. yp->cur_rx = yp->cur_tx = 0;
  779. yp->dirty_tx = 0;
  781. yp->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
  783. for (i = 0; i < RX_RING_SIZE; i++) {
  784. yp->rx_ring[i].dbdma_cmd =
  785. cpu_to_le32(CMD_RX_BUF | INTR_ALWAYS | yp->rx_buf_sz);
  786. yp->rx_ring[i].branch_addr = cpu_to_le32(yp->rx_ring_dma +
  787. ((i+1)%RX_RING_SIZE)*sizeof(struct yellowfin_desc));
  788. }
  790. for (i = 0; i < RX_RING_SIZE; i++) {
  791. struct sk_buff *skb = dev_alloc_skb(yp->rx_buf_sz);
  792. yp->rx_skbuff[i] = skb;
  793. if (skb == NULL)
  794. break;
  795. skb->dev = dev; /* Mark as being used by this device. */
  796. skb_reserve(skb, 2); /* 16 byte align the IP header. */
  797. yp->rx_ring[i].addr = cpu_to_le32(pci_map_single(yp->pci_dev,
  798. skb->tail, yp->rx_buf_sz, PCI_DMA_FROMDEVICE));
  799. }
  800. yp->rx_ring[i-1].dbdma_cmd = cpu_to_le32(CMD_STOP);
  801. yp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
  803. #define NO_TXSTATS
  804. #ifdef NO_TXSTATS
  805. /* In this mode the Tx ring needs only a single descriptor. */
  806. for (i = 0; i < TX_RING_SIZE; i++) {
  807. yp->tx_skbuff[i] = 0;
  808. yp->tx_ring[i].dbdma_cmd = cpu_to_le32(CMD_STOP);
  809. yp->tx_ring[i].branch_addr = cpu_to_le32(yp->tx_ring_dma +
  810. ((i+1)%TX_RING_SIZE)*sizeof(struct yellowfin_desc));
  811. }
  812. /* Wrap ring */
  813. yp->tx_ring[--i].dbdma_cmd = cpu_to_le32(CMD_STOP | BRANCH_ALWAYS);
  814. #else
  815. {
  816. int j;
  818. /* Tx ring needs a pair of descriptors, the second for the status. */
  819. for (i = 0; i < TX_RING_SIZE; i++) {
  820. j = 2*i;
  821. yp->tx_skbuff[i] = 0;
  822. /* Branch on Tx error. */
  823. yp->tx_ring[j].dbdma_cmd = cpu_to_le32(CMD_STOP);
  824. yp->tx_ring[j].branch_addr = cpu_to_le32(yp->tx_ring_dma +
  825. (j+1)*sizeof(struct yellowfin_desc);
  826. j++;
  827. if (yp->flags & FullTxStatus) {
  828. yp->tx_ring[j].dbdma_cmd =
  829. cpu_to_le32(CMD_TXSTATUS | sizeof(*yp->tx_status));
  830. yp->tx_ring[j].request_cnt = sizeof(*yp->tx_status);
  831. yp->tx_ring[j].addr = cpu_to_le32(yp->tx_status_dma +
  832. i*sizeof(struct tx_status_words);
  833. } else {
  834. /* Symbios chips write only tx_errs word. */
  835. yp->tx_ring[j].dbdma_cmd =
  836. cpu_to_le32(CMD_TXSTATUS | INTR_ALWAYS | 2);
  837. yp->tx_ring[j].request_cnt = 2;
  838. /* Om pade ummmmm... */
  839. yp->tx_ring[j].addr = cpu_to_le32(yp->tx_status_dma +
  840. i*sizeof(struct tx_status_words) +
  841. &(yp->tx_status[0].tx_errs) - 
  842. &(yp->tx_status[0]));
  843. }
  844. yp->tx_ring[j].branch_addr = cpu_to_le32(yp->tx_ring_dma + 
  845. ((j+1)%(2*TX_RING_SIZE))*sizeof(struct yellowfin_desc));
  846. }
  847. /* Wrap ring */
  848. yp->tx_ring[++j].dbdma_cmd |= cpu_to_le32(BRANCH_ALWAYS | INTR_ALWAYS);
  849. }
  850. #endif
  851. yp->tx_tail_desc = &yp->tx_status[0];
  852. return;
  853. }
  855. static int yellowfin_start_xmit(struct sk_buff *skb, struct net_device *dev)
  856. {
  857. struct yellowfin_private *yp = dev->priv;
  858. unsigned entry;
  860. netif_stop_queue (dev);
  862. /* Note: Ordering is important here, set the field with the
  863.    "ownership" bit last, and only then increment cur_tx. */
  865. /* Calculate the next Tx descriptor entry. */
  866. entry = yp->cur_tx % TX_RING_SIZE;
  868. yp->tx_skbuff[entry] = skb;
  870. if (gx_fix) { /* Note: only works for paddable protocols e.g.  IP. */
  871. int cacheline_end = ((unsigned long)skb->data + skb->len) % 32;
  872. /* Fix GX chipset errata. */
  873. if (cacheline_end > 24  || cacheline_end == 0)
  874. skb->len += 32 - cacheline_end + 1;
  875. }
  876. #ifdef NO_TXSTATS
  877. yp->tx_ring[entry].addr = cpu_to_le32(pci_map_single(yp->pci_dev, 
  878. skb->data, skb->len, PCI_DMA_TODEVICE));
  879. yp->tx_ring[entry].result_status = 0;
  880. if (entry >= TX_RING_SIZE-1) {
  881. /* New stop command. */
  882. yp->tx_ring[0].dbdma_cmd = cpu_to_le32(CMD_STOP);
  883. yp->tx_ring[TX_RING_SIZE-1].dbdma_cmd =
  884. cpu_to_le32(CMD_TX_PKT|BRANCH_ALWAYS | skb->len);
  885. } else {
  886. yp->tx_ring[entry+1].dbdma_cmd = cpu_to_le32(CMD_STOP);
  887. yp->tx_ring[entry].dbdma_cmd =
  888. cpu_to_le32(CMD_TX_PKT | BRANCH_IFTRUE | skb->len);
  889. }
  890. yp->cur_tx++;
  891. #else
  892. yp->tx_ring[entry<<1].request_cnt = skb->len;
  893. yp->tx_ring[entry<<1].addr = cpu_to_le32(pci_map_single(yp->pci_dev, 
  894. skb->data, skb->len, PCI_DMA_TODEVICE));
  895. /* The input_last (status-write) command is constant, but we must 
  896.    rewrite the subsequent 'stop' command. */
  898. yp->cur_tx++;
  899. {
  900. unsigned next_entry = yp->cur_tx % TX_RING_SIZE;
  901. yp->tx_ring[next_entry<<1].dbdma_cmd = cpu_to_le32(CMD_STOP);
  902. }
  903. /* Final step -- overwrite the old 'stop' command. */
  905. yp->tx_ring[entry<<1].dbdma_cmd =
  906. cpu_to_le32( ((entry % 6) == 0 ? CMD_TX_PKT|INTR_ALWAYS|BRANCH_IFTRUE :
  907.   CMD_TX_PKT | BRANCH_IFTRUE) | skb->len);
  908. #endif
  910. /* Non-x86 Todo: explicitly flush cache lines here. */
  912. /* Wake the potentially-idle transmit channel. */
  913. outl(0x10001000, dev->base_addr + TxCtrl);
  915. if (yp->cur_tx - yp->dirty_tx < TX_QUEUE_SIZE)
  916. netif_start_queue (dev); /* Typical path */
  917. else
  918. yp->tx_full = 1;
  919. dev->trans_start = jiffies;
  921. if (yellowfin_debug > 4) {
  922. printk(KERN_DEBUG "%s: Yellowfin transmit frame #%d queued in slot %d.n",
  923.    dev->name, yp->cur_tx, entry);
  924. }
  925. return 0;
  926. }
  928. /* The interrupt handler does all of the Rx thread work and cleans up
  929.    after the Tx thread. */
  930. static void yellowfin_interrupt(int irq, void *dev_instance, struct pt_regs *regs)
  931. {
  932. struct net_device *dev = dev_instance;
  933. struct yellowfin_private *yp;
  934. long ioaddr;
  935. int boguscnt = max_interrupt_work;
  937. #ifndef final_version /* Can never occur. */
  938. if (dev == NULL) {
  939. printk (KERN_ERR "yellowfin_interrupt(): irq %d for unknown device.n", irq);
  940. return;
  941. }
  942. #endif
  944. ioaddr = dev->base_addr;
  945. yp = dev->priv;
  947. spin_lock (&yp->lock);
  949. do {
  950. u16 intr_status = inw(ioaddr + IntrClear);
  952. if (yellowfin_debug > 4)
  953. printk(KERN_DEBUG "%s: Yellowfin interrupt, status %4.4x.n",
  954.    dev->name, intr_status);
  956. if (intr_status == 0)
  957. break;
  959. if (intr_status & (IntrRxDone | IntrEarlyRx)) {
  960. yellowfin_rx(dev);
  961. outl(0x10001000, ioaddr + RxCtrl); /* Wake Rx engine. */
  962. }
  964. #ifdef NO_TXSTATS
  965. for (; yp->cur_tx - yp->dirty_tx > 0; yp->dirty_tx++) {
  966. int entry = yp->dirty_tx % TX_RING_SIZE;
  967. struct sk_buff *skb;
  969. if (yp->tx_ring[entry].result_status == 0)
  970. break;
  971. skb = yp->tx_skbuff[entry];
  972. yp->stats.tx_packets++;
  973. yp->stats.tx_bytes += skb->len;
  974. /* Free the original skb. */
  975. pci_unmap_single(yp->pci_dev, yp->tx_ring[entry].addr,
  976. skb->len, PCI_DMA_TODEVICE);
  977. dev_kfree_skb_irq(skb);
  978. yp->tx_skbuff[entry] = 0;
  979. }
  980. if (yp->tx_full
  981. && yp->cur_tx - yp->dirty_tx < TX_QUEUE_SIZE - 4) {
  982. /* The ring is no longer full, clear tbusy. */
  983. yp->tx_full = 0;
  984. netif_wake_queue(dev);
  985. }
  986. #else
  987. if ((intr_status & IntrTxDone) || (yp->tx_tail_desc->tx_errs)) {
  988. unsigned dirty_tx = yp->dirty_tx;
  990. for (dirty_tx = yp->dirty_tx; yp->cur_tx - dirty_tx > 0;
  991.  dirty_tx++) {
  992. /* Todo: optimize this. */
  993. int entry = dirty_tx % TX_RING_SIZE;
  994. u16 tx_errs = yp->tx_status[entry].tx_errs;
  995. struct sk_buff *skb;
  997. #ifndef final_version
  998. if (yellowfin_debug > 5)
  999. printk(KERN_DEBUG "%s: Tx queue %d check, Tx status "
  1000.    "%4.4x %4.4x %4.4x %4.4x.n",
  1001.    dev->name, entry,
  1002.    yp->tx_status[entry].tx_cnt,
  1003.    yp->tx_status[entry].tx_errs,
  1004.    yp->tx_status[entry].total_tx_cnt,
  1005.    yp->tx_status[entry].paused);
  1006. #endif
  1007. if (tx_errs == 0)
  1008. break; /* It still hasn't been Txed */
  1009. skb = yp->tx_skbuff[entry];
  1010. if (tx_errs & 0xF810) {
  1011. /* There was an major error, log it. */
  1012. #ifndef final_version
  1013. if (yellowfin_debug > 1)
  1014. printk(KERN_DEBUG "%s: Transmit error, Tx status %4.4x.n",
  1015.    dev->name, tx_errs);
  1016. #endif
  1017. yp->stats.tx_errors++;
  1018. if (tx_errs & 0xF800) yp->stats.tx_aborted_errors++;
  1019. if (tx_errs & 0x0800) yp->stats.tx_carrier_errors++;
  1020. if (tx_errs & 0x2000) yp->stats.tx_window_errors++;
  1021. if (tx_errs & 0x8000) yp->stats.tx_fifo_errors++;
  1022. #ifdef ETHER_STATS
  1023. if (tx_errs & 0x1000) yp->stats.collisions16++;
  1024. #endif
  1025. } else {
  1026. #ifndef final_version
  1027. if (yellowfin_debug > 4)
  1028. printk(KERN_DEBUG "%s: Normal transmit, Tx status %4.4x.n",
  1029.    dev->name, tx_errs);
  1030. #endif
  1031. #ifdef ETHER_STATS
  1032. if (tx_errs & 0x0400) yp->stats.tx_deferred++;
  1033. #endif
  1034. yp->stats.tx_bytes += skb->len;
  1035. yp->stats.collisions += tx_errs & 15;
  1036. yp->stats.tx_packets++;
  1037. }
  1038. /* Free the original skb. */
  1039. pci_unmap_single(yp->pci_dev, 
  1040. yp->tx_ring[entry<<1].addr, skb->len, 
  1041. PCI_DMA_TODEVICE);
  1042. dev_kfree_skb_irq(skb);
  1043. yp->tx_skbuff[entry] = 0;
  1044. /* Mark status as empty. */
  1045. yp->tx_status[entry].tx_errs = 0;
  1046. }
  1048. #ifndef final_version
  1049. if (yp->cur_tx - dirty_tx > TX_RING_SIZE) {
  1050. printk(KERN_ERR "%s: Out-of-sync dirty pointer, %d vs. %d, full=%d.n",
  1051.    dev->name, dirty_tx, yp->cur_tx, yp->tx_full);
  1052. dirty_tx += TX_RING_SIZE;
  1053. }
  1054. #endif
  1056. if (yp->tx_full
  1057. && yp->cur_tx - dirty_tx < TX_QUEUE_SIZE - 2) {
  1058. /* The ring is no longer full, clear tbusy. */
  1059. yp->tx_full = 0;
  1060. netif_wake_queue(dev);
  1061. }
  1063. yp->dirty_tx = dirty_tx;
  1064. yp->tx_tail_desc = &yp->tx_status[dirty_tx % TX_RING_SIZE];
  1065. }
  1066. #endif
  1068. /* Log errors and other uncommon events. */
  1069. if (intr_status & 0x2ee) /* Abnormal error summary. */
  1070. yellowfin_error(dev, intr_status);
  1072. if (--boguscnt < 0) {
  1073. printk(KERN_WARNING "%s: Too much work at interrupt, "
  1074.    "status=0x%4.4x.n",
  1075.    dev->name, intr_status);
  1076. break;
  1077. }
  1078. } while (1);
  1080. if (yellowfin_debug > 3)
  1081. printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.n",
  1082.    dev->name, inw(ioaddr + IntrStatus));
  1084. spin_unlock (&yp->lock);
  1085. return;
  1086. }
  1088. /* This routine is logically part of the interrupt handler, but separated
  1089.    for clarity and better register allocation. */
  1090. static int yellowfin_rx(struct net_device *dev)
  1091. {
  1092. struct yellowfin_private *yp = dev->priv;
  1093. int entry = yp->cur_rx % RX_RING_SIZE;
  1094. int boguscnt = yp->dirty_rx + RX_RING_SIZE - yp->cur_rx;
  1096. if (yellowfin_debug > 4) {
  1097. printk(KERN_DEBUG " In yellowfin_rx(), entry %d status %8.8x.n",
  1098.    entry, yp->rx_ring[entry].result_status);
  1099. printk(KERN_DEBUG "   #%d desc. %8.8x %8.8x %8.8x.n",
  1100.    entry, yp->rx_ring[entry].dbdma_cmd, yp->rx_ring[entry].addr,
  1101.    yp->rx_ring[entry].result_status);
  1102. }
  1104. /* If EOP is set on the next entry, it's a new packet. Send it up. */
  1105. while (1) {
  1106. struct yellowfin_desc *desc = &yp->rx_ring[entry];
  1107. struct sk_buff *rx_skb = yp->rx_skbuff[entry];
  1108. s16 frame_status;
  1109. u16 desc_status;
  1110. int data_size;
  1111. u8 *buf_addr;
  1113. if(!desc->result_status)
  1114. break;
  1115. pci_dma_sync_single(yp->pci_dev, desc->addr, 
  1116. yp->rx_buf_sz, PCI_DMA_FROMDEVICE);
  1117. desc_status = le32_to_cpu(desc->result_status) >> 16;
  1118. buf_addr = rx_skb->tail;
  1119. data_size = (le32_to_cpu(desc->dbdma_cmd) - 
  1120. le32_to_cpu(desc->result_status)) & 0xffff;
  1121. frame_status = le16_to_cpu(get_unaligned((s16*)&(buf_addr[data_size - 2])));
  1122. if (yellowfin_debug > 4)
  1123. printk(KERN_DEBUG "  yellowfin_rx() status was %4.4x.n",
  1124.    frame_status);
  1125. if (--boguscnt < 0)
  1126. break;
  1127. if ( ! (desc_status & RX_EOP)) {
  1128. printk(KERN_WARNING "%s: Oversized Ethernet frame spanned multiple buffers,"
  1129.    " status %4.4x!n", dev->name, desc_status);
  1130. yp->stats.rx_length_errors++;
  1131. } else if ((yp->drv_flags & IsGigabit)  &&  (frame_status & 0x0038)) {
  1132. /* There was a error. */
  1133. if (yellowfin_debug > 3)
  1134. printk(KERN_DEBUG "  yellowfin_rx() Rx error was %4.4x.n",
  1135.    frame_status);
  1136. yp->stats.rx_errors++;
  1137. if (frame_status & 0x0060) yp->stats.rx_length_errors++;
  1138. if (frame_status & 0x0008) yp->stats.rx_frame_errors++;
  1139. if (frame_status & 0x0010) yp->stats.rx_crc_errors++;
  1140. if (frame_status < 0) yp->stats.rx_dropped++;
  1141. } else if ( !(yp->drv_flags & IsGigabit)  &&
  1142.    ((buf_addr[data_size-1] & 0x85) || buf_addr[data_size-2] & 0xC0)) {
  1143. u8 status1 = buf_addr[data_size-2];
  1144. u8 status2 = buf_addr[data_size-1];
  1145. yp->stats.rx_errors++;
  1146. if (status1 & 0xC0) yp->stats.rx_length_errors++;
  1147. if (status2 & 0x03) yp->stats.rx_frame_errors++;
  1148. if (status2 & 0x04) yp->stats.rx_crc_errors++;
  1149. if (status2 & 0x80) yp->stats.rx_dropped++;
  1150. #ifdef YF_PROTOTYPE /* Support for prototype hardware errata. */
  1151. } else if ((yp->flags & HasMACAddrBug)  &&
  1152. memcmp(le32_to_cpu(yp->rx_ring_dma +
  1153. entry*sizeof(struct yellowfin_desc)),
  1154. dev->dev_addr, 6) != 0 && 
  1155. memcmp(le32_to_cpu(yp->rx_ring_dma +
  1156. entry*sizeof(struct yellowfin_desc)),
  1157. "377377377377377377", 6) != 0) {
  1158. if (bogus_rx++ == 0)
  1159. printk(KERN_WARNING "%s: Bad frame to %2.2x:%2.2x:%2.2x:%2.2x:"
  1160.    "%2.2x:%2.2x.n",
  1161.    dev->name, buf_addr[0], buf_addr[1], buf_addr[2],
  1162.    buf_addr[3], buf_addr[4], buf_addr[5]);
  1163. #endif
  1164. } else {
  1165. struct sk_buff *skb;
  1166. int pkt_len = data_size -
  1167. (yp->chip_id ? 7 : 8 + buf_addr[data_size - 8]);
  1168. /* To verify: Yellowfin Length should omit the CRC! */
  1170. #ifndef final_version
  1171. if (yellowfin_debug > 4)
  1172. printk(KERN_DEBUG "  yellowfin_rx() normal Rx pkt length %d"
  1173.    " of %d, bogus_cnt %d.n",
  1174.    pkt_len, data_size, boguscnt);
  1175. #endif
  1176. /* Check if the packet is long enough to just pass up the skbuff
  1177.    without copying to a properly sized skbuff. */
  1178. if (pkt_len > rx_copybreak) {
  1179. skb_put(skb = rx_skb, pkt_len);
  1180. pci_unmap_single(yp->pci_dev, 
  1181. yp->rx_ring[entry].addr, 
  1182. yp->rx_buf_sz, 
  1183. PCI_DMA_FROMDEVICE);
  1184. yp->rx_skbuff[entry] = NULL;
  1185. } else {
  1186. skb = dev_alloc_skb(pkt_len + 2);
  1187. if (skb == NULL)
  1188. break;
  1189. skb->dev = dev;
  1190. skb_reserve(skb, 2); /* 16 byte align the IP header */
  1191. #if HAS_IP_COPYSUM
  1192. eth_copy_and_sum(skb, rx_skb->tail, pkt_len, 0);
  1193. skb_put(skb, pkt_len);
  1194. #else
  1195. memcpy(skb_put(skb, pkt_len), 
  1196. rx_skb->tail, pkt_len);
  1197. #endif
  1198. }
  1199. skb->protocol = eth_type_trans(skb, dev);
  1200. netif_rx(skb);
  1201. dev->last_rx = jiffies;
  1202. yp->stats.rx_packets++;
  1203. yp->stats.rx_bytes += pkt_len;
  1204. }
  1205. entry = (++yp->cur_rx) % RX_RING_SIZE;
  1206. }
  1208. /* Refill the Rx ring buffers. */
  1209. for (; yp->cur_rx - yp->dirty_rx > 0; yp->dirty_rx++) {
  1210. entry = yp->dirty_rx % RX_RING_SIZE;
  1211. if (yp->rx_skbuff[entry] == NULL) {
  1212. struct sk_buff *skb = dev_alloc_skb(yp->rx_buf_sz);
  1213. if (skb == NULL)
  1214. break; /* Better luck next round. */
  1215. yp->rx_skbuff[entry] = skb;
  1216. skb->dev = dev; /* Mark as being used by this device. */
  1217. skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
  1218. yp->rx_ring[entry].addr = cpu_to_le32(pci_map_single(yp->pci_dev,
  1219. skb->tail, yp->rx_buf_sz, PCI_DMA_FROMDEVICE));
  1220. }
  1221. yp->rx_ring[entry].dbdma_cmd = cpu_to_le32(CMD_STOP);
  1222. yp->rx_ring[entry].result_status = 0; /* Clear complete bit. */
  1223. if (entry != 0)
  1224. yp->rx_ring[entry - 1].dbdma_cmd =
  1225. cpu_to_le32(CMD_RX_BUF | INTR_ALWAYS | yp->rx_buf_sz);
  1226. else
  1227. yp->rx_ring[RX_RING_SIZE - 1].dbdma_cmd =
  1228. cpu_to_le32(CMD_RX_BUF | INTR_ALWAYS | BRANCH_ALWAYS
  1229. | yp->rx_buf_sz);
  1230. }
  1232. return 0;
  1233. }
  1235. static void yellowfin_error(struct net_device *dev, int intr_status)
  1236. {
  1237. struct yellowfin_private *yp = dev->priv;
  1239. printk(KERN_ERR "%s: Something Wicked happened! %4.4x.n",
  1240.    dev->name, intr_status);
  1241. /* Hmmmmm, it's not clear what to do here. */
  1242. if (intr_status & (IntrTxPCIErr | IntrTxPCIFault))
  1243. yp->stats.tx_errors++;
  1244. if (intr_status & (IntrRxPCIErr | IntrRxPCIFault))
  1245. yp->stats.rx_errors++;
  1246. }
  1248. static int yellowfin_close(struct net_device *dev)
  1249. {
  1250. long ioaddr = dev->base_addr;
  1251. struct yellowfin_private *yp = dev->priv;
  1252. int i;
  1254. netif_stop_queue (dev);
  1256. if (yellowfin_debug > 1) {
  1257. printk(KERN_DEBUG "%s: Shutting down ethercard, status was Tx %4.4x "
  1258.    "Rx %4.4x Int %2.2x.n",
  1259.    dev->name, inw(ioaddr + TxStatus),
  1260.    inw(ioaddr + RxStatus), inw(ioaddr + IntrStatus));
  1261. printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d,  Rx %d / %d.n",
  1262.    dev->name, yp->cur_tx, yp->dirty_tx, yp->cur_rx, yp->dirty_rx);
  1263. }
  1265. /* Disable interrupts by clearing the interrupt mask. */
  1266. outw(0x0000, ioaddr + IntrEnb);
  1268. /* Stop the chip's Tx and Rx processes. */
  1269. outl(0x80000000, ioaddr + RxCtrl);
  1270. outl(0x80000000, ioaddr + TxCtrl);
  1272. del_timer(&yp->timer);
  1274. #if defined(__i386__)
  1275. if (yellowfin_debug > 2) {
  1276. printk("n"KERN_DEBUG"  Tx ring at %8.8x:n", yp->tx_ring_dma);
  1277. for (i = 0; i < TX_RING_SIZE*2; i++)
  1278. printk(" %c #%d desc. %8.8x %8.8x %8.8x %8.8x.n",
  1279.    inl(ioaddr + TxPtr) == (long)&yp->tx_ring[i] ? '>' : ' ',
  1280.    i, yp->tx_ring[i].dbdma_cmd, yp->tx_ring[i].addr,
  1281.    yp->tx_ring[i].branch_addr, yp->tx_ring[i].result_status);
  1282. printk(KERN_DEBUG "  Tx status %p:n", yp->tx_status);
  1283. for (i = 0; i < TX_RING_SIZE; i++)
  1284. printk("   #%d status %4.4x %4.4x %4.4x %4.4x.n",
  1285.    i, yp->tx_status[i].tx_cnt, yp->tx_status[i].tx_errs,
  1286.    yp->tx_status[i].total_tx_cnt, yp->tx_status[i].paused);
  1288. printk("n"KERN_DEBUG "  Rx ring %8.8x:n", yp->rx_ring_dma);
  1289. for (i = 0; i < RX_RING_SIZE; i++) {
  1290. printk(KERN_DEBUG " %c #%d desc. %8.8x %8.8x %8.8xn",
  1291.    inl(ioaddr + RxPtr) == (long)&yp->rx_ring[i] ? '>' : ' ',
  1292.    i, yp->rx_ring[i].dbdma_cmd, yp->rx_ring[i].addr,
  1293.    yp->rx_ring[i].result_status);
  1294. if (yellowfin_debug > 6) {
  1295. if (get_unaligned((u8*)yp->rx_ring[i].addr) != 0x69) {
  1296. int j;
  1297. for (j = 0; j < 0x50; j++)
  1298. printk(" %4.4x",
  1299.    get_unaligned(((u16*)yp->rx_ring[i].addr) + j));
  1300. printk("n");
  1301. }
  1302. }
  1303. }
  1304. }
  1305. #endif /* __i386__ debugging only */
  1307. free_irq(dev->irq, dev);
  1309. /* Free all the skbuffs in the Rx queue. */
  1310. for (i = 0; i < RX_RING_SIZE; i++) {
  1311. yp->rx_ring[i].dbdma_cmd = cpu_to_le32(CMD_STOP);
  1312. yp->rx_ring[i].addr = 0xBADF00D0; /* An invalid address. */
  1313. if (yp->rx_skbuff[i]) {
  1314. dev_kfree_skb(yp->rx_skbuff[i]);
  1315. }
  1316. yp->rx_skbuff[i] = 0;
  1317. }
  1318. for (i = 0; i < TX_RING_SIZE; i++) {
  1319. if (yp->tx_skbuff[i])
  1320. dev_kfree_skb(yp->tx_skbuff[i]);
  1321. yp->tx_skbuff[i] = 0;
  1322. }
  1324. #ifdef YF_PROTOTYPE /* Support for prototype hardware errata. */
  1325. if (yellowfin_debug > 0) {
  1326. printk(KERN_DEBUG "%s: Received %d frames that we should not have.n",
  1327.    dev->name, bogus_rx);
  1328. }
  1329. #endif
  1331. return 0;
  1332. }
  1334. static struct net_device_stats *yellowfin_get_stats(struct net_device *dev)
  1335. {
  1336. struct yellowfin_private *yp = dev->priv;
  1337. return &yp->stats;
  1338. }
  1340. /* Set or clear the multicast filter for this adaptor. */
  1342. /* The little-endian AUTODIN32 ethernet CRC calculation.
  1343.    N.B. Do not use for bulk data, use a table-based routine instead.
  1344.    This is common code and should be moved to net/core/crc.c */
  1345. static unsigned const ethernet_polynomial_le = 0xedb88320U;
  1347. static inline unsigned ether_crc_le(int length, unsigned char *data)
  1348. {
  1349. unsigned int crc = 0xffffffff; /* Initial value. */
  1350. while(--length >= 0) {
  1351. unsigned char current_octet = *data++;
  1352. int bit;
  1353. for (bit = 8; --bit >= 0; current_octet >>= 1) {
  1354. if ((crc ^ current_octet) & 1) {
  1355. crc >>= 1;
  1356. crc ^= ethernet_polynomial_le;
  1357. } else
  1358. crc >>= 1;
  1359. }
  1360. }
  1361. return crc;
  1362. }
  1365. static void set_rx_mode(struct net_device *dev)
  1366. {
  1367. struct yellowfin_private *yp = dev->priv;
  1368. long ioaddr = dev->base_addr;
  1369. u16 cfg_value = inw(ioaddr + Cnfg);
  1371. /* Stop the Rx process to change any value. */
  1372. outw(cfg_value & ~0x1000, ioaddr + Cnfg);
  1373. if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
  1374. /* Unconditionally log net taps. */
  1375. printk(KERN_NOTICE "%s: Promiscuous mode enabled.n", dev->name);
  1376. outw(0x000F, ioaddr + AddrMode);
  1377. } else if ((dev->mc_count > 64)  ||  (dev->flags & IFF_ALLMULTI)) {
  1378. /* Too many to filter well, or accept all multicasts. */
  1379. outw(0x000B, ioaddr + AddrMode);
  1380. } else if (dev->mc_count > 0) { /* Must use the multicast hash table. */
  1381. struct dev_mc_list *mclist;
  1382. u16 hash_table[4];
  1383. int i;
  1384. memset(hash_table, 0, sizeof(hash_table));
  1385. for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
  1386.  i++, mclist = mclist->next) {
  1387. /* Due to a bug in the early chip versions, multiple filter
  1388.    slots must be set for each address. */
  1389. if (yp->drv_flags & HasMulticastBug) {
  1390. set_bit((ether_crc_le(3, mclist->dmi_addr) >> 3) & 0x3f,
  1391. hash_table);
  1392. set_bit((ether_crc_le(4, mclist->dmi_addr) >> 3) & 0x3f,
  1393. hash_table);
  1394. set_bit((ether_crc_le(5, mclist->dmi_addr) >> 3) & 0x3f,
  1395. hash_table);
  1396. }
  1397. set_bit((ether_crc_le(6, mclist->dmi_addr) >> 3) & 0x3f,
  1398. hash_table);
  1399. }
  1400. /* Copy the hash table to the chip. */
  1401. for (i = 0; i < 4; i++)
  1402. outw(hash_table[i], ioaddr + HashTbl + i*2);
  1403. outw(0x0003, ioaddr + AddrMode);
  1404. } else { /* Normal, unicast/broadcast-only mode. */
  1405. outw(0x0001, ioaddr + AddrMode);
  1406. }
  1407. /* Restart the Rx process. */
  1408. outw(cfg_value | 0x1000, ioaddr + Cnfg);
  1409. }
  1411. static int netdev_ethtool_ioctl(struct net_device *dev, void *useraddr)
  1412. {
  1413. struct yellowfin_private *np = dev->priv;
  1414. u32 ethcmd;
  1416. if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
  1417. return -EFAULT;
  1419.         switch (ethcmd) {
  1420.         case ETHTOOL_GDRVINFO: {
  1421. struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
  1422. strcpy(info.driver, DRV_NAME);
  1423. strcpy(info.version, DRV_VERSION);
  1424. strcpy(info.bus_info, np->pci_dev->slot_name);
  1425. if (copy_to_user(useraddr, &info, sizeof(info)))
  1426. return -EFAULT;
  1427. return 0;
  1428. }
  1430.         }
  1432. return -EOPNOTSUPP;
  1433. }
  1435. static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  1436. {
  1437. struct yellowfin_private *np = dev->priv;
  1438. long ioaddr = dev->base_addr;
  1439. struct mii_ioctl_data *data = (struct mii_ioctl_data *)&rq->ifr_data;
  1441. switch(cmd) {
  1442. case SIOCETHTOOL:
  1443. return netdev_ethtool_ioctl(dev, (void *) rq->ifr_data);
  1444. case SIOCGMIIPHY: /* Get address of MII PHY in use. */
  1445. case SIOCDEVPRIVATE: /* for binary compat, remove in 2.5 */
  1446. data->phy_id = np->phys[0] & 0x1f;
  1447. /* Fall Through */
  1449. case SIOCGMIIREG: /* Read MII PHY register. */
  1450. case SIOCDEVPRIVATE+1: /* for binary compat, remove in 2.5 */
  1451. data->val_out = mdio_read(ioaddr, data->phy_id & 0x1f, data->reg_num & 0x1f);
  1452. return 0;
  1454. case SIOCSMIIREG: /* Write MII PHY register. */
  1455. case SIOCDEVPRIVATE+2: /* for binary compat, remove in 2.5 */
  1456. if (!capable(CAP_NET_ADMIN))
  1457. return -EPERM;
  1458. if (data->phy_id == np->phys[0]) {
  1459. u16 value = data->val_in;
  1460. switch (data->reg_num) {
  1461. case 0:
  1462. /* Check for autonegotiation on or reset. */
  1463. np->medialock = (value & 0x9000) ? 0 : 1;
  1464. if (np->medialock)
  1465. np->full_duplex = (value & 0x0100) ? 1 : 0;
  1466. break;
  1467. case 4: np->advertising = value; break;
  1468. }
  1469. /* Perhaps check_duplex(dev), depending on chip semantics. */
  1470. }
  1471. mdio_write(ioaddr, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
  1472. return 0;
  1473. default:
  1474. return -EOPNOTSUPP;
  1475. }
  1476. }
  1479. static void __devexit yellowfin_remove_one (struct pci_dev *pdev)
  1480. {
  1481. struct net_device *dev = pci_get_drvdata(pdev);
  1482. struct yellowfin_private *np;
  1484. if (!dev)
  1485. BUG();
  1486. np = dev->priv;
  1488.         pci_free_consistent(pdev, STATUS_TOTAL_SIZE, np->tx_status, 
  1489. np->tx_status_dma);
  1490. pci_free_consistent(pdev, RX_TOTAL_SIZE, np->rx_ring, np->rx_ring_dma);
  1491. pci_free_consistent(pdev, TX_TOTAL_SIZE, np->tx_ring, np->tx_ring_dma);
  1492. unregister_netdev (dev);
  1494. pci_release_regions (pdev);
  1496. #ifndef USE_IO_OPS
  1497. iounmap ((void *) dev->base_addr);
  1498. #endif
  1500. kfree (dev);
  1501. pci_set_drvdata(pdev, NULL);
  1502. }
  1505. static struct pci_driver yellowfin_driver = {
  1506. name: DRV_NAME,
  1507. id_table: yellowfin_pci_tbl,
  1508. probe: yellowfin_init_one,
  1509. remove: __devexit_p(yellowfin_remove_one),
  1510. };
  1513. static int __init yellowfin_init (void)
  1514. {
  1515. /* when a module, this is printed whether or not devices are found in probe */
  1516. #ifdef MODULE
  1517. printk(version);
  1518. #endif
  1519. return pci_module_init (&yellowfin_driver);
  1520. }
  1523. static void __exit yellowfin_cleanup (void)
  1524. {
  1525. pci_unregister_driver (&yellowfin_driver);
  1526. }
  1529. module_init(yellowfin_init);
  1530. module_exit(yellowfin_cleanup);
  1532. /*
  1533.  * Local variables:
  1534.  *  compile-command: "gcc -DMODULE -Wall -Wstrict-prototypes -O6 -c yellowfin.c"
  1535.  *  compile-command-alphaLX: "gcc -DMODULE -Wall -Wstrict-prototypes -O2 -c yellowfin.c -fomit-frame-pointer -fno-strength-reduce -mno-fp-regs -Wa,-m21164a -DBWX_USABLE -DBWIO_ENABLED"
  1536.  *  simple-compile-command: "gcc -DMODULE -O6 -c yellowfin.c"
  1537.  *  c-indent-level: 4
  1538.  *  c-basic-offset: 4
  1539.  *  tab-width: 4
  1540.  * End:
  1541.  */