dev->netdev_ops =&stmmac_netdev_ops;（见第2小节）

stmmac_set_ethtool_ops(dev);（见第3小节）

dev->features |= NETIF_F_SG |NETIF_F_HIGHDMA | NETIF_F_IP_CSUM

                | NETIF_F_IPV6_CSUM;

设置网卡接口特性，这些特性驱动和协议层将会用到

dev->watchdog_timeo =msecs_to_jiffies(watchdog); 设置发送超时，超时后最终会调用stmmac_tx_timeout这个进行超时处理

（3）初始化NAPI轮询接收数据包接口

netif_napi_add(dev, &priv->napi, stmmac_poll, 64);（重要，见第八节）

初始化napi，poll=stmmac_poll，weight=64，poll_list等信息

Weight: 描述接口的相对重要性，当资源紧张时，在接口上能承受多大的流量。

（4）从寄存器中获取MAC地址，并判断有效性

priv->hw->mac->get_umac_addr((void__iomem *)dev->base_addr, dev->dev_addr, 0);

（5）初始化自旋锁

spin_lock_init(&priv->lock);

tnk_lock_init(&priv->tlock);

（6）注册网卡设备

ret = register_netdev(dev);

2、网卡基本操作函数

static const struct net_device_opsstmmac_netdev_ops = {

    .ndo_open = stmmac_open,（见第六节）

    .ndo_start_xmit = stmmac_xmit,（见第九节）

   .ndo_stop = stmmac_release,

   .ndo_change_mtu = stmmac_change_mtu,

   .ndo_set_multicast_list = stmmac_multicast_list,

   .ndo_tx_timeout = stmmac_tx_timeout,

   .ndo_do_ioctl = stmmac_ioctl,

   .ndo_set_config = stmmac_config,

#ifdef STMMAC_VLAN_TAG_USED

   .ndo_vlan_rx_register = stmmac_vlan_rx_register,

#endif

#ifdef CONFIG_NET_POLL_CONTROLLER

   .ndo_poll_controller = stmmac_poll_controller,

#endif

   .ndo_set_mac_address = eth_mac_addr,

};

3、ethtool操作函数

static struct ethtool_opsstmmac_ethtool_ops = {

   .begin = stmmac_check_if_running,

   .get_drvinfo = stmmac_ethtool_getdrvinfo,

   .get_settings = stmmac_ethtool_getsettings,

   .set_settings = stmmac_ethtool_setsettings,

   .get_msglevel = stmmac_ethtool_getmsglevel,

   .set_msglevel = stmmac_ethtool_setmsglevel,

   .get_regs = stmmac_ethtool_gregs,

   .get_regs_len = stmmac_ethtool_get_regs_len,

   .get_link = stmmac_ethtool_get_link,

   .get_rx_csum = stmmac_ethtool_get_rx_csum,

   .get_tx_csum = ethtool_op_get_tx_csum,

   .set_tx_csum = ethtool_op_set_tx_ipv6_csum,

   .get_sg = ethtool_op_get_sg,

   .set_sg = ethtool_op_set_sg,

   .get_pauseparam = stmmac_get_pauseparam,

   .set_pauseparam = stmmac_set_pauseparam,

   .get_ethtool_stats = stmmac_get_ethtool_stats,

   .get_strings = stmmac_get_strings,

   .get_wol = stmmac_get_wol,

   .set_wol = stmmac_set_wol,

   .get_sset_count = stmmac_get_sset_count,

   .get_tso = ethtool_op_get_tso,

   .set_tso = ethtool_op_set_tso,

};

六、打开网卡设备stmmac_open

1、基本流程

基本流程图：

（1）MAC地址有效性

is_valid_ether_addr(dev->dev_addr)

（2）修正传递给驱动参数

stmmac_verify_args();

（3）初始化PHY设备

stmmac_init_phy(dev);（见第2小节）

（4）设备MAC地址到硬件

priv->hw->mac->set_umac_addr(priv->ioaddr,dev->dev_addr, 0);

（5）初始化MAC core

priv->hw->mac->core_init(priv->ioaddr);

（6）使能NAPI并schedule

napi_enable(&priv->napi);

napi_schedule(&priv->napi)

