Linux设备驱动工程师之路——DM9000网卡驱动程序分析(3)

5.接收数据

1. /*
    *  Received a packet and pass to upper layer
    */
2. static void  
3. dm9000_rx(struct net_device *dev)  
4. {  
5.     board_info_t *db = netdev_priv(dev);  
6.     struct dm9000_rxhdr rxhdr;  
7.     struct sk_buff *skb;  
8.     u8 rxbyte, *rdptr;  
9.     bool GoodPacket;  
10.     int RxLen;  
11.   
12.     /* Check packet ready or not */  
13.     do {  
14.         ior(db, DM9000_MRCMDX); /* Dummy read */  
15.   
16.         //获取接收数据的长度  
17.         /* Get most updated data */  
18.         rxbyte = readb(db->io_data);  
19.   
20.         //检查设备接收状态  
21.         /* Status check: this byte must be 0 or 1 */  
22.         if (rxbyte > DM9000_PKT_RDY) {  
23.             dev_warn(db->dev, "status check fail: %d\n", rxbyte);  
24.             iow(db, DM9000_RCR, 0x00);  /* Stop Device */  
25.             iow(db, DM9000_ISR, IMR_PAR);   /* Stop INT request */  
26.             return;  
27.         }  
28.   
29.         if (rxbyte != DM9000_PKT_RDY)  
30.             return;  
31.   
32.           
33.         /* A packet ready now  & Get status/length */  
34.         GoodPacket = true;  
35.         writeb(DM9000_MRCMD, db->io_addr);  
36.   
37.         (db->inblk)(db->io_data, &rxhdr, sizeof(rxhdr));  
38.   
39.         RxLen = le16_to_cpu(rxhdr.RxLen);  
40.   
41.         if (netif_msg_rx_status(db))  
42.             dev_dbg(db->dev, "RX: status %02x, length %04x\n",  
43.                 rxhdr.RxStatus, RxLen);  
44.   
45.         /* Packet Status check */  
46.         if (RxLen < 0x40) {  
47.             GoodPacket = false;  
48.             if (netif_msg_rx_err(db))  
49.                 dev_dbg(db->dev, "RX: Bad Packet (runt)\n");  
50.         }  
51.   
52.         if (RxLen > DM9000_PKT_MAX) {  
53.             dev_dbg(db->dev, "RST: RX Len:%x\n", RxLen);  
54.         }  
55.   
56.         /* rxhdr.RxStatus is identical to RSR register. */  
57.         if (rxhdr.RxStatus & (RSR_FOE | RSR_CE | RSR_AE |  
58.                       RSR_PLE | RSR_RWTO |  
59.                       RSR_LCS | RSR_RF)) {  
60.             GoodPacket = false;  
61.             if (rxhdr.RxStatus & RSR_FOE) {  
62.                 if (netif_msg_rx_err(db))  
63.                     dev_dbg(db->dev, "fifo error\n");  
64.                 dev->stats.rx_fifo_errors++;  
65.             }  
66.             if (rxhdr.RxStatus & RSR_CE) {  
67.                 if (netif_msg_rx_err(db))  
68.                     dev_dbg(db->dev, "crc error\n");  
69.                 dev->stats.rx_crc_errors++;  
70.             }  
71.             if (rxhdr.RxStatus & RSR_RF) {  
72.                 if (netif_msg_rx_err(db))  
73.                     dev_dbg(db->dev, "length error\n");  
74.                 dev->stats.rx_length_errors++;  
75.             }  
76.         }  
77.   
78.         /* Move data from DM9000 */  
79.         //如果接收正确，开始接收  
80.         if (GoodPacket  
81.             && ((skb = dev_alloc_skb(RxLen + 4)) != NULL)) {  
82.             skb_reserve(skb, 2);  
83.             rdptr = (u8 *) skb_put(skb, RxLen - 4);//获取skb的数据指针  
84.   
85.             /* Read received packet from RX SRAM */  
86.   
87.             (db->inblk)(db->io_data, rdptr, RxLen);//读取数据  
88.             dev->stats.rx_bytes += RxLen;  
89.   
90.             /* Pass to upper layer */  
91.             skb->protocol = eth_type_trans(skb, dev);  
92.             netif_rx(skb);//将接收到的skb交给协议层  
93.             dev->stats.rx_packets++;  
94.   
95.         } else {  
96.             /* need to dump the packet's data */  
97.   
98.             (db->dumpblk)(db->io_data, RxLen);  
99.         }  
100.     } while (rxbyte == DM9000_PKT_RDY);  
101. }  

6.发送完成

1. /*
    * DM9000 interrupt handler
    * receive the packet to upper layer, free the transmitted packet
    */
   
2. static void dm9000_tx_done(struct net_device *dev, board_info_t *db)  
3. {  
4.     int tx_status = ior(db, DM9000_NSR);    /* Got TX status */  
5.   
6.     if (tx_status & (NSR_TX2END | NSR_TX1END)) {  
7.         /* One packet sent complete */  
8.   
9.         //将数据包计数减1  
10.         db->tx_pkt_cnt--;  
11.         dev->stats.tx_packets++;  
12.   
13.         if (netif_msg_tx_done(db))  
14.             dev_dbg(db->dev, "tx done, NSR %02x\n", tx_status);  
15.   
16.         /* Queue packet check & send */  
17.         //如果数据包数量依然大于0，说明是TX RAM中的第二个包，再次启动发送，将TX RAM中第二个包发送出去  
18.         if (db->tx_pkt_cnt > 0) {  
19.           /*把数据的长度填到TXPLL(发送包长度低字节)和TXPLH(发送包长度高字节)中*/    
20.         iow(db, DM9000_TXPLL, skb->len);    
21.         iow(db, DM9000_TXPLH, skb->len >> 8);    
22.         /*置发送控制寄存器(TX Control Register)的发送请求位TXREQ(Auto clears after sending completely)，这样就可以发送出去了*/   
23.             dev->trans_start = jiffies;  
24.         }  
25.         netif_wake_queue(dev);//唤醒发送队列  
26.     }  
27. }  

7.超时处理

1. static void dm9000_timeout(struct net_device *dev)  
2. {  
3.     board_info_t *db = netdev_priv(dev);  
4.     u8 reg_save;  
5.     unsigned long flags;  
6.   
7.     /* Save previous register address */  
8.     reg_save = readb(db->io_addr);  
9.     spin_lock_irqsave(&db->lock, flags);  
10.   
11.     //停止发送队列并复位DM9000网卡  
12.     netif_stop_queue(dev);  
13.     dm9000_reset(db);  
14.     dm9000_init_dm9000(dev);  
15.     /* We can accept TX packets again */  
16.   
17.     //重新发送  
18.     dev->trans_start = jiffies;  
19.     netif_wake_queue(dev);  
20.   
21.     /* Restore previous register address */  
22.     writeb(reg_save, db->io_addr);  
23.     spin_unlock_irqrestore(&db->lock, flags);  
24. }