Linux DM9000网卡驱动程序完全分析

[置顶]Linux DM9000网卡驱动程序完全分析

说明1：本文分析基于内核源码版本为linux-2.6.31
说明2：本文在理解了linux中总线、设备和驱动模型的基础上加以分析代码

虽然Linux驱动程序应该是和具体的硬件平台分离的，但是为了更好的理解DM9000的驱动程序，这里还是结合一下Mini2440开发板，这样也可以更好的体会如何实现驱动和平台分离。

本文分成以下几个部分：
一、Mini2440开发板上DM9000的电气连接和Mach-mini2440.c文件的关系。
二、两个重要的结构体介绍：sk_buff和net_device
三、具体代码分析

一、Mini2440开发板上DM9000的电气连接和Mach-mini2440.c文件的关系
Mini2440开发板上DM9000与S3C2440的连接关系如下：

其中片选信号AEN使用了nGCS4，所以网卡的内存区域在BANK4，也就是从地址0x20000000开始。DM9000的TXD[2:0]作为strap pin在电路图中是空接的，所以IO base是300H。中断使用了EINT7。这些内容在Mach文件中有如下体现：

view plain

1. #defineS3C2410_CS4(0x20000000)
2. #defineMACH_MINI2440_DM9K_BASE(S3C2410_CS4+0x300)
3. staticstructresourcemini2440_dm9k_resource[]__initdata={
4. [0]={
5. .start=MACH_MINI2440_DM9K_BASE,
6. .end=MACH_MINI2440_DM9K_BASE+3,
7. .flags=IORESOURCE_MEM
8. },
9. [1]={
10. .start=MACH_MINI2440_DM9K_BASE+4,
11. .end=MACH_MINI2440_DM9K_BASE+7,
12. .flags=IORESOURCE_MEM
13. },
14. [2]={
15. .start=IRQ_EINT7,
16. .end=IRQ_EINT7,
17. .flags=IORESOURCE_IRQ|IORESOURCE_IRQ_HIGHEDGE,
18. }
19. };

另外在Mach文件中还定义了DM9000平台设备，设备名称为“dm9000”，设备资源就是上面定义的IO和中断资源。代码清单如下：

view plain

1. staticstructdm9000_plat_datamini2440_dm9k_pdata__initdata={
2. .flags=(DM9000_PLATF_16BITONLY|DM9000_PLATF_NO_EEPROM),
3. };
5. staticstructplatform_devicemini2440_device_eth__initdata={
6. .name="dm9000",
7. .id=-1,
8. .num_resources=ARRAY_SIZE(mini2440_dm9k_resource),
9. .resource=mini2440_dm9k_resource,
10. .dev={
11. .platform_data=&mini2440_dm9k_pdata,
12. },
13. };

这个DM9000平台设备作为众多平台设备中的一个在扳子初始化的时候就被添加到了总线上。代码清单如下：

view plain

1. MACHINE_START(MINI2440,"MINI2440")
2. /*Maintainer:MichelPollet<buserror@gmail.com>*/
3. .phys_io=S3C2410_PA_UART,
4. .io_pg_offst=(((u32)S3C24XX_VA_UART)>>18)&0xfffc,
5. .boot_params=S3C2410_SDRAM_PA+0x100,
6. .map_io=mini2440_map_io,
7. .init_machine=mini2440_init,/*初始化函数*/
8. .init_irq=s3c24xx_init_irq,
9. .timer=&s3c24xx_timer,
10. MACHINE_END

view plain

1. staticvoid__initmini2440_init(void)
2. {
3. ...
4. ...
5. platform_add_devices(mini2440_devices,ARRAY_SIZE(mini2440_devices));
7. ...
8. ...
9. }

view plain

1. staticstructplatform_device*mini2440_devices[]__initdata={
2. &s3c_device_usb,
3. &s3c_device_wdt,
4. /*&s3c_device_adc,*//*ADCdoesn'tlikelivingwithtouchscreen!*/
5. &s3c_device_i2c0,
6. &s3c_device_rtc,
7. &s3c_device_usbgadget,
8. &mini2440_device_eth,/*dm9000是众多平台设备中的一个*/
9. &mini2440_led1,
10. &mini2440_led2,
11. &mini2440_led3,
12. &mini2440_led4,
13. &mini2440_button_device,
14. &s3c_device_nand,
15. &s3c_device_sdi,
16. &s3c_device_iis,
17. &mini2440_audio,
18. /*&s3c_device_timer[0],*//*buzzerpwm,noAPIforit*/
19. /*remainingdevicesareoptional*/
20. };

二、两个重要的结构体简单介绍：sk_buff和net_device

*sk_buff

如果把网络传输看成是运送货物的话，那么sk_buff就是这个“货物”了，所有经手这个货物的人都要干点什么事儿，要么加个包装，要么印个戳儿等等。收货的时候就要拆掉这些包装，得到我们需要的货物（payload data）。没有货物你还运输什么呢？由此可见sk_buff的重要性了。关于sk_buff的详细介绍和几个操作它的函数，参考本博客转载的一篇文章：“linux内核sk_buff的结构分析”，写得非常明白了。赞一个~

*net_device

又是一个庞大的结构体。好吧，我承认我从来就没有看全过这个结构体。它在内核中就是指代了一个网络设备。驱动程序需要在探测的时候分配并初始化这个结构体，然后使用register_netdev来注册它，这样就可以把操作硬件的函数与内核挂接在一起。

三、具体代码的分析
在顺序分析之前先看三个结构体变量和一个自定义的结构体。

* dm9000_driver变量。是platform_driver结构体变量，其中包含了重要的：驱动的名字（用来match）和几个重要操作函数。

view plain

1. staticstructplatform_driverdm9000_driver={
2. .driver={
3. .name="dm9000",
4. .owner=THIS_MODULE,
5. },
6. .probe=dm9000_probe,
7. .remove=__devexit_p(dm9000_drv_remove),
8. .suspend=dm9000_drv_suspend,
9. .resume=dm9000_drv_resume,
10. };

* dm9000_netdev_ops变量。是net_device_ops结构体变量，其中定义了操作net_device的重要函数，我们在驱动程序中根据需要的操作要填充这些函数。代码清单如下：

view plain

