|
说是网络，其实是网卡驱动。而且是针对于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完成。。。
|
