Linux-3.6.6很好的支持了DM9000，因此对于S3C2440芯片来说无需进行任何修改，甚至连menuconfig都已经默认配置了网卡驱动。但我们还需要设置网卡的MAC和IP等信息。有许多方法可以实现网卡的设置，在这里我们选择一种比较简单的方法——修改根文件系统的启动脚本文件rcS。在根文件etc/init.d/rcS文件中添加下列语句：

/sbin/ifconfig  lo  127.0.0.1

/sbin/ifconfig  eth0  hw ether  5e:f7:90:82:66:28

/sbin/ifconfig  eth0  192.168.1.234  up

route  add  default  gw  192.168.1.1

这样就完成了网卡的移植。我们测试一下网卡。在启动开发板时，系统会打印出类似下列信息：

dm9000 dm9000: eth0: link down

dm9000 dm9000: eth0: link up, 100Mbps,full-duplex, lpa 0xCDE1

如果在提示符下输入ifconfig命令，则：

[root@zhaocj /]#ifconfig

eth0     Link encap:Ethernet  HWaddr5E:F7:90:82:66:28

         inet addr:192.168.1.234 Bcast:192.168.1.255 Mask:255.255.255.0

         UP BROADCAST RUNNING MULTICAST MTU:1500  Metric:1

         RX packets:51 errors:0 dropped:0 overruns:0 frame:0

         TX packets:0 errors:0 dropped:0 overruns:0 carrier:0

         collisions:0 txqueuelen:1000

         RX bytes:5324 (5.1 KiB)  TXbytes:0 (0.0 B)

         Interrupt:51 Base address:0x2300

 

lo       Link encap:Local Loopback

         inet addr:127.0.0.1 Mask:255.0.0.0

         UP LOOPBACK RUNNING MTU:16436  Metric:1

         RX packets:0 errors:0 dropped:0 overruns:0 frame:0

         TX packets:0 errors:0 dropped:0 overruns:0 carrier:0

         collisions:0 txqueuelen:0

         RX bytes:0 (0.0 B)  TX bytes:0(0.0 B)

另外主机和开发板都可以互相ping通对方。

 

下面我们就简单介绍一下DM9000网卡驱动。

在arch/arm/mach-s3c24xx/mach-zhaocj2440.c文件内定义了DM9000网卡平台设备：

static struct resource zhaocj2440_dm9k_resource[]= {

       [0]= DEFINE_RES_MEM(MACH_ZHAOCJ2440_DM9K_BASE, 4),

       [1]= DEFINE_RES_MEM(MACH_ZHAOCJ2440_DM9K_BASE + 4, 4),

       [2]= DEFINE_RES_NAMED(IRQ_EINT7, 1, NULL, IORESOURCE_IRQ \

                                          |IORESOURCE_IRQ_HIGHEDGE),

};

 

/*

 *The DM9000 has no eeprom, and it's MAC address is set by

 *the bootloader before starting the kernel.

 */

static struct dm9000_plat_data zhaocj2440_dm9k_pdata= {

       .flags             = (DM9000_PLATF_16BITONLY |DM9000_PLATF_NO_EEPROM),

};

 

static struct platform_device zhaocj2440_device_eth= {

       .name             = "dm9000",

       .id          = -1,

       .num_resources      = ARRAY_SIZE(zhaocj2440_dm9k_resource),

       .resource =zhaocj2440_dm9k_resource,

       .dev        ={

              .platform_data       = &zhaocj2440_dm9k_pdata,

       },

};

 

并把网卡平台设备添加进平台设备数组内：

static structplatform_device *zhaocj2440_devices[] __initdata = {

       ……

       &zhaocj2440_device_eth,

       ……

};

 

在drivers/net/ethernet/davicom/dm9000.c文件内定义了DM9000网卡平台驱动：

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

};

 

下面分析一下探测函数dm9000_probe：

static int__devinit

dm9000_probe(structplatform_device *pdev)

