linux网络设备驱动DM9000驱动分析（1）

  转载请注明出处：http://blog.csdn.net/gotowu/article/details/46329809

  本文所分析的DM9000驱动，是基于platform设备模型的。

网络驱动程序不再是对文件进行操作，而是由专门的网络接口struct net_device来实现。应用程序不能直接访问网络驱动程序，只能由网络字系统与它交互。此外，不像字符设备和块设备在/dev目录下有一个特殊文件来表示该设备，网络设备没有这样的入口点。

首先，在网络驱动程序中，有两个很重要的结构体分别是net_device和sk_buff。；

1、skb_buf

它是Linux在其协议栈里传送的结构体，也就是所谓的“包”，在他里面包含了各层协议的头部，比如ethernet, ip ,tcp ,udp等等. sk_buff是一个复杂的双向链表，在他结构中有next和prev指针，分别指向链表的下一个节点和前一个节点。该结构在内核源码的include/linux/skbuff.h文件中定义.

2、net_device

net_device是网络设备驱动的核心，包含网络适配器的硬件信息（中断、端口、驱动程序函数等）和高层网络协议的网络配置信息（IP地址、子网掩码等）。该结构的定义位于include/linux/netdevice.h。

一、模块的注册和加载。

1、模块的注册，使用platform_driver_register，将模块注册进内核。

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

	return platform_driver_register(&dm9000_driver);
}

2、填充platform_driver 结构体，其中包括用去match的驱动名字以及probe等操作函数。

static struct platform_driver dm9000_driver = {
	.driver	= {
		.name    = "dm9000",                                   //若内核中有相同名称的平台设备，则调用probe函数
		.owner	 = THIS_MODULE,
		.pm	 = &dm9000_drv_pm_ops,
	},
	.probe   = dm9000_probe,
	.remove  = __devexit_p(dm9000_drv_remove),
};

3、下面来看看很重要的probe函数，该函数主要完成了探测设备，对网络设备的初始化，获取资源，申请中断，映射物理地址，读取MAC地址和注册net_device结构体。

先来看几个函数吧：

（1）alloc_etherdev 初始化一个网络设备最终是调用了函数alloc_netdev_mq,因为对以太网设备来讲，很多操作与属性是固定的，内核可以帮助完成。

（2）request_mem_region这个函数向内核申请n个内存地址,这些地址从first 开始,name参数为设备的名称。如果分配成功返回值是非  NULL，如果返回NULL，则意味着申

请I/O 内存失败.

（3）ioremap()将设备所处的物理地址映射为虚拟地址，并且返回一个特殊的虚拟地址

该地址可以用来存取特点的物理地址范围

static int __devinit
dm9000_probe(struct platform_device *pdev)
{
	struct dm9000_plat_data *pdata = pdev->dev.platform_data;
	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;

	//初始化一个网络设备最终是调用了函数alloc_netdev_mq,因为对以太网设备来讲，
	//很多操作与属性是固定的，内核可以帮助完成。
	ndev = alloc_etherdev(sizeof(struct board_info));                   
	if (!ndev)
		return -ENOMEM;
        //建立net_device到device的连接
	SET_NETDEV_DEV(ndev, &pdev->dev);

	dev_dbg(&pdev->dev, "dm9000_probe()\n");

	db = netdev_priv(ndev);        //函数netdev_priv直接返回了net_device结构末端地址,
                                       //也就是网卡私有数据结构的起始地址.
	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);

	db->addr_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);      //获取资源赋给地址、数据、中断
	db->data_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);    //内存地址空间定义在板级文件common-smdk.c
	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，获取一个设备irq，这个irq号也是板级配置文件中设置的
	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 = irq_set_irq_wake(db->irq_wake, 1);            //使能IRQ的电源管理唤醒模式
			if (ret) {                                          //使系统能从睡眠态唤醒
				dev_err(db->dev, "irq %d cannot set wakeup (%d)\n",
					db->irq_wake, ret);
				ret = 0;
			} else {
				irq_set_irq_wake(db->irq_wake, 0);       //不使能IRQ的电源管理唤醒模式
				db->wake_supported = 1;
			}
		}
	}

	iosize = resource_size(db->addr_res);               //获取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);  //将addr_res在platform_get_resource获取的物理地址映射为虚拟地址

	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;
	}
	//上面因为dm9000提供了地址和数据两个访问口，所以映射了两个
	
	ndev->base_addr = (unsigned long)db->io_addr;  //网络接口的IO基地址
	ndev->irq	= db->irq_res->start;   //中断号  ifconfig时会打印出这个值  也可通过这个修改
	
//设置dm9000位宽，根据板级配置文件中struct platform_data设置而定 
	dm9000_set_io(db, iosize);

	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 */
	                                             /*inblk :IO模式*/
		if (pdata->inblk != NULL)            //若pdata->inblk != NULL则对上面的dm9000_set_io设置的值重新赋值
			db->inblk = pdata->inblk;   //否则就使用上面的dm9000_set_io设置的值
								    //此处为什么这样???
		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);       //复位操作，初始化NCR网络控制寄存器
/*此处的复位操作我的理解是，当我们开始运行后，对db的一些成员进行
*了设置后，就要进行复位，对DM9000芯片进行重启，然后重新读取
*芯片中的数据，比如mac地址，VID或者PID等。
*/

	for (i = 0; i < 8; i++) {                    //读取DM9000的寄存器
		id_val  = ior(db, DM9000_VIDL);      //读一下生产商和制造商的ID
		id_val |= (u32)ior(db, DM9000_VIDH) << 8;    //根据DM9000datasheet中的VIDL地址读取
		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) {
		ndev->hw_features = NETIF_F_RXCSUM | NETIF_F_IP_CSUM;
		ndev->features |= ndev->hw_features;
	}

	/* 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;
        //dm9000网卡的初始化,提供了这些，对phy的操作就可以用mii.c中的函数去操作
	db->msg_enable       = NETIF_MSG_LINK;
	db->mii.phy_id_mask  = 0x1f;          //这个给驱动用，dm9000没用，是考虑smi总线上有多个phy时。
	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);   //读取MAC地址，并保存在ndev->dev_addr中

	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);    //PAR :物理地址mac寄存器,用来保存6个字节的MAC地址
	}

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

		eth_hw_addr_random(ndev);     //产生一个随机的MAC地址给net_device
		mac_src = "random";
	}

//把ndev保存为平台设备pdev的私有数据，并可以调用platform_get_drvdata获取该数据 
	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);

	return ret;
}