mini2440 dm9000 网卡驱动详解 (三)

mini2440 dm9000 网卡驱动详解 (三)

*dm9000_get_drvinfo()

 

    该函数去的设备的基本信息(设备名,版本,总线名)传给ethtool_drvinfo结构体变量。代码清单如下:

 

 

[cpp]  view plain copy
  1. static void dm9000_get_drvinfo(struct net_device *dev,      
  2.                    struct ethtool_drvinfo *info)      
  3. {      
  4.     board_info_t *dm = to_dm9000_board(dev); /*to_dm9000_board实际上就是调用了netdev_priv(dev)*/     
  5.      
  6.     strcpy(info->driver, CARDNAME);      
  7.     strcpy(info->version, DRV_VERSION);      
  8.     strcpy(info->bus_info, to_platform_device(dm->dev)->name);      
  9. }    

   *dm9000_get_settings()

 

    该函数得到由参数cmd指定的设置信息。

 

   *dm9000_set_settings()

 

    该函数设置由参数cmd指定的信息。

 

   *dm9000_get_msglevel()

 

   *dm9000_set_msglevel()

 

    这两个函数设置和取得messagelevel,实际是设置和取得board_info中的msg_enable信息。

 

   *dm9000_nway_reset()

 

    重启mii的自动协商

 

   *dm9000_get_link()

 

    该函数的到link状态。如果带外部PHY,则返回mii链接状态。 否则返回DM9000 NSR寄存器数值。

 

   *dm9000_get_eeprom_len()

     dm9000_get_eeprom()

     dm9000_set_eeprom()

 

    这三个函数用来读写eeprom。

5. 与数据传输有关的函数。

 

     上面已经分析了一个与数据传输有关的函数,那就是发送数据的函数dm9000_start_xmit()。这里再来分析数据的接收。再看具体代码之前还是来看看DM9000的数据接收的过程。

 

 

     接收的数据存储在RX SRAM中,地址是0C00h~3FFFh。存储在RX_SRAM中的每个包都有4个字节的信息头。可以使用MRCMDX和MRCMD寄存器来得到这些信息。第一个字节用来检查数据包是否接收到了RX_SRAM中,如果这个字节是"01",意味着一个包已经接收。如果是"00",则还没有数据包被接收到RX_SRAM中。第二个字节保存接收到的数据包的信息,格式和RSR寄存器一样。根据这个格式,接收到的包能被校验是正确的还是错误的包。第三和第四字节保存了接收的数据包的长度。这四个字节以外的其他字节就是接收包的数据。看下图可以更好的理解这种格式。

根据包的结构可以知道接收一个包应该按照下面的步骤来进行:

 

第一步:判断包是否已经接收过来了。需要用到MRCMDX寄存器。MRCMDX寄存器是存储数据读命令寄存器(地址不增加)。这个寄存器只是用来读接收包标志位"01"。下面这段代码是一个例子,用来判断RX ready:

