Linux设备驱动工程师之路——DM9000网卡驱动程序分析

Linux设备驱动工程师之路——DM9000网卡驱动程序分析

K-Style

转载请注明来自于衡阳师范学院08电2 K-Style http://blog.csdn.net/ayangke,QQ:843308498 邮箱：[email protected]

DM9000是开发板经采用的网络芯片，是一种高度集成而且功耗很低的高速网络控制器，可以和CPU直连，支持10/100M以太网连接，芯片内部自带16K SARM(3KB用来发送，13KB用来接收).

1.模块初始化

static struct platform_driver dm9000_driver = { .driver = { .name = "dm9000", .owner = THIS_MODULE, }, .probe = dm9000_probe, .remove = __devexit_p(dm9000_drv_remove), .suspend = dm9000_drv_suspend, .resume = dm9000_drv_resume, }; static int __init dm9000_init(void) { printk(KERN_INFO "%s Ethernet Driver, V%s\n", CARDNAME, DRV_VERSION); return platform_driver_register(&dm9000_driver); }

模块初始化完成了基于platfrom平台的DM9000网卡驱动的注册，当DM9000网卡找到其对应的能处理的platform设备后调用probe函数。

2.DM9000网卡初始化

在probe函数中完成了对DM9000网卡的初始化

DM9000的特性：DM9000地址信号和数据信号复用使用CMD引脚区分它们（CMD为低是读写DM900地址寄存器，CMD为高时读写DM9000数据寄存器），访问DM9000内部寄存器时，先将CMD置低，写DM900地址寄存器，然后将CMD置高，读写DM9000数据寄存器。