{

       struct dm9000_plat_data *pdata =pdev->dev.platform_data;

       struct board_info*db;    /* Point a board informationstructure */

       structnet_device *ndev;

       constunsigned char *mac_src;

       intret = 0;

       intiosize;

       inti;

       u32id_val;

 

       /*Init network device */

       //初始化网络设备结构体net_device

       ndev= alloc_etherdev(sizeof(struct board_info));

       if(!ndev)

              return-ENOMEM;

 

       SET_NETDEV_DEV(ndev,&pdev->dev);

 

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

 

       /*setup board info structure */

       //设置板块信息结构体——db

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

       //提取出DM9000网卡资源，即zhaocj2440_dm9k_resource

       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;

              gotoout;

       }

       //获取网卡中断资源

       db->irq_wake= platform_get_irq(pdev, 1);

       if(db->irq_wake >= 0) {

              dev_dbg(db->dev,"wakeup irq %d\n", db->irq_wake);

              //申请网卡中断，中断函数为dm9000_wol_interrupt

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

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

                            db->wake_supported = 1;

                     }

              }

       }

       //申请网卡地址所需的内存空间

       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;

              gotoout;

       }

       //地址内存空间映射

       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;

              gotoout;

       }

       //申请网卡数据所需的内存空间

       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;

              gotoout;

       }

       //数据内存空间映射

       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;

              gotoout;

       }

 

       /*fill in parameters for net-dev structure */

       //设置网络设备结构体——ndev

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

       //确保至少有一种IO路由方式，即先设置一种缺省的IO路由

       dm9000_set_io(db,iosize);

 

       /*check to see if anything is being over-ridden */

       /*检查是否可以替代刚才设置的IO路由，由于我们在zhaocj2440_dm9k_pdata结构体内的flags元素定义了DM9000_PLATF_16BITONLY，所以缺省的IO路由方式会被替代，即执行dm9000_set_io(db, 2);*/

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

       //多次读取DM9000的ID，以确保能够正确识别DM9000

       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;

              //判断读取的值是否为0x90000A46

              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;

              gotoout;

       }

 

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

       //读取CHIPR寄存器，获得type信息

       id_val= ior(db, DM9000_CHIPR);

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

 

       switch(id_val) {

       caseCHIPR_DM9000A:

              db->type= TYPE_DM9000A;

              break;

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

       //设置以太网卡设备，即把有关以太网设备的数据赋值给ndev

       ether_setup(ndev);

 

       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

       mac_src= "eeprom";

 

       /*try reading the node address from the attached EEPROM */

       //从eeprom中读取MAC

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

              dm9000_read_eeprom(db,i / 2, ndev->dev_addr+i);

       /*如果从eeprom中读取MAC失败，则从平台设备中读取MAC，即提取出zhaocj2440_dm9k_pdata结构中的dev_addr数组元素*/

       if(!is_valid_ether_addr(ndev->dev_addr) && pdata != NULL) {

              mac_src= "platform data";

              memcpy(ndev->dev_addr,pdata->dev_addr, 6);

       }

       /*如果到目前为止，还没有读取到正确的MAC，则从DM9000芯片的PAR寄存器内提取出MAC*/

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

       }

       /*如果上述方法都不行，则MAC值最终是要通过ifconfig来确定。但由于现在还没有执行ifconfig命令，因此系统在启动初始化的过程中，要随机分配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_src= "random";

       }

 

       //把ndev保存为平台设备pdev的私有数据，以后可以用platform_get_drvdata获取该数据

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

       return0;

 

out:

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

 

       dm9000_release_board(pdev,db);

       free_netdev(ndev);

 

       returnret;

}

 

在dm9000_probe函数内定义了dm9000_netdev_ops：

static const struct net_device_opsdm9000_netdev_ops = {

       .ndo_open             = dm9000_open,           //打开设备

       .ndo_stop              = dm9000_stop,            //关闭设备

       .ndo_start_xmit             = dm9000_start_xmit,           //开始发送数据

       .ndo_tx_timeout            = dm9000_timeout,              //发送超时

       .ndo_set_rx_mode  = dm9000_hash_table,          //设定多播列表

       .ndo_do_ioctl         = dm9000_ioctl,            //io操作函数

       .ndo_change_mtu          = eth_change_mtu,        //改变mtu

       .ndo_set_features    = dm9000_set_features,

       .ndo_validate_addr = eth_validate_addr,

       .ndo_set_mac_address    = eth_mac_addr,

#ifdef CONFIG_NET_POLL_CONTROLLER

       .ndo_poll_controller      = dm9000_poll_controller,

#endif

};

 

我们分析几个重要的回调函数。

当执行ifconfig命令时，会调用dm9000_open函数，以打开网络接口

static int

dm9000_open(struct net_device *dev)

{

       board_info_t*db = netdev_priv(dev);

       unsignedlong irqflags = db->irq_res->flags & IRQF_TRIGGER_MASK;

 

       if(netif_msg_ifup(db))

              dev_dbg(db->dev,"enabling %s\n", dev->name);

 

       /*If there is no IRQ type specified, default to something that

        * may work, and tell the user that this is aproblem */

 

       if(irqflags == IRQF_TRIGGER_NONE)

              dev_warn(db->dev,"WARNING: no IRQ resource flags set.\n");

 

       irqflags|= IRQF_SHARED;

 

       /*GPIO0 on pre-activate PHY, Reg 1Fis not set by reset */

       //将GPR寄存器的第0位清零，激活内部PHY

       iow(db,DM9000_GPR, 0);   /* REG_1F bit0 activate phyxcer */

       mdelay(1);/* delay needs by DM9000B */

 

       /*Initialize DM9000 board */

       dm9000_reset(db);        //复位DM9000

       //初始化DM9000，主要就是配置DM9000的内部寄存器

       dm9000_init_dm9000(dev);        

       //注册中断，中断函数为dm9000_interrupt，该中断负责收发数据

       if(request_irq(dev->irq, dm9000_interrupt, irqflags, dev->name, dev))

              return-EAGAIN;

 

       /*Init driver variable */

       db->dbug_cnt= 0;

       //检测mii接口的状态

       mii_check_media(&db->mii,netif_msg_link(db), 1);

       //允许上层协议使用该设备，开启发送队列

       netif_start_queue(dev);

       /*在dm9000_probe函数中，使用INIT_DELAYED_WORK初始化了一个工作队列，现在就调用它，即执行dm9000_poll_work函数，用以检测并显示网络信息*/

       dm9000_schedule_poll(db);

 

       return 0;

}

 

