dm9000网卡驱动分析（一）

转自http://blog.chinaunix.net/uid-26442066-id-3184195.html

s3c6410自带的DM9000网卡驱动也是基于platform设备模型。

其定义的设备资源在arch/arm/mach-s3c64xx/mach-smdk6410中。有网卡的resource resource dm9000_resources[]，还有一些板级信息，dm9000_plat_data dm9000_setup。

1.宏及参数  //板级、系统定义

 #define DM9000_PHY        0x40    /* PHY address 0x01 */

 #define CARDNAME    "dm9000"
 #define DRV_VERSION    "1.31"
 /*
  * Transmit timeout, default 5 seconds.
  */
 static int watchdog = 5000; //5s的延时时间
 module_param(watchdog, int, 0400);
 MODULE_PARM_DESC(watchdog, "transmit timeout in milliseconds");
 enum dm9000_type {  //开发板定义了三个DM9000类型
     TYPE_DM9000E,    /* original DM9000 */
     TYPE_DM9000A,
     TYPE_DM9000B
 };

2.模块注册

此处因为基于platform模型，采用platform_driver_register函数注册内核模块，当设备驱动与设备匹配真确后，转入执行dm9000_probe()函数，该函数包含真正的dm9000网卡驱动注册函数是register_netdev()函数。

 static int __init dm9000_init(void)
 {
     printk(KERN_INFO "%s Ethernet Driver, V%s\n", CARDNAME, DRV_VERSION);

     return platform_driver_register(&dm9000_driver); //platform设备模型注册驱动
 }

dm9000的platform设备驱动函数如下

 static struct platform_driver dm9000_driver = {
     .driver    = {
         .name = "dm9000",
         .owner     = THIS_MODULE,
         .pm     = &dm9000_drv_pm_ops,
     },
     .probe = dm9000_probe,
     .remove = __devexit_p(dm9000_drv_remove),
 };

3.dm9000_probe函数

