驱动11.网卡驱动程序

1 网络传输的简介

  

  (1)接收过程,如上图,网络上的数据包到达网卡后,网卡产生中断,然后设备驱动层收到中断后,开始进行网络包的接收,接收完之后调用一个netif_rx函数交给网络协议层(层次结构上图一),然后就是一层一层的网上传到用户空间了。

  (2)发送过程,从用户空间过来的数据包,经过层层穿越之后,到达网络协议层,然后调用一个dev_queue_xmit()函数之后就不管了,剩下的交给驱动层经过处理后,使用函数hard_start_xmit()函数发送,然后硬件上网卡开始发送数据包了。

2 dm9000网卡驱动源代码分析

2.1 首先,看入口函数

1 static int __init dm9000_init(void)
2 {
3     printk(KERN_INFO "%s Ethernet Driver\n", CARDNAME);
4
5     return platform_driver_register(&dm9000_driver);    /* search board and register */
6 }

这是一个平台总线的结构,注册dm9000_driver。

 1 static struct platform_driver dm9000_driver = {
 2     .driver    = {
 3         .name    = "dm9000",
 4         .owner     = THIS_MODULE,
 5     },
 6     .probe   = dm9000_probe,
 7     .remove  = dm9000_drv_remove,
 8     .suspend = dm9000_drv_suspend,
 9     .resume  = dm9000_drv_resume,
10 };

如果平台存在与其同名的平台设备,将调用probe函数

