DM9000网卡驱动深度分析

一、dm9000_porbe函数分析
不同于u-boot代码，tq2440中的DM9000更加复杂，需要分析的点也很多：
  1. /*
  2.  * Search DM9000 board, allocate space and register it
  3.  */
  4. static int __devinit
  5. dm9000_probe(struct platform_device *pdev)
  6. {
  7.     struct dm9000_plat_data *pdata = pdev->dev.platform_data;
  8.     struct board_info *db;    /* Point a board information structure */
  9.     struct net_device *ndev;
  10.     const unsigned char *mac_src;
  11.     int ret = 0;
  12.     int iosize;
  13.     int i;
  14.     u32 id_val;

  16. #if defined(CONFIG_ARCH_S3C2410)
  17.     unsigned int oldval_bwscon = *(volatile unsigned int *)S3C2410_BWSCON;
  18.     unsigned int oldval_bankcon4 = *(volatile unsigned int *)S3C2410_BANKCON4;
  19. #endif

  21.     /* Init network device */
  22.     ndev = alloc_etherdev(sizeof(struct board_info));                                     //分配netdev结构
  23.     if (!ndev) {
  24.         dev_err(&pdev->dev, "could not allocate device. ");
  25.         return -ENOMEM;
  26.     }

  28.     SET_NETDEV_DEV(ndev, &pdev->dev);

  30.     dev_dbg(&pdev->dev, "dm9000_probe() ");                     //不管

  32. #if defined(CONFIG_ARCH_S3C2410)                                 //2410可以不管
  33. //    *((volatile unsigned int *)S3C2410_BWSCON) = (oldval_bwscon & ~(3<<16)) | S3C2410_BWSCON_DW4_16 | S3C2410_BWSCON_WS4 | S3C2410_BWSCON_ST4;
  34.     *((volatile unsigned int *)S3C2410_BWSCON) = (oldval_bwscon & ~(3<<16)) | S3C2410_BWSCON_DW4_16 ;
  35.     *((volatile unsigned int *)S3C2410_BANKCON4) = 0x1f7c;
  36. #endif

  38.     /* setup board info structure */
  39.     db = netdev_priv(ndev);
  40.     memset(db, 0, sizeof(*db));

  42.     db->dev = &pdev->dev;
  43.     db->ndev = ndev;

  45.     spin_lock_init(&db->lock);
  46.     mutex_init(&db->addr_lock);

  48.     INIT_DELAYED_WORK(&db->phy_poll, dm9000_poll_work);

  50.     db->addr_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);                  //获取平台资源，对应的platform_driver
  51.     db->data_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
  52.     db->irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
  53.    
  54.    ..................
  55. }
从这里可以引出之前的知识点：平台设备和平台驱动的相关知识。在dm9000.c中有：
  1. static struct platform_driver dm9000_driver = {
  2.     .driver    = {
  3.         .name = "dm9000",                                                //这个平台驱动通过name和tq2440中的dm9000的驱动设备结构对接
  4.         .owner     = THIS_MODULE,
  5.     },
  6.     .probe = dm9000_probe,
  7.     .remove = __devexit_p(dm9000_drv_remove),
  8.     .suspend = dm9000_drv_suspend,
  9.     .resume = dm9000_drv_resume,
  10. };
在arch/arm/mach-tq2440.c:
  1. struct platform_device s3c_device_dm9000 = {
  2.     .name        = "dm9000",                                          //这里有同样的name来实现
  3.     .id            = 0,
  4.     .num_resources    = ARRAY_SIZE(s3c_dm9k_resource),
  5.     .resource        = s3c_dm9k_resource,                             //这里保存着dm9000硬件的资源
  6.     .dev            = {
  7.         .platform_data = &s3c_dm9k_platdata,
  8.     }
  9. };
