网卡驱动3：DM9000驱动解析2

/*
* Initilize dm9000 board
 配置DM9000芯片内部寄存器，使其能工作
*/
static void
dm9000_init_dm9000(struct net_device *dev)
{
board_info_t *db = (board_info_t *) dev->priv;
 PRINTK1("entering %s/n",__FUNCTION__);
 /* I/O mode
检查当前芯片的总线带宽8bit，16bit，32bit
芯片的总线带宽由硬件走线决定 */
db->io_mode = ior(db, DM9000_ISR) >> 6; /* ISR bit7:6 keeps I/O mode */
 /* GPIO0 on pre-activate PHY
启动PHY*/
iow(db, DM9000_GPR, 0); /* REG_1F bit0 activate phyxcer */
iow(db, DM9000_GPCR, GPCR_GEP_CNTL); /* Let GPIO0 output */
iow(db, DM9000_GPR, 0); /* Enable PHY */
 /* 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(dev);
 /* Activate DM9000
接收包大小不能超过1.5k,CRC错误的抛弃，使能接收*/
iow(db, DM9000_RCR, RCR_DIS_LONG | RCR_DIS_CRC | RCR_RXEN);
/* Enable TX/RX interrupt mask
使用发送，接收中断。SRAM缓冲区指针自动回0 */
iow(db, DM9000_IMR, IMR_PAR | IMR_PTM | IMR_PRM);
 /* Init Driver variable */
db->tx_pkt_cnt = 0;
db->queue_pkt_len = 0;
dev->trans_start = 0;
}
 /*
* 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)
{
board_info_t *db = (board_info_t *) dev->priv;
 PRINTK3("dm9000_start_xmit/n");
 if (db->tx_pkt_cnt > 1)
 return 1;
/*停止接收*/
netif_stop_queue(dev);
/* Disable all interrupts
关闭发送，接收中断*/
iow(db, DM9000_IMR, IMR_PAR);
 /* Move data to DM9000 TX RAM */
writeb(DM9000_MWCMD, db->io_addr);
/*把skb的数据拷贝到DM9000的SRAM中*/
(db->outblk)(db->io_data, skb->data, skb->len);
/*统计值加上相应的长度*/
db->stats.tx_bytes += skb->len;
 /* TX control: First packet immediately send, second packet queue */
if (db->tx_pkt_cnt == 0) {
 /* First Packet
发送的包增加*/
 db->tx_pkt_cnt++;
 /* Set TX length to DM9000
设定DM9000需要发送的包长度*/
 iow(db, DM9000_TXPLL, skb->len & 0xff);
 iow(db, DM9000_TXPLH, (skb->len >> 8) & 0xff);
 /* Issue TX polling command
设定发送请求，即启动发送*/
 iow(db, DM9000_TCR, TCR_TXREQ); /* Cleared after TX complete */
 /*启动时间*/
 dev->trans_start = jiffies; /* save the time stamp */
 } else {
 /*第二个包发送，在tx_done中实现*/
 /* Second packet */
 db->tx_pkt_cnt++;
 db->queue_pkt_len = skb->len;
}
 /* free this SKB
发送完毕释放skb */
dev_kfree_skb(skb);
 /* Re-enable resource check
第一个包发送完毕，即内存拷贝完毕，不是实际总线上的
可以启动第二包拷贝到SRAM*/
if (db->tx_pkt_cnt == 1)
 netif_wake_queue(dev);
 /* Re-enable interrupt
重新启用中断，这时DM9000若发送完成，会产生发送完毕中断*/
iow(db, DM9000_IMR, IMR_PAR | IMR_PTM | IMR_PRM);
 return 0;
}
 static void
dm9000_shutdown(struct net_device *dev)
{
board_info_t *db = (board_info_t *) dev->priv;
 /* RESET device */
dm9000_phy_write(dev, 0, MII_BMCR, BMCR_RESET); /* PHY RESET */
/*关闭PHY*/
iow(db, DM9000_GPR, 0x01); /* Power-Down PHY */
/*屏蔽所有中断*/
iow(db, DM9000_IMR, IMR_PAR); /* Disable all interrupt */
/*禁用接收*/
iow(db, DM9000_RCR, 0x00); /* Disable RX */
}
 /*
* Stop the interface.
* The interface is stopped when it is brought.
*/
static int
dm9000_stop(struct net_device *ndev)
{
board_info_t *db = (board_info_t *) ndev->priv;
 PRINTK1("entering %s/n",__FUNCTION__);
 /* deleted timer
删除内核定时器*/
del_timer(&db->timer);
/*通知内核队列不可用*/
netif_stop_queue(ndev);
/*linkstat 状态断路*/
netif_carrier_off(ndev);
 /* free interrupt
释放中断*/
free_irq(ndev->irq, ndev);
/*硬件上关闭芯片*/
dm9000_shutdown(ndev);
 return 0;
}
 /*
* DM9000 interrupt handler
* receive the packet to upper layer, free the transmitted packet
*/
 static void
