linuxPCIE驱动开发

#include #include #include #include #include #include #undef debug  // ATTENTION copied from /uboot_for_mpc/arch/powerpc/include/asm/signal.h// Maybe it don't work with that//____________________________________________________________#define SA_INTERRUPT    0x20000000 /* dummy -- ignored */#define SA_SHIRQ        0x04000000//____________________________________________________________ #define pci_module_init pci_register_driver // function is obsoleted // Hardware specific part#define MY_VENDOR_ID 0x5333#define MY_DEVICE_ID 0x8e40#define MAJOR_NR     240#define DRIVER_NAME  "PCI-Driver" static unsigned long ioport=0L, iolen=0L, memstart=0L, memlen=0L,flag0,flag1,flag2,temp=0L; // private_datastruct _instance_data {     int counter; // just as a example (5-27)     // other instance specific data}; // Interrupt Service Routinestatic irqreturn_t pci_isr( int irq, void *dev_id, struct pt_regs *regs ){    return IRQ_HANDLED;}  // Check if this driver is for the new devicestatic int device_init(struct pci_dev *dev,        const struct pci_device_id *id){    int err=0;  // temp variable     #ifdef debug     flag0=pci_resource_flags(dev, 0 );    flag1=pci_resource_flags(dev, 1 );    flag2=pci_resource_flags(dev, 2 );    printk("DEBUG: FLAGS0 = %u\n",flag0);    printk("DEBUG: FLAGS1 = %u\n",flag1);    printk("DEBUG: FLAGS2 = %u\n",flag2);     /*     * The following sequence checks if the resource is in the     * IO / Storage / Interrupt / DMA address space     * and prints the result in the dmesg log     */    if(pci_resource_flags(dev,0) & IORESOURCE_IO)    {        // Ressource is in the IO address space        printk("DEBUG: IORESOURCE_IO\n");    }    else if (pci_resource_flags(dev,0) & IORESOURCE_MEM)    {        // Resource is in the Storage address space        printk("DEBUG: IORESOURCE_MEM\n");    }    else if (pci_resource_flags(dev,0) & IORESOURCE_IRQ)    {        // Resource is in the IRQ address space        printk("DEBUG: IORESOURCE_IRQ\n");    }    else if (pci_resource_flags(dev,0) & IORESOURCE_DMA)    {        // Resource is in the DMA address space        printk("DEBUG: IORESOURCE_DMA\n");    }    else    {        printk("DEBUG: NOTHING\n");    }     #endif /* debug */     // allocate memory_region    memstart = pci_resource_start( dev, 0 );    memlen = pci_resource_len( dev, 0 );    if( request_mem_region( memstart, memlen, dev->dev.kobj.name )==NULL ) {        printk(KERN_ERR "Memory address conflict for device \"%s\"\n",                dev->dev.kobj.name);        return -EIO;    }    // allocate a interrupt    if(request_irq(dev->irq,pci_isr,SA_INTERRUPT|SA_SHIRQ,            "pci_drv",dev)) {        printk( KERN_ERR "pci_drv: IRQ %d not free.\n", dev->irq );    }    else    {        err=pci_enable_device( dev );        if(err==0)      // enable device successful        {            return 0;        }        else        // enable device not successful        {            return err;        }     }    // cleanup_mem    release_mem_region( memstart, memlen );    return -EIO;}// Function for deinitialization of the devicestatic void device_deinit( struct pci_dev *pdev ){    free_irq( pdev->irq, pdev );    if( memstart )        release_mem_region( memstart, memlen );} static struct file_operations pci_fops; static struct pci_device_id pci_drv_tbl[] __devinitdata = {    {       MY_VENDOR_ID,           // manufacturer identifier        MY_DEVICE_ID,           // device identifier        PCI_ANY_ID,             // subsystem manufacturer identifier        PCI_ANY_ID,             // subsystem device identifier        0,                      // device class        0,                      // mask for device class        0 },                    // driver specific data        { 0, }}; static int driver_open( struct inode *geraetedatei, struct file *instance ){    struct _instance_data *iptr;     iptr = (struct _instance_data *)kmalloc(sizeof(struct _instance_data),            GFP_KERNEL);    if( iptr==0 ) {        printk("not enough kernel mem\n");        return -ENOMEM;    }    /* replace the following line with your instructions  */    iptr->counter= strlen("Hello World\n")+1;    // just as a example (5-27)     instance->private_data = (void *)iptr;    return 0;} static void driver_close( struct file *instance ){    if( instance->private_data )        kfree( instance->private_data );}  static struct pci_driver pci_drv = {    .name= "pci_drv",            .id_table= pci_drv_tbl,            .probe= device_init,            .remove= device_deinit,}; static int __init pci_drv_init(void){    // register the driver by the OS    if(register_chrdev(MAJOR_NR, DRIVER_NAME, &pci_fops)==0) {        if(pci_module_init(&pci_drv) == 0 ) // register by the subsystem            return 0;        unregister_chrdev(MAJOR_NR,DRIVER_NAME); // unregister if no subsystem support    }    return -EIO;} static void __exit pci_drv_exit(void){    pci_unregister_driver( &pci_drv );    unregister_chrdev(MAJOR_NR,DRIVER_NAME);} module_init(pci_drv_init);module_exit(pci_drv_exit); MODULE_LICENSE("GPL");

