Linux2.6.39下dm9k驱动源码分析(二)

2.3、网卡打开操作

问题：open函数在什么时候调用?

答：网卡打开的时候,命令#ifconfig eth0 up,此时网卡被打开,在网卡open函数中应该完成以下操作：

注册中断;设置寄存器,启动设备;启动发送队列,初始化dm9000,复位芯片,检查MII接口。
static int dm9000_open(struct net_device *dev)
{
board_info_t *db = netdev_priv(dev);
unsigned long irqflags = db->irq_res->flags & IRQF_TRIGGER_MASK;

if (netif_msg_ifup(db))
dev_dbg(db->dev, "enabling %s\n", dev->name);

/* If there is no IRQ type specified, default to something that
* may work, and tell the user that this is a problem */

if (irqflags == IRQF_TRIGGER_NONE)
dev_warn(db->dev, "WARNING: no IRQ resource flags set.\n");
//注册中断
irqflags |= IRQF_SHARED;

if (request_irq(dev->irq, dm9000_interrupt, irqflags, dev->name, dev))
return -EAGAIN;

/* GPIO0 on pre-activate PHY, Reg 1F is not set by reset */
iow(db, DM9000_GPR, 0); /* REG_1F bit0 activate phyxcer */
mdelay(1); /* delay needs by DM9000B */

/* Initialize DM9000 board */
dm9000_reset(db);//复位芯片
dm9000_init_dm9000(dev);//初始化dm9K,初始化芯片的寄存器

/* Init driver variable */
db->dbug_cnt = 0;

//检查MII接口
mii_check_media(&db->mii, netif_msg_link(db), 1);
/**开启网络接口发送数据队列*/
netif_start_queue(dev);
/*之前在probe函数中已经使用 INIT_DELAYED_WORK来初始化一个延迟工作队列并关联了一个操作函数dm9000_poll_work()， 此时运行schedule来调用这个函数*/
dm9000_schedule_poll(db);

return 0;
}

/* dm9k复位操作往network ctl 控制寄存器写数据*/

static void dm9000_reset(board_info_t * db)
{
dev_dbg(db->dev, "resetting device\n");

/* RESET device */
//写地址 00h
writeb(DM9000_NCR, db->io_addr);
udelay(200);
//写1
writeb(NCR_RST, db->io_data);
udelay(200);
}

/*
*初始化dm9k硬件信息
*/
static void dm9000_init_dm9000(struct net_device *dev)
{
board_info_t *db = netdev_priv(dev);
unsigned int imr;
unsigned int ncr;

dm9000_dbg(db, 1, "entering %s\n", __func__);

/* I/O mode */
//读中断状态寄存器
db->io_mode = ior(db, DM9000_ISR) >> 6; /* ISR bit7:6 keeps I/O mode */

/* Checksum mode */
dm9000_set_rx_csum_unlocked(dev, db->rx_csum);//校验模式

iow(db, DM9000_GPCR, GPCR_GEP_CNTL); /* Let GPIO0 output */

ncr = (db->flags & DM9000_PLATF_EXT_PHY) ? NCR_EXT_PHY : 0;

/* if wol is needed, then always set NCR_WAKEEN otherwise we end
* up dumping the wake events if we disable this. There is already
* a wake-mask in DM9000_WCR */
if (db->wake_supported)
ncr |= NCR_WAKEEN;

iow(db, DM9000_NCR, ncr);

/* Program operating register */
iow(db, DM9000_TCR, 0); /* TX Polling clear */
iow(db, DM9000_BPTR, 0x3f); /* Less 3Kb, 200us */
iow(db, DM9000_FCR, 0xff); /* Flow Control */
iow(db, DM9000_SMCR, 0); /* Special Mode */
/* clear TX status */
iow(db, DM9000_NSR, NSR_WAKEST | NSR_TX2END | NSR_TX1END);
iow(db, DM9000_ISR, ISR_CLR_STATUS); /* Clear interrupt status */

/* Set address filter table */
dm9000_hash_table_unlocked(dev);

imr = IMR_PAR | IMR_PTM | IMR_PRM;
if (db->type != TYPE_DM9000E)
imr |= IMR_LNKCHNG;

db->imr_all = imr;

/* Enable TX/RX interrupt mask */
iow(db, DM9000_IMR, imr);

/* Init Driver variable */
db->tx_pkt_cnt = 0;
db->queue_pkt_len = 0;
dev->trans_start = jiffies;
}