2.2 probe函数

  1 /*
  2  * Search DM9000 board, allocate space and register it
  3  */
  4 static int
  5 dm9000_probe(struct platform_device *pdev)
  6 {
  7     struct dm9000_plat_data *pdata = pdev->dev.platform_data;
  8     struct board_info *db;    /* Point a board information structure */
  9     struct net_device *ndev;
 10     unsigned long base;
 11     int ret = 0;
 12     int iosize;
 13     int i;
 14     u32 id_val;
 15
 16 #if defined(CONFIG_ARCH_S3C2410xxx)
 17     unsigned int oldval_bwscon;        /* 用来保存BWSCON寄存器的值 */
 18     unsigned int oldval_bankcon4;    /* 用来保存S3C2410_BANKCON4寄存器的值 */
 19 #endif
 20
 21     /* Init network device */
 22     ndev = alloc_etherdev(sizeof (struct board_info));
 23     if (!ndev) {
 24         printk("%s: could not allocate device.\n", CARDNAME);
 25         return -ENOMEM;
 26     }
 27
 28     SET_MODULE_OWNER(ndev);
 29     SET_NETDEV_DEV(ndev, &pdev->dev);
 30
 31     PRINTK2("dm9000_probe()");
 32
 33 #if defined(CONFIG_ARCH_S3C2410xxx)
 34     /* 设置Bank4: 总线宽度为16, 使能nWAIT。by www.100ask.net */
 35     oldval_bwscon = *((volatile unsigned int *)S3C2410_BWSCON);
 36     *((volatile unsigned int *)S3C2410_BWSCON) = (oldval_bwscon & ~(3<<16))  37         | S3C2410_BWSCON_DW4_16 | S3C2410_BWSCON_WS4 | S3C2410_BWSCON_ST4;
 38
 39     /* 设置BANK4的时间参数, by www.100ask.net */
 40     oldval_bankcon4 = *((volatile unsigned int *)S3C2410_BANKCON4);
 41     *((volatile unsigned int *)S3C2410_BANKCON4) = 0x1f7c;
 42 #endif
 43
 44     /* setup board info structure */
 45     db = (struct board_info *) ndev->priv;
 46     memset(db, 0, sizeof (*db));
 47
 48     spin_lock_init(&db->lock);
 49
 50     if (pdev->num_resources < 2) {
 51         ret = -ENODEV;
 52         goto out;
 53     } else if (pdev->num_resources == 2) {
 54         base = pdev->resource[0].start;
 55
 56         if (!request_mem_region(base, 4, ndev->name)) {
 57             ret = -EBUSY;
 58             goto out;
 59         }
 60
 61         ndev->base_addr = base;
 62         ndev->irq = pdev->resource[1].start;
 63         db->io_addr = (void __iomem *)base;
 64         db->io_data = (void __iomem *)(base + 4);
 65
 66     } else {
 67         db->addr_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 68         db->data_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 69         db->irq_res  = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
 70
 71         if (db->addr_res == NULL || db->data_res == NULL ||
 72             db->irq_res == NULL) {
 73             printk(KERN_ERR PFX "insufficient resources\n");
 74             ret = -ENOENT;
 75             goto out;
 76         }
 77
 78         i = res_size(db->addr_res);
 79         db->addr_req = request_mem_region(db->addr_res->start, i,
 80                           pdev->name);
 81
 82         if (db->addr_req == NULL) {
 83             printk(KERN_ERR PFX "cannot claim address reg area\n");
 84             ret = -EIO;
 85             goto out;
 86         }
 87
 88         db->io_addr = ioremap(db->addr_res->start, i);
 89
 90         if (db->io_addr == NULL) {
 91             printk(KERN_ERR "failed to ioremap address reg\n");
 92             ret = -EINVAL;
 93             goto out;
 94         }
 95
 96         iosize = res_size(db->data_res);
 97         db->data_req = request_mem_region(db->data_res->start, iosize,
 98                           pdev->name);
 99
100         if (db->data_req == NULL) {
101             printk(KERN_ERR PFX "cannot claim data reg area\n");
102             ret = -EIO;
103             goto out;
104         }
105
106         db->io_data = ioremap(db->data_res->start, iosize);
107
108         if (db->io_data == NULL) {
109             printk(KERN_ERR "failed to ioremap data reg\n");
110             ret = -EINVAL;
111             goto out;
112         }
113
114         /* fill in parameters for net-dev structure */
115
116         ndev->base_addr = (unsigned long)db->io_addr;
117         ndev->irq    = db->irq_res->start;
118
119         /* ensure at least we have a default set of IO routines */
120         dm9000_set_io(db, iosize);
121     }
122
123     /* check to see if anything is being over-ridden */
124     if (pdata != NULL) {
125         /* check to see if the driver wants to over-ride the
126          * default IO width */
127
128         if (pdata->flags & DM9000_PLATF_8BITONLY)
129             dm9000_set_io(db, 1);
130
131         if (pdata->flags & DM9000_PLATF_16BITONLY)
132             dm9000_set_io(db, 2);
133
134         if (pdata->flags & DM9000_PLATF_32BITONLY)
135             dm9000_set_io(db, 4);
136
137         /* check to see if there are any IO routine
138          * over-rides */
139
140         if (pdata->inblk != NULL)
141             db->inblk = pdata->inblk;
142
143         if (pdata->outblk != NULL)
144             db->outblk = pdata->outblk;
145
146         if (pdata->dumpblk != NULL)
147             db->dumpblk = pdata->dumpblk;
148     }
149
150     dm9000_reset(db);
151
152     /* try two times, DM9000 sometimes gets the first read wrong */
153     for (i = 0; i < 2; i++) {
154         id_val  = ior(db, DM9000_VIDL);
155         id_val |= (u32)ior(db, DM9000_VIDH) << 8;
156         id_val |= (u32)ior(db, DM9000_PIDL) << 16;
157         id_val |= (u32)ior(db, DM9000_PIDH) << 24;
158
159         if (id_val == DM9000_ID)
160             break;
161         printk("%s: read wrong id 0x%08x\n", CARDNAME, id_val);
162     }
163
164     if (id_val != DM9000_ID) {
165         printk("%s: wrong id: 0x%08x\n", CARDNAME, id_val);
166         goto release;
167     }
168
169     /* from this point we assume that we have found a DM9000 */
170
171     /* driver system function */
172     ether_setup(ndev);
173
174     ndev->open         = &dm9000_open;
175     ndev->hard_start_xmit    = &dm9000_start_xmit;
176     ndev->tx_timeout         = &dm9000_timeout;
177     ndev->watchdog_timeo = msecs_to_jiffies(watchdog);
178     ndev->stop         = &dm9000_stop;
179     ndev->get_stats         = &dm9000_get_stats;
180     ndev->set_multicast_list = &dm9000_hash_table;
181 #ifdef CONFIG_NET_POLL_CONTROLLER
182     ndev->poll_controller     = &dm9000_poll_controller;
183 #endif
184
185 #ifdef DM9000_PROGRAM_EEPROM
186     program_eeprom(db);
187 #endif
188     db->msg_enable       = NETIF_MSG_LINK;
189     db->mii.phy_id_mask  = 0x1f;
190     db->mii.reg_num_mask = 0x1f;
191     db->mii.force_media  = 0;
192     db->mii.full_duplex  = 0;
193     db->mii.dev         = ndev;
194     db->mii.mdio_read    = dm9000_phy_read;
195     db->mii.mdio_write   = dm9000_phy_write;
196
197     /* Read SROM content */
198     for (i = 0; i < 64; i++)
199         ((u16 *) db->srom)[i] = read_srom_word(db, i);
200
201     /* Set Node Address */
202     for (i = 0; i < 6; i++)
203         ndev->dev_addr[i] = db->srom[i];
204
205     if (!is_valid_ether_addr(ndev->dev_addr)) {
206         /* try reading from mac */
207
208         for (i = 0; i < 6; i++)
209             ndev->dev_addr[i] = ior(db, i+DM9000_PAR);
210     }
211
212     if (!is_valid_ether_addr(ndev->dev_addr)) {
213         printk("%s: Invalid ethernet MAC address.  Please "
214                "set using ifconfig\n", ndev->name);
215 #if defined(CONFIG_ARCH_S3C2410)
216         printk("Now use the default MAC address: 08:90:90:90:90:90\n");
217         ndev->dev_addr[0] = 0x08;
218         ndev->dev_addr[1] = 0x90;
219         ndev->dev_addr[2] = 0x90;
220         ndev->dev_addr[3] = 0x90;
221         ndev->dev_addr[4] = 0x90;
222         ndev->dev_addr[5] = 0x90;
223 #endif
224     }
225
226     platform_set_drvdata(pdev, ndev);
227     ret = register_netdev(ndev);
228
229     if (ret == 0) {
230         printk("%s: dm9000 at %p,%p IRQ %d MAC: ",
231                ndev->name,  db->io_addr, db->io_data, ndev->irq);
232         for (i = 0; i < 5; i++)
233             printk("%02x:", ndev->dev_addr[i]);
234         printk("%02x\n", ndev->dev_addr[5]);
235     }
236     return 0;
237
238  release:
239  out:
240     printk("%s: not found (%d).\n", CARDNAME, ret);
241 #if defined(CONFIG_ARCH_S3C2410xxx)
242     /* 恢复寄存器原来的值 */
243     *((volatile unsigned int *)S3C2410_BWSCON) = oldval_bwscon;
244     *((volatile unsigned int *)S3C2410_BANKCON4) = oldval_bankcon4;
245 #endif
246     dm9000_release_board(pdev, db);
247     free_netdev(ndev);
248
249     return ret;
250 }

