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命令，則：

[[email protected] /]#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函式傳送第二個資料包，至此兩個資料包都發送了出去。