关闭网卡设备函数dm9000_stop：

static int

dm9000_stop(struct net_device *ndev)

{

       board_info_t*db = netdev_priv(ndev);

 

       if(netif_msg_ifdown(db))

              dev_dbg(db->dev,"shutting down %s\n", ndev->name);

       //终止phy_poll队列中被延迟的任务

       cancel_delayed_work_sync(&db->phy_poll);

       //关闭发送队列

       netif_stop_queue(ndev);

       //载波丢失

       netif_carrier_off(ndev);

 

       /*free interrupt */

       free_irq(ndev->irq,ndev);            //释放中断

 

       dm9000_shutdown(ndev);            //关闭网卡

 

       return0;

}

 

发送数据函数dm9000_start_xmit：

static int

dm9000_start_xmit(struct sk_buff *skb,struct net_device *dev)

{

       unsignedlong flags;

       board_info_t*db = netdev_priv(dev);

 

       dm9000_dbg(db,3, "%s:\n", __func__);

 

       if(db->tx_pkt_cnt > 1)

              returnNETDEV_TX_BUSY;

       //获得自旋锁

       spin_lock_irqsave(&db->lock,flags);

 

       /*Move data to DM9000 TX RAM */

       //根据io操作数据宽度，来设置MWCMD，即填充数据完毕后指针加1还是加2

       writeb(DM9000_MWCMD,db->io_addr);

       //将数据从sk_buff中复制到DM9000内部发送RAM（TX_Buffer）中

       (db->outblk)(db->io_data,skb->data, skb->len);

       dev->stats.tx_bytes +=skb->len;          //统计发送的字节数

 

       db->tx_pkt_cnt++;        //发送计数

       /*TX control: First packet immediately send, second packet queue */

       if(db->tx_pkt_cnt == 1) {

              //计数值为1，立即发送

              dm9000_send_packet(dev,skb->ip_summed, skb->len);

       } else {

              /* Secondpacket */

              //如果是第2个数据包，加入队列以后，停止发送

              db->queue_pkt_len= skb->len;

              db->queue_ip_summed= skb->ip_summed;

              netif_stop_queue(dev);         

       }

       //解自旋锁

       spin_unlock_irqrestore(&db->lock,flags);

 

       /*free this SKB */

       dev_kfree_skb(skb);

 

       returnNETDEV_TX_OK;

}

 

