深入解析网卡驱动开发与移植

网卡驱动的原理、开发、适配与移植详解（CSDN技术深度解析）

作者： 技术探索者 发布时间： 2024年6月 标签： Linux驱动开发｜网卡驱动｜设备树｜内核模块｜嵌入式系统

引言

在现代操作系统中，网络通信是核心功能之一。而实现网络通信的基础，正是网卡驱动程序（Network Interface Card Driver, NIC Driver）。它作为操作系统与物理网络硬件之间的桥梁，负责数据包的收发、中断处理、DMA传输等关键任务。

本文将深入剖析网卡驱动的工作原理，详细介绍其在Linux系统中的开发流程、适配方法及跨平台移植技巧，并结合真实代码示例进行讲解，帮助开发者全面掌握网卡驱动从零到一的构建过程。

一、网卡驱动的基本原理

1.1 网卡驱动的作用

网卡驱动的主要职责包括：

• 初始化硬件：配置MAC地址、设置工作模式（全双工/半双工）、速率协商等。
• 管理数据收发：
  • 发送数据时，将上层协议栈的数据封装成帧并写入网卡寄存器或DMA缓冲区；
  • 接收数据时，从硬件读取以太网帧，剥离头部后提交给上层协议栈（如IP层）。
• 中断处理：响应数据到达、发送完成、错误状态等中断事件。
• DMA控制：利用直接内存访问机制高效传输大量数据，减少CPU负担。
• 电源管理与热插拔支持：支持Suspend/Resume、动态功耗调节等功能。

1.2 驱动在内核中的位置

Linux网络子系统采用分层架构：

[应用层] → socket()
↓
[协议栈层] → TCP/IP (inet_protos)
↓
[网络设备层] → struct net_device （核心结构体）
↓
[网卡驱动层] → 驱动实现 open(), xmit(), interrupt() 等回调函数
↓
[物理硬件] → PHY + MAC 控制器（如 RTL8139、e1000、DM9000）

其中 struct net_device 是所有网络接口的核心抽象，由驱动注册并向内核提供操作接口。

二、Linux网卡驱动开发详解

我们以一个典型的嵌入式平台（基于ARM+SMSC LAN9220芯片）为例，说明如何编写一个简单的平台网卡驱动。

2.1 开发环境准备

• 主机系统：Ubuntu 20.04
• 目标平台：ARM Cortex-A9（Zynq）
• 内核版本：Linux 5.10
• 编译工具链：arm-linux-gnueabihf-gcc
• 开发方式：模块化编译（insmod加载）

2.2 核心数据结构介绍

struct net_device

这是每个网络接口的代表，包含如下重要字段：

struct net_device {
char name[IFNAMSIZ]; // 接口名，如 eth0
struct net_device_ops *netdev_ops; // 操作函数集
unsigned long state; // 状态标志（UP/DOWN等）
unsigned int flags; // IFF_UP, IFF_BROADCAST 等
struct net_device_stats stats; // 统计信息（收发包数、错误等）
void *priv; // 私有数据指针（常用于保存驱动上下文）
};

struct net_device_ops

定义驱动提供的功能函数：

static const struct net_device_ops smsc_netdev_ops = {
.ndo_open = smsc_open,
.ndo_stop = smsc_close,
.ndo_start_xmit = smsc_hard_start_xmit,
.ndo_set_mac_address = smsc_set_mac_address,
.ndo_get_stats = smsc_get_stats,
};

2.3 示例驱动代码框架（简化版）

#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/interrupt.h>
#include <linux/io.h>

// 私有数据结构
struct smsc_local {
void __iomem *base;
int irq;
struct net_device *dev;
};

// 打开设备
static int smsc_open(struct net_device *dev)
{
struct smsc_local *lp = netdev_priv(dev);

// 映射I/O内存、申请中断
if (!request_mem_region(lp->base_phys, SZ_64K, "smsc9220")) {
return –EBUSY;
}

lp->base = ioremap(lp->base_phys, SZ_64K);
if (!lp->base)
return –ENOMEM;

if (request_irq(lp->irq, smsc_interrupt, 0, dev->name, dev)) {
iounmap(lp->base);
release_mem_region(lp->base_phys, SZ_64K);
return –EAGAIN;
}

// 启动硬件（伪代码）
writel(0x1, lp->base + REG_MAC_ENABLE);

netif_start_queue(dev);
printk(KERN_INFO "%s: device opened\\n", dev->name);
return 0;
}

// 发送数据包
static netdev_tx_t smsc_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
struct smsc_local *lp = netdev_priv(dev);

// 将skb数据写入硬件TX FIFO（此处为简化逻辑）
memcpy_toio(lp->base + TX_FIFO, skb->data, skb->len);

// 触发发送
writel(skb->len, lp->base + REG_TX_LENGTH);
writel(0x1, lp->base + REG_TX_START);

// 释放skb
dev_kfree_skb(skb);

// 更新统计
dev->stats.tx_packets++;
dev->stats.tx_bytes += skb->len;

return NETDEV_TX_OK;
}

// 中断处理函数
static irqreturn_t smsc_interrupt(int irq, void *dev_id)
{
struct net_device *dev = (struct net_device *)dev_id;
struct smsc_local *lp = netdev_priv(dev);
u32 intr_status;

intr_status = readl(lp->base + REG_INT_STS);

if (intr_status & INT_RX) {
smsc_rx(dev); // 调用接收处理
}
if (intr_status & INT_TX) {
dev->stats.tx_packets++;
netif_wake_queue(dev);
}

return IRQ_HANDLED;
}