同样在此文件中：
  1. static struct resource s3c_dm9k_resource[] = {
  2.     [0] = {                                               //用的片选4
  3.         .start    = S3C2410_CS4,                          //这里的起始地址是0x20000000和网上一些0x20000300不一样。wu'suo
  4.         .end    = S3C2410_CS4 + 3,                        //.end为什么尾地址是+3?因为一个地址需要四个字节。这是根据网卡来定义的
  5.         .flags    = IORESOURCE_MEM,
  6.     },
  7.     [1] = {                                               //0x20000004~0x20000007?
  8.         .start    = S3C2410_CS4 + 4,                      //这里的4意味着地址线2等于1，设置了cmd为高位，是数据内容
  9.         .end    = S3C2410_CS4 + 4 + 3,
  10.         .flags    = IORESOURCE_MEM,
  11.     },
  12.     [2] = {
  13.         .start    = IRQ_EINT7,                            //对应的中断信息
  14.         .end    = IRQ_EINT7,
  15.         .flags    = IORESOURCE_IRQ | IRQF_TRIGGER_RISING,
  16.     }

  18. };
回来继续看dm9000.c中的probe函数：
  1.     db->addr_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  2.     db->data_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
  3.     db->irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);

  5.     if (db->addr_res == NULL || db->data_res == NULL ||
  6.      db->irq_res == NULL) {
  7.         dev_err(db->dev, "insufficient resources ");
  8.         ret = -ENOENT;
  9.         goto out;
  10.     }

  12.     iosize = res_size(db->addr_res);
  13.     db->addr_req = request_mem_region(db->addr_res->start, iosize,
  14.                      pdev->name);

  16.     if (db->addr_req == NULL) {
  17.         dev_err(db->dev, "cannot claim address reg area ");
  18.         ret = -EIO;
  19.         goto out;
  20.     }

  22.     db->io_addr = ioremap(db->addr_res->start, iosize);                    //将地址信息重映射

  24.     if (db->io_addr == NULL) {
  25.         dev_err(db->dev, "failed to ioremap address reg ");
  26.         ret = -EINVAL;
  27.         goto out;
  28.     }

  30.     iosize = res_size(db->data_res);
  31.     db->data_req = request_mem_region(db->data_res->start, iosize,
  32.                      pdev->name);

  34.     if (db->data_req == NULL) {
  35.         dev_err(db->dev, "cannot claim data reg area ");
  36.         ret = -EIO;
  37.         goto out;
  38.     }

  40.     db->io_data = ioremap(db->data_res->start, iosize);               //将数据信息重映射

  42.     if (db->io_data == NULL) {
  43.         dev_err(db->dev, "failed to ioremap data reg ");
  44.         ret = -EINVAL;
  45.         goto out;
  46.     }

  48.     .........................

  50.     id_val = ior(db, DM9000_CHIPR);                                    //读取芯片信息
  51. //    dev_dbg(db->dev, "dm9000 revision 0x%02x io_mode %02x ", id_val, db->io_mode);
  52.     printk(KERN_INFO "dm9000 revision 0x%02x io_mode %02x ", id_val, db->io_mode);

  54.     switch (id_val) {
  55.     case CHIPR_DM9000A:
  56.         db->type = TYPE_DM9000A;
  57.         break;
  58.     case CHIPR_DM9000B:
  59.         db->type = TYPE_DM9000B;
  60.         break;
  61.     case CHIPR_DM9000C:
  62.         db->type = TYPE_DM9000C;
  63.         break;
  64.     default:
  65.         dev_dbg(db->dev, "ID %02x => defaulting to DM9000E ", id_val);
  66.         db->type = TYPE_DM9000E;
  67.     }

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

  71.     /* driver system function */                                                //下面在设置dm9000的操作函数集了
  72.     ether_setup(ndev);

  74.     ndev->open         = &dm9000_open;
  75.     ndev->hard_start_xmit = &dm9000_start_xmit;
  76.     ndev->tx_timeout = &dm9000_timeout;
  77.     ndev->watchdog_timeo = msecs_to_jiffies(watchdog);
  78.     ndev->stop         = &dm9000_stop;
  79.     ndev->set_multicast_list = &dm9000_hash_table;
  80.     ndev->ethtool_ops     = &dm9000_ethtool_ops;
  81.     ndev->do_ioctl         = &dm9000_ioctl;

  83. #ifdef CONFIG_NET_POLL_CONTROLLER
  84.     ndev->poll_controller     = &dm9000_poll_controller;
  85. #endif

  87.     db->msg_enable = NETIF_MSG_LINK;
  88.     db->mii.phy_id_mask = 0x1f;
  89.     db->mii.reg_num_mask = 0x1f;
  90.     db->mii.force_media = 0;
  91.     db->mii.full_duplex = 0;
  92.     db->mii.dev     = ndev;
  93.     db->mii.mdio_read = dm9000_phy_read;
  94.     db->mii.mdio_write = dm9000_phy_write;

  96. #if defined(CONFIG_ARCH_S3C2410)
  97.     printk("Now use the default MAC address: 10:23:45:67:89:ab ");
  98.     mac_src = "EmbedSky";
  99.     ndev->dev_addr[0] = 0x10;
  100.     ndev->dev_addr[1] = 0x23;
  101.     ndev->dev_addr[2] = 0x45;
  102.     ndev->dev_addr[3] = 0x67;
  103.     ndev->dev_addr[4] = 0x89;
  104.     ndev->dev_addr[5] = 0xab;
  105. #else
  106.     mac_src = "eeprom";

  108.     /* try reading the node address from the attached EEPROM */         //读取MAC地址，从EEPROM中
  109.     for (i = 0; i < 6; i += 2)
  110.         dm9000_read_eeprom(db, i / 2, ndev->dev_addr+i);

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

  117.     if (!is_valid_ether_addr(ndev->dev_addr)) {
  118.         /* try reading from mac */
  119.         
  120.         mac_src = "chip";
  121.         for (i = 0; i < 6; i++)
  122.             ndev->dev_addr[i] = ior(db, i+DM9000_PAR);
  123.     }

  125.     if (!is_valid_ether_addr(ndev->dev_addr))
  126.         dev_warn(db->dev, "%s: Invalid ethernet MAC address. Please "
  127.              "set using ifconfig ", ndev->name);
  128. #endif

  130.     platform_set_drvdata(pdev, ndev);
  131.     ret = register_netdev(ndev);                                           //注册网卡驱动

  133.     if (ret == 0)
  134.         printk(KERN_INFO "%s: dm9000%c at %p,%p IRQ %d MAC: %pM (%s) ",
  135.          ndev->name, dm9000_type_to_char(db->type),
  136.          db->io_addr, db->io_data, ndev->irq,
  137.          ndev->dev_addr, mac_src);
  138.     return 0;

  140. out:
  141. #if defined(CONFIG_ARCH_S3C2410)
  142.     *(volatile unsigned int *)S3C2410_BWSCON = oldval_bwscon;
  143.     *(volatile unsigned int *)S3C2410_BANKCON4 = oldval_bankcon4;
  144. #endif
  145.     dev_err(db->dev, "not found (%d). ", ret);

  147.     dm9000_release_board(pdev, db);
  148.     free_netdev(ndev);

  150.     return ret;
  151. }