1. staticconststructnet_device_opsdm9000_netdev_ops={
2. .ndo_open=dm9000_open,
3. .ndo_stop=dm9000_stop,
4. .ndo_start_xmit=dm9000_start_xmit,
5. .ndo_tx_timeout=dm9000_timeout,
6. .ndo_set_multicast_list=dm9000_hash_table,
7. .ndo_do_ioctl=dm9000_ioctl,
8. .ndo_change_mtu=eth_change_mtu,
9. .ndo_validate_addr=eth_validate_addr,
10. .ndo_set_mac_address=eth_mac_addr,
11. #ifdefCONFIG_NET_POLL_CONTROLLER
12. .ndo_poll_controller=dm9000_poll_controller,
13. #endif
14. };

* dm9000_ethtool_ops变量。是ethtool_ops结构体变量，为了支持ethtool，其中的函数主要是用于查询和设置网卡参数（当然也有的驱动程序可能不支持ethtool）。代码清单如下：

view plain

1. staticconststructethtool_opsdm9000_ethtool_ops={
2. .get_drvinfo=dm9000_get_drvinfo,
3. .get_settings=dm9000_get_settings,
4. .set_settings=dm9000_set_settings,
5. .get_msglevel=dm9000_get_msglevel,
6. .set_msglevel=dm9000_set_msglevel,
7. .nway_reset=dm9000_nway_reset,
8. .get_link=dm9000_get_link,
9. .get_eeprom_len=dm9000_get_eeprom_len,
10. .get_eeprom=dm9000_get_eeprom,
11. .set_eeprom=dm9000_set_eeprom,
12. };

* board_info结构体。用来保存芯片相关的一些私有信息。具体在代码中分析。下面是这个结构体的清单。

view plain

1. /*Structure/enumdeclaration-------------------------------*/
2. typedefstructboard_info{
4. void__iomem*io_addr;/*RegisterI/Obaseaddress*/
5. void__iomem*io_data;/*DataI/Oaddress*/
6. u16irq;/*IRQ*/
8. u16tx_pkt_cnt;
9. u16queue_pkt_len;
10. u16queue_start_addr;
11. u16dbug_cnt;
12. u8io_mode;/*0:word,2:byte*/
13. u8phy_addr;
14. u8imr_all;
16. unsignedintflags;
17. unsignedintin_suspend:1;
18. intdebug_level;
20. enumdm9000_typetype;
22. void(*inblk)(void__iomem*port,void*data,intlength);
23. void(*outblk)(void__iomem*port,void*data,intlength);
24. void(*dumpblk)(void__iomem*port,intlength);
26. structdevice*dev;/*parentdevice*/
28. structresource*addr_res;/*resourcesfound*/
29. structresource*data_res;
30. structresource*addr_req;/*resourcesrequested*/
31. structresource*data_req;
32. structresource*irq_res;
34. structmutexaddr_lock;/*phyandeepromaccesslock*/
36. structdelayed_workphy_poll;
37. structnet_device*ndev;
39. spinlock_tlock;
41. structmii_if_infomii;
42. u32msg_enable;
43. }board_info_t;

下面看一下具体代码。

分析代码还是从init顺序开始。

1. 注册平台驱动。

主要完成的任务是：将驱动添加到总线上，完成驱动和设备的match，并执行驱动的probe函数。代码清单如下：

view plain

1. staticstructplatform_driverdm9000_driver={
2. .driver={
3. .name="dm9000",/*用这个名字完成驱动和设备的match*/
4. .owner=THIS_MODULE,
5. },
6. .probe=dm9000_probe,
7. .remove=__devexit_p(dm9000_drv_remove),
8. .suspend=dm9000_drv_suspend,
9. .resume=dm9000_drv_resume,
10. };
12. staticint__init
13. dm9000_init(void)
14. {
15. printk(KERN_INFO"%sEthernetDriver,V%s/n",CARDNAME,DRV_VERSION);
17. returnplatform_driver_register(&dm9000_driver);
18. }

2. probe函数。

主要完成的任务是：探测设备获得并保存资源信息，根据这些信息申请内存和中断，最后调用register_netdev注册这个网络设备。以下是代码清单，可以分成几个部分来看：

1) 首先定义了几个局部变量：

struct dm9000_plat_data *pdata = pdev->dev.platform_data;
struct board_info *db;/* Point a board information structure */
struct net_device *ndev;

2) 初始化一个网络设备。关键系统函数：alloc_etherdev()

3) 获得资源信息并将其保存在board_info变量db中。关键系统函数：netdev_priv(), platform_get_resource()

4) 根据资源信息分配内存，申请中断等等, 并将申请后的资源信息也保存到db中，并且填充ndev中的参数。 关键系统函数：request_mem_region(), ioremap()。 自定义函数:dm9000_set_io()

5) 完成了第4步以后，回顾一下db和ndev中都有了什么：

struct board_info *db:

addr_res -- 地址资源

data_res -- 数据资源

irq_res -- 中断资源

addr_req-- 分配的地址内存资源

io_addr -- 寄存器I/O基地址

data_req -- 分配的数据内存资源

io_data -- 数据I/O基地址

dumpblk -- IO模式

outblk -- IO模式

inblk -- IO模式

lock -- 自旋锁（已经被初始化）

addr_lock -- 互斥锁（已经被初始化）

struct net_device *ndev：

base_addr -- 设备IO地址

irq -- 设备IRQ号

6) 设备复位。硬件操作函数dm9000_reset()

7) 读一下生产商和制造商的ID，应该是0x9000 0A46。 关键函数：ior()

8) 读一下芯片类型。

========以上步骤结束后我们可以认为已经找到了DM9000========

9) 借助ether_setup()函数来部分初始化ndev。因为对以太网设备来讲，很多操作与属性是固定的，内核可以帮助完成。

10) 手动初始化ndev的ops和db的mii部分。

11) （如果有的话）从EEPROM中读取节点地址。这里可以看到mini2440这个板子上没有为DM9000外挂EEPROM，所以读取出来的全部是0xff。见函数dm9000_read_eeprom。 关于外挂EEPROM，可以参考datasheet上的7.EEPROM Format一节。

12) 很显然ndev是我们在probe函数中定义的局部变量，如果我想在其他地方使用它怎么办呢？ 这就需要把它保存起来。内核提供了这个方法，使用函数platform_set_drvdata()可以将ndev保存成平台总线设备的私有数据。以后再要使用它时只需调用platform_get_drvdata()就可以了。