dm9000_tx_done(struct net_device *dev, board_info_t * db)
{
int tx_status = ior(db, DM9000_NSR); /* Got TX status */
 /*一个包已经发送完毕*/
if (tx_status & (NSR_TX2END | NSR_TX1END)) {
 /* One packet sent complete */
 db->tx_pkt_cnt--;
 db->stats.tx_packets++;
 /* Queue packet check & send
当前还有一个包未发送，且在缓冲区中，是第二个包*/
 if (db->tx_pkt_cnt > 0) {
 /*设定DM9000发送包的长度*/
 iow(db, DM9000_TXPLL, db->queue_pkt_len & 0xff);
 iow(db, DM9000_TXPLH, (db->queue_pkt_len >> 8) & 0xff);
 /*启动发送*/
 iow(db, DM9000_TCR, TCR_TXREQ);
 dev->trans_start = jiffies;
 }
 /*通知内核*/
 netif_wake_queue(dev);
}
}
 static irqreturn_t
dm9000_interrupt(int irq, void *dev_id)
{
struct net_device *dev = dev_id;
board_info_t *db;
int int_status;
u8 reg_save;
 PRINTK3("entering %s/n",__FUNCTION__);
 if (!dev) {
 PRINTK1("dm9000_interrupt() without DEVICE arg/n");
 return IRQ_HANDLED;
}
 /* A real interrupt coming */
db = (board_info_t *) dev->priv;
spin_lock(&db->lock);
 /* 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 */
 /* 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);
 /* Re-enable interrupt mask */
iow(db, DM9000_IMR, IMR_PAR | IMR_PTM | IMR_PRM);
 /* Restore previous register address */
writeb(reg_save, db->io_addr);
 spin_unlock(&db->lock);
 return IRQ_HANDLED;
}
 /*
* Get statistics from driver.
获取网卡接口统计信息
*/
static struct net_device_stats *
dm9000_get_stats(struct net_device *dev)
{
board_info_t *db = (board_info_t *) dev->priv;
return &db->stats;
}
 