probe函数

主要完后以下工作:

①分配一个net_device结构体(alloc_etherdev)

②定义一个单板相关信息board_info结构体

③设置net_device和board_info结构体

④使用board_info信息来初始化单板

⑤初始化网卡

⑥设置操作函数open,hard_start_xmit(发包函数),tx_timeout(超时函数),watchdog_timeo(看门狗函数),stop,get_stats,set_multicast_list

设置MAC地址

最后,注册net_device结构体

2.3 发包函数

 1 /*
 2  *  Hardware start transmission.
 3  *  Send a packet to media from the upper layer.
 4  */
 5 static int
 6 dm9000_start_xmit(struct sk_buff *skb, struct net_device *dev)
 7 {
 8     board_info_t *db = (board_info_t *) dev->priv;
 9
10     PRINTK3("dm9000_start_xmit\n");
11
12     if (db->tx_pkt_cnt > 1)
13         return 1;
14
15     netif_stop_queue(dev);
16
17     /* Disable all interrupts */
18     iow(db, DM9000_IMR, IMR_PAR);
19
20     /* Move data to DM9000 TX RAM */
21     writeb(DM9000_MWCMD, db->io_addr);
22
23     (db->outblk)(db->io_data, skb->data, skb->len);
24     db->stats.tx_bytes += skb->len;
25
26     /* TX control: First packet immediately send, second packet queue */
27     if (db->tx_pkt_cnt == 0) {
28
29         /* First Packet */
30         db->tx_pkt_cnt++;
31
32         /* Set TX length to DM9000 */
33         iow(db, DM9000_TXPLL, skb->len & 0xff);
34         iow(db, DM9000_TXPLH, (skb->len >> 8) & 0xff);
35
36         /* Issue TX polling command */
37         iow(db, DM9000_TCR, TCR_TXREQ);    /* Cleared after TX complete */
38
39         dev->trans_start = jiffies;    /* save the time stamp */
40
41     } else {
42         /* Second packet */
43         db->tx_pkt_cnt++;
44         db->queue_pkt_len = skb->len;
45     }
46
47     /* free this SKB */
48     dev_kfree_skb(skb);
49
50     /* Re-enable resource check */
51     if (db->tx_pkt_cnt == 1)
52         netif_wake_queue(dev);
53
54     /* Re-enable interrupt */
55     iow(db, DM9000_IMR, IMR_PAR | IMR_PTM | IMR_PRM);
56
57     return 0;
58 }