（7）启动DMA收发（写寄存器）

priv->hw->dma->start_tx(priv->dma_ioaddr,priv->dma_channel);

priv->hw->dma->start_rx(priv->dma_ioaddr,priv->dma_channel);

（8）启动相关定时器

priv->poll_timer.function= stmmac_poll_func;

定时唤醒处于挂起状态的RxDMA/TxDMA

priv->check_timer.function= stmmac_check_func;

读取寄存器地址获取当前接收描述符地址，如果在cur_rx和dirty_cur之前，则设置描述子归属为GMAC操作。

（9）使能MAC TX/RX

stmmac_enable_mac(priv->ioaddr);

（10）启动队列

netif_start_queue(dev);

2、初始化PHY设备stmmac_init_phy

（1）通知内核载波消失

netif_carrier_off(dev);

（2）以太网设备连接到PHY设备

phydev= phy_connect(dev, phy_id, &stmmac_adjust_link, 0, priv->phy_interface);

stmmac_adjust_link：根绝实际PHY情况，调整连接参数：全双工/半双功，速度，MII/GMII

A．d =bus_find_device_by_name(&mdio_bus_type, NULL, bus_id);

在MDIO bus总线PHY device列表中找到指定的设备

B．设备转化为PHY设备

phydev= to_phy_device(d);

C．rc =phy_connect_direct(dev, phydev, handler, flags, interface);

连接以太网device到指定的PHY 设备，然后启动PHY。

七、中断处理函数stmmac_interrupt

中断里3个并行流程：网卡1、网卡2、TOE，网卡和网卡2处理流程一样，且未使用TOE，只分析网卡1。

接收到第一个数据包或者数据发送完成时，产生中断，进入该中断处理函数。

1、读取中断状态寄存器

不管发送或者接收，产生DMA0中断时，则进入dma中断处理函数

2、stmmac_dma_interrupt

status = priv->hw->dma->dma_interrupt(priv->dma_ioaddr,priv->dma_channel,

                     &priv->xstats);

读取dma中断状态，如果是正确的接收和发送，则进行NAPI调度_stmmac_schedule(priv)。

里面调用napi_schedule(&priv->napi)，同时禁止中断（中断由stmmac_poll里面开启）。

3、napi_schedule简单说明

（1）将priv->napi加入到softnet_data->napi，从定义看每个CPU有一个softnet_data

（2）启动网络接收软中断NET_RX_SOFTIRQ

（3）在CPU一定时间内处理该软中断

（4）软中断处理函数为net_rx_action，里面则会调用n->poll进行相应处理（该处的poll为下面probe是注册的stmmac_poll，见后面章节说明）

（5）软中断处理函数在subsys_initcall(net_dev_init)时注册

open_softirq(NET_TX_SOFTIRQ, net_tx_action);

   open_softirq(NET_RX_SOFTIRQ, net_rx_action);

（6）最后在do_softirq中统一处理所有的软中断。

常见软中断类型：

enum   

{      

   HI_SOFTIRQ=0,

   TIMER_SOFTIRQ,

   NET_TX_SOFTIRQ,

   NET_RX_SOFTIRQ,

   BLOCK_SOFTIRQ,

   BLOCK_IOPOLL_SOFTIRQ,

   TASKLET_SOFTIRQ,

   SCHED_SOFTIRQ,

   HRTIMER_SOFTIRQ,

   RCU_SOFTIRQ,    /* Preferable RCUshould always be the last softirq */

   NR_SOFTIRQS

};

4、中断里没对接收到的数据进行处理，而是调用NAPI接口在适当的时间进行处理。

八、NAPI接口之stmmac_poll

         该接口完成两个事情：一个是当数据发送完成时产生中断，进入该函数进行资源回收；另外一个是收到数据产生中断，进入该函数进行数据接收和处理。

1、基本操作流程

（1）接口开始时记录proc信息

         stmmac_poll_begin();

（2）回收已经发送完成的资源（放在发送章节讲解）

stmmac_tx(priv);（见第九节7小节）

（3）接收数据包

（4）如果接收到的数据包没有超过接口的容量，则开启中断

