大家好，又见面了，我是你们的朋友全栈君。
说是网络，其实是网卡驱动。而且是针对于FREESCALE芯片的FEC端的驱动，我不知道别的芯片厂商的FEC模块是怎么样的， 但就我接触过的几款FREESCALE的芯片来看，比如基于POWERPC的860T和ARM系列的MX27等，他们的FEC有一个明显的特点就是 都是由BD和一个DMA缓冲组成，而这个DMA是专用的，也就是只是给FEC使用，区别于芯片内的DMAC模块。我们先来从fec.c这 个与硬件直接相关的看起： 首先找到module_init(fec_enet_module_init);这里fec_enet_module_init为入口点 fec_enet_module_init（） 首先调用fec_arch_init，它调用gpio_fec_active设置GPIO为FEC模式，然后如果有电源管理的话，就调用 mxc_fec_power_on开启电源。接着调用clk_get，clk_enable, clk_put设置FEC的CLOCK，这里退出fec_arch_init函数，接 着循环FEC_MAX_PORTS次，也就是有几个FEC就循环几次，在这里我们只有一个FEC，所以这个循环不用管。接下来因为我们 用的是以太网，所以调用dev = alloc_etherdev(sizeof(struct fec_enet_private));申请一个以太网设备描述，其中 struct fec_enet_private是用来描述FEC专有的数据结构。如下： /* The FEC buffer descriptors track the ring buffers. The rx_bd_base and * tx_bd_base always point to the base of the buffer descriptors. The * cur_rx and cur_tx point to the currently available buffer. * The dirty_tx tracks the current buffer that is being sent by the * controller. The cur_tx and dirty_tx are equal under both completely * empty and completely full conditions. The empty/ready indicator in * the buffer descriptor determines the actual condition. */ struct fec_enet_private { /* Hardware registers of the FEC device */ volatile fec_t *hwp; /* The saved address of a sent-in-place packet/buffer, for skfree(). */ unsigned char *tx_bounce[TX_RING_SIZE]; struct sk_buff* tx_skbuff[TX_RING_SIZE]; struct sk_buff* rx_skbuff[RX_RING_SIZE]; ushort skb_cur; ushort skb_dirty; /* CPM dual port RAM relative addresses. */ void * cbd_mem_base; /* save the virtual base address of rx&tx buffer descripter */ cbd_t *rx_bd_base; /* Address of Rx and Tx buffers. */ cbd_t *tx_bd_base; cbd_t *cur_rx, *cur_tx; /* The next free ring entry */ cbd_t *dirty_tx; /* The ring entries to be free()ed. */ struct net_device_stats stats; uint tx_full; spinlock_t lock; uint phy_id; uint phy_id_done; uint phy_status; uint phy_speed; phy_info_t const *phy; struct work_struct phy_task; uint sequence_done; uint mii_phy_task_queued; uint phy_addr; int index; int opened; int link; int old_link; int full_duplex; struct clk *clk; }; 调用完这个函数后我们就有eth0这人设备了，其中一些结构的初始化是在这个函数里的一个回调ether_setup里设 置的，在这里我也把它帖出来吧。 /** * ether_setup – setup Ethernet network device * @dev: network device * Fill in the fields of the device structure with Ethernet-generic values. */ void ether_setup(struct net_device *dev) { dev->change_mtu = eth_change_mtu; dev->hard_header = eth_header; dev->rebuild_header = eth_rebuild_header; dev->set_mac_address = eth_mac_addr; dev->hard_header_cache = eth_header_cache; dev->header_cache_update= eth_header_cache_update; dev->hard_header_parse = eth_header_parse; dev->type = ARPHRD_ETHER; dev->hard_header_len = ETH_HLEN; dev->mtu = ETH_DATA_LEN; dev->addr_len = ETH_ALEN; dev->tx_queue_len = 1000; /* Ethernet wants good queues */ dev->flags = IFF_BROADCAST|IFF_MULTICAST; memset(dev->broadcast, 0xFF, ETH_ALEN); } alloc_etherdev完了之后，调用fec_enet_init函数，这里才是真正芯片级的代码： fec_enet_init（） 上锁spin_lock_init(&(fep->lock))，调用__get_free_page申请一页的内存，这个返回的地址为虚拟地 址，然后将这个地址值赋给fep->cbc_mem_base，然后将fecp和fep->hwp指向FEC硬件寄存器，fecp->fec_ecntrl = 1，复位 FEC模块，等待10us后调用fec_get_mac从FLASH中读取MAC地址，调用cbd_base = (cbd_t *)fec_map_uncache(mem_addr, PAGE_SIZE);将刚才申请的一页进行映射（mem_addr不是虚拟地址么？为什么这里还要映射？？）作为BD的初始地址并将FEC 的rx_bd_base指向该地址，同时将tx_bd_base指向RX_RING_SIZE之后的地址，这个RX_RING_SIZE定义如下： /* The number of Tx and Rx buffers. These are allocated from the page * pool. The code may assume these are power of two, so it it best * to keep them that size. * We don’t need to allocate pages for the transmitter. We just use * the skbuffer directly. */ #define FEC_ENET_RX_PAGES 8 #define FEC_ENET_RX_FRSIZE 2048 #define FEC_ENET_RX_FRPPG (PAGE_SIZE / FEC_ENET_RX_FRSIZE) #define RX_RING_SIZE (FEC_ENET_RX_FRPPG * FEC_ENET_RX_PAGES) #define FEC_ENET_TX_FRSIZE 2048 #define FEC_ENET_TX_FRPPG (PAGE_SIZE / FEC_ENET_TX_FRSIZE) #define TX_RING_SIZE 16 /* Must be power of two */ #define TX_RING_MOD_MASK 15 /* for this to work */ #if (((RX_RING_SIZE TX_RING_SIZE) * 8) > PAGE_SIZE) #error “FEC: descriptor ring size constants too large” #endif 其中PAGE_SIZE是为4096，所以这个RX_RING_SIZE的值也为16,意思好像是说有16个FEC_ENET_RX_FRSIZE? 接下来循环初始化RX_RING_SIZE个frame，循环中，调用dev_alloc_skb(FEC_ENET_RX_FRSIZE);初始化skb，并将赋给fep- >rx_skbuff[i]，接下来将pskb->data进行对齐，这个对齐要求是通过 #define FEC_ADDR_ALIGNMENT(x) ((unsigned char *)(((unsigned long )(x) (FEC_ALIGNMENT)) & (~FEC_ALIGNMENT))) 来实现的，也就是说这个对齐要求是由datasheet里的FEC模块规定的。注意的是最后将这个地址进行物理 地址变换后赋给cbd_bufaddr的，即cbd_bufaddr = __pa(pskb->data);然后将BD的cbd_sc状态描述置为BD_ENET_RX_EMPTY空 闲。 接下来将最后一个BD的cbd_sc状态描述置上BD_SC_WRAP标志，这估计是datasheet里规定的吧？？接下来 初始化发送BD，这里看不懂，先帖上来先 bdp = fep->tx_bd_base; for (i=0, j=FEC_ENET_TX_FRPPG; i<TX_RING_SIZE; i ) { if (j >= FEC_ENET_TX_FRPPG) { mem_addr = __get_free_page(GFP_KERNEL); j = 1; } else { mem_addr = FEC_ENET_TX_FRSIZE; j ; } fep->tx_bounce[i] = (unsigned char *) mem_addr; /* Initialize the BD for every fragment in the page. */ bdp->cbd_sc = 0; bdp->cbd_bufaddr = 0; bdp ; } /* Set the last buffer to wrap. */ bdp–; bdp->cbd_sc |= BD_SC_WRAP; 接着调用 /* Set receive and transmit descriptor base. */ fecp->fec_r_des_start = __pa((uint)(fep->cbd_mem_base)); fecp->fec_x_des_start = __pa((uint)(fep->cbd_mem_base RX_RING_SIZE*sizeof (cbd_t))); 将发送同接收地址值写入寄存器中。下面调用fec_request_intrs申请两个中断，一个为FEC的中 断static irqreturn_t fec_enet_interrupt(int irq, void * dev_id)，用作发送接收、MII及出错等中断使用，另一个为 PHY端的中断static irqreturn_t mii_link_interrupt(int irq, void * dev_id)，用作PHY芯片检测LINK DOWN或AUTO- NEGO DONE中断，下面 /* Clear and enable interrupts */ fecp->fec_ievent = FEC_ENET_MASK; fecp->fec_imask = FEC_ENET_TXF | FEC_ENET_TXB | FEC_ENET_RXF | FEC_ENET_RXB | FEC_ENET_MII; fecp->fec_hash_table_high = 0; fecp->fec_hash_table_low = 0; fecp->fec_r_buff_size = PKT_MAXBLR_SIZE; fecp->fec_ecntrl = 2; fecp->fec_r_des_active = 0x01000000; 都是设置硬件寄存器，接着设置 /* The FEC Ethernet specific entries in the device structure. */ dev->open = fec_enet_open; dev->hard_start_xmit = fec_enet_start_xmit; dev->tx_timeout = fec_timeout; dev->watchdog_timeo = TX_TIMEOUT; dev->stop = fec_enet_close; dev->get_stats = fec_enet_get_stats; dev->set_multicast_list = set_multicast_list; 这里是重载DEV的一些实现，当我们敲入ifconfig eth0 up的时候就会调用fec_enet_open。这里 要说明的是fec_timeout这个函数，这个函数运行在SOFTIRQ上下文，被当作网络的watchdog超时函数。而 set_multicast_list函数还不清楚是用来做什么的？？？？接下来 for (i=0; i<NMII-1; i ) mii_cmds[i].mii_next = &mii_cmds[i 1]; mii_free = mii_cmds; 这是初始化mii的命令队列，这个其实是一个静态数组，然后通过内部的链表变量将这个数组链 起来。mii_free是一个链表头，指向第一个可用的mii_cmd元素。接着调用fec_set_mii初始化MII的速度： static void __inline__ fec_set_mii(struct net_device *dev, struct fec_enet_private *fep) { u32 rate; struct clk *clk; volatile fec_t *fecp; fecp = fep->hwp; fecp->fec_r_cntrl = OPT_FRAME_SIZE | 0x04; fecp->fec_x_cntrl = 0x00; /* * Set MII speed to 2.5 MHz */ clk = clk_get(NULL, “fec_clk”); rate = clk_get_rate(clk); clk_put(clk); fep->phy_speed = ((((rate / 2 4999999) / 2500000) / 2) & 0x3F) << 1; fecp->fec_mii_speed = fep->phy_speed; fec_restart(dev, 0); } 设置完clk后，调用fec_restart重新设置FEC的参数： /* This function is called to start or restart the FEC during a link * change. This only happens when switching between half and full * duplex. */ static void fec_restart(struct net_device *dev, int duplex) { struct fec_enet_private *fep; volatile cbd_t *bdp; volatile fec_t *fecp; int i; OUTDEB(“entry!!!!!n”); fep = netdev_priv(dev); fecp = fep->hwp; /* Whack a reset. We should wait for this. */ fecp->fec_ecntrl = 1; udelay(10); /* Enable interrupts we wish to service. */ fecp->fec_imask = FEC_ENET_TXF | FEC_ENET_TXB | FEC_ENET_RXF | FEC_ENET_RXB | FEC_ENET_MII; /* Clear any outstanding interrupt. * */ fecp->fec_ievent = FEC_ENET_MASK; #if 0/*modified by Zenith @ 2010.1.21 for int bug*/ fec_enable_phy_intr(); #endif /* Set station address. */ fec_set_mac_address(dev); /* Reset all multicast. */ fecp->fec_hash_table_high = 0; fecp->fec_hash_table_low = 0; /* Set maximum receive buffer size. */ fecp->fec_r_buff_size = PKT_MAXBLR_SIZE; fec_localhw_setup(); /* Set receive and transmit descriptor base. */ fecp->fec_r_des_start = __pa((uint)(fep->cbd_mem_base)); fecp->fec_x_des_start = __pa((uint)(fep->cbd_mem_base RX_RING_SIZE*sizeof(cbd_t))); fep->dirty_tx = fep->cur_tx = fep->tx_bd_base; fep->cur_rx = fep->rx_bd_base; /* Reset SKB transmit buffers. */ fep->skb_cur = fep->skb_dirty = 0; for (i=0; i<=TX_RING_MOD_MASK; i ) { if (fep->tx_skbuff[i] != NULL) { dev_kfree_skb_any(fep->tx_skbuff[i]); fep->tx_skbuff[i] = NULL; } } /* Initialize the receive buffer descriptors. */ bdp = fep->rx_bd_base; for (i=0; i<RX_RING_SIZE; i ) { /* Initialize the BD for every fragment in the page. */ bdp->cbd_sc = BD_ENET_RX_EMPTY; bdp ; } /* Set the last buffer to wrap. */ bdp–; bdp->cbd_sc |= BD_SC_WRAP; /* …and the same for transmmit. */ bdp = fep->tx_bd_base; for (i=0; i<TX_RING_SIZE; i ) { /* Initialize the BD for every fragment in the page. */ bdp->cbd_sc = 0; bdp->cbd_bufaddr = 0; bdp ; } /* Set the last buffer to wrap. */ bdp–; bdp->cbd_sc |= BD_SC_WRAP; /* Enable MII mode. */ if (duplex) { fecp->fec_r_cntrl = OPT_FRAME_SIZE | 0x04;/* MII enable */ fecp->fec_x_cntrl = 0x04; /* FD enable */ } else { /* MII enable|No Rcv on Xmit */ fecp->fec_r_cntrl = OPT_FRAME_SIZE | 0x06; fecp->fec_x_cntrl = 0x00; } fep->full_duplex = duplex; /* Set MII speed. */ fecp->fec_mii_speed = fep->phy_speed; /* And last, enable the transmit and receive processing. */ fecp->fec_ecntrl = 2; fecp->fec_r_des_active = 0x01000000; netif_start_queue(dev); } 这里的其实是一个内联函数： static inline void netif_start_queue(struct net_device *dev) { clear_bit(__LINK_STATE_XOFF, &dev->state); } 它清除state中的XOFF位。 下面我们继续回到fec_enet_init函数中： /* Queue up command to detect the PHY and initialize the * remainder of the interface. */ fep->phy_id_done = 0; fep->phy_addr = 0; mii_queue(dev, mk_mii_read(MII_REG_PHYIR1), mii_discover_phy); 这里是将命令mk_mii_read(MII_REG_PHYIR1)插入mii的命令队列，并设置回调函数mii_discover_phy。 end fec_enet_init() end fec_enet_module_init() 我们来看一下mii_queue的实现： static int mii_queue(struct net_device *dev, int regval, void (*func)(uint, struct net_device *)) { struct fec_enet_private *fep; unsigned long flags; mii_list_t *mip; int retval; /* Add PHY address to register command. */ fep = netdev_priv(dev); regval |= fep->phy_addr << 23; retval = 0; spin_lock_irqsave(&fep->lock,flags); if ((mip = mii_free) != NULL) { mii_free = mip->mii_next; mip->mii_regval = regval; mip->mii_func = func; mip->mii_next = NULL; if (mii_head) { mii_tail->mii_next = mip; mii_tail = mip; } else { mii_head = mii_tail = mip; fep->hwp->fec_mii_data = regval; } } else { retval = 1; } spin_unlock_irqrestore(&fep->lock,flags); return(retval); } 可以看到，它先是读取FEC硬件寄存器phy_addr的低八位，将它放入变量regval中，这里应该是取PHY的地址，然后先看下 mii_free队列中有无元素，也即是判断有无可用的MII命令队列，如果有，则把寄存器的值（即是要读写PHY的哪个寄存器） 及回调函数放入队列中，再判断mii_head有无元素，如果无的话就将mii_head指向当前这个元素，如果有的话，更新 mii_tail指向当前元素（mii_tail始终指向最后一个命令元素），所以当我们向MII命令队列插入第一个元素的时候，它就 直接读写PHY的那个寄存器（fep->hwp->fec_mii_data = regval;）。而我们前面FEC的MII初始化的时候已经置了MII的中断 ，所以这里往fep->hwp->fec_mii_data寄存器写数据完后便会产生一个FEC中断，这个中断由fec_enet_interrupt函数里调 用fec_enet_mii来处理。 我们再来看下fec_enet_mii的实现： /* called from interrupt context */ static void fec_enet_mii(struct net_device *dev) { struct fec_enet_private *fep; volatile fec_t *ep; mii_list_t *mip; uint mii_reg; fep = netdev_priv(dev); ep = fep->hwp; mii_reg = ep->fec_mii_data; spin_lock(&fep->lock); if ((mip = mii_head) == NULL) { printk(“MII and no head!n”); goto unlock; } if (mip->mii_func != NULL) (*(mip->mii_func))(mii_reg, dev); mii_head = mip->mii_next; mip->mii_next = mii_free; mii_free = mip; if ((mip = mii_head) != NULL) ep->fec_mii_data = mip->mii_regval; unlock: spin_unlock(&fep->lock); } 可以看到，函数首先是读取FEC的硬件寄存器fec_mii_data，这里的值应该是PHY芯片通过MII接口返回上次要求读的寄存器 的值，然后如果有mip->mii_func的话就回调这个函数，接着移动mii_head和mii_free队列，最后再写入下一个要读（写） 的PHY的寄存器。 所以当我们在初始化函数中调用mii_queue(dev, mk_mii_read(MII_REG_PHYIR1), mii_discover_phy);将mii_discover_phy 插入命令队列时，它先将要读的寄存器MII_REG_PHYIR1通过宏mk_mii_read转换成MII寄存器的格式，然后写入fec_mii_data 寄存器，表示我想读取PHY芯片的MII_REG_PHYIR1寄存器的值，而读寄存器写完后，FEC的MII模块会产生一个中断表示说这 个PHY寄存器的读已经完成，然后中断处理函数fec_enet_mii中，会读取PHY返回的刚才我想要读取的寄存器的值给 fec_mii_data寄存器，后来再调用刚才插入的那个mii_discover_phy函数，mii_discover_phy函数就会根据这个返回的ID来 判断是哪个厂家的PHY芯片。这里将mii_discover_phy再帖出来： /* Scan all of the MII PHY addresses looking for someone to respond * with a valid ID. This usually happens quickly. */ static void mii_discover_phy(uint mii_reg, struct net_device *dev) { struct fec_enet_private *fep; volatile fec_t *fecp; uint phytype; fep = netdev_priv(dev); fecp = fep->hwp; if (fep->phy_addr < 32) { if ((phytype = (mii_reg & 0xffff)) != 0xffff && phytype != 0) { /* Got first part of ID, now get remainder. */ fep->phy_id = phytype << 16; mii_queue(dev, mk_mii_read(MII_REG_PHYIR2), mii_discover_phy3); } else { fep->phy_addr ; mii_queue(dev, mk_mii_read(MII_REG_PHYIR1), mii_discover_phy); } } else { printk(“FEC: No PHY device found.n”); /* Disable external MII interface */ fecp->fec_mii_speed = fep->phy_speed = 0; fec_disable_phy_intr(); } } 至于判断fep->phy_addr < 32与否，这个是说一个FEC可以接多个PHY，每个PHY有一个地址，用5个BIT来表示，这里是从 0~31去自加，然后查询对应的PHY地址上是否有PHY设备。 初始化过程中fec_enet_init调用完了之后，dev这个变量已经设置得差不多了，接下来是调用register_netdev(dev) 来注 册一个网络设备，后面fec_device[i] = dev;将这个DEV放入FEC的设备表中。到此，module_init完成。。。
发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/169594.html原文链接：https://javaforall.cn