发包函数

主要完后以下工作:

1.停止该网卡的队列,把skb数据写入网卡netif_stop_queue(dev);
2.构造一个虚假的skb_buff上报
3.释放skb(dev_kfree_skb)

4.数据全部发送出去后唤醒网卡队列(netif_wake_queue)

5.更新统计信息

3 写代码

  1 /*
  2  * 参考 drivers\net\cs89x0.c
  3  */
  4
  5 #include <linux/module.h>
  6 #include <linux/errno.h>
  7 #include <linux/netdevice.h>
  8 #include <linux/etherdevice.h>
  9 #include <linux/kernel.h>
 10 #include <linux/types.h>
 11 #include <linux/fcntl.h>
 12 #include <linux/interrupt.h>
 13 #include <linux/ioport.h>
 14 #include <linux/in.h>
 15 #include <linux/skbuff.h>
 16 #include <linux/slab.h>
 17 #include <linux/spinlock.h>
 18 #include <linux/string.h>
 19 #include <linux/init.h>
 20 #include <linux/bitops.h>
 21 #include <linux/delay.h>
 22 #include <linux/ip.h>
 23
 24 #include <asm/system.h>
 25 #include <asm/io.h>
 26 #include <asm/irq.h>
 27
 28 static struct net_device *vnet_dev;
 29
 30 static void emulator_rx_packet(struct sk_buff *skb, struct net_device *dev)
 31 {
 32     /* 参考LDD3 */
 33     unsigned char *type;
 34     struct iphdr *ih;
 35     __be32 *saddr, *daddr, tmp;
 36     unsigned char    tmp_dev_addr[ETH_ALEN];
 37     struct ethhdr *ethhdr;
 38
 39     struct sk_buff *rx_skb;
 40
 41     // 从硬件读出/保存数据
 42     /* 对调"源/目的"的mac地址 */
 43     ethhdr = (struct ethhdr *)skb->data;
 44     memcpy(tmp_dev_addr, ethhdr->h_dest, ETH_ALEN);
 45     memcpy(ethhdr->h_dest, ethhdr->h_source, ETH_ALEN);
 46     memcpy(ethhdr->h_source, tmp_dev_addr, ETH_ALEN);
 47
 48     /* 对调"源/目的"的ip地址 */
 49     ih = (struct iphdr *)(skb->data + sizeof(struct ethhdr));
 50     saddr = &ih->saddr;
 51     daddr = &ih->daddr;
 52
 53     tmp = *saddr;
 54     *saddr = *daddr;
 55     *daddr = tmp;
 56
 57     //((u8 *)saddr)[2] ^= 1; /* change the third octet (class C) */
 58     //((u8 *)daddr)[2] ^= 1;
 59     type = skb->data + sizeof(struct ethhdr) + sizeof(struct iphdr);
 60     //printk("tx package type = %02x\n", *type);
 61     // 修改类型, 原来0x8表示ping
 62     *type = 0; /* 0表示reply */
 63
 64     ih->check = 0;           /* and rebuild the checksum (ip needs it) */
 65     ih->check = ip_fast_csum((unsigned char *)ih,ih->ihl);
 66
 67     // 构造一个sk_buff
 68     rx_skb = dev_alloc_skb(skb->len + 2);
 69     skb_reserve(rx_skb, 2); /* align IP on 16B boundary */
 70     memcpy(skb_put(rx_skb, skb->len), skb->data, skb->len);
 71
 72     /* Write metadata, and then pass to the receive level */
 73     rx_skb->dev = dev;
 74     rx_skb->protocol = eth_type_trans(rx_skb, dev);
 75     rx_skb->ip_summed = CHECKSUM_UNNECESSARY; /* don‘t check it */
 76     dev->stats.rx_packets++;
 77     dev->stats.rx_bytes += skb->len;
 78
 79     // 提交sk_buff
 80     netif_rx(rx_skb);
 81 }
 82
 83 static int virt_net_send_packet(struct sk_buff *skb, struct net_device *dev)
 84 {
 85     static int cnt = 0;
 86     printk("virt_net_send_packet cnt = %d\n", ++cnt);
 87
 88     /* 对于真实的网卡, 把skb里的数据通过网卡发送出去 */
 89     netif_stop_queue(dev); /* 停止该网卡的队列 */
 90     /* ...... */           /* 把skb的数据写入网卡 */
 91
 92     /* 构造一个假的sk_buff,上报 */
 93     emulator_rx_packet(skb, dev);
 94
 95     dev_kfree_skb (skb);   /* 释放skb */
 96     netif_wake_queue(dev); /* 数据全部发送出去后,唤醒网卡的队列 */
 97
 98     /* 更新统计信息 */
 99     dev->stats.tx_packets++;
100     dev->stats.tx_bytes += skb->len;
101
102     return 0;
103 }
104
105
106 static int virt_net_init(void)
107 {
108     /* 1. 分配一个net_device结构体 */
109     vnet_dev = alloc_netdev(0, "vnet%d", ether_setup);;  /* alloc_etherdev */
110
111     /* 2. 设置 */
112     vnet_dev->hard_start_xmit = virt_net_send_packet;
113
114     /* 设置MAC地址 */
115     vnet_dev->dev_addr[0] = 0x08;
116     vnet_dev->dev_addr[1] = 0x89;
117     vnet_dev->dev_addr[2] = 0x89;
118     vnet_dev->dev_addr[3] = 0x89;
119     vnet_dev->dev_addr[4] = 0x89;
120     vnet_dev->dev_addr[5] = 0x11;
121
122     /* 设置下面两项才能ping通 */
123     vnet_dev->flags           |= IFF_NOARP;
124     vnet_dev->features        |= NETIF_F_NO_CSUM;
125
126     /* 3. 注册 */
127     //register_netdevice(vnet_dev);
128     register_netdev(vnet_dev);
129
130     return 0;
131 }
132
133 static void virt_net_exit(void)
134 {
135     unregister_netdev(vnet_dev);
136     free_netdev(vnet_dev);
137 }
138
139 module_init(virt_net_init);
140 module_exit(virt_net_exit);
141
142 MODULE_AUTHOR("[email protected],[email protected]");
143 MODULE_LICENSE("GPL");

