rtl8139 网卡驱动分析：（注：这里只分析了主要函数，代码版本是:
| 8139too.c | 71420 bytes | 2010-04-01 22:56:18 |
）
/* * 提供了一系列驱动程序可调用的接口，主要用于发现和初始化设备 */ static struct pci_driver rtl8139_pci_driver = { .name = DRV_NAME, .id_table = rtl8139_pci_tbl, .probe = rtl8139_init_one, .remove = __devexit_p(rtl8139_remove_one), #ifdef CONFIG_PM .suspend = rtl8139_suspend, .resume = rtl8139_resume, #endif /* CONFIG_PM */ }; static int __devinit rtl8139_init_one (struct pci_dev *pdev, const struct pci_device_id *ent) { struct net_device *dev = NULL; struct rtl8139_private *tp; int i, addr_len, option; void __iomem *ioaddr; static int board_idx = -1; assert (pdev != NULL); assert (ent != NULL); board_idx++; /* when we're built into the kernel, the driver version message * is only printed if at least one 8139 board has been found */ #ifndef MODULE { static int printed_version; if (!printed_version++) pr_info(RTL8139_DRIVER_NAME "\n"); } #endif if (pdev->vendor == PCI_VENDOR_ID_REALTEK && pdev->device == PCI_DEVICE_ID_REALTEK_8139 && pdev->revision >= 0x20) { dev_info(&pdev->dev, "This (id %04x:%04x rev %02x) is an enhanced 8139C+ chip, use 8139cp\n", pdev->vendor, pdev->device, pdev->revision); return -ENODEV; } if (pdev->vendor == PCI_VENDOR_ID_REALTEK && pdev->device == PCI_DEVICE_ID_REALTEK_8139 && pdev->subsystem_vendor == PCI_VENDOR_ID_ATHEROS && pdev->subsystem_device == PCI_DEVICE_ID_REALTEK_8139) { pr_info("8139too: OQO Model 2 detected. Forcing PIO\n"); use_io = 1; } dev = rtl8139_init_board (pdev);//返回了一个struct net_device 对象的指针 if (IS_ERR(dev)) return PTR_ERR(dev); assert (dev != NULL); tp = netdev_priv(dev);//获取私有结构的指针 tp->dev = dev;//关联rtl8139_init_board 返回的 net_device 对象指针，便于操作 ioaddr = tp->mmio_addr;//获取虚拟io地址，便于操作 assert (ioaddr != NULL); /*读取MAC地址*/ addr_len = read_eeprom (ioaddr, 0, 8) == 0x8129 ? 8 : 6; for (i = 0; i < 3; i++)//macaddr 6 byte, each time 2byte ,so three times is ok ((__le16 *) (dev->dev_addr))[i] = cpu_to_le16(read_eeprom (ioaddr, i + 7, addr_len)); memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);//保存MAC地址 /* The Rtl8139-specific entries in the device structure. */ dev->netdev_ops = &rtl8139_netdev_ops; //关联net_device的操作 dev->ethtool_ops = &rtl8139_ethtool_ops; dev->watchdog_timeo = TX_TIMEOUT; netif_napi_add(dev, &tp->napi, rtl8139_poll, 64); /*注册轮询函数，64为一次处理的帧数，如果一个处理的帧数小于这个数字，则使用中断的方式，否则使用轮询的方式*/ /* note: the hardware is not capable of sg/csum/highdma, however * through the use of skb_copy_and_csum_dev we enable these * features */ dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA; dev->irq = pdev->irq;//关联irq，方便在request_irq 函数中的操作 /* tp zeroed and aligned in alloc_etherdev */ tp = netdev_priv(dev); /* note: tp->chipset set in rtl8139_init_board */ tp->drv_flags = board_info[ent->driver_data].hw_flags; tp->mmio_addr = ioaddr; tp->msg_enable = (debug < 0 ? RTL8139_DEF_MSG_ENABLE : ((1 << debug) - 1)); spin_lock_init (&tp->lock); spin_lock_init (&tp->rx_lock); INIT_DELAYED_WORK(&tp->thread, rtl8139_thread); tp->mii.dev = dev; tp->mii.mdio_read = mdio_read; tp->mii.mdio_write = mdio_write; tp->mii.phy_id_mask = 0x3f; tp->mii.reg_num_mask = 0x1f; /* dev is fully set up and ready to use now */ pr_debug("about to register device named %s (%p)...\n", dev->name, dev); i = register_netdev (dev);//注册网络设备 if (i) goto err_out; pci_set_drvdata (pdev, dev); /*把网络设备指针地址放入PCI设备中的设备指针中，便于remove的时候使用 * pci_get_drvdata 获取该网络设备 */ pr_info("%s: %s at 0x%lx, %pM, IRQ %d\n", dev->name, board_info[ent->driver_data].name, dev->base_addr, dev->dev_addr, dev->irq); pr_debug("%s: Identified 8139 chip type '%s'\n", dev->name, rtl_chip_info[tp->chipset].name); /* Find the connected MII xcvrs. Doing this in open() would allow detecting external xcvrs later, but takes too much time. */ #ifdef CONFIG_8139TOO_8129 if (tp->drv_flags & HAS_MII_XCVR) { int phy, phy_idx = 0; for (phy = 0; phy < 32 && phy_idx < sizeof(tp->phys); phy++) { int mii_status = mdio_read(dev, phy, 1); if (mii_status != 0xffff && mii_status != 0x0000) { u16 advertising = mdio_read(dev, phy, 4); tp->phys[phy_idx++] = phy; pr_info("%s: MII transceiver %d status 0x%4.4x advertising %4.4x.\n", dev->name, phy, mii_status, advertising); } } if (phy_idx == 0) { pr_info("%s: No MII transceivers found! Assuming SYM transceiver.\n", dev->name); tp->phys[0] = 32; } } else #endif tp->phys[0] = 32; tp->mii.phy_id = tp->phys[0]; /* The lower four bits are the media type. */ option = (board_idx >= MAX_UNITS) ? 0 : media[board_idx]; if (option > 0) { tp->mii.full_duplex = (option & 0x210) ? 1 : 0; tp->default_port = option & 0xFF; if (tp->default_port) tp->mii.force_media = 1; } if (board_idx < MAX_UNITS && full_duplex[board_idx] > 0) tp->mii.full_duplex = full_duplex[board_idx]; if (tp->mii.full_duplex) { pr_info("%s: Media type forced to Full Duplex.\n", dev->name); /* Changing the MII-advertised media because might prevent re-connection. */ tp->mii.force_media = 1; } if (tp->default_port) { pr_info(" Forcing %dMbps %s-duplex operation.\n", (option & 0x20 ? 100 : 10), (option & 0x10 ? "full" : "half")); mdio_write(dev, tp->phys[0], 0, ((option & 0x20) ? 0x2000 : 0) | /* 100Mbps? */ ((option & 0x10) ? 0x0100 : 0)); /* Full duplex? */ } /* Put the chip into low-power mode. */ if (rtl_chip_info[tp->chipset].flags & HasHltClk) RTL_W8 (HltClk, 'H'); /* 'R' would leave the clock running. */ return 0; err_out: __rtl8139_cleanup_dev (dev); pci_disable_device (pdev); return i; } static __devinit struct net_device * rtl8139_init_board (struct pci_dev *pdev) { void __iomem *ioaddr; struct net_device *dev; struct rtl8139_private *tp; u8 tmp8; int rc, disable_dev_on_err = 0; unsigned int i; unsigned long pio_start, pio_end, pio_flags, pio_len; unsigned long mmio_start, mmio_end, mmio_flags, mmio_len; u32 version; assert (pdev != NULL); /* dev and priv zeroed in alloc_etherdev */ dev = alloc_etherdev (sizeof (*tp)); /*注意到这里分配空间传入的参数是 struct rtl8139rtl 的大小，其实也就是在创建 struct net_device 的同时给 指向 private 的指针分配了空间*/ if (dev == NULL) { dev_err(&pdev->dev, "Unable to alloc new net device\n"); return ERR_PTR(-ENOMEM); } SET_NETDEV_DEV(dev, &pdev->dev); /*#define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))*/ /*netdev_priv - access network device private data*/ tp = netdev_priv(dev); tp->pci_dev = pdev; /* enable device (incl. PCI PM wakeup and hotplug setup) 相当于windows驱动中发送IRP_MN_START_DEVICE 类型IRP 包给PDO处理 */ rc = pci_enable_device (pdev); if (rc) goto err_out; /*读取PCI配置空间信息*/ pio_start = pci_resource_start (pdev, 0); pio_end = pci_resource_end (pdev, 0); pio_flags = pci_resource_flags (pdev, 0); pio_len = pci_resource_len (pdev, 0); mmio_start = pci_resource_start (pdev, 1); mmio_end = pci_resource_end (pdev, 1); mmio_flags = pci_resource_flags (pdev, 1); mmio_len = pci_resource_len (pdev, 1); /* set this immediately, we need to know before * we talk to the chip directly */ pr_debug("PIO region size == 0x%02lX\n", pio_len); pr_debug("MMIO region size == 0x%02lX\n", mmio_len); retry: if (use_io) { /* make sure PCI base addr 0 is PIO */ if (!(pio_flags & IORESOURCE_IO)) { dev_err(&pdev->dev, "region #0 not a PIO resource, aborting\n"); rc = -ENODEV; goto err_out; } /* check for weird/broken PCI region reporting */ if (pio_len < RTL_MIN_IO_SIZE) { dev_err(&pdev->dev, "Invalid PCI I/O region size(s), aborting\n"); rc = -ENODEV; goto err_out; } } else { /* make sure PCI base addr 1 is MMIO */ if (!(mmio_flags & IORESOURCE_MEM)) { dev_err(&pdev->dev, "region #1 not an MMIO resource, aborting\n"); rc = -ENODEV; goto err_out; } if (mmio_len < RTL_MIN_IO_SIZE) { dev_err(&pdev->dev, "Invalid PCI mem region size(s), aborting\n"); rc = -ENODEV; goto err_out; } } /*登记该空间已经分配给了特定对象，不能再次分配给其它设备*/ rc = pci_request_regions (pdev, DRV_NAME); if (rc) goto err_out; disable_dev_on_err = 1; /* enable PCI bus-mastering */ pci_set_master (pdev); /*跟ioremap类似的功能，将板上硬件物理地址映射为虚拟地址*/ if (use_io) { ioaddr = pci_iomap(pdev, 0, 0); if (!ioaddr) { dev_err(&pdev->dev, "cannot map PIO, aborting\n"); rc = -EIO; goto err_out; } dev->base_addr = pio_start; tp->regs_len = pio_len; } else { /* ioremap MMIO region */ ioaddr = pci_iomap(pdev, 1, 0); if (ioaddr == NULL) { dev_err(&pdev->dev, "cannot remap MMIO, trying PIO\n"); pci_release_regions(pdev); use_io = 1; goto retry; } dev->base_addr = (long) ioaddr; tp->regs_len = mmio_len; } tp->mmio_addr = ioaddr;//在rtl8139_private 结构中保存该虚拟地址，用于io操作 /* Bring old chips out of low-power mode. */ RTL_W8 (HltClk, 'R'); /* check for missing/broken hardware */ if (RTL_R32 (TxConfig) == 0xFFFFFFFF) { dev_err(&pdev->dev, "Chip not responding, ignoring board\n"); rc = -EIO; goto err_out; } /* identify chip attached to board */ version = RTL_R32 (TxConfig) & HW_REVID_MASK; for (i = 0; i < ARRAY_SIZE (rtl_chip_info); i++) if (version == rtl_chip_info[i].version) { tp->chipset = i; goto match; } /* if unknown chip, assume array element #0, original RTL-8139 in this case */ dev_dbg(&pdev->dev, "unknown chip version, assuming RTL-8139\n"); dev_dbg(&pdev->dev, "TxConfig = 0x%lx\n", RTL_R32 (TxConfig)); tp->chipset = 0; match: pr_debug("chipset id (%d) == index %d, '%s'\n", version, i, rtl_chip_info[i].name); if (tp->chipset >= CH_8139B) { u8 new_tmp8 = tmp8 = RTL_R8 (Config1); pr_debug("PCI PM wakeup\n"); if ((rtl_chip_info[tp->chipset].flags & HasLWake) && (tmp8 & LWAKE)) new_tmp8 &= ~LWAKE; new_tmp8 |= Cfg1_PM_Enable; if (new_tmp8 != tmp8) { RTL_W8 (Cfg9346, Cfg9346_Unlock); RTL_W8 (Config1, tmp8); RTL_W8 (Cfg9346, Cfg9346_Lock); } if (rtl_chip_info[tp->chipset].flags & HasLWake) { tmp8 = RTL_R8 (Config4); if (tmp8 & LWPTN) { RTL_W8 (Cfg9346, Cfg9346_Unlock); RTL_W8 (Config4, tmp8 & ~LWPTN); RTL_W8 (Cfg9346, Cfg9346_Lock); } } } else { pr_debug("Old chip wakeup\n"); tmp8 = RTL_R8 (Config1); tmp8 &= ~(SLEEP | PWRDN); RTL_W8 (Config1, tmp8); } rtl8139_chip_reset (ioaddr); return dev; err_out: __rtl8139_cleanup_dev (dev); if (disable_dev_on_err) pci_disable_device (pdev); return ERR_PTR(rc); } /* *8139网卡的有⼀个接收缓冲寄存器，用于存放接收缓存的首地址，网 *卡⼀边把网线上的发出的数据放到内部FIFO，⼀边从FIFO中把数据通过 *DMA传送到由接收寄存器指定的内存地址中，接收到的数据依次排放，当 *长度超过默认的缓冲区长度时，会回过头来放到开始的地方，所以接收 *缓冲区被称为环形缓冲区。发送方面：8139有四个发送地址寄存器，CPU *将要发送的数据在内存中的地址写⼊这四个寄存器中的任何⼀个，网卡 *就会通过DMA操作把数据发送出去。当发送或者接送完成后，网卡会发出 *中断，中断处理程序通过读取网卡的中断状态寄存器来识别出是发送完 *成发出的中断，接收到数据包的中断，还是错误中断。 *当运行ifconfig ethx up的时候，rtl8139_open得到调用。该函数的 *任务就是分配，初始化接收，发送缓冲区，分配中断号等。 * */ static int rtl8139_open (struct net_device *dev) { struct rtl8139_private *tp = netdev_priv(dev); int retval; void __iomem *ioaddr = tp->mmio_addr; retval = request_irq (dev->irq, rtl8139_interrupt, IRQF_SHARED, dev->name, dev); if (retval) return retval; //dma_alloc_coherent() -- 获取物理页，并将该物理页的总线地址保存于dma_handle，返回该物理页的虚拟地址 tp->tx_bufs = dma_alloc_coherent(&tp->pci_dev->dev, TX_BUF_TOT_LEN, &tp->tx_bufs_dma, GFP_KERNEL); tp->rx_ring = dma_alloc_coherent(&tp->pci_dev->dev, RX_BUF_TOT_LEN, &tp->rx_ring_dma, GFP_KERNEL); if (tp->tx_bufs == NULL || tp->rx_ring == NULL) { free_irq(dev->irq, dev); if (tp->tx_bufs) dma_free_coherent(&tp->pci_dev->dev, TX_BUF_TOT_LEN, tp->tx_bufs, tp->tx_bufs_dma); if (tp->rx_ring) dma_free_coherent(&tp->pci_dev->dev, RX_BUF_TOT_LEN, tp->rx_ring, tp->rx_ring_dma); return -ENOMEM; } /** * napi_enable - enable NAPI scheduling * @n: napi context * * Resume NAPI from being scheduled on this context. * Must be paired with napi_disable. */ napi_enable(&tp->napi); tp->mii.full_duplex = tp->mii.force_media; tp->tx_flag = (TX_FIFO_THRESH << 11) & 0x003f0000; rtl8139_init_ring (dev);//将发送帧所存放的地址写下来 rtl8139_hw_start (dev);//初始化接收和发送寄存器对于的dma地址 netif_start_queue (dev);//该函数用于告诉上层网络驱动层驱动空间有缓冲区可用，开始发送数据包到驱动层。 if (netif_msg_ifup(tp)) pr_debug("%s: rtl8139_open() ioaddr %#llx IRQ %d" " GP Pins %2.2x %s-duplex.\n", dev->name, (unsigned long long)pci_resource_start (tp->pci_dev, 1), dev->irq, RTL_R8 (MediaStatus), tp->mii.full_duplex ? "full" : "half"); rtl8139_start_thread(tp); return 0; } /* The interrupt handler does all of the Rx thread work and cleans up after the Tx thread. */ static irqreturn_t rtl8139_interrupt (int irq, void *dev_instance) { struct net_device *dev = (struct net_device *) dev_instance; struct rtl8139_private *tp = netdev_priv(dev); void __iomem *ioaddr = tp->mmio_addr; u16 status, ackstat; int link_changed = 0; /* avoid bogus "uninit" warning */ int handled = 0; spin_lock (&tp->lock); status = RTL_R16 (IntrStatus);//从网卡的中断状态寄存器中读出状态值进行分析 /* shared irq? */ if (unlikely((status & rtl8139_intr_mask) == 0)) goto out; handled = 1; /* h/w no longer present (hotplug?) or major error, bail */ if (unlikely(status == 0xFFFF)) goto out; /* close possible race's with dev_close */ if (unlikely(!netif_running(dev))) { RTL_W16 (IntrMask, 0); goto out; } /* Acknowledge all of the current interrupt sources ASAP, but an first get an additional status bit from CSCR. */ if (unlikely(status & RxUnderrun)) link_changed = RTL_R16 (CSCR) & CSCR_LinkChangeBit; ackstat = status & ~(RxAckBits | TxErr); if (ackstat) RTL_W16 (IntrStatus, ackstat); /* Receive packets are processed by poll routine. If not running start it now. */ /*如果状态寄存器的接收bit位置为1，则进入接收处理函数。根据NAPI机制。这里先向终端屏蔽寄存器写入rtl8139_norx_intr_mask,关闭中断，然后通过把接收的poll 函数加入中断队列，将来软中断调度的时候回调用rtl8139_poll,进行轮询*/ if (status & RxAckBits){ if (napi_schedule_prep(&tp->napi)) { RTL_W16_F (IntrMask, rtl8139_norx_intr_mask); __napi_schedule(&tp->napi); //转为轮询机制，而非中断机制 } } /* Check uncommon events with one test. */ if (unlikely(status & (PCIErr | PCSTimeout | RxUnderrun | RxErr))) rtl8139_weird_interrupt (dev, tp, ioaddr, status, link_changed); /* 如果状态寄存器的发送位置 1 ，则进入发送中断的处理函数 */ if (status & (TxOK | TxErr)) { rtl8139_tx_interrupt (dev, tp, ioaddr); if (status & TxErr) RTL_W16 (IntrStatus, TxErr); } out: spin_unlock (&tp->lock); pr_debug("%s: exiting interrupt, intr_status=%#4.4x.\n", dev->name, RTL_R16 (IntrStatus)); return IRQ_RETVAL(handled); } static int rtl8139_poll(struct napi_struct *napi, int budget) { struct rtl8139_private *tp = container_of(napi, struct rtl8139_private, napi); struct net_device *dev = tp->dev; void __iomem *ioaddr = tp->mmio_addr; int work_done; spin_lock(&tp->rx_lock); work_done = 0; if (likely(RTL_R16(IntrStatus) & RxAckBits))//接收中断 work_done += rtl8139_rx(dev, tp, budget); /*rtl8139_rx 将接收到的数据拷贝出来封装到 sk_buff 里面传递给上层协议驱动*/ if (work_done < budget) {//如果一次处理的帧个数小于budget(64)则退出轮询模式 unsigned long flags; /* * Order is important since data can get interrupted * again when we think we are done. */ spin_lock_irqsave(&tp->lock, flags); RTL_W16_F(IntrMask, rtl8139_intr_mask); __napi_complete(napi); //退出轮询模式 spin_unlock_irqrestore(&tp->lock, flags); } spin_unlock(&tp->rx_lock); return work_done; } static int rtl8139_rx(struct net_device *dev, struct rtl8139_private *tp, int budget) { void __iomem *ioaddr = tp->mmio_addr; int received = 0; unsigned char *rx_ring = tp->rx_ring; unsigned int cur_rx = tp->cur_rx; unsigned int rx_size = 0; pr_debug("%s: In rtl8139_rx(), current %4.4x BufAddr %4.4x," " free to %4.4x, Cmd %2.2x.\n", dev->name, (u16)cur_rx, RTL_R16 (RxBufAddr), RTL_R16 (RxBufPtr), RTL_R8 (ChipCmd)); //这个函数是一个大循环，循环条件是只要接收缓存不为空就还可以继续读取数据，循环不会停止，读空了之后就跳出 while (netif_running(dev) && received < budget && (RTL_R8 (ChipCmd) & RxBufEmpty) == 0) { u32 ring_offset = cur_rx % RX_BUF_LEN; // u32 rx_status; unsigned int pkt_size; struct sk_buff *skb; rmb(); /* read size+status of next frame from DMA ring buffer */ rx_status = le32_to_cpu (*(__le32 *) (rx_ring + ring_offset)); rx_size = rx_status >> 16; //计算出要接收的包的长度 pkt_size = rx_size - 4; if (netif_msg_rx_status(tp)) pr_debug("%s: rtl8139_rx() status %4.4x, size %4.4x," " cur %4.4x.\n", dev->name, rx_status, rx_size, cur_rx); #if RTL8139_DEBUG > 2 { int i; pr_debug("%s: Frame contents ", dev->name); for (i = 0; i < 70; i++) pr_cont(" %2.2x", rx_ring[ring_offset + i]); pr_cont(".\n"); } #endif /* Packet copy from FIFO still in progress. * Theoretically, this should never happen * since EarlyRx is disabled. */ if (unlikely(rx_size == 0xfff0)) { if (!tp->fifo_copy_timeout) tp->fifo_copy_timeout = jiffies + 2; else if (time_after(jiffies, tp->fifo_copy_timeout)) { pr_debug("%s: hung FIFO. Reset.", dev->name); rx_size = 0; goto no_early_rx; } if (netif_msg_intr(tp)) { pr_debug("%s: fifo copy in progress.", dev->name); } tp->xstats.early_rx++; break; } no_early_rx: tp->fifo_copy_timeout = 0; /* If Rx err or invalid rx_size/rx_status received * (which happens if we get lost in the ring), * Rx process gets reset, so we abort any further * Rx processing. */ if (unlikely((rx_size > (MAX_ETH_FRAME_SIZE+4)) || (rx_size < 8) || (!(rx_status & RxStatusOK)))) { rtl8139_rx_err (rx_status, dev, tp, ioaddr); received = -1; goto out; } /* Malloc up new buffer, compatible with net-2e. */ /* Omit the four octet CRC from the length. */ skb = netdev_alloc_skb(dev, pkt_size + NET_IP_ALIGN); //如果分配成功就把数据从接收缓存中拷贝到这个包中 if (likely(skb)) { skb_reserve (skb, NET_IP_ALIGN); /* 16 byte align the IP fields. */ #if RX_BUF_IDX == 3 wrap_copy(skb, rx_ring, ring_offset+4, pkt_size); #else //现在我们已经熟知，&rx_ring[ring_offset + 4]就是接收缓存，也是源地址， //而skb->data就是包的数据地址,下面这个函数就是将接收到的数据拷贝到skb->data 所指向的位置 skb_copy_to_linear_data (skb, &rx_ring[ring_offset + 4], pkt_size); #endif skb_put (skb, pkt_size); //当接收到的数据应经复制到skb中head指向的位置之后，需要改变skb->tail 指针 skb->protocol = eth_type_trans (skb, dev); dev->stats.rx_bytes += pkt_size; dev->stats.rx_packets++; //在netif_receive_skb (skb)函数执行完后，这个包的数据就脱离了网卡驱动范畴，而进入了Linux网络协议栈里面 netif_receive_skb (skb); } else { if (net_ratelimit()) pr_warning("%s: Memory squeeze, dropping packet.\n", dev->name); dev->stats.rx_dropped++; } received++; cur_rx = (cur_rx + rx_size + 4 + 3) & ~3; RTL_W16 (RxBufPtr, (u16) (cur_rx - 16)); rtl8139_isr_ack(tp); } if (unlikely(!received || rx_size == 0xfff0)) rtl8139_isr_ack(tp); pr_debug("%s: Done rtl8139_rx(), current %4.4x BufAddr %4.4x," " free to %4.4x, Cmd %2.2x.\n", dev->name, cur_rx, RTL_R16 (RxBufAddr), RTL_R16 (RxBufPtr), RTL_R8 (ChipCmd)); tp->cur_rx = cur_rx; /* * The receive buffer should be mostly empty. * Tell NAPI to reenable the Rx irq. */ if (tp->fifo_copy_timeout) received = budget; out: return received; } static int rtl8139_start_xmit (struct sk_buff *skb, struct net_device *dev) { struct rtl8139_private *tp = netdev_priv(dev); void __iomem *ioaddr = tp->mmio_addr; unsigned int entry; unsigned int len = skb->len; unsigned long flags; /* Calculate the next Tx descriptor entry. */ entry = tp->cur_tx % NUM_TX_DESC; /* Note: the chip doesn't have auto-pad! */ if (likely(len < TX_BUF_SIZE)) { if (len < ETH_ZLEN) memset(tp->tx_buf[entry], 0, ETH_ZLEN); skb_copy_and_csum_dev(skb, tp->tx_buf[entry]);//把待发送的数据拷贝到发送缓冲区,也就是skb->data 指向的空间 dev_kfree_skb(skb); } else { dev_kfree_skb(skb); dev->stats.tx_dropped++; return 0; } spin_lock_irqsave(&tp->lock, flags); /* * Writing to TxStatus triggers a DMA transfer of the data * copied to tp->tx_buf[entry] above. Use a memory barrier * to make sure that the device sees the updated data. */ wmb(); /* 我们要让网卡知道这个包的长度，才能保证数据不多不少精确的从缓存中截取出来搬运到网卡中去， 这是靠写发送状态寄存器（TSD）来完成的。 */ RTL_W32_F (TxStatus0 + (entry * sizeof (u32)), tp->tx_flag | max(len, (unsigned int)ETH_ZLEN)); dev->trans_start = jiffies; tp->cur_tx++; /*判断发送缓存是否已经满了，如果满了在发就覆盖数据了，要停发。*/ if ((tp->cur_tx - NUM_TX_DESC) == tp->dirty_tx) netif_stop_queue (dev); spin_unlock_irqrestore(&tp->lock, flags); if (netif_msg_tx_queued(tp)) pr_debug("%s: Queued Tx packet size %u to slot %d.\n", dev->name, len, entry); return 0; }