2.4、数据发送

问题：数据发送函数在什么时候调用

答：当网卡有数据要发送的时候,该函数被调用

/*
* Hardware start transmission.
* Send a packet to media from the upper layer.
*/
static int dm9000_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
unsigned long flags;
board_info_t *db = netdev_priv(dev);//获取net_device私有数据

dm9000_dbg(db, 3, "%s:\n", __func__);

if (db->tx_pkt_cnt > 1)
return NETDEV_TX_BUSY;
//屏蔽自旋锁并将目前的的状态写入flags中
spin_lock_irqsave(&db->lock, flags);
// 将skb中的data部分写入DM9000的TX RAM，
/* Move data to DM9000 TX RAM */
writeb(DM9000_MWCMD, db->io_addr);
//更新已经发送的字节数和字节计数
(db->outblk)(db->io_data, skb->data, skb->len);
dev->stats.tx_bytes += skb->len;

db->tx_pkt_cnt++;
/* TX control: First packet immediately send, second packet queue */
if (db->tx_pkt_cnt == 1) {
dm9000_send_packet(dev, skb->ip_summed, skb->len);
} else {
/* Second packet */
db->queue_pkt_len = skb->len;
db->queue_ip_summed = skb->ip_summed;
netif_stop_queue(dev);
}
//恢复之前的自旋锁
spin_unlock_irqrestore(&db->lock, flags);

/* free this SKB */
dev_kfree_skb(skb);

return NETDEV_TX_OK;
}

static void dm9000_send_packet(struct net_device *dev,
int ip_summed,
u16 pkt_len)
{
board_info_t *dm = to_dm9000_board(dev);

/* The DM9000 is not smart enough to leave fragmented packets alone. */
if (dm->ip_summed != ip_summed) {
if (ip_summed == CHECKSUM_NONE)
iow(dm, DM9000_TCCR, 0);
else
iow(dm, DM9000_TCCR, TCCR_IP | TCCR_UDP | TCCR_TCP);
dm->ip_summed = ip_summed;
}
//配置TX长度
/* Set TX length to DM9000 */
iow(dm, DM9000_TXPLL, pkt_len);
iow(dm, DM9000_TXPLH, pkt_len >> 8);
//发送数据将TX控制寄存器的0位配置1
/* Issue TX polling command */
iow(dm, DM9000_TCR, TCR_TXREQ); /* Cleared after TX complete */
}

2.4、中断处理函数

问题：网卡有几种类型的中断

答：网卡有三种中断：新报文到达中断,报文发送完成中断,出错中断,当数据包发送完后会出发该中断函数

static irqreturn_t dm9000_interrupt(int irq, void *dev_id)
{
struct net_device *dev = dev_id;
board_info_t *db = netdev_priv(dev);
int int_status;
unsigned long flags;
u8 reg_save;

dm9000_dbg(db, 3, "entering %s\n", __func__);

/* A real interrupt coming */

/* holders of db->lock must always block IRQs */
spin_lock_irqsave(&db->lock, flags);
//保存之前的IO地址
/* Save previous register address */
reg_save = readb(db->io_addr);
//关闭所有的中断
/* Disable all interrupts */
iow(db, DM9000_IMR, IMR_PAR);
//读取中断状态寄存器
/* Got DM9000 interrupt status */
int_status = ior(db, DM9000_ISR); /* Got ISR */
//清中断
iow(db, DM9000_ISR, int_status); /* Clear ISR status */

if (netif_msg_intr(db))
dev_dbg(db->dev, "interrupt status %02x\n", int_status);
//新报文达到中断
/* Received the coming packet */
if (int_status & ISR_PRS)
dm9000_rx(dev);
//报文发送完成中断
/* Trnasmit Interrupt check */
if (int_status & ISR_PTS)
dm9000_tx_done(dev, db);//包发送完

if (db->type != TYPE_DM9000E) {
if (int_status & ISR_LNKCHNG) {
/* fire a link-change request */
schedule_delayed_work(&db->phy_poll, 1);
}
}
//重新使能中断
/* Re-enable interrupt mask */
iow(db, DM9000_IMR, db->imr_all);
//恢复之前的IO地址
/* Restore previous register address */
writeb(reg_save, db->io_addr);

spin_unlock_irqrestore(&db->lock, flags);

return IRQ_HANDLED;
}