[cpp]  view plain copy
  1. u8 RX_ready = ior( IOaddr, 0xF0 );         /* dummy read the packet ready flag */     
  2. RX_ready = (u8) inp( IOaddr + 4 );         /* got the most updated data */     
  3. if ( RX_ready == 1 ) {                     /* ready check: this byte must be 0 or 1 */     
  4.        /* check the RX status and to get RX length (see datasheet ch.5.6.3) */     
  5.        /* income RX a packet (see datasheet ch.5.6.4) */     
  6. else if ( RX_ready != 0 ) {              /* stop device and wait to reset device */     
  7.        iow( IOaddr, 0xFF, 0x80 );          /* stop INT request */     
  8.        iow( IOaddr, 0xFE, 0x0F );          /* clear ISR status */     
  9.        iow( IOaddr, 0x05, 0x00 );          /* stop RX function */     
  10.        u8 device_wait_reset = TRUE;        /* raise the reset flag */     
  11. }    

 第二步:检查包的状态和长度。需要用到MRCMD寄存器(存储数据读命令,读指针自动增加)。下面这段例子代码用来读RX状态和长度。

 

[cpp]  view plain copy
  1. u8 io_mode = ior( IOaddr, 0xFE ) >> 6; /* ISR bit[7:6] keep I/O mode */     
  2. outp( IOaddr, 0xF2 );                /* trigger MRCMD reg_F2h with read_ptr++ */     
  3. /* int RX_status : the RX packet status, int RX_length : the RX packet length */     
  4. if ( io_mode == 2 ) {                /* I/O byte mode */     
  5. RX_status = inp( IOaddr + 4 ) + ( inp( IOaddr + 4 ) << 8 );      
  6. RX_length = inp( IOaddr + 4 ) + ( inp( IOaddr + 4 ) << 8 );        }      
  7. else if ( io_mode == 0 ) {           /* I/O word mode */     
  8. RX_status = inpw( IOaddr + 4 );      
  9. RX_length = inpw( IOaddr + 4 );             }      
  10. else if ( io_mode == 1 ) {           /* I/O dword mode */     
  11. (u32) status_tmp = inpl( IOaddr + 4 );           /* got the RX 32-bit dword data */     
  12. RX_status = (u16)( status_tmp & 0xFFFF );      
  13. RX_length = (u16)( ( status_tmp >> 16 ) & 0xFFFF );          }    

第三步:读包的数据。也需要MRCMD寄存器。例子代码如下:

[cpp]  view plain copy
  1. /* u8 RX_data[] : the data of the received packet */     
  2. if ( io_mode == 2 ) {                 /* I/O byte mode */     
  3. for ( i = 0 ; i < RX_length ; i++ ) /* loop to read a byte data from RX SRAM */     
  4.   RX_data[ i ] = (u8) inp( IOaddr + 4 );          }      
  5. else if ( io_mode == 0 ) {            /* I/O word mode */     
  6. int length_tmp = ( RX_length + 1 ) / 2;      
  7. for ( i = 0 ; i < length_tmp ; i++ ) /* loop to read a word data from RX SRAM */     
  8.  ( (u16 *)RX_data)[ i ] = inpw( IOaddr + 4 );           }      
  9. else if ( io_mode == 1 ) {            /* I/O dword mode */     
  10. int length_tmp = ( RX_length + 3 ) / 4;      
  11. for ( i = 0 ; i < length_tmp ; i++ ) /* loop to read a dword data from RX SRAM */     
  12.  ( (u32 *)RX_data)[ i ] = inpl( IOaddr + 4 ); }         /* inpl() is inport 32-bit I/O */    

下面的dm9000_rx()函数实际上是按照上面这三个步骤来实现的,具体实现并不一定是要参照例子代码。注意这里按照DM9000接收包的格式定义了一个结构体dm9000_rxhdr用来表示头部的四个字节。代码清单如下:

 

[cpp]  view plain copy
  1. struct dm9000_rxhdr {      
  2.     u8  RxPktReady;      
  3.     u8  RxStatus;      
  4.     __le16  RxLen;      
  5. } __attribute__((__packed__));    

接收函数代码如下:

 

[cpp]  view plain copy
  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.      
  14.     /* Check packet ready or not */     
  15.     do {      
  16.         ior(db, DM9000_MRCMDX); /* Dummy read */     
  17.      
  18.         /* Get most updated data */     
  19.                 /*读一下最新数据的第一个字节*/     
  20.         rxbyte = readb(db->io_data);      
  21.      
  22.         /* Status check: this byte must be 0 or 1 */     
  23.                 /*DM9000_PKT_RDY定义是0x01,如果第一个字节大于0x01,则不是正确的状态。因为第一个字节只能是01h或00h*/     
  24.         if (rxbyte > DM9000_PKT_RDY) {      
  25.             dev_warn(db->dev, "status check fail: %d\n", rxbyte);      
  26.             iow(db, DM9000_RCR, 0x00);  /* Stop Device */     
  27.             iow(db, DM9000_ISR, IMR_PAR);   /* Stop INT request */     
  28.             return;      
  29.         }      
  30.      
  31.         if (rxbyte != DM9000_PKT_RDY)      
  32.             return;      
  33.      
  34.         /* A packet ready now  & Get status/length */     
  35.         GoodPacket = true;      
  36.         writeb(DM9000_MRCMD, db->io_addr);      
  37.      
  38.         (db->inblk)(db->io_data, &rxhdr, sizeof(rxhdr));/*一次性读入四个字节的内容到rxhdr变量*/     
  39.      
  40.         RxLen = le16_to_cpu(rxhdr.RxLen);      
  41.      
  42.         if (netif_msg_rx_status(db))      
  43.             dev_dbg(db->dev, "RX: status %02x, length %04x\n",      
  44.                 rxhdr.RxStatus, RxLen);      
  45.      
  46.         /* Packet Status check */     
  47.         if (RxLen < 0x40) {      
  48.             GoodPacket = false;      
  49.             if (netif_msg_rx_err(db))      
  50.                 dev_dbg(db->dev, "RX: Bad Packet (runt)\n");      
  51.         }      
  52.      
  53.         if (RxLen > DM9000_PKT_MAX) {      
  54.             dev_dbg(db->dev, "RST: RX Len:%x\n", RxLen);      
  55.         }      
  56.      
  57.         /* rxhdr.RxStatus is identical to RSR register. */     
  58.         if (rxhdr.RxStatus & (RSR_FOE | RSR_CE | RSR_AE |      
  59.                       RSR_PLE | RSR_RWTO |      
  60.                       RSR_LCS | RSR_RF)) {      
  61.             GoodPacket = false;      
  62.             if (rxhdr.RxStatus & RSR_FOE) {      
  63.                 if (netif_msg_rx_err(db))      
  64.                     dev_dbg(db->dev, "fifo error\n");      
  65.                 dev->stats.rx_fifo_errors++;      
  66.             }      
  67.             if (rxhdr.RxStatus & RSR_CE) {      
  68.                 if (netif_msg_rx_err(db))      
  69.                     dev_dbg(db->dev, "crc error\n");      
  70.                 dev->stats.rx_crc_errors++;      
  71.             }      
  72.             if (rxhdr.RxStatus & RSR_RF) {      
  73.                 if (netif_msg_rx_err(db))      
  74.                     dev_dbg(db->dev, "length error\n");      
  75.                 dev->stats.rx_length_errors++;      
  76.             }      
  77.         }      
  78.      
  79.         /* Move data from DM9000 */     
  80.                 /*关键的代码就是这里啦。使用到了上面提到的sk_buff。将RX SRAM中的data段数据放入sk_buff,然后发送给上层,至于怎么发送,不用去驱动操心了。sk_buff的protocol全部搞定*/     
  81.         if (GoodPacket      
  82.             && ((skb = dev_alloc_skb(RxLen + 4)) != NULL)) {      
  83.             skb_reserve(skb, 2);      
  84.             rdptr = (u8 *) skb_put(skb, RxLen - 4);      
  85.      
  86.             /* Read received packet from RX SRAM */     
  87.      
  88.             (db->inblk)(db->io_data, rdptr, RxLen);      
  89.             dev->stats.rx_bytes += RxLen;      
  90.      
  91.             /* Pass to upper layer */     
  92.             skb->protocol = eth_type_trans(skb, dev);      
  93.             netif_rx(skb);      
  94.             dev->stats.rx_packets++;      
  95.      
  96.         } else {      
  97.             /* need to dump the packet's data */     
  98.      
  99.             (db->dumpblk)(db->io_data, RxLen);      
  100.         }      
  101.     } while (rxbyte == DM9000_PKT_RDY);      
  102. }    