二、DM9000_OPEN函数分析
在probe中没有太多的dm9000的初始化代码，都写在了open中（这个open函数在ifconfig eth0 192.168.1.1时调用）：
  1. /*
  2.  * Open the interface.
  3.  * The interface is opened whenever "ifconfig" actives it.
  4.  */
  5. static int
  6. dm9000_open(struct net_device *dev)
  7. {
  8.     board_info_t *db = netdev_priv(dev);
  9.     unsigned long irqflags = db->irq_res->flags & IRQF_TRIGGER_MASK;

  11.     if (netif_msg_ifup(db))
  12.         dev_dbg(db->dev, "enabling %s ", dev->name);

  14.     /* If there is no IRQ type specified, default to something that
  15.      * may work, and tell the user that this is a problem */

  17.     if (irqflags == IRQF_TRIGGER_NONE)
  18.         dev_warn(db->dev, "WARNING: no IRQ resource flags set. ");

  20.     irqflags |= IRQF_SHARED;

  22.     if (request_irq(dev->irq, &dm9000_interrupt, irqflags, dev->name, dev))                      //注册网卡驱动的中断处理函数
  23.         return -EAGAIN;

  25.     /* Initialize DM9000 board */
  26. //    dm9000_reset(db);
  27.     dm9000_init_dm9000(dev);                                                                     //网卡初始化在这里

  29.     /* Init driver variable */
  30.     db->dbug_cnt = 0;

  32.     mii_check_media(&db->mii, netif_msg_link(db), 1);
  33.     netif_start_queue(dev);                                                                      //启动发送队列
  34.     
  35.     dm9000_schedule_poll(db);

  37.     return 0;
  38. }