2.5、包接收

当网卡接收到数据时,产生中断,在中断处理函数中通过中断状态寄存器判断出是否接收中断,接着使用函数dm9000_rx处理接收到的数据

/*
* Received a packet and pass to upper layer
*/
static void
dm9000_rx(struct net_device *dev)
{
board_info_t *db = netdev_priv(dev);
struct dm9000_rxhdr rxhdr;
struct sk_buff *skb;
u8 rxbyte, *rdptr;
bool GoodPacket;
int RxLen;

/* Check packet ready or not */
do {
ior(db, DM9000_MRCMDX); /* Dummy read */

/* Get most updated data */
rxbyte = readb(db->io_data);

/* Status check: this byte must be 0 or 1 */
if (rxbyte & DM9000_PKT_ERR) {
dev_warn(db->dev, "status check fail: %d\n", rxbyte);
iow(db, DM9000_RCR, 0x00); /* Stop Device */
iow(db, DM9000_ISR, IMR_PAR); /* Stop INT request */
return;
}

if (!(rxbyte & DM9000_PKT_RDY))
return;

/* A packet ready now & Get status/length */
GoodPacket = true;
writeb(DM9000_MRCMD, db->io_addr);

(db->inblk)(db->io_data, &rxhdr, sizeof(rxhdr));

RxLen = le16_to_cpu(rxhdr.RxLen);

if (netif_msg_rx_status(db))
dev_dbg(db->dev, "RX: status %02x, length %04x\n",
rxhdr.RxStatus, RxLen);

/* Packet Status check */
if (RxLen < 0x40) {
GoodPacket = false;
if (netif_msg_rx_err(db))
dev_dbg(db->dev, "RX: Bad Packet (runt)\n");
}

if (RxLen > DM9000_PKT_MAX) {
dev_dbg(db->dev, "RST: RX Len:%x\n", RxLen);
}

/* rxhdr.RxStatus is identical to RSR register. */
if (rxhdr.RxStatus & (RSR_FOE | RSR_CE | RSR_AE |
RSR_PLE | RSR_RWTO |
RSR_LCS | RSR_RF)) {
GoodPacket = false;
if (rxhdr.RxStatus & RSR_FOE) {
if (netif_msg_rx_err(db))
dev_dbg(db->dev, "fifo error\n");
dev->stats.rx_fifo_errors++;
}
if (rxhdr.RxStatus & RSR_CE) {
if (netif_msg_rx_err(db))
dev_dbg(db->dev, "crc error\n");
dev->stats.rx_crc_errors++;
}
if (rxhdr.RxStatus & RSR_RF) {
if (netif_msg_rx_err(db))
dev_dbg(db->dev, "length error\n");
dev->stats.rx_length_errors++;
}
}

/* Move data from DM9000 */
if (GoodPacket &&
((skb = dev_alloc_skb(RxLen + 4)) != NULL)) {
skb_reserve(skb, 2);
rdptr = (u8 *) skb_put(skb, RxLen - 4);

/* Read received packet from RX SRAM */

(db->inblk)(db->io_data, rdptr, RxLen);
dev->stats.rx_bytes += RxLen;

/* Pass to upper layer */
skb->protocol = eth_type_trans(skb, dev);
if (db->rx_csum) {
if ((((rxbyte & 0x1c) << 3) & rxbyte) == 0)
skb->ip_summed = CHECKSUM_UNNECESSARY;
else
skb_checksum_none_assert(skb);
}
netif_rx(skb);
dev->stats.rx_packets++;

} else {
/* need to dump the packet's data */

(db->dumpblk)(db->io_data, RxLen);
}
} while (rxbyte & DM9000_PKT_RDY);
}