编写的dm9000ep驱动(2.6.13)

最新推荐文章于 2023-03-05 16:22:46 发布
原创 最新推荐文章于 2023-03-05 16:22:46 发布 · 486 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了DM9000EP网卡驱动的编写过程，包括初始化、中断处理、发送和接收数据的步骤。通过分析代码，展示了如何配置寄存器、设置中断、读写PHY寄存器以及处理网络数据包。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

the code behind is a some  error ,the hwaddr must written to the relevant regesiters in the init function .this is important and essential.
最近手头刚好有个开发板,也还有点时间,就试着写了一下它上面的网卡驱动,当然也是参考了其现有的驱动再写的,程序如下:
#include <linux/module.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <asm/irq.h>
#include <asm/io.h>

static void *bwscon;
static void *gpfcon;
static void *extint0;
static void *intmsk;
#define BWSCON    (0x48000000)
#define GPFCON    (0x56000050)
#define EXTINT0    (0x56000088)
#define INTMSK    (0x4A000008)

#define BWSCON    (0x48000000)
#define GPFCON    (0x56000050)
#define EXTINT0    (0x56000088)
#define INTMSK    (0x4A000008)

#define DM9000_MIN_IO    0x20000300    //--
#define DM9000_MAX_IO    0x20000370    //--

#define DM9000_VID_L        0x28
#define DM9000_VID_H        0x29
#define DM9000_PID_L        0x2A
#define DM9000_PID_H        0x2B

#define DM9000_PKT_MAX    1536        //Received packet max size
#define DM9000_PKT_RDY    0x01        //Packet ready to receive

#define DMFE_TIMER_WUT  jiffies+(HZ*2)    //timer wakeup time : 2 second 
#define DMFE_TX_TIMEOUT (HZ*2)        //tx packet time-out time 1.5 s"

struct dm9000x{
    u32 ioaddr;        // Register I/O base address
    u32 iodata;        // Data I/O address
    u16 irq;        // IRQ
    u8 iomode;        // 0:16bits 1:word  2:byte
    u8 opmode;
    u16 Preg0, Preg4;

    u16 tx_pkt_cnt;
    u16 sent_pkt_len, queue_pkt_len;
    u8 device_wait_reset;    //device state
    u8 nic_type;            // NIC type

    spinlock_t lock;
};

static struct net_device *xnet_dev = NULL;

int xnet_probe(struct net_device *dev);
static int xnet_open(struct net_device *dev);
static int xnet_stop(struct net_device *dev);
static int xnet_xmit(struct sk_buff *skb, struct net_device *dev);
static irqreturn_t xnet_interrupt(int irq, void *dev_id, struct pt_regs *regs);
static void do_init_dm9000x(struct net_device *dev);
static void do_xnet_tx(void);
static void do_xnet_rx(void);

static void iowt(struct dm9000x *dm9x, int reg, u8 value);
static u8 iord(struct dm9000x *dm9x, int reg);
static u16 phy_read(struct dm9000x *dm9x, int reg);
static void phy_write(struct dm9000x *dm9x, int reg, u16 value);