DM9000初始化：
①分配net_device结构
②从platform_device中获取地址，中断号
③把获取到的地址映射为虚拟地址
④读取芯片类型
⑤设置操作函数集
⑥注册网卡驱动

三、dm9000_start_xmit发送函数分析
dm9000_start_xmit:
  1. /*
  2.  * Hardware start transmission.
  3.  * Send a packet to media from the upper layer.
  4.  */
  5. static int
  6. dm9000_start_xmit(struct sk_buff *skb, struct net_device *dev)
  7. {
  8.     unsigned long flags;
  9.     board_info_t *db = netdev_priv(dev);
  10.     int save_mwr, check_mwr, calc_mwr;    

  12.     dm9000_dbg(db, 3, "%s: ", __func__);

  14.     if ((db->tx_pkt_cnt > 0) || !netif_carrier_ok(dev))
  15.         return 1;

  17.     spin_lock_irqsave(&db->lock, flags);
  18.     
  19.     netif_stop_queue(dev);                                                                                     //通知协议栈，暂停向驱动传送数据
  20.     db->tx_pkt_cnt++;
  21.     dev->stats.tx_bytes += skb->len;
  22.     dev->stats.tx_packets++;
  23.     
  24.     save_mwr = (ior(db, 0xfb) << 8) | ior(db, 0xfa);
  25.     calc_mwr = save_mwr + skb->len;
  26.     if(skb->len & 0x01) calc_mwr++;
  27.     if(calc_mwr > 0x0bff ) calc_mwr -= 0x0c00;

  29.     /* Set TX length to DM9000 */                                                                              //获取发送长度
  30.     iow(db, DM9000_TXPLL, skb->len);
  31.     iow(db, DM9000_TXPLH, skb->len >> 8);
  32.     
  33.     /* Move data to DM9000 TX RAM */                                                                           //将要发送的数据发送入缓存
  34.     writeb(DM9000_MWCMD, db->io_addr);
  35.     (db->outblk)(db->io_data, skb->data, skb->len);                                                            //skb->data,skb->len分别指向结构体数据的头和尾

  37.     /* Issue TX polling command */
  38.     iow(db, DM9000_TCR, TCR_TXREQ);    /* Cleared after TX complete */                                         //清除发送位

  40.     dev->trans_start = jiffies;    /* save the time stamp */
  41.     
  42.     check_mwr = (ior(db, 0xfb) << 8) | ior(db, 0xfa);
  43.     if(calc_mwr != check_mwr)
  44.     {
  45.         printk(KERN_INFO "TX: fifo error %04x %04x %04x %04x ", save_mwr, skb->len, calc_mwr, check_mwr);
  46.         iow(db, 0xfb, (calc_mwr >> 8) & 0xff);
  47.         iow(db, 0xfa, calc_mwr & 0xff);
  48.     }            

  50.     spin_unlock_irqrestore(&db->lock, flags);

  52.     /* free this SKB */
  53.     dev_kfree_skb(skb);                                                                                          //释放SKB结构

  55.     return 0;
  56. }
发送完成产生中断（dm9000_interrupt）：
  1. static irqreturn_t dm9000_interrupt(int irq, void *dev_id)
  2. {
  3.     struct net_device *dev = dev_id;
  4.     board_info_t *db = netdev_priv(dev);
  5.     int int_status;
  6.     unsigned long flags;
  7.     u8 reg_save;

  9.     dm9000_dbg(db, 3, "entering %s ", __func__);

  11.     /* A real interrupt coming */

  13.     /* holders of db->lock must always block IRQs */
  14.     spin_lock_irqsave(&db->lock, flags);

  16.     /* Save previous register address */
  17.     reg_save = readb(db->io_addr);

  19.     /* Disable all interrupts */
  20.     iow(db, DM9000_IMR, IMR_PAR);

  22.     /* Got DM9000 interrupt status */
  23.     int_status = ior(db, DM9000_ISR);    /* Got ISR */
  24.     iow(db, DM9000_ISR, int_status);    /* Clear ISR status */

  26.     if (netif_msg_intr(db))
  27.         dev_dbg(db->dev, "interrupt status %02x ", int_status);

  29.     /* Received the coming packet */
  30.     if (int_status & ISR_PRS)
  31.         dm9000_rx(dev);                                                               //接收中断
  32.     
  33.     int_status |= ior(db, DM9000_ISR);    /* Got ISR */

  35.     /* Trnasmit Interrupt check */
  36.     if (int_status & ISR_PTS)
  37.     {
  38.         iow(db, DM9000_ISR, ISR_PTS);
  39.         dm9000_tx_done(dev, db);                                                      //发送中断
  40.     }

  42.     if (db->type != TYPE_DM9000E) {
  43.         if (int_status & ISR_LNKCHNG) {
  44.             /* fire a link-change request */
  45.             schedule_delayed_work(&db->phy_poll, 1);
  46.         }
  47.     }

  49.     /* Re-enable interrupt mask */
  50.     iow(db, DM9000_IMR, db->imr_all);

  52.     /* Restore previous register address */
  53.     writeb(reg_save, db->io_addr);

  55.     spin_unlock_irqrestore(&db->lock, flags);

  57.     return IRQ_HANDLED;
  58. }