13) 使用register_netdev()注册ndev。

下面是代码清单：

view plain

1. staticint__devinit
2. dm9000_probe(structplatform_device*pdev)
3. {
4. structdm9000_plat_data*pdata=pdev->dev.platform_data;
5. structboard_info*db;/*Pointaboardinformationstructure*/
6. structnet_device*ndev;
7. constunsignedchar*mac_src;
8. intret=0;
9. intiosize;
10. inti;
11. u32id_val;
13. /*Initnetworkdevice*/
14. /*使用alloc_etherdev()来生成一个net_device结构体，并对其公有成员赋值*/
15. ndev=alloc_etherdev(sizeof(structboard_info));
16. if(!ndev){
17. dev_err(&pdev->dev,"couldnotallocatedevice./n");
18. return-ENOMEM;
19. }
21. SET_NETDEV_DEV(ndev,&pdev->dev);
23. dev_dbg(&pdev->dev,"dm9000_probe()/n");
25. /*setupboardinfostructure*/
26. db=netdev_priv(ndev);
27. memset(db,0,sizeof(*db));
29. db->dev=&pdev->dev;
30. db->ndev=ndev;
32. spin_lock_init(&db->lock);
33. mutex_init(&db->addr_lock);
35. INIT_DELAYED_WORK(&db->phy_poll,dm9000_poll_work);
37. db->addr_res=platform_get_resource(pdev,IORESOURCE_MEM,0);
38. db->data_res=platform_get_resource(pdev,IORESOURCE_MEM,1);
39. db->irq_res=platform_get_resource(pdev,IORESOURCE_IRQ,0);
41. if(db->addr_res==NULL||db->data_res==NULL||
42. db->irq_res==NULL){
43. dev_err(db->dev,"insufficientresources/n");
44. ret=-ENOENT;
45. gotoout;
46. }
48. iosize=res_size(db->addr_res);
49. db->addr_req=request_mem_region(db->addr_res->start,iosize,
50. pdev->name);
52. if(db->addr_req==NULL){
53. dev_err(db->dev,"cannotclaimaddressregarea/n");
54. ret=-EIO;
55. gotoout;
56. }
58. db->io_addr=ioremap(db->addr_res->start,iosize);
60. if(db->io_addr==NULL){
61. dev_err(db->dev,"failedtoioremapaddressreg/n");
62. ret=-EINVAL;
63. gotoout;
64. }
66. iosize=res_size(db->data_res);
67. db->data_req=request_mem_region(db->data_res->start,iosize,
68. pdev->name);
70. if(db->data_req==NULL){
71. dev_err(db->dev,"cannotclaimdataregarea/n");
72. ret=-EIO;
73. gotoout;
74. }
76. db->io_data=ioremap(db->data_res->start,iosize);
78. if(db->io_data==NULL){
79. dev_err(db->dev,"failedtoioremapdatareg/n");
80. ret=-EINVAL;
81. gotoout;
82. }
84. /*fillinparametersfornet-devstructure*/
85. ndev->base_addr=(unsignedlong)db->io_addr;
86. ndev->irq=db->irq_res->start;
88. /*ensureatleastwehaveadefaultsetofIOroutines*/
89. dm9000_set_io(db,iosize);
91. /*checktoseeifanythingisbeingover-ridden*/
92. if(pdata!=NULL){
93. /*checktoseeifthedriverwantstoover-ridethe
94. *defaultIOwidth*/
96. if(pdata->flags&DM9000_PLATF_8BITONLY)
97. dm9000_set_io(db,1);
99. if(pdata->flags&DM9000_PLATF_16BITONLY)
100. dm9000_set_io(db,2);
102. if(pdata->flags&DM9000_PLATF_32BITONLY)
103. dm9000_set_io(db,4);
105. /*checktoseeifthereareanyIOroutine
106. *over-rides*/
108. if(pdata->inblk!=NULL)
109. db->inblk=pdata->inblk;
111. if(pdata->outblk!=NULL)
112. db->outblk=pdata->outblk;
114. if(pdata->dumpblk!=NULL)
115. db->dumpblk=pdata->dumpblk;
117. db->flags=pdata->flags;
118. }
120. #ifdefCONFIG_DM9000_FORCE_SIMPLE_PHY_POLL
121. db->flags|=DM9000_PLATF_SIMPLE_PHY;
122. #endif
124. dm9000_reset(db);
126. /*trymultipletimes,DM9000sometimesgetsthereadwrong*/
127. for(i=0;i<8;i++){
128. id_val=ior(db,DM9000_VIDL);
129. id_val|=(u32)ior(db,DM9000_VIDH)<<8;
130. id_val|=(u32)ior(db,DM9000_PIDL)<<16;
131. id_val|=(u32)ior(db,DM9000_PIDH)<<24;
133. if(id_val==DM9000_ID)
134. break;
135. dev_err(db->dev,"readwrongid0x%08x/n",id_val);
136. }
138. if(id_val!=DM9000_ID){
139. dev_err(db->dev,"wrongid:0x%08x/n",id_val);
140. ret=-ENODEV;
141. gotoout;
142. }
144. /*IdentifywhattypeofDM9000weareworkingon*/
146. id_val=ior(db,DM9000_CHIPR);
147. dev_dbg(db->dev,"dm9000revision0x%02x/n",id_val);
149. switch(id_val){
150. caseCHIPR_DM9000A:
151. db->type=TYPE_DM9000A;
152. break;
153. caseCHIPR_DM9000B:
154. db->type=TYPE_DM9000B;
155. break;
156. default:
157. dev_dbg(db->dev,"ID%02x=>defaultingtoDM9000E/n",id_val);
158. db->type=TYPE_DM9000E;
159. }
161. /*fromthispointweassumethatwehavefoundaDM9000*/
163. /*driversystemfunction*/
164. ether_setup(ndev);
166. ndev->netdev_ops=&dm9000_netdev_ops;
167. ndev->watchdog_timeo=msecs_to_jiffies(watchdog);
168. ndev->ethtool_ops=&dm9000_ethtool_ops;
170. db->msg_enable=NETIF_MSG_LINK;
171. db->mii.phy_id_mask=0x1f;
172. db->mii.reg_num_mask=0x1f;
173. db->mii.force_media=0;
174. db->mii.full_duplex=0;
175. db->mii.dev=ndev;
176. db->mii.mdio_read=dm9000_phy_read;
177. db->mii.mdio_write=dm9000_phy_write;
179. mac_src="eeprom";
181. /*tryreadingthenodeaddressfromtheattachedEEPROM*/
182. for(i=0;i<6;i+=2)
183. dm9000_read_eeprom(db,i/2,ndev->dev_addr+i);
185. if(!is_valid_ether_addr(ndev->dev_addr)&&pdata!=NULL){
186. mac_src="platformdata";
187. memcpy(ndev->dev_addr,pdata->dev_addr,6);
188. }
190. if(!is_valid_ether_addr(ndev->dev_addr)){
191. /*tryreadingfrommac*/
193. mac_src="chip";
194. for(i=0;i<6;i++)
195. ndev->dev_addr[i]=ior(db,i+DM9000_PAR);
196. }
198. if(!is_valid_ether_addr(ndev->dev_addr))
199. dev_warn(db->dev,"%s:InvalidethernetMACaddress.Please"
200. "setusingifconfig/n",ndev->name);
202. platform_set_drvdata(pdev,ndev);
203. ret=register_netdev(ndev);
205. if(ret==0)
206. printk(KERN_INFO"%s:dm9000%cat%p,%pIRQ%dMAC:%pM(%s)/n",
207. ndev->name,dm9000_type_to_char(db->type),
208. db->io_addr,db->io_data,ndev->irq,
209. ndev->dev_addr,mac_src);
210. return0;
212. out:
213. dev_err(db->dev,"notfound(%d)./n",ret);
215. dm9000_release_board(pdev,db);
216. free_netdev(ndev);
218. returnret;
219. }