int xnet_probe(struct net_device *dev)
{
    int i = 0;
    u32 id_val;
    u32 iobase;
    struct dm9000x *dm9x;
    unsigned char mac_add[6] = {0x00, 0x13, 0xf6, 0x6c, 0x87, 0x89};

    bwscon = ioremap_nocache(BWSCON,0x0000004);    //总线位宽和等待状态控制器
    gpfcon = ioremap_nocache(GPFCON,0x0000004);    //Port F 控制寄存器
    extint0 = ioremap_nocache(EXTINT0,0x0000004);    //外部中断控制
    intmsk = ioremap_nocache(INTMSK,0x0000004);    //中断控制

    writel(readl(bwscon) | 0xc0000, bwscon);        //允许等待,使用UB/LB
    //设置GFP7为外部中断模式 EINT7
    writel( (readl(gpfcon) & ~(0x3 << 14)) | (0x2 << 14), gpfcon);
    //设置EINT7 为 falling edge triggered 
    writel( (readl(extint0) & ~(0xf << 28)) | (0x4 << 28), extint0); 
    //中断掩码设置1为屏蔽,这里设置开启EINT4~7
    writel( (readl(intmsk))  & ~0x80, intmsk);    

    iobase = ioremap(DM9000_MIN_IO, 0x400);        //进行地址隐射

    outb(DM9000_VID_L, iobase);
    id_val = inb(iobase + 4);
    outb(DM9000_VID_H, iobase);
    id_val |= inb(iobase + 4) << 8;
    outb(DM9000_PID_L, iobase);
    id_val |= inb(iobase + 4) << 16;
    outb(DM9000_PID_H, iobase);
    id_val |= inb(iobase + 4) << 24;
    
    if (id_val == 0x90000a46) {
        printk("id_val: %x, iobase: %p \n", id_val, (void *)iobase);
        
        dm9x = (void *)kmalloc(sizeof(struct dm9000x), GFP_KERNEL);
        //memset(dm9x,'0', sizeof(struct dm9000x));
        //dm9x = (void *) (kmalloc(sizeof (struct dm9000x), GFP_KERNEL));
        memset(dm9x, 0, sizeof (struct dm9000x));
        dev->priv = dm9x;
        
        dm9x->ioaddr         = iobase;
        dm9x->iodata         = iobase + 4;
        ether_setup(dev);
        
        dev->base_addr    = iobase;
        dev->irq         = IRQ_EINT7;
        dev->open         = &xnet_open;
        dev->stop         = &xnet_stop;
        dev->hard_start_xmit  = &xnet_xmit;
        SET_MODULE_OWNER(dev);
        for (i = 0; i < 6; i++)
            dev->dev_addr[i] = mac_add[i];
        request_region(iobase, 2, dev->name);    
    }    
    return 0;
}

static void do_init_dm9000x(struct net_device *dev)
{
    u16 phy_reg3;
    u16 phy_reg0 = 0x1000;    //Auto-negotiation & non-duplux mode
    u16 phy_reg4 = 0x01e1;    //Default non flow control
    struct dm9000x *dm9x = (struct dm9000x *)dev->priv;

    //set the internal PHY power-on, GPIOs normal, and wait 2ms 
    iowt(dm9x, 0x1F, 0);        //GPR (reg_1Fh)bit GPIO0=0 pre-activate PHY 
    udelay(20);            //wait 2ms for PHY power-on ready 
    
    //0x00 network ctrl reg bit[0]:soft reset bit[1:2]:01 MAC inter loopback
    iowt(dm9x, 0x00, 3);    
    udelay(20);

    //set GPIO0=1 then GPIO0=0 to turn off and on the internal PHY 
    iowt(dm9x, 0x1F, 1);      //GPR (reg_1Fh) bit[0] GPIO0=1 turn-off PHY  
    iowt(dm9x, 0x1F, 0);        //GPR (reg_1Fh) bit[0] GPIO0=0 activate PHY  
    udelay(1000);            //wait 4ms linking PHY (AUTO sense) if RX/TX 
    udelay(1000);
    udelay(1000);
    udelay(1000);
    
    dm9x->iomode = iord(dm9x, 0xFE) >> 6; //ISR bit[7:6] I/O mode
    
    //Full-Duplex Mode. Read only on Internal PHY mode. R/W on External PHY mode 
    iowt(dm9x, 0x00, 0x80);    
    phy_reg3 = phy_read(dm9x, 3);
    dm9x->nic_type = 0;
    printk("IOmode: %x phy_reg3: %x \n", dm9x->iomode, phy_reg3);
    iowt(dm9x, 0x00, 0x00);

    dm9x->opmode = 0;    
    phy_write(dm9x, 0, phy_reg0);
    phy_write(dm9x, 4, 0x0400 | phy_reg4);
    dm9x->Preg0 = phy_reg0;
    dm9x->Preg4 = phy_reg4 + 0x0400;

    //Program operating register 
    iowt(dm9x, 0x00, 0x08);
    iowt(dm9x, 0x02, 0x00);       
    iowt(dm9x, 0x2f, 0x00);       
    iowt(dm9x, 0x01, 0x2c);   
    iowt(dm9x, 0xfe, 0x0f);   
    iowt(dm9x, 0x08, 0x37);
    iowt(dm9x, 0x09, 0x38);   
    iowt(dm9x, 0x0a, 0x29);   
    
    // Activate DM9000 
    iowt(dm9x, 0x05, 0x30 | 1);    //RX enable 
    iowt(dm9x, 0xff, 0x83);    //Enable TX/RX interrupt mask
    
    dm9x->tx_pkt_cnt    = 0;
    dm9x->queue_pkt_len    = 0;
    dev->trans_start    = 0;
    
    netif_carrier_on(dev);
    spin_lock_init(&dm9x->lock);
    printk("do init dm9000x xnte dev! \n");
}

