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");