基于mini2440的DM9000网卡驱动分析probe函数部分

         此为源代码，是基于mini2440开发板的DM9000网卡驱动程序，内核版本为Linux2.6.32.2

以下是对内核源码的拷贝，并对源码进行了个人的分析，如有错误之处，请指正，万分感谢。

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_etherdev函数为alloc_netdev针对以太网的“快捷”函数，用于分配一个net_device结构体并对其成员赋值*/

       /* Init network device */

       ndev = alloc_etherdev(sizeof(struct board_info));

       if (!ndev) {

              dev_err(&pdev->dev, "could not allocate device.\n");

              return -ENOMEM;

       }

/* Set the sysfs physical device reference for the network logical device

 * if set prior to registration will cause a symlink during initialization.

 */

       SET_NETDEV_DEV(ndev, &pdev->dev);

 

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

/*设置板信息结构体，填充board_info结构*/

       /* 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);

/*初始化延时工作队列，phy_poll为一个延时的工作队列，dm_poll_work为一个时间到了的处理函数*/

       INIT_DELAYED_WORK(&db->phy_poll, dm9000_poll_work);

/*获得平台资源，dm9000地址、数据、中断，在mach-mini2440.c中有定义*/

       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;

       }

/*为dm9000地址资源申请内存*/

       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;

       }

/*为dm9000的数据资源申请内存*/

       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;  //数据地址

       ndev->irq       = db->irq_res->start;     //中断起始地址

 

       /* ensure at least we have a default set of IO routines */

       dm9000_set_io(db, iosize);    //设置IO操作的默认位宽

/*检查是否有设置dm9000的IO操作位宽，若果有，则进行设置新的位宽*/

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

/*检查是否有对IO模式的设置操作*/

              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复位，对dm9000内部寄存器的网络控制寄存器NCR第0位置1进行软件复位*/

       dm9000_reset(db);

/*读取生产厂家序列号VID和产品序列号PID，为0x90000A46，多次读取确保不会发生错误*/

       /* try multiple times, DM9000 sometimes gets the read wrong */

       for (i = 0; i < 8; i++) {

              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;

/*识别dm9000的ID*/

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

/*获得DM9000芯片修订版本，以证实是DM9000A还是DM9000B缺省为DM9000E*/

       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; /* Can checksum TCP/UDP over IPv4.能通过IPV4来进行TCP/UDP协议的校验和检测 */

       }

/*在这里我们可以确保我们找到了一个DM9000设备*/

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

 

       /* driver system function */

/*初始化以太网设备的公用成员，主要是对以太网设备的一些公用的操作进行设定，是固定的一些设置，如：设置对以太网头的操作，以太网数据发送类型10Mbps，以太网头部字节数14个字节，以太网最大传输字节数1500字节，以太网地址字节数6字节，以太网发送队列1000，以太网设备标识——广播地址有效和支持多点传送，设置6个字节广播地址都为0xFF,使用ether_setup(ndev)函数*/

       ether_setup(ndev);        

/*设置设备的成员函数指针*/

       ndev->netdev_ops  = &dm9000_netdev_ops;      //dm9000网络设备操作

       ndev->watchdog_timeo  = msecs_to_jiffies(watchdog);      //看门狗定时器

       ndev->ethtool_ops  = &dm9000_ethtool_ops;      /*以太网协议操作，用来查询和设置网卡参数*/

/*以下是对MII进行初始化，MII（媒体独立接口）用来连接MAC和PHY的一个接口，它是IEEE-802.3定义的以太网行业标准，包括一个数据接口和一个MAC和PHY之间的管理接口。数据接口包括分别用于发送和接受的两条独立信道，每条信道都有自己的数据、时钟和控制信号，MII数据接口总共需要16个信号。MII管理接口包含两个信号，一个是时钟信号，另一个是数据信号。通过管理接口上层能监视和控制PHY。

       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";

/*读取节点地址从附带的EEPROM中，在mini2440中没有外界eeprom，所以读出来的都是0xff*/

       /* 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);

/*检查以太网地址是否有效FF：FF：FF：FF：FF：FF是一个多点播放地址，我们不需要去明确的去检查它*/

       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地址*/

              mac_src = "chip";

              for (i = 0; i < 6; i++)

                     ndev->dev_addr[i] = ior(db, i+DM9000_PAR);

       }

/*设置MAC地址为08:90:90:90:90:90*/

       memcpy(ndev->dev_addr, "\x08\x90\x90\x90\x90\x90", 6);

 

       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);

 

       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;

}

 