static void do_xnet_tx(void)
{
    struct net_device *dev = xnet_dev;
    struct dm9000x *dm9x = (struct dm9000x *)dev->priv;
    int tx_status = iord(dm9x, 0x01);        //Got TX status
    
    if (tx_status & 0xc) {            //One packet sent complete
        dm9x->tx_pkt_cnt--;
        dev->trans_start = 0;
    
        if (dm9x->tx_pkt_cnt > 0) {        //Queue packet check & send
            //Set TX length to DM9000
            iowt(dm9x, 0xfc, dm9x->queue_pkt_len & 0xff);
            iowt(dm9x, 0xfd, (dm9x->queue_pkt_len >> 8) & 0xff);

            //Issue TX polling command
            iowt(dm9x, 0x2, 0x1);        //Cleared after TX complete
            dev->trans_start = jiffies;    //saved the time stamp
        }
        netif_wake_queue(dev);
    }
    printk("xnet_tx_done the xnet dev! \n");
}

static void do_xnet_rx(void)
{
    struct net_device *dev = xnet_dev;
    struct dm9000x *dm9x = (struct dm9000x *)dev->priv;
    struct sk_buff *skb;
    u8 rxbyte, *rdptr;
    u16 i, RxStatus, RxLen, GoodPacket, tmplen;
    
    do {
        iord(dm9x, 0xf0);        //Dummy read
        rxbyte = inb(dm9x->iodata);    //Got most updated data
        if (rxbyte == DM9000_PKT_RDY) { // packet ready to receive check
            GoodPacket = 1;
            outb(0xf2, dm9x->ioaddr);
            RxStatus = RxLen = (u16) 0;
            RxStatus = inw(dm9x->iodata);
            outb(0xf2, dm9x->ioaddr);
            RxLen = inw(dm9x->iodata);

           
            if (RxLen < 0x40) {
                GoodPacket = 0;
            } else if (RxLen > DM9000_PKT_MAX) {
                printk("<DM9000> RST: RX Len:%x(%x)\n", RxLen, RxStatus);
                dm9x->device_wait_reset = 1;
            }
            if (RxStatus & 0xbf00) GoodPacket = 0;
            if (!dm9x->device_wait_reset){
                if(GoodPacket && ((skb = dev_alloc_skb(RxLen + 4)) != NULL)){
                    skb->dev = dev;
                    skb_reserve(skb, 2);
                    rdptr = (u8 *) skb_put(skb, RxLen - 4);
                    tmplen = (RxLen + 1) / 2;
                    for (i = 0; i < tmplen; i++){
                        ((u16 *) rdptr)[i] = inw(dm9x->iodata);
                        //printk("%x ",((u16 *) rdptr)[i]);
                    }
                     
                    skb->protocol = eth_type_trans(skb, dev);
                    netif_rx(skb);
                } else {       
                    tmplen = (RxLen + 1) / 2;
                    for (i = 0; i < tmplen; i++)
                        inw(dm9x->iodata);
                } 
            }            
        } else if (rxbyte > DM9000_PKT_RDY) {
            // Status check: this byte must be 0 or 1
            printk("RX SRAM 1st byte(x) != 01, must reset.\n", rxbyte);
            iowt(dm9x, 0x05, 0x00);        // Stop Device
            iowt(dm9x, 0xfe, 0x80);        // Stop INT request
            dm9x->device_wait_reset = 1;
            //dm9x->reset_rx_status++;
        }
    } while (rxbyte == DM9000_PKT_RDY && !dm9x->device_wait_reset); 
    printk("xnet_packet_receive the xnet dev! %x\n", dm9x->ioaddr);
}

