DM9000驱动解析

* 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 

   包长不能小于字节*/

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