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

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

Linux/Unix编程

开发平台：

Unix_Linux

8139cp.c：源码内容
  1. /* 8139cp.c: A Linux PCI Ethernet driver for the RealTek 8139C+ chips. */
  2. /*
  3. Copyright 2001,2002 Jeff Garzik <jgarzik@mandrakesoft.com>
  5. Copyright (C) 2001, 2002 David S. Miller (davem@redhat.com) [tg3.c]
  6. Copyright (C) 2000, 2001 David S. Miller (davem@redhat.com) [sungem.c]
  7. Copyright 2001 Manfred Spraul     [natsemi.c]
  8. Copyright 1999-2001 by Donald Becker.     [natsemi.c]
  9.         Written 1997-2001 by Donald Becker.     [8139too.c]
  10. Copyright 1998-2001 by Jes Sorensen, <jes@trained-monkey.org>. [acenic.c]
  12. This software may be used and distributed according to the terms of
  13. the GNU General Public License (GPL), incorporated herein by reference.
  14. Drivers based on or derived from this code fall under the GPL and must
  15. retain the authorship, copyright and license notice.  This file is not
  16. a complete program and may only be used when the entire operating
  17. system is licensed under the GPL.
  19. See the file COPYING in this distribution for more information.
  21. Contributors:
  23. Wake-on-LAN support - Felipe Damasio <felipewd@terra.com.br>
  24. PCI suspend/resume  - Felipe Damasio <felipewd@terra.com.br>
  25. LinkChg interrupt   - Felipe Damasio <felipewd@terra.com.br>
  27. TODO, in rough priority order:
  28. * Test Tx checksumming thoroughly
  29. * dev->tx_timeout
  30. * Constants (module parms?) for Rx work limit
  31. * Complete reset on PciErr
  32. * Consider Rx interrupt mitigation using TimerIntr
  33. * Implement 8139C+ statistics dump; maybe not...
  34.   h/w stats can be reset only by software reset
  35. * Handle netif_rx return value
  36. * Investigate using skb->priority with h/w VLAN priority
  37. * Investigate using High Priority Tx Queue with skb->priority
  38. * Adjust Rx FIFO threshold and Max Rx DMA burst on Rx FIFO error
  39. * Adjust Tx FIFO threshold and Max Tx DMA burst on Tx FIFO error
  40. * Implement Tx software interrupt mitigation via
  41.   Tx descriptor bit
  42. * The real minimum of CP_MIN_MTU is 4 bytes.  However,
  43.   for this to be supported, one must(?) turn on packet padding.
  44. * Support 8169 GMII
  45. * Support external MII transceivers
  47.  */
  49. #define DRV_NAME "8139cp"
  50. #define DRV_VERSION "0.3.0"
  51. #define DRV_RELDATE "Sep 29, 2002"
  54. #include <linux/config.h>
  55. #include <linux/module.h>
  56. #include <linux/kernel.h>
  57. #include <linux/compiler.h>
  58. #include <linux/netdevice.h>
  59. #include <linux/etherdevice.h>
  60. #include <linux/init.h>
  61. #include <linux/pci.h>
  62. #include <linux/delay.h>
  63. #include <linux/ethtool.h>
  64. #include <linux/mii.h>
  65. #include <linux/if_vlan.h>
  66. #include <linux/crc32.h>
  67. #include <linux/in.h>
  68. #include <linux/ip.h>
  69. #include <linux/tcp.h>
  70. #include <linux/udp.h>
  71. #include <asm/io.h>
  72. #include <asm/uaccess.h>
  74. /* experimental TX checksumming feature enable/disable */
  75. #undef CP_TX_CHECKSUM
  77. /* VLAN tagging feature enable/disable */
  78. #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
  79. #define CP_VLAN_TAG_USED 1
  80. #define CP_VLAN_TX_TAG(tx_desc,vlan_tag_value) 
  81. do { (tx_desc)->opts2 = (vlan_tag_value); } while (0)
  82. #else
  83. #define CP_VLAN_TAG_USED 0
  84. #define CP_VLAN_TX_TAG(tx_desc,vlan_tag_value) 
  85. do { (tx_desc)->opts2 = 0; } while (0)
  86. #endif
  88. /* These identify the driver base version and may not be removed. */
  89. static char version[] __devinitdata =
  90. KERN_INFO DRV_NAME ": 10/100 PCI Ethernet driver v" DRV_VERSION " (" DRV_RELDATE ")n";
  92. MODULE_AUTHOR("Jeff Garzik <jgarzik@mandrakesoft.com>");
  93. MODULE_DESCRIPTION("RealTek RTL-8139C+ series 10/100 PCI Ethernet driver");
  94. MODULE_LICENSE("GPL");
  96. static int debug = -1;
  97. MODULE_PARM (debug, "i");
  98. MODULE_PARM_DESC (debug, "8139cp: bitmapped message enable number");
  100. /* Maximum number of multicast addresses to filter (vs. Rx-all-multicast).
  101.    The RTL chips use a 64 element hash table based on the Ethernet CRC.  */
  102. static int multicast_filter_limit = 32;
  103. MODULE_PARM (multicast_filter_limit, "i");
  104. MODULE_PARM_DESC (multicast_filter_limit, "8139cp: maximum number of filtered multicast addresses");
  106. #define PFX DRV_NAME ": "
  108. #ifndef TRUE
  109. #define FALSE 0
  110. #define TRUE (!FALSE)
  111. #endif
  113. #define CP_DEF_MSG_ENABLE (NETIF_MSG_DRV | 
  114.  NETIF_MSG_PROBE  | 
  115.  NETIF_MSG_LINK)
  116. #define CP_NUM_STATS 14 /* struct cp_dma_stats, plus one */
  117. #define CP_STATS_SIZE 64 /* size in bytes of DMA stats block */
  118. #define CP_REGS_SIZE (0xff + 1)
  119. #define CP_REGS_VER 1 /* version 1 */
  120. #define CP_RX_RING_SIZE 64
  121. #define CP_TX_RING_SIZE 64
  122. #define CP_RING_BYTES
  123. ((sizeof(struct cp_desc) * CP_RX_RING_SIZE) +
  124.  (sizeof(struct cp_desc) * CP_TX_RING_SIZE) +
  125.  CP_STATS_SIZE)
  126. #define NEXT_TX(N) (((N) + 1) & (CP_TX_RING_SIZE - 1))
  127. #define NEXT_RX(N) (((N) + 1) & (CP_RX_RING_SIZE - 1))
  128. #define TX_BUFFS_AVAIL(CP)
  129. (((CP)->tx_tail <= (CP)->tx_head) ?
  130.   (CP)->tx_tail + (CP_TX_RING_SIZE - 1) - (CP)->tx_head :
  131.   (CP)->tx_tail - (CP)->tx_head - 1)
  133. #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/
  134. #define RX_OFFSET 2
  135. #define CP_INTERNAL_PHY 32
  137. /* The following settings are log_2(bytes)-4:  0 == 16 bytes .. 6==1024, 7==end of packet. */
  138. #define RX_FIFO_THRESH 5 /* Rx buffer level before first PCI xfer.  */
  139. #define RX_DMA_BURST 4 /* Maximum PCI burst, '4' is 256 */
  140. #define TX_DMA_BURST 6 /* Maximum PCI burst, '6' is 1024 */
  141. #define TX_EARLY_THRESH 256 /* Early Tx threshold, in bytes */
  143. /* Time in jiffies before concluding the transmitter is hung. */
  144. #define TX_TIMEOUT (6*HZ)
  146. /* hardware minimum and maximum for a single frame's data payload */
  147. #define CP_MIN_MTU 60 /* TODO: allow lower, but pad */
  148. #define CP_MAX_MTU 4096
  150. enum {
  151. /* NIC register offsets */
  152. MAC0 = 0x00, /* Ethernet hardware address. */
  153. MAR0 = 0x08, /* Multicast filter. */
  154. StatsAddr = 0x10, /* 64-bit start addr of 64-byte DMA stats blk */
  155. TxRingAddr = 0x20, /* 64-bit start addr of Tx ring */
  156. HiTxRingAddr = 0x28, /* 64-bit start addr of high priority Tx ring */
  157. Cmd = 0x37, /* Command register */
  158. IntrMask = 0x3C, /* Interrupt mask */
  159. IntrStatus = 0x3E, /* Interrupt status */
  160. TxConfig = 0x40, /* Tx configuration */
  161. ChipVersion = 0x43, /* 8-bit chip version, inside TxConfig */
  162. RxConfig = 0x44, /* Rx configuration */
  163. Cfg9346 = 0x50, /* EEPROM select/control; Cfg reg [un]lock */
  164. Config1 = 0x52, /* Config1 */
  165. Config3 = 0x59, /* Config3 */
  166. Config4 = 0x5A, /* Config4 */
  167. MultiIntr = 0x5C, /* Multiple interrupt select */
  168. BasicModeCtrl = 0x62, /* MII BMCR */
  169. BasicModeStatus = 0x64, /* MII BMSR */
  170. NWayAdvert = 0x66, /* MII ADVERTISE */
  171. NWayLPAR = 0x68, /* MII LPA */
  172. NWayExpansion = 0x6A, /* MII Expansion */
  173. Config5 = 0xD8, /* Config5 */
  174. TxPoll = 0xD9, /* Tell chip to check Tx descriptors for work */
  175. RxMaxSize = 0xDA, /* Max size of an Rx packet (8169 only) */
  176. CpCmd = 0xE0, /* C+ Command register (C+ mode only) */
  177. IntrMitigate = 0xE2, /* rx/tx interrupt mitigation control */
  178. RxRingAddr = 0xE4, /* 64-bit start addr of Rx ring */
  179. TxThresh = 0xEC, /* Early Tx threshold */
  180. OldRxBufAddr = 0x30, /* DMA address of Rx ring buffer (C mode) */
  181. OldTSD0 = 0x10, /* DMA address of first Tx desc (C mode) */
  183. /* Tx and Rx status descriptors */
  184. DescOwn = (1 << 31), /* Descriptor is owned by NIC */
  185. RingEnd = (1 << 30), /* End of descriptor ring */
  186. FirstFrag = (1 << 29), /* First segment of a packet */
  187. LastFrag = (1 << 28), /* Final segment of a packet */
  188. TxError = (1 << 23), /* Tx error summary */
  189. RxError = (1 << 20), /* Rx error summary */
  190. IPCS = (1 << 18), /* Calculate IP checksum */
  191. UDPCS = (1 << 17), /* Calculate UDP/IP checksum */
  192. TCPCS = (1 << 16), /* Calculate TCP/IP checksum */
  193. TxVlanTag = (1 << 17), /* Add VLAN tag */
  194. RxVlanTagged = (1 << 16), /* Rx VLAN tag available */
  195. IPFail = (1 << 15), /* IP checksum failed */
  196. UDPFail = (1 << 14), /* UDP/IP checksum failed */
  197. TCPFail = (1 << 13), /* TCP/IP checksum failed */
  198. NormalTxPoll = (1 << 6),  /* One or more normal Tx packets to send */
  199. PID1 = (1 << 17), /* 2 protocol id bits:  0==non-IP, */
  200. PID0 = (1 << 16), /* 1==UDP/IP, 2==TCP/IP, 3==IP */
  201. RxProtoTCP = 1,
  202. RxProtoUDP = 2,
  203. RxProtoIP = 3,
  204. TxFIFOUnder = (1 << 25), /* Tx FIFO underrun */
  205. TxOWC = (1 << 22), /* Tx Out-of-window collision */
  206. TxLinkFail = (1 << 21), /* Link failed during Tx of packet */
  207. TxMaxCol = (1 << 20), /* Tx aborted due to excessive collisions */
  208. TxColCntShift = 16,      /* Shift, to get 4-bit Tx collision cnt */
  209. TxColCntMask = 0x01 | 0x02 | 0x04 | 0x08, /* 4-bit collision count */
  210. RxErrFrame = (1 << 27), /* Rx frame alignment error */
  211. RxMcast = (1 << 26), /* Rx multicast packet rcv'd */
  212. RxErrCRC = (1 << 18), /* Rx CRC error */
  213. RxErrRunt = (1 << 19), /* Rx error, packet < 64 bytes */
  214. RxErrLong = (1 << 21), /* Rx error, packet > 4096 bytes */
  215. RxErrFIFO = (1 << 22), /* Rx error, FIFO overflowed, pkt bad */
  217. /* StatsAddr register */
  218. DumpStats = (1 << 3),  /* Begin stats dump */
  220. /* RxConfig register */
  221. RxCfgFIFOShift = 13,      /* Shift, to get Rx FIFO thresh value */
  222. RxCfgDMAShift = 8,      /* Shift, to get Rx Max DMA value */
  223. AcceptErr = 0x20,      /* Accept packets with CRC errors */
  224. AcceptRunt = 0x10,      /* Accept runt (<64 bytes) packets */
  225. AcceptBroadcast = 0x08,      /* Accept broadcast packets */
  226. AcceptMulticast = 0x04,      /* Accept multicast packets */
  227. AcceptMyPhys = 0x02,      /* Accept pkts with our MAC as dest */
  228. AcceptAllPhys = 0x01,      /* Accept all pkts w/ physical dest */
  230. /* IntrMask / IntrStatus registers */
  231. PciErr = (1 << 15), /* System error on the PCI bus */
  232. TimerIntr = (1 << 14), /* Asserted when TCTR reaches TimerInt value */
  233. LenChg = (1 << 13), /* Cable length change */
  234. SWInt = (1 << 8),  /* Software-requested interrupt */
  235. TxEmpty = (1 << 7),  /* No Tx descriptors available */
  236. RxFIFOOvr = (1 << 6),  /* Rx FIFO Overflow */
  237. LinkChg = (1 << 5),  /* Packet underrun, or link change */
  238. RxEmpty = (1 << 4),  /* No Rx descriptors available */
  239. TxErr = (1 << 3),  /* Tx error */
  240. TxOK = (1 << 2),  /* Tx packet sent */
  241. RxErr = (1 << 1),  /* Rx error */
  242. RxOK = (1 << 0),  /* Rx packet received */
  243. IntrResvd = (1 << 10), /* reserved, according to RealTek engineers,
  244. but hardware likes to raise it */
  246. IntrAll = PciErr | TimerIntr | LenChg | SWInt | TxEmpty |
  247.   RxFIFOOvr | LinkChg | RxEmpty | TxErr | TxOK |
  248.   RxErr | RxOK | IntrResvd,
  250. /* C mode command register */
  251. CmdReset = (1 << 4),  /* Enable to reset; self-clearing */
  252. RxOn = (1 << 3),  /* Rx mode enable */
  253. TxOn = (1 << 2),  /* Tx mode enable */
  255. /* C+ mode command register */
  256. RxVlanOn = (1 << 6),  /* Rx VLAN de-tagging enable */
  257. RxChkSum = (1 << 5),  /* Rx checksum offload enable */
  258. PCIDAC = (1 << 4),  /* PCI Dual Address Cycle (64-bit PCI) */
  259. PCIMulRW = (1 << 3),  /* Enable PCI read/write multiple */
  260. CpRxOn = (1 << 1),  /* Rx mode enable */
  261. CpTxOn = (1 << 0),  /* Tx mode enable */
  263. /* Cfg9436 EEPROM control register */
  264. Cfg9346_Lock = 0x00,      /* Lock ConfigX/MII register access */
  265. Cfg9346_Unlock = 0xC0,      /* Unlock ConfigX/MII register access */
  267. /* TxConfig register */
  268. IFG = (1 << 25) | (1 << 24), /* standard IEEE interframe gap */
  269. TxDMAShift = 8,      /* DMA burst value (0-7) is shift this many bits */
  271. /* Early Tx Threshold register */
  272. TxThreshMask = 0x3f,      /* Mask bits 5-0 */
  273. TxThreshMax = 2048,      /* Max early Tx threshold */
  275. /* Config1 register */
  276. DriverLoaded = (1 << 5),  /* Software marker, driver is loaded */
  277. LWACT           = (1 << 4),  /* LWAKE active mode */
  278. PMEnable = (1 << 0),  /* Enable various PM features of chip */
  280. /* Config3 register */
  281. PARMEnable = (1 << 6),  /* Enable auto-loading of PHY parms */
  282. MagicPacket     = (1 << 5),  /* Wake up when receives a Magic Packet */
  283. LinkUp          = (1 << 4),  /* Wake up when the cable connection is re-established */
  285. /* Config4 register */
  286. LWPTN           = (1 << 1),  /* LWAKE Pattern */
  287. LWPME           = (1 << 4),  /* LANWAKE vs PMEB */
  289. /* Config5 register */
  290. BWF             = (1 << 6),  /* Accept Broadcast wakeup frame */
  291. MWF             = (1 << 5),  /* Accept Multicast wakeup frame */
  292. UWF             = (1 << 4),  /* Accept Unicast wakeup frame */
  293. LANWake         = (1 << 1),  /* Enable LANWake signal */
  294. PMEStatus = (1 << 0),  /* PME status can be reset by PCI RST# */
  295. };
  297. static const unsigned int cp_intr_mask =
  298. PciErr | LinkChg |
  299. RxOK | RxErr | RxEmpty | RxFIFOOvr |
  300. TxOK | TxErr | TxEmpty;
  302. static const unsigned int cp_rx_config =
  303.   (RX_FIFO_THRESH << RxCfgFIFOShift) |
  304.   (RX_DMA_BURST << RxCfgDMAShift);
  306. struct cp_desc {
  307. u32 opts1;
  308. u32 opts2;
  309. u64 addr;
  310. };
  312. struct ring_info {
  313. struct sk_buff *skb;
  314. dma_addr_t mapping;
  315. unsigned frag;
  316. };
  318. struct cp_dma_stats {
  319. u64 tx_ok;
  320. u64 rx_ok;
  321. u64 tx_err;
  322. u32 rx_err;
  323. u16 rx_fifo;
  324. u16 frame_align;
  325. u32 tx_ok_1col;
  326. u32 tx_ok_mcol;
  327. u64 rx_ok_phys;
  328. u64 rx_ok_bcast;
  329. u32 rx_ok_mcast;
  330. u16 tx_abort;
  331. u16 tx_underrun;
  332. } __attribute__((packed));
  334. struct cp_extra_stats {
  335. unsigned long rx_frags;
  336. };
  338. struct cp_private {
  339. unsigned tx_head;
  340. unsigned tx_tail;
  341. unsigned rx_tail;
  343. void *regs;
  344. struct net_device *dev;
  345. spinlock_t lock;
  347. struct cp_desc *rx_ring;
  348. struct cp_desc *tx_ring;
  349. struct ring_info tx_skb[CP_TX_RING_SIZE];
  350. struct ring_info rx_skb[CP_RX_RING_SIZE];
  351. unsigned rx_buf_sz;
  352. dma_addr_t ring_dma;
  354. #if CP_VLAN_TAG_USED
  355. struct vlan_group *vlgrp;
  356. #endif
  358. u32 msg_enable;
  360. struct net_device_stats net_stats;
  361. struct cp_extra_stats cp_stats;
  362. struct cp_dma_stats *nic_stats;
  363. dma_addr_t nic_stats_dma;
  365. struct pci_dev *pdev;
  366. u32 rx_config;
  368. struct sk_buff *frag_skb;
  369. unsigned dropping_frag : 1;
  370. unsigned pci_using_dac : 1;
  371. unsigned int board_type;
  373. unsigned int wol_enabled : 1; /* Is Wake-on-LAN enabled? */
  374. u32 power_state[16];
  376. struct mii_if_info mii_if;
  377. };
  379. #define cpr8(reg) readb(cp->regs + (reg))
  380. #define cpr16(reg) readw(cp->regs + (reg))
  381. #define cpr32(reg) readl(cp->regs + (reg))
  382. #define cpw8(reg,val) writeb((val), cp->regs + (reg))
  383. #define cpw16(reg,val) writew((val), cp->regs + (reg))
  384. #define cpw32(reg,val) writel((val), cp->regs + (reg))
  385. #define cpw8_f(reg,val) do {
  386. writeb((val), cp->regs + (reg));
  387. readb(cp->regs + (reg));
  388. } while (0)
  389. #define cpw16_f(reg,val) do {
  390. writew((val), cp->regs + (reg));
  391. readw(cp->regs + (reg));
  392. } while (0)
  393. #define cpw32_f(reg,val) do {
  394. writel((val), cp->regs + (reg));
  395. readl(cp->regs + (reg));
  396. } while (0)
  399. static void __cp_set_rx_mode (struct net_device *dev);
  400. static void cp_tx (struct cp_private *cp);
  401. static void cp_clean_rings (struct cp_private *cp);
  403. enum board_type {
  404. RTL8139Cp,
  405. RTL8169,
  406. };
  408. static struct cp_board_info {
  409. const char *name;
  410. } cp_board_tbl[] __devinitdata = {
  411. /* RTL8139Cp */
  412. { "RTL-8139C+" },
  414. /* RTL8169 */
  415. { "RTL-8169" },
  416. };
  418. static struct pci_device_id cp_pci_tbl[] __devinitdata = {
  419. { PCI_VENDOR_ID_REALTEK, PCI_DEVICE_ID_REALTEK_8139,
  420.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139Cp },
  421. #if 0
  422. { PCI_VENDOR_ID_REALTEK, PCI_DEVICE_ID_REALTEK_8169,
  423.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8169 },
  424. #endif
  425. { },
  426. };
  427. MODULE_DEVICE_TABLE(pci, cp_pci_tbl);
  429. static struct {
  430. const char str[ETH_GSTRING_LEN];
  431. } ethtool_stats_keys[] = {
  432. { "tx_ok" },
  433. { "rx_ok" },
  434. { "tx_err" },
  435. { "rx_err" },
  436. { "rx_fifo" },
  437. { "frame_align" },
  438. { "tx_ok_1col" },
  439. { "tx_ok_mcol" },
  440. { "rx_ok_phys" },
  441. { "rx_ok_bcast" },
  442. { "rx_ok_mcast" },
  443. { "tx_abort" },
  444. { "tx_underrun" },
  445. { "rx_frags" },
  446. };
  449. static inline void cp_set_rxbufsize (struct cp_private *cp)
  450. {
  451. unsigned int mtu = cp->dev->mtu;
  453. if (mtu > ETH_DATA_LEN)
  454. /* MTU + ethernet header + FCS + optional VLAN tag */
  455. cp->rx_buf_sz = mtu + ETH_HLEN + 8;
  456. else
  457. cp->rx_buf_sz = PKT_BUF_SZ;
  458. }
  460. static inline void cp_rx_skb (struct cp_private *cp, struct sk_buff *skb,
  461.       struct cp_desc *desc)
  462. {
  463. skb->protocol = eth_type_trans (skb, cp->dev);
  465. cp->net_stats.rx_packets++;
  466. cp->net_stats.rx_bytes += skb->len;
  467. cp->dev->last_rx = jiffies;
  469. #if CP_VLAN_TAG_USED
  470. if (cp->vlgrp && (desc->opts2 & RxVlanTagged)) {
  471. vlan_hwaccel_rx(skb, cp->vlgrp, desc->opts2 & 0xffff);
  472. } else
  473. #endif
  474. netif_rx(skb);
  475. }
  477. static void cp_rx_err_acct (struct cp_private *cp, unsigned rx_tail,
  478.     u32 status, u32 len)
  479. {
  480. if (netif_msg_rx_err (cp))
  481. printk (KERN_DEBUG
  482. "%s: rx err, slot %d status 0x%x len %dn",
  483. cp->dev->name, rx_tail, status, len);
  484. cp->net_stats.rx_errors++;
  485. if (status & RxErrFrame)
  486. cp->net_stats.rx_frame_errors++;
  487. if (status & RxErrCRC)
  488. cp->net_stats.rx_crc_errors++;
  489. if (status & RxErrRunt)
  490. cp->net_stats.rx_length_errors++;
  491. if (status & RxErrLong)
  492. cp->net_stats.rx_length_errors++;
  493. if (status & RxErrFIFO)
  494. cp->net_stats.rx_fifo_errors++;
  495. }
  497. static void cp_rx_frag (struct cp_private *cp, unsigned rx_tail,
  498. struct sk_buff *skb, u32 status, u32 len)
  499. {
  500. struct sk_buff *copy_skb, *frag_skb = cp->frag_skb;
  501. unsigned orig_len = frag_skb ? frag_skb->len : 0;
  502. unsigned target_len = orig_len + len;
  503. unsigned first_frag = status & FirstFrag;
  504. unsigned last_frag = status & LastFrag;
  506. if (netif_msg_rx_status (cp))
  507. printk (KERN_DEBUG "%s: rx %s%sfrag, slot %d status 0x%x len %dn",
  508. cp->dev->name,
  509. cp->dropping_frag ? "dropping " : "",
  510. first_frag ? "first " :
  511. last_frag ? "last " : "",
  512. rx_tail, status, len);
  514. cp->cp_stats.rx_frags++;
  516. if (!frag_skb && !first_frag)
  517. cp->dropping_frag = 1;
  518. if (cp->dropping_frag)
  519. goto drop_frag;
  521. copy_skb = dev_alloc_skb (target_len + RX_OFFSET);
  522. if (!copy_skb) {
  523. printk(KERN_WARNING "%s: rx slot %d alloc failedn",
  524.        cp->dev->name, rx_tail);
  526. cp->dropping_frag = 1;
  527. drop_frag:
  528. if (frag_skb) {
  529. dev_kfree_skb_irq(frag_skb);
  530. cp->frag_skb = NULL;
  531. }
  532. if (last_frag) {
  533. cp->net_stats.rx_dropped++;
  534. cp->dropping_frag = 0;
  535. }
  536. return;
  537. }
  539. copy_skb->dev = cp->dev;
  540. skb_reserve(copy_skb, RX_OFFSET);
  541. skb_put(copy_skb, target_len);
  542. if (frag_skb) {
  543. memcpy(copy_skb->data, frag_skb->data, orig_len);
  544. dev_kfree_skb_irq(frag_skb);
  545. }
  546. pci_dma_sync_single(cp->pdev, cp->rx_skb[rx_tail].mapping,
  547.     len, PCI_DMA_FROMDEVICE);
  548. memcpy(copy_skb->data + orig_len, skb->data, len);
  550. copy_skb->ip_summed = CHECKSUM_NONE;
  552. if (last_frag) {
  553. if (status & (RxError | RxErrFIFO)) {
  554. cp_rx_err_acct(cp, rx_tail, status, len);
  555. dev_kfree_skb_irq(copy_skb);
  556. } else
  557. cp_rx_skb(cp, copy_skb, &cp->rx_ring[rx_tail]);
  558. cp->frag_skb = NULL;
  559. } else {
  560. cp->frag_skb = copy_skb;
  561. }
  562. }
  564. static inline unsigned int cp_rx_csum_ok (u32 status)
  565. {
  566. unsigned int protocol = (status >> 16) & 0x3;
  568. if (likely((protocol == RxProtoTCP) && (!(status & TCPFail))))
  569. return 1;
  570. else if ((protocol == RxProtoUDP) && (!(status & UDPFail)))
  571. return 1;
  572. else if ((protocol == RxProtoIP) && (!(status & IPFail)))
  573. return 1;
  574. return 0;
  575. }
  577. static void cp_rx (struct cp_private *cp)
  578. {
  579. unsigned rx_tail = cp->rx_tail;
  580. unsigned rx_work = 100;
  582. while (rx_work--) {
  583. u32 status, len;
  584. dma_addr_t mapping;
  585. struct sk_buff *skb, *new_skb;
  586. struct cp_desc *desc;
  587. unsigned buflen;
  589. skb = cp->rx_skb[rx_tail].skb;
  590. if (!skb)
  591. BUG();
  593. desc = &cp->rx_ring[rx_tail];
  594. status = le32_to_cpu(desc->opts1);
  595. if (status & DescOwn)
  596. break;
  598. len = (status & 0x1fff) - 4;
  599. mapping = cp->rx_skb[rx_tail].mapping;
  601. if ((status & (FirstFrag | LastFrag)) != (FirstFrag | LastFrag)) {
  602. cp_rx_frag(cp, rx_tail, skb, status, len);
  603. goto rx_next;
  604. }
  606. if (status & (RxError | RxErrFIFO)) {
  607. cp_rx_err_acct(cp, rx_tail, status, len);
  608. goto rx_next;
  609. }
  611. if (netif_msg_rx_status(cp))
  612. printk(KERN_DEBUG "%s: rx slot %d status 0x%x len %dn",
  613.        cp->dev->name, rx_tail, status, len);
  615. buflen = cp->rx_buf_sz + RX_OFFSET;
  616. new_skb = dev_alloc_skb (buflen);
  617. if (!new_skb) {
  618. cp->net_stats.rx_dropped++;
  619. goto rx_next;
  620. }
  622. skb_reserve(new_skb, RX_OFFSET);
  623. new_skb->dev = cp->dev;
  625. pci_unmap_single(cp->pdev, mapping,
  626.  buflen, PCI_DMA_FROMDEVICE);
  628. /* Handle checksum offloading for incoming packets. */
  629. if (cp_rx_csum_ok(status))
  630. skb->ip_summed = CHECKSUM_UNNECESSARY;
  631. else
  632. skb->ip_summed = CHECKSUM_NONE;
  634. skb_put(skb, len);
  636. mapping =
  637. cp->rx_skb[rx_tail].mapping =
  638. pci_map_single(cp->pdev, new_skb->tail,
  639.        buflen, PCI_DMA_FROMDEVICE);
  640. cp->rx_skb[rx_tail].skb = new_skb;
  642. cp_rx_skb(cp, skb, desc);
  644. rx_next:
  645. cp->rx_ring[rx_tail].opts2 = 0;
  646. cp->rx_ring[rx_tail].addr = cpu_to_le64(mapping);
  647. if (rx_tail == (CP_RX_RING_SIZE - 1))
  648. desc->opts1 = cpu_to_le32(DescOwn | RingEnd |
  649.   cp->rx_buf_sz);
  650. else
  651. desc->opts1 = cpu_to_le32(DescOwn | cp->rx_buf_sz);
  652. rx_tail = NEXT_RX(rx_tail);
  653. }
  655. if (!rx_work)
  656. printk(KERN_WARNING "%s: rx work limit reachedn", cp->dev->name);
  658. cp->rx_tail = rx_tail;
  659. }
  661. static void cp_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
  662. {
  663. struct net_device *dev = dev_instance;
  664. struct cp_private *cp = dev->priv;
  665. u16 status;
  667. status = cpr16(IntrStatus);
  668. if (!status || (status == 0xFFFF))
  669. return;
  671. if (netif_msg_intr(cp))
  672. printk(KERN_DEBUG "%s: intr, status %04x cmd %02x cpcmd %04xn",
  673.         dev->name, status, cpr8(Cmd), cpr16(CpCmd));
  675. cpw16_f(IntrStatus, status);
  677. spin_lock(&cp->lock);
  679. if (status & (RxOK | RxErr | RxEmpty | RxFIFOOvr))
  680. cp_rx(cp);
  681. if (status & (TxOK | TxErr | TxEmpty | SWInt))
  682. cp_tx(cp);
  683. if (status & LinkChg)
  684. mii_check_media(&cp->mii_if, netif_msg_link(cp), FALSE);
  686. if (status & PciErr) {
  687. u16 pci_status;
  689. pci_read_config_word(cp->pdev, PCI_STATUS, &pci_status);
  690. pci_write_config_word(cp->pdev, PCI_STATUS, pci_status);
  691. printk(KERN_ERR "%s: PCI bus error, status=%04x, PCI status=%04xn",
  692.        dev->name, status, pci_status);
  693. }
  695. spin_unlock(&cp->lock);
  696. }
  698. static void cp_tx (struct cp_private *cp)
  699. {
  700. unsigned tx_head = cp->tx_head;
  701. unsigned tx_tail = cp->tx_tail;
  703. while (tx_tail != tx_head) {
  704. struct sk_buff *skb;
  705. u32 status;
  707. rmb();
  708. status = le32_to_cpu(cp->tx_ring[tx_tail].opts1);
  709. if (status & DescOwn)
  710. break;
  712. skb = cp->tx_skb[tx_tail].skb;
  713. if (!skb)
  714. BUG();
  716. pci_unmap_single(cp->pdev, cp->tx_skb[tx_tail].mapping,
  717. skb->len, PCI_DMA_TODEVICE);
  719. if (status & LastFrag) {
  720. if (status & (TxError | TxFIFOUnder)) {
  721. if (netif_msg_tx_err(cp))
  722. printk(KERN_DEBUG "%s: tx err, status 0x%xn",
  723.        cp->dev->name, status);
  724. cp->net_stats.tx_errors++;
  725. if (status & TxOWC)
  726. cp->net_stats.tx_window_errors++;
  727. if (status & TxMaxCol)
  728. cp->net_stats.tx_aborted_errors++;
  729. if (status & TxLinkFail)
  730. cp->net_stats.tx_carrier_errors++;
  731. if (status & TxFIFOUnder)
  732. cp->net_stats.tx_fifo_errors++;
  733. } else {
  734. cp->net_stats.collisions +=
  735. ((status >> TxColCntShift) & TxColCntMask);
  736. cp->net_stats.tx_packets++;
  737. cp->net_stats.tx_bytes += skb->len;
  738. if (netif_msg_tx_done(cp))
  739. printk(KERN_DEBUG "%s: tx done, slot %dn", cp->dev->name, tx_tail);
  740. }
  741. dev_kfree_skb_irq(skb);
  742. }
  744. cp->tx_skb[tx_tail].skb = NULL;
  746. tx_tail = NEXT_TX(tx_tail);
  747. }
  749. cp->tx_tail = tx_tail;
  751. if (netif_queue_stopped(cp->dev) && (TX_BUFFS_AVAIL(cp) > (MAX_SKB_FRAGS + 1)))
  752. netif_wake_queue(cp->dev);
  753. }
  755. static int cp_start_xmit (struct sk_buff *skb, struct net_device *dev)
  756. {
  757. struct cp_private *cp = dev->priv;
  758. unsigned entry;
  759. u32 eor;
  760. #if CP_VLAN_TAG_USED
  761. u32 vlan_tag = 0;
  762. #endif
  764. spin_lock_irq(&cp->lock);
  766. /* This is a hard error, log it. */
  767. if (TX_BUFFS_AVAIL(cp) <= (skb_shinfo(skb)->nr_frags + 1)) {
  768. netif_stop_queue(dev);
  769. spin_unlock_irq(&cp->lock);
  770. printk(KERN_ERR PFX "%s: BUG! Tx Ring full when queue awake!n",
  771.        dev->name);
  772. return 1;
  773. }
  775. #if CP_VLAN_TAG_USED
  776. if (cp->vlgrp && vlan_tx_tag_present(skb))
  777. vlan_tag = TxVlanTag | vlan_tx_tag_get(skb);
  778. #endif
  780. entry = cp->tx_head;
  781. eor = (entry == (CP_TX_RING_SIZE - 1)) ? RingEnd : 0;
  782. if (skb_shinfo(skb)->nr_frags == 0) {
  783. struct cp_desc *txd = &cp->tx_ring[entry];
  784. u32 len;
  785. dma_addr_t mapping;
  787. len = skb->len;
  788. mapping = pci_map_single(cp->pdev, skb->data, len, PCI_DMA_TODEVICE);
  789. CP_VLAN_TX_TAG(txd, vlan_tag);
  790. txd->addr = cpu_to_le64(mapping);
  791. wmb();
  793. #ifdef CP_TX_CHECKSUM
  794. if (skb->ip_summed == CHECKSUM_HW) {
  795. const struct iphdr *ip = skb->nh.iph;
  796. if (ip->protocol == IPPROTO_TCP)
  797. txd->opts1 = cpu_to_le32(eor | len | DescOwn |
  798.  FirstFrag | LastFrag |
  799.  IPCS | TCPCS);
  800. else if (ip->protocol == IPPROTO_UDP)
  801. txd->opts1 = cpu_to_le32(eor | len | DescOwn |
  802.  FirstFrag | LastFrag |
  803.  IPCS | UDPCS);
  804. else
  805. BUG();
  806. } else
  807. #endif
  808. txd->opts1 = cpu_to_le32(eor | len | DescOwn |
  809.  FirstFrag | LastFrag);
  810. wmb();
  812. cp->tx_skb[entry].skb = skb;
  813. cp->tx_skb[entry].mapping = mapping;
  814. cp->tx_skb[entry].frag = 0;
  815. entry = NEXT_TX(entry);
  816. } else {
  817. struct cp_desc *txd;
  818. u32 first_len, first_eor;
  819. dma_addr_t first_mapping;
  820. int frag, first_entry = entry;
  821. #ifdef CP_TX_CHECKSUM
  822. const struct iphdr *ip = skb->nh.iph;
  823. #endif
  825. /* We must give this initial chunk to the device last.
  826.  * Otherwise we could race with the device.
  827.  */
  828. first_eor = eor;
  829. first_len = skb->len - skb->data_len;
  830. first_mapping = pci_map_single(cp->pdev, skb->data,
  831.        first_len, PCI_DMA_TODEVICE);
  832. cp->tx_skb[entry].skb = skb;
  833. cp->tx_skb[entry].mapping = first_mapping;
  834. cp->tx_skb[entry].frag = 1;
  835. entry = NEXT_TX(entry);
  837. for (frag = 0; frag < skb_shinfo(skb)->nr_frags; frag++) {
  838. skb_frag_t *this_frag = &skb_shinfo(skb)->frags[frag];
  839. u32 len;
  840. u32 ctrl;
  841. dma_addr_t mapping;
  843. len = this_frag->size;
  844. mapping = pci_map_single(cp->pdev,
  845.  ((void *) page_address(this_frag->page) +
  846.   this_frag->page_offset),
  847.  len, PCI_DMA_TODEVICE);
  848. eor = (entry == (CP_TX_RING_SIZE - 1)) ? RingEnd : 0;
  849. #ifdef CP_TX_CHECKSUM
  850. if (skb->ip_summed == CHECKSUM_HW) {
  851. ctrl = eor | len | DescOwn | IPCS;
  852. if (ip->protocol == IPPROTO_TCP)
  853. ctrl |= TCPCS;
  854. else if (ip->protocol == IPPROTO_UDP)
  855. ctrl |= UDPCS;
  856. else
  857. BUG();
  858. } else
  859. #endif
  860. ctrl = eor | len | DescOwn;
  862. if (frag == skb_shinfo(skb)->nr_frags - 1)
  863. ctrl |= LastFrag;
  865. txd = &cp->tx_ring[entry];
  866. CP_VLAN_TX_TAG(txd, vlan_tag);
  867. txd->addr = cpu_to_le64(mapping);
  868. wmb();
  870. txd->opts1 = cpu_to_le32(ctrl);
  871. wmb();
  873. cp->tx_skb[entry].skb = skb;
  874. cp->tx_skb[entry].mapping = mapping;
  875. cp->tx_skb[entry].frag = frag + 2;
  876. entry = NEXT_TX(entry);
  877. }
  879. txd = &cp->tx_ring[first_entry];
  880. CP_VLAN_TX_TAG(txd, vlan_tag);
  881. txd->addr = cpu_to_le64(first_mapping);
  882. wmb();
  884. #ifdef CP_TX_CHECKSUM
  885. if (skb->ip_summed == CHECKSUM_HW) {
  886. if (ip->protocol == IPPROTO_TCP)
  887. txd->opts1 = cpu_to_le32(first_eor | first_len |
  888.  FirstFrag | DescOwn |
  889.  IPCS | TCPCS);
  890. else if (ip->protocol == IPPROTO_UDP)
  891. txd->opts1 = cpu_to_le32(first_eor | first_len |
  892.  FirstFrag | DescOwn |
  893.  IPCS | UDPCS);
  894. else
  895. BUG();
  896. } else
  897. #endif
  898. txd->opts1 = cpu_to_le32(first_eor | first_len |
  899.  FirstFrag | DescOwn);
  900. wmb();
  901. }
  902. cp->tx_head = entry;
  903. if (netif_msg_tx_queued(cp))
  904. printk(KERN_DEBUG "%s: tx queued, slot %d, skblen %dn",
  905.        dev->name, entry, skb->len);
  906. if (TX_BUFFS_AVAIL(cp) <= (MAX_SKB_FRAGS + 1))
  907. netif_stop_queue(dev);
  909. spin_unlock_irq(&cp->lock);
  911. cpw8(TxPoll, NormalTxPoll);
  912. dev->trans_start = jiffies;
  914. return 0;
  915. }
  917. /* Set or clear the multicast filter for this adaptor.
  918.    This routine is not state sensitive and need not be SMP locked. */
  920. static void __cp_set_rx_mode (struct net_device *dev)
  921. {
  922. struct cp_private *cp = dev->priv;
  923. u32 mc_filter[2]; /* Multicast hash filter */
  924. int i, rx_mode;
  925. u32 tmp;
  927. /* Note: do not reorder, GCC is clever about common statements. */
  928. if (dev->flags & IFF_PROMISC) {
  929. /* Unconditionally log net taps. */
  930. printk (KERN_NOTICE "%s: Promiscuous mode enabled.n",
  931. dev->name);
  932. rx_mode =
  933.     AcceptBroadcast | AcceptMulticast | AcceptMyPhys |
  934.     AcceptAllPhys;
  935. mc_filter[1] = mc_filter[0] = 0xffffffff;
  936. } else if ((dev->mc_count > multicast_filter_limit)
  937.    || (dev->flags & IFF_ALLMULTI)) {
  938. /* Too many to filter perfectly -- accept all multicasts. */
  939. rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
  940. mc_filter[1] = mc_filter[0] = 0xffffffff;
  941. } else {
  942. struct dev_mc_list *mclist;
  943. rx_mode = AcceptBroadcast | AcceptMyPhys;
  944. mc_filter[1] = mc_filter[0] = 0;
  945. for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
  946.      i++, mclist = mclist->next) {
  947. int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
  949. mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
  950. rx_mode |= AcceptMulticast;
  951. }
  952. }
  954. /* We can safely update without stopping the chip. */
  955. tmp = cp_rx_config | rx_mode;
  956. if (cp->rx_config != tmp) {
  957. cpw32_f (RxConfig, tmp);
  958. cp->rx_config = tmp;
  959. }
  960. cpw32_f (MAR0 + 0, mc_filter[0]);
  961. cpw32_f (MAR0 + 4, mc_filter[1]);
  962. }
  964. static void cp_set_rx_mode (struct net_device *dev)
  965. {
  966. unsigned long flags;
  967. struct cp_private *cp = dev->priv;
  969. spin_lock_irqsave (&cp->lock, flags);
  970. __cp_set_rx_mode(dev);
  971. spin_unlock_irqrestore (&cp->lock, flags);
  972. }
  974. static void __cp_get_stats(struct cp_private *cp)
  975. {
  976. /* XXX implement */
  977. }
  979. static struct net_device_stats *cp_get_stats(struct net_device *dev)
  980. {
  981. struct cp_private *cp = dev->priv;
  983. /* The chip only need report frame silently dropped. */
  984. spin_lock_irq(&cp->lock);
  985.   if (netif_running(dev) && netif_device_present(dev))
  986.   __cp_get_stats(cp);
  987. spin_unlock_irq(&cp->lock);
  989. return &cp->net_stats;
  990. }
  992. static void cp_stop_hw (struct cp_private *cp)
  993. {
  994. cpw16(IntrMask, 0);
  995. cpr16(IntrMask);
  996. cpw8(Cmd, 0);
  997. cpw16(CpCmd, 0);
  998. cpr16(CpCmd);
  999. cpw16(IntrStatus, ~(cpr16(IntrStatus)));
  1000. synchronize_irq();
  1001. udelay(10);
  1003. cp->rx_tail = 0;
  1004. cp->tx_head = cp->tx_tail = 0;
  1005. }
  1007. static void cp_reset_hw (struct cp_private *cp)
  1008. {
  1009. unsigned work = 1000;
  1011. cpw8(Cmd, CmdReset);
  1013. while (work--) {
  1014. if (!(cpr8(Cmd) & CmdReset))
  1015. return;
  1017. set_current_state(TASK_UNINTERRUPTIBLE);
  1018. schedule_timeout(10);
  1019. }
  1021. printk(KERN_ERR "%s: hardware reset timeoutn", cp->dev->name);
  1022. }
  1024. static inline void cp_start_hw (struct cp_private *cp)
  1025. {
  1026. u16 pci_dac = cp->pci_using_dac ? PCIDAC : 0;
  1027. if (cp->board_type == RTL8169)
  1028. cpw16(CpCmd, pci_dac | PCIMulRW | RxChkSum);
  1029. else
  1030. cpw16(CpCmd, pci_dac | PCIMulRW | RxChkSum | CpRxOn | CpTxOn);
  1031. cpw8(Cmd, RxOn | TxOn);
  1032. }
  1034. static void cp_init_hw (struct cp_private *cp)
  1035. {
  1036. struct net_device *dev = cp->dev;
  1038. cp_reset_hw(cp);
  1040. cpw8_f (Cfg9346, Cfg9346_Unlock);
  1042. /* Restore our idea of the MAC address. */
  1043. cpw32_f (MAC0 + 0, cpu_to_le32 (*(u32 *) (dev->dev_addr + 0)));
  1044. cpw32_f (MAC0 + 4, cpu_to_le32 (*(u32 *) (dev->dev_addr + 4)));
  1046. cp_start_hw(cp);
  1047. cpw8(TxThresh, 0x06); /* XXX convert magic num to a constant */
  1049. __cp_set_rx_mode(dev);
  1050. cpw32_f (TxConfig, IFG | (TX_DMA_BURST << TxDMAShift));
  1052. cpw8(Config1, cpr8(Config1) | DriverLoaded | PMEnable);
  1053. /* Disable Wake-on-LAN. Can be turned on with ETHTOOL_SWOL */
  1054. if (cp->board_type == RTL8139Cp) {
  1055. cpw8(Config3, PARMEnable);
  1056. cp->wol_enabled = 0;
  1057. }
  1058. cpw8(Config5, cpr8(Config5) & PMEStatus); 
  1059. if (cp->board_type == RTL8169)
  1060. cpw16(RxMaxSize, cp->rx_buf_sz);
  1062. cpw32_f(HiTxRingAddr, 0);
  1063. cpw32_f(HiTxRingAddr + 4, 0);
  1065. cpw32_f(RxRingAddr, cp->ring_dma);
  1066. cpw32_f(RxRingAddr + 4, 0); /* FIXME: 64-bit PCI */
  1067. cpw32_f(TxRingAddr, cp->ring_dma + (sizeof(struct cp_desc) * CP_RX_RING_SIZE));
  1068. cpw32_f(TxRingAddr + 4, 0); /* FIXME: 64-bit PCI */
  1070. cpw16(MultiIntr, 0);
  1072. cpw16_f(IntrMask, cp_intr_mask);
  1074. cpw8_f(Cfg9346, Cfg9346_Lock);
  1075. }
  1077. static int cp_refill_rx (struct cp_private *cp)
  1078. {
  1079. unsigned i;
  1081. for (i = 0; i < CP_RX_RING_SIZE; i++) {
  1082. struct sk_buff *skb;
  1084. skb = dev_alloc_skb(cp->rx_buf_sz + RX_OFFSET);
  1085. if (!skb)
  1086. goto err_out;
  1088. skb->dev = cp->dev;
  1089. skb_reserve(skb, RX_OFFSET);
  1091. cp->rx_skb[i].mapping = pci_map_single(cp->pdev,
  1092. skb->tail, cp->rx_buf_sz, PCI_DMA_FROMDEVICE);
  1093. cp->rx_skb[i].skb = skb;
  1094. cp->rx_skb[i].frag = 0;
  1096. cp->rx_ring[i].opts2 = 0;
  1097. cp->rx_ring[i].addr = cpu_to_le64(cp->rx_skb[i].mapping);
  1098. if (i == (CP_RX_RING_SIZE - 1))
  1099. cp->rx_ring[i].opts1 =
  1100. cpu_to_le32(DescOwn | RingEnd | cp->rx_buf_sz);
  1101. else
  1102. cp->rx_ring[i].opts1 =
  1103. cpu_to_le32(DescOwn | cp->rx_buf_sz);
  1104. }
  1106. return 0;
  1108. err_out:
  1109. cp_clean_rings(cp);
  1110. return -ENOMEM;
  1111. }
  1113. static int cp_init_rings (struct cp_private *cp)
  1114. {
  1115. memset(cp->tx_ring, 0, sizeof(struct cp_desc) * CP_TX_RING_SIZE);
  1116. cp->tx_ring[CP_TX_RING_SIZE - 1].opts1 = cpu_to_le32(RingEnd);
  1118. cp->rx_tail = 0;
  1119. cp->tx_head = cp->tx_tail = 0;
  1121. return cp_refill_rx (cp);
  1122. }
  1124. static int cp_alloc_rings (struct cp_private *cp)
  1125. {
  1126. void *mem;
  1128. mem = pci_alloc_consistent(cp->pdev, CP_RING_BYTES, &cp->ring_dma);
  1129. if (!mem)
  1130. return -ENOMEM;
  1132. cp->rx_ring = mem;
  1133. cp->tx_ring = &cp->rx_ring[CP_RX_RING_SIZE];
  1135. mem += (CP_RING_BYTES - CP_STATS_SIZE);
  1136. cp->nic_stats = mem;
  1137. cp->nic_stats_dma = cp->ring_dma + (CP_RING_BYTES - CP_STATS_SIZE);
  1139. return cp_init_rings(cp);
  1140. }
  1142. static void cp_clean_rings (struct cp_private *cp)
  1143. {
  1144. unsigned i;
  1146. memset(cp->rx_ring, 0, sizeof(struct cp_desc) * CP_RX_RING_SIZE);
  1147. memset(cp->tx_ring, 0, sizeof(struct cp_desc) * CP_TX_RING_SIZE);
  1149. for (i = 0; i < CP_RX_RING_SIZE; i++) {
  1150. if (cp->rx_skb[i].skb) {
  1151. pci_unmap_single(cp->pdev, cp->rx_skb[i].mapping,
  1152.  cp->rx_buf_sz, PCI_DMA_FROMDEVICE);
  1153. dev_kfree_skb(cp->rx_skb[i].skb);
  1154. }
  1155. }
  1157. for (i = 0; i < CP_TX_RING_SIZE; i++) {
  1158. if (cp->tx_skb[i].skb) {
  1159. struct sk_buff *skb = cp->tx_skb[i].skb;
  1160. pci_unmap_single(cp->pdev, cp->tx_skb[i].mapping,
  1161.  skb->len, PCI_DMA_TODEVICE);
  1162. dev_kfree_skb(skb);
  1163. cp->net_stats.tx_dropped++;
  1164. }
  1165. }
  1167. memset(&cp->rx_skb, 0, sizeof(struct ring_info) * CP_RX_RING_SIZE);
  1168. memset(&cp->tx_skb, 0, sizeof(struct ring_info) * CP_TX_RING_SIZE);
  1169. }
  1171. static void cp_free_rings (struct cp_private *cp)
  1172. {
  1173. cp_clean_rings(cp);
  1174. pci_free_consistent(cp->pdev, CP_RING_BYTES, cp->rx_ring, cp->ring_dma);
  1175. cp->rx_ring = NULL;
  1176. cp->tx_ring = NULL;
  1177. cp->nic_stats = NULL;
  1178. }
  1180. static int cp_open (struct net_device *dev)
  1181. {
  1182. struct cp_private *cp = dev->priv;
  1183. int rc;
  1185. if (netif_msg_ifup(cp))
  1186. printk(KERN_DEBUG "%s: enabling interfacen", dev->name);
  1188. rc = cp_alloc_rings(cp);
  1189. if (rc)
  1190. return rc;
  1192. cp_init_hw(cp);
  1194. rc = request_irq(dev->irq, cp_interrupt, SA_SHIRQ, dev->name, dev);
  1195. if (rc)
  1196. goto err_out_hw;
  1198. netif_carrier_off(dev);
  1199. mii_check_media(&cp->mii_if, netif_msg_link(cp), TRUE);
  1200. netif_start_queue(dev);
  1202. return 0;
  1204. err_out_hw:
  1205. cp_stop_hw(cp);
  1206. cp_free_rings(cp);
  1207. return rc;
  1208. }
  1210. static int cp_close (struct net_device *dev)
  1211. {
  1212. struct cp_private *cp = dev->priv;
  1214. if (netif_msg_ifdown(cp))
  1215. printk(KERN_DEBUG "%s: disabling interfacen", dev->name);
  1217. netif_stop_queue(dev);
  1218. netif_carrier_off(dev);
  1220. spin_lock_irq(&cp->lock);
  1221. cp_stop_hw(cp);
  1222. spin_unlock_irq(&cp->lock);
  1224. free_irq(dev->irq, dev);
  1225. cp_free_rings(cp);
  1226. return 0;
  1227. }
  1229. #ifdef BROKEN
  1230. static int cp_change_mtu(struct net_device *dev, int new_mtu)
  1231. {
  1232. struct cp_private *cp = dev->priv;
  1233. int rc;
  1235. /* check for invalid MTU, according to hardware limits */
  1236. if (new_mtu < CP_MIN_MTU || new_mtu > CP_MAX_MTU)
  1237. return -EINVAL;
  1239. /* if network interface not up, no need for complexity */
  1240. if (!netif_running(dev)) {
  1241. dev->mtu = new_mtu;
  1242. cp_set_rxbufsize(cp); /* set new rx buf size */
  1243. return 0;
  1244. }
  1246. spin_lock_irq(&cp->lock);
  1248. cp_stop_hw(cp); /* stop h/w and free rings */
  1249. cp_clean_rings(cp);
  1251. dev->mtu = new_mtu;
  1252. cp_set_rxbufsize(cp); /* set new rx buf size */
  1253. if (cp->board_type == RTL8169)
  1254. cpw16(RxMaxSize, cp->rx_buf_sz);
  1256. rc = cp_init_rings(cp); /* realloc and restart h/w */
  1257. cp_start_hw(cp);
  1259. spin_unlock_irq(&cp->lock);
  1261. return rc;
  1262. }
  1263. #endif /* BROKEN */
  1265. static char mii_2_8139_map[8] = {
  1266. BasicModeCtrl,
  1267. BasicModeStatus,
  1268. 0,
  1269. 0,
  1270. NWayAdvert,
  1271. NWayLPAR,
  1272. NWayExpansion,
  1273. 0
  1274. };
  1276. static int mdio_read(struct net_device *dev, int phy_id, int location)
  1277. {
  1278. struct cp_private *cp = dev->priv;
  1280. return location < 8 && mii_2_8139_map[location] ?
  1281.        readw(cp->regs + mii_2_8139_map[location]) : 0;
  1282. }
  1285. static void mdio_write(struct net_device *dev, int phy_id, int location,
  1286.        int value)
  1287. {
  1288. struct cp_private *cp = dev->priv;
  1290. if (location == 0) {
  1291. cpw8(Cfg9346, Cfg9346_Unlock);
  1292. cpw16(BasicModeCtrl, value);
  1293. cpw8(Cfg9346, Cfg9346_Lock);
  1294. } else if (location < 8 && mii_2_8139_map[location])
  1295. cpw16(mii_2_8139_map[location], value);
  1296. }
  1298. /* Set the ethtool Wake-on-LAN settings */
  1299. static void netdev_set_wol (struct cp_private *cp,
  1300.                      const struct ethtool_wolinfo *wol)
  1301. {
  1302. u8 options;
  1304. options = cpr8 (Config3) & ~(LinkUp | MagicPacket);
  1305. /* If WOL is being disabled, no need for complexity */
  1306. if (wol->wolopts) {
  1307. if (wol->wolopts & WAKE_PHY) options |= LinkUp;
  1308. if (wol->wolopts & WAKE_MAGIC) options |= MagicPacket;
  1309. }
  1311. cpw8 (Cfg9346, Cfg9346_Unlock);
  1312. cpw8 (Config3, options);
  1313. cpw8 (Cfg9346, Cfg9346_Lock);
  1315. options = 0; /* Paranoia setting */
  1316. options = cpr8 (Config5) & ~(UWF | MWF | BWF);
  1317. /* If WOL is being disabled, no need for complexity */
  1318. if (wol->wolopts) {
  1319. if (wol->wolopts & WAKE_UCAST)  options |= UWF;
  1320. if (wol->wolopts & WAKE_BCAST) options |= BWF;
  1321. if (wol->wolopts & WAKE_MCAST) options |= MWF;
  1322. }
  1324. cpw8 (Config5, options);
  1326. cp->wol_enabled = (wol->wolopts) ? 1 : 0;
  1327. }
  1329. /* Get the ethtool Wake-on-LAN settings */
  1330. static void netdev_get_wol (struct cp_private *cp,
  1331.              struct ethtool_wolinfo *wol)
  1332. {
  1333. u8 options;
  1335. wol->wolopts   = 0; /* Start from scratch */
  1336. wol->supported = WAKE_PHY   | WAKE_BCAST | WAKE_MAGIC |
  1337.          WAKE_MCAST | WAKE_UCAST;
  1338. /* We don't need to go on if WOL is disabled */
  1339. if (!cp->wol_enabled) return;
  1341. options        = cpr8 (Config3);
  1342. if (options & LinkUp)        wol->wolopts |= WAKE_PHY;
  1343. if (options & MagicPacket)   wol->wolopts |= WAKE_MAGIC;
  1345. options        = 0; /* Paranoia setting */
  1346. options        = cpr8 (Config5);
  1347. if (options & UWF)           wol->wolopts |= WAKE_UCAST;
  1348. if (options & BWF)           wol->wolopts |= WAKE_BCAST;
  1349. if (options & MWF)           wol->wolopts |= WAKE_MCAST;
  1350. }
  1352. static int cp_ethtool_ioctl (struct cp_private *cp, void *useraddr)
  1353. {
  1354. u32 ethcmd;
  1356. /* dev_ioctl() in ../../net/core/dev.c has already checked
  1357.    capable(CAP_NET_ADMIN), so don't bother with that here.  */
  1359. if (get_user(ethcmd, (u32 *)useraddr))
  1360. return -EFAULT;
  1362. switch (ethcmd) {
  1364. case ETHTOOL_GDRVINFO: {
  1365. struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
  1366. strcpy (info.driver, DRV_NAME);
  1367. strcpy (info.version, DRV_VERSION);
  1368. strcpy (info.bus_info, cp->pdev->slot_name);
  1369. info.regdump_len = CP_REGS_SIZE;
  1370. info.n_stats = CP_NUM_STATS;
  1371. if (copy_to_user (useraddr, &info, sizeof (info)))
  1372. return -EFAULT;
  1373. return 0;
  1374. }
  1376. /* get settings */
  1377. case ETHTOOL_GSET: {
  1378. struct ethtool_cmd ecmd = { ETHTOOL_GSET };
  1379. spin_lock_irq(&cp->lock);
  1380. mii_ethtool_gset(&cp->mii_if, &ecmd);
  1381. spin_unlock_irq(&cp->lock);
  1382. if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
  1383. return -EFAULT;
  1384. return 0;
  1385. }
  1386. /* set settings */
  1387. case ETHTOOL_SSET: {
  1388. int r;
  1389. struct ethtool_cmd ecmd;
  1390. if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
  1391. return -EFAULT;
  1392. spin_lock_irq(&cp->lock);
  1393. r = mii_ethtool_sset(&cp->mii_if, &ecmd);
  1394. spin_unlock_irq(&cp->lock);
  1395. return r;
  1396. }
  1397. /* restart autonegotiation */
  1398. case ETHTOOL_NWAY_RST: {
  1399. return mii_nway_restart(&cp->mii_if);
  1400. }
  1401. /* get link status */
  1402. case ETHTOOL_GLINK: {
  1403. struct ethtool_value edata = {ETHTOOL_GLINK};
  1404. edata.data = mii_link_ok(&cp->mii_if);
  1405. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  1406. return -EFAULT;
  1407. return 0;
  1408. }
  1410. /* get message-level */
  1411. case ETHTOOL_GMSGLVL: {
  1412. struct ethtool_value edata = {ETHTOOL_GMSGLVL};
  1413. edata.data = cp->msg_enable;
  1414. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  1415. return -EFAULT;
  1416. return 0;
  1417. }
  1418. /* set message-level */
  1419. case ETHTOOL_SMSGLVL: {
  1420. struct ethtool_value edata;
  1421. if (copy_from_user(&edata, useraddr, sizeof(edata)))
  1422. return -EFAULT;
  1423. cp->msg_enable = edata.data;
  1424. return 0;
  1425. }
  1427. /* NIC register dump */
  1428. case ETHTOOL_GREGS: {
  1429.                 struct ethtool_regs regs;
  1430.                 u8 *regbuf = kmalloc(CP_REGS_SIZE, GFP_KERNEL);
  1431.                 int rc;
  1433. if (!regbuf)
  1434. return -ENOMEM;
  1435. memset(regbuf, 0, CP_REGS_SIZE);
  1437.                 rc = copy_from_user(&regs, useraddr, sizeof(regs));
  1438. if (rc) {
  1439. rc = -EFAULT;
  1440. goto err_out_gregs;
  1441. }
  1442.                 
  1443.                 if (regs.len > CP_REGS_SIZE)
  1444.                         regs.len = CP_REGS_SIZE;
  1445.                 if (regs.len < CP_REGS_SIZE) {
  1446. rc = -EINVAL;
  1447. goto err_out_gregs;
  1448. }
  1450.                 regs.version = CP_REGS_VER;
  1451.                 rc = copy_to_user(useraddr, &regs, sizeof(regs));
  1452. if (rc) {
  1453. rc = -EFAULT;
  1454. goto err_out_gregs;
  1455. }
  1457.                 useraddr += offsetof(struct ethtool_regs, data);
  1459.                 spin_lock_irq(&cp->lock);
  1460.                 memcpy_fromio(regbuf, cp->regs, CP_REGS_SIZE);
  1461.                 spin_unlock_irq(&cp->lock);
  1463.                 if (copy_to_user(useraddr, regbuf, regs.len))
  1464.                         rc = -EFAULT;
  1466. err_out_gregs:
  1467. kfree(regbuf);
  1468. return rc;
  1469. }
  1471. /* get/set RX checksumming */
  1472. case ETHTOOL_GRXCSUM: {
  1473. struct ethtool_value edata = { ETHTOOL_GRXCSUM };
  1474. u16 cmd = cpr16(CpCmd) & RxChkSum;
  1476. edata.data = cmd ? 1 : 0;
  1477. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  1478. return -EFAULT;
  1479. return 0;
  1480. }
  1481. case ETHTOOL_SRXCSUM: {
  1482. struct ethtool_value edata;
  1483. u16 cmd = cpr16(CpCmd), newcmd;
  1485. newcmd = cmd;
  1487. if (copy_from_user(&edata, useraddr, sizeof(edata)))
  1488. return -EFAULT;
  1490. if (edata.data)
  1491. newcmd |= RxChkSum;
  1492. else
  1493. newcmd &= ~RxChkSum;
  1495. if (newcmd == cmd)
  1496. return 0;
  1498. spin_lock_irq(&cp->lock);
  1499. cpw16_f(CpCmd, newcmd);
  1500. spin_unlock_irq(&cp->lock);
  1501. }
  1503. /* get/set TX checksumming */
  1504. case ETHTOOL_GTXCSUM: {
  1505. struct ethtool_value edata = { ETHTOOL_GTXCSUM };
  1507. edata.data = (cp->dev->features & NETIF_F_IP_CSUM) != 0;
  1508. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  1509. return -EFAULT;
  1510. return 0;
  1511. }
  1512. case ETHTOOL_STXCSUM: {
  1513. struct ethtool_value edata;
  1515. if (copy_from_user(&edata, useraddr, sizeof(edata)))
  1516. return -EFAULT;
  1518. if (edata.data)
  1519. cp->dev->features |= NETIF_F_IP_CSUM;
  1520. else
  1521. cp->dev->features &= ~NETIF_F_IP_CSUM;
  1523. return 0;
  1524. }
  1526. /* get/set scatter-gather */
  1527. case ETHTOOL_GSG: {
  1528. struct ethtool_value edata = { ETHTOOL_GSG };
  1530. edata.data = (cp->dev->features & NETIF_F_SG) != 0;
  1531. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  1532. return -EFAULT;
  1533. return 0;
  1534. }
  1535. case ETHTOOL_SSG: {
  1536. struct ethtool_value edata;
  1538. if (copy_from_user(&edata, useraddr, sizeof(edata)))
  1539. return -EFAULT;
  1541. if (edata.data)
  1542. cp->dev->features |= NETIF_F_SG;
  1543. else
  1544. cp->dev->features &= ~NETIF_F_SG;
  1546. return 0;
  1547. }
  1549. /* get string list(s) */
  1550. case ETHTOOL_GSTRINGS: {
  1551. struct ethtool_gstrings estr = { ETHTOOL_GSTRINGS };
  1553. if (copy_from_user(&estr, useraddr, sizeof(estr)))
  1554. return -EFAULT;
  1555. if (estr.string_set != ETH_SS_STATS)
  1556. return -EINVAL;
  1558. estr.len = CP_NUM_STATS;
  1559. if (copy_to_user(useraddr, &estr, sizeof(estr)))
  1560. return -EFAULT;
  1561. if (copy_to_user(useraddr + sizeof(estr),
  1562.  &ethtool_stats_keys,
  1563.  sizeof(ethtool_stats_keys)))
  1564. return -EFAULT;
  1565. return 0;
  1566. }
  1568. /* get NIC-specific statistics */
  1569. case ETHTOOL_GSTATS: {
  1570. struct ethtool_stats estats = { ETHTOOL_GSTATS };
  1571. u64 *tmp_stats;
  1572. unsigned int work = 100;
  1573. const unsigned int sz = sizeof(u64) * CP_NUM_STATS;
  1574. int i;
  1576. /* begin NIC statistics dump */
  1577. cpw32(StatsAddr + 4, 0); /* FIXME: 64-bit PCI */
  1578. cpw32(StatsAddr, cp->nic_stats_dma | DumpStats);
  1579. cpr32(StatsAddr);
  1581. estats.n_stats = CP_NUM_STATS;
  1582. if (copy_to_user(useraddr, &estats, sizeof(estats)))
  1583. return -EFAULT;
  1585. while (work-- > 0) {
  1586. if ((cpr32(StatsAddr) & DumpStats) == 0)
  1587. break;
  1588. cpu_relax();
  1589. }
  1591. if (cpr32(StatsAddr) & DumpStats)
  1592. return -EIO;
  1594. tmp_stats = kmalloc(sz, GFP_KERNEL);
  1595. if (!tmp_stats)
  1596. return -ENOMEM;
  1597. memset(tmp_stats, 0, sz);
  1599. i = 0;
  1600. tmp_stats[i++] = le64_to_cpu(cp->nic_stats->tx_ok);
  1601. tmp_stats[i++] = le64_to_cpu(cp->nic_stats->rx_ok);
  1602. tmp_stats[i++] = le64_to_cpu(cp->nic_stats->tx_err);
  1603. tmp_stats[i++] = le32_to_cpu(cp->nic_stats->rx_err);
  1604. tmp_stats[i++] = le16_to_cpu(cp->nic_stats->rx_fifo);
  1605. tmp_stats[i++] = le16_to_cpu(cp->nic_stats->frame_align);
  1606. tmp_stats[i++] = le32_to_cpu(cp->nic_stats->tx_ok_1col);
  1607. tmp_stats[i++] = le32_to_cpu(cp->nic_stats->tx_ok_mcol);
  1608. tmp_stats[i++] = le64_to_cpu(cp->nic_stats->rx_ok_phys);
  1609. tmp_stats[i++] = le64_to_cpu(cp->nic_stats->rx_ok_bcast);
  1610. tmp_stats[i++] = le32_to_cpu(cp->nic_stats->rx_ok_mcast);
  1611. tmp_stats[i++] = le16_to_cpu(cp->nic_stats->tx_abort);
  1612. tmp_stats[i++] = le16_to_cpu(cp->nic_stats->tx_underrun);
  1613. tmp_stats[i++] = cp->cp_stats.rx_frags;
  1614. if (i != CP_NUM_STATS)
  1615. BUG();
  1617. i = copy_to_user(useraddr + sizeof(estats),
  1618.  tmp_stats, sz);
  1619. kfree(tmp_stats);
  1621. if (i)
  1622. return -EFAULT;
  1623. return 0;
  1624. }
  1626. /* get/set Wake-on-LAN settings */
  1627. case ETHTOOL_GWOL: {
  1628. struct ethtool_wolinfo wol = { ETHTOOL_GWOL };
  1630. spin_lock_irq (&cp->lock);
  1631. netdev_get_wol (cp, &wol);
  1632. spin_unlock_irq (&cp->lock);
  1633. return ((copy_to_user (useraddr, &wol, sizeof (wol)))? -EFAULT : 0);
  1634. }
  1636. case ETHTOOL_SWOL: {
  1637. struct ethtool_wolinfo wol;
  1639. if (copy_from_user (&wol, useraddr, sizeof (wol)))
  1640. return -EFAULT;
  1641. spin_lock_irq (&cp->lock);
  1642. netdev_set_wol (cp, &wol);
  1643. spin_unlock_irq (&cp->lock);
  1644. return 0;
  1645. }
  1647. default:
  1648. break;
  1649. }
  1651. return -EOPNOTSUPP;
  1652. }
  1655. static int cp_ioctl (struct net_device *dev, struct ifreq *rq, int cmd)
  1656. {
  1657. struct cp_private *cp = dev->priv;
  1658. struct mii_ioctl_data *mii = (struct mii_ioctl_data *) &rq->ifr_data;
  1659. int rc;
  1661. if (!netif_running(dev))
  1662. return -EINVAL;
  1664. if (cmd == SIOCETHTOOL)
  1665. return cp_ethtool_ioctl(cp, (void *) rq->ifr_data);
  1667. spin_lock_irq(&cp->lock);
  1668. rc = generic_mii_ioctl(&cp->mii_if, mii, cmd, NULL);
  1669. spin_unlock_irq(&cp->lock);
  1670. return rc;
  1671. }
  1673. #if CP_VLAN_TAG_USED
  1674. static void cp_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
  1675. {
  1676. struct cp_private *cp = dev->priv;
  1678. spin_lock_irq(&cp->lock);
  1679. cp->vlgrp = grp;
  1680. cpw16(CpCmd, cpr16(CpCmd) | RxVlanOn);
  1681. spin_unlock_irq(&cp->lock);
  1682. }
  1684. static void cp_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
  1685. {
  1686. struct cp_private *cp = dev->priv;
  1688. spin_lock_irq(&cp->lock);
  1689. cpw16(CpCmd, cpr16(CpCmd) & ~RxVlanOn);
  1690. if (cp->vlgrp)
  1691. cp->vlgrp->vlan_devices[vid] = NULL;
  1692. spin_unlock_irq(&cp->lock);
  1693. }
  1694. #endif
  1696. /* Serial EEPROM section. */
  1698. /*  EEPROM_Ctrl bits. */
  1699. #define EE_SHIFT_CLK 0x04 /* EEPROM shift clock. */
  1700. #define EE_CS 0x08 /* EEPROM chip select. */
  1701. #define EE_DATA_WRITE 0x02 /* EEPROM chip data in. */
  1702. #define EE_WRITE_0 0x00
  1703. #define EE_WRITE_1 0x02
  1704. #define EE_DATA_READ 0x01 /* EEPROM chip data out. */
  1705. #define EE_ENB (0x80 | EE_CS)
  1707. /* Delay between EEPROM clock transitions.
  1708.    No extra delay is needed with 33Mhz PCI, but 66Mhz may change this.
  1709.  */
  1711. #define eeprom_delay() readl(ee_addr)
  1713. /* The EEPROM commands include the alway-set leading bit. */
  1714. #define EE_WRITE_CMD (5)
  1715. #define EE_READ_CMD (6)
  1716. #define EE_ERASE_CMD (7)
  1718. static int __devinit read_eeprom (void *ioaddr, int location, int addr_len)
  1719. {
  1720. int i;
  1721. unsigned retval = 0;
  1722. void *ee_addr = ioaddr + Cfg9346;
  1723. int read_cmd = location | (EE_READ_CMD << addr_len);
  1725. writeb (EE_ENB & ~EE_CS, ee_addr);
  1726. writeb (EE_ENB, ee_addr);
  1727. eeprom_delay ();
  1729. /* Shift the read command bits out. */
  1730. for (i = 4 + addr_len; i >= 0; i--) {
  1731. int dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
  1732. writeb (EE_ENB | dataval, ee_addr);
  1733. eeprom_delay ();
  1734. writeb (EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
  1735. eeprom_delay ();
  1736. }
  1737. writeb (EE_ENB, ee_addr);
  1738. eeprom_delay ();
  1740. for (i = 16; i > 0; i--) {
  1741. writeb (EE_ENB | EE_SHIFT_CLK, ee_addr);
  1742. eeprom_delay ();
  1743. retval =
  1744.     (retval << 1) | ((readb (ee_addr) & EE_DATA_READ) ? 1 :
  1745.      0);
  1746. writeb (EE_ENB, ee_addr);
  1747. eeprom_delay ();
  1748. }
  1750. /* Terminate the EEPROM access. */
  1751. writeb (~EE_CS, ee_addr);
  1752. eeprom_delay ();
  1754. return retval;
  1755. }
  1757. /* Put the board into D3cold state and wait for WakeUp signal */
  1758. static void cp_set_d3_state (struct cp_private *cp)
  1759. {
  1760. pci_enable_wake (cp->pdev, 0, 1); /* Enable PME# generation */
  1761. pci_set_power_state (cp->pdev, 3);
  1762. }
  1764. static int __devinit cp_init_one (struct pci_dev *pdev,
  1765.   const struct pci_device_id *ent)
  1766. {
  1767. struct net_device *dev;
  1768. struct cp_private *cp;
  1769. int rc;
  1770. void *regs;
  1771. long pciaddr;
  1772. unsigned int addr_len, i;
  1773. u8 pci_rev, cache_size;
  1774. u16 pci_command;
  1775. unsigned int board_type = (unsigned int) ent->driver_data;
  1777. #ifndef MODULE
  1778. static int version_printed;
  1779. if (version_printed++ == 0)
  1780. printk("%s", version);
  1781. #endif
  1783. pci_read_config_byte(pdev, PCI_REVISION_ID, &pci_rev);
  1785. if (pdev->vendor == PCI_VENDOR_ID_REALTEK &&
  1786.     pdev->device == PCI_DEVICE_ID_REALTEK_8139 && pci_rev < 0x20) {
  1787. printk(KERN_ERR PFX "pci dev %s (id %04x:%04x rev %02x) is not an 8139C+ compatible chipn",
  1788.        pdev->slot_name, pdev->vendor, pdev->device, pci_rev);
  1789. printk(KERN_ERR PFX "Try the "8139too" driver instead.n");
  1790. return -ENODEV;
  1791. }
  1793. dev = alloc_etherdev(sizeof(struct cp_private));
  1794. if (!dev)
  1795. return -ENOMEM;
  1796. SET_MODULE_OWNER(dev);
  1797. cp = dev->priv;
  1798. cp->pdev = pdev;
  1799. cp->board_type = board_type;
  1800. cp->dev = dev;
  1801. cp->msg_enable = (debug < 0 ? CP_DEF_MSG_ENABLE : debug);
  1802. spin_lock_init (&cp->lock);
  1803. cp->mii_if.dev = dev;
  1804. cp->mii_if.mdio_read = mdio_read;
  1805. cp->mii_if.mdio_write = mdio_write;
  1806. cp->mii_if.phy_id = CP_INTERNAL_PHY;
  1807. cp->mii_if.phy_id_mask = 0x1f;
  1808. cp->mii_if.reg_num_mask = 0x1f;
  1809. cp_set_rxbufsize(cp);
  1811. rc = pci_enable_device(pdev);
  1812. if (rc)
  1813. goto err_out_free;
  1815. rc = pci_request_regions(pdev, DRV_NAME);
  1816. if (rc)
  1817. goto err_out_disable;
  1819. if (pdev->irq < 2) {
  1820. rc = -EIO;
  1821. printk(KERN_ERR PFX "invalid irq (%d) for pci dev %sn",
  1822.        pdev->irq, pdev->slot_name);
  1823. goto err_out_res;
  1824. }
  1825. pciaddr = pci_resource_start(pdev, 1);
  1826. if (!pciaddr) {
  1827. rc = -EIO;
  1828. printk(KERN_ERR PFX "no MMIO resource for pci dev %sn",
  1829.        pdev->slot_name);
  1830. goto err_out_res;
  1831. }
  1832. if (pci_resource_len(pdev, 1) < CP_REGS_SIZE) {
  1833. rc = -EIO;
  1834. printk(KERN_ERR PFX "MMIO resource (%lx) too small on pci dev %sn",
  1835.        pci_resource_len(pdev, 1), pdev->slot_name);
  1836. goto err_out_res;
  1837. }
  1839. /* Configure DMA attributes. */
  1840. if (!pci_set_dma_mask(pdev, (u64) 0xffffffffffffffff)) {
  1841. cp->pci_using_dac = 1;
  1842. } else {
  1843. rc = pci_set_dma_mask(pdev, (u64) 0xffffffff);
  1844. if (rc) {
  1845. printk(KERN_ERR PFX "No usable DMA configuration, "
  1846.        "aborting.n");
  1847. goto err_out_res;
  1848. }
  1849. cp->pci_using_dac = 0;
  1850. }
  1852. regs = ioremap_nocache(pciaddr, CP_REGS_SIZE);
  1853. if (!regs) {
  1854. rc = -EIO;
  1855. printk(KERN_ERR PFX "Cannot map PCI MMIO (%lx@%lx) on pci dev %sn",
  1856.        pci_resource_len(pdev, 1), pciaddr, pdev->slot_name);
  1857. goto err_out_res;
  1858. }
  1859. dev->base_addr = (unsigned long) regs;
  1860. cp->regs = regs;
  1862. cp_stop_hw(cp);
  1864. /* read MAC address from EEPROM */
  1865. addr_len = read_eeprom (regs, 0, 8) == 0x8129 ? 8 : 6;
  1866. for (i = 0; i < 3; i++)
  1867. ((u16 *) (dev->dev_addr))[i] =
  1868.     le16_to_cpu (read_eeprom (regs, i + 7, addr_len));
  1870. dev->open = cp_open;
  1871. dev->stop = cp_close;
  1872. dev->set_multicast_list = cp_set_rx_mode;
  1873. dev->hard_start_xmit = cp_start_xmit;
  1874. dev->get_stats = cp_get_stats;
  1875. dev->do_ioctl = cp_ioctl;
  1876. #ifdef BROKEN
  1877. dev->change_mtu = cp_change_mtu;
  1878. #endif
  1879. #if 0
  1880. dev->tx_timeout = cp_tx_timeout;
  1881. dev->watchdog_timeo = TX_TIMEOUT;
  1882. #endif
  1883. #ifdef CP_TX_CHECKSUM
  1884. dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
  1885. #endif
  1886. #if CP_VLAN_TAG_USED
  1887. dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
  1888. dev->vlan_rx_register = cp_vlan_rx_register;
  1889. dev->vlan_rx_kill_vid = cp_vlan_rx_kill_vid;
  1890. #endif
  1892. dev->irq = pdev->irq;
  1894. rc = register_netdev(dev);
  1895. if (rc)
  1896. goto err_out_iomap;
  1898. printk (KERN_INFO "%s: %s at 0x%lx, "
  1899. "%02x:%02x:%02x:%02x:%02x:%02x, "
  1900. "IRQ %dn",
  1901. dev->name,
  1902. cp_board_tbl[board_type].name,
  1903. dev->base_addr,
  1904. dev->dev_addr[0], dev->dev_addr[1],
  1905. dev->dev_addr[2], dev->dev_addr[3],
  1906. dev->dev_addr[4], dev->dev_addr[5],
  1907. dev->irq);
  1909. pci_set_drvdata(pdev, dev);
  1911. /*
  1912.  * Looks like this is necessary to deal with on all architectures,
  1913.  * even this %$#%$# N440BX Intel based thing doesn't get it right.
  1914.  * Ie. having two NICs in the machine, one will have the cache
  1915.  * line set at boot time, the other will not.
  1916.  */
  1917. pci_read_config_byte(pdev, PCI_CACHE_LINE_SIZE, &cache_size);
  1918. cache_size <<= 2;
  1919. if (cache_size != SMP_CACHE_BYTES) {
  1920. printk(KERN_INFO "%s: PCI cache line size set incorrectly "
  1921.        "(%i bytes) by BIOS/FW, ", dev->name, cache_size);
  1922. if (cache_size > SMP_CACHE_BYTES)
  1923. printk("expecting %in", SMP_CACHE_BYTES);
  1924. else {
  1925. printk("correcting to %in", SMP_CACHE_BYTES);
  1926. pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
  1927.       SMP_CACHE_BYTES >> 2);
  1928. }
  1929. }
  1931. /* enable busmastering and memory-write-invalidate */
  1932. pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
  1933. if (!(pci_command & PCI_COMMAND_INVALIDATE)) {
  1934. pci_command |= PCI_COMMAND_INVALIDATE;
  1935. pci_write_config_word(pdev, PCI_COMMAND, pci_command);
  1936. }
  1937. pci_set_master(pdev);
  1939. if (cp->wol_enabled) cp_set_d3_state (cp);
  1941. return 0;
  1943. err_out_iomap:
  1944. iounmap(regs);
  1945. err_out_res:
  1946. pci_release_regions(pdev);
  1947. err_out_disable:
  1948. pci_disable_device(pdev);
  1949. err_out_free:
  1950. kfree(dev);
  1951. return rc;
  1952. }
  1954. static void __devexit cp_remove_one (struct pci_dev *pdev)
  1955. {
  1956. struct net_device *dev = pci_get_drvdata(pdev);
  1957. struct cp_private *cp = dev->priv;
  1959. if (!dev)
  1960. BUG();
  1961. unregister_netdev(dev);
  1962. iounmap(cp->regs);
  1963. if (cp->wol_enabled) pci_set_power_state (pdev, 0);
  1964. pci_release_regions(pdev);
  1965. pci_disable_device(pdev);
  1966. pci_set_drvdata(pdev, NULL);
  1967. kfree(dev);
  1968. }
  1970. #ifdef CONFIG_PM
  1971. static int cp_suspend (struct pci_dev *pdev, u32 state)
  1972. {
  1973. struct net_device *dev;
  1974. struct cp_private *cp;
  1975. unsigned long flags;
  1977. dev = pci_get_drvdata (pdev);
  1978. cp  = dev->priv;
  1980. if (!dev || !netif_running (dev)) return 0;
  1982. netif_device_detach (dev);
  1983. netif_stop_queue (dev);
  1985. spin_lock_irqsave (&cp->lock, flags);
  1987. /* Disable Rx and Tx */
  1988. cpw16 (IntrMask, 0);
  1989. cpw8  (Cmd, cpr8 (Cmd) & (~RxOn | ~TxOn));
  1991. spin_unlock_irqrestore (&cp->lock, flags);
  1993. if (cp->pdev && cp->wol_enabled) {
  1994. pci_save_state (cp->pdev, cp->power_state);
  1995. cp_set_d3_state (cp);
  1996. }
  1998. return 0;
  1999. }
  2001. static int cp_resume (struct pci_dev *pdev)
  2002. {
  2003. struct net_device *dev;
  2004. struct cp_private *cp;
  2006. dev = pci_get_drvdata (pdev);
  2007. cp  = dev->priv;
  2009. netif_device_attach (dev);
  2011. if (cp->pdev && cp->wol_enabled) {
  2012. pci_set_power_state (cp->pdev, 0);
  2013. pci_restore_state (cp->pdev, cp->power_state);
  2014. }
  2016. cp_init_hw (cp);
  2017. netif_start_queue (dev);
  2019. return 0;
  2020. }
  2021. #endif /* CONFIG_PM */
  2023. static struct pci_driver cp_driver = {
  2024. .name         = DRV_NAME,
  2025. .id_table     = cp_pci_tbl,
  2026. .probe        = cp_init_one,
  2027. .remove       = __devexit_p(cp_remove_one),
  2028. #ifdef CONFIG_PM
  2029. .resume       = cp_resume,
  2030. .suspend      = cp_suspend,
  2031. #endif
  2032. };
  2034. static int __init cp_init (void)
  2035. {
  2036. #ifdef MODULE
  2037. printk("%s", version);
  2038. #endif
  2039. return pci_module_init (&cp_driver);
  2040. }
  2042. static void __exit cp_exit (void)
  2043. {
  2044. pci_unregister_driver (&cp_driver);
  2045. }
  2047. module_init(cp_init);
  2048. module_exit(cp_exit);