Linux 网卡设备驱动

时间：2021-02-09 15:10:38

Linux 网卡驱动


刺猬@http://blog.csdn.net/littlehedgehog






网上一位前辈写的，时至今日，代码很多编译通不过(主要是Linux 内核变化实在太快)，我把代码移植到我的ubuntu 8.10下测试成功，里面也加上了我的注解。不过还有不少东西没有搞懂，手头上也没有相关的硬件资料，就一份Realtek 的datasheet。 TNND，后面要备考备荒，手头的事情只能放一放。



  1. #include <linux/module.h>
  2. #include <linux/kernel.h>
  3. #include <linux/compiler.h>
  4. #include <linux/pci.h>
  5. #include <linux/init.h>
  6. #include <linux/ioport.h>
  7. #include <linux/netdevice.h>
  8. #include <linux/etherdevice.h>
  9. #include <linux/rtnetlink.h>
  10. #include <linux/delay.h>
  11. #include <linux/ethtool.h>
  12. #include <linux/completion.h>
  13. #include <linux/crc32.h>
  14. #include <linux/mii.h>
  15. #include <asm/io.h>
  16. #include <asm/uaccess.h>
  17. #include <asm/irq.h>
  19. #if defined(CONFIG_SH_DREAMCAST)
  20. #define RX_BUF_IDX  1   /* 16K ring */
  21. #else
  22. #define RX_BUF_IDX  2   /* 32K ring */
  23. #endif
  24. #define RX_BUF_LEN  (8192 << RX_BUF_IDX)
  25. #define RX_BUF_PAD  16
  26. #define RX_BUF_WRAP_PAD 2048 /* spare padding to handle lack of packet wrap */
  28. #if RX_BUF_LEN == 65536
  29. #define RX_BUF_TOT_LEN  RX_BUF_LEN
  30. #else
  31. #define RX_BUF_TOT_LEN  (RX_BUF_LEN + RX_BUF_PAD + RX_BUF_WRAP_PAD)
  32. #endif
  34. typedef enum
  35. {
  36.     RTL8139 = 0,
  37.     RTL8129,
  38. } board_t;
  39. static struct pci_device_id xc_id[] =
  40. {
  41.     {0x10ec, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  42.     {0x10ec, 0x8138, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  43.     {0x1113, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  44.     {0x1500, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  45.     {0x4033, 0x1360, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  46.     {0x1186, 0x1300, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  47.     {0x1186, 0x1340, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  48.     {0x13d1, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  49.     {0x1259, 0xa117, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  50.     {0x1259, 0xa11e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  51.     {0x14ea, 0xab06, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  52.     {0x14ea, 0xab07, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  53.     {0x11db, 0x1234, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  54.     {0x1432, 0x9130, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  55.     {0x02ac, 0x1012, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  56.     {0x018a, 0x0106, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  57.     {0x126c, 0x1211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  58.     {0x1743, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  59.     {0x021b, 0x8139, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  60. #ifdef CONFIG_SH_SECUREEDGE5410
  61.     /* Bogus 8139 silicon reports 8129 without external PROM :-*/
  62.     {0x10ec, 0x8129, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8139 },
  63. #endif
  64. #ifdef CONFIG_8139TOO_8129
  65.     {0x10ec, 0x8129, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RTL8129 },
  66. #endif
  67.     {PCI_ANY_ID, 0x8139, 0x10ec, 0x8139, 0, 0, RTL8139 },
  68.     {PCI_ANY_ID, 0x8139, 0x1186, 0x1300, 0, 0, RTL8139 },
  69.     {PCI_ANY_ID, 0x8139, 0x13d1, 0xab06, 0, 0, RTL8139 },
  70.     {0,}
  71. };
  72. MODULE_DEVICE_TABLE (pci,xc_id);
  74. enum RTL8139_registers
  75. {
  76.     MAC0 = 0,       /* Ethernet hardware address. */
  77.     MAR0 = 8,       /* Multicast filter. */
  78.     TxStatus0 = 0x10,   /* Transmit status (Four 32bit registers). */
  79.     TxAddr0 = 0x20,     /*物理地址*/
  80.     RxBuf = 0x30,       /*物理地址*/
  81.     ChipCmd = 0x37,
  82.     RxBufPtr = 0x38,
  83.     IntrMask = 0x3C,
  84.     IntrStatus = 0x3E,
  85.     TxConfig = 0x40,
  86.     RxConfig = 0x44,
  87.     RxMissed = 0x4C,
  88.     Cfg9346 = 0x50,
  89.     Config1 = 0x52,
  90.     Config3 = 0x59,
  91.     Config4 = 0x5A,
  92.     HltClk = 0x5B,
  93.     MultiIntr = 0x5C,
  94.     /*MII*/
  95.     BasicModeCtrl = 0x62,
  96.     BasicModeStatus = 0x64,
  97.     NWayAdvert = 0x66,
  98.     NWayLPAR = 0x68,
  99.     NWayExpansion = 0x6A,
  100.     /*MII*/
  101.     CSCR = 0x74,
  102. };
  103. enum ChipCmdBits  /*ChipCmd = 0x37 register*/
  104. {
  105.     CmdReset = 0x10,/*chip重置*/
  106.     CmdRxEnb = 0x08,/*开启读*/
  107.     CmdTxEnb = 0x04,/*开启写*/
  108.     RxBufEmpty = 0x01,/*如果设置这个位表示接收缓冲区为空*/
  109. };
  110. enum IntrStatusBits
  111. {
  112.     PCIErr = 0x8000,
  113.     PCSTimeout = 0x4000,
  114.     RxFIFOOver = 0x40,
  115.     RxUnderrun = 0x20,
  116.     RxOverflow = 0x10,
  117.     TxErr = 0x08,
  118.     TxOK = 0x04,
  119.     RxErr = 0x02,
  120.     RxOK = 0x01,
  122.     RxAckBits = RxFIFOOver | RxOverflow | RxOK,
  123. };
  124. static const u16 xc_intr_mask =
  125.     PCIErr | PCSTimeout | RxUnderrun | RxOverflow | RxFIFOOver |
  126.     TxErr | TxOK | RxErr | RxOK;
  127. static const u16 xc_norx_intr_mask =/*不包含任何接收中断*/
  128.     PCIErr | PCSTimeout | RxUnderrun | TxErr | TxOK | RxErr ;
  129. enum Config1Bits  /*Config1 = 0x52*/
  130. {
  131.     Cfg1_PM_Enable = 0x01,/*开启电源管理(cfg9346要设置为可写)*/
  132.     LWAKE = 0x10,/*于Config4的LWPTN共同工作 同时设置为0为(active high)*/
  133. };
  134. enum Config3Bits  /*Config3 = 0x59*/
  135. {
  136.     Cfg3_Magic     = (1 << 5), /* 1 = wake up on Magic Packet (tm) */
  137. };
  138. enum Config4Bits  /*Config4 = 0x5A*/
  139. {
  140.     LWPTN = (1 << 2),/*于Config1的LWAKE共同工作 同时设置为0为(active high)*/
  141. };
  142. enum Cfg9346Bits
  143. {
  144.     Cfg9346_lock = 0x00,/*一般状态*/
  145.     Cfg9346_Unlock = 0xC0,/*可写状态*/
  146. };
  147. enum TxStatusBits  /*TxStatus0 = 0x10 共4个发送状态register 0x10-0x1f*/
  148. {
  149.     TxHostOwns = 0x2000,
  150.     TxUnderrun = 0x4000,/*在发送数据时如果，Tx FIFO耗尽时设置为1*/
  151.     TxStatOK = 0x8000,/*发送数据成功*/
  152.     TxOutOfWindow = 0x20000000,/*发生 "out of windown" 冲突*/
  153.     TxAborted = 0x40000000,/*设置为1表示发送被中止，该位是只读的*/
  154.     TxCarrierLost = 0x80000000,/*在发送数据包时，carrier丢失*/
  155. };
  156. /* Bits in RxConfig. */
  157. enum rx_mode_bits
  158. {
  159.     AcceptErr = 0x20,
  160.     AcceptRunt = 0x10,
  161.     AcceptBroadcast = 0x08,
  162.     AcceptMulticast = 0x04,
  163.     AcceptMyPhys = 0x02,
  164.     AcceptAllPhys = 0x01,
  165. };
  166. typedef enum
  167. {
  168.     CH_8139 = 0,
  169.     CH_8139_K,
  170.     CH_8139A,
  171.     CH_8139A_G,
  172.     CH_8139B,
  173.     CH_8130,
  174.     CH_8139C,
  175.     CH_8100,
  176.     CH_8100B_8139D,/*我的网卡类型 HOHO～ */
  177.     CH_8101,
  178. } chip_t;
  179. enum chip_flags
  180. {
  181.     HasHltClk = (1 << 0),
  182.     HasLWake = (1 << 1),
  183. };
  184. #define HW_REVID(b30, b29, b28, b27, b26, b23, b22) /
  185.     (b30<<30 | b29<<29 | b28<<28 | b27<<27 | b26<<26 | b23<<23 | b22<<22)
  186. #define HW_REVID_MASK   HW_REVID(1, 1, 1, 1, 1, 1, 1)
  187. static const struct
  188. {
  189.     const char *name;
  190.     u32 version; /* from RTL8139C/RTL8139D docs */
  191.     u32 flags;
  192. } rtl_chip_info[] =
  193. {
  194.     { "RTL-8139",HW_REVID(1, 0, 0, 0, 0, 0, 0),HasHltClk,},
  195.     { "RTL-8139 rev K",HW_REVID(1, 1, 0, 0, 0, 0, 0),HasHltClk,},
  196.     { "RTL-8139A",HW_REVID(1, 1, 1, 0, 0, 0, 0),HasHltClk,},
  197.     { "RTL-8139A rev G",HW_REVID(1, 1, 1, 0, 0, 1, 0),HasHltClk,},
  198.     { "RTL-8139B",HW_REVID(1, 1, 1, 1, 0, 0, 0),HasLWake,},
  199.     { "RTL-8130",HW_REVID(1, 1, 1, 1, 1, 0, 0),HasLWake,},
  200.     { "RTL-8139C",HW_REVID(1, 1, 1, 0, 1, 0, 0),HasLWake,},
  201.     { "RTL-8100",HW_REVID(1, 1, 1, 1, 0, 1, 0),HasLWake,},
  202.     { "RTL-8100B/8139D",HW_REVID(1, 1, 1, 0, 1, 0, 1),HasHltClk | HasLWake,},
  203.     { "RTL-8101", HW_REVID(1, 1, 1, 0, 1, 1, 1),HasLWake,},
  204. };
  205. struct xc_priv
  206. {
  207.     void __iomem *ioaddr;
  208.     spinlock_t lock;
  209.     spinlock_t rx_lock;
  210.     chip_t chipset;
  211.     struct napi_struct napi;
  212.     struct pci_dev *pdev;
  213.     struct net_device *dev;
  214.     struct net_device_stats stats;
  216.     u32 rx_config;
  217.     unsigned char *rx_bufs;
  218.     unsigned int cur_rx;
  219.     dma_addr_t rx_bufs_dma;
  221.     unsigned int tx_flag;
  222.     unsigned long cur_tx;
  223.     unsigned long dirty_tx;
  224.     unsigned char *tx_bufs;
  225.     unsigned char *tx_buf[4];
  226.     dma_addr_t tx_bufs_dma;
  227.     /*MII define*/
  228.     u32 msg_enable;
  229.     unsigned int default_port : 4;  /* Last dev->if_port value. */
  230.     signed char phys[4];            /* MII device addresses. */
  231.     struct mii_if_info mii;
  232.     /*MII*/
  233. };
  235. #if RX_BUF_IDX == 1
  236. static const unsigned int xc_rx_config =
  237.     (1 << 11) | (1 << 7) | (7 << 13) | (7 << 8);/*(1<<11) 16k-0x00002980*/
  238. #elif RX_BUF_IDX == 2
  239. static const unsigned int xc_rx_config =
  240.     (1 << 12) | (1 << 7) | (7 << 13) | (7 << 8);/*(1<<12) 32k-0x00003180*/
  241. #else
  242. #error "Invalid configuration for 8139_RXBUF_IDX"
  243. #endif
  245. /*MII*/
  246. static char mii_2_8139_map[8] =
  247. {
  248.     BasicModeCtrl,BasicModeStatus,0,0,
  249.     NWayAdvert,NWayLPAR,NWayExpansion,0
  250. };/*一些于MII相关的8139register*/
  252. static void xc_check_media(struct net_device *dev, unsigned int init_media)
  253. {
  254.     struct xc_priv *tp = netdev_priv(dev);
  255.     if (tp->phys[0] >= 0)
  256.         mii_check_media(&tp->mii, netif_msg_link(tp), init_media);
  257. }
  259. static int mdio_read (struct net_device *dev, int phy_id, int location)
  260. {
  261.     struct xc_priv *tp = netdev_priv(dev);
  262.     void __iomem *ioaddr = tp->ioaddr;
  263.     return location < 8 && mii_2_8139_map[location] ?
  264.            ioread16(ioaddr+mii_2_8139_map[location]) : 0;
  265. }
  267. static void mdio_write(struct net_device *dev, int phy_id, int location,int value)
  268. {
  269.     struct xc_priv *tp = netdev_priv(dev);
  270.     void __iomem *ioaddr = tp->ioaddr;
  271.     if (location < 8 && mii_2_8139_map[location])
  272.     {
  273.         if (location == 0)
  274.         {
  275.             iowrite8(Cfg9346_Unlock,ioaddr+Cfg9346);
  276.             iowrite16(value,ioaddr+BasicModeCtrl);
  277.             iowrite8(Cfg9346_lock,ioaddr+Cfg9346);
  278.         }
  279.         else
  280.             iowrite32(value,ioaddr+mii_2_8139_map[location]);
  281.     }
  282. }
  284. /*MII*/
  286. /*ethtool*/
  287. static u32 xc_get_link(struct net_device *dev)
  288. {
  289.     struct xc_priv *tp = netdev_priv(dev);
  290.     return mii_link_ok(&tp->mii);
  291. }
  293. static int xc_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
  294. {
  295.     struct xc_priv *tp = netdev_priv(dev);
  296.     spin_lock_irq(&tp->lock);
  297.     mii_ethtool_gset(&tp->mii, cmd);
  298.     spin_unlock_irq(&tp->lock);
  299.     return 0;
  300. }
  301. static struct ethtool_ops xc_ethtool_ops =
  302. {
  303.     .get_settings       = xc_get_settings,
  304.     .get_link       = xc_get_link,
  305. };
  306. /*ethtool*/
  308. static void __set_rx_mode (struct net_device *dev)
  309. {////(leave)
  310.     struct xc_priv *tp = netdev_priv(dev);
  311.     void __iomem *ioaddr = tp->ioaddr;
  312.     u32 mc_filter[2];   /* Multicast hash filter */
  313.     int i, rx_mode;
  314.     u32 tmp;
  316.     struct dev_mc_list *mclist;
  317.     rx_mode = AcceptBroadcast | AcceptMyPhys;
  318.     mc_filter[1] = mc_filter[0] = 0;
  319.     for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
  320.             i++, mclist = mclist->next)
  321.     {
  322.         int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
  324.         mc_filter[bit_nr >> 5] |= 1 << (bit_nr & 31);
  325.         rx_mode |= AcceptMulticast;
  326.     }
  328.     /* We can safely update without stopping the chip. */
  329.     tmp = xc_rx_config | rx_mode;
  330.     if (tp->rx_config != tmp)
  331.     {
  332.         iowrite32(tmp,ioaddr+RxConfig);
  333.         ioread32(ioaddr+RxConfig);
  334.         tp->rx_config = tmp;
  335.     }
  336.     iowrite32(mc_filter[0],ioaddr+MAR0 + 0);
  337.     iowrite32(mc_filter[1],ioaddr+MAR0 + 4);
  338. }
  340. static void xc_set_multicast_list(struct net_device *dev)
  341. {
  342.     unsigned long flags;
  343.     struct xc_priv *tp = netdev_priv(dev);
  345.     spin_lock_irqsave (&tp->lock, flags);
  346.     __set_rx_mode(dev);
  347.     spin_unlock_irqrestore (&tp->lock, flags);
  348. }
  350. /*  Setting to 1 forces the RTL8139D(L) to a software reset state
  351.     which disables the transmitter and receiver, reinitializes the FIFOs,
  352.     resets the system buffer pointer to the initial value (Tx buffer is at
  353.     TSAD0, Rx buffer is empty). 
  354. */
  355. static void xc_reset(void __iomem *ioaddr)
  356. {
  357.     int i;
  358.     /* Soft reset the chip. */
  359.     iowrite8(CmdReset,ioaddr+ChipCmd);
  360.     /* Check that the chip has finished the reset. */
  361.     for (i = 1000; i > 0; i--)
  362.     {
  363.         barrier();
  364.         if ((ioread8(ioaddr+ChipCmd) & CmdReset) == 0)
  365.             break;
  366.         udelay (10);
  367.     }
  368. }
  370. static void xc_cleanup_dev(struct net_device *dev)
  371. {
  372.     struct xc_priv *tp = netdev_priv(dev);
  373.     if (tp->pdev == NULL || dev == NULL)
  374.         return;
  375.     if (tp->ioaddr)
  376.         pci_iounmap(tp->pdev,tp->ioaddr);
  377.     pci_release_regions(tp->pdev);
  378.     free_netdev(dev);
  379.     pci_set_drvdata(tp->pdev,NULL);
  380. }
  382. static int xc_rx(struct net_device *dev, struct xc_priv *tp, int budget)
  383. {
  384.     u16 status;
  385.     struct sk_buff *skb;
  386.     int packet_size,data_size;
  387.     int work_done = 0;
  388.     void __iomem *ioaddr = tp->ioaddr;
  389.     unsigned long cur_rx = tp->cur_rx;
  391.     while (netif_running(dev) && work_done < budget && ((ioread8(ioaddr+ChipCmd) & RxBufEmpty) == 0))
  392.     {
  393.         u32 tmp_size;
  394.         u32 offset = cur_rx % RX_BUF_LEN;
  395.         rmb();
  396.         tmp_size = le32_to_cpu(*(u32 *)(tp->rx_bufs+offset));
  397.         packet_size = tmp_size >> 16;
  398.         data_size = packet_size - 4;
  399.         skb = dev_alloc_skb(data_size + 2);
  400.         if (likely(skb))
  401.         {
  402.             skb->dev = dev;
  403.             skb_reserve(skb,2);
  404.             skb_copy_to_linear_data (skb, &tp->rx_bufs[offset + 4], data_size);
  405.             skb_put(skb,data_size);
  406.             skb->protocol = eth_type_trans (skb, dev);
  407.             dev->last_rx = jiffies;
  408.             tp->stats.rx_bytes += data_size;
  409.             tp->stats.rx_packets++;
  410.             netif_receive_skb (skb);
  411.         }
  412.         else
  413.             tp->stats.rx_dropped++;
  415.         ++work_done;
  417.         /* 这里需要保持双字对齐，不过加上4干什么？*/
  418.         cur_rx = (cur_rx + packet_size + 4 + 3) & ~3;   /*更新接收offset*/
  419.         iowrite16((u16)(cur_rx - 16), ioaddr+RxBufPtr); /*更新当前包读取地址*/
  421.         status = ioread16(ioaddr+IntrStatus) & RxAckBits;
  422.         /* 在datasheet里面我看到说往isr写没有任何效果 难道我又错了*/
  423.         /* Clear out errors and receive interrupts */
  424.         if (likely(status != 0))
  425.         {
  426.             iowrite16 (RxAckBits, ioaddr+IntrStatus);
  427.             ioread16(ioaddr+IntrStatus);
  428.         }
  429.     }
  431.     tp->cur_rx = cur_rx;
  432.     return work_done;
  433. }
  435. /* 轮询， 还好不是轮fuck 这里的budget是接受数据包的最大量 */
  436. static int xc_poll(struct napi_struct *napi, int budget)
  437. {
  438.     
  439.     struct xc_priv *tp = container_of(napi, struct xc_priv, napi);
  440.     struct net_device *dev = tp->dev;
  441.     int work_done = 0;
  442.     unsigned long flags = 0;
  443.     void __iomem *ioaddr = tp->ioaddr;
  445.     if (budget <= 0)
  446.         return -1;
  448.     spin_lock(&tp->rx_lock);
  449.     if (likely(ioread16(ioaddr+IntrStatus) & RxAckBits))
  450.     {
  451.         work_done = xc_rx(dev, tp, budget);
  452.     }
  454.     /* 这里加锁且禁用中断 貌似仅仅加锁已经足够了 毕竟我们不在中断中 */
  455.     if (budget > work_done)
  456.     {
  457.         spin_lock_irqsave(&tp->lock, flags);
  458.         iowrite16(xc_intr_mask, ioaddr+IntrMask);
  459.         __netif_rx_complete(dev, napi);         /* 这里我们摘下napi中poll_list 并且清除NAPI_STATE_SCHED 的标志 */
  460.         spin_unlock_irqrestore(&tp->lock, flags);
  461.     }
  462.     spin_unlock(&tp->rx_lock);
  464.     return work_done;
  465. }
  467. /* 发送: 发送过程包括两部分，第一部分是把上层协议层传递下来的 第二部分就是把发送命令写入我们选定的寄存器 */
  468. static int xc_tx(struct sk_buff *skb, struct net_device *dev)
  469. {
  470.     struct xc_priv *tp = netdev_priv(dev);
  471.     void __iomem *ioaddr = tp->ioaddr;
  472.     unsigned int entry = tp->cur_tx % 4;        /* 这里我们要选择一个发送寄存器 注意这里的cur_tx标记的是当前选取的发送寄存器(发送寄存器有四个)*/
  473.     unsigned int len = skb->len;
  475.     /* 这里我们由于指定了发送缓冲区只能是1536 octet */
  477.     if (skb->len < 1536)    
  478.     {
  479.         if (len < ETH_ZLEN)
  480.             memset(tp->tx_buf[entry], 0, ETH_ZLEN);
  481.         /* 把skb中的内容拷贝至发送缓冲区 */
  482.         skb_copy_and_csum_dev(skb, tp->tx_buf[entry]);
  483.         dev_kfree_skb(skb);
  484.     }
  485.     else    /* 如果多于指定缓冲区大小，我们只有丢弃该数据包了 */
  486.     {
  487.         dev_kfree_skb(skb);/*释放skb*/
  488.         tp->stats.tx_dropped++;/*更新统计数据*/
  489.         return 0;
  490.     }
  492.     spin_lock_irq(&tp->lock);
  493.     /* 发送寄存器的高位是一些其他的标识 */
  494.     iowrite32(tp->tx_flag | max(len, (unsigned int)ETH_ZLEN), ioaddr+TxStatus0 + (entry * sizeof (u32)));       
  495.     dev->trans_start = jiffies;         /*设置发送开始时间*/
  496.     tp->cur_tx++;                       /*设置下一个发送要用的register ,也就是直接递增cur_tx */
  497.     wmb();
  498.     if (tp->cur_tx - 4 == tp->dirty_tx)     /* 如果发送缓冲区都满了 关闭发送队列 */
  499.         netif_stop_queue(dev);
  500.     spin_unlock_irq(&tp->lock);
  501.     return 0;
  502. }
  504. /* 这里是发送中断调用的函数， 注意这里并不是发送数据，发送数据是xc_tx所完成的，网卡发送完数据要通知cpu "hey 我这儿工作ok了"，这里就是cpu的应答*/
  505. static void tx_interrupt (struct net_device *dev,
  506.                           struct xc_priv *tp,void __iomem *ioaddr)
  507. {
  508.     unsigned long dirty_tx,tx_left;
  509.     if (dev == NULL || ioaddr == NULL)
  510.         return;
  511.     dirty_tx = tp->dirty_tx;            /* dirty_tx标记的是还没有来得及发送的数据缓冲区 (cur_tx依次递增)*/
  512.     tx_left = tp->cur_tx - dirty_tx;
  514.     while (tx_left > 0)
  515.     {
  516.         int entry = dirty_tx % 4;
  517.         int txstatus;
  518.         
  519.         txstatus = ioread32(ioaddr+TxStatus0 + (entry * sizeof (u32)));
  520.         if (!(txstatus & (TxStatOK | TxUnderrun | TxAborted)))          /* 看看是否真的有缓冲区被安排发出去了 */
  521.             break;/* It still hasn't been Txed */
  522.         
  523.         dirty_tx++;
  524.         tx_left--;
  525.     }
  526.     if (tp->dirty_tx != dirty_tx)
  527.     {
  528.         tp->dirty_tx = dirty_tx;
  529.         mb();
  530.         netif_wake_queue (dev);
  531.     }
  532. }
  534. /* linux 允许多个设备共享中断号 中断处理过程是把有相同中断号的中断处理程序依次执行一遍 */
  535. static irqreturn_t xc_interrupt(int irq, void *dev_inst, struct pt_regs *regs)
  536. {
  537.     u16 status,ackstat;
  538.     struct net_device *dev = (struct net_device *)dev_inst;
  539.     struct xc_priv *tp = netdev_priv(dev);
  540.     int handle = 0;
  541.     int link_changed = 0;
  542.     void __iomem *ioaddr = tp->ioaddr;
  544.     spin_lock(&tp->lock);
  545.     /* 读取中断寄存器的状态 这样我们就可以知道是不是我们网卡发出的中断 */
  546.     status = ioread16(ioaddr+IntrStatus);
  547.     if (unlikely(status & xc_intr_mask) == 0) 
  548.       goto out;
  549.     handle = 1;
  550.     
  551.     if (unlikely(status == 0xFFFF)) 
  552.       goto out;
  553.     if (unlikely(!netif_running(dev)))
  554.     {
  555.         iowrite16(0,ioaddr+IntrMask);
  556.         goto out;
  557.     }
  558.     
  559.     if (unlikely(status & RxUnderrun))
  560.         link_changed = ioread16(ioaddr+CSCR) & 0x0800;
  562.     /* 往这个寄存器写数值貌似没什么用*/
  563.     //ackstat = status & ~(RxAckBits | TxErr);
  564.     //if (ackstat)
  565.     //  iowrite16(0, ioaddr+IntrStatus);
  566.     
  567.     if (status & RxAckBits)
  568.     {
  569.         /* schedule prepare ! 在这里我们检测两个地方 第一个是napi这个结构里面的state，有两个状态一个是 NAPI_STATE_SCHED 表示poll已被调度;另一个是NAPI——STATE_DISABLE 表示Disable pending ()*/
  570.         if (netif_rx_schedule_prep(dev, &tp->napi))
  571.         {
  572.             /* 关闭接收数据包的中断 这个是NAPI这种数据包接收方式的"规定"*/
  573.             iowrite16(xc_norx_intr_mask,ioaddr+IntrStatus);
  574.             /* 其实下面这句最终执行的就是 list_add_tail(&n->poll_list, &__get_cpu_var(softnet_data).poll_list); 也就是把napi里面的poll_list加入CPU的poll_list */
  575.             __netif_rx_schedule(dev, &tp->napi);
  576.         }
  577.     }
  579.     /* 如果是发送成功或者发送错误... */
  580.     if (status & (TxOK | TxErr))
  581.     {
  582.         tx_interrupt(dev, tp, ioaddr);
  583.         if (status & TxErr)
  584.             iowrite16(TxErr,ioaddr+IntrStatus);
  585.     }
  586. out:
  587.     spin_unlock (&tp->lock);
  588.     return IRQ_RETVAL(handle);
  589. }
  591. static void xc_hw_start(struct net_device *dev)
  592. {
  593.     int i;
  594.     u8 tmp;
  595.     struct xc_priv *tp = netdev_priv(dev);
  596.     void __iomem *ioaddr = tp->ioaddr;
  597.     if (rtl_chip_info[tp->chipset].flags & HasHltClk)
  598.         iowrite8('R',ioaddr+HltClk);
  599.     xc_reset(ioaddr);
  601.     /* 写入mac地址 */
  602.     iowrite8(Cfg9346_Unlock,ioaddr+Cfg9346);
  603.     //iowrite32(cpu_to_le32(*(u32*)(dev->dev_addr+0)),ioaddr+MAC0+0);
  604.     //iowrite32(cpu_to_le32(*(u32*)(dev->dev_addr+4)),ioaddr+MAC0+4);
  605.     /* 开启读、写*/
  606.     iowrite8(CmdRxEnb | CmdTxEnb,ioaddr+ChipCmd);
  607.     
  608.     /* 接受广播和发送给自己的地址 */
  609.     tp->rx_config = xc_rx_config | AcceptBroadcast | AcceptMyPhys;
  610.     iowrite32(tp->rx_config,ioaddr+RxConfig);
  611.     iowrite32(xc_rx_config,ioaddr+TxConfig);
  612.     tp->cur_rx = 0;
  613.     xc_check_media (dev, 1);
  614.     if (tp->chipset >= CH_8139B)
  615.         iowrite8(ioread8(ioaddr+Config3) & ~Cfg3_Magic,ioaddr+Config3);
  616.     iowrite8(Cfg9346_lock, ioaddr+Cfg9346);
  618.     /* 数据包接收地址 */
  619.     iowrite32(tp->rx_bufs_dma, ioaddr+RxBuf);
  620.     ioread32(ioaddr+RxBuf);
  621.     for (i = 0; i < 4; i++)
  622.     {
  623.         iowrite32(tp->tx_bufs_dma + (tp->tx_buf[i] - tp->tx_bufs),
  624.                   ioaddr+TxAddr0 + (i * 4));
  625.         ioread32(ioaddr+TxAddr0 + (i * 4));
  626.     }
  627.     /* 初始化 miss counter 寄存器 */
  628.     iowrite32(0,ioaddr+RxMissed);
  629.     xc_set_multicast_list(dev);
  630.     iowrite16(ioread16(ioaddr+MultiIntr) & 0xF000,ioaddr+MultiIntr);
  631.     tmp = ioread8(ioaddr+ChipCmd);
  632.     if (!(tmp & CmdRxEnb) || !(tmp & CmdTxEnb))
  633.         iowrite8(CmdRxEnb | CmdTxEnb,ioaddr+ChipCmd);
  634.     /* 开启中断 注意mask的含义*/
  635.     iowrite16(xc_intr_mask,ioaddr+IntrMask);
  636. }
  638. /* 通常在ifconfig调用 */
  639. static int xc_open(struct net_device *dev)
  640. {
  641.     int rc,i;
  642.     struct xc_priv *tp = netdev_priv(dev);;
  643.     rc = request_irq (dev->irq, xc_interrupt, IRQF_SHARED, dev->name, dev);
  644.     if (rc) 
  645.       return rc;
  646.     
  647.     /* 这里申请DMA地址 并且在tx_bufs_dma里返回了申请的总线地址 */
  648.     tp->tx_bufs = pci_alloc_consistent(tp->pdev, 1536*4, &tp->tx_bufs_dma);
  649.     tp->rx_bufs = pci_alloc_consistent(tp->pdev, RX_BUF_TOT_LEN, &tp->rx_bufs_dma);
  650.     if (tp->rx_bufs == NULL || tp->tx_bufs == NULL)
  651.     {
  652.         free_irq(dev->irq, dev);
  653.         if (tp->tx_bufs)
  654.             pci_free_consistent(tp->pdev, 1536*4,tp->tx_bufs,tp->tx_bufs_dma);
  655.         if (tp->rx_bufs)
  656.             pci_free_consistent(tp->pdev, RX_BUF_TOT_LEN,tp->rx_bufs,tp->rx_bufs_dma);
  657.         return -ENOMEM;
  658.     }
  660.     napi_enable(&tp->napi);
  661.     tp->mii.full_duplex = tp->mii.force_media;
  662.     tp->tx_flag = (256 << 11) & 0x003f0000;
  663.     /* 初始化缓冲队列*/
  664.     tp->cur_rx = 0;
  665.     tp->cur_tx = 0;
  666.     tp->dirty_tx = 0;
  667.     for (i = 0; i < 4; i++)
  668.         tp->tx_buf[i] = &tp->tx_bufs[i * 1536];
  669.     xc_hw_start(dev);
  670.     /* 开启队列 */
  671.     netif_start_queue(dev);
  672.     return 0;
  673. }
  675. static int xc_stop(struct net_device *dev)
  676. {
  677.     unsigned long flags;
  678.     struct xc_priv *tp = netdev_priv(dev);
  679.     void __iomem *ioaddr = tp->ioaddr;
  680.     netif_stop_queue(dev);
  681.     napi_disable(&tp->napi);
  683.     spin_lock_irqsave(&tp->lock,flags);
  684.     iowrite8(0,ioaddr+ChipCmd);
  685.     iowrite16(0,ioaddr+IntrMask);
  686.     tp->stats.rx_missed_errors += ioread32(ioaddr+RxMissed);
  687.     iowrite32(0,ioaddr+RxMissed);
  688.     spin_unlock_irqrestore (&tp->lock, flags);
  690.     synchronize_irq (dev->irq);/* racy, but that's ok here */
  691.     free_irq (dev->irq, dev);
  692.     tp->cur_tx = 0;
  693.     tp->dirty_tx = 0;
  694.     pci_free_consistent(tp->pdev, RX_BUF_TOT_LEN,tp->rx_bufs, tp->rx_bufs_dma);
  695.     pci_free_consistent(tp->pdev, 1536*4,tp->tx_bufs, tp->tx_bufs_dma);
  696.     tp->rx_bufs = NULL;
  697.     tp->tx_bufs = NULL;
  698.     /* Green! Put the chip in low-power mode. */
  699.     iowrite8(Cfg9346_Unlock,ioaddr+Cfg9346);
  700.     if (rtl_chip_info[tp->chipset].flags & HasHltClk)
  701.         iowrite8('H',ioaddr+HltClk);
  702.     return 0;
  703. }
  705. static struct net_device_stats *xc_get_stats (struct net_device *dev)
  706. {
  707.     struct xc_priv *tp = netdev_priv(dev);
  708.     return &tp->stats;
  709. }
  711. static void xc_tx_timeout(struct net_device *dev)
  712. {
  713.     struct xc_priv *tp = netdev_priv(dev);
  714.     void __iomem *ioaddr = tp->ioaddr;
  715.     u8 tmp8;
  717.     tmp8= ioread8(ioaddr+ChipCmd);
  718.     if (tmp8 & CmdTxEnb)
  719.         iowrite8(CmdRxEnb,ioaddr+ChipCmd);/*如果8139任开启写则关闭，只保留读*/
  721.     spin_lock_bh(&tp->rx_lock);
  722.     /* Disable interrupts by clearing the interrupt mask. */
  723.     iowrite16(0x0000,ioaddr+IntrMask);
  725.     /* Stop a shared interrupt from scavenging while we are. */
  726.     spin_lock_irq(&tp->lock);
  727.     tp->cur_tx = 0;
  728.     tp->dirty_tx = 0;
  729.     spin_unlock_irq(&tp->lock);
  731.     if (netif_running(dev))
  732.     {/*重新设置8139所有信息*/
  733.         xc_hw_start (dev);
  734.         netif_wake_queue (dev);
  735.     }
  736.     spin_unlock_bh(&tp->rx_lock);
  737. }
  739. /* 初始化网卡设备 */
  740. static int __devinit xc_board(struct pci_dev *pdev,struct net_device **dev_out)
  741. {
  742.     struct net_device *dev;
  743.     struct xc_priv *tp;
  744.     void __iomem *ioaddr;
  745.     int rc,dev_on,i;
  746.     u32 version;
  747.     u8 tmp;
  748.     if (pdev == NULL)
  749.         return -1;
  750.     dev_on = 0;
  751.     *dev_out = NULL;
  752.     dev = alloc_etherdev(sizeof(*tp));
  753.     if (dev == NULL)
  754.         return -ENOMEM;
  755.     //dev->owner = THIS_MODULE;
  756.     SET_NETDEV_DEV(dev, &pdev->dev);
  757.     tp = netdev_priv(dev);
  758.     tp->pdev = pdev;
  759.     tp->dev = dev;
  760.     
  761.     rc = pci_enable_device(pdev);
  762.     if (rc) 
  763.       goto err_out;
  764.     rc = pci_request_regions (pdev, "xc8139too");
  765.     if (rc) 
  766.       goto err_out;
  767.     
  768.     dev_on = 1;
  770.     
  771.         /*
  772.          * PCI网卡被BIOS配置后，某些特性可能会被屏蔽掉。比如，多数BIOS都会清掉“master”位，
  773.          * 这导致板卡不能随意向主存中拷贝数据。pci_set_master函数数会检查是否需要设置标志位，
  774.          * 如果需要，则会将“master”位置位。
  775.          * PS：什么是PCI master？
  776.          * 不同于ISA总线，PCI总线的地址总线与数据总线是分时复用的。这样做的好处是，一方面
  777.          * 可以节省接插件的管脚数，另一方面便于实现突发数据传输。在做数据传输时，由一个PCI
  778.          * 设备做发起者(主控，Initiator或Master)，而另一个PCI设备做目标(从设备，Target或Slave)。
  779.          * 总线上的所有时序的产生与控制，都由Master来发起。PCI总线在同一时刻只能供一对设备完成传输。
  780.          */
  781.     pci_set_master (pdev);
  782.     ioaddr = pci_iomap(pdev, 1, 0);
  783.     if (ioaddr == NULL)
  784.     {
  785.         rc = -EIO;
  786.         goto err_out;
  787.     }
  788.     tp->ioaddr = ioaddr;
  789.     dev->base_addr = (long)ioaddr;
  790.     iowrite8('R',ioaddr+HltClk);
  791.     
  792.     /*为什么这样能判断出来？*/
  793.     if (ioread32(ioaddr+TxConfig) == 0xFFFFFFFF)
  794.     {
  795.         rc = -EIO;
  796.         goto err_out;
  797.     }
  799.     /* 判断网卡型号 */
  800.     version = ioread32(ioaddr+TxConfig) & HW_REVID_MASK;
  801.     for (i=0;i<ARRAY_SIZE(rtl_chip_info);++i)
  802.         if (version == rtl_chip_info[i].version)
  803.         {
  804.             tp->chipset = i;
  805.             goto match;
  806.         }
  807.     tp->chipset = 0;
  808.     
  809.     /*      这里设置为默认的方式 active high
  810.      *
  811.      *      摘抄自datasheet 
  812.      *
  813.      *      The LWACT bit and LWPTN bit in CONFIG4 register
  814.             are used to program the LWAKE pin’s output signal. According to the
  815.             combination of these two bits, there may be 4 choices of LWAKE signal, i.e.,
  816.             active high, active low, positive (high) pulse, and negative (low) pulse. The
  817.             output pulse width is about 150ms.
  818.     */
  819. match:
  820.     if (tp->chipset >= CH_8139B)
  821.     {
  822.         u8 ntmp = tmp = ioread8(ioaddr+Config1);
  823.         /*  Software may use this bit to make sure that the driver has been loaded 这样我们可以确保驱动加载 */
  824.         if ((rtl_chip_info[tp->chipset].flags & HasLWake) && (ntmp & LWAKE))
  825.             ntmp = ntmp & ~LWAKE;
  826.         ntmp = ntmp | Cfg1_PM_Enable;           //这里我们要开启电源管理
  827.         if (ntmp != tmp)
  828.         {
  829.             iowrite8(Cfg9346_Unlock,ioaddr+Cfg9346);
  830.             iowrite8(ntmp,ioaddr+Config1);
  831.             iowrite8(Cfg9346_lock,ioaddr+Cfg9346);
  832.         }
  833.         if (rtl_chip_info[tp->chipset].flags & HasLWake)
  834.         {
  835.             tmp = ioread8(ioaddr+Config4);
  836.             if (tmp & LWPTN)
  837.             {
  838.                 iowrite8(Cfg9346_Unlock,ioaddr+Cfg9346);
  839.                 iowrite8(tmp & ~LWPTN,ioaddr+Config4);
  840.                 iowrite8(Cfg9346_lock,ioaddr+Cfg9346);
  841.             }
  842.         }
  843.     }
  844.     else
  845.     {
  846.         tmp = ioread8(ioaddr+Config1);
  847.         tmp = tmp & ~((1 << 1) | (1 << 0));
  848.         iowrite8(tmp,ioaddr+Config1);
  849.     }
  850.     xc_reset(ioaddr);
  851.     *dev_out = dev;
  852.     return 0;
  853. err_out:
  854.     xc_cleanup_dev (dev);
  855.     if (dev_on)
  856.         pci_disable_device(pdev);
  857.     return rc;
  859. }
  861. static int __devinit xc_probe(struct pci_dev *pdev,const struct pci_device_id *ent)
  862. {
  863.     int i;
  864.     struct xc_priv *tp;
  865.     void __iomem *ioaddr;
  866.     struct net_device *dev = NULL;
  867.     int rc,option;
  868.     static int index = -1;
  870.     if (pdev == NULL || ent == NULL)
  871.         return -ENODEV;
  872.     ++index;
  873.     rc = xc_board(pdev,&dev);
  874.     if (rc < 0)
  875.         return rc;
  876.     if (dev == NULL)
  877.         return -1;
  878.     tp = netdev_priv(dev);
  879.     ioaddr = tp->ioaddr;
  880.     if (ioaddr == NULL)
  881.         return -1;
  883.     if (!dev->addr_len)
  884.     {
  885.         printk(KERN_INFO "XC:%i:dev->addr_len is set here/n",dev->addr_len);
  886.         dev->addr_len = 6;
  887.     }
  889.     /*硬件mac地址*/
  890.     
  891.     ((u32 *)dev->dev_addr)[0] = ioread32(ioaddr + MAC0) ;
  892.     ((u16 *)dev->dev_addr)[2] = ioread32(ioaddr + MAC0 + 4);
  894.     memcpy(dev->perm_addr,dev->dev_addr,dev->addr_len);
  895.     
  896.     /*dev function init*/
  897.     dev->open       = xc_open;
  898.     dev->stop       = xc_stop;
  899.     dev->hard_start_xmit    = xc_tx;
  900.     netif_napi_add(dev, &tp->napi, xc_poll, 64);
  901.     dev->get_stats      = xc_get_stats;
  902.     dev->set_multicast_list = xc_set_multicast_list;
  903.     dev->do_ioctl       = NULL;
  904.     dev->ethtool_ops    = &xc_ethtool_ops;
  905.     dev->tx_timeout     = xc_tx_timeout;
  906.     dev->watchdog_timeo = 6*HZ;
  908.     /* 如果你的接口可以发送一个报文, 它由几个不同的内存段组成, 你应当设置 NETIF_F_SG
  909.      * 如果你的硬件自己做校验, 设置 NETIF_F_HW_CWSUM.
  910.      * 设置这个标志, 如果你的设备能够对高端内存进行 DMA.
  911.      */
  912.     dev->features       |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA;
  913.     /* 这里设置中断号，其实内核在初始化的时候已经为设备分配好了中断号*/
  914.     dev->irq        = pdev->irq;
  916.     tp      = netdev_priv(dev);
  917.     ioaddr      = tp->ioaddr;
  918.     /* 不知道什么意思 */
  919.     tp->msg_enable  = NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK;
  920.     spin_lock_init(&tp->lock);
  921.     spin_lock_init(&tp->rx_lock);
  923.     /* 不是特别清楚 */
  924.     tp->mii.dev     = dev;
  925.     tp->mii.mdio_read   = mdio_read;
  926.     tp->mii.mdio_write  = mdio_write;
  927.     tp->mii.phy_id_mask = 0x3f;     //
  928.     tp->mii.reg_num_mask    = 0x1f;
  929.     
  930.     rc = register_netdev(dev);
  931.     if (rc) 
  932.       goto err_out;
  933.     
  934.     pci_set_drvdata (pdev, dev);
  936.     printk (KERN_INFO "%s:0x%lx--%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x,IRQ %d/n",
  937.             dev->name,dev->base_addr,dev->dev_addr[0], dev->dev_addr[1],
  938.             dev->dev_addr[2], dev->dev_addr[3],dev->dev_addr[4], dev->dev_addr[5],
  939.             dev->irq);
  940.     printk (KERN_DEBUG "%s:  Identified 8139 chip type '%s'/n",
  941.             dev->name, rtl_chip_info[tp->chipset].name);
  943.     /* */
  944.     /*MII define*/
  945.     tp->phys[0] = 32;
  946.     tp->mii.phy_id = tp->phys[0];
  948.     /* The lower four bits are the media type. */
  949.     option = (index >= 8) ? 0 : -1;
  950.     if (tp->mii.full_duplex)
  951.     {
  952.         printk(KERN_INFO "%s: Media type forced to Full Duplex./n", dev->name);
  953.         /* Changing the MII-advertised media because might prevent
  954.            re-connection. */
  955.         tp->mii.force_media = 1;
  956.     }
  957.     if (tp->default_port)
  958.     {
  959.         printk(KERN_INFO "  Forcing %dMbps %s-duplex operation./n",
  960.                (option & 0x20 ? 100 : 10),
  961.                (option & 0x10 ? "full" : "half"));
  962.         mdio_write(dev, tp->phys[0], 0,
  963.                    ((option & 0x20) ? 0x2000 : 0) |     /* 100Mbps? */
  964.                    ((option & 0x10) ? 0x0100 : 0)); /* Full duplex? */
  965.     }
  966.     /*MII*/
  967.     if (rtl_chip_info[tp->chipset].flags & HasHltClk)
  968.         iowrite8('H',ioaddr+HltClk);
  969.     return 0;
  970. err_out:
  971.     xc_cleanup_dev (dev);
  972.     pci_disable_device (pdev);
  973.     return rc;
  974. }
  976. static void __devexit xc_remove(struct pci_dev *pdev)
  977. {
  978.     struct net_device *dev = pci_get_drvdata(pdev);
  979.     unregister_netdev(dev);
  980.     xc_cleanup_dev(dev);
  981.     pci_disable_device(pdev);
  982. }
  984. struct pci_driver xc_driver =
  985. {
  986.     .name       = "xc8139too",
  987.     .id_table   = xc_id,
  988.     .probe      = xc_probe,
  989.     .remove     = __devexit_p(xc_remove),
  990. };
  992. static int __init xc_module_init(void)
  993. {
  994.     return pci_register_driver(&xc_driver);
  995. }
  996. static void __exit xc_module_exit(void)
  997. {
  998.     pci_unregister_driver(&xc_driver);
  999. }
  1000. module_init(xc_module_init);
  1001. module_exit(xc_module_exit);
标签：

相关文章