【概述】
该文描述了CS8900A网卡芯片，在Linux中的驱动程序的原理，以SMDK2410平台为例。
CS8900A在该驱动中，仍工作于IO访问模式。
本文详细描述了作为Linux网络设备驱动，需要实现的几个函数的工作原理，这几个函数为：
--cs8900_probe
--cs8900_start
--cs8900_stop
--cs8900_send_start
其他几个函数，暂时没在本文中得到叙述：
--cs8900_get_stats
--cs8900_set_receive_mode
--cs8900_transmit_timeout
【环境】
硬件：EBD2410开发板（S3C2410+CS8900A）
Linux版本：V2.6.20
【cs8900_init() 函数】
初始化函数，在系统启动时得到调用：
module_init (cs8900_init);
static int __init cs8900_init (void)
{
struct net_device *ndev;
ndev = alloc_etherdev(sizeof (cs8900_t));
if (!ndev) {
printk("%s: could not allocate device./n", "cs8900");
return -ENOMEM;
}
cs8900_dev = ndev;
cs8900_dev->init = cs8900_probe;
ether_setup (ndev);
ndev->open = cs8900_start;
ndev->stop = cs8900_stop;
ndev->hard_start_xmit = cs8900_send_start;
ndev->get_stats = cs8900_get_stats;
ndev->set_multicast_list = cs8900_set_receive_mode;
ndev->tx_timeout = cs8900_transmit_timeout;
ndev->watchdog_timeo = HZ;
return (register_netdev (cs8900_dev));
}
该函数申请了一个
net_device 类型的
结构体，并对结构体相关成员作初始化后，注册网络设备。
我们可以看见驱动需要实现相关的net_device 中的函数体：
cs8900_start：打开网络设备
cs8900_stop：关闭网络设备
cs8900_send_start:通知发送网络数据
cs8900_get_stats：获取状态
cs8900_set_receive_mode：设置接收模式，如是全部接收（Promiscuous模式），接收广播等
cs8900_transmit_timeout：发送超时的处理函数
【cs8900_probe()函数】
设备程序的初始化由net_device结构体中的init()函数完成，这个函数将在net_device被注册时自动被调用。我们在上面提到的函数中将其赋值为cs8900_probe
int __init cs8900_probe (struct net_device *dev)
{
//两个很重要的成员变量赋值：
dev->base_addr = vSMDK2410_ETH_IO + 0x300;
dev->irq = IRQ_EINT9;
//......
//映射地址空间
if ((result = check_mem_region (dev->base_addr, 16))) ......
request_mem_region (dev->base_addr, 16, dev->name);
//......
//检测芯片的型号及版本号
if ((value = cs8900_read (dev,PP_ProductID)) != EISA_REG_CODE)......
value = cs8900_read (dev,PP_ProductID + 2);
if (VERSION (value) != CS8900A) ......
//......
//设置中断线使用INTRQ0
cs8900_write (dev,PP_IntNum,0);
//设置MAC地址
for (i = 0; i < ETH_ALEN; i += 2)
cs8900_write (dev,PP_IA + i,dev->dev_addr[i] | (dev->dev_addr[i + 1] << 8));
//......
}
【cs8900_start() 函数】
网络设备的打开函数，其完成使能设备，设置中断，申请IO区域，DMA通道等；激活发送队列
static int cs8900_start (struct net_device *dev)
{
int result;
set_irq_type(dev->irq, IRQT_RISING);
/* enable the ethernet controller */
cs8900_set (dev,PP_RxCFG,RxOKiE | BufferCRC | CRCerroriE | RuntiE | ExtradataiE);
cs8900_set (dev,PP_RxCTL,RxOKA | IndividualA | BroadcastA);
cs8900_set (dev,PP_TxCFG,TxOKiE | Out_of_windowiE | JabberiE);
cs8900_set (dev,PP_BufCFG,Rdy4TxiE | RxMissiE | TxUnderruniE | TxColOvfiE | MissOvfloiE);
cs8900_set (dev,PP_LineCTL,SerRxON | SerTxON);
cs8900_set (dev,PP_BusCTL,EnableRQ);
#ifdef FULL_DUPLEX
cs8900_set (dev,PP_TestCTL,FDX);
#endif
/* #ifdef FULL_DUPLEX */
udelay(200);
/* install interrupt handler */
if ((result = request_irq (dev->irq, &cs8900_interrupt, 0, dev->name, dev)) < 0) {
printk (KERN_ERR "%s: could not register interrupt %d/n",dev->name, dev->irq);
return (result);
}
/* start the queue */
netif_start_queue (dev);
return (0);
}
CS8900驱动中的这个函数完成了如下任务：
1：设置芯片相关的寄存器：
--设置PP_RxCFG寄存器，使其能响应如下中断：接收正确，校验错误，短包接收中断，长包接收中断；且使得CRC包含在接收的数据缓冲区中。
--设置PP_RxCTL寄存器，使其接收校验正确，地址匹配的包，以及广播包。
--设置PP_TxCFG寄存器，使其能响应如下中断：发送正确，后冲突检测，发送时间过长（大于26mS）
--设置PP_BufCFG寄存器，使其能响应如下中断：发送缓冲区可用，接收数据丢失，发送缓冲区欠载，TX冲突计数器溢出，Rx丢弃计数器溢出。
--设置PP_LineCTL寄存器，开启数据发送/接收功能
--设置PP_BusCTL寄存器，开启全局中断使能
--若工作于全双工模式，则设置PP_TestCTL的FDX位。
2：申请中断
3：激活设备发送队列
【cs8900_stop() 函数】
网络设备的关闭函数，首先禁用设备发送队列，随后释放一切资源。
static int cs8900_stop (struct net_device *dev)
{
/* disable ethernet controller */
cs8900_write (dev,PP_BusCTL,0);
cs8900_write (dev,PP_TestCTL,0);
cs8900_write (dev,PP_SelfCTL,0);
cs8900_write (dev,PP_LineCTL,0);
cs8900_write (dev,PP_BufCFG,0);
cs8900_write (dev,PP_TxCFG,0);
cs8900_write (dev,PP_RxCTL,0);
cs8900_write (dev,PP_RxCFG,0);
/* uninstall interrupt handler */
free_irq (dev->irq,dev);
/* stop the queue */
netif_stop_queue (dev);
return (0);
}
【cs8900_send_start()函数】
数据发送函数接收上层函数传递的sk_buff参数，获得数据包的地址和长度，通过调用硬件相关操作完成发送。
static int cs8900_send_start (struct sk_buff *skb,struct net_device *dev)
{
cs8900_t *priv = (cs8900_t *) dev->priv;
u16 status;
spin_lock_irq(&priv->lock);
netif_stop_queue (dev);
cs8900_write (dev,PP_TxCMD,TxStart (After5));
cs8900_write (dev,PP_TxLength,skb->len);
status = cs8900_read (dev,PP_BusST);
if ((status & TxBidErr)) {
spin_unlock_irq(&priv->lock);
printk (KERN_WARNING "%s: Invalid frame size %d!/n",dev->name,skb->len);
priv->stats.tx_errors++;
priv->stats.tx_aborted_errors++;
priv->txlen = 0;
return (1);
}
if (!(status & Rdy4TxNOW)) {
spin_unlock_irq(&priv->lock);
printk (KERN_WARNING "%s: Transmit buffer not free!/n",dev->name);
priv->stats.tx_errors++;
priv->txlen = 0;
/* FIXME: store skb and send it in interrupt handler */
return (1);
}
cs8900_frame_write (dev,skb);
spin_unlock_irq(&priv->lock);
#ifdef DEBUG
dump_packet (dev,skb,"send");
#endif
/* #ifdef DEBUG */
dev->trans_start = jiffies;
dev_kfree_skb (skb);
priv->txlen = skb->len;
return (0);
}
关于硬件层的操作，参考文档《
CS8900网卡在U-boot中的使用
》
【数据包发送】
该函数完成以下功能：
1：尝试获得自旋锁，随后暂时禁用设备发送队列。
2：告知CS8900需要发送数据，以及数据的长度
3：读取CS8900的状态，通过读取PP_BusST寄存器：
--若TxBidErr置位，则表示数据长度不合法，返回错误
--若Rdy4TxNOW没被置位，则表示硬件还没准备好，返回错误
--若一切正常，则开始发送数据
4：调用函数cs8900_frame_write发送数据。
5：记录发送这个包的时间，以及释放skb缓冲区
【cs8900_receive() 函数】
网络设备接收数据的主要方法是由中断引发设备的中断处理函数，中断处理函数调用该函数。
static void cs8900_receive (struct net_device *dev)
{
cs8900_t *priv = (cs8900_t *) dev->priv;
struct sk_buff *skb;
u16 status,length;
status = cs8900_read (dev,PP_RxStatus);
length = cs8900_read (dev,PP_RxLength);
if (!(status & RxOK)) {
priv->stats.rx_errors++;
if ((status & (Runt | Extradata))) priv->stats.rx_length_errors++;
if ((status & CRCerror)) priv->stats.rx_crc_errors++;
return;
}
if ((skb = dev_alloc_skb (length + 4)) == NULL) {
priv->stats.rx_dropped++;
return;
}
skb->dev = dev;
skb_reserve (skb,2);
cs8900_frame_read (dev,skb,length);
#ifdef FULL_DUPLEX
dump_packet (dev,skb,"recv");
#endif
/* #ifdef FULL_DUPLEX */
skb->protocol = eth_type_trans (skb,dev);
netif_rx (skb);
dev->last_rx = jiffies;
priv->stats.rx_packets++;
priv->stats.rx_bytes += length;
}
关于硬件层的操作，参考文档《CS8900网卡在U-boot中的使用》【数据包接收】
该函数主要完成如下功能：
1：通过读取硬件寄存器，获取CS8900A的状态，以及这次接收的长度。、
2：解析状态，若不是RxOK状态，则判断错误类型（此处读取的是PP_RxStatus地址，其和RxEvent寄存器内容相同）
--若为Runt或Extradata，表示数据包长度不合法
--若为CRCerror，表示数据包校验错误
--若一切正常，则开始接收数据
3：申请一个skb缓冲区，并调用cs8900_frame_read()函数接收数据。
4：数据接收完成后，调用netif_rx()函数通知上层。
【cs8900_interrupt()函数】
此函数为中断响应函数，在open函数注册中断时传递给中断注册函数。
static irqreturn_t cs8900_interrupt (int irq,void *id)
{
struct net_device *dev = (struct net_device *) id;
cs8900_t *priv;
volatile u16 status;
irqreturn_t handled = 0;
if (dev->priv == NULL) {
printk (KERN_WARNING "%s: irq %d for unknown device./n",dev->name,irq);
return 0;
}
priv = (cs8900_t *) dev->priv;
while ((status = cs8900_read (dev, PP_ISQ))) {
handled = 1;
switch (RegNum (status)) {
case RxEvent:
cs8900_receive (dev);
break;
case TxEvent:
priv->stats.collisions += ColCount (cs8900_read (dev,PP_TxCOL));
if (!(RegContent (status) & TxOK)) {
priv->stats.tx_errors++;
if ((RegContent (status) & Out_of_window)) priv->stats.tx_window_errors++;
if ((RegContent (status) & Jabber)) priv->stats.tx_aborted_errors++;
break;
} else if (priv->txlen) {
priv->stats.tx_packets++;
priv->stats.tx_bytes += priv->txlen;
}
priv->txlen = 0;
netif_wake_queue (dev);
break;
case BufEvent:
if ((RegContent (status) & RxMiss)) {
u16 missed = MissCount (cs8900_read (dev,PP_RxMISS));
priv->stats.rx_errors += missed;
priv->stats.rx_missed_errors += missed;
}
if ((RegContent (status) & TxUnderrun)) {
priv->stats.tx_errors++;
priv->stats.tx_fifo_errors++;
priv->txlen = 0;
netif_wake_queue (dev);
}
/* FIXME: if Rdy4Tx, transmit last sent packet (if any) */
break;
case TxCOL:
priv->stats.collisions += ColCount (cs8900_read (dev,PP_TxCOL));
break;
case RxMISS:
status = MissCount (cs8900_read (dev,PP_RxMISS));
priv->stats.rx_errors += status;
priv->stats.rx_missed_errors += status;
break;
}
}
return IRQ_RETVAL(handled);
}
该函数先读取PP_ISQ寄存器，判断中断的类型，做出相应的操作：
--RxEvent：表示接收数据中断，因此调用数据接收函数
--TxEvent：表示上一次的数据发送已经完成，随后再进行发送的情况检测：
--读取PP_TxCOL寄存器，查看是否有冲突产生，并增加相应的冲突计数。
--若非发送成功，则根据Out_of_window或Jabber错误标识，分别作相关的计数。
--若发送成功，通过增加相关计数
--调用netif_wake_queue()，重新激活发送队列
--BufEvent：和buffer有关的情况：
--RxMiss：表示有接收数据包丢失
--TxUnderrun：表示发送缓冲区欠载
--TxCOL：表示检测到发送冲突
--RxMISS：表示有接收数据丢失，因为CPU没有及时将上一次数据取走。
【通过IO空间访问CS8900A的几个函数】
原理都很简单，参考文档《CS8900网卡在U-boot中的使用》【通过I/O空间访问CS8900的内部寄存器】
static inline u16 cs8900_read (struct net_device *dev,u16 reg)
{
outw (reg,dev->base_addr + PP_Address);
return (inw (dev->base_addr + PP_Data));
}
static inline void cs8900_write (struct net_device *dev,u16 reg,u16 value)
{
outw (reg,dev->base_addr + PP_Address);
outw (value,dev->base_addr + PP_Data);
}
static inline void cs8900_set (struct net_device *dev,u16 reg,u16 value)
{
cs8900_write (dev,reg,cs8900_read (dev,reg) | value);
}
static inline void cs8900_clear (struct net_device *dev,u16 reg,u16 value)
{
cs8900_write (dev,reg,cs8900_read (dev,reg) & ~value);
}
//以下为发送及接收网络数据部分
static inline void cs8900_frame_read (struct net_device *dev,struct sk_buff *skb,u16 length)
{
insw (dev->base_addr,skb_put (skb,length),(length + 1) / 2);
}
static inline void cs8900_frame_write (struct net_device *dev,struct sk_buff *skb)
{
outsw (dev->base_addr,skb->data,(skb->len + 1) / 2);
}
【后续问题】
1：Linux IO空间地址的映射：
check_mem_region();
request_mem_region();
2；与发送队列相关的操作：
netif_wake_queue();
netif_start_queue();
netif_stop_queue();
【问题】
1：net_device结构体中的tx_timeout()函数如何调用的？
【其他补充】
1：Interrupt Number的设定：
根据Datasheet中的描述：
00b: INTRQ0
01b: INTRQ1
10b: INTRQ2
11b: INTRQ3
1xxb: All high-impedance
根据电路图：使用的是INRQ0。
但在驱动中却赋值为：0x0000，详情为：
int __init cs8900_probe (struct net_device *dev)
{
cs8900_write (dev,PP_IntNum,0);
}
#define PP_IntNum 0x0022
2：关于ISQ寄存器（Interrupt Status Queue）
CPU在响应硬件中断时，读取该寄存器以确定中断的内容。该寄存器会被映射到相应的状态寄存器，其低5位表示被映射的寄存器号，其他位则是这个被映射寄存器的内容。
被映射的寄存器为：RxEvent, TxEvent, BufEvent, RxMISS, TxCOL。
538
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
