zoukankan      html  css  js  c++  java

  • 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. }









    无欲速，无见小利。欲速，则不达；见小利，则大事不成。
  • 相关阅读:
    USACO提交方法
    洛谷 P1967 【货车运输】
    一本通 P1386 【打击犯罪】
    洛谷 P5767 【最优乘车】
    洛谷 P5658 【括号树】
    洛谷 P5657 【格雷码】
    洛谷 P2272 【最大半连通子图】
    二分图匈牙利算法
    最小生成树Kruskal算法
    觉得写出了抽象类和接口，以及概括了设计模式的宗旨
  • 原文地址：https://www.cnblogs.com/ch122633/p/7363302.html
Copyright © 2011-2022 走看看