3. platform_driver的remove， suspend和resume的实现

remove函数的功能是把设备从内核中移除，释放内存区域。该函数在卸载模块时被调用。代码清单如下：

view plain

1. staticint__devexit
2. dm9000_drv_remove(structplatform_device*pdev)
3. {
4. structnet_device*ndev=platform_get_drvdata(pdev);
6. platform_set_drvdata(pdev,NULL);
8. unregister_netdev(ndev);
9. dm9000_release_board(pdev,(board_info_t*)netdev_priv(ndev));
10. free_netdev(ndev);/*freedevicestructure*/
12. dev_dbg(&pdev->dev,"releasedandfreeddevice/n");
13. return0;
14. }

suspend函数并不真正把设备从内核中移除，而只是标志设备为removed状态，并设置挂起标志位，最后关闭设备。代码清单如下：

view plain

1. staticint
2. dm9000_drv_suspend(structplatform_device*dev,pm_message_tstate)
3. {
4. structnet_device*ndev=platform_get_drvdata(dev);
5. board_info_t*db;
7. if(ndev){
8. db=netdev_priv(ndev);
9. db->in_suspend=1;
11. if(netif_running(ndev)){
12. netif_device_detach(ndev);
13. dm9000_shutdown(ndev);
14. }
15. }
16. return0;
17. }

resume函数将挂起的设备复位并初始化，软后将设备标志为attached状态，并设置挂起标志位。代码清单如下：

view plain

1. staticint
2. dm9000_drv_resume(structplatform_device*dev)
3. {
4. structnet_device*ndev=platform_get_drvdata(dev);
5. board_info_t*db=netdev_priv(ndev);
7. if(ndev){
9. if(netif_running(ndev)){
10. dm9000_reset(db);
11. dm9000_init_dm9000(ndev);
13. netif_device_attach(ndev);
14. }
16. db->in_suspend=0;
17. }
18. return0;
19. }

4. 下面看一下用于填充net_device中netdev_ops和ethtool_ops的一些函数。

代码在上面已经写出来了，为了看着方便在下面再写一遍，可以看出虽然mini2440的板子上没有为DM9000挂EEPROM，但这里还是定义了操作EEPROM的函数。就是说写驱动的时候是不考虑具体的板子的，你板子用不用是你的事，但是我们的驱动应该所有的功能都考虑进去。这也体现了驱动和平台分离的设计思想。

view plain

1. staticconststructnet_device_opsdm9000_netdev_ops={
2. .ndo_open=dm9000_open,
3. .ndo_stop=dm9000_stop,
4. .ndo_start_xmit=dm9000_start_xmit,
5. .ndo_tx_timeout=dm9000_timeout,
6. .ndo_set_multicast_list=dm9000_hash_table,
7. .ndo_do_ioctl=dm9000_ioctl,
8. .ndo_change_mtu=eth_change_mtu,
9. .ndo_validate_addr=eth_validate_addr,
10. .ndo_set_mac_address=eth_mac_addr,
11. #ifdefCONFIG_NET_POLL_CONTROLLER
12. .ndo_poll_controller=dm9000_poll_controller,
13. #endif
14. };

view plain

1. staticconststructethtool_opsdm9000_ethtool_ops={
2. .get_drvinfo=dm9000_get_drvinfo,
3. .get_settings=dm9000_get_settings,
4. .set_settings=dm9000_set_settings,
5. .get_msglevel=dm9000_get_msglevel,
6. .set_msglevel=dm9000_set_msglevel,
7. .nway_reset=dm9000_nway_reset,
8. .get_link=dm9000_get_link,
9. .get_eeprom_len=dm9000_get_eeprom_len,
10. .get_eeprom=dm9000_get_eeprom,
11. .set_eeprom=dm9000_set_eeprom,
12. };

*dm9000_open()

进行的工作有 向内核注册中断，复位并初始化dm9000，检查MII接口，使能传输等。代码清单如下：

view plain

1. /*
2. *Opentheinterface.
3. *Theinterfaceisopenedwhenever"ifconfig"activesit.
4. */
5. staticint
6. dm9000_open(structnet_device*dev)
7. {
8. board_info_t*db=netdev_priv(dev);
9. unsignedlongirqflags=db->irq_res->flags&IRQF_TRIGGER_MASK;
11. if(netif_msg_ifup(db))
12. dev_dbg(db->dev,"enabling%s/n",dev->name);
14. /*IfthereisnoIRQtypespecified,defaulttosomethingthat
15. *maywork,andtelltheuserthatthisisaproblem*/
17. if(irqflags==IRQF_TRIGGER_NONE)
18. dev_warn(db->dev,"WARNING:noIRQresourceflagsset./n");
20. irqflags|=IRQF_SHARED;
22. if(request_irq(dev->irq,&dm9000_interrupt,irqflags,dev->name,dev))/*注册一个中断，中断处理函数为dm9000_interrupt()*/
23. return-EAGAIN;
25. /*InitializeDM9000board*/
26. dm9000_reset(db);
27. dm9000_init_dm9000(dev);
29. /*Initdrivervariable*/
30. db->dbug_cnt=0;
32. mii_check_media(&db->mii,netif_msg_link(db),1);
33. netif_start_queue(dev);
35. dm9000_schedule_poll(db);/*之前在probe函数中已经使用INIT_DELAYED_WORK来初始化一个延迟工作队列并关联了一个操作函数dm9000_poll_work()，此时运行schedule来调用这个函数*/
37. return0;
38. }