if (work_done< budget) {

       stm_proc.polls_done++;

       napi_complete(napi);

       stmmac_enable_irq(priv);

    }

（5）结束接口调用

stmmac_poll_end();

2、数据包接收处理stmmac_rx

unsigned int entry = priv->cur_rx % rxsize;

struct dma_desc *p = priv->dma_rx +entry;

（1）priv->hw->desc->get_rx_owner(p)

判断当前描述子的归属：描述子数据结构中OWN位，0:当前描述子应该由CPU操作，1:前描述子应该由GMAC操作。对于接收，初始化dma描述子队列时设置为1。

         GMAC根据寄存器配置，获取可用接收描述子，然后从RxFIFO中读取从PHY接收的Ethernet报文，如果报文符合接收条件，将该报文写入接收描述子指向的数据缓冲区，并回写接收描述子。这个回写就会将OWN位设置为0。

（2）获取下一帧描述符

next_entry = (++priv->cur_rx) % rxsize;

p_next =priv->dma_rx + next_entry;

priv->cur_rx：已经传递给协议层的index

（3）获取收到帧状态

status =(priv->hw->desc->rx_status(&priv->dev->stats, &priv->xstats,p));

如果是丢弃帧，则什么都不处理；否则上传到上层网络。

（4）获取帧长度

frame_len =priv->hw->desc->get_rx_frame_len(p);

（5）获取帧数据

skb = priv->rx_skbuff[entry];

priv->rx_skbuff[entry] = NULL;

注意：skb将有上层网络处理完后进行释放。

（6）设置skb数据长度和解除流式DMA映射

skb_put(skb, frame_len);

dma_unmap_single(priv->device, priv->rx_skbuff_dma[entry],priv->dma_buf_sz, DMA_FROM_DEVICE);

（7）获取skb的协议类型

skb->protocol = eth_type_trans(skb,priv->dev);

skb->dev = priv->dev;

（8）将skb通过NAPI接口上传上层网络协议处理

napi_gro_receive(&priv->napi,skb);（见第九节）

注：以上是一个while循环操作

（9）重新填充接收队列

stmmac_rx_refill(priv);（见第3小节）

3、接收队列填充函数stmmac_rx_refill

         由第2小节，接收到数据的skb从dma接收队列剥离，传递给网络层处理完成后，会将skb给释放。所以，需要重新申请新的skb传递填充dma接收队列。

（1）判断是否需要重新填充

将priv->cur_rx和priv->dirty_rx进行对比，如果priv->cur_rx > priv->dirty_rx即上传给网络协议层的数量大于已经填充dma的数量时，才会重新填充dma接收队列。

（2）检查描述子操作归属

priv->hw->desc->get_rx_owner(p+ entry)，只有属于CPU的，才进行填充操作。

（3）申请新的SKB

skb= __skb_dequeue(&priv->rx_recycle);

先从回收队列中获取有效的skb。该回收队列来自由协议层申请且发送完成的数据帧skb。在stmmac_tx接口进行回收，它没有释放skb，而是放在了回收队列中，提高利用效率。

