AR9344中ethernet处理方式分析

http://bbs.chinaunix.net/thread-1960516-1-1.html
9344 ethernet数据接收代码分析
在板的ethernet只有一个网卡，在系统处理话的时候有如下类似代码：
    for(i = 0; i < ATHR_GMAC_NMACS; i++)
    {

        dev = alloc_etherdev(ATHR_MAC_ETHERDEV_SZ);
        if (!dev)
        {
            printk(MODULE_NAME ": unable to allocate mac\n");
            return 1;
        }
        ATHR_MAC_NETPRIV(mac,dev);
        memset(mac, 0, sizeof(athr_gmac_t));

        mac->mac_dev       = dev;
        mac->mac_unit      = i;
        mac->mac_base      = athr_gmac_base(i);
        mac->mac_irq       = athr_gmac_irq(i);//以太网申请的中断号。
        mac->mac_noacs     = 1;
        mac->num_tx_desc   = athr_tx_desc_num[i];
        mac->num_rx_desc   = athr_rx_desc_num[i];
        mac->reap_thresh   = athr_tx_desc_num[i] / 2;
        mac->qstart_thresh = 4 * tx_max_desc_per_ds_pkt;
        mac->mac_speed     = ATHR_PHY_SPEED_UNKNOWN;
       ..............................................
       
     }
在之前的中断处理过程说明过，我们在申请中断之前，必须将中断注册到OS中。
/proc # cat interrupts
           CPU0      
  4:       3604            MIPS  eth0
  6:          0            MIPS  cascade
  7:     737861            MIPS  timer
 18:          0        ATH MISC  cascade
 19:        317        ATH MISC  serial
 48:          0        ATH GPIO  SW JUMPSTART/FACTORY RESET

有上面的可以知道，我们申请的中断号为4，其代码中也有定义#define ATH_CPU_IRQ_GE0 ATH_CPU_IRQ_BASE+4
当收到数据时，会触发中断：其执行如下代码：
asmlinkage void plat_irq_dispatch(void)
{
 int pending = read_c0_status() & read_c0_cause();
#if 0
 if (!(pending & CAUSEF_IP7))
  printk("%s: in irq dispatch \n", __func__);
#endif
 if (pending & CAUSEF_IP7) {
  do_IRQ(ATH_CPU_IRQ_TIMER);
  ath_aphang_timer_fn();
 }
 else if (pending & CAUSEF_IP2)
  ath_dispatch_wlan_intr();

 else if (pending & CAUSEF_IP4) //操作系统调度执行注册的中断处理函数。
  do_IRQ(ATH_CPU_IRQ_GE0);

 else if (pending & CAUSEF_IP5)
  do_IRQ(ATH_CPU_IRQ_GE1);

 else if (pending & CAUSEF_IP3)
  do_IRQ(ATH_CPU_IRQ_USB);

 else if (pending & CAUSEF_IP6)
  ath_dispatch_misc_intr();

 /*
  * Some PCI devices are write to clear. These writes are posted and might
  * require a flush (r8169.c e.g.). Its unclear what will have more
  * performance impact - flush after every interrupt or taking a few
  * "spurious" interrupts. For now, its the latter.
  */
 /*else
    printk("spurious IRQ pending: 0x%x\n", pending); */
}
注册的中断处理函数如下：
    st = request_irq(mac->mac_irq, athr_gmac_intr, ATHR_MAC_IRQF_DISABLED, dev->name, dev);
    if (st < 0)
    {
        printk(MODULE_NAME ": request irq %d failed %d\n", mac->mac_irq, st);
        return 1;
    }