*dm9000_stop()

做的工作基本上和open相反。代码清单如下：

view plain

1. /*
2. *Stoptheinterface.
3. *Theinterfaceisstoppedwhenitisbrought.
4. */
5. staticint
6. dm9000_stop(structnet_device*ndev)
7. {
8. board_info_t*db=netdev_priv(ndev);
10. if(netif_msg_ifdown(db))
11. dev_dbg(db->dev,"shuttingdown%s/n",ndev->name);
13. cancel_delayed_work_sync(&db->phy_poll);/*杀死延迟工作队列phy_poll*/
15. /*停止传输并清空carrier*/
16. netif_stop_queue(ndev);
17. netif_carrier_off(ndev);
19. /*freeinterrupt*/
20. free_irq(ndev->irq,ndev);
22. dm9000_shutdown(ndev);
24. return0;
25. }

*dm9000_start_xmit()

重要的发送数据包函数。从上层发送sk_buff包。在看代码之前先来看一下DM9000是如何发送数据包的。

如上图所示，在DM9000内部SRAM中，地址0x0000~0x0BFF是TX Buffer， 地址0x0C00~0x3FFF是RX Buffer。在发送一个包之前，包中的有效数据必须先被存储到TX Buffer中并且使用输出端口命令来选择MWCMD寄存器。包的长度定义在TXPLL和TXPLH中。最后设置TXCR寄存器的bit[0] TXREQ来自动发送包。如果设置了IMR寄存器的PTM位，则DM9000会产生一个中断触发在ISR寄存器的bit[1]=PTS=1, 同时设置一个完成标志在NSR寄存器的bit[2]=TX1END或者 bit[3]=TX2END，表示包已经发送完了。发送一个包的具体步骤如下：

Step 1： 检查存储数据宽度。通过读取中断状态寄存器（ISR）的bit[7:6]来确定是8bit，16bit还是32bit。

Step 2： 写数据到TX SRAM中。

Step 3： 写传输长度到TXPLL和TXPLH寄存器中。

Step 4： 设置TXCR寄存器的bit[0]TXREQ来开始发送一个包。

代码清单如下，让我们看看在获得自旋锁这段期间都干了些什么：

view plain

1. /*
2. *Hardwarestarttransmission.
3. *Sendapackettomediafromtheupperlayer.
4. */
5. staticint
6. dm9000_start_xmit(structsk_buff*skb,structnet_device*dev)
7. {
8. unsignedlongflags;
9. board_info_t*db=netdev_priv(dev);
11. dm9000_dbg(db,3,"%s:/n",__func__);
13. if(db->tx_pkt_cnt>1)
14. returnNETDEV_TX_BUSY;
16. /*获得自旋锁*/
17. spin_lock_irqsave(&db->lock,flags);
19. /*MovedatatoDM9000TXRAM*/
20. /*下面四行代码将skb中的data部分写入DM9000的TXRAM，并更新已发送字节数和发送计数*/
21. writeb(DM9000_MWCMD,db->io_addr);
23. (db->outblk)(db->io_data,skb->data,skb->len);
24. dev->stats.tx_bytes+=skb->len;
26. db->tx_pkt_cnt++;
27. /*TXcontrol:Firstpacketimmediatelysend,secondpacketqueue*/
28. /*如果发送的是第一个包，则设置一下包的长度后直接发送*/
29. /*如果发的不是第一个包，*/
30. if(db->tx_pkt_cnt==1){
31. /*SetTXlengthtoDM9000*/
32. iow(db,DM9000_TXPLL,skb->len);
33. iow(db,DM9000_TXPLH,skb->len>>8);
35. /*IssueTXpollingcommand*/
36. iow(db,DM9000_TCR,TCR_TXREQ);/*ClearedafterTXcomplete*/
38. dev->trans_start=jiffies;/*savethetimestamp*/
39. }else{
40. /*Secondpacket*/
41. /*如果发送的是第二个数据包（表明队列中此时有包发送），则将其加入队列中：将skb->len和skb->ip_summed（控制校验操作）赋值给board_info_t中有关队列的相关成员。调用函数netif_stop_queue(dev)，通知内核现在queue已满，不能再将发送数据传到队列中，注：第二个包的发送将在tx_done中实现。*/
42. db->queue_pkt_len=skb->len;
43. netif_stop_queue(dev);
44. }
46. /*释放自旋锁*/
47. spin_unlock_irqrestore(&db->lock,flags);
49. /*freethisSKB*/
50. dev_kfree_skb(skb);
52. return0;
53. }

*dm9000_timeout()

当watchdog超时时调用该函数。主要的功能是保存寄存器地址，停止队列，重启并初始化DM9000，唤醒队列，恢复寄存器地址。

代码清单如下：

view plain

1. /*Ourwatchdogtimedout.Calledbythenetworkinglayer*/
2. staticvoiddm9000_timeout(structnet_device*dev)
3. {
4. board_info_t*db=netdev_priv(dev);
5. u8reg_save;
6. unsignedlongflags;
8. /*Savepreviousregisteraddress*/
9. reg_save=readb(db->io_addr);
10. spin_lock_irqsave(&db->lock,flags);
12. netif_stop_queue(dev);
13. dm9000_reset(db);
14. dm9000_init_dm9000(dev);
15. /*WecanacceptTXpacketsagain*/
16. dev->trans_start=jiffies;
17. netif_wake_queue(dev);
19. /*Restorepreviousregisteraddress*/
20. writeb(reg_save,db->io_addr);
21. spin_unlock_irqrestore(&db->lock,flags);
22. }