6. 中断处理相关函数

 

  DM9000的驱动程序采用了中断方式而非轮询方式。触发中断的时机发生在:1)DM9000接收到一个包以后。2)DM9000发送完了一个包以后。

 

   中断处理函数在open的时候被注册进内核。代码清单如下:

 

[cpp]  view plain copy
  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;      
  8.      
  9.     dm9000_dbg(db, 3, "entering %s\n", __func__);      
  10.      
  11.     /* A real interrupt coming */     
  12.      
  13.     /* holders of db->lock must always block IRQs */     
  14.     spin_lock_irqsave(&db->lock, flags);      
  15.      
  16.     /* Save previous register address */     
  17.     reg_save = readb(db->io_addr);      
  18.      
  19.     /* Disable all interrupts */     
  20.     iow(db, DM9000_IMR, IMR_PAR);      
  21.      
  22.     /* Got DM9000 interrupt status */     
  23.     int_status = ior(db, DM9000_ISR);   /* Got ISR */     
  24.     iow(db, DM9000_ISR, int_status);    /* Clear ISR status */     
  25.      
  26.     if (netif_msg_intr(db))      
  27.         dev_dbg(db->dev, "interrupt status %02x\n", int_status);      
  28.      
  29.     /* Received the coming packet */     
  30.         /*如果是由于收到数据而触发的中断,显然调用dm9000_rx()把数据取走,传递给上层*/     
  31.     if (int_status & ISR_PRS)      
  32.         dm9000_rx(dev);      
  33.      
  34.     /* Trnasmit Interrupt check */     
  35.         /*如果是由于发送完了数据而触发的中断,则调用dm9000_tx_done()函数,下面具体分析这个函数*/     
  36.     if (int_status & ISR_PTS)      
  37.         dm9000_tx_done(dev, db);      
  38.      
  39.     if (db->type != TYPE_DM9000E) {      
  40.         if (int_status & ISR_LNKCHNG) {      
  41.             /* fire a link-change request */     
  42.             schedule_delayed_work(&db->phy_poll, 1);      
  43.         }      
  44.     }      
  45.      
  46.     /* Re-enable interrupt mask */     
  47.     iow(db, DM9000_IMR, db->imr_all);      
  48.      
  49.     /* Restore previous register address */     
  50.     writeb(reg_save, db->io_addr);      
  51.      
  52.     spin_unlock_irqrestore(&db->lock, flags);      
  53.      
  54.     return IRQ_HANDLED;      
  55. }    