static irqreturn_t athr_gmac_intr(ATHR_MAC_ISR_ARGS)
{
    struct net_device *dev  = (struct net_device *)dev_id;
    athr_gmac_t      *mac  = (athr_gmac_t *)ATHR_MAC_PRIV(dev);
    int   isr, imr, handled = 0;

    isr   = athr_gmac_get_isr(mac); //取得中断状态寄存器的值
    imr   = athr_gmac_reg_rd(mac, ATHR_GMAC_DMA_INTR_MASK);

    athr_gmac_trc(isr,"isr");
    athr_gmac_trc(imr,"imr");

    assert(mac->mac_ifup);
    assert(isr == (isr & imr));

    if (isr & (ATHR_GMAC_INTR_RX_OVF))
    {
     handled = 1;
 
     if (is_ar7240() || is_ar933x())
   {
       athr_gmac_reg_wr(mac,ATHR_GMAC_CFG1,(athr_gmac_reg_rd(mac,ATHR_GMAC_CFG1)&0xfffffff3));
   }
      athr_gmac_intr_ack_rxovf(mac);
    }
    if (likely(isr & ATHR_GMAC_INTR_RX)) //接收中断触发，是分析的重点。
    {
      handled = 1;
      if (mac_has_flag(mac,ATHR_RX_POLL))
    {
              if (likely(athr_mac_rx_sched_prep(mac,dev)))
              {
                  int status = athr_gmac_reg_rd(mac, ATHR_GMAC_DMA_RX_STATUS);
                  athr_gmac_intr_disable_recv(mac);
                  assert((status & ATHR_GMAC_RX_STATUS_PKT_RCVD));
                  assert((status >> 16));
                  __athr_mac_rx_sched(mac,dev);
              }
              else
              {
                  //printk(MODULE_NAME ": driver bug! interrupt while in poll\n");
                  //assert(0);
                  athr_gmac_intr_disable_recv(mac);
              }
       }
       else
    {
           athr_gmac_intr_disable_recv(mac);
        ATH_SCHEDULE_TQUEUE(&mac->rxtq,mac);
       }
    }
    if (likely(isr & ATHR_GMAC_INTR_TX))
    {
        handled = 1;
        athr_gmac_intr_ack_tx(mac);
        athr_gmac_intr_disable_tx(mac);
     ATH_SCHEDULE_TQUEUE(&mac->txreaptq,mac);
    }
    if (unlikely(isr & ATHR_GMAC_INTR_RX_BUS_ERROR))
    {
        assert(0);
        handled = 1;
        athr_gmac_intr_ack_rxbe(mac);
    }
    if (unlikely(isr & ATHR_GMAC_INTR_TX_BUS_ERROR))
    {
        assert(0);
        handled = 1;
        athr_gmac_intr_ack_txbe(mac);
    }
    if (!handled)
    {
 /*
  * Mac fast reset will clear the status register
  * if we get a previously queued interrupt after reset
  * ignore it.
   */
        if (mac->dma_check)
  {
            mac->dma_check = 0;
            return IRQ_HANDLED;
        }
        printk(MODULE_NAME ": unhandled intr isr %#x\n", isr);
        assert(0);
    }

    return IRQ_HANDLED;
}

由于在SDK中，我们定义了，#define CONFIG_ATHR_RX_TASK 1故在中断处理函数中时候，中断上下半部分。
使用的是tasklet
    if (likely(isr & ATHR_GMAC_INTR_RX)) //没有使用查询模式，此模式时将会涉及到NAPI机制来接收数据包。
    {
      handled = 1;
      if (mac_has_flag(mac,ATHR_RX_POLL))
    {
              if (likely(athr_mac_rx_sched_prep(mac,dev)))
              {
                  int status = athr_gmac_reg_rd(mac, ATHR_GMAC_DMA_RX_STATUS);
                  athr_gmac_intr_disable_recv(mac);
                  assert((status & ATHR_GMAC_RX_STATUS_PKT_RCVD));
                  assert((status >> 16));
                  __athr_mac_rx_sched(mac,dev);
              }
              else
              {
                  //printk(MODULE_NAME ": driver bug! interrupt while in poll\n");
                  //assert(0);
                  athr_gmac_intr_disable_recv(mac);
              }
       }
       else
    {
          athr_gmac_intr_disable_recv(mac);//禁止中断
        ATH_SCHEDULE_TQUEUE(&mac->rxtq,mac); //调度tasklet。
      }
    }
中断处理的下半部定义如下：
#define ATH_INIT_RX_TASK() ATH_INIT_TQUEUE(&mac->rxtq,athr_gmac_recv_packets,mac);
athr_gmac_recv_packets()函数定义如下：