static irqreturn_t xnet_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
    struct net_device *dev = dev_id;    
    struct dm9000x *dm9x;
    int int_status;
    u8 reg_save;

    dm9x = (struct dm9000x *)dev->priv;
    spin_lock_irq(&dm9x->lock);

    //Save previous register address 
    reg_save = inb(dm9x->ioaddr);
    //Disable all interrupt
    iowt(dm9x, 0xff, 0x80);

    //Got DM9000 interrupt status 
    int_status = iord(dm9x, 0xfe);        //Got ISR 
    iowt(dm9x, 0xfe, int_status);        //Clear ISR status

    if (int_status & 0x02) {    //Trnasmit Interrupt check
        do_xnet_tx();
    }
    if (int_status & 0x01) {    //Received the coming packet
        do_xnet_rx();
    }
    //Re-enable interrupt mask
    iowt(dm9x, 0xff, 0x83);

    //Restore previous register address
    outb(reg_save, dm9x->ioaddr);

    spin_unlock_irq(&dm9x->lock);

    printk("interrupt the xnet dev!  %x\n", dm9x->ioaddr);
    return IRQ_HANDLED;
}

static int xnet_open(struct net_device *dev)
{
    //struct dm9000x *dm9x = (struct dm9000x *)dev->priv;
    
    if(request_irq(dev->irq, &xnet_interrupt, SA_SHIRQ, dev->name, dev))
        return -EAGAIN;
        
    do_init_dm9000x(dev);

    netif_start_queue(dev);
    enable_irq(dev->irq);

    printk("open the xnet dev! \n");
    return 0;
}

static int xnet_stop(struct net_device *dev)
{
    struct dm9000x *dm9x = (struct dm9000x *)dev->priv;

    netif_stop_queue(dev);
    free_irq(dev->irq, dev);

   
    phy_write(dm9x, 0x00, 0x8000);   
    iowt(dm9x, 0x1f, 0x01);   
    iowt(dm9x, 0xff, 0x80);   
    iowt(dm9x, 0x05, 0x00);   

    printk("stop the xnet dev! \n");
    return 0;
}

static int xnet_xmit(struct sk_buff *skb, struct net_device *dev)
{
    struct dm9000x *dm9x = (struct dm9000x *)dev->priv;
    char *data;
    int i, len;

    if (dm9x->tx_pkt_cnt > 1) return 1;

    netif_stop_queue(dev);
    iowt(dm9x, 0xff, 0x80);    //Disable all interrupt
    data = (char *)skb->data;
    outb(0xf8, dm9x->ioaddr);

    len = (skb->len + 1) / 2;
    for (i = 0; i < len; i++){
        outw(((u16 *) data)[i], dm9x->iodata);
        //printk("%x ",((u16 *) data)[i]);
    }

    // TX control: First packet immediately send, second packet queue 
    if (dm9x->tx_pkt_cnt == 0){            // First Packet
        dm9x->tx_pkt_cnt++;
        // Set TX length to DM9000
        iowt(dm9x, 0xfc, skb->len & 0xff);
        iowt(dm9x, 0xfd, (skb->len >> 8) & 0xff);
        // Issue TX polling command
        iowt(dm9x, 0x2, 0x1);            //Cleared after TX complete
        // saved the time stamp
        dev->trans_start = jiffies;
    } else {                    //Second packet
        dm9x->tx_pkt_cnt++;
        dm9x->queue_pkt_len = skb->len;
    }

    dev_kfree_skb(skb);

    if (dm9x->tx_pkt_cnt == 1) netif_wake_queue(dev);
    //Re-enable interrupt
    iowt(dm9x, 0xff, 0x83);

    printk("hard start xmit the xnet dev! \n");    
    return 0;
}