[root@gary root]# mknod  /dev/lp0  c  6  0

struct file_operations {        struct module *owner;        loff_t (*llseek) (struct file *, loff_t, int);        ssize_t (*read) (struct file *, char *, size_t, loff_t *);        ssize_t (*write) (struct file *, const char *, size_t, loff_t *);        int (*readdir) (struct file *, void *, filldir_t);        unsigned int (*poll) (struct file *, struct poll_table_struct *);        int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);        int (*mmap) (struct file *, struct vm_area_struct *);        int (*open) (struct inode *, struct file *);        int (*flush) (struct file *);        int (*release) (struct inode *, struct file *);        int (*fsync) (struct file *, struct dentry *, int datasync);        int (*fasync) (int, struct file *, int);        int (*lock) (struct file *, int, struct file_lock *);        ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *);        ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *);        ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);        unsigned long (*get_unmapped_area)(struct file *, unsigned long,          unsigned long, unsigned long, unsigned long);};

struct pci_driver {    struct list_head node;    char *name;    const struct pci_device_id *id_table;    int  (*probe)  (struct pci_dev *dev, const struct pci_device_id *id);    void (*remove) (struct pci_dev *dev);    int  (*save_state) (struct pci_dev *dev, u32 state);    int  (*suspend)(struct pci_dev *dev, u32 state);    int  (*resume) (struct pci_dev *dev);    int  (*enable_wake) (struct pci_dev *dev, u32 state, int enable);};

struct pci_dev {    struct list_head global_list;    struct list_head bus_list;    struct pci_bus  *bus;    struct pci_bus  *subordinate;    void        *sysdata;    struct proc_dir_entry *procent;    unsigned int    devfn;    unsigned short  vendor;    unsigned short  device;    unsigned short  subsystem_vendor;    unsigned short  subsystem_device;    unsigned int    class;    u8      hdr_type;    u8      rom_base_reg;    struct pci_driver *driver;    void        *driver_data;    u64     dma_mask;    u32             current_state;    unsigned short vendor_compatible[DEVICE_COUNT_COMPATIBLE];    unsigned short device_compatible[DEVICE_COUNT_COMPATIBLE];    unsigned int    irq;    struct resource resource[DEVICE_COUNT_RESOURCE];    struct resource dma_resource[DEVICE_COUNT_DMA];    struct resource irq_resource[DEVICE_COUNT_IRQ];    char        name[80];    char        slot_name[8];    int     active;    int     ro;    unsigned short  regs;    int (*prepare)(struct pci_dev *dev);    int (*activate)(struct pci_dev *dev);    int (*deactivate)(struct pci_dev *dev);};

/* 指明该驱动程序适用于哪一些PCI设备 */static struct pci_device_id demo_pci_tbl [] __initdata = {    {PCI_VENDOR_ID_DEMO, PCI_DEVICE_ID_DEMO,     PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEMO},    {0,}};/* 对特定PCI设备进行描述的数据结构 */struct demo_card {    unsigned int magic;    /* 使用链表保存所有同类的PCI设备 */    struct demo_card *next;        /* ... */}/* 中断处理模块 */static void demo_interrupt(int irq, void *dev_id, struct pt_regs *regs){    /* ... */}/* 设备文件操作接口 */static struct file_operations demo_fops = {    owner:      THIS_MODULE,   /* demo_fops所属的设备模块 */    read:       demo_read,    /* 读设备操作*/    write:      demo_write,    /* 写设备操作*/    ioctl:      demo_ioctl,    /* 控制设备操作*/    mmap:       demo_mmap,    /* 内存重映射操作*/    open:       demo_open,    /* 打开设备操作*/    release:    demo_release    /* 释放设备操作*/    /* ... */};/* 设备模块信息 */static struct pci_driver demo_pci_driver = {    name:       demo_MODULE_NAME,    /* 设备模块名称 */    id_table:   demo_pci_tbl,    /* 能够驱动的设备列表 */    probe:      demo_probe,    /* 查找并初始化设备 */    remove:     demo_remove    /* 卸载设备模块 */    /* ... */};static int __init demo_init_module (void){    /* ... */}static void __exit demo_cleanup_module (void){    pci_unregister_driver(&demo_pci_driver);}/* 加载驱动程序模块入口 */module_init(demo_init_module);/* 卸载驱动程序模块入口 */module_exit(demo_cleanup_module);

