`
wodamazi
  • 浏览: 1410028 次
文章分类
社区版块
存档分类
最新评论

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文件中有如下体现:

  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和中断资源。代码清单如下:

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

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

  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
  1. staticvoid__initmini2440_init(void)
  2. {
  3. ...
  4. ...
  5. platform_add_devices(mini2440_devices,ARRAY_SIZE(mini2440_devices));
  6. ...
  7. ...
  8. }
  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)和几个重要操作函数。

  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的重要函数,我们在驱动程序中根据需要的操作要填充这些函数。代码清单如下:

  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)。代码清单如下:

  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结构体。用来保存芯片相关的一些私有信息。具体在代码中分析。下面是这个结构体的清单。

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

下面看一下具体代码。

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

1. 注册平台驱动。

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

  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. };
  11. staticint__init
  12. dm9000_init(void)
  13. {
  14. printk(KERN_INFO"%sEthernetDriver,V%s/n",CARDNAME,DRV_VERSION);
  15. returnplatform_driver_register(&dm9000_driver);
  16. }

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。

下面是代码清单:

  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;
  12. /*Initnetworkdevice*/
  13. /*使用alloc_etherdev()来生成一个net_device结构体,并对其公有成员赋值*/
  14. ndev=alloc_etherdev(sizeof(structboard_info));
  15. if(!ndev){
  16. dev_err(&pdev->dev,"couldnotallocatedevice./n");
  17. return-ENOMEM;
  18. }
  19. SET_NETDEV_DEV(ndev,&pdev->dev);
  20. dev_dbg(&pdev->dev,"dm9000_probe()/n");
  21. /*setupboardinfostructure*/
  22. db=netdev_priv(ndev);
  23. memset(db,0,sizeof(*db));
  24. db->dev=&pdev->dev;
  25. db->ndev=ndev;
  26. spin_lock_init(&db->lock);
  27. mutex_init(&db->addr_lock);
  28. INIT_DELAYED_WORK(&db->phy_poll,dm9000_poll_work);
  29. db->addr_res=platform_get_resource(pdev,IORESOURCE_MEM,0);
  30. db->data_res=platform_get_resource(pdev,IORESOURCE_MEM,1);
  31. db->irq_res=platform_get_resource(pdev,IORESOURCE_IRQ,0);
  32. if(db->addr_res==NULL||db->data_res==NULL||
  33. db->irq_res==NULL){
  34. dev_err(db->dev,"insufficientresources/n");
  35. ret=-ENOENT;
  36. gotoout;
  37. }
  38. iosize=res_size(db->addr_res);
  39. db->addr_req=request_mem_region(db->addr_res->start,iosize,
  40. pdev->name);
  41. if(db->addr_req==NULL){
  42. dev_err(db->dev,"cannotclaimaddressregarea/n");
  43. ret=-EIO;
  44. gotoout;
  45. }
  46. db->io_addr=ioremap(db->addr_res->start,iosize);
  47. if(db->io_addr==NULL){
  48. dev_err(db->dev,"failedtoioremapaddressreg/n");
  49. ret=-EINVAL;
  50. gotoout;
  51. }
  52. iosize=res_size(db->data_res);
  53. db->data_req=request_mem_region(db->data_res->start,iosize,
  54. pdev->name);
  55. if(db->data_req==NULL){
  56. dev_err(db->dev,"cannotclaimdataregarea/n");
  57. ret=-EIO;
  58. gotoout;
  59. }
  60. db->io_data=ioremap(db->data_res->start,iosize);
  61. if(db->io_data==NULL){
  62. dev_err(db->dev,"failedtoioremapdatareg/n");
  63. ret=-EINVAL;
  64. gotoout;
  65. }
  66. /*fillinparametersfornet-devstructure*/
  67. ndev->base_addr=(unsignedlong)db->io_addr;
  68. ndev->irq=db->irq_res->start;
  69. /*ensureatleastwehaveadefaultsetofIOroutines*/
  70. dm9000_set_io(db,iosize);
  71. /*checktoseeifanythingisbeingover-ridden*/
  72. if(pdata!=NULL){
  73. /*checktoseeifthedriverwantstoover-ridethe
  74. *defaultIOwidth*/
  75. if(pdata->flags&DM9000_PLATF_8BITONLY)
  76. dm9000_set_io(db,1);
  77. if(pdata->flags&DM9000_PLATF_16BITONLY)
  78. dm9000_set_io(db,2);
  79. if(pdata->flags&DM9000_PLATF_32BITONLY)
  80. dm9000_set_io(db,4);
  81. /*checktoseeifthereareanyIOroutine
  82. *over-rides*/
  83. if(pdata->inblk!=NULL)
  84. db->inblk=pdata->inblk;
  85. if(pdata->outblk!=NULL)
  86. db->outblk=pdata->outblk;
  87. if(pdata->dumpblk!=NULL)
  88. db->dumpblk=pdata->dumpblk;
  89. db->flags=pdata->flags;
  90. }
  91. #ifdefCONFIG_DM9000_FORCE_SIMPLE_PHY_POLL
  92. db->flags|=DM9000_PLATF_SIMPLE_PHY;
  93. #endif
  94. dm9000_reset(db);
  95. /*trymultipletimes,DM9000sometimesgetsthereadwrong*/
  96. for(i=0;i<8;i++){
  97. id_val=ior(db,DM9000_VIDL);
  98. id_val|=(u32)ior(db,DM9000_VIDH)<<8;
  99. id_val|=(u32)ior(db,DM9000_PIDL)<<16;
  100. id_val|=(u32)ior(db,DM9000_PIDH)<<24;
  101. if(id_val==DM9000_ID)
  102. break;
  103. dev_err(db->dev,"readwrongid0x%08x/n",id_val);
  104. }
  105. if(id_val!=DM9000_ID){
  106. dev_err(db->dev,"wrongid:0x%08x/n",id_val);
  107. ret=-ENODEV;
  108. gotoout;
  109. }
  110. /*IdentifywhattypeofDM9000weareworkingon*/
  111. id_val=ior(db,DM9000_CHIPR);
  112. dev_dbg(db->dev,"dm9000revision0x%02x/n",id_val);
  113. switch(id_val){
  114. caseCHIPR_DM9000A:
  115. db->type=TYPE_DM9000A;
  116. break;
  117. caseCHIPR_DM9000B:
  118. db->type=TYPE_DM9000B;
  119. break;
  120. default:
  121. dev_dbg(db->dev,"ID%02x=>defaultingtoDM9000E/n",id_val);
  122. db->type=TYPE_DM9000E;
  123. }
  124. /*fromthispointweassumethatwehavefoundaDM9000*/
  125. /*driversystemfunction*/
  126. ether_setup(ndev);
  127. ndev->netdev_ops=&dm9000_netdev_ops;
  128. ndev->watchdog_timeo=msecs_to_jiffies(watchdog);
  129. ndev->ethtool_ops=&dm9000_ethtool_ops;
  130. db->msg_enable=NETIF_MSG_LINK;
  131. db->mii.phy_id_mask=0x1f;
  132. db->mii.reg_num_mask=0x1f;
  133. db->mii.force_media=0;
  134. db->mii.full_duplex=0;
  135. db->mii.dev=ndev;
  136. db->mii.mdio_read=dm9000_phy_read;
  137. db->mii.mdio_write=dm9000_phy_write;
  138. mac_src="eeprom";
  139. /*tryreadingthenodeaddressfromtheattachedEEPROM*/
  140. for(i=0;i<6;i+=2)
  141. dm9000_read_eeprom(db,i/2,ndev->dev_addr+i);
  142. if(!is_valid_ether_addr(ndev->dev_addr)&&pdata!=NULL){
  143. mac_src="platformdata";
  144. memcpy(ndev->dev_addr,pdata->dev_addr,6);
  145. }
  146. if(!is_valid_ether_addr(ndev->dev_addr)){
  147. /*tryreadingfrommac*/
  148. mac_src="chip";
  149. for(i=0;i<6;i++)
  150. ndev->dev_addr[i]=ior(db,i+DM9000_PAR);
  151. }
  152. if(!is_valid_ether_addr(ndev->dev_addr))
  153. dev_warn(db->dev,"%s:InvalidethernetMACaddress.Please"
  154. "setusingifconfig/n",ndev->name);
  155. platform_set_drvdata(pdev,ndev);
  156. ret=register_netdev(ndev);
  157. if(ret==0)
  158. printk(KERN_INFO"%s:dm9000%cat%p,%pIRQ%dMAC:%pM(%s)/n",
  159. ndev->name,dm9000_type_to_char(db->type),
  160. db->io_addr,db->io_data,ndev->irq,
  161. ndev->dev_addr,mac_src);
  162. return0;
  163. out:
  164. dev_err(db->dev,"notfound(%d)./n",ret);
  165. dm9000_release_board(pdev,db);
  166. free_netdev(ndev);
  167. returnret;
  168. }

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

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

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

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

  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;
  6. if(ndev){
  7. db=netdev_priv(ndev);
  8. db->in_suspend=1;
  9. if(netif_running(ndev)){
  10. netif_device_detach(ndev);
  11. dm9000_shutdown(ndev);
  12. }
  13. }
  14. return0;
  15. }

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

  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);
  6. if(ndev){
  7. if(netif_running(ndev)){
  8. dm9000_reset(db);
  9. dm9000_init_dm9000(ndev);
  10. netif_device_attach(ndev);
  11. }
  12. db->in_suspend=0;
  13. }
  14. return0;
  15. }

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

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

  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. };
  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接口,使能传输等。代码清单如下:

  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;
  10. if(netif_msg_ifup(db))
  11. dev_dbg(db->dev,"enabling%s/n",dev->name);
  12. /*IfthereisnoIRQtypespecified,defaulttosomethingthat
  13. *maywork,andtelltheuserthatthisisaproblem*/
  14. if(irqflags==IRQF_TRIGGER_NONE)
  15. dev_warn(db->dev,"WARNING:noIRQresourceflagsset./n");
  16. irqflags|=IRQF_SHARED;
  17. if(request_irq(dev->irq,&dm9000_interrupt,irqflags,dev->name,dev))/*注册一个中断,中断处理函数为dm9000_interrupt()*/
  18. return-EAGAIN;
  19. /*InitializeDM9000board*/
  20. dm9000_reset(db);
  21. dm9000_init_dm9000(dev);
  22. /*Initdrivervariable*/
  23. db->dbug_cnt=0;
  24. mii_check_media(&db->mii,netif_msg_link(db),1);
  25. netif_start_queue(dev);
  26. dm9000_schedule_poll(db);/*之前在probe函数中已经使用INIT_DELAYED_WORK来初始化一个延迟工作队列并关联了一个操作函数dm9000_poll_work(),此时运行schedule来调用这个函数*/
  27. return0;
  28. }

*dm9000_stop()

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

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

*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来开始发送一个包。

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

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

*dm9000_timeout()

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

代码清单如下:

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

*dm9000_hash_table()

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

  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;
  15. dm9000_dbg(db,1,"entering%s/n",__func__);
  16. spin_lock_irqsave(&db->lock,flags);
  17. for(i=0,oft=DM9000_PAR;i<6;i++,oft++)
  18. iow(db,oft,dev->dev_addr[i]);
  19. /*ClearHashTable*/
  20. for(i=0;i<4;i++)
  21. hash_table[i]=0x0;
  22. /*broadcastaddress*/
  23. hash_table[3]=0x8000;
  24. if(dev->flags&IFF_PROMISC)
  25. rcr|=RCR_PRMSC;
  26. if(dev->flags&IFF_ALLMULTI)
  27. rcr|=RCR_ALL;
  28. /*themulticastaddressinHashTable:64bits*/
  29. for(i=0;i<mc_cnt;i++,mcptr=mcptr->next){
  30. hash_val=ether_crc_le(6,mcptr->dmi_addr)&0x3f;
  31. hash_table[hash_val/16]|=(u16)1<<(hash_val%16);
  32. }
  33. /*WritethehashtabletoMACMDtable*/
  34. for(i=0,oft=DM9000_MAR;i<4;i++){
  35. iow(db,oft++,hash_table[i]);
  36. iow(db,oft++,hash_table[i]>>8);
  37. }
  38. iow(db,DM9000_RCR,rcr);
  39. spin_unlock_irqrestore(&db->lock,flags);
  40. }

*dm9000_ioctl()

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

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

*dm9000_poll_controller()

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

  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结构体变量。代码清单如下:

  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)*/
  5. strcpy(info->driver,CARDNAME);
  6. strcpy(info->version,DRV_VERSION);
  7. strcpy(info->bus_info,to_platform_device(dm->dev)->name);
  8. }

*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:

  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状态和长度。

  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寄存器。例子代码如下:

  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用来表示头部的四个字节。代码清单如下:

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

接收函数代码如下:

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

6. 中断处理相关函数

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

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

  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;
  8. dm9000_dbg(db,3,"entering%s/n",__func__);
  9. /*Arealinterruptcoming*/
  10. /*holdersofdb->lockmustalwaysblockIRQs*/
  11. spin_lock_irqsave(&db->lock,flags);
  12. /*Savepreviousregisteraddress*/
  13. reg_save=readb(db->io_addr);
  14. /*Disableallinterrupts*/
  15. iow(db,DM9000_IMR,IMR_PAR);
  16. /*GotDM9000interruptstatus*/
  17. int_status=ior(db,DM9000_ISR);/*GotISR*/
  18. iow(db,DM9000_ISR,int_status);/*ClearISRstatus*/
  19. if(netif_msg_intr(db))
  20. dev_dbg(db->dev,"interruptstatus%02x/n",int_status);
  21. /*Receivedthecomingpacket*/
  22. /*如果是由于收到数据而触发的中断,显然调用dm9000_rx()把数据取走,传递给上层*/
  23. if(int_status&ISR_PRS)
  24. dm9000_rx(dev);
  25. /*TrnasmitInterruptcheck*/
  26. /*如果是由于发送完了数据而触发的中断,则调用dm9000_tx_done()函数,下面具体分析这个函数*/
  27. if(int_status&ISR_PTS)
  28. dm9000_tx_done(dev,db);
  29. if(db->type!=TYPE_DM9000E){
  30. if(int_status&ISR_LNKCHNG){
  31. /*firealink-changerequest*/
  32. schedule_delayed_work(&db->phy_poll,1);
  33. }
  34. }
  35. /*Re-enableinterruptmask*/
  36. iow(db,DM9000_IMR,db->imr_all);
  37. /*Restorepreviousregisteraddress*/
  38. writeb(reg_save,db->io_addr);
  39. spin_unlock_irqrestore(&db->lock,flags);
  40. returnIRQ_HANDLED;
  41. }

*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)通知内核可以将待发送的数据包进入发送队列。

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

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端口读一个字节。代码清单如下:

  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端口写一个字节。代码清单如下:

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

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

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


分享到:
评论

相关推荐

    dm9000网卡驱动程序分析

    arm9开发板上 dm9000网卡驱动程序分析

    DM9000网卡驱动程序

    linux内核的DM9000网卡驱动,注意:对于linux源码中已经存在的驱动文件,网络驱动内容只需要修改一下几点:网卡基地址,中断号,网卡工作模式,中断触发方式.

    国嵌培训课件Linux驱动程序设计

    第一天 1.Linux驱动简介 2.字符设备驱动程序设计 3.驱动调试技术 4. 并发与竞态 第二天 1.Ioctl型驱动 ...3. Dm9000网卡驱动程序分析 4. 触摸屏驱动程序设计 第六天 1. PCI驱动程序设计 2. 串口驱动程序设计

    linux网卡DM9000c.c驱动源代码

    S3C6410为基础的linux系统环境下的网卡DM9000驱动程序源代码

    基于S3C2440的DM9000网卡驱动的移植

    Linux网络设备驱动程序的体系结构可以分为4层,首先分析了各层的具体功能实现,并在此基础上充分利用S3C2440开发板完成DM9000网卡驱动的移植,编译内核生成内核镜像。最后介绍了网络驱动测试的三种方法,并采用第一...

    Altera Enthernet DM9000开发资料

    Linux下DM9000网卡驱动实验.doc lwip 到 lxRTOS 移植实现.doc NIOS II网络驱动程序分析(1).doc 基于MFC的网络通讯.doc 基于嵌入式调试器的网络通信方法设计与实现.doc 网卡.doc 请问有会dm9000驱动的么.doc ...

    DM9000的LINUX驱动

    DM9000是一款主流的网卡芯片,这是他的驱动程序

    单片机驱动DM9000

    本文主要介绍单片机驱动DM9000E网卡芯片的详细过程。从网卡电路的连接,到网卡初始化相关程序调试,再到ARP协议的实现,一步一步详细...当然,会用单片机编写DM9000的驱动,再想编写ARM下的Linux的驱动就容易的多了。

    基于ARM_LINUX的多功能视频监控系统研究与实现.caj

    研究分析了Linux内核中经典的bus-device-driver框架结构及Linux内核中提供的输入子系统框架,以及LCD、触摸屏、网卡、摄像头驱动框架等,分别设计并实现了LCD、触摸屏、摄像头、按键四种设备驱动程序,并对DM9000网卡...

    Altera Enthernet开发资料

    Linux下DM9000网卡驱动实验.doc lwip 到 lxRTOS 移植实现.doc NIOS II网络驱动程序分析(1).doc 基于MFC的网络通讯.doc 基于嵌入式调试器的网络通信方法设计与实现.doc 网卡.doc 请问有会dm9000驱动的么.doc ...

    ENC28J60 SPI网卡移植 linux 2.6.28 SAMSUNG 6410 ARM11

    linux2.6.28 开发板:飞凌TE6410 (256M RAM 2G NAND) 网卡:ENC28J60 SPI 测试用的工具:Saleae logic (逻辑分析仪),Iris 抓包工具 6410作为一颗强大的ARM11处理器,网卡模块已经是相当的成熟(如:DM9000/3 ...

    PDF 资料 ENC28J60 SPI网卡移植 linux 2.6.28 SAMSUNG 6410 ARM11

    linux2.6.28 开发板:飞凌TE6410 (256M RAM 2G NAND) 网卡:ENC28J60 SPI 测试用的工具:Saleae logic (逻辑分析仪),Iris 抓包工具 6410作为一颗强大的ARM11处理器,网卡模块已经是相当的成熟(如:DM9000/3 ...

    基于ARM和DM9000的网卡接口设计与实现

    1 引言要实现小型嵌入式设备的Internet接入,TCP/IP首先要解决的是底层硬件问题,即协议的物理层。Ethernet具有成熟的技术...寄存器操作简单有效,有成熟的Linux驱动程序支持;3.3V接口电平;成本相当低廉;还可以使用

    4.网络设备驱动.zip

    从我们在实验中所得到的数据来看,在随着网络的接收速度的增加,NIC 触发的中断能做到不断减少,目前 NAPI 技术已经在网卡驱动层和网络层得到了广泛的应用,驱动层次上已经有 E1000 系列网卡,RTL8139 系列网卡,3c...

    AT91SAM9263开发板SBC6300X.rar

    提供全部板载外设驱动程序说明及相关测试程序 UploadFile/2009/09/DownloadFile/SBC6300X_1.rar 再来个底板特性 底板特性: 类别 功能 参数 存储接口 SD card SDIO模式 支持热插拔 电源 输入电源 宽电压范围8~20V,...

    基于ARM的矿井综采面无线传感器网络的网关设计

    介绍了一种基于ARM的综采面无线传感器网络的网关设计。...阐述了网关的硬件设计,重点论述了无线收发模块和以太网接口模块,并介绍了DM9000以太网卡的移植,CC2420无线模块驱动的开发,以及上层应用程序等软件设计。

Global site tag (gtag.js) - Google Analytics