*dm9000_hash_table()

该函数用来设置DM9000的组播地址。代码清单如下：

view plain

1. /*
2. *SetDM9000multicastaddress
3. */
4. staticvoid
5. dm9000_hash_table(structnet_device*dev)
6. {
7. board_info_t*db=netdev_priv(dev);
8. structdev_mc_list*mcptr=dev->mc_list;
9. intmc_cnt=dev->mc_count;
10. inti,oft;
11. u32hash_val;
12. u16hash_table[4];
13. u8rcr=RCR_DIS_LONG|RCR_DIS_CRC|RCR_RXEN;
14. unsignedlongflags;
16. dm9000_dbg(db,1,"entering%s/n",__func__);
18. spin_lock_irqsave(&db->lock,flags);
20. for(i=0,oft=DM9000_PAR;i<6;i++,oft++)
21. iow(db,oft,dev->dev_addr[i]);
23. /*ClearHashTable*/
24. for(i=0;i<4;i++)
25. hash_table[i]=0x0;
27. /*broadcastaddress*/
28. hash_table[3]=0x8000;
30. if(dev->flags&IFF_PROMISC)
31. rcr|=RCR_PRMSC;
33. if(dev->flags&IFF_ALLMULTI)
34. rcr|=RCR_ALL;
36. /*themulticastaddressinHashTable:64bits*/
37. for(i=0;i<mc_cnt;i++,mcptr=mcptr->next){
38. hash_val=ether_crc_le(6,mcptr->dmi_addr)&0x3f;
39. hash_table[hash_val/16]|=(u16)1<<(hash_val%16);
40. }
42. /*WritethehashtabletoMACMDtable*/
43. for(i=0,oft=DM9000_MAR;i<4;i++){
44. iow(db,oft++,hash_table[i]);
45. iow(db,oft++,hash_table[i]>>8);
46. }
48. iow(db,DM9000_RCR,rcr);
49. spin_unlock_irqrestore(&db->lock,flags);
50. }

*dm9000_ioctl()

从源码可以看出，dm9000的ioctl实际上是使用了mii的ioctl。代码清单如下：

view plain

1. staticintdm9000_ioctl(structnet_device*dev,structifreq*req,intcmd)
2. {
3. board_info_t*dm=to_dm9000_board(dev);
5. if(!netif_running(dev))
6. return-EINVAL;
8. returngeneric_mii_ioctl(&dm->mii,if_mii(req),cmd,NULL);
9. }

*dm9000_poll_controller()

当内核配置Netconsole时该函数生效。代码清单如下：

view plain

1. #ifdefCONFIG_NET_POLL_CONTROLLER
2. /*
3. *Usedbynetconsole
4. */
5. staticvoiddm9000_poll_controller(structnet_device*dev)
6. {
7. disable_irq(dev->irq);
8. dm9000_interrupt(dev->irq,dev);
9. enable_irq(dev->irq);
10. }
11. #endif

*dm9000_get_drvinfo()

该函数去的设备的基本信息(设备名，版本，总线名)传给ethtool_drvinfo结构体变量。代码清单如下：

view plain

1. staticvoiddm9000_get_drvinfo(structnet_device*dev,
2. structethtool_drvinfo*info)
3. {
4. board_info_t*dm=to_dm9000_board(dev);/*to_dm9000_board实际上就是调用了netdev_priv(dev)*/
6. strcpy(info->driver,CARDNAME);
7. strcpy(info->version,DRV_VERSION);
8. strcpy(info->bus_info,to_platform_device(dm->dev)->name);
9. }

*dm9000_get_settings()

该函数得到由参数cmd指定的设置信息。

*dm9000_set_settings()

该函数设置由参数cmd指定的信息。

*dm9000_get_msglevel()

*dm9000_set_msglevel()

这两个函数设置和取得message level，实际是设置和取得board_info中的msg_enable信息。

*dm9000_nway_reset()

重启mii的自动协商

*dm9000_get_link()

该函数的到link状态。如果带外部PHY，则返回mii链接状态。 否则返回DM9000 NSR寄存器数值。

*dm9000_get_eeprom_len()
dm9000_get_eeprom()
dm9000_set_eeprom()

这三个函数用来读写eeprom。

5. 与数据传输有关的函数。

上面已经分析了一个与数据传输有关的函数，那就是发送数据的函数dm9000_start_xmit()。这里再来分析数据的接收。再看具体代码之前还是来看看DM9000的数据接收的过程。

接收的数据存储在RX SRAM中，地址是0C00h~3FFFh。存储在RX_SRAM中的每个包都有4个字节的信息头。可以使用MRCMDX和MRCMD寄存器来得到这些信息。第一个字节用来检查数据包是否接收到了RX_SRAM中，如果这个字节是"01"，意味着一个包已经接收。如果是"00"，则还没有数据包被接收到RX_SRAM中。第二个字节保存接收到的数据包的信息，格式和RSR寄存器一样。根据这个格式，接收到的包能被校验是正确的还是错误的包。第三和第四字节保存了接收的数据包的长度。这四个字节以外的其他字节就是接收包的数据。看下图可以更好的理解这种格式。

根据包的结构可以知道接收一个包应该按照下面的步骤来进行：

第一步：判断包是否已经接收过来了。需要用到MRCMDX寄存器。MRCMDX寄存器是存储数据读命令寄存器（地址不增加）。 这个寄存器只是用来读接收包标志位"01"。下面这段代码是一个例子，用来判断RX ready：

view plain

1. u8RX_ready=ior(IOaddr,0xF0);/*dummyreadthepacketreadyflag*/
2. RX_ready=(u8)inp(IOaddr+4);/*gotthemostupdateddata*/
3. if(RX_ready==1){/*readycheck:thisbytemustbe0or1*/
4. /*checktheRXstatusandtogetRXlength(seedatasheetch.5.6.3)*/
5. /*incomeRXapacket(seedatasheetch.5.6.4)*/
6. }elseif(RX_ready!=0){/*stopdeviceandwaittoresetdevice*/
7. iow(IOaddr,0xFF,0x80);/*stopINTrequest*/
8. iow(IOaddr,0xFE,0x0F);/*clearISRstatus*/
9. iow(IOaddr,0x05,0x00);/*stopRXfunction*/
10. u8device_wait_reset=TRUE;/*raisetheresetflag*/
11. }