static int __init demo_init_module (void){    /* 检查系统是否支持PCI总线 */    if (!pci_present())        return -ENODEV;    /* 注册硬件驱动程序 */    if (!pci_register_driver(&demo_pci_driver)) {        pci_unregister_driver(&demo_pci_driver);                return -ENODEV;    }    /* ... */       return 0;}

static int __init demo_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id){    struct demo_card *card;    /* 启动PCI设备 */    if (pci_enable_device(pci_dev))        return -EIO;    /* 设备DMA标识 */    if (pci_set_dma_mask(pci_dev, DEMO_DMA_MASK)) {        return -ENODEV;    }    /* 在内核空间中动态申请内存 */    if ((card = kmalloc(sizeof(struct demo_card), GFP_KERNEL)) == NULL) {        printk(KERN_ERR "pci_demo: out of memory\n");        return -ENOMEM;    }    memset(card, 0, sizeof(*card));    /* 读取PCI配置信息 */    card->iobase = pci_resource_start (pci_dev, 1);    card->pci_dev = pci_dev;    card->pci_id = pci_id->device;    card->irq = pci_dev->irq;    card->next = devs;    card->magic = DEMO_CARD_MAGIC;    /* 设置成总线主DMA模式 */        pci_set_master(pci_dev);    /* 申请I/O资源 */    request_region(card->iobase, 64, card_names[pci_id->driver_data]);    return 0;}

static int demo_open(struct inode *inode, struct file *file){    /* 申请中断，注册中断处理程序 */    request_irq(card->irq, &demo_interrupt, SA_SHIRQ,        card_names[pci_id->driver_data], card)) {    /* 检查读写模式 */    if(file->f_mode & FMODE_READ) {        /* ... */    }    if(file->f_mode & FMODE_WRITE) {       /* ... */    }        /* 申请对设备的控制权 */    down(&card->open_sem);    while(card->open_mode & file->f_mode) {        if (file->f_flags & O_NONBLOCK) {            /* NONBLOCK模式，返回-EBUSY */            up(&card->open_sem);            return -EBUSY;        } else {            /* 等待调度，获得控制权 */            card->open_mode |= f_mode & (FMODE_READ | FMODE_WRITE);            up(&card->open_sem);            /* 设备打开计数增1 */            MOD_INC_USE_COUNT;            /* ... */        }    }}

static int demo_ioctl(struct inode *inode, struct file *file,      unsigned int cmd, unsigned long arg){    /* ... */        switch(cmd) {        case DEMO_RDATA:            /* 从I/O端口读取4字节的数据 */            val = inl(card->iobae + 0x10);            /* 将读取的数据传输到用户空间 */            return 0;    }        /* ... */}

static void demo_interrupt(int irq, void *dev_id, struct pt_regs *regs){    struct demo_card *card = (struct demo_card *)dev_id;    u32 status;    spin_lock(&card->lock);    /* 识别中断 */    status = inl(card->iobase + GLOB_STA);    if(!(status & INT_MASK))     {        spin_unlock(&card->lock);        return;  /* not for us */    }    /* 告诉设备已经收到中断 */    outl(status & INT_MASK, card->iobase + GLOB_STA);    spin_unlock(&card->lock);        /* 其它进一步的处理，如更新DMA缓冲区指针等 */}

static int demo_release(struct inode *inode, struct file *file){    /* ... */        /* 释放对设备的控制权 */    card->open_mode &= (FMODE_READ | FMODE_WRITE);        /* 唤醒其它等待获取控制权的进程 */    wake_up(&card->open_wait);    up(&card->open_sem);        /* 释放中断 */    free_irq(card->irq, card);        /* 设备打开计数增1 */    MOD_DEC_USE_COUNT;        /* ... */  }

static void __exit demo_cleanup_module (void){    pci_unregister_driver(&demo_pci_driver);}

ifneq ($(KERNELRELEASE),)
obj-m:=hello.o
else
#generate the path
CURRENT_PATH:=$(shell pwd)
#the absolute path
LINUX_KERNEL_PATH:=/lib/modules/$(shell uname -r)/build
#complie object
default:
make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) modules
clean:
make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) clean
endif

#define pci_resource_start(dev, bar)((dev)->resource[(bar)].start)

#define pci_resource_end(dev, bar)((dev)->resource[(bar)].end)

#define pci_resource_flags(dev, bar)((dev)->resource[(bar)].flags)