主要完成网络设备的初始化，以及网卡驱动的注册register_netdev（）

 static int __devinit  dm9000_probe(struct platform_device *pdev)
 {
     struct dm9000_plat_data *pdata = pdev->dev.platform_data;//驱动程序中获得系统定义的网卡板级信息
                                             //定义在/arch/arm/mach-s3c64xx/mach-smdk6410.c中。
     struct board_info *db;    /* Point a board information structure */
     struct net_device *ndev; //定义设备结构体
     const unsigned char *mac_src;
     int ret = 0;
     int iosize;
     int i;
     u32 id_val;

     /* Init network device */
 //分配生成net_device结构体  alloc_etherdev是alloc_netdev()针对以太网的快捷操作函数
     ndev = alloc_etherdev(sizeof(struct board_info));

 //判断是否分配正确
     if (!ndev) {
         dev_err(&pdev->dev, "could not allocate device.\n");
         return -ENOMEM;
     }
 //建立net_device到device的连接
     SET_NETDEV_DEV(ndev, &pdev->dev);
 //内核输出信息
     dev_dbg(&pdev->dev, "dm9000_probe()\n");
 //函数netdev_priv直接返回了net_device结构末端地址，也就是网卡私有数据结构的起始地址。
     /* setup board info structure */
     db = netdev_priv(ndev);

     db->dev = &pdev->dev;
     db->ndev = ndev;

     spin_lock_init(&db->lock);//初始化自旋锁
     mutex_init(&db->addr_lock);

     INIT_DELAYED_WORK(&db->phy_poll, dm9000_poll_work); //??
 //获取平台设备资源 resource 地址空间、数据空间、中断信号 7号中断
     db->addr_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
     db->data_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
     db->irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
 //判断资源是否获取成功
     if (db->addr_res == NULL || db->data_res == NULL ||
      db->irq_res == NULL) {
         dev_err(db->dev, "insufficient resources\n");
         ret = -ENOENT;
         goto out;
     }
 //platform_get_resource的变体 同  platform_get_resource(pdev, IORESOURCE_IRQ, 1)
     db->irq_wake = platform_get_irq(pdev, 1);
     if (db->irq_wake >= 0) {
         dev_dbg(db->dev, "wakeup irq %d\n", db->irq_wake);
                                                                                           //前面获得中断号  申请中断
         ret = request_irq(db->irq_wake, dm9000_wol_interrupt,
                  IRQF_SHARED, dev_name(db->dev), ndev);
         if (ret) {
             dev_err(db->dev, "cannot get wakeup irq (%d)\n", ret);
         } else {
             /* test to see if irq is really wakeup capable */
             ret = set_irq_wake(db->irq_wake, 1);
             if (ret) {
                 dev_err(db->dev, "irq %d cannot set wakeup (%d)\n",
                     db->irq_wake, ret);
                 ret = 0;
             } else {
                 set_irq_wake(db->irq_wake, 0);
                 db->wake_supported = 1;
             }
         }
     }
 //IO资源分配大小  地址  为resource分配内存
     iosize = resource_size(db->addr_res);
     db->addr_req = request_mem_region(db->addr_res->start, iosize,
                      pdev->name); //内存申请

     if (db->addr_req == NULL) {
         dev_err(db->dev, "cannot claim address reg area\n");
         ret = -EIO;
         goto out;
     }

     db->io_addr = ioremap(db->addr_res->start, iosize);

     if (db->io_addr == NULL) {
         dev_err(db->dev, "failed to ioremap address reg\n");
         ret = -EINVAL;
         goto out;
     }

     iosize = resource_size(db->data_res);
     db->data_req = request_mem_region(db->data_res->start, iosize,
                      pdev->name);

     if (db->data_req == NULL) {
         dev_err(db->dev, "cannot claim data reg area\n");
         ret = -EIO;
         goto out;
     }

     db->io_data = ioremap(db->data_res->start, iosize);

     if (db->io_data == NULL) {
         dev_err(db->dev, "failed to ioremap data reg\n");
         ret = -EINVAL;
         goto out;
     }
 //初始化net_device中的成员
     /* fill in parameters for net-dev structure */
     ndev->base_addr = (unsigned long)db->io_addr; //网络接口的IO基地址
     ndev->irq    = db->irq_res->start;//中断号  ifconfig时会打印出这个值  也可通过这个修改

     /* ensure at least we have a default set of IO routines */
     dm9000_set_io(db, iosize);

     /* check to see if anything is being over-ridden */
     if (pdata != NULL) {
         /* check to see if the driver wants to over-ride the
          * default IO width */
 //检测与板级信息是否相同
         if (pdata->flags & DM9000_PLATF_8BITONLY)
             dm9000_set_io(db, 1);

         if (pdata->flags & DM9000_PLATF_16BITONLY)
             dm9000_set_io(db, 2);

         if (pdata->flags & DM9000_PLATF_32BITONLY)
             dm9000_set_io(db, 4);

         /* check to see if there are any IO routine
          * over-rides */

         if (pdata->inblk != NULL)
             db->inblk = pdata->inblk;

         if (pdata->outblk != NULL)
             db->outblk = pdata->outblk;

         if (pdata->dumpblk != NULL)
             db->dumpblk = pdata->dumpblk;

         db->flags = pdata->flags;
     }

 #ifdef CONFIG_DM9000_FORCE_SIMPLE_PHY_POLL
     db->flags |= DM9000_PLATF_SIMPLE_PHY;
 #endif

     dm9000_reset(db);

     /* try multiple times, DM9000 sometimes gets the read wrong */
     for (i = 0; i < 8; i++) {  //宏定义在dm9000.h中
         id_val = ior(db, DM9000_VIDL);
         id_val |= (u32)ior(db, DM9000_VIDH) << 8;
         id_val |= (u32)ior(db, DM9000_PIDL) << 16;
         id_val |= (u32)ior(db, DM9000_PIDH) << 24;

         if (id_val == DM9000_ID)
             break;
         dev_err(db->dev, "read wrong id 0x%08x\n", id_val);
     }

     if (id_val != DM9000_ID) {
         dev_err(db->dev, "wrong id: 0x%08x\n", id_val);
         ret = -ENODEV;
         goto out;
     }

     /* Identify what type of DM9000 we are working on */

     id_val = ior(db, DM9000_CHIPR);
     dev_dbg(db->dev, "dm9000 revision 0x%02x\n", id_val);

     switch (id_val) {
     case CHIPR_DM9000A:
         db->type = TYPE_DM9000A;
         break;
     case CHIPR_DM9000B:
         db->type = TYPE_DM9000B;
         break;
     default:
         dev_dbg(db->dev, "ID %02x => defaulting to DM9000E\n", id_val);
         db->type = TYPE_DM9000E;
     }

     /* dm9000a/b are capable of hardware checksum offload */
     if (db->type == TYPE_DM9000A || db->type == TYPE_DM9000B) {
         db->can_csum = 1;
         db->rx_csum = 1;
         ndev->features |= NETIF_F_IP_CSUM;
     }

     /* from this point we assume that we have found a DM9000 */

     /* driver system function */ //初始化以太网设备的公有成员
     ether_setup(ndev);//在调用register_netdev之前必须初始化完全。该函数中为net_device设置了很多默认值

     ndev->netdev_ops    = &dm9000_netdev_ops;
     ndev->watchdog_timeo    = msecs_to_jiffies(watchdog);
     ndev->ethtool_ops    = &dm9000_ethtool_ops;

     db->msg_enable = NETIF_MSG_LINK;
     db->mii.phy_id_mask = 0x1f;
     db->mii.reg_num_mask = 0x1f;
     db->mii.force_media = 0;
     db->mii.full_duplex = 0;
     db->mii.dev     = ndev;
     db->mii.mdio_read = dm9000_phy_read;
     db->mii.mdio_write = dm9000_phy_write;

     mac_src = "eeprom";

     /* try reading the node address from the attached EEPROM */
     for (i = 0; i < 6; i += 2)
         dm9000_read_eeprom(db, i / 2, ndev->dev_addr+i);

     if (!is_valid_ether_addr(ndev->dev_addr) && pdata != NULL) {
         mac_src = "platform data";
         memcpy(ndev->dev_addr, pdata->dev_addr, 6);
     }

     if (!is_valid_ether_addr(ndev->dev_addr)) {
         /* try reading from mac */

         mac_src = "chip";
         for (i = 0; i < 6; i++)
             ndev->dev_addr[i] = ior(db, i+DM9000_PAR);
     }

     if (!is_valid_ether_addr(ndev->dev_addr))
         dev_warn(db->dev, "%s: Invalid ethernet MAC address. Please "
              "set using ifconfig\n", ndev->name);

     platform_set_drvdata(pdev, ndev);
     ret = register_netdev(ndev); //注册net_device结构体

     if (ret == 0)
         printk(KERN_INFO "%s: dm9000%c at %p,%p IRQ %d MAC: %pM (%s)\n",
          ndev->name, dm9000_type_to_char(db->type),
          db->io_addr, db->io_data, ndev->irq,
          ndev->dev_addr, mac_src);
     return 0;

 out:
     dev_err(db->dev, "not found (%d).\n", ret);

     dm9000_release_board(pdev, db);
     free_netdev(ndev); //分配错误则释放net_device结构

     return ret;
 }

模块加载后转入probe中执行，在probe中完成了分配net_device、网络设备的初始化，设备驱动的加载。

先是分配获得了net_device结构体等。

网络设备初始化包括:

进行硬件上的准备工作，检查网络设备是否存在，检测所使用的硬件资源，主要是resource；

获得软件接口上的准备工作；

获得私有数据指针，初始化以太网设备公有成员、初始化成员，初始化自旋锁或并发同步机制、申请设备所需的硬件资源 request_region等。