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

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

嵌入式Linux

开发平台：

Unix_Linux

starfire.c：源码内容
  1. /* starfire.c: Linux device driver for the Adaptec Starfire network adapter. */
  2. /*
  3. Written 1998-2000 by Donald Becker.
  5. Current maintainer is Ion Badulescu <ionut@cs.columbia.edu>. Please
  6. send all bug reports to me, and not to Donald Becker, as this code
  7. has been modified quite a bit from Donald's original version.
  9. This software may be used and distributed according to the terms of
  10. the GNU General Public License (GPL), incorporated herein by reference.
  11. Drivers based on or derived from this code fall under the GPL and must
  12. retain the authorship, copyright and license notice.  This file is not
  13. a complete program and may only be used when the entire operating
  14. system is licensed under the GPL.
  16. The author may be reached as becker@scyld.com, or C/O
  17. Scyld Computing Corporation
  18. 410 Severn Ave., Suite 210
  19. Annapolis MD 21403
  21. Support and updates available at
  22. http://www.scyld.com/network/starfire.html
  24. -----------------------------------------------------------
  26. Linux kernel-specific changes:
  28. LK1.1.1 (jgarzik):
  29. - Use PCI driver interface
  30. - Fix MOD_xxx races
  31. - softnet fixups
  33. LK1.1.2 (jgarzik):
  34. - Merge Becker version 0.15
  36. LK1.1.3 (Andrew Morton)
  37. - Timer cleanups
  39. LK1.1.4 (jgarzik):
  40. - Merge Becker version 1.03
  42. LK1.2.1 (Ion Badulescu <ionut@cs.columbia.edu>)
  43. - Support hardware Rx/Tx checksumming
  44. - Use the GFP firmware taken from Adaptec's Netware driver
  46. LK1.2.2 (Ion Badulescu)
  47. - Backported to 2.2.x
  49. LK1.2.3 (Ion Badulescu)
  50. - Fix the flaky mdio interface
  51. - More compat clean-ups
  53. LK1.2.4 (Ion Badulescu)
  54. - More 2.2.x initialization fixes
  56. LK1.2.5 (Ion Badulescu)
  57. - Several fixes from Manfred Spraul
  59. LK1.2.6 (Ion Badulescu)
  60. - Fixed ifup/ifdown/ifup problem in 2.4.x
  62. LK1.2.7 (Ion Badulescu)
  63. - Removed unused code
  64. - Made more functions static and __init
  66. LK1.2.8 (Ion Badulescu)
  67. - Quell bogus error messages, inform about the Tx threshold
  68. - Removed #ifdef CONFIG_PCI, this driver is PCI only
  70. LK1.2.9 (Ion Badulescu)
  71. - Merged Jeff Garzik's changes from 2.4.4-pre5
  72. - Added 2.2.x compatibility stuff required by the above changes
  74. LK1.2.9a (Ion Badulescu)
  75. - More updates from Jeff Garzik
  77. LK1.3.0 (Ion Badulescu)
  78. - Merged zerocopy support
  80. LK1.3.1 (Ion Badulescu)
  81. - Added ethtool support
  82. - Added GPIO (media change) interrupt support
  84. LK1.3.2 (Ion Badulescu)
  85. - Fixed 2.2.x compatibility issues introduced in 1.3.1
  86. - Fixed ethtool ioctl returning uninitialized memory
  88. LK1.3.3 (Ion Badulescu)
  89. - Initialize the TxMode register properly
  90. - Don't dereference dev->priv after freeing it
  92. LK1.3.4 (Ion Badulescu)
  93. - Fixed initialization timing problems
  94. - Fixed interrupt mask definitions
  96. LK1.3.5 (jgarzik)
  97. - ethtool NWAY_RST, GLINK, [GS]MSGLVL support
  99. TODO:
  100. - implement tx_timeout() properly
  101. */
  103. #define DRV_NAME "starfire"
  104. #define DRV_VERSION "1.03+LK1.3.5"
  105. #define DRV_RELDATE "November 17, 2001"
  107. #include <linux/version.h>
  108. #include <linux/module.h>
  109. #include <linux/kernel.h>
  110. #include <linux/pci.h>
  111. #include <linux/netdevice.h>
  112. #include <linux/etherdevice.h>
  113. #include <linux/init.h>
  114. #include <linux/delay.h>
  115. #include <asm/processor.h> /* Processor type for cache alignment. */
  116. #include <asm/uaccess.h>
  117. #include <asm/io.h>
  119. /*
  120.  * Adaptec's license for their Novell drivers (which is where I got the
  121.  * firmware files) does not allow one to redistribute them. Thus, we can't
  122.  * include the firmware with this driver.
  123.  *
  124.  * However, an end-user is allowed to download and use it, after
  125.  * converting it to C header files using starfire_firmware.pl.
  126.  * Once that's done, the #undef below must be changed into a #define
  127.  * for this driver to really use the firmware. Note that Rx/Tx
  128.  * hardware TCP checksumming is not possible without the firmware.
  129.  *
  130.  * I'm currently [Feb 2001] talking to Adaptec about this redistribution
  131.  * issue. Stay tuned...
  132.  */
  133. #undef HAS_FIRMWARE
  134. /*
  135.  * The current frame processor firmware fails to checksum a fragment
  136.  * of length 1. If and when this is fixed, the #define below can be removed.
  137.  */
  138. #define HAS_BROKEN_FIRMWARE
  139. /*
  140.  * Define this if using the driver with the zero-copy patch
  141.  */
  142. #if defined(HAS_FIRMWARE) && defined(MAX_SKB_FRAGS)
  143. #define ZEROCOPY
  144. #endif
  146. #ifdef HAS_FIRMWARE
  147. #include "starfire_firmware.h"
  148. #endif /* HAS_FIRMWARE */
  150. /* The user-configurable values.
  151.    These may be modified when a driver module is loaded.*/
  153. /* Used for tuning interrupt latency vs. overhead. */
  154. static int interrupt_mitigation;
  156. static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */
  157. static int max_interrupt_work = 20;
  158. static int mtu;
  159. /* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
  160.    The Starfire has a 512 element hash table based on the Ethernet CRC. */
  161. static int multicast_filter_limit = 512;
  163. #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/
  164. /*
  165.  * Set the copy breakpoint for the copy-only-tiny-frames scheme.
  166.  * Setting to > 1518 effectively disables this feature.
  167.  *
  168.  * NOTE:
  169.  * The ia64 doesn't allow for unaligned loads even of integers being
  170.  * misaligned on a 2 byte boundary. Thus always force copying of
  171.  * packets as the starfire doesn't allow for misaligned DMAs ;-(
  172.  * 23/10/2000 - Jes
  173.  *
  174.  * The Alpha and the Sparc don't allow unaligned loads, either. -Ion
  175.  */
  176. #if defined(__ia64__) || defined(__alpha__) || defined(__sparc__)
  177. static int rx_copybreak = PKT_BUF_SZ;
  178. #else
  179. static int rx_copybreak /* = 0 */;
  180. #endif
  182. /* Used to pass the media type, etc.
  183.    Both 'options[]' and 'full_duplex[]' exist for driver interoperability.
  184.    The media type is usually passed in 'options[]'.
  185. */
  186. #define MAX_UNITS 8 /* More are supported, limit only on options */
  187. static int options[MAX_UNITS] = {0, };
  188. static int full_duplex[MAX_UNITS] = {0, };
  190. /* Operational parameters that are set at compile time. */
  192. /* The "native" ring sizes are either 256 or 2048.
  193.    However in some modes a descriptor may be marked to wrap the ring earlier.
  194.    The driver allocates a single page for each descriptor ring, constraining
  195.    the maximum size in an architecture-dependent way.
  196. */
  197. #define RX_RING_SIZE 256
  198. #define TX_RING_SIZE 32
  199. /* The completion queues are fixed at 1024 entries i.e. 4K or 8KB. */
  200. #define DONE_Q_SIZE 1024
  202. /* Operational parameters that usually are not changed. */
  203. /* Time in jiffies before concluding the transmitter is hung. */
  204. #define TX_TIMEOUT (2 * HZ)
  206. #ifdef ZEROCOPY
  207. #if MAX_SKB_FRAGS <= 6
  208. #define MAX_STARFIRE_FRAGS 6
  209. #else  /* MAX_STARFIRE_FRAGS > 6 */
  210. #warning This driver will not work with more than 6 skb fragments.
  211. #warning Turning off zerocopy support.
  212. #undef ZEROCOPY
  213. #endif /* MAX_STARFIRE_FRAGS > 6 */
  214. #endif /* ZEROCOPY */
  216. #ifdef ZEROCOPY
  217. #define skb_first_frag_len(skb) skb_headlen(skb)
  218. #else  /* not ZEROCOPY */
  219. #define skb_first_frag_len(skb) (skb->len)
  220. #endif /* not ZEROCOPY */
  222. /* 2.2.x compatibility code */
  223. #if LINUX_VERSION_CODE < 0x20300
  225. #include "starfire-kcomp22.h"
  227. #else  /* LINUX_VERSION_CODE > 0x20300 */
  229. #include <linux/ethtool.h>
  230. #include <linux/mii.h>
  232. #define COMPAT_MOD_INC_USE_COUNT
  233. #define COMPAT_MOD_DEC_USE_COUNT
  235. #define init_tx_timer(dev, func, timeout) 
  236. dev->tx_timeout = func; 
  237. dev->watchdog_timeo = timeout;
  238. #define kick_tx_timer(dev, func, timeout)
  240. #define netif_start_if(dev)
  241. #define netif_stop_if(dev)
  243. #define PCI_SLOT_NAME(pci_dev) (pci_dev)->slot_name
  245. #endif /* LINUX_VERSION_CODE > 0x20300 */
  246. /* end of compatibility code */
  249. /* These identify the driver base version and may not be removed. */
  250. static char version[] __devinitdata =
  251. KERN_INFO "starfire.c:v1.03 7/26/2000  Written by Donald Becker <becker@scyld.com>n"
  252. KERN_INFO " (unofficial 2.2/2.4 kernel port, version " DRV_VERSION ", " DRV_RELDATE ")n";
  254. MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
  255. MODULE_DESCRIPTION("Adaptec Starfire Ethernet driver");
  256. MODULE_LICENSE("GPL");
  258. MODULE_PARM(max_interrupt_work, "i");
  259. MODULE_PARM(mtu, "i");
  260. MODULE_PARM(debug, "i");
  261. MODULE_PARM(rx_copybreak, "i");
  262. MODULE_PARM(interrupt_mitigation, "i");
  263. MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i");
  264. MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");
  265. MODULE_PARM_DESC(max_interrupt_work, "Starfire maximum events handled per interrupt");
  266. MODULE_PARM_DESC(mtu, "Starfire MTU (all boards)");
  267. MODULE_PARM_DESC(debug, "Starfire debug level (0-6)");
  268. MODULE_PARM_DESC(rx_copybreak, "Starfire copy breakpoint for copy-only-tiny-frames");
  269. MODULE_PARM_DESC(options, "Starfire: Bits 0-3: media type, bit 17: full duplex");
  270. MODULE_PARM_DESC(full_duplex, "Starfire full duplex setting(s) (1)");
  272. /*
  273. Theory of Operation
  275. I. Board Compatibility
  277. This driver is for the Adaptec 6915 "Starfire" 64 bit PCI Ethernet adapter.
  279. II. Board-specific settings
  281. III. Driver operation
  283. IIIa. Ring buffers
  285. The Starfire hardware uses multiple fixed-size descriptor queues/rings.  The
  286. ring sizes are set fixed by the hardware, but may optionally be wrapped
  287. earlier by the END bit in the descriptor.
  288. This driver uses that hardware queue size for the Rx ring, where a large
  289. number of entries has no ill effect beyond increases the potential backlog.
  290. The Tx ring is wrapped with the END bit, since a large hardware Tx queue
  291. disables the queue layer priority ordering and we have no mechanism to
  292. utilize the hardware two-level priority queue.  When modifying the
  293. RX/TX_RING_SIZE pay close attention to page sizes and the ring-empty warning
  294. levels.
  296. IIIb/c. Transmit/Receive Structure
  298. See the Adaptec manual for the many possible structures, and options for
  299. each structure.  There are far too many to document here.
  301. For transmit this driver uses type 0/1 transmit descriptors (depending
  302. on the presence of the zerocopy infrastructure), and relies on automatic
  303. minimum-length padding.  It does not use the completion queue
  304. consumer index, but instead checks for non-zero status entries.
  306. For receive this driver uses type 0 receive descriptors.  The driver
  307. allocates full frame size skbuffs for the Rx ring buffers, so all frames
  308. should fit in a single descriptor.  The driver does not use the completion
  309. queue consumer index, but instead checks for non-zero status entries.
  311. When an incoming frame is less than RX_COPYBREAK bytes long, a fresh skbuff
  312. is allocated and the frame is copied to the new skbuff.  When the incoming
  313. frame is larger, the skbuff is passed directly up the protocol stack.
  314. Buffers consumed this way are replaced by newly allocated skbuffs in a later
  315. phase of receive.
  317. A notable aspect of operation is that unaligned buffers are not permitted by
  318. the Starfire hardware.  Thus the IP header at offset 14 in an ethernet frame
  319. isn't longword aligned, which may cause problems on some machine
  320. e.g. Alphas and IA64. For these architectures, the driver is forced to copy
  321. the frame into a new skbuff unconditionally. Copied frames are put into the
  322. skbuff at an offset of "+2", thus 16-byte aligning the IP header.
  324. IIId. Synchronization
  326. The driver runs as two independent, single-threaded flows of control.  One
  327. is the send-packet routine, which enforces single-threaded use by the
  328. dev->tbusy flag.  The other thread is the interrupt handler, which is single
  329. threaded by the hardware and interrupt handling software.
  331. The send packet thread has partial control over the Tx ring and 'dev->tbusy'
  332. flag.  It sets the tbusy flag whenever it's queuing a Tx packet. If the next
  333. queue slot is empty, it clears the tbusy flag when finished otherwise it sets
  334. the 'lp->tx_full' flag.
  336. The interrupt handler has exclusive control over the Rx ring and records stats
  337. from the Tx ring.  After reaping the stats, it marks the Tx queue entry as
  338. empty by incrementing the dirty_tx mark. Iff the 'lp->tx_full' flag is set, it
  339. clears both the tx_full and tbusy flags.
  341. IV. Notes
  343. IVb. References
  345. The Adaptec Starfire manuals, available only from Adaptec.
  346. http://www.scyld.com/expert/100mbps.html
  347. http://www.scyld.com/expert/NWay.html
  349. IVc. Errata
  351. */
  355. enum chip_capability_flags {CanHaveMII=1, };
  356. #define PCI_IOTYPE (PCI_USES_MASTER | PCI_USES_MEM | PCI_ADDR0)
  358. #if 0
  359. #define ADDR_64BITS 1 /* This chip uses 64 bit addresses. */
  360. #endif
  362. #define HAS_IP_COPYSUM 1
  364. enum chipset {
  365. CH_6915 = 0,
  366. };
  368. static struct pci_device_id starfire_pci_tbl[] __devinitdata = {
  369. { 0x9004, 0x6915, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CH_6915 },
  370. { 0, }
  371. };
  372. MODULE_DEVICE_TABLE(pci, starfire_pci_tbl);
  374. /* A chip capabilities table, matching the CH_xxx entries in xxx_pci_tbl[] above. */
  375. static struct chip_info {
  376. const char *name;
  377. int drv_flags;
  378. } netdrv_tbl[] __devinitdata = {
  379. { "Adaptec Starfire 6915", CanHaveMII },
  380. };
  383. /* Offsets to the device registers.
  384.    Unlike software-only systems, device drivers interact with complex hardware.
  385.    It's not useful to define symbolic names for every register bit in the
  386.    device.  The name can only partially document the semantics and make
  387.    the driver longer and more difficult to read.
  388.    In general, only the important configuration values or bits changed
  389.    multiple times should be defined symbolically.
  390. */
  391. enum register_offsets {
  392. PCIDeviceConfig=0x50040, GenCtrl=0x50070, IntrTimerCtrl=0x50074,
  393. IntrClear=0x50080, IntrStatus=0x50084, IntrEnable=0x50088,
  394. MIICtrl=0x52000, StationAddr=0x50120, EEPROMCtrl=0x51000,
  395. GPIOCtrl=0x5008C, TxDescCtrl=0x50090,
  396. TxRingPtr=0x50098, HiPriTxRingPtr=0x50094, /* Low and High priority. */
  397. TxRingHiAddr=0x5009C, /* 64 bit address extension. */
  398. TxProducerIdx=0x500A0, TxConsumerIdx=0x500A4,
  399. TxThreshold=0x500B0,
  400. CompletionHiAddr=0x500B4, TxCompletionAddr=0x500B8,
  401. RxCompletionAddr=0x500BC, RxCompletionQ2Addr=0x500C0,
  402. CompletionQConsumerIdx=0x500C4, RxDMACtrl=0x500D0,
  403. RxDescQCtrl=0x500D4, RxDescQHiAddr=0x500DC, RxDescQAddr=0x500E0,
  404. RxDescQIdx=0x500E8, RxDMAStatus=0x500F0, RxFilterMode=0x500F4,
  405. TxMode=0x55000, PerfFilterTable=0x56000, HashTable=0x56100,
  406. TxGfpMem=0x58000, RxGfpMem=0x5a000,
  407. };
  409. /* Bits in the interrupt status/mask registers. */
  410. enum intr_status_bits {
  411. IntrLinkChange=0xf0000000, IntrStatsMax=0x08000000,
  412. IntrAbnormalSummary=0x02000000, IntrGeneralTimer=0x01000000,
  413. IntrSoftware=0x800000, IntrRxComplQ1Low=0x400000,
  414. IntrTxComplQLow=0x200000, IntrPCI=0x100000,
  415. IntrDMAErr=0x080000, IntrTxDataLow=0x040000,
  416. IntrRxComplQ2Low=0x020000, IntrRxDescQ1Low=0x010000,
  417. IntrNormalSummary=0x8000, IntrTxDone=0x4000,
  418. IntrTxDMADone=0x2000, IntrTxEmpty=0x1000,
  419. IntrEarlyRxQ2=0x0800, IntrEarlyRxQ1=0x0400,
  420. IntrRxQ2Done=0x0200, IntrRxQ1Done=0x0100,
  421. IntrRxGFPDead=0x80, IntrRxDescQ2Low=0x40,
  422. IntrNoTxCsum=0x20, IntrTxBadID=0x10,
  423. IntrHiPriTxBadID=0x08, IntrRxGfp=0x04,
  424. IntrTxGfp=0x02, IntrPCIPad=0x01,
  425. /* not quite bits */
  426. IntrRxDone=IntrRxQ2Done | IntrRxQ1Done,
  427. IntrRxEmpty=IntrRxDescQ1Low | IntrRxDescQ2Low,
  428. IntrNormalMask=0xff00, IntrAbnormalMask=0x3ff00fe,
  429. };
  431. /* Bits in the RxFilterMode register. */
  432. enum rx_mode_bits {
  433. AcceptBroadcast=0x04, AcceptAllMulticast=0x02, AcceptAll=0x01,
  434. AcceptMulticast=0x10, AcceptMyPhys=0xE040,
  435. };
  437. /* Bits in the TxDescCtrl register. */
  438. enum tx_ctrl_bits {
  439. TxDescSpaceUnlim=0x00, TxDescSpace32=0x10, TxDescSpace64=0x20,
  440. TxDescSpace128=0x30, TxDescSpace256=0x40,
  441. TxDescType0=0x00, TxDescType1=0x01, TxDescType2=0x02,
  442. TxDescType3=0x03, TxDescType4=0x04,
  443. TxNoDMACompletion=0x08, TxDescQ64bit=0x80,
  444. TxHiPriFIFOThreshShift=24, TxPadLenShift=16,
  445. TxDMABurstSizeShift=8,
  446. };
  448. /* Bits in the RxDescQCtrl register. */
  449. enum rx_ctrl_bits {
  450. RxBufferLenShift=16, RxMinDescrThreshShift=0,
  451. RxPrefetchMode=0x8000, Rx2048QEntries=0x4000,
  452. RxVariableQ=0x2000, RxDesc64bit=0x1000,
  453. RxDescQAddr64bit=0x0100,
  454. RxDescSpace4=0x000, RxDescSpace8=0x100,
  455. RxDescSpace16=0x200, RxDescSpace32=0x300,
  456. RxDescSpace64=0x400, RxDescSpace128=0x500,
  457. RxConsumerWrEn=0x80,
  458. };
  460. /* Bits in the RxCompletionAddr register */
  461. enum rx_compl_bits {
  462. RxComplQAddr64bit=0x80, TxComplProducerWrEn=0x40,
  463. RxComplType0=0x00, RxComplType1=0x10,
  464. RxComplType2=0x20, RxComplType3=0x30,
  465. RxComplThreshShift=0,
  466. };
  468. /* The Rx and Tx buffer descriptors. */
  469. struct starfire_rx_desc {
  470. u32 rxaddr; /* Optionally 64 bits. */
  471. };
  472. enum rx_desc_bits {
  473. RxDescValid=1, RxDescEndRing=2,
  474. };
  476. /* Completion queue entry.
  477.    You must update the page allocation, init_ring and the shift count in rx()
  478.    if using a larger format. */
  479. #ifdef HAS_FIRMWARE
  480. #define csum_rx_status
  481. #endif /* HAS_FIRMWARE */
  482. struct rx_done_desc {
  483. u32 status; /* Low 16 bits is length. */
  484. #ifdef csum_rx_status
  485. u32 status2; /* Low 16 bits is csum */
  486. #endif /* csum_rx_status */
  487. #ifdef full_rx_status
  488. u32 status2;
  489. u16 vlanid;
  490. u16 csum; /* partial checksum */
  491. u32 timestamp;
  492. #endif /* full_rx_status */
  493. };
  494. enum rx_done_bits {
  495. RxOK=0x20000000, RxFIFOErr=0x10000000, RxBufQ2=0x08000000,
  496. };
  498. #ifdef ZEROCOPY
  499. /* Type 0 Tx descriptor. */
  500. /* If more fragments are needed, don't forget to change the
  501.    descriptor spacing as well! */
  502. struct starfire_tx_desc {
  503. u32 status;
  504. u32 nbufs;
  505. u32 first_addr;
  506. u16 first_len;
  507. u16 total_len;
  508. struct {
  509. u32 addr;
  510. u32 len;
  511. } frag[MAX_STARFIRE_FRAGS];
  512. };
  513. #else  /* not ZEROCOPY */
  514. /* Type 1 Tx descriptor. */
  515. struct starfire_tx_desc {
  516. u32 status; /* Upper bits are status, lower 16 length. */
  517. u32 first_addr;
  518. };
  519. #endif /* not ZEROCOPY */
  520. enum tx_desc_bits {
  521. TxDescID=0xB0000000,
  522. TxCRCEn=0x01000000, TxDescIntr=0x08000000,
  523. TxRingWrap=0x04000000, TxCalTCP=0x02000000,
  524. };
  525. struct tx_done_report {
  526. u32 status; /* timestamp, index. */
  527. #if 0
  528. u32 intrstatus; /* interrupt status */
  529. #endif
  530. };
  532. struct rx_ring_info {
  533. struct sk_buff *skb;
  534. dma_addr_t mapping;
  535. };
  536. struct tx_ring_info {
  537. struct sk_buff *skb;
  538. dma_addr_t first_mapping;
  539. #ifdef ZEROCOPY
  540. dma_addr_t frag_mapping[MAX_STARFIRE_FRAGS];
  541. #endif /* ZEROCOPY */
  542. };
  544. #define PHY_CNT 2
  545. struct netdev_private {
  546. /* Descriptor rings first for alignment. */
  547. struct starfire_rx_desc *rx_ring;
  548. struct starfire_tx_desc *tx_ring;
  549. dma_addr_t rx_ring_dma;
  550. dma_addr_t tx_ring_dma;
  551. /* The addresses of rx/tx-in-place skbuffs. */
  552. struct rx_ring_info rx_info[RX_RING_SIZE];
  553. struct tx_ring_info tx_info[TX_RING_SIZE];
  554. /* Pointers to completion queues (full pages). */
  555. struct rx_done_desc *rx_done_q;
  556. dma_addr_t rx_done_q_dma;
  557. unsigned int rx_done;
  558. struct tx_done_report *tx_done_q;
  559. dma_addr_t tx_done_q_dma;
  560. unsigned int tx_done;
  561. struct net_device_stats stats;
  562. struct pci_dev *pci_dev;
  563. /* Frequently used values: keep some adjacent for cache effect. */
  564. unsigned int cur_rx, dirty_rx; /* Producer/consumer ring indices */
  565. unsigned int cur_tx, dirty_tx;
  566. unsigned int rx_buf_sz; /* Based on MTU+slack. */
  567. unsigned int tx_full:1, /* The Tx queue is full. */
  568. /* These values keep track of the transceiver/media in use. */
  569. autoneg:1, /* Autonegotiation allowed. */
  570. full_duplex:1, /* Full-duplex operation. */
  571. speed100:1; /* Set if speed == 100MBit. */
  572. unsigned int intr_mitigation;
  573. u32 tx_mode;
  574. u8 tx_threshold;
  575. /* MII transceiver section. */
  576. u16 advertising; /* NWay media advertisement */
  577. int phy_cnt; /* MII device addresses. */
  578. unsigned char phys[PHY_CNT]; /* MII device addresses. */
  579. };
  582. static int mdio_read(struct net_device *dev, int phy_id, int location);
  583. static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
  584. static int netdev_open(struct net_device *dev);
  585. static void check_duplex(struct net_device *dev);
  586. static void tx_timeout(struct net_device *dev);
  587. static void init_ring(struct net_device *dev);
  588. static int start_tx(struct sk_buff *skb, struct net_device *dev);
  589. static void intr_handler(int irq, void *dev_instance, struct pt_regs *regs);
  590. static void netdev_error(struct net_device *dev, int intr_status);
  591. static int netdev_rx(struct net_device *dev);
  592. static void netdev_error(struct net_device *dev, int intr_status);
  593. static void set_rx_mode(struct net_device *dev);
  594. static struct net_device_stats *get_stats(struct net_device *dev);
  595. static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
  596. static int netdev_close(struct net_device *dev);
  597. static void netdev_media_change(struct net_device *dev);
  601. static int __devinit starfire_init_one(struct pci_dev *pdev,
  602.        const struct pci_device_id *ent)
  603. {
  604. struct netdev_private *np;
  605. int i, irq, option, chip_idx = ent->driver_data;
  606. struct net_device *dev;
  607. static int card_idx = -1;
  608. long ioaddr;
  609. int drv_flags, io_size;
  610. int boguscnt;
  611. u8 cache;
  613. /* when built into the kernel, we only print version if device is found */
  614. #ifndef MODULE
  615. static int printed_version;
  616. if (!printed_version++)
  617. printk(version);
  618. #endif
  620. card_idx++;
  622. if (pci_enable_device (pdev))
  623. return -EIO;
  625. ioaddr = pci_resource_start(pdev, 0);
  626. io_size = pci_resource_len(pdev, 0);
  627. if (!ioaddr || ((pci_resource_flags(pdev, 0) & IORESOURCE_MEM) == 0)) {
  628. printk (KERN_ERR DRV_NAME " %d: no PCI MEM resources, abortingn", card_idx);
  629. return -ENODEV;
  630. }
  632. dev = alloc_etherdev(sizeof(*np));
  633. if (!dev) {
  634. printk (KERN_ERR DRV_NAME " %d: cannot alloc etherdev, abortingn", card_idx);
  635. return -ENOMEM;
  636. }
  637. SET_MODULE_OWNER(dev);
  639. irq = pdev->irq;
  641. if (pci_request_regions (pdev, dev->name)) {
  642. printk (KERN_ERR DRV_NAME " %d: cannot reserve PCI resources, abortingn", card_idx);
  643. goto err_out_free_netdev;
  644. }
  646. ioaddr = (long) ioremap (ioaddr, io_size);
  647. if (!ioaddr) {
  648. printk (KERN_ERR DRV_NAME " %d: cannot remap 0x%x @ 0x%lx, abortingn",
  649. card_idx, io_size, ioaddr);
  650. goto err_out_free_res;
  651. }
  653. pci_set_master (pdev);
  655. /* set PCI cache size */
  656. pci_read_config_byte(pdev, PCI_CACHE_LINE_SIZE, &cache);
  657. if ((cache << 2) != SMP_CACHE_BYTES) {
  658. printk(KERN_INFO "  PCI cache line size set incorrectly "
  659.        "(%i bytes) by BIOS/FW, correcting to %in",
  660.        (cache << 2), SMP_CACHE_BYTES);
  661. pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
  662.       SMP_CACHE_BYTES >> 2);
  663. }
  665. #ifdef ZEROCOPY
  666. /* Starfire can do SG and TCP/UDP checksumming */
  667. dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
  668. #endif /* ZEROCOPY */
  670. /* Serial EEPROM reads are hidden by the hardware. */
  671. for (i = 0; i < 6; i++)
  672. dev->dev_addr[i] = readb(ioaddr + EEPROMCtrl + 20-i);
  674. #if ! defined(final_version) /* Dump the EEPROM contents during development. */
  675. if (debug > 4)
  676. for (i = 0; i < 0x20; i++)
  677. printk("%2.2x%s",
  678.        (unsigned int)readb(ioaddr + EEPROMCtrl + i),
  679.        i % 16 != 15 ? " " : "n");
  680. #endif
  682. /* Issue soft reset */
  683. writel(0x8000, ioaddr + TxMode);
  684. udelay(1000);
  685. writel(0, ioaddr + TxMode);
  687. /* Reset the chip to erase previous misconfiguration. */
  688. writel(1, ioaddr + PCIDeviceConfig);
  689. boguscnt = 1000;
  690. while (--boguscnt > 0) {
  691. udelay(10);
  692. if ((readl(ioaddr + PCIDeviceConfig) & 1) == 0)
  693. break;
  694. }
  695. if (boguscnt == 0)
  696. printk("%s: chipset reset never completed!n", dev->name);
  697. /* wait a little longer */
  698. udelay(1000);
  700. dev->base_addr = ioaddr;
  701. dev->irq = irq;
  703. np = dev->priv;
  704. pci_set_drvdata(pdev, dev);
  706. np->pci_dev = pdev;
  707. drv_flags = netdrv_tbl[chip_idx].drv_flags;
  709. option = card_idx < MAX_UNITS ? options[card_idx] : 0;
  710. if (dev->mem_start)
  711. option = dev->mem_start;
  713. /* The lower four bits are the media type. */
  714. if (option & 0x200)
  715. np->full_duplex = 1;
  717. if (card_idx < MAX_UNITS && full_duplex[card_idx] > 0)
  718. np->full_duplex = 1;
  720. if (np->full_duplex)
  721. np->autoneg = 0;
  722. else
  723. np->autoneg = 1;
  724. np->speed100 = 1;
  726. /* The chip-specific entries in the device structure. */
  727. dev->open = &netdev_open;
  728. dev->hard_start_xmit = &start_tx;
  729. init_tx_timer(dev, tx_timeout, TX_TIMEOUT);
  730. dev->stop = &netdev_close;
  731. dev->get_stats = &get_stats;
  732. dev->set_multicast_list = &set_rx_mode;
  733. dev->do_ioctl = &netdev_ioctl;
  735. if (mtu)
  736. dev->mtu = mtu;
  738. i = register_netdev(dev);
  739. if (i)
  740. goto err_out_cleardev;
  742. printk(KERN_INFO "%s: %s at 0x%lx, ",
  743.    dev->name, netdrv_tbl[chip_idx].name, ioaddr);
  744. for (i = 0; i < 5; i++)
  745. printk("%2.2x:", dev->dev_addr[i]);
  746. printk("%2.2x, IRQ %d.n", dev->dev_addr[i], irq);
  748. if (drv_flags & CanHaveMII) {
  749. int phy, phy_idx = 0;
  750. int mii_status;
  751. for (phy = 0; phy < 32 && phy_idx < PHY_CNT; phy++) {
  752. mdio_write(dev, phy, MII_BMCR, BMCR_RESET);
  753. mdelay(100);
  754. boguscnt = 1000;
  755. while (--boguscnt > 0)
  756. if ((mdio_read(dev, phy, MII_BMCR) & BMCR_RESET) == 0)
  757. break;
  758. if (boguscnt == 0) {
  759. printk("%s: PHY reset never completed!n", dev->name);
  760. continue;
  761. }
  762. mii_status = mdio_read(dev, phy, MII_BMSR);
  763. if (mii_status != 0) {
  764. np->phys[phy_idx++] = phy;
  765. np->advertising = mdio_read(dev, phy, MII_ADVERTISE);
  766. printk(KERN_INFO "%s: MII PHY found at address %d, status "
  767.    "0x%4.4x advertising %4.4x.n",
  768.    dev->name, phy, mii_status, np->advertising);
  769. /* there can be only one PHY on-board */
  770. break;
  771. }
  772. }
  773. np->phy_cnt = phy_idx;
  774. }
  776. #ifdef ZEROCOPY
  777. printk(KERN_INFO "%s: scatter-gather and hardware TCP cksumming enabled.n",
  778.        dev->name);
  779. #else  /* not ZEROCOPY */
  780. printk(KERN_INFO "%s: scatter-gather and hardware TCP cksumming disabled.n",
  781.        dev->name);
  782. #endif /* not ZEROCOPY */
  784. return 0;
  786. err_out_cleardev:
  787. pci_set_drvdata(pdev, NULL);
  788. iounmap((void *)ioaddr);
  789. err_out_free_res:
  790. pci_release_regions (pdev);
  791. err_out_free_netdev:
  792. unregister_netdev(dev);
  793. kfree(dev);
  794. return -ENODEV;
  795. }
  798. /* Read the MII Management Data I/O (MDIO) interfaces. */
  799. static int mdio_read(struct net_device *dev, int phy_id, int location)
  800. {
  801. long mdio_addr = dev->base_addr + MIICtrl + (phy_id<<7) + (location<<2);
  802. int result, boguscnt=1000;
  803. /* ??? Should we add a busy-wait here? */
  804. do
  805. result = readl(mdio_addr);
  806. while ((result & 0xC0000000) != 0x80000000 && --boguscnt > 0);
  807. if (boguscnt == 0)
  808. return 0;
  809. if ((result & 0xffff) == 0xffff)
  810. return 0;
  811. return result & 0xffff;
  812. }
  815. static void mdio_write(struct net_device *dev, int phy_id, int location, int value)
  816. {
  817. long mdio_addr = dev->base_addr + MIICtrl + (phy_id<<7) + (location<<2);
  818. writel(value, mdio_addr);
  819. /* The busy-wait will occur before a read. */
  820. return;
  821. }
  824. static int netdev_open(struct net_device *dev)
  825. {
  826. struct netdev_private *np = dev->priv;
  827. long ioaddr = dev->base_addr;
  828. int i, retval;
  830. /* Do we ever need to reset the chip??? */
  832. COMPAT_MOD_INC_USE_COUNT;
  834. retval = request_irq(dev->irq, &intr_handler, SA_SHIRQ, dev->name, dev);
  835. if (retval) {
  836. COMPAT_MOD_DEC_USE_COUNT;
  837. return retval;
  838. }
  840. /* Disable the Rx and Tx, and reset the chip. */
  841. writel(0, ioaddr + GenCtrl);
  842. writel(1, ioaddr + PCIDeviceConfig);
  843. if (debug > 1)
  844. printk(KERN_DEBUG "%s: netdev_open() irq %d.n",
  845.        dev->name, dev->irq);
  846. /* Allocate the various queues, failing gracefully. */
  847. if (np->tx_done_q == 0)
  848. np->tx_done_q = pci_alloc_consistent(np->pci_dev, PAGE_SIZE, &np->tx_done_q_dma);
  849. if (np->rx_done_q == 0)
  850. np->rx_done_q = pci_alloc_consistent(np->pci_dev, sizeof(struct rx_done_desc) * DONE_Q_SIZE, &np->rx_done_q_dma);
  851. if (np->tx_ring == 0)
  852. np->tx_ring = pci_alloc_consistent(np->pci_dev, PAGE_SIZE, &np->tx_ring_dma);
  853. if (np->rx_ring == 0)
  854. np->rx_ring = pci_alloc_consistent(np->pci_dev, PAGE_SIZE, &np->rx_ring_dma);
  855. if (np->tx_done_q == 0 || np->rx_done_q == 0
  856. || np->rx_ring == 0 || np->tx_ring == 0) {
  857. if (np->tx_done_q)
  858. pci_free_consistent(np->pci_dev, PAGE_SIZE,
  859.     np->tx_done_q, np->tx_done_q_dma);
  860. if (np->rx_done_q)
  861. pci_free_consistent(np->pci_dev, sizeof(struct rx_done_desc) * DONE_Q_SIZE,
  862.     np->rx_done_q, np->rx_done_q_dma);
  863. if (np->tx_ring)
  864. pci_free_consistent(np->pci_dev, PAGE_SIZE,
  865.     np->tx_ring, np->tx_ring_dma);
  866. if (np->rx_ring)
  867. pci_free_consistent(np->pci_dev, PAGE_SIZE,
  868.     np->rx_ring, np->rx_ring_dma);
  869. COMPAT_MOD_DEC_USE_COUNT;
  870. return -ENOMEM;
  871. }
  873. init_ring(dev);
  874. /* Set the size of the Rx buffers. */
  875. writel((np->rx_buf_sz << RxBufferLenShift) |
  876.        (0 << RxMinDescrThreshShift) |
  877.        RxPrefetchMode | RxVariableQ |
  878.        RxDescSpace4,
  879.        ioaddr + RxDescQCtrl);
  881. #ifdef ZEROCOPY
  882. /* Set Tx descriptor to type 0 and spacing to 64 bytes. */
  883. writel((2 << TxHiPriFIFOThreshShift) |
  884.        (0 << TxPadLenShift) |
  885.        (4 << TxDMABurstSizeShift) |
  886.        TxDescSpace64 | TxDescType0,
  887.        ioaddr + TxDescCtrl);
  888. #else  /* not ZEROCOPY */
  889. /* Set Tx descriptor to type 1 and padding to 0 bytes. */
  890. writel((2 << TxHiPriFIFOThreshShift) |
  891.        (0 << TxPadLenShift) |
  892.        (4 << TxDMABurstSizeShift) |
  893.        TxDescSpaceUnlim | TxDescType1,
  894.        ioaddr + TxDescCtrl);
  895. #endif /* not ZEROCOPY */
  897. #if defined(ADDR_64BITS) && defined(__alpha__)
  898. /* XXX We really need a 64-bit PCI dma interfaces too... -DaveM */
  899. writel(np->rx_ring_dma >> 32, ioaddr + RxDescQHiAddr);
  900. writel(np->tx_ring_dma >> 32, ioaddr + TxRingHiAddr);
  901. #else
  902. writel(0, ioaddr + RxDescQHiAddr);
  903. writel(0, ioaddr + TxRingHiAddr);
  904. writel(0, ioaddr + CompletionHiAddr);
  905. #endif
  906. writel(np->rx_ring_dma, ioaddr + RxDescQAddr);
  907. writel(np->tx_ring_dma, ioaddr + TxRingPtr);
  909. writel(np->tx_done_q_dma, ioaddr + TxCompletionAddr);
  910. #ifdef full_rx_status
  911. writel(np->rx_done_q_dma |
  912.        RxComplType3 |
  913.        (0 << RxComplThreshShift),
  914.        ioaddr + RxCompletionAddr);
  915. #else  /* not full_rx_status */
  916. #ifdef csum_rx_status
  917. writel(np->rx_done_q_dma |
  918.        RxComplType2 |
  919.        (0 << RxComplThreshShift),
  920.        ioaddr + RxCompletionAddr);
  921. #else  /* not csum_rx_status */
  922. writel(np->rx_done_q_dma |
  923.        RxComplType0 |
  924.        (0 << RxComplThreshShift),
  925.        ioaddr + RxCompletionAddr);
  926. #endif /* not csum_rx_status */
  927. #endif /* not full_rx_status */
  929. if (debug > 1)
  930. printk(KERN_DEBUG "%s: Filling in the station address.n", dev->name);
  932. /* Fill both the unused Tx SA register and the Rx perfect filter. */
  933. for (i = 0; i < 6; i++)
  934. writeb(dev->dev_addr[i], ioaddr + StationAddr + 5-i);
  935. for (i = 0; i < 16; i++) {
  936. u16 *eaddrs = (u16 *)dev->dev_addr;
  937. long setup_frm = ioaddr + PerfFilterTable + i * 16;
  938. writew(cpu_to_be16(eaddrs[2]), setup_frm); setup_frm += 4;
  939. writew(cpu_to_be16(eaddrs[1]), setup_frm); setup_frm += 4;
  940. writew(cpu_to_be16(eaddrs[0]), setup_frm); setup_frm += 8;
  941. }
  943. /* Initialize other registers. */
  944. /* Configure the PCI bus bursts and FIFO thresholds. */
  945. np->tx_mode = 0x0C04; /* modified when link is up. */
  946. writel(0x8000 | np->tx_mode, ioaddr + TxMode);
  947. udelay(1000);
  948. writel(np->tx_mode, ioaddr + TxMode);
  949. np->tx_threshold = 4;
  950. writel(np->tx_threshold, ioaddr + TxThreshold);
  952. interrupt_mitigation &= 0x1f;
  953. np->intr_mitigation = interrupt_mitigation;
  954. writel(np->intr_mitigation, ioaddr + IntrTimerCtrl);
  956. netif_start_if(dev);
  957. netif_start_queue(dev);
  959. if (debug > 1)
  960. printk(KERN_DEBUG "%s: Setting the Rx and Tx modes.n", dev->name);
  961. set_rx_mode(dev);
  963. np->advertising = mdio_read(dev, np->phys[0], MII_ADVERTISE);
  964. check_duplex(dev);
  966. /* Enable GPIO interrupts on link change */
  967. writel(0x0f00ff00, ioaddr + GPIOCtrl);
  969. /* Set the interrupt mask and enable PCI interrupts. */
  970. writel(IntrRxDone | IntrRxEmpty | IntrDMAErr |
  971.        IntrTxDone | IntrStatsMax | IntrLinkChange |
  972.        IntrNormalSummary | IntrAbnormalSummary |
  973.        IntrRxGFPDead | IntrNoTxCsum | IntrTxBadID,
  974.        ioaddr + IntrEnable);
  975. writel(0x00800000 | readl(ioaddr + PCIDeviceConfig),
  976.        ioaddr + PCIDeviceConfig);
  978. #ifdef HAS_FIRMWARE
  979. /* Load Rx/Tx firmware into the frame processors */
  980. for (i = 0; i < FIRMWARE_RX_SIZE * 2; i++)
  981. writel(cpu_to_le32(firmware_rx[i]), ioaddr + RxGfpMem + i * 4);
  982. for (i = 0; i < FIRMWARE_TX_SIZE * 2; i++)
  983. writel(cpu_to_le32(firmware_tx[i]), ioaddr + TxGfpMem + i * 4);
  984. /* Enable the Rx and Tx units, and the Rx/Tx frame processors. */
  985. writel(0x003F, ioaddr + GenCtrl);
  986. #else  /* not HAS_FIRMWARE */
  987. /* Enable the Rx and Tx units only. */
  988. writel(0x000F, ioaddr + GenCtrl);
  989. #endif /* not HAS_FIRMWARE */
  991. if (debug > 2)
  992. printk(KERN_DEBUG "%s: Done netdev_open().n",
  993.        dev->name);
  995. return 0;
  996. }
  999. static void check_duplex(struct net_device *dev)
  1000. {
  1001. struct netdev_private *np = dev->priv;
  1002. u16 reg0;
  1004. mdio_write(dev, np->phys[0], MII_ADVERTISE, np->advertising);
  1005. mdio_write(dev, np->phys[0], MII_BMCR, BMCR_RESET);
  1006. udelay(500);
  1007. while (mdio_read(dev, np->phys[0], MII_BMCR) & BMCR_RESET);
  1009. reg0 = mdio_read(dev, np->phys[0], MII_BMCR);
  1011. if (np->autoneg) {
  1012. reg0 |= BMCR_ANENABLE | BMCR_ANRESTART;
  1013. } else {
  1014. reg0 &= ~(BMCR_ANENABLE | BMCR_ANRESTART);
  1015. if (np->speed100)
  1016. reg0 |= BMCR_SPEED100;
  1017. if (np->full_duplex)
  1018. reg0 |= BMCR_FULLDPLX;
  1019. printk(KERN_DEBUG "%s: Link forced to %sMbit %s-duplexn",
  1020.        dev->name,
  1021.        np->speed100 ? "100" : "10",
  1022.        np->full_duplex ? "full" : "half");
  1023. }
  1024. mdio_write(dev, np->phys[0], MII_BMCR, reg0);
  1025. }
  1028. static void tx_timeout(struct net_device *dev)
  1029. {
  1030. struct netdev_private *np = dev->priv;
  1031. long ioaddr = dev->base_addr;
  1033. printk(KERN_WARNING "%s: Transmit timed out, status %8.8x,"
  1034.        " resetting...n", dev->name, (int)readl(ioaddr + IntrStatus));
  1036. #ifndef __alpha__
  1037. {
  1038. int i;
  1039. printk(KERN_DEBUG "  Rx ring %p: ", np->rx_ring);
  1040. for (i = 0; i < RX_RING_SIZE; i++)
  1041. printk(" %8.8x", (unsigned int)le32_to_cpu(np->rx_ring[i].rxaddr));
  1042. printk("n"KERN_DEBUG"  Tx ring %p: ", np->tx_ring);
  1043. for (i = 0; i < TX_RING_SIZE; i++)
  1044. printk(" %4.4x", le32_to_cpu(np->tx_ring[i].status));
  1045. printk("n");
  1046. }
  1047. #endif
  1049. /* Perhaps we should reinitialize the hardware here. */
  1050. /* Stop and restart the chip's Tx processes . */
  1052. /* Trigger an immediate transmit demand. */
  1054. dev->trans_start = jiffies;
  1055. np->stats.tx_errors++;
  1056. netif_wake_queue(dev);
  1057. }
  1060. /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
  1061. static void init_ring(struct net_device *dev)
  1062. {
  1063. struct netdev_private *np = dev->priv;
  1064. int i;
  1066. np->tx_full = 0;
  1067. np->cur_rx = np->cur_tx = 0;
  1068. np->dirty_rx = np->rx_done = np->dirty_tx = np->tx_done = 0;
  1070. np->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
  1072. /* Fill in the Rx buffers.  Handle allocation failure gracefully. */
  1073. for (i = 0; i < RX_RING_SIZE; i++) {
  1074. struct sk_buff *skb = dev_alloc_skb(np->rx_buf_sz);
  1075. np->rx_info[i].skb = skb;
  1076. if (skb == NULL)
  1077. break;
  1078. np->rx_info[i].mapping = pci_map_single(np->pci_dev, skb->tail, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
  1079. skb->dev = dev; /* Mark as being used by this device. */
  1080. /* Grrr, we cannot offset to correctly align the IP header. */
  1081. np->rx_ring[i].rxaddr = cpu_to_le32(np->rx_info[i].mapping | RxDescValid);
  1082. }
  1083. writew(i - 1, dev->base_addr + RxDescQIdx);
  1084. np->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
  1086. /* Clear the remainder of the Rx buffer ring. */
  1087. for (  ; i < RX_RING_SIZE; i++) {
  1088. np->rx_ring[i].rxaddr = 0;
  1089. np->rx_info[i].skb = NULL;
  1090. np->rx_info[i].mapping = 0;
  1091. }
  1092. /* Mark the last entry as wrapping the ring. */
  1093. np->rx_ring[i-1].rxaddr |= cpu_to_le32(RxDescEndRing);
  1095. /* Clear the completion rings. */
  1096. for (i = 0; i < DONE_Q_SIZE; i++) {
  1097. np->rx_done_q[i].status = 0;
  1098. np->tx_done_q[i].status = 0;
  1099. }
  1101. for (i = 0; i < TX_RING_SIZE; i++) {
  1102. np->tx_info[i].skb = NULL;
  1103. np->tx_info[i].first_mapping = 0;
  1104. #ifdef ZEROCOPY
  1105. {
  1106. int j;
  1107. for (j = 0; j < MAX_STARFIRE_FRAGS; j++)
  1108. np->tx_info[i].frag_mapping[j] = 0;
  1109. }
  1110. #endif /* ZEROCOPY */
  1111. np->tx_ring[i].status = 0;
  1112. }
  1113. return;
  1114. }
  1117. static int start_tx(struct sk_buff *skb, struct net_device *dev)
  1118. {
  1119. struct netdev_private *np = dev->priv;
  1120. unsigned int entry;
  1121. #ifdef ZEROCOPY
  1122. int i;
  1123. #endif
  1125. kick_tx_timer(dev, tx_timeout, TX_TIMEOUT);
  1127. /* Caution: the write order is important here, set the field
  1128.    with the "ownership" bits last. */
  1130. /* Calculate the next Tx descriptor entry. */
  1131. entry = np->cur_tx % TX_RING_SIZE;
  1133. #if defined(ZEROCOPY) && defined(HAS_FIRMWARE) && defined(HAS_BROKEN_FIRMWARE)
  1134. {
  1135. int has_bad_length = 0;
  1137. if (skb_first_frag_len(skb) == 1)
  1138. has_bad_length = 1;
  1139. else {
  1140. for (i = 0; i < skb_shinfo(skb)->nr_frags; i++)
  1141. if (skb_shinfo(skb)->frags[i].size == 1) {
  1142. has_bad_length = 1;
  1143. break;
  1144. }
  1145. }
  1147. if (has_bad_length)
  1148. skb_checksum_help(skb);
  1149. }
  1150. #endif /* ZEROCOPY && HAS_FIRMWARE && HAS_BROKEN_FIRMWARE */
  1152. np->tx_info[entry].skb = skb;
  1153. np->tx_info[entry].first_mapping =
  1154. pci_map_single(np->pci_dev, skb->data, skb_first_frag_len(skb), PCI_DMA_TODEVICE);
  1156. np->tx_ring[entry].first_addr = cpu_to_le32(np->tx_info[entry].first_mapping);
  1157. #ifdef ZEROCOPY
  1158. np->tx_ring[entry].first_len = cpu_to_le32(skb_first_frag_len(skb));
  1159. np->tx_ring[entry].total_len = cpu_to_le32(skb->len);
  1160. /* Add "| TxDescIntr" to generate Tx-done interrupts. */
  1161. np->tx_ring[entry].status = cpu_to_le32(TxDescID | TxCRCEn);
  1162. np->tx_ring[entry].nbufs = cpu_to_le32(skb_shinfo(skb)->nr_frags + 1);
  1163. #else  /* not ZEROCOPY */
  1164. /* Add "| TxDescIntr" to generate Tx-done interrupts. */
  1165. np->tx_ring[entry].status = cpu_to_le32(skb->len | TxDescID | TxCRCEn | 1 << 16);
  1166. #endif /* not ZEROCOPY */
  1168. if (entry >= TX_RING_SIZE-1)  /* Wrap ring */
  1169. np->tx_ring[entry].status |= cpu_to_le32(TxRingWrap | TxDescIntr);
  1171. #ifdef ZEROCOPY
  1172. if (skb->ip_summed == CHECKSUM_HW)
  1173. np->tx_ring[entry].status |= cpu_to_le32(TxCalTCP);
  1174. #endif /* ZEROCOPY */
  1176. if (debug > 5) {
  1177. #ifdef ZEROCOPY
  1178. printk(KERN_DEBUG "%s: Tx #%d slot %d status %8.8x nbufs %d len %4.4x/%4.4x.n",
  1179.        dev->name, np->cur_tx, entry,
  1180.        le32_to_cpu(np->tx_ring[entry].status),
  1181.        le32_to_cpu(np->tx_ring[entry].nbufs),
  1182.        le32_to_cpu(np->tx_ring[entry].first_len),
  1183.        le32_to_cpu(np->tx_ring[entry].total_len));
  1184. #else  /* not ZEROCOPY */
  1185. printk(KERN_DEBUG "%s: Tx #%d slot %d status %8.8x.n",
  1186.        dev->name, np->cur_tx, entry,
  1187.        le32_to_cpu(np->tx_ring[entry].status));
  1188. #endif /* not ZEROCOPY */
  1189. }
  1191. #ifdef ZEROCOPY
  1192. for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
  1193. skb_frag_t *this_frag = &skb_shinfo(skb)->frags[i];
  1195. /* we already have the proper value in entry */
  1196. np->tx_info[entry].frag_mapping[i] =
  1197. pci_map_single(np->pci_dev, page_address(this_frag->page) + this_frag->page_offset, this_frag->size, PCI_DMA_TODEVICE);
  1199. np->tx_ring[entry].frag[i].addr = cpu_to_le32(np->tx_info[entry].frag_mapping[i]);
  1200. np->tx_ring[entry].frag[i].len = cpu_to_le32(this_frag->size);
  1201. if (debug > 5) {
  1202. printk(KERN_DEBUG "%s: Tx #%d frag %d len %4.4x.n",
  1203.        dev->name, np->cur_tx, i,
  1204.        le32_to_cpu(np->tx_ring[entry].frag[i].len));
  1205. }
  1206. }
  1207. #endif /* ZEROCOPY */
  1209. np->cur_tx++;
  1211. if (entry >= TX_RING_SIZE-1)  /* Wrap ring */
  1212. entry = -1;
  1213. entry++;
  1215. /* Non-x86: explicitly flush descriptor cache lines here. */
  1216. /* Ensure everything is written back above before the transmit is
  1217.    initiated. - Jes */
  1218. wmb();
  1220. /* Update the producer index. */
  1221. writel(entry * (sizeof(struct starfire_tx_desc) / 8), dev->base_addr + TxProducerIdx);
  1223. if (np->cur_tx - np->dirty_tx >= TX_RING_SIZE - 1) {
  1224. np->tx_full = 1;
  1225. netif_stop_queue(dev);
  1226. }
  1228. dev->trans_start = jiffies;
  1230. return 0;
  1231. }
  1234. /* The interrupt handler does all of the Rx thread work and cleans up
  1235.    after the Tx thread. */
  1236. static void intr_handler(int irq, void *dev_instance, struct pt_regs *rgs)
  1237. {
  1238. struct net_device *dev = (struct net_device *)dev_instance;
  1239. struct netdev_private *np;
  1240. long ioaddr;
  1241. int boguscnt = max_interrupt_work;
  1242. int consumer;
  1243. int tx_status;
  1245. #ifndef final_version /* Can never occur. */
  1246. if (dev == NULL) {
  1247. printk (KERN_ERR "Netdev interrupt handler(): IRQ %d for unknown device.n", irq);
  1248. return;
  1249. }
  1250. #endif
  1252. ioaddr = dev->base_addr;
  1253. np = dev->priv;
  1255. do {
  1256. u32 intr_status = readl(ioaddr + IntrClear);
  1258. if (debug > 4)
  1259. printk(KERN_DEBUG "%s: Interrupt status %4.4x.n",
  1260.        dev->name, intr_status);
  1262. if (intr_status == 0)
  1263. break;
  1265. if (intr_status & IntrRxDone)
  1266. netdev_rx(dev);
  1268. /* Scavenge the skbuff list based on the Tx-done queue.
  1269.    There are redundant checks here that may be cleaned up
  1270.    after the driver has proven to be reliable. */
  1271. consumer = readl(ioaddr + TxConsumerIdx);
  1272. if (debug > 4)
  1273. printk(KERN_DEBUG "%s: Tx Consumer index is %d.n",
  1274.        dev->name, consumer);
  1275. #if 0
  1276. if (np->tx_done >= 250 || np->tx_done == 0)
  1277. printk(KERN_DEBUG "%s: Tx completion entry %d is %8.8x, %d is %8.8x.n",
  1278.        dev->name, np->tx_done,
  1279.        le32_to_cpu(np->tx_done_q[np->tx_done].status),
  1280.        (np->tx_done+1) & (DONE_Q_SIZE-1),
  1281.        le32_to_cpu(np->tx_done_q[(np->tx_done+1)&(DONE_Q_SIZE-1)].status));
  1282. #endif
  1284. while ((tx_status = le32_to_cpu(np->tx_done_q[np->tx_done].status)) != 0) {
  1285. if (debug > 4)
  1286. printk(KERN_DEBUG "%s: Tx completion entry %d is %8.8x.n",
  1287.        dev->name, np->tx_done, tx_status);
  1288. if ((tx_status & 0xe0000000) == 0xa0000000) {
  1289. np->stats.tx_packets++;
  1290. } else if ((tx_status & 0xe0000000) == 0x80000000) {
  1291. struct sk_buff *skb;
  1292. #ifdef ZEROCOPY
  1293. int i;
  1294. #endif /* ZEROCOPY */
  1295. u16 entry = tx_status; /* Implicit truncate */
  1296. entry /= sizeof(struct starfire_tx_desc);
  1298. skb = np->tx_info[entry].skb;
  1299. np->tx_info[entry].skb = NULL;
  1300. pci_unmap_single(np->pci_dev,
  1301.  np->tx_info[entry].first_mapping,
  1302.  skb_first_frag_len(skb),
  1303.  PCI_DMA_TODEVICE);
  1304. np->tx_info[entry].first_mapping = 0;
  1306. #ifdef ZEROCOPY
  1307. for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
  1308. pci_unmap_single(np->pci_dev,
  1309.  np->tx_info[entry].frag_mapping[i],
  1310.  skb_shinfo(skb)->frags[i].size,
  1311.  PCI_DMA_TODEVICE);
  1312. np->tx_info[entry].frag_mapping[i] = 0;
  1313. }
  1314. #endif /* ZEROCOPY */
  1316. /* Scavenge the descriptor. */
  1317. dev_kfree_skb_irq(skb);
  1319. np->dirty_tx++;
  1320. }
  1321. np->tx_done_q[np->tx_done].status = 0;
  1322. np->tx_done = (np->tx_done+1) & (DONE_Q_SIZE-1);
  1323. }
  1324. writew(np->tx_done, ioaddr + CompletionQConsumerIdx + 2);
  1326. if (np->tx_full && np->cur_tx - np->dirty_tx < TX_RING_SIZE - 4) {
  1327. /* The ring is no longer full, wake the queue. */
  1328. np->tx_full = 0;
  1329. netif_wake_queue(dev);
  1330. }
  1332. /* Stats overflow */
  1333. if (intr_status & IntrStatsMax) {
  1334. get_stats(dev);
  1335. }
  1337. /* Media change interrupt. */
  1338. if (intr_status & IntrLinkChange)
  1339. netdev_media_change(dev);
  1341. /* Abnormal error summary/uncommon events handlers. */
  1342. if (intr_status & IntrAbnormalSummary)
  1343. netdev_error(dev, intr_status);
  1345. if (--boguscnt < 0) {
  1346. printk(KERN_WARNING "%s: Too much work at interrupt, "
  1347.        "status=0x%4.4x.n",
  1348.        dev->name, intr_status);
  1349. break;
  1350. }
  1351. } while (1);
  1353. if (debug > 4)
  1354. printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.n",
  1355.        dev->name, (int)readl(ioaddr + IntrStatus));
  1357. #ifndef final_version
  1358. /* Code that should never be run!  Remove after testing.. */
  1359. {
  1360. static int stopit = 10;
  1361. if (!netif_running(dev) && --stopit < 0) {
  1362. printk(KERN_ERR "%s: Emergency stop, looping startup interrupt.n",
  1363.        dev->name);
  1364. free_irq(irq, dev);
  1365. }
  1366. }
  1367. #endif
  1368. }
  1371. /* This routine is logically part of the interrupt handler, but separated
  1372.    for clarity and better register allocation. */
  1373. static int netdev_rx(struct net_device *dev)
  1374. {
  1375. struct netdev_private *np = dev->priv;
  1376. int boguscnt = np->dirty_rx + RX_RING_SIZE - np->cur_rx;
  1377. u32 desc_status;
  1379. if (np->rx_done_q == 0) {
  1380. printk(KERN_ERR "%s:  rx_done_q is NULL!  rx_done is %d. %p.n",
  1381.        dev->name, np->rx_done, np->tx_done_q);
  1382. return 0;
  1383. }
  1385. /* If EOP is set on the next entry, it's a new packet. Send it up. */
  1386. while ((desc_status = le32_to_cpu(np->rx_done_q[np->rx_done].status)) != 0) {
  1387. struct sk_buff *skb;
  1388. u16 pkt_len;
  1389. int entry;
  1391. if (debug > 4)
  1392. printk(KERN_DEBUG "  netdev_rx() status of %d was %8.8x.n", np->rx_done, desc_status);
  1393. if (--boguscnt < 0)
  1394. break;
  1395. if ( ! (desc_status & RxOK)) {
  1396. /* There was a error. */
  1397. if (debug > 2)
  1398. printk(KERN_DEBUG "  netdev_rx() Rx error was %8.8x.n", desc_status);
  1399. np->stats.rx_errors++;
  1400. if (desc_status & RxFIFOErr)
  1401. np->stats.rx_fifo_errors++;
  1402. goto next_rx;
  1403. }
  1405. pkt_len = desc_status; /* Implicitly Truncate */
  1406. entry = (desc_status >> 16) & 0x7ff;
  1408. #ifndef final_version
  1409. if (debug > 4)
  1410. printk(KERN_DEBUG "  netdev_rx() normal Rx pkt length %d, bogus_cnt %d.n", pkt_len, boguscnt);
  1411. #endif
  1412. /* Check if the packet is long enough to accept without copying
  1413.    to a minimally-sized skbuff. */
  1414. if (pkt_len < rx_copybreak
  1415.     && (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
  1416. skb->dev = dev;
  1417. skb_reserve(skb, 2); /* 16 byte align the IP header */
  1418. pci_dma_sync_single(np->pci_dev,
  1419.     np->rx_info[entry].mapping,
  1420.     pkt_len, PCI_DMA_FROMDEVICE);
  1421. #if HAS_IP_COPYSUM /* Call copy + cksum if available. */
  1422. eth_copy_and_sum(skb, np->rx_info[entry].skb->tail, pkt_len, 0);
  1423. skb_put(skb, pkt_len);
  1424. #else
  1425. memcpy(skb_put(skb, pkt_len), np->rx_info[entry].skb->tail, pkt_len);
  1426. #endif
  1427. } else {
  1428. pci_unmap_single(np->pci_dev, np->rx_info[entry].mapping, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
  1429. skb = np->rx_info[entry].skb;
  1430. skb_put(skb, pkt_len);
  1431. np->rx_info[entry].skb = NULL;
  1432. np->rx_info[entry].mapping = 0;
  1433. }
  1434. #ifndef final_version /* Remove after testing. */
  1435. /* You will want this info for the initial debug. */
  1436. if (debug > 5)
  1437. printk(KERN_DEBUG "  Rx data %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:"
  1438.        "%2.2x %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x %2.2x%2.2x "
  1439.        "%d.%d.%d.%d.n",
  1440.        skb->data[0], skb->data[1], skb->data[2], skb->data[3],
  1441.        skb->data[4], skb->data[5], skb->data[6], skb->data[7],
  1442.        skb->data[8], skb->data[9], skb->data[10],
  1443.        skb->data[11], skb->data[12], skb->data[13],
  1444.        skb->data[14], skb->data[15], skb->data[16],
  1445.        skb->data[17]);
  1446. #endif
  1447. skb->protocol = eth_type_trans(skb, dev);
  1448. #if defined(full_rx_status) || defined(csum_rx_status)
  1449. if (le32_to_cpu(np->rx_done_q[np->rx_done].status2) & 0x01000000) {
  1450. skb->ip_summed = CHECKSUM_UNNECESSARY;
  1451. }
  1452. /*
  1453.  * This feature doesn't seem to be working, at least
  1454.  * with the two firmware versions I have. If the GFP sees
  1455.  * a fragment, it either ignores it completely, or reports
  1456.  * "bad checksum" on it.
  1457.  *
  1458.  * Maybe I missed something -- corrections are welcome.
  1459.  * Until then, the printk stays. :-) -Ion
  1460.  */
  1461. else if (le32_to_cpu(np->rx_done_q[np->rx_done].status2) & 0x00400000) {
  1462. skb->ip_summed = CHECKSUM_HW;
  1463. skb->csum = le32_to_cpu(np->rx_done_q[np->rx_done].status2) & 0xffff;
  1464. printk(KERN_DEBUG "%s: checksum_hw, status2 = %xn", dev->name, np->rx_done_q[np->rx_done].status2);
  1465. }
  1466. #endif
  1467. netif_rx(skb);
  1468. dev->last_rx = jiffies;
  1469. np->stats.rx_packets++;
  1471. next_rx:
  1472. np->cur_rx++;
  1473. np->rx_done_q[np->rx_done].status = 0;
  1474. np->rx_done = (np->rx_done + 1) & (DONE_Q_SIZE-1);
  1475. }
  1476. writew(np->rx_done, dev->base_addr + CompletionQConsumerIdx);
  1478. /* Refill the Rx ring buffers. */
  1479. for (; np->cur_rx - np->dirty_rx > 0; np->dirty_rx++) {
  1480. struct sk_buff *skb;
  1481. int entry = np->dirty_rx % RX_RING_SIZE;
  1482. if (np->rx_info[entry].skb == NULL) {
  1483. skb = dev_alloc_skb(np->rx_buf_sz);
  1484. np->rx_info[entry].skb = skb;
  1485. if (skb == NULL)
  1486. break; /* Better luck next round. */
  1487. np->rx_info[entry].mapping =
  1488. pci_map_single(np->pci_dev, skb->tail, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
  1489. skb->dev = dev; /* Mark as being used by this device. */
  1490. np->rx_ring[entry].rxaddr =
  1491. cpu_to_le32(np->rx_info[entry].mapping | RxDescValid);
  1492. }
  1493. if (entry == RX_RING_SIZE - 1)
  1494. np->rx_ring[entry].rxaddr |= cpu_to_le32(RxDescEndRing);
  1495. /* We could defer this until later... */
  1496. writew(entry, dev->base_addr + RxDescQIdx);
  1497. }
  1499. if (debug > 5)
  1500. printk(KERN_DEBUG "  exiting netdev_rx() status of %d was %8.8x.n",
  1501.        np->rx_done, desc_status);
  1503. /* Restart Rx engine if stopped. */
  1504. return 0;
  1505. }
  1508. static void netdev_media_change(struct net_device *dev)
  1509. {
  1510. struct netdev_private *np = dev->priv;
  1511. long ioaddr = dev->base_addr;
  1512. u16 reg0, reg1, reg4, reg5;
  1513. u32 new_tx_mode;
  1515. /* reset status first */
  1516. mdio_read(dev, np->phys[0], MII_BMCR);
  1517. mdio_read(dev, np->phys[0], MII_BMSR);
  1519. reg0 = mdio_read(dev, np->phys[0], MII_BMCR);
  1520. reg1 = mdio_read(dev, np->phys[0], MII_BMSR);
  1522. if (reg1 & BMSR_LSTATUS) {
  1523. /* link is up */
  1524. if (reg0 & BMCR_ANENABLE) {
  1525. /* autonegotiation is enabled */
  1526. reg4 = mdio_read(dev, np->phys[0], MII_ADVERTISE);
  1527. reg5 = mdio_read(dev, np->phys[0], MII_LPA);
  1528. if (reg4 & ADVERTISE_100FULL && reg5 & LPA_100FULL) {
  1529. np->speed100 = 1;
  1530. np->full_duplex = 1;
  1531. } else if (reg4 & ADVERTISE_100HALF && reg5 & LPA_100HALF) {
  1532. np->speed100 = 1;
  1533. np->full_duplex = 0;
  1534. } else if (reg4 & ADVERTISE_10FULL && reg5 & LPA_10FULL) {
  1535. np->speed100 = 0;
  1536. np->full_duplex = 1;
  1537. } else {
  1538. np->speed100 = 0;
  1539. np->full_duplex = 0;
  1540. }
  1541. } else {
  1542. /* autonegotiation is disabled */
  1543. if (reg0 & BMCR_SPEED100)
  1544. np->speed100 = 1;
  1545. else
  1546. np->speed100 = 0;
  1547. if (reg0 & BMCR_FULLDPLX)
  1548. np->full_duplex = 1;
  1549. else
  1550. np->full_duplex = 0;
  1551. }
  1552. printk(KERN_DEBUG "%s: Link is up, running at %sMbit %s-duplexn",
  1553.        dev->name,
  1554.        np->speed100 ? "100" : "10",
  1555.        np->full_duplex ? "full" : "half");
  1557. new_tx_mode = np->tx_mode & ~0x2; /* duplex setting */
  1558. if (np->full_duplex)
  1559. new_tx_mode |= 2;
  1560. if (np->tx_mode != new_tx_mode) {
  1561. np->tx_mode = new_tx_mode;
  1562. writel(np->tx_mode | 0x8000, ioaddr + TxMode);
  1563. udelay(1000);
  1564. writel(np->tx_mode, ioaddr + TxMode);
  1565. }
  1566. } else {
  1567. printk(KERN_DEBUG "%s: Link is downn", dev->name);
  1568. }
  1569. }
  1572. static void netdev_error(struct net_device *dev, int intr_status)
  1573. {
  1574. struct netdev_private *np = dev->priv;
  1576. /* Came close to underrunning the Tx FIFO, increase threshold. */
  1577. if (intr_status & IntrTxDataLow) {
  1578. writel(++np->tx_threshold, dev->base_addr + TxThreshold);
  1579. printk(KERN_NOTICE "%s: Increasing Tx FIFO threshold to %d bytesn",
  1580.        dev->name, np->tx_threshold * 16);
  1581. }
  1582. if ((intr_status & ~(IntrNormalMask | IntrAbnormalSummary | IntrLinkChange | IntrStatsMax | IntrTxDataLow | IntrPCIPad)) && debug)
  1583. printk(KERN_ERR "%s: Something Wicked happened! %4.4x.n",
  1584.        dev->name, intr_status);
  1585. /* Hmmmmm, it's not clear how to recover from DMA faults. */
  1586. if (intr_status & IntrDMAErr)
  1587. np->stats.tx_fifo_errors++;
  1588. }
  1591. static struct net_device_stats *get_stats(struct net_device *dev)
  1592. {
  1593. long ioaddr = dev->base_addr;
  1594. struct netdev_private *np = dev->priv;
  1596. /* This adapter architecture needs no SMP locks. */
  1597. np->stats.tx_bytes = readl(ioaddr + 0x57010);
  1598. np->stats.rx_bytes = readl(ioaddr + 0x57044);
  1599. np->stats.tx_packets = readl(ioaddr + 0x57000);
  1600. np->stats.tx_aborted_errors =
  1601. readl(ioaddr + 0x57024) + readl(ioaddr + 0x57028);
  1602. np->stats.tx_window_errors = readl(ioaddr + 0x57018);
  1603. np->stats.collisions =
  1604. readl(ioaddr + 0x57004) + readl(ioaddr + 0x57008);
  1606. /* The chip only need report frame silently dropped. */
  1607. np->stats.rx_dropped += readw(ioaddr + RxDMAStatus);
  1608. writew(0, ioaddr + RxDMAStatus);
  1609. np->stats.rx_crc_errors = readl(ioaddr + 0x5703C);
  1610. np->stats.rx_frame_errors = readl(ioaddr + 0x57040);
  1611. np->stats.rx_length_errors = readl(ioaddr + 0x57058);
  1612. np->stats.rx_missed_errors = readl(ioaddr + 0x5707C);
  1614. return &np->stats;
  1615. }
  1618. /* The little-endian AUTODIN II ethernet CRC calculations.
  1619.    A big-endian version is also available.
  1620.    This is slow but compact code.  Do not use this routine for bulk data,
  1621.    use a table-based routine instead.
  1622.    This is common code and should be moved to net/core/crc.c.
  1623.    Chips may use the upper or lower CRC bits, and may reverse and/or invert
  1624.    them.  Select the endian-ness that results in minimal calculations.
  1625. */
  1626. static unsigned const ethernet_polynomial_le = 0xedb88320U;
  1627. static inline unsigned ether_crc_le(int length, unsigned char *data)
  1628. {
  1629. unsigned int crc = 0xffffffff; /* Initial value. */
  1630. while(--length >= 0) {
  1631. unsigned char current_octet = *data++;
  1632. int bit;
  1633. for (bit = 8; --bit >= 0; current_octet >>= 1) {
  1634. if ((crc ^ current_octet) & 1) {
  1635. crc >>= 1;
  1636. crc ^= ethernet_polynomial_le;
  1637. } else
  1638. crc >>= 1;
  1639. }
  1640. }
  1641. return crc;
  1642. }
  1645. static void set_rx_mode(struct net_device *dev)
  1646. {
  1647. long ioaddr = dev->base_addr;
  1648. u32 rx_mode;
  1649. struct dev_mc_list *mclist;
  1650. int i;
  1652. if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
  1653. rx_mode = AcceptBroadcast|AcceptAllMulticast|AcceptAll|AcceptMyPhys;
  1654. } else if ((dev->mc_count > multicast_filter_limit)
  1655.    || (dev->flags & IFF_ALLMULTI)) {
  1656. /* Too many to match, or accept all multicasts. */
  1657. rx_mode = AcceptBroadcast|AcceptAllMulticast|AcceptMyPhys;
  1658. } else if (dev->mc_count <= 15) {
  1659. /* Use the 16 element perfect filter, skip first entry. */
  1660. long filter_addr = ioaddr + PerfFilterTable + 1 * 16;
  1661. for (i = 1, mclist = dev->mc_list; mclist && i <= dev->mc_count;
  1662.      i++, mclist = mclist->next) {
  1663. u16 *eaddrs = (u16 *)mclist->dmi_addr;
  1664. writew(cpu_to_be16(eaddrs[2]), filter_addr); filter_addr += 4;
  1665. writew(cpu_to_be16(eaddrs[1]), filter_addr); filter_addr += 4;
  1666. writew(cpu_to_be16(eaddrs[0]), filter_addr); filter_addr += 8;
  1667. }
  1668. while (i++ < 16) {
  1669. writew(0xffff, filter_addr); filter_addr += 4;
  1670. writew(0xffff, filter_addr); filter_addr += 4;
  1671. writew(0xffff, filter_addr); filter_addr += 8;
  1672. }
  1673. rx_mode = AcceptBroadcast | AcceptMyPhys;
  1674. } else {
  1675. /* Must use a multicast hash table. */
  1676. long filter_addr;
  1677. u16 mc_filter[32] __attribute__ ((aligned(sizeof(long)))); /* Multicast hash filter */
  1679. memset(mc_filter, 0, sizeof(mc_filter));
  1680. for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
  1681.      i++, mclist = mclist->next) {
  1682. int bit_nr = ether_crc_le(ETH_ALEN, mclist->dmi_addr) >> 23;
  1683. __u32 *fptr = (__u32 *) &mc_filter[(bit_nr >> 4) & ~1];
  1685. *fptr |= cpu_to_le32(1 << (bit_nr & 31));
  1686. }
  1687. /* Clear the perfect filter list, skip first entry. */
  1688. filter_addr = ioaddr + PerfFilterTable + 1 * 16;
  1689. for (i = 1; i < 16; i++) {
  1690. writew(0xffff, filter_addr); filter_addr += 4;
  1691. writew(0xffff, filter_addr); filter_addr += 4;
  1692. writew(0xffff, filter_addr); filter_addr += 8;
  1693. }
  1694. for (filter_addr = ioaddr + HashTable, i=0; i < 32; filter_addr+= 16, i++)
  1695. writew(mc_filter[i], filter_addr);
  1696. rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
  1697. }
  1698. writel(rx_mode, ioaddr + RxFilterMode);
  1699. }
  1702. static int netdev_ethtool_ioctl(struct net_device *dev, void *useraddr)
  1703. {
  1704. struct ethtool_cmd ecmd;
  1705. struct netdev_private *np = dev->priv;
  1707. if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
  1708. return -EFAULT;
  1710. switch (ecmd.cmd) {
  1711. case ETHTOOL_GSET:
  1712. ecmd.supported =
  1713. SUPPORTED_10baseT_Half |
  1714. SUPPORTED_10baseT_Full |
  1715. SUPPORTED_100baseT_Half |
  1716. SUPPORTED_100baseT_Full |
  1717. SUPPORTED_Autoneg |
  1718. SUPPORTED_MII;
  1720. ecmd.advertising = ADVERTISED_MII;
  1721. if (np->advertising & ADVERTISE_10HALF)
  1722. ecmd.advertising |= ADVERTISED_10baseT_Half;
  1723. if (np->advertising & ADVERTISE_10FULL)
  1724. ecmd.advertising |= ADVERTISED_10baseT_Full;
  1725. if (np->advertising & ADVERTISE_100HALF)
  1726. ecmd.advertising |= ADVERTISED_100baseT_Half;
  1727. if (np->advertising & ADVERTISE_100FULL)
  1728. ecmd.advertising |= ADVERTISED_100baseT_Full;
  1729. if (np->autoneg) {
  1730. ecmd.advertising |= ADVERTISED_Autoneg;
  1731. ecmd.autoneg = AUTONEG_ENABLE;
  1732. } else
  1733. ecmd.autoneg = AUTONEG_DISABLE;
  1735. ecmd.port = PORT_MII;
  1736. ecmd.transceiver = XCVR_INTERNAL;
  1737. ecmd.phy_address = np->phys[0];
  1738. ecmd.speed = np->speed100 ? SPEED_100 : SPEED_10;
  1739. ecmd.duplex = np->full_duplex ? DUPLEX_FULL : DUPLEX_HALF;
  1740. ecmd.maxtxpkt = TX_RING_SIZE;
  1741. ecmd.maxrxpkt = np->intr_mitigation; /* not 100% accurate */
  1744. if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
  1745. return -EFAULT;
  1746. return 0;
  1748. case ETHTOOL_SSET: {
  1749. u16 autoneg, speed100, full_duplex;
  1751. autoneg = (ecmd.autoneg == AUTONEG_ENABLE);
  1752. speed100 = (ecmd.speed == SPEED_100);
  1753. full_duplex = (ecmd.duplex == DUPLEX_FULL);
  1755. np->autoneg = autoneg;
  1756. if (speed100 != np->speed100 ||
  1757.     full_duplex != np->full_duplex) {
  1758. np->speed100 = speed100;
  1759. np->full_duplex = full_duplex;
  1760. /* change advertising bits */
  1761. np->advertising &= ~(ADVERTISE_10HALF |
  1762.      ADVERTISE_10FULL |
  1763.      ADVERTISE_100HALF |
  1764.      ADVERTISE_100FULL |
  1765.      ADVERTISE_100BASE4);
  1766. if (speed100) {
  1767. if (full_duplex)
  1768. np->advertising |= ADVERTISE_100FULL;
  1769. else
  1770. np->advertising |= ADVERTISE_100HALF;
  1771. } else {
  1772. if (full_duplex)
  1773. np->advertising |= ADVERTISE_10FULL;
  1774. else
  1775. np->advertising |= ADVERTISE_10HALF;
  1776. }
  1777. }
  1778. check_duplex(dev);
  1779. return 0;
  1780. }
  1782. case ETHTOOL_GDRVINFO: {
  1783. struct ethtool_drvinfo info;
  1784. memset(&info, 0, sizeof(info));
  1785. info.cmd = ecmd.cmd;
  1786. strcpy(info.driver, DRV_NAME);
  1787. strcpy(info.version, DRV_VERSION);
  1788. *info.fw_version = 0;
  1789. strcpy(info.bus_info, PCI_SLOT_NAME(np->pci_dev));
  1790. if (copy_to_user(useraddr, &info, sizeof(info)))
  1791.        return -EFAULT;
  1792. return 0;
  1793. }
  1795. /* restart autonegotiation */
  1796. case ETHTOOL_NWAY_RST: {
  1797. int tmp;
  1798. int r = -EINVAL;
  1799. /* if autoneg is off, it's an error */
  1800. tmp = mdio_read(dev, np->phys[0], MII_BMCR);
  1801. if (tmp & BMCR_ANENABLE) {
  1802. tmp |= (BMCR_ANRESTART);
  1803. mdio_write(dev, np->phys[0], MII_BMCR, tmp);
  1804. r = 0;
  1805. }
  1806. return r;
  1807. }
  1808. /* get link status */
  1809. case ETHTOOL_GLINK: {
  1810. struct ethtool_value edata = {ETHTOOL_GLINK};
  1811. if (mdio_read(dev, np->phys[0], MII_BMSR) & BMSR_LSTATUS)
  1812. edata.data = 1;
  1813. else
  1814. edata.data = 0;
  1815. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  1816. return -EFAULT;
  1817. return 0;
  1818. }
  1820. /* get message-level */
  1821. case ETHTOOL_GMSGLVL: {
  1822. struct ethtool_value edata = {ETHTOOL_GMSGLVL};
  1823. edata.data = debug;
  1824. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  1825. return -EFAULT;
  1826. return 0;
  1827. }
  1828. /* set message-level */
  1829. case ETHTOOL_SMSGLVL: {
  1830. struct ethtool_value edata;
  1831. if (copy_from_user(&edata, useraddr, sizeof(edata)))
  1832. return -EFAULT;
  1833. debug = edata.data;
  1834. return 0;
  1835. }
  1836. default:
  1837. return -EOPNOTSUPP;
  1838. }
  1839. }
  1842. static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  1843. {
  1844. struct netdev_private *np = dev->priv;
  1845. struct mii_ioctl_data *data = (struct mii_ioctl_data *)&rq->ifr_data;
  1847. switch(cmd) {
  1848. case SIOCETHTOOL:
  1849. return netdev_ethtool_ioctl(dev, (void *) rq->ifr_data);
  1851. /* Legacy mii-diag interface */
  1852. case SIOCGMIIPHY: /* Get address of MII PHY in use. */
  1853. case SIOCDEVPRIVATE: /* for binary compat, remove in 2.5 */
  1854. data->phy_id = np->phys[0] & 0x1f;
  1855. /* Fall Through */
  1857. case SIOCGMIIREG: /* Read MII PHY register. */
  1858. case SIOCDEVPRIVATE+1: /* for binary compat, remove in 2.5 */
  1859. data->val_out = mdio_read(dev, data->phy_id & 0x1f, data->reg_num & 0x1f);
  1860. return 0;
  1862. case SIOCSMIIREG: /* Write MII PHY register. */
  1863. case SIOCDEVPRIVATE+2: /* for binary compat, remove in 2.5 */
  1864. if (!capable(CAP_NET_ADMIN))
  1865. return -EPERM;
  1866. if (data->phy_id == np->phys[0]) {
  1867. u16 value = data->val_in;
  1868. switch (data->reg_num) {
  1869. case 0:
  1870. if (value & (BMCR_RESET | BMCR_ANENABLE))
  1871. /* Autonegotiation. */
  1872. np->autoneg = 1;
  1873. else {
  1874. np->full_duplex = (value & BMCR_FULLDPLX) ? 1 : 0;
  1875. np->autoneg = 0;
  1876. }
  1877. break;
  1878. case 4:
  1879. np->advertising = value;
  1880. break;
  1881. }
  1882. check_duplex(dev);
  1883. }
  1884. mdio_write(dev, data->phy_id & 0x1f, data->reg_num & 0x1f, data->val_in);
  1885. return 0;
  1886. default:
  1887. return -EOPNOTSUPP;
  1888. }
  1889. }
  1891. static int netdev_close(struct net_device *dev)
  1892. {
  1893. long ioaddr = dev->base_addr;
  1894. struct netdev_private *np = dev->priv;
  1895. int i;
  1897. netif_stop_queue(dev);
  1898. netif_stop_if(dev);
  1900. if (debug > 1) {
  1901. printk(KERN_DEBUG "%s: Shutting down ethercard, Intr status %4.4x.n",
  1902.    dev->name, (int)readl(ioaddr + IntrStatus));
  1903. printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d,  Rx %d / %d.n",
  1904.    dev->name, np->cur_tx, np->dirty_tx, np->cur_rx, np->dirty_rx);
  1905. }
  1907. /* Disable interrupts by clearing the interrupt mask. */
  1908. writel(0, ioaddr + IntrEnable);
  1910. /* Stop the chip's Tx and Rx processes. */
  1912. #ifdef __i386__
  1913. if (debug > 2) {
  1914. printk("n"KERN_DEBUG"  Tx ring at %8.8x:n",
  1915.    np->tx_ring_dma);
  1916. for (i = 0; i < 8 /* TX_RING_SIZE is huge! */; i++)
  1917. printk(KERN_DEBUG " #%d desc. %8.8x %8.8x -> %8.8x.n",
  1918.        i, le32_to_cpu(np->tx_ring[i].status),
  1919.        le32_to_cpu(np->tx_ring[i].first_addr),
  1920.        le32_to_cpu(np->tx_done_q[i].status));
  1921. printk(KERN_DEBUG "  Rx ring at %8.8x -> %p:n",
  1922.        np->rx_ring_dma, np->rx_done_q);
  1923. if (np->rx_done_q)
  1924. for (i = 0; i < 8 /* RX_RING_SIZE */; i++) {
  1925. printk(KERN_DEBUG " #%d desc. %8.8x -> %8.8xn",
  1926.        i, le32_to_cpu(np->rx_ring[i].rxaddr), le32_to_cpu(np->rx_done_q[i].status));
  1927. }
  1928. }
  1929. #endif /* __i386__ debugging only */
  1931. free_irq(dev->irq, dev);
  1933. /* Free all the skbuffs in the Rx queue. */
  1934. for (i = 0; i < RX_RING_SIZE; i++) {
  1935. np->rx_ring[i].rxaddr = cpu_to_le32(0xBADF00D0); /* An invalid address. */
  1936. if (np->rx_info[i].skb != NULL) {
  1937. pci_unmap_single(np->pci_dev, np->rx_info[i].mapping, np->rx_buf_sz, PCI_DMA_FROMDEVICE);
  1938. dev_kfree_skb(np->rx_info[i].skb);
  1939. }
  1940. np->rx_info[i].skb = NULL;
  1941. np->rx_info[i].mapping = 0;
  1942. }
  1943. for (i = 0; i < TX_RING_SIZE; i++) {
  1944. struct sk_buff *skb = np->tx_info[i].skb;
  1945. #ifdef ZEROCOPY
  1946. int j;
  1947. #endif /* ZEROCOPY */
  1948. if (skb == NULL)
  1949. continue;
  1950. pci_unmap_single(np->pci_dev,
  1951.  np->tx_info[i].first_mapping,
  1952.  skb_first_frag_len(skb), PCI_DMA_TODEVICE);
  1953. np->tx_info[i].first_mapping = 0;
  1954. dev_kfree_skb(skb);
  1955. np->tx_info[i].skb = NULL;
  1956. #ifdef ZEROCOPY
  1957. for (j = 0; j < MAX_STARFIRE_FRAGS; j++)
  1958. if (np->tx_info[i].frag_mapping[j]) {
  1959. pci_unmap_single(np->pci_dev,
  1960.  np->tx_info[i].frag_mapping[j],
  1961.  skb_shinfo(skb)->frags[j].size,
  1962.  PCI_DMA_TODEVICE);
  1963. np->tx_info[i].frag_mapping[j] = 0;
  1964. } else
  1965. break;
  1966. #endif /* ZEROCOPY */
  1967. }
  1969. COMPAT_MOD_DEC_USE_COUNT;
  1971. return 0;
  1972. }
  1975. static void __devexit starfire_remove_one (struct pci_dev *pdev)
  1976. {
  1977. struct net_device *dev = pci_get_drvdata(pdev);
  1978. struct netdev_private *np;
  1980. if (!dev)
  1981. BUG();
  1983. np = dev->priv;
  1984. if (np->tx_done_q)
  1985. pci_free_consistent(pdev, PAGE_SIZE,
  1986.     np->tx_done_q, np->tx_done_q_dma);
  1987. if (np->rx_done_q)
  1988. pci_free_consistent(pdev,
  1989.     sizeof(struct rx_done_desc) * DONE_Q_SIZE,
  1990.     np->rx_done_q, np->rx_done_q_dma);
  1991. if (np->tx_ring)
  1992. pci_free_consistent(pdev, PAGE_SIZE,
  1993.     np->tx_ring, np->tx_ring_dma);
  1994. if (np->rx_ring)
  1995. pci_free_consistent(pdev, PAGE_SIZE,
  1996.     np->rx_ring, np->rx_ring_dma);
  1998. unregister_netdev(dev);
  1999. iounmap((char *)dev->base_addr);
  2000. pci_release_regions(pdev);
  2002. pci_set_drvdata(pdev, NULL);
  2003. kfree(dev); /* Will also free np!! */
  2004. }
  2007. static struct pci_driver starfire_driver = {
  2008. name: DRV_NAME,
  2009. probe: starfire_init_one,
  2010. remove: __devexit_p(starfire_remove_one),
  2011. id_table: starfire_pci_tbl,
  2012. };
  2015. static int __init starfire_init (void)
  2016. {
  2017. /* when a module, this is printed whether or not devices are found in probe */
  2018. #ifdef MODULE
  2019. printk(version);
  2020. #endif
  2021. return pci_module_init (&starfire_driver);
  2022. }
  2025. static void __exit starfire_cleanup (void)
  2026. {
  2027. pci_unregister_driver (&starfire_driver);
  2028. }
  2031. module_init(starfire_init);
  2032. module_exit(starfire_cleanup);
  2035. /*
  2036.  * Local variables:
  2037.  *  compile-command: "gcc -DMODULE -Wall -Wstrict-prototypes -O2 -c starfire.c"
  2038.  *  simple-compile-command: "gcc -DMODULE -O2 -c starfire.c"
  2039.  *  c-basic-offset: 8
  2040.  *  tab-width: 8
  2041.  * End:
  2042.  */