static void iowt(struct dm9000x *dm9x, int reg, u8 value)
{
    outb(reg, dm9x->ioaddr);
    outb(value, dm9x->iodata);
}

static u8 iord(struct dm9000x *dm9x, int reg)
{
    outb(reg, dm9x->ioaddr);
    return inb(dm9x->iodata);
}

//Read a word from phyxcer
static u16 phy_read(struct dm9000x *dm9x, int reg)
{
    //Fill the phyxcer register into REG_0C
    //0x0C EEPROM & PHY Address Register bit[7:6]:01 select PHY
    //bit[5:0]:address of PHY or EEPROM
    iowt(dm9x, 0xc, 0x40 | reg);
    iowt(dm9x, 0xb, 0xc);    //Issue phyxcer read command
    udelay(100);            //Wait read complete
    iowt(dm9x, 0xb, 0x0);    //Clear phyxcer read command

    //The read data keeps on REG_0D(L) & REG_0E(H)
    return (iord(dm9x, 0xe) << 8) | iord(dm9x, 0xd);
}

static void phy_write(struct dm9000x *dm9x, int reg, u16 value)
{
    //Fill the phyxcer register into REG_0C
    iowt(dm9x, 0xc, 0x40 | reg);

    //Fill the written data into REG_0D(L) & REG_0E(H)
    iowt(dm9x, 0xd, (value & 0xff));
    iowt(dm9x, 0xe, ((value >> 8) & 0xff));

    iowt(dm9x, 0xb, 0xa);    //Issue phyxcer write command 
    udelay(500);            //Wait write complete 
    iowt(dm9x, 0xb, 0x0);    //Clear phyxcer write command
}

static int __init xnet_dev_init(void)
{
    int err = 0;

    xnet_dev = alloc_etherdev(sizeof(struct net_device));
    xnet_dev->init = xnet_probe;
    
    err = dev_alloc_name(xnet_dev, "eth%d");
    if (err < 0)
        return err;
    err = register_netdev(xnet_dev);
    if (err < 0)
        return err;
    printk("init the xnet dev! \n");

    return 0;
}

static void __exit xnet_dev_exit(void)
{
    unregister_netdev(xnet_dev);
    kfree(xnet_dev->priv);
    memset(xnet_dev, 0, sizeof (*xnet_dev));
    printk("xnet dev exit!! \n");
}

module_init(xnet_dev_init);
module_exit(xnet_dev_exit);

MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("Helight.Xu");
基于linux下的dm9000网卡移植全分析
wantianpei的专栏
05-31 2404
DM9000可以直接与ISA总线相连，也可以与大多数CPU直接相连。Mini2440采用的是dm9000直接连接CPU（s3c2440)上。就像是nandflash一样直接被挂在CUP上，被挂在s3c2440的bank4上。 小插曲1：s3c2440芯片把存储系统分为了8个Bank，由nGCS0[0]~nGCS[7] 这8根引脚决定当前访问的是哪一个Bank对应的存储器。其中，前6个Bank
DM9000A网卡芯片介绍
linux嵌入式驱动软件开发
12-22 2632
1、总体介绍　　该DM9000是一款完全集成的和符合成本效益单芯片快速以太网MAC控制器与一般处理接口，一个10/100M自适应的PHY和4K DWORD值的SRAM 。它的目的是在低功耗和高性能进程的3.3V与5V的支持宽容。　　DM9000还提供了介质无关的接口，来连接所有提供支持介质无关接口功能的家用电话线网络设备或其他收发器。该DM9000支持8位， 16位和32 -位接口访问内部
mini2440驱动dm9000ep（无操作系统）
12-02
mini2440驱动dm9000ep（无操作系统），实现arp解析和udp包发送，速率59mbps
s3c2440 DM9000EP驱动程序
shangyaowei的专栏
12-19 1968
#include #include #include #include #include #include #include #include #include #include #include #include static volatile unsigned long *bwscon; static volatile unsigned long *bankcon4;
Cstyle的札记，R&D必读手册，第4篇 DM9000EP
业余电子爱好者的日常
03-24 1978
DM9000EP这款号称的嵌入式网络控制器，由台湾的联杰科技出品（绝对不是广告^_^），网址：http://www.davicom.com.tw，从这里可以下载到相关的文档和参考设计。这次换个口味，但是还是先上图，有图有真相，从下面的框图可以看出这款网络控制器主要有以下几部分组成： 1.10/100 PHY ceiver 2.MAC 控制器 3.内部4K Dword S
uc/tcpip 官方DM9000EP驱动
03-28
非常不错的DM9000EP驱动学习源代码
mini2440实现dm9000ep驱动开发，支持arp解析与udp传输
在开发板如mini2440上开发DM9000EP的驱动程序，通常需要完成以下任务： - 编写初始化代码，配置DM9000EP的工作模式和相关参数。 - 实现MAC地址的读写，以及网络设置相关功能。 - 实现网络数据的发送和接收功能，通常...
dm9000_driver.rar_DM9000_DM9000驱动_dm9000 驱动
09-23
这些定义为编写驱动程序提供了清晰的接口。 在实际使用过程中，开发者可能需要根据具体平台进行适配，比如配置中断向量、I/O端口地址等。"自己改过后可以用"的描述表明了驱动的可定制性，开发者可能需要对原有的...
嵌入式linux上的dm9000网卡驱动源代码和Makefile编译驱动文件源代码
05-27
这里我们关注的是DM9000网卡的驱动程序，它是一款广泛应用于嵌入式系统的以太网控制器。DM9000芯片提供了对10/100Mbps以太网连接的支持，适用于多种工业和消费级应用。 首先，DM9000驱动源代码通常由几个关键部分...
DM9000EP和DM9000CEP datasheet
最新发布
12-08
DM9000EP和DM9000CEP datasheet，电流型PHY
DM9000的手册、硬件原理图和驱动源代码
09-28
DM9000的手册、硬件原理图和驱动源代码
ARM 学习 DM9000 网卡原理与基地址设置
weixin_42109053的博客
03-05 1106
一、 网卡也是属于类内存总线的设备，类内存总线的设备有地址总线和数据总线，先来看下DM9000的管脚： 从上面可以看出，DM9000 的地址总线就一根，它不像 CS8900 那样，地址总线和数据总线都齐全。而这里只有一根地址线(CMD)，16 根数据线，所以可以确定位宽为 16 位，而地址线为什么只有一根，这是 DM9000 决定的。 看手册可以知道，CPU 总线只访问它的两个地址：CMD 管脚为 0 时，数据线送的是 DM9000 的寄存器地址，CMD 管脚为 1 时，数据线上送的是 16 位的寄存器数
四十.DM9000网卡搭建
lzjsqn的专栏
12-26 2810
一.网络模型 1.OSI（开放式系统互联模型） 从上往下依次是：应用层，表示层，会话层，传输层，网络层，数据链路层，物理层。 2.Linux四层模型：从上往下依次是应用层，传输层，IP层，网络接口层。基于TCP/IP协议栈的模型。 二.DM9000物理结构 1.原理图 工作实质就是MAC通过MII控制PHY的过程。
学习笔记 --- DM9000网卡原理与基地址设置
忧郁天蝎
03-30 1834
前面有文章分析了网卡也是属于类内存总线的设备，类内存总线的设备有地址总线和数据总线，先来看下DM9000的管脚： 从上面可以看出DM9000的地址总线就一根，它不像CS8900那样地址总线和数据总线都齐全。而这里只有一根地址线(CMD)，16跟数据线，所以可以确定位宽为16位，而地址线为什么只有一根，这是DM9000决定的，看手册可以知道CPU只访问它的两个地址，CMD管脚为0时，数据线
DM9000驱动程序详解
liuhongwei123888的专栏
03-21 2388
//arch/arm/mach-s5pv210/mach-smdkv210.c /*片选信号使用的是XM0CSn1,查看S5PV210的芯片手册内存映射一节可以找到SROM BANK1的地址范围是0x8800_0000 --0x8FFF_FFFF， 则访问这个范围的地址时会激活片选使能信号XM0CSn1*/ #define S5PV210_PA_DM9000_A     (0x880010
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值