*dm9000_tx_done()

 

   注:dm9000可以发送两个数据包,当发送一个数据包产生中断后,要确认一下队列中有没有第2个包需要发送。

 

 

 

    (1)读取dm9000寄存器NSR(NetworkStatus Register)获取发送的状态,存在变量tx_status中;

 

    (2)如果发送状态为NSR_TX2END(第2个包发送完毕)或者NSR_TX1END(第1个包发送完毕),则将待发送的数据包数量(db-> tx_pkt_cnt )减1,已发送的数据包数量(dev->stats.tx_packets)加1;

 

    (3)检查变量db->tx_pkt_cnt(待发送的数据包)是否大于0(表明还有数据包要发送),则调用函数dm9000_send_packet发送队列中的数据包;

 

    (4)调用函数netif_wake_queue(dev)通知内核可以将待发送的数据包进入发送队列。

 

[cpp]  view plain copy
  1. /*    
  2.  * DM9000 interrupt handler    
  3.  * receive the packet to upper layer, free the transmitted packet    
  4.  */     
  5.      
  6. static void dm9000_tx_done(struct net_device *dev, board_info_t *db)      
  7. {      
  8.     int tx_status = ior(db, DM9000_NSR);    /* Got TX status */     
  9.      
  10.     if (tx_status & (NSR_TX2END | NSR_TX1END)) {      
  11.         /* One packet sent complete */     
  12.         db->tx_pkt_cnt--;      
  13.         dev->stats.tx_packets++;      
  14.      
  15.         if (netif_msg_tx_done(db))      
  16.             dev_dbg(db->dev, "tx done, NSR %02x\n", tx_status);      
  17.      
  18.         /* Queue packet check & send */     
  19.         if (db->tx_pkt_cnt > 0) {      
  20.             iow(db, DM9000_TXPLL, db->queue_pkt_len);      
  21.             iow(db, DM9000_TXPLH, db->queue_pkt_len >> 8);      
  22.             iow(db, DM9000_TCR, TCR_TXREQ);      
  23.             dev->trans_start = jiffies;      
  24.         }      
  25.         netif_wake_queue(dev);      
  26.     }      
  27. }    

   7.一些操作硬件细节的函数。

 

   在看函数之前还是先来看一下DM9000CMD Pin 和Processor并行总线的连接关系。CMD管脚用来设置命令类型。当CMD管脚拉高时,这个命令周期访问DATA_PORT。如果拉低, 则这个命令周期访问ADDR_PORT。见下图:

当然,内存映射的I/O空间读写还是采用最基本的readb(), readw(), readl(), writeb(), writew(), writel() , readsb(),readsw(), readsl(), writesb(), writesw(), writesl() 。

 

在DM9000的驱动中还自定义了几个函数,方便操作。

 

    * ior()

 

       从IO端口读一个字节。代码清单如下:

[cpp]  view plain copy
  1. static u8 ior(board_info_t * db, int reg)      
  2. {      
  3.     writeb(reg, db->io_addr); /*写reg到ADDR_PORT,用来选择寄存器*/     
  4.     return readb(db->io_data); /*从DATA_PORT读一个字节,用来读寄存器*/     
  5. }    
  6.   
  7.     * iow()  
  8.   
  9.         向IO端口写一个字节。代码清单如下:  
  10.   
  11. /*    
  12.  *   Write a byte to I/O port    
  13.  */     
  14.      
  15. static void     
  16. iow(board_info_t * db, int reg, int value)      
  17. {      
  18.     writeb(reg, db->io_addr);      
  19.     writeb(value, db->io_data);      
  20. }    

此外还有dm9000_outblk_8bit(), dm9000_outblk_16bit(), dm9000_outblk_32bit(),dm9000_inblk_8bit(), dm9000_inblk_16bit(), dm9000_inblk_32bit()等等。不一一解释。

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页