athr_receive_pkt() //这个函数兼顾中断俩种处理方式NAPI和完全中断的方式。
{
    ATHR_TASK_DEFS()
    athr_gmac_ring_t       *r     = &mac->mac_rxring;     
    athr_gmac_desc_t       *ds;
    athr_gmac_buffer_t     *bp;
    struct sk_buff      *skb;
    athr_gmac_rx_status_t   ret   = ATHR_GMAC_RX_STATUS_DONE;
    int head = r->ring_head, len, status, iquota = quota, more_pkts, rep;
#ifdef MEMLAT_OPT
    athr_gmac_desc_t       ds_pre[2];
    int head_pre;
#endif

    athr_gmac_trc(iquota,"iquota");
    status = athr_gmac_reg_rd(mac, ATHR_GMAC_DMA_RX_STATUS);

process_pkts:
    athr_gmac_trc(status,"status");

    assert(mac->mac_ifup);

    /*
     * Flush the DDR FIFOs for our gmac
     */
    athrs_flush_ge(mac->mac_unit);

    assert(quota > 0); /* WCL */

    if (mac->dma_check) {
        mac->dma_check = 0;
    }
    else {
        ATHR_NAPI_CHECK_STATUS();
    }

#ifdef MEMLAT_OPT
    head_pre = head;
    ds_pre[quota & 1] = r->ring_desc[head_pre];
#endif
    while(quota)
    {
#ifndef MEMLAT_OPT
        ds    = &r->ring_desc[head];
#else
        ds = ds_pre + (quota & 1);
        if (quota - 1) {
            athr_gmac_ring_incr(head_pre);
            ds_pre[(quota & 1) ^ 1] = r->ring_desc[head_pre];
        }
#endif

        athr_gmac_trc(head,"hd");
        athr_gmac_trc(ds,  "ds");

        if (athr_gmac_rx_owned_by_dma(ds))
        {
            assert(quota != iquota); /* WCL */
            break;
        }
        athr_gmac_intr_ack_rx(mac);

        bp                  = &r->ring_buffer[head];
        len                 = ds->pkt_size;
        skb                 = bp->buf_pkt;

        assert(skb);
        skb_put(skb, len - ETHERNET_FCS_SIZE);

        /*
         *Data corruption sometimes with large buffer size of 4k.Cached region
         *is not synced with non cached region putting temporary fix for
         *invalidating cache contents Need to find the root cause.
         */
       
    athr_mac_cache_inv((unsigned long)(skb->data), skb->len);

        athr_ssdk_process_arp_header(mac, skb);

        athr_gmac_rx_qos(mac,skb);

        athr_gmac_vlan_igmp(mac,skb);

        mac->net_rx_packets ++;
        mac->net_rx_bytes += skb->len;
        /*
         * also pulls the ether header
         */
        skb->protocol       = eth_type_trans(skb, dev);
        skb->dev            = dev;
        bp->buf_pkt         = NULL;
        dev->last_rx        = jiffies;

        quota--;

        athr_nat_process_ingress_pkts(mac->mac_unit, skb, ds);

        netif_receive_skb(skb); //将接受的数据送往协议栈

        if (mac->rx_dma_check) {
            mac->rx_dma_check = 0;
        }

        athr_gmac_ring_incr(head);
    }

    assert(iquota != quota);
    r->ring_head   =  head;

    rep = athr_gmac_rx_replenish(mac);

    /*
    * let's see what changed while we were slogging.
    * ack Rx in the loop above is no flush version. It will get flushed now.
    */
    status       =  athr_gmac_reg_rd(mac, ATHR_GMAC_DMA_RX_STATUS);
    more_pkts    =  (status & ATHR_GMAC_RX_STATUS_PKT_RCVD);

    athr_gmac_trc(more_pkts,"more_pkts");

    if (!more_pkts) goto done;
    /*
    * more pkts arrived; if we have quota left, get rolling again
    */
    if (quota)      goto process_pkts;
    /*
    * out of quota
    */
    ret = ATHR_GMAC_RX_STATUS_NOT_DONE;

done:

    if (mac_has_flag(mac,ATHR_RX_POLL))
        *work_done   = (iquota - quota);

    if (mac_has_flag(mac,ATHR_RX_POLL) &&
           unlikely(athr_gmac_rx_ring_full(mac)))
        return GMAC_RX_STATUS_OOM;
    /*
    * !oom; if stopped, restart h/w
    */

    if (unlikely(status & ATHR_GMAC_RX_STATUS_OVF))
    {
        mac->net_rx_over_errors ++;
        athr_gmac_intr_ack_rxovf(mac);
        athr_gmac_rx_start(mac);
    }

    if (mac_has_flag(mac,ATHR_RX_TASK))
        athr_gmac_intr_enable_recv(mac);

    RX_RETURN();
}
上面的接收处理函数中，重要的结构参数ring_buffer[]不好理解，还需要更升入的研究。
需要注意的是：每中断一次，都会禁止中断，之后在tasklet中来接收数据，数据接收完成之后有开启中断。
我们对capwap协议的处理放在了驱动中进行处理，故接收和发送函数都需要对capwap协议进行处理。
注意：不能在中断和查询中占用太多的时间。
9344中数据接收兼容了中断和查询这俩种方式来处理数据接收。在性能方面不知道那个要好一些。