第二步：检查包的状态和长度。需要用到MRCMD寄存器（存储数据读命令，读指针自动增加）。下面这段例子代码用来读RX状态和长度。

view plain

1. u8io_mode=ior(IOaddr,0xFE)>>6;/*ISRbit[7:6]keepI/Omode*/
2. outp(IOaddr,0xF2);/*triggerMRCMDreg_F2hwithread_ptr++*/
3. /*intRX_status:theRXpacketstatus,intRX_length:theRXpacketlength*/
4. if(io_mode==2){/*I/Obytemode*/
5. RX_status=inp(IOaddr+4)+(inp(IOaddr+4)<<8);
6. RX_length=inp(IOaddr+4)+(inp(IOaddr+4)<<8);}
7. elseif(io_mode==0){/*I/Owordmode*/
8. RX_status=inpw(IOaddr+4);
9. RX_length=inpw(IOaddr+4);}
10. elseif(io_mode==1){/*I/Odwordmode*/
11. (u32)status_tmp=inpl(IOaddr+4);/*gottheRX32-bitdworddata*/
12. RX_status=(u16)(status_tmp&0xFFFF);
13. RX_length=(u16)((status_tmp>>16)&0xFFFF);}

第三步：读包的数据。也需要MRCMD寄存器。例子代码如下：

view plain

1. /*u8RX_data[]:thedataofthereceivedpacket*/
2. if(io_mode==2){/*I/Obytemode*/
3. for(i=0;i<RX_length;i++)/*looptoreadabytedatafromRXSRAM*/
4. RX_data[i]=(u8)inp(IOaddr+4);}
5. elseif(io_mode==0){/*I/Owordmode*/
6. intlength_tmp=(RX_length+1)/2;
7. for(i=0;i<length_tmp;i++)/*looptoreadaworddatafromRXSRAM*/
8. ((u16*)RX_data)[i]=inpw(IOaddr+4);}
9. elseif(io_mode==1){/*I/Odwordmode*/
10. intlength_tmp=(RX_length+3)/4;
11. for(i=0;i<length_tmp;i++)/*looptoreadadworddatafromRXSRAM*/
12. ((u32*)RX_data)[i]=inpl(IOaddr+4);}/*inpl()isinport32-bitI/O*/

下面的dm9000_rx()函数实际上是按照上面这三个步骤来实现的，具体实现并不一定是要参照例子代码。注意这里按照DM9000接收包的格式定义了一个结构体dm9000_rxhdr用来表示头部的四个字节。代码清单如下：

view plain

1. structdm9000_rxhdr{
2. u8RxPktReady;
3. u8RxStatus;
4. __le16RxLen;
5. }__attribute__((__packed__));

接收函数代码如下：

view plain

1. /*
2. *Receivedapacketandpasstoupperlayer
3. */
4. staticvoid
5. dm9000_rx(structnet_device*dev)
6. {
7. board_info_t*db=netdev_priv(dev);
8. structdm9000_rxhdrrxhdr;
9. structsk_buff*skb;
10. u8rxbyte,*rdptr;
11. boolGoodPacket;
12. intRxLen;
14. /*Checkpacketreadyornot*/
15. do{
16. ior(db,DM9000_MRCMDX);/*Dummyread*/
18. /*Getmostupdateddata*/
19. /*读一下最新数据的第一个字节*/
20. rxbyte=readb(db->io_data);
22. /*Statuscheck:thisbytemustbe0or1*/
23. /*DM9000_PKT_RDY定义是0x01，如果第一个字节大于0x01，则不是正确的状态。因为第一个字节只能是01h或00h*/
24. if(rxbyte>DM9000_PKT_RDY){
25. dev_warn(db->dev,"statuscheckfail:%d/n",rxbyte);
26. iow(db,DM9000_RCR,0x00);/*StopDevice*/
27. iow(db,DM9000_ISR,IMR_PAR);/*StopINTrequest*/
28. return;
29. }
31. if(rxbyte!=DM9000_PKT_RDY)
32. return;
34. /*Apacketreadynow&Getstatus/length*/
35. GoodPacket=true;
36. writeb(DM9000_MRCMD,db->io_addr);
38. (db->inblk)(db->io_data,&rxhdr,sizeof(rxhdr));/*一次性读入四个字节的内容到rxhdr变量*/
40. RxLen=le16_to_cpu(rxhdr.RxLen);
42. if(netif_msg_rx_status(db))
43. dev_dbg(db->dev,"RX:status%02x,length%04x/n",
44. rxhdr.RxStatus,RxLen);
46. /*PacketStatuscheck*/
47. if(RxLen<0x40){
48. GoodPacket=false;
49. if(netif_msg_rx_err(db))
50. dev_dbg(db->dev,"RX:BadPacket(runt)/n");
51. }
53. if(RxLen>DM9000_PKT_MAX){
54. dev_dbg(db->dev,"RST:RXLen:%x/n",RxLen);
55. }
57. /*rxhdr.RxStatusisidenticaltoRSRregister.*/
58. if(rxhdr.RxStatus&(RSR_FOE|RSR_CE|RSR_AE|
59. RSR_PLE|RSR_RWTO|
60. RSR_LCS|RSR_RF)){
61. GoodPacket=false;
62. if(rxhdr.RxStatus&RSR_FOE){
63. if(netif_msg_rx_err(db))
64. dev_dbg(db->dev,"fifoerror/n");
65. dev->stats.rx_fifo_errors++;
66. }
67. if(rxhdr.RxStatus&RSR_CE){
68. if(netif_msg_rx_err(db))
69. dev_dbg(db->dev,"crcerror/n");
70. dev->stats.rx_crc_errors++;
71. }
72. if(rxhdr.RxStatus&RSR_RF){
73. if(netif_msg_rx_err(db))
74. dev_dbg(db->dev,"lengtherror/n");
75. dev->stats.rx_length_errors++;
76. }
77. }
79. /*MovedatafromDM9000*/
80. /*关键的代码就是这里啦。使用到了上面提到的sk_buff。将RXSRAM中的data段数据放入sk_buff，然后发送给上层，至于怎么发送，不用去驱动操心了。sk_buff的protocol全部搞定*/
81. if(GoodPacket
82. &&((skb=dev_alloc_skb(RxLen+4))!=NULL)){
83. skb_reserve(skb,2);
84. rdptr=(u8*)skb_put(skb,RxLen-4);
86. /*ReadreceivedpacketfromRXSRAM*/
88. (db->inblk)(db->io_data,rdptr,RxLen);
89. dev->stats.rx_bytes+=RxLen;
91. /*Passtoupperlayer*/
92. skb->protocol=eth_type_trans(skb,dev);
93. netif_rx(skb);
94. dev->stats.rx_packets++;
96. }else{
97. /*needtodumpthepacket'sdata*/
99. (db->dumpblk)(db->io_data,RxLen);
100. }
101. }while(rxbyte==DM9000_PKT_RDY);
102. }