// 接收数据包处理
static void smsc_rx(struct net_device *dev)
{
struct smsc_local *lp = netdev_priv(dev);
u32 rx_status, rx_len;
struct sk_buff *skb;

rx_status = readl(lp->base + REG_RX_STATUS);
if (!(rx_status & RX_EOP))
return;

rx_len = readl(lp->base + REG_RX_LENGTH) & 0xFFFF;

skb = netdev_alloc_skb(dev, rx_len + 4);
if (!skb) {
dev->stats.rx_dropped++;
return;
}

skb_reserve(skb, 2);
memcpy_fromio(skb->data, lp->base + RX_FIFO, rx_len);
skb_put(skb, rx_len);

skb->protocol = eth_type_trans(skb, dev);
netif_rx(skb); // 提交到上层协议栈

dev->stats.rx_packets++;
dev->stats.rx_bytes += rx_len;
}

// 关闭设备
static int smsc_close(struct net_device *dev)
{
struct smsc_local *lp = netdev_priv(dev);

netif_stop_queue(dev);
writel(0x0, lp->base + REG_MAC_ENABLE);

free_irq(lp->irq, dev);
iounmap(lp->base);
release_mem_region(lp->base_phys, SZ_64K);

return 0;
}

// 设置MAC地址
static int smsc_set_mac_address(struct net_device *dev, void *p)
{
struct sockaddr *addr = p;

if (!is_valid_ether_addr(addr->sa_data))
return –EADDRNOTAVAIL;

eth_hw_addr_set(dev, addr->sa_data);
return 0;
}

// 获取统计信息
static struct net_device_stats *smsc_get_stats(struct net_device *dev)
{
return &dev->stats;
}

2.4 驱动注册与卸载

static int __init smsc_init(void)
{
struct net_device *dev;
struct smsc_local *lp;
int ret;

dev = alloc_etherdev(sizeof(struct smsc_local));
if (!dev)
return –ENOMEM;

lp = netdev_priv(dev);
ether_setup(dev);

// 初始化硬件资源（根据设备树获取）
lp->base_phys = 0x40000000;
lp->irq = 57;
lp->dev = dev;

dev->netdev_ops = &smsc_netdev_ops;
dev->watchdog_timeo = HZ; // 超时时间

ret = register_netdev(dev);
if (ret) {
free_netdev(dev);
return ret;
}

printk(KERN_INFO "SMSC LAN9220 driver loaded\\n");
return 0;
}

static void __exit smsc_exit(void)
{
unregister_netdev(lp->dev);
free_netdev(lp->dev);
printk(KERN_INFO "SMSC driver unloaded\\n");
}

module_init(smsc_init);
module_exit(smsc_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Simple SMSC LAN9220 Network Driver");

三、设备树适配（Device Tree）

对于现代嵌入式Linux系统，硬件资源配置通过设备树传递。

设备树节点示例（.dtsi 文件）：

&axi {
smsc: ethernet@40000000 {
compatible = "smsc,lan9220";
reg = <0x40000000 0x10000>;
interrupts = <0 57 4>; /* IRQ_TYPE_LEVEL_HIGH */
interrupt-parent = <&gic>;
phy-mode = "mii";
status = "okay";
};
};

驱动中使用 OF 匹配：

static const struct of_device_id smsc_of_match[] = {
{ .compatible = "smsc,lan9220", },
{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, smsc_of_match);

static struct platform_driver smsc_platform_driver = {
.probe = smsc_probe,
.remove = smsc_remove,
.driver = {
.name = "smsc9220",
.of_match_table = smsc_of_match,
},
};

module_platform_driver(smsc_platform_driver);

在 probe() 函数中使用 of_iomap() 和 irq_of_parse_and_map() 自动获取资源。

四、驱动移植的关键步骤

当你需要将网卡驱动从一个平台迁移到另一个平台时，需关注以下几点：

4.1 硬件差异分析

4.2 修改点清单

4.3 使用标准PHY框架（推荐做法）

不要自己实现MDIO读写！应使用内核的 phylib 框架：

#include <linux/phy.h>

// 在 probe 中连接 PHY
struct phy_device *phydev;
phydev = phy_find_first(priv->mii_bus);
if (!phydev)
return –ENODEV;

phy_connect(dev, phydev->attached_dev.phy, &smsc_adjust_link, PHY_INTERFACE_MODE_MII);

这样可以自动处理自协商、链路状态监控、速率切换等问题。

五、调试技巧与常见问题

5.1 常见问题排查

5.2 调试手段

• 使用 printk() 输出关键流程（建议用 netdev_info/dev_err）
• 利用 ethtool 查看驱动状态：

ethtool eth0 # 查看基本信息
ethtool -i eth0 # 查看驱动版本
ethtool -S eth0 # 查看统计计数

• 使用 tcpdump 验证数据通路：

tcpdump -i eth0 -n

• 内核配置开启网络调试选项：

CONFIG_NET_CORE_DIAG=y
CONFIG_ETHTOOL_NETLINK=y

六、进阶话题：虚拟网卡与TUN/TAP

除了物理网卡驱动，Linux还支持虚拟网络设备，例如：

• TUN/TAP：用户态隧道设备，用于VPN（OpenVPN）、容器网络。
• veth pair：虚拟以太网对，用于Docker bridge通信。
• Bridge/NF Tables接口：软交换与防火墙集成。

这些也基于 struct net_device 实现，但无需操作真实硬件。

示例：创建TAP设备

#include <linux/if_tun.h>

struct tun_struct *tun;
tun = tun_alloc("tap0", IFF_TAP | IFF_NO_PI);

七、总结

网卡驱动开发是一项系统性工程，要求开发者同时具备硬件知识、操作系统原理和C语言编程能力。随着Linux内核生态日益成熟，借助标准框架（如 phylib、MDIO、ethtool）可大幅降低开发难度。

参考资料

✅ 原创不易，欢迎点赞收藏转发！ ❓ 如有疑问，欢迎评论区留言交流~