dm9000_start_xmit函数只负责发送一个数据包，那么如何发送第二个数据包呢？网卡又如何接收数据呢？还记得在dm9000_open函数内，申请了一个中断，中断函数为dm9000_interrupt，该中断就是负责接收数据和发送多个数据包的任务：

static irqreturn_t dm9000_interrupt(intirq, void *dev_id)

{

       struct net_device *dev = dev_id;

       board_info_t *db = netdev_priv(dev);

       int int_status;

       unsigned long flags;

       u8 reg_save;

 

       dm9000_dbg(db, 3, "entering%s\n", __func__);

 

       /* A realinterrupt coming */

 

       /*holders of db->lock must always block IRQs */

       //获取自旋锁

       spin_lock_irqsave(&db->lock,flags);

 

       /*Save previous register address */

       //保存以前的寄存器地址

       reg_save= readb(db->io_addr);

 

       /*Disable all interrupts */

       //禁止所有中断

       iow(db,DM9000_IMR, IMR_PAR);

 

       /*Got DM9000 interrupt status */

       //得到中断状态，即是何种原因引起的中断

       int_status= ior(db, DM9000_ISR);      /* Got ISR */

       iow(db,DM9000_ISR, int_status);       /* ClearISR status */

 

       if(netif_msg_intr(db))

              dev_dbg(db->dev,"interrupt status %02x\n", int_status);

 

       /*Received the coming packet */

       //该中断为接收数据中断

       if(int_status & ISR_PRS)

              dm9000_rx(dev);

 

       /*Trnasmit Interrupt check */

       //该中断为发送数据结束中断

       if(int_status & ISR_PTS)

              dm9000_tx_done(dev,db);

 

       if(db->type != TYPE_DM9000E) {

              if(int_status & ISR_LNKCHNG) {

                     /*fire a link-change request */

                     schedule_delayed_work(&db->phy_poll,1);

              }

       }

 

       /*Re-enable interrupt mask */

       //开启中断

       iow(db,DM9000_IMR, db->imr_all);

 

       /*Restore previous register address */

       writeb(reg_save,db->io_addr);

 

       spin_unlock_irqrestore(&db->lock,flags);

 

       returnIRQ_HANDLED;

}

 

从上面函数的分析可以看出，当是接收数据触发的中断时，会调用dm9000_rx函数来接收数据，然后调用netif_rx函数把数据传输到上层网络协议中；而当一个数据包发送完毕后也会触发该中断，并调用dm9000_tx_done函数。在该函数内，如果判断还有待发送的数据则调用执行dm9000_send_packet函数再次发送数据。例如我们要发送两个数据包，则首先调用dm9000_start_xmit函数发送第一个数据包，当发送完毕后触发中断dm9000_interrupt，并调用dm9000_tx_done函数发送第二个数据包，至此两个数据包都发送了出去。