6. 中断处理相关函数

DM9000的驱动程序采用了中断方式而非轮询方式。触发中断的时机发生在：1）DM9000接收到一个包以后。2）DM9000发送完了一个包以后。

中断处理函数在open的时候被注册进内核。代码清单如下：

view plain

1. staticirqreturn_tdm9000_interrupt(intirq,void*dev_id)
2. {
3. structnet_device*dev=dev_id;
4. board_info_t*db=netdev_priv(dev);
5. intint_status;
6. unsignedlongflags;
7. u8reg_save;
9. dm9000_dbg(db,3,"entering%s/n",__func__);
11. /*Arealinterruptcoming*/
13. /*holdersofdb->lockmustalwaysblockIRQs*/
14. spin_lock_irqsave(&db->lock,flags);
16. /*Savepreviousregisteraddress*/
17. reg_save=readb(db->io_addr);
19. /*Disableallinterrupts*/
20. iow(db,DM9000_IMR,IMR_PAR);
22. /*GotDM9000interruptstatus*/
23. int_status=ior(db,DM9000_ISR);/*GotISR*/
24. iow(db,DM9000_ISR,int_status);/*ClearISRstatus*/
26. if(netif_msg_intr(db))
27. dev_dbg(db->dev,"interruptstatus%02x/n",int_status);
29. /*Receivedthecomingpacket*/
30. /*如果是由于收到数据而触发的中断，显然调用dm9000_rx()把数据取走，传递给上层*/
31. if(int_status&ISR_PRS)
32. dm9000_rx(dev);
34. /*TrnasmitInterruptcheck*/
35. /*如果是由于发送完了数据而触发的中断，则调用dm9000_tx_done()函数，下面具体分析这个函数*/
36. if(int_status&ISR_PTS)
37. dm9000_tx_done(dev,db);
39. if(db->type!=TYPE_DM9000E){
40. if(int_status&ISR_LNKCHNG){
41. /*firealink-changerequest*/
42. schedule_delayed_work(&db->phy_poll,1);
43. }
44. }
46. /*Re-enableinterruptmask*/
47. iow(db,DM9000_IMR,db->imr_all);
49. /*Restorepreviousregisteraddress*/
50. writeb(reg_save,db->io_addr);
52. spin_unlock_irqrestore(&db->lock,flags);
54. returnIRQ_HANDLED;
55. }

*dm9000_tx_done()

注：dm9000可以发送两个数据包，当发送一个数据包产生中断后，要确认一下队列中有没有第2个包需要发送。

（1）读取dm9000寄存器NSR（Network Status Register）获取发送的状态，存在变量tx_status中；

（2）如果发送状态为NSR_TX2END（第2个包发送完毕）或者NSR_TX1END（第1个包发送完毕），则将待发送的数据包数量（db-> tx_pkt_cnt ）减1，已发送的数据包数量（dev->stats.tx_packets）加1；

（3）检查变量db-> tx_pkt_cnt（待发送的数据包）是否大于0（表明还有数据包要发送），则调用函数dm9000_send_packet发送队列中的数据包；

（4）调用函数netif_wake_queue (dev)通知内核可以将待发送的数据包进入发送队列。

view plain

1. /*
2. *DM9000interrupthandler
3. *receivethepackettoupperlayer,freethetransmittedpacket
4. */
6. staticvoiddm9000_tx_done(structnet_device*dev,board_info_t*db)
7. {
8. inttx_status=ior(db,DM9000_NSR);/*GotTXstatus*/
10. if(tx_status&(NSR_TX2END|NSR_TX1END)){
11. /*Onepacketsentcomplete*/
12. db->tx_pkt_cnt--;
13. dev->stats.tx_packets++;
15. if(netif_msg_tx_done(db))
16. dev_dbg(db->dev,"txdone,NSR%02x/n",tx_status);
18. /*Queuepacketcheck&send*/
19. if(db->tx_pkt_cnt>0){
20. iow(db,DM9000_TXPLL,db->queue_pkt_len);
21. iow(db,DM9000_TXPLH,db->queue_pkt_len>>8);
22. iow(db,DM9000_TCR,TCR_TXREQ);
23. dev->trans_start=jiffies;
24. }
25. netif_wake_queue(dev);
26. }
27. }

7. 一些操作硬件细节的函数。

在看函数之前还是先来看一下DM9000 CMD Pin 和Processor并行总线的连接关系。CMD管脚用来设置命令类型。当CMD管脚拉高时，这个命令周期访问DATA_PORT。 如果拉低， 则这个命令周期访问ADDR_PORT。见下图：

当然，内存映射的I/O空间读写还是采用最基本的readb(), readw(), readl(), writeb(), writew(), writel() , readsb(), readsw(), readsl(), writesb(), writesw(), writesl() 。

在DM9000的驱动中还自定义了几个函数，方便操作。

* ior()

从IO端口读一个字节。代码清单如下：

view plain

1. staticu8
2. ior(board_info_t*db,intreg)
3. {
4. writeb(reg,db->io_addr);/*写reg到ADDR_PORT,用来选择寄存器*/
5. returnreadb(db->io_data);/*从DATA_PORT读一个字节，用来读寄存器*/
6. }

* iow()

向IO端口写一个字节。代码清单如下：

view plain

1. /*
2. *WriteabytetoI/Oport
3. */
5. staticvoid
6. iow(board_info_t*db,intreg,intvalue)
7. {
8. writeb(reg,db->io_addr);
9. writeb(value,db->io_data);
10. }

此外还有dm9000_outblk_8bit(), dm9000_outblk_16bit(), dm9000_outblk_32bit(), dm9000_inblk_8bit(), dm9000_inblk_16bit(), dm9000_inblk_32bit()等等。不一一解释。

======================THE END======================