skb= netdev_alloc_skb_ip_align(priv->dev,

若回收队列没有，则重新申请skb。

（4）填充接收DMA描述符队列

priv->rx_skbuff[entry]= skb;

priv->rx_skbuff_dma[entry]= dma_map_single(priv->device, skb->data, bfsize, DMA_FROM_DEVICE);

(p+ entry)->des2 = priv->rx_skbuff_dma[entry];

（5）设置描述子归属，交给GMAC操作

priv->hw->desc->set_rx_owner(p+ entry);

注：以上通过for循环进行，直到没有需要填充为止。

（6）激活RxDMA

STMMAC_SYNC_BARRIER();

处理下一条指令前，先flush一下DMA write buffers

priv->hw->dma->enable_dma_receive(priv->dma_ioaddr,priv->dma_channel);

写任何值唤醒处于挂起的RxDMA。

九、传递skb数据给协议栈napi_gro_receive（generic receive offload）

1、概念了解

TSO、UFO和GSO是对应网络发送，LRO、GRO是对应网络接收。

TSO（TCPSegmentation Offload）是一种利用网卡对TCP数据包分片，减轻CPU负荷的一种技术，也叫LSO（Largesegment offload），TSO—TCP，UFO—UDP。如果硬件支持TSO功能，也需要硬件支持的TCP校验计算和分散/聚集功能。

    GSO（GenericSegmentation Offload）比TSO更通用。基本思想：尽可能的推迟数据分片直至发送到网卡驱动之前，此时会检查网卡是否支持分片功能（TSO、UFO），如果支持直接发送到网卡，如果不支持就进行分片后再发往网卡。这样大数据包只需走一次协议栈，而不是被分割成几个数据包分别走，提高效率。

    LRO（Large ReceiveOfflaod） 通过接收到的多个TCP数据聚合成一个大的数据包，然后传递给网络协议层处理，以减少上层协议栈处理开销，提高系统接收TCP数据包能力

    GRO（Generic ReceiveOffload）基本思想跟LRO类似，但是更加通用，现在驱动基本使用GRO接口，而不是LRO。

    RSS（Receive SideScaling）是一项网卡的特性，俗称多队列。具备多个RSS队列的网卡，可以将不同的网络流分成不同的队列，再分别将这些队列分配到多个CPU核心进行处理，从而将负荷分散，充分利用多核处理器的能力。

2、GRO结构体struct napi_gro_cb

GRO功能使用skb结构体内私有空间char cb[48]来存放gro所用到的一些信息。

具体内容如下：

struct napi_gro_cb {

/* Virtual address ofskb_shinfo(skb)->frags[0].page + offset. */

指向存在skb_shinfo(skb)->frag[0].page页的数据的头部。见skb_gro_reset_offset

   void *frag0;

    /*Length of frag0.  第一页中数据的长度 */

   unsigned int frag0_len;

/* This indicates where we areprocessing relative to skb->data. 表明skb->data到GRO需要处理的数据区的偏移量 */

    比如进入ip层进行GRO处理，这时skb->data指向ip 头， 而ip层的gro 正好要处理ip头，这时偏移量就为0。进入传输层后进行GRO处理，这时skb->data还指向ip头， 而tcp层gro要处理tcp头，这时偏移量就是ip头部长度

    intdata_offset;

/* This is non-zero if thepacket may be of the same flow.  挂在napi->gro_list上的报文是否跟现在的报文进行匹配*/

每层的gro_receive都设置该标记位。 接收到一个报文后，使用该报文和挂在napi->gro_list上 的报文进行匹配。 在链路层，使用dev 和 mac头进行匹配，如果一样表示两个报文是通一个设备发过来的，就标记napi->gro_list上对应的skb的same为1. 到网络层，再进一步进行匹配时，只需跟napi->list上刚被链路层标记 same为1的报文进行网络层的匹配即可，不需再跟每个报文进行匹配。 如果网络层不匹配，就清除该标记。 到传输层，也是只配置被网络层标记same为1 的报文即可。这样设计为的是减少没必要的匹配操作

    intsame_flow;

/* This is non-zero if thepacket cannot be merged with the new skb. */

     如果该字段不为0，表示该数据报文没必要再等待合并，可以直接送进协议栈进行处理了

int flush;

    /*Number of segments aggregated.  该报文被合并过的次数*/

    intcount;

    /*Free the skb?  是否该被丢弃*/

    intfree;

};

3、函数基本流程

（1）skb_gro_reset_offset（见第4小节）

初始化NAPI_GRO_CB;

（2）__napi_gro_receive（见第6小节）

连路层gro_receive，实现数据包合并还是上传协议栈

（3）napi_skb_finish（见第5小节，内容少先讲）

根据第二个函数的返回值决定合并，feed协议栈，还是free。

4、初始化GRO cb: skb_gro_reset_offset(skb)

支持S/G IO的网卡存在如下一种可能：skb本身不包含数据（头也没有），所有的数据都保存在skb_share_info中，且frags.page不在higih_mem。此种情况如果要合并，将包头信息取出来即skb_shared_info的frags[0]，将头信息保存到napi_gro_cb 的frags0中。

具体源码如下：

NAPI_GRO_CB(skb)->data_offset = 0;

NAPI_GRO_CB(skb)->frag0 = NULL;

NAPI_GRO_CB(skb)->frag0_len = 0;

如果mac_header和skb->tail相等并且地址不在高端内存，则说明包头保存在skb_shinfo中，所以我们需要从frags中取得对应的数据包

if(skb->mac_header == skb->tail && !PageHighMem(skb_shinfo(skb)->frags[0].page)){

可以看到frag0保存的就是对应的skb的frags的第一个元素的地址

NAPI_GRO_CB(skb)->frag0=  page_address(skb_shinfo(skb)->frags[0].page)+

           skb_shinfo(skb)->frags[0].page_offset;

然后保存对应的大小

NAPI_GRO_CB(skb)->frag0_len= skb_shinfo(skb)->frags[0].size;

    }

5、napi_skb_finish

         根据__napi_gro_receive的返回值处理合并后的数据包。

switch(ret) {

         //将数据包送进协议栈

    case GRO_NORMAL:

        if (netif_receive_skb(skb))（见第8小节）

            ret = GRO_DROP;

        break;

         //报文可以丢弃或者已经合并进gro，则free报文

    case GRO_DROP:

    case GRO_MERGED_FREE:

        kfree_skb(skb);

        break;

   //数据已经被gro保存起来，但是并没有合并的，skb还需要保留不能释放。

    case GRO_HELD:

    case GRO_MERGED:

        break; 

    }          

    return ret;

6、__napi_gro_receive接收合并函数

（1）基本概念

每个协议中定义自己的GRO接收合并函数和合并后处理函数，即gro_receive和gro_complete。GRO系统会根据协议来调用对应回调函数。gro_receive将         skb合并到gro_list中，返回值：空则表示合并后无需送入协议栈，非空则需要立即送入协议栈。gro_complete则是当返回值非空时将gro合并数据包送到协议栈时被调用。

__napi_gro_receive和napi_gro_complete可以被看做是链路层的gro_receive和gro_complete。

各个协议层gro_receive:

             .gro_receive = tcp4_gro_receive,

             .gro_receive = inet_gro_receive,

             .gro_receive = ipv6_gro_receive,

各个协议层gro_complete:

             .gro_complete = tcp4_gro_complete,

             .gro_complete = inet_gro_complete,

             .gro_complete = ipv6_gro_complete,

（2）函数基本内容

A．for (p = napi->gro_list;p; p = p->next) {

        unsigned long diffs;

        diffs = (unsigned long)p->dev ^(unsigned long)skb->dev;

        diffs |= p->vlan_tci ^skb->vlan_tci;

        diffs |=compare_ether_header(skb_mac_header(p),

                         skb_gro_mac_header(skb));

        NAPI_GRO_CB(p)->same_flow = !diffs;

        NAPI_GRO_CB(p)->flush = 0;

    }   

         遍历gro_list，查找列表中skb是否有和当前skb相同的流，然后给same_flow赋值。如果此层（链路层）相同，则ip层、tcp层再进行相同流判断，否则不会进行判断。不同层流是否相同的判断条件不一样，此处判断3个判断条件：同一设备、同一VLAN、同一MAC头。

  B．  returndev_gro_receive(napi, skb);（见第7节）

         真正的接收合并处理

7、dev_gro_receive真正的接收合并

         可以分为两部分看待，一个是正常的合并处理，另外一个就是frags0处理部分。需要注意GRO不支持切片的IP包，IP切片的组包在内核IP层会做一遍，GRO再做没意义增加复杂度。

（1）合并相同流处理

A．先遍历对应的ptype（协议的类链表），找到匹配协议后，调用对应的回调函数gro_receive；链路层则调用ip层的gro_receive即inet_gro_receive。

B．进入ip层合并处理，主要判断是否same_flow和是否需要flush。只有两个包是same_flow的情况下才会flush判断

same_flow判断：协议需要相同，tos域需要相同，源和目的地址需要相同；只要一个不同就是设置为0。

flush判断：是切片包，ttl不一样，id顺序不对；只要一个满足skb就会flush出gro到协议栈。然后进入TCP层的gro_receive即tcp4_gro_receive。

C．进入TCP层合并处理：类似IP层，对same_flow和flush判断。其中对flush的判断比较多和复杂，如果需要flush就不需要进行合并处理，返回相应的gro_list。

         真正的合并函数：skb_gro_receive（此处暂不分析）。

（2）当gro_receive返回值非空时，对flush出gro的skb进行立即feed进协议栈处理napi_gro_complete。如果当前skb的same_flow非0表明找到同流且已合并直接返回，如果未找到同流，则添加skb到gro_list中。

（3）frags0处理部分

         将skb_shinfo结构体存放的frags，往前移动到skb。（为啥这么做？）

8、netif_receive_skb

最终将skb数据分发给各个协议层。有空再讲解。

十、发送数据stmmac_xmit

该接口实现了Scatter/Gather I/O功能，通过skb_shinfo宏来判断数据包是一个数据片段组成，还是由大量数据片段组成。

1、获取可用发送描述子

entry= priv->cur_tx % txsize;

desc= priv->dma_tx + entry;

first= desc; 保存第一个数据片段

2、将skb放到发送队列

priv->tx_skbuff[entry]= skb;

priv->tx_page[entry]= NULL;

3、发送单个或第一个数据包

unsignedint nopaged_len = skb_headlen(skb);

desc->des2= dma_map_single(priv->device, skb->data,nopaged_len, DMA_TO_DEVICE);

priv->hw->desc->prepare_tx_desc(desc,1, nopaged_len, csum_insertion);

当只有一个数据片段时，skb->data将发送所有数据；当有多个数据片段时，skb->data则指向第一个数据片段，数据长度skb->len –skb->data_len，其他数据存放在共享数据结构frags数组中。（skb->len:数据包中全部数据的长度，skb->data_len分隔存储数据片段长度）

4、发送剩余数据片段

对于多个数据片段时，还要进行数据片段的发送，采用页处理。直接处理页结构，而不是内核虚拟地址。

for(i = 0; i < nfrags; i++)

{

        skb_frag_t *frag =&skb_shinfo(skb)->frags[i];

        int len = frag->size;

        entry = (entry + 1) % txsize;

        desc = priv->dma_tx + entry;

        TX_DBG("\t[entry %d] segment len:%d\n", entry, len);

        desc->des2 = dma_map_page(priv->device, frag->page,

                      frag->page_offset,

                      len, DMA_TO_DEVICE);

        priv->tx_skbuff[entry] = NULL;

        priv->tx_page[entry] =frag->page;

        get_page(frag->page);（需要查一下原理）

       priv->hw->desc->prepare_tx_desc(desc, 0, len, csum_insertion);

       priv->hw->desc->set_tx_owner(desc);

}

5、将第一个数据片段描述子交给GMAC，记录当前发送index

    priv->hw->desc->set_tx_owner(first);

    priv->cur_tx += count;

6、激活RxDMA

STMMAC_SYNC_BARRIER();

处理下一条指令前，先flush一下DMA write buffers

priv->hw->dma->enable_dma_transmission(priv->dma_ioaddr,

                          priv->dma_channel);

写任何值唤醒处于挂起的RxDMA

7、发送资源回收接口stmmac_tx

当数据发送完成时产生中断，调用stmmac_poll函数进入该接口进行发送资源回收操作。

（1）从寄存器获取当前发送描述符DMA index

（2）循环判断dirty_tx 和 cur_tx

while(priv->dirty_tx != priv->cur_tx)

（3）判断DMA index 和 描述符归属

if (entry == hw_dma_index) // entry =dirty_tx % txsize

            break;

if(priv->hw->desc->get_tx_owner(p))

            break;

（4）skb加入回收接收队列

if((skb_queue_len(&priv->rx_recycle) <priv->dma_rx_size)

&&skb_recycle_check(skb, priv->dma_buf_sz))

__skb_queue_head(&priv->rx_recycle,skb);

else

dev_kfree_skb(skb);

接收回收队列没有超出接收队列总长度（256），且skb可以进行回收的情况下，将skb加入回收队里。其他就释放skb。

（5）释放多数据数据片段的page页

put_page(priv->tx_page[entry]);

priv->tx_page[entry]= NULL;

（6）增加dirty_tx

entry= (++priv->dirty_tx) % txsize;

十一、其他补充

参考文档