virtnet.c

时间: 2024-10-20 16:42:27

驱动11.网卡驱动程序的相关文章

S3C2440实现dm9000网卡驱动程序移植

20150419 S3C2440实现dm9000网卡驱动程序移植 2015-04-19 Lover雪儿 首先附上厂家提供的完整的dm9000程序: 1 /* 2 3 dm9ks.c: Version 2.08 2007/02/12 4 5 A Davicom DM9000/DM9010 ISA NIC fast Ethernet driver for Linux. 6 7 This program is free software; you can redistribute it and/or

转:Linux网卡驱动程序编写

Linux网卡驱动程序编写 [摘自 LinuxAID] 工作需要写了我们公司一块网卡的Linux驱动程序.经历一个从无到有的过程,深感技术交流的重要.Linux作为挑战微软垄断的强有力武器,日益受到大家的喜爱.真希望她能在中国迅速成长.把程序文档贴出来,希望和大家探讨Linux技术和应用,促进Linux在中国的普及. Linux操作系统网络驱动程序编写 一.Linux系统设备驱动程序概述 1.1 Linux设备驱动程序分类 1.2 编写驱动程序的一些基本概念 二.Linux系统网络设备驱动程序

DM9000C网卡驱动程序编写与测试

一般网卡驱动程序厂商会给我们提供一份模板驱动,我们的工作就是需要根据自己的需要更改这个模板驱动 1.DM9000C的硬件连接 硬件连接图如下所示:它接在S3C2440的BANK4内存控制器上,它只占用8个字节的长度,并且是16bit的位宽. 下面介绍一下DM9000C的主要引脚的功能:SD0-SD15位16bit的数据引脚接口:IOR为读使能信号,低电平有效:IOW为写使能信号,低电平有效:CS为片选信号,低电平有效:CMD为数据与索引选择信号,高电平表数据,低电平表索引,它连接到S3C2440

安装或更新CentOS6.7平台的网卡驱动程序

基于Linux平台安装或更新网卡驱动程序与Windows平台相差不大,首先查阅出主机网卡的具体型号.Windows平台可以借助鲁大师等硬件检测工具查看网卡,Linux平台有适用的命令lspci.ethtool查看. 在CentOS6.7平台下使用命令lspci | grep -i net查看网卡具体型号 可以查看到该主机网卡为Intel 82545EM 千兆以太网卡 如果是更新网卡驱动,我们可以使用命令ethtool -i eth0查看目前网卡驱动程序版本信息 可查看到驱动程序名称.版本号.固件

《 转》Linux 网卡驱动程序对 ethtool 的支持和实现

Linux 的一个显著特点就是其强大的网络功能,Linux 几乎支持所有的网络协议,并在这些协议基础上提供了丰富的应用.对 Linux 网络管理的重要性不言而喻,这些管理依赖于网络工具,比如最常用的 ifconfig,route,ip,ethtool 等,其中 ethtool 提供了强大的网卡及网卡驱动管理能力,其具体的实现框架和网络驱动程序及网络硬件关系紧密,容易修改和扩展,能够为 Linux 网络开发人员和管理人员提供对网卡硬件,驱动程序和网络协议栈的设置,查看以及及调试等功能. 从典型的以

LINUX块设备驱动&lt;11&gt;

第 11章 +---------------------------------------------------+ |                 写一个块设备驱动                   | +---------------------------------------------------+ | 作者:赵磊                                         | | email: [email protected]             

写一个块设备驱动11,12

http://blogold.chinaunix.net/u3/108239/showart.php?id=2144635 第11章 +---------------------------------------------------+|                 写一个块设备驱动                  |+---------------------------------------------------+| 作者:赵磊                         

【Linux 驱动】设备驱动程序再理解

学习设备驱动编程也有一段时间了,也写过了几个驱动程序,因此有对设备驱动程序有了一些新的理解和认识,总结一下.学习设备驱动编程也有一段时间了,也写过了几个驱动程序,因此有对设备驱动程序有了一些新的理解和认识,总结一下. ★什么是驱动程序 刚开始学习设备驱动程序的时候,产生了许多的问题.什么是驱动程序?驱动程序是干嘛的?它是如何工作的?它又是如何跟操作系统联系起来的?一系列的问题,现在有些地方还是不一定清楚,但是相比起刚开始的那个阶段,感觉自己还是清楚了很多. 设备驱动程序说白了(实质)就是为应用程

Linux通过网卡驱动程序和版本号的信息

检查卡制造商和信号 查看基本信息:lspci 查看详情:lspci -vvv   # 3小作文v 查看卡信息:lspci | grep Ethernet 查看网卡驱动 查看网卡驱动信息:lspci -vvv # 找到网卡设备的具体信息.包含网卡驱动 # lsmod    列出载入的全部驱动.包含网卡驱动 查看网卡驱动版本号 查看模块信息:modifo<module name>   # 当中包括version信息 或 # ethtool-i <device name> RHEL 6.