static int

dm9000_drv_suspend(struct device *dev)

{

       struct platform_device *pdev = to_platform_device(dev);

       struct net_device *ndev = platform_get_drvdata(pdev);

       board_info_t *db;

 

       if (ndev) {

              db = netdev_priv(ndev);//获得设备私有数据

              db->in_suspend = 1;      //挂载标志设置

 

              if (netif_running(ndev)) {

                     netif_device_detach(ndev);    //设置device为为连接状态

                     dm9000_shutdown(ndev);     //关电源

              }

       }

       return 0;

}

 

static int

dm9000_drv_resume(struct device *dev)

{

       struct platform_device *pdev = to_platform_device(dev);

       struct net_device *ndev = platform_get_drvdata(pdev);

       board_info_t *db = netdev_priv(ndev);

 

       if (ndev) {

 

              if (netif_running(ndev)) {

                     dm9000_reset(db); //复位

                     dm9000_init_dm9000(ndev); //重新初始化

 

                     netif_device_attach(ndev);     //设置device为连接状态

              }

 

              db->in_suspend = 0;      //挂载标志

       }

       return 0;

}

/*驱动电源管理操作*/

static struct dev_pm_ops dm9000_drv_pm_ops = {

       .suspend  = dm9000_drv_suspend,              //挂载

       .resume          = dm9000_drv_resume, //恢复

};

 

static int __devexit

dm9000_drv_remove(struct platform_device *pdev)

{

       struct net_device *ndev = platform_get_drvdata(pdev);      //得到平台数据

/*设置平台数据为空*/

       platform_set_drvdata(pdev, NULL);

/*注销驱动*/

       unregister_netdev(ndev);

/*释放板资源*/

       dm9000_release_board(pdev, (board_info_t *) netdev_priv(ndev));

/*释放网络设备结构体*/

       free_netdev(ndev);        /* free device structure */

 

       dev_dbg(&pdev->dev, "released and freed device\n");

       return 0;

}

 

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),        /*__devexit_p宏为告知内核如果此驱动被编译成模块或者有热插拔事件时，此成员应被加载，否则此成员为NULL*/

};

 

static int __init

dm9000_init(void)

{

/*mini2440的dm9000网卡是接在bank4上的，所以要bank4进行时序设置*/

#if defined(CONFIG_ARCH_S3C2410)

/*获得总线宽度和等待控制寄存器地址*/

       unsigned int oldval_bwscon = *(volatile unsigned int *)S3C2410_BWSCON;

/*获得bank4控制寄存器地址*/

       unsigned int oldval_bankcon4 = *(volatile unsigned int *)S3C2410_BANKCON4;

/* 先清除BWSCON上的DW4为0，然后设置数据总线宽度为16位，启用BANK4的WAIT状态，启用BANK4的SRAM的写高低字节使能*/

       *((volatile unsigned int *)S3C2410_BWSCON) =

                     (oldval_bwscon & ~(3<<16)) | S3C2410_BWSCON_DW4_16 | S3C2410_BWSCON_WS4 | S3C2410_BWSCON_ST4;

/* 设置PMC – 页模式配置 为normal（ 1 data）
  Tacp – 页模式下的访问周期为 6 clocks
  Tcah – nGCSn后的地址保持时间为 4 clocks
  Tcoh – nOE后的片选保持时间为 1 clock
  Tacc – 访问周期为 14 clocks
  Tcos – nOE前的片选建立时间为 4 clocks
  Tacs – nGCSn前的地址建立时间为 0 clock

0  00    11   111   01     11    11    00

   Tacs  Tcos Tacc Tcoh   Tcah  Tacp   PMC      */

       *((volatile unsigned int *)S3C2410_BANKCON4) = 0x1f7c;

#endif

       printk(KERN_INFO "%s Ethernet Driver, V%s\n", CARDNAME, DRV_VERSION);

/*注册平台驱动*/

       return platform_driver_register(&dm9000_driver);

}

 

static void __exit

dm9000_cleanup(void)

{

/*注销平台驱动，将struct platform_driver dm9000_driver结构体注册到平台设备进行match匹配，匹配成功会调用probe函数往下进行*/

       platform_driver_unregister(&dm9000_driver);

}

 

module_init(dm9000_init);

module_exit(dm9000_cleanup);

 

MODULE_AUTHOR("Sascha Hauer, Ben Dooks");

MODULE_DESCRIPTION("Davicom DM9000 network driver");

MODULE_LICENSE("GPL");

MODULE_ALIAS("platform:dm9000");