发送函数完成后进入中断dm9000_tx_done:
  1. /*
  2.  * DM9000 interrupt handler
  3.  * receive the packet to upper layer, free the transmitted packet
  4.  */

  6. static void dm9000_tx_done(struct net_device *dev, board_info_t *db)
  7. {
  8.     int tx_status = ior(db, DM9000_TCR);    /* Got TX status */                           //获取中断状态
  9.     
  10.     if(tx_status & TCR_TXREQ)                                                             //查看发送是否出错    
  11.     {
  12.         dev->stats.rx_fifo_errors++;                                                      //错误计数加1
  13.     }
  14.     else
  15.     {
  16.         db->tx_pkt_cnt = 0;
  17.         dev->trans_start = 0;
  18.         netif_wake_queue(dev);                                                            //调用netif_wake_queue()，通知协议栈发送数据
  19.     }
  20. }
dm9000_rx():
  1. /*
  2.  * Received a packet and pass to upper layer
  3.  */
  4. static void
  5. dm9000_rx(struct net_device *dev)
  6. {
  7.     board_info_t *db = netdev_priv(dev);
  8.     struct dm9000_rxhdr rxhdr;
  9.     struct sk_buff *skb;
  10.     u8 rxbyte, *rdptr;
  11.     bool GoodPacket;
  12.     int RxLen;
  13.     int save_mrr, check_mrr, calc_mrr;

  15.     /* Check packet ready or not */
  16.     do {
  17.         ior(db, DM9000_MRCMDX);    /* Dummy read */                                                     //空读
  18.         save_mrr = (ior(db, 0xf5) << 8) | ior(db, 0xf4);
  19.         /* Get most updated data */
  20.         rxbyte = ior(db, DM9000_MRCMDX);                                                                //查看接收状态
  21.         
  22.         if(DM9000_PKT_RDY != rxbyte)                                                                    //是否已经ready
  23.         {
  24.             /* Status check: this byte must be 0 or 1 */
  25.             if (rxbyte) {
  26. //                dev_warn(db->dev, "status check fail: %d ", rxbyte);
  27.                 printk(KERN_INFO "status check fail: %d ", rxbyte);
  28.                 iow(db, DM9000_RCR, 0x00);    /* Stop Device */
  29.                 iow(db, DM9000_IMR, IMR_PAR);    /* Stop INT request */
  30.                 
  31.                 dm9000_init_dm9000(dev);
  32.             }
  33.             return;
  34.         }

  36.         /* A packet ready now & Get status/length */
  37.         GoodPacket = true;                                                           
  38.         writeb(DM9000_MRCMD, db->io_addr);                                                                //
  39.         (db->inblk)(db->io_data, &rxhdr, sizeof(rxhdr));                                                  //dm9000_rxhdr结构中有rx_len，接收长度

  41.         calc_mrr = save_mrr + 4;
  42.         if(calc_mrr > 0x3fff) calc_mrr -= 0x3400;
  43.         
  44.         check_mrr = (ior(db, 0xf5) << 8) | ior(db, 0xf4);
  45.         if(calc_mrr != check_mrr)
  46.         {
  47.             printk(KERN_INFO "RX: 4 byte error %04x %04x %04x ", save_mrr, calc_mrr, check_mrr);
  48.             iow(db, 0xf5, (save_mrr >> 8) & 0xff);
  49.             iow(db, 0xf4, save_mrr & 0xff);
  50.             continue;
  51.         }
  52.         
  53.         writeb(DM9000_MRCMD, db->io_addr);
  54.         
  55.         RxLen = le16_to_cpu(rxhdr.RxLen);
  56.         
  57.         calc_mrr = save_mrr + 4 + RxLen;
  58.         if(RxLen & 0x01) calc_mrr++;
  59.         if(calc_mrr > 0x3fff) calc_mrr -= 0x3400;

  61.         if (netif_msg_rx_status(db))
  62.             dev_dbg(db->dev, "RX: status %02x, length %04x ",
  63.                 rxhdr.RxStatus, RxLen);

  65.         /* Packet Status check */                                                                     //判断长度
  66.         if (RxLen < 0x40) {
  67.             GoodPacket = false;
  68.             if (netif_msg_rx_err(db))
  69.                 dev_dbg(db->dev, "RX: Bad Packet (runt) ");
  70.         }

  72.         if (RxLen > DM9000_PKT_MAX) {
  73.             dev_dbg(db->dev, "RST: RX Len:%x ", RxLen);
  74.         }

  76.         /* rxhdr.RxStatus is identical to RSR register. */                                             //读取状态看有没有出错
  77.         if (rxhdr.RxStatus & (RSR_FOE | RSR_CE | RSR_AE |
  78.                  RSR_PLE | RSR_RWTO |
  79.                  RSR_LCS | RSR_RF)) {
  80.             GoodPacket = false;
  81.             if (rxhdr.RxStatus & RSR_FOE) {
  82.                 if (netif_msg_rx_err(db))
  83.                     dev_dbg(db->dev, "fifo error ");
  84.                 dev->stats.rx_fifo_errors++;
  85.             }
  86.             if (rxhdr.RxStatus & RSR_CE) {
  87.                 if (netif_msg_rx_err(db))
  88.                     dev_dbg(db->dev, "crc error ");
  89.                 dev->stats.rx_crc_errors++;
  90.             }
  91.             if (rxhdr.RxStatus & RSR_RF) {
  92.                 if (netif_msg_rx_err(db))
  93.                     dev_dbg(db->dev, "length error ");
  94.                 dev->stats.rx_length_errors++;
  95.             }
  96.         }

  98.         /* Move data from DM9000 */                                                                       
  99.         if (GoodPacket
  100.          && ((skb = dev_alloc_skb(RxLen + 4)) != NULL)) {                                                    //分配skb=接收到的数据长度+4
  101.             skb_reserve(skb, 2);                                                                             //skb中的ip包需要4字节对齐，所以skb要保留多2个字节。（以太网包格式）
  102.             rdptr = (u8 *) skb_put(skb, RxLen - 4);                                                          //skb的tail指针，数据包长度减4

  104.             /* Read received packet from RX SRAM */

  106.             (db->inblk)(db->io_data, rdptr, RxLen);                                                          //读取io_data地址到rdptr中
  107.             dev->stats.rx_bytes += RxLen;

  109.             /* Pass to upper layer */
  110.             skb->protocol = eth_type_trans(skb, dev);
  111.             netif_rx(skb);                                                                                   //把准备好的skb提交给上层协议
  112.             dev->stats.rx_packets++;
  113.             
  114.             check_mrr = (ior(db, 0xf5) << 8) | ior(db, 0xf4);
  115.             if(calc_mrr != check_mrr)
  116.             {
  117. //                dev_dbg(db->dev, "RX: fifo error %04x %04x %04x %04x ", save_mrr, RxLen, calc_mrr, check_mrr);
  118.                 printk(KERN_INFO "RX: fifo error %04x %04x %04x %04x ", save_mrr, RxLen, calc_mrr, check_mrr);
  119.                 iow(db, 0xf5, (calc_mrr >> 8) & 0xff);
  120.                 iow(db, 0xf4, calc_mrr & 0xff);
  121.             }            

  123.         } else {
  124.             /* need to dump the packet's data */
  125.             iow(db, 0xf5, (calc_mrr >> 8) & 0xff);
  126.             iow(db, 0xf4, calc_mrr & 0xff);
  127.         }
  128.         
  129.     } while (rxbyte == DM9000_PKT_RDY);
  130. }









无欲速，无见小利。欲速，则不达；见小利，则大事不成。
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/ch122633/p/7363302.html