static int __devinit dm9000_probe(struct platform_device *pdev) { struct dm9000_plat_data *pdata = pdev->dev.platform_data; struct board_info *db; /* Point a board information structure */ struct net_device *ndev; const unsigned char *mac_src; int ret = 0; int iosize; int i; u32 id_val; /* Init network device */ //申请net_device结构 ndev = alloc_etherdev(sizeof(struct board_info)); if (!ndev) { dev_err(&pdev->dev, "could not allocate device.\n"); return -ENOMEM; } //将net_device的parent指针指向platform_device对象，表示该设备挂载platform设备上。 SET_NETDEV_DEV(ndev, &pdev->dev); dev_dbg(&pdev->dev, "dm9000_probe()\n"); /* setup board info structure */ //获取net_device私有数据结构指针 db = netdev_priv(ndev); memset(db, 0, sizeof(*db)); //设置相关设备 db->dev = &pdev->dev; db->ndev = ndev; spin_lock_init(&db->lock); mutex_init(&db->addr_lock); INIT_DELAYED_WORK(&db->phy_poll, dm9000_poll_work); //获取平台设备资源。包括DM9000地址寄存器地址，DM9000数据寄存器地址，和DM900所占用的中断号 db->addr_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); db->data_res = platform_get_resource(pdev, IORESOURCE_MEM, 1); db->irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (db->addr_res == NULL || db->data_res == NULL || db->irq_res == NULL) { dev_err(db->dev, "insufficient resources\n"); ret = -ENOENT; goto out; } //申请地址寄存器IO内存区域并映射 iosize = res_size(db->addr_res); db->addr_req = request_mem_region(db->addr_res->start, iosize, pdev->name); if (db->addr_req == NULL) { dev_err(db->dev, "cannot claim address reg area\n"); ret = -EIO; goto out; } db->io_addr = ioremap(db->addr_res->start, iosize); if (db->io_addr == NULL) { dev_err(db->dev, "failed to ioremap address reg\n"); ret = -EINVAL; goto out; } //申请数据寄存器IO内存区域并映射 iosize = res_size(db->data_res); db->data_req = request_mem_region(db->data_res->start, iosize, pdev->name); if (db->data_req == NULL) { dev_err(db->dev, "cannot claim data reg area\n"); ret = -EIO; goto out; } db->io_data = ioremap(db->data_res->start, iosize); if (db->io_data == NULL) { dev_err(db->dev, "failed to ioremap data reg\n"); ret = -EINVAL; goto out; } /* fill in parameters for net-dev structure */ ndev->base_addr = (unsigned long)db->io_addr; ndev->irq = db->irq_res->start; //设置数据位宽 /* ensure at least we have a default set of IO routines */ dm9000_set_io(db, iosize); /* check to see if anything is being over-ridden */ if (pdata != NULL) { /* check to see if the driver wants to over-ride the * default IO width */ if (pdata->flags & DM9000_PLATF_8BITONLY) dm9000_set_io(db, 1); if (pdata->flags & DM9000_PLATF_16BITONLY) dm9000_set_io(db, 2); if (pdata->flags & DM9000_PLATF_32BITONLY) dm9000_set_io(db, 4); /* check to see if there are any IO routine * over-rides */ if (pdata->inblk != NULL) db->inblk = pdata->inblk; if (pdata->outblk != NULL) db->outblk = pdata->outblk; if (pdata->dumpblk != NULL) db->dumpblk = pdata->dumpblk; db->flags = pdata->flags; } #ifdef CONFIG_DM9000_FORCE_SIMPLE_PHY_POLL db->flags |= DM9000_PLATF_SIMPLE_PHY; #endif //复位网卡芯片 dm9000_reset(db); //读取设备ID，判断是否是驱动能够处理的网卡芯片 /* try multiple times, DM9000 sometimes gets the read wrong */ for (i = 0; i < 8; i++) { id_val = ior(db, DM9000_VIDL); id_val |= (u32)ior(db, DM9000_VIDH) << 8; id_val |= (u32)ior(db, DM9000_PIDL) << 16; id_val |= (u32)ior(db, DM9000_PIDH) << 24; if (id_val == DM9000_ID) break; dev_err(db->dev, "read wrong id 0x%08x\n", id_val); } if (id_val != DM9000_ID) { dev_err(db->dev, "wrong id: 0x%08x\n", id_val); ret = -ENODEV; goto out; } /* Identify what type of DM9000 we are working on */ id_val = ior(db, DM9000_CHIPR); dev_dbg(db->dev, "dm9000 revision 0x%02x\n", id_val); switch (id_val) { case CHIPR_DM9000A: db->type = TYPE_DM9000A; break; case CHIPR_DM9000B: db->type = TYPE_DM9000B; break; default: dev_dbg(db->dev, "ID %02x => defaulting to DM9000E\n", id_val); db->type = TYPE_DM9000E; } /* from this point we assume that we have found a DM9000 */ /* driver system function */ ether_setup(ndev); //设置网卡芯片的接口函数 ndev->open = &dm9000_open; ndev->hard_start_xmit = &dm9000_start_xmit; ndev->tx_timeout = &dm9000_timeout; ndev->watchdog_timeo = msecs_to_jiffies(watchdog); ndev->stop = &dm9000_stop; ndev->set_multicast_list = &dm9000_hash_table; ndev->ethtool_ops = &dm9000_ethtool_ops; ndev->do_ioctl = &dm9000_ioctl; #ifdef CONFIG_NET_POLL_CONTROLLER ndev->poll_controller = &dm9000_poll_controller; #endif db->msg_enable = NETIF_MSG_LINK; db->mii.phy_id_mask = 0x1f; db->mii.reg_num_mask = 0x1f; db->mii.force_media = 0; db->mii.full_duplex = 0; db->mii.dev = ndev; db->mii.mdio_read = dm9000_phy_read; db->mii.mdio_write = dm9000_phy_write; mac_src = "eeprom"; //从EEPROM中读取MAC地址填充dev_addr /* try reading the node address from the attached EEPROM */ for (i = 0; i < 6; i += 2) dm9000_read_eeprom(db, i / 2, ndev->dev_addr+i); if (!is_valid_ether_addr(ndev->dev_addr) && pdata != NULL) { mac_src = "platform data"; memcpy(ndev->dev_addr, pdata->dev_addr, 6); } if (!is_valid_ether_addr(ndev->dev_addr)) { /* try reading from mac */ mac_src = "chip"; for (i = 0; i < 6; i++) ndev->dev_addr[i] = ior(db, i+DM9000_PAR); } if (!is_valid_ether_addr(ndev->dev_addr)) dev_warn(db->dev, "%s: Invalid ethernet MAC address. Please " "set using ifconfig\n", ndev->name); //设置平台设备驱动的dev成员为ndev。 platform_set_drvdata(pdev, ndev); //注册网络设备驱动 ret = register_netdev(ndev); if (ret == 0) printk(KERN_INFO "%s: dm9000%c at %p,%p IRQ %d MAC: %pM (%s)\n", ndev->name, dm9000_type_to_char(db->type), db->io_addr, db->io_data, ndev->irq, ndev->dev_addr, mac_src); return 0; out: dev_err(db->dev, "not found (%d).\n", ret); dm9000_release_board(pdev, db); free_netdev(ndev); return ret; }

我们在来看看读写网卡寄存器所用的ior和iow

static u8 ior(board_info_t * db, int reg) { writeb(reg, db->io_addr); return readb(db->io_data); } static void iow(board_info_t * db, int reg, int value) { writeb(reg, db->io_addr); writeb(value, db->io_data); }

可以看得出是先将要访问的寄存器地址写入到地址寄存器，然后在将数据写入到数据寄存器。地址。

3.打开网卡

在linux终端下使用ifconfig命令时调用net_device的open函数打开网卡设备

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; /* Initialize DM9000 board */ //复位网卡芯片 dm9000_reset(db); //初始化网卡（相关寄存器设置） dm9000_init_dm9000(dev); /* Init driver variable */ db->dbug_cnt = 0; mii_check_media(&db->mii, netif_msg_link(db), 1); //打开发送队列 netif_start_queue(dev); //调度发送队列开始工作 dm9000_schedule_poll(db); return 0; }

4.数据发送

下面说一下DM9000A中的存储部分，DM9000A内部有一个4K Dword SRAM，其中3KB是作为发送，16KB作为接收，如下图所示。其中0x0000~0x0BFF是传说中的TX buffer(TX buffer中只能存放两个包)，0x0C00~0x3FFF是RX buffer。因此在写内存操作时，当IMR的第7位被设置，如果到达了地址的结尾比如到了3KB，则回卷到0。相似的方式，在读操作中，当IMR的第7位被设置如果到达了地址的结尾比如16K，则回卷到0x0C00。

DM9000的TX RAM可以同时放两个包，可以第9行代码中看出如果大于TXRAM中的包大于2则返回，DM9000会先发送第一个包，然后再发第二个包。

<pre name="code" class="html">static int dm9000_start_xmit(struct sk_buff *skb, struct net_device *dev) { unsigned long flags; board_info_t *db = netdev_priv(dev); dm9000_dbg(db, 3, "%s:\n", __func__); //如果TX RAM中的包大于2个包则返回 if (db->tx_pkt_cnt > 1) return 1; spin_lock_irqsave(&db->lock, flags); *MWCMD是Memory data write command with address increment Register(F8H) *将要访问的TXRAM地址写入地址寄存器。 /* Move data to DM9000 TX RAM */ writeb(DM9000_MWCMD, db->io_addr); //拷贝数据到TXRAM (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) { /* Set TX length to DM9000 */ /*把数据的长度填到TXPLL(发送包长度低字节)和TXPLH(发送包长度高字节)中*/ iow(db, DM9000_TXPLL, skb->len); iow(db, DM9000_TXPLH, skb->len >> 8); /*置发送控制寄存器(TX Control Register)的发送请求位TXREQ(Auto clears after sending completely)，这样就可以发送出去了*/ /* *记下此时的时间，这里起一个时间戳的作用，之后的超时会用到。如果当前的系统时间超过设备的trans_start时间 *至少一个超时周期，网络层将最终调用驱动程序的tx_timeout。那个这个"一个超时周期"又是什么呢？这个是我们在 *probe函数中设置的,ndev->watchdog_timeo = msecs_to_jiffies(watchdog); */ dev->trans_start = jiffies; /* save the time stamp */ } else { //如果是第二个包，则暂时不发送，等待第一个包发送完成时tx_pkt_cnt减为1的时候再发送。 /* Second packet */ db->queue_pkt_len = skb->len; netif_stop_queue(dev);//停止发送队列 } spin_unlock_irqrestore(&db->lock, flags); /* free this SKB */ dev_kfree_skb(skb); return 0; } </pre>

4.中断

static irqreturn_t dm9000_interrupt(intirq, void *dev_id) { structnet_device *dev = dev_id; board_info_t*db = netdev_priv(dev); intint_status; unsignedlong flags; u8reg_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); //保存寄存器地址 /*Save previous register address */ reg_save= readb(db->io_addr); //禁止DM9000的所有中断 /*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 ISRstatus */ 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 */ //重新打开DM9000的内部中断 iow(db,DM9000_IMR, db->imr_all); /*Restore previous register address */ //恢复寄存器的值 writeb(reg_save,db->io_addr); //重新允许所有中断 spin_unlock_irqrestore(&db->lock,flags); returnIRQ_HANDLED; }

5.接收数据

<pre name="code" class="html">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_RDY) { 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);//获取skb的数据指针 /* 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); netif_rx(skb);//将接收到的skb交给协议层 dev->stats.rx_packets++; } else { /* need to dump the packet's data */ (db->dumpblk)(db->io_data, RxLen); } } while (rxbyte == DM9000_PKT_RDY); } </pre>

6.发送完成

<pre name="code" class="html">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 */ //将数据包计数减1 db->tx_pkt_cnt--; dev->stats.tx_packets++; if (netif_msg_tx_done(db)) dev_dbg(db->dev, "tx done, NSR %02x\n", tx_status); /* Queue packet check & send */ //如果数据包数量依然大于0，说明是TX RAM中的第二个包，再次启动发送，将TX RAM中第二个包发送出去 if (db->tx_pkt_cnt > 0) { /*把数据的长度填到TXPLL(发送包长度低字节)和TXPLH(发送包长度高字节)中*/ iow(db, DM9000_TXPLL, skb->len); iow(db, DM9000_TXPLH, skb->len >> 8); /*置发送控制寄存器(TX Control Register)的发送请求位TXREQ(Auto clears after sending completely)，这样就可以发送出去了*/ dev->trans_start = jiffies; } netif_wake_queue(dev);//唤醒发送队列 } } </pre>

7.超时处理

static void dm9000_timeout(struct net_device *dev) { board_info_t *db = netdev_priv(dev); u8 reg_save; unsigned long flags; /* Save previous register address */ reg_save = readb(db->io_addr); spin_lock_irqsave(&db->lock, flags); //停止发送队列并复位DM9000网卡 netif_stop_queue(dev); dm9000_reset(db); dm9000_init_dm9000(dev); /* We can accept TX packets again */ //重新发送 dev->trans_start = jiffies; netif_wake_queue(dev); /* Restore previous register address */ writeb(reg_save, db->io_addr); spin_unlock_irqrestore(&db->lock, flags); }