/*
* A periodic timer routine
* Dynamic media sense, allocated Rx buffer...
*/
static void
dm9000_timer(unsigned long data)
{
struct net_device *dev = (struct net_device *) data;
board_info_t *db = (board_info_t *) dev->priv;
 PRINTK3("dm9000_timer()/n");
/*检查mii接口*/
mii_check_media(&db->mii, netif_msg_link(db), 0);
 /* Set timer again
重新启动内核定时器，周期检查mii接口 */
db->timer.expires = DM9000_TIMER_WUT;
add_timer(&db->timer);
}
/*DM9000接收包头，芯片提供
01，status，length low,length high*/
struct dm9000_rxhdr {
u16 RxStatus;
u16 RxLen;
} __attribute__((__packed__));
 /*
* Received a packet and pass to upper layer
*/
static void
dm9000_rx(struct net_device *dev)
{
board_info_t *db = (board_info_t *) dev->priv;
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
接收包最长为1536 */
 if (rxbyte > DM9000_PKT_RDY) {
 printk("status check failed: %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);
 /*获取接收数据包头，共4字节，参考DM9000手册*/
 (db->inblk)(db->io_data, &rxhdr, sizeof(rxhdr));
 /*查看包长*/
 RxLen = rxhdr.RxLen;
 /* Packet Status check
包长不能小于64字节*/
 if (RxLen < 0x40) {
 GoodPacket = false;
 PRINTK1("Bad Packet received (runt)/n");
 }
 /*包长不能大于1536字节*/
 if (RxLen > DM9000_PKT_MAX) {
 PRINTK1("RST: RX Len:%x/n", RxLen);
 }
 /*接收的包有错误*/
 if (rxhdr.RxStatus & 0xbf00) {
 GoodPacket = false;
 if (rxhdr.RxStatus & 0x100) {
 PRINTK1("fifo error/n");
 db->stats.rx_fifo_errors++;
 }
 if (rxhdr.RxStatus & 0x200) {
 PRINTK1("crc error/n");
 db->stats.rx_crc_errors++;
 }
 if (rxhdr.RxStatus & 0x8000) {
 PRINTK1("length error/n");
 db->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 */
 /*数据从DM9000内存拷贝到skb*/
 (db->inblk)(db->io_data, rdptr, RxLen);
 /*更新接收字节数统计*/
 db->stats.rx_bytes += RxLen;
 /* Pass to upper layer */
 skb->protocol = eth_type_trans(skb, dev);
 /*通知上层有新的skb收到*/
 netif_rx(skb);
 /*接收包更新*/
 db->stats.rx_packets++;
 } else {
 /* need to dump the packet's data */
 (db->dumpblk)(db->io_data, RxLen);
 }
} while (rxbyte == DM9000_PKT_RDY);
}
 /*
* Read a word data from SROM
 从EEPROM9346中读取数据 16bit
*/
static u16
read_srom_word(board_info_t * db, int offset)
{
iow(db, DM9000_EPAR, offset);
iow(db, DM9000_EPCR, EPCR_ERPRR);
mdelay(8); /* according to the datasheet 200us should be enough,
 but it doesn't work */
iow(db, DM9000_EPCR, 0x0);
return (ior(db, DM9000_EPDRL) + (ior(db, DM9000_EPDRH) << 8));
}
 #ifdef DM9000_PROGRAM_EEPROM
/*
* Write a word data to SROM
向EEPROM 9346中写数据 16bit
*/
static void
write_srom_word(board_info_t * db, int offset, u16 val)
{
iow(db, DM9000_EPAR, offset);
iow(db, DM9000_EPDRH, ((val >> 8) & 0xff));
iow(db, DM9000_EPDRL, (val & 0xff));
iow(db, DM9000_EPCR, EPCR_WEP | EPCR_ERPRW);
mdelay(8); /* same shit */
iow(db, DM9000_EPCR, 0);
}
 /*
* Only for development:
* Here we write static data to the eeprom in case
* we don't have valid content on a new board
*/
static void
program_eeprom(board_info_t * db)
{
u16 eeprom[] = { 0x0c00, 0x007f, 0x1300, /* MAC Address */
 0x0000, /* Autoload: accept nothing */
 0x0a46, 0x9000, /* Vendor / Product ID */
 0x0000, /* pin control */
 0x0000,
}; /* Wake-up mode control */
int i;
for (i = 0; i < 8; i++)
 write_srom_word(db, i, eeprom[i]);
}
#endif
 
/*
* Calculate the CRC valude of the Rx packet
* flag = 1 : return the reverse CRC (for the received packet CRC)
* 0 : return the normal CRC (for Hash Table index)
 计算接收包的crc值
*/
 static unsigned long
cal_CRC(unsigned char *Data, unsigned int Len, u8 flag)
{
 u32 crc = ether_crc_le(Len, Data);
 if (flag)
 return ~crc;
 return crc;
}
 /*
* Set DM9000 multicast address
*/
static void
dm9000_hash_table(struct net_device *dev)
{
board_info_t *db = (board_info_t *) dev->priv;
struct dev_mc_list *mcptr = dev->mc_list;
int mc_cnt = dev->mc_count;
u32 hash_val;
u16 i, oft, hash_table[4];
unsigned long flags;
 PRINTK2("dm9000_hash_table()/n");
 spin_lock_irqsave(&db->lock,flags);
 for (i = 0, oft = 0x10; i < 6; i++, oft++)
 iow(db, oft, dev->dev_addr[i]);
 /* Clear Hash Table */
for (i = 0; i < 4; i++)
 hash_table[i] = 0x0;
 /* broadcast address */
hash_table[3] = 0x8000;
 /* the multicast address in Hash Table : 64 bits */
for (i = 0; i < mc_cnt; i++, mcptr = mcptr->next) {
 hash_val = cal_CRC((char *) mcptr->dmi_addr, 6, 0) & 0x3f;
 hash_table[hash_val / 16] |= (u16) 1 << (hash_val % 16);
}
 /* Write the hash table to MAC MD table */
for (i = 0, oft = 0x16; i < 4; i++) {
 iow(db, oft++, hash_table[i] & 0xff);
 iow(db, oft++, (hash_table[i] >> 8) & 0xff);
}
 spin_unlock_irqrestore(&db->lock,flags);
}
 
/*
* Read a word from phyxcer
 从PHY读取数据16bit
*/
static int
dm9000_phy_read(struct net_device *dev, int phy_reg_unused, int reg)
{
board_info_t *db = (board_info_t *) dev->priv;
unsigned long flags;
unsigned int reg_save;
int ret;
 spin_lock_irqsave(&db->lock,flags);
 /* Save previous register address */
reg_save = readb(db->io_addr);
 /* Fill the phyxcer register into REG_0C */
iow(db, DM9000_EPAR, DM9000_PHY | reg);
 iow(db, DM9000_EPCR, 0xc); /* Issue phyxcer read command */
udelay(100); /* Wait read complete */
iow(db, DM9000_EPCR, 0x0); /* Clear phyxcer read command */
 /* The read data keeps on REG_0D & REG_0E */
ret = (ior(db, DM9000_EPDRH) << 8) | ior(db, DM9000_EPDRL);
 /* restore the previous address */
writeb(reg_save, db->io_addr);
 spin_unlock_irqrestore(&db->lock,flags);
 return ret;
}
 /*
* Write a word to phyxcer
向PHY写入数据16bit
*/
static void
dm9000_phy_write(struct net_device *dev, int phyaddr_unused, int reg, int value)
{
board_info_t *db = (board_info_t *) dev->priv;
unsigned long flags;
unsigned long reg_save;
 spin_lock_irqsave(&db->lock,flags);
 /* Save previous register address */
reg_save = readb(db->io_addr);
 /* Fill the phyxcer register into REG_0C */
iow(db, DM9000_EPAR, DM9000_PHY | reg);
 /* Fill the written data into REG_0D & REG_0E */
iow(db, DM9000_EPDRL, (value & 0xff));
iow(db, DM9000_EPDRH, ((value >> 8) & 0xff));
 iow(db, DM9000_EPCR, 0xa); /* Issue phyxcer write command */
udelay(500); /* Wait write complete */
iow(db, DM9000_EPCR, 0x0); /* Clear phyxcer write command */
 /* restore the previous address */
writeb(reg_save, db->io_addr);
 spin_unlock_irqrestore(&db->lock,flags);
}
 /*挂起网卡接口*/
static int
dm9000_drv_suspend(struct platform_device *dev, pm_message_t state)
{
struct net_device *ndev = platform_get_drvdata(dev);
 if (ndev) {
 if (netif_running(ndev)) {
 /*内核临时删除接口*/
 netif_device_detach(ndev);
 /*关闭设备*/
 dm9000_shutdown(ndev);
 }
}
return 0;
}
 static int
dm9000_drv_resume(struct platform_device *dev)
{
struct net_device *ndev = platform_get_drvdata(dev);
board_info_t *db = (board_info_t *) ndev->priv;
 if (ndev) {
 if (netif_running(ndev)) {
 /*复位设备*/
 dm9000_reset(db);
 dm9000_init_dm9000(ndev);
 /*恢复接口*/
 netif_device_attach(ndev);
 }
}
return 0;
}
 static int
dm9000_drv_remove(struct platform_device *pdev)
{
struct net_device *ndev = platform_get_drvdata(pdev);
 platform_set_drvdata(pdev, NULL);
/*释放注册的网络接口*/
unregister_netdev(ndev);
dm9000_release_board(pdev, (board_info_t *) ndev->priv);
/*释放资源*/
free_netdev(ndev); /* free device structure */
 PRINTK1("clean_module() exit/n");
 return 0;
}
 static struct platform_driver dm9000_driver = {
.driver = {
 .name = "dm9000",
 .owner = THIS_MODULE,
},
.probe = dm9000_probe,
.remove = dm9000_drv_remove,
.suspend = dm9000_drv_suspend,
.resume = dm9000_drv_resume,
};
 static int __init
dm9000_init(void)
{
printk(KERN_INFO "%s Ethernet Driver/n", CARDNAME);
 return platform_driver_register(&dm9000_driver); /* search board and register */
}
 static void __exit
dm9000_cleanup(void)
{
platform_driver_unregister(&dm9000_driver);
}
 module_init(dm9000_init);
module_exit(dm9000_cleanup);
 MODULE_AUTHOR("Sascha Hauer, Ben Dooks");
MODULE_DESCRIPTION("Davicom DM9000 network driver");
MODULE_LICENSE("GPL");