FPGA驱动

 设备驱动程序是应用程序与硬件之间的一个中间软件层，设备驱动程序为应用程序屏蔽了硬件的细节。这样在应用程序看来，硬件设备只是一个设备文件，应用程序可以像操作普通文件一样对硬件设备进行操作。设备驱动程序是内核的一部分，它主要实现的功能有：对设备进行初始化和释放；把数据从内核传送到硬件和从硬件读取数据；读取应用程序传送给设备文件的数据，回送应用程序请求的数据以及检测和处理设备出现的错误。
    
    Linux将设备分为最基本的两大类：一类是字符设备；另一类是块设备。字符设备和块设备的主要区别在于是否使用了缓冲技术。字符设备以单个字节为单位进行顺序读/写操作，通常不使用缓冲技术；块设备为了提高效率，利用一块系统内存作为读/写操作的缓冲区，由于涉及缓冲区管理、调度和同步等问题，实现起来比字符设备复杂得多。
    
    Linux通过设备文件系统对设备进行管理，各种设备都以文件的形式存放在/dev目录下，称为“设备文件”。应用程序可以像普通文件一样打开、关闭和读/写这些设备文件。为了管理这些设备，系统为设备编了号，每个设备号又分为主设备号和次设备号。主设备号用来区分不同种类的设备，而次设备号用来区分同一类型的多个设备。Linux为所有的设备文件都提供了统一的操作函数接口，方法是使用数据结构struct file_operations。这个数据结构中包括许多操作函数的指针，如open()、close()、read()和write()等，但由于外设的种类较多，操作方式各不相同。struct file_operations结构体中的成员为一系列的接口函数，如用于读/写的read/write函数和用于控制的ioctl等。打开一个文件就是调用这个文件file_operations中的open操作。不同类型的文件（如普通的磁盘数据文件）有不同的file_operations成员函数，接口函数完成磁盘数据块读/写操作；而对于各种设备文件，则最终调用各自驱动程序中的I/O函数进行具体设备的操作。这样，应用程序根本不必考虑操作的是设备还是普通文件，可一律当作文件处理，具有非常清晰、统一的I/O接口，所以file_operations是文件层次的I/O接口。
ACEX1K50在Linux下设备驱动的实现
    
    在驱动程序中使用内存映射可以提供给用户程序直接访问设备内存的能力。使用内存映射的好处是处理大文件时速度明显快于标准文件I/O，无论读/写，都少了一次用户空间与内核空间之间的复制。在用户空间对ACEX1K50 FPGA设备的访问是通过内存映射来实现的。
    
    ACEX1K50可以看作是硬件连接在PXA270微处理器的nCS<2>上的一段物理地址来寻址。因为有虚拟内存管理单元，所以如果在Linux下，必须先把物理地址映射到虚拟地址空间，然后才能对该段地址进行读/写。
    
    在内核驱动程序的初始化阶段，通过ioremap（）将ACEX1K50的这段物理地址映射到内核虚拟空间；在驱动程序的mmap系统调用中，使用remap_page_range（）将该块ROM映射到用户虚拟空间。这样内核空间和用户空间都能访问ACEX1K50的这段被映射后的虚拟地址。
    
    由于ACEX1K50位于nCS<2>上，参照PXA270静态存储体系结构映射表，其物理起始地址为0x08000000。另外，其设备名称及主次设备号定义如下：
    
    #define FPGA_PHY_START0x08000000
    // nCS<2>: PAX270平台
    #define FPGA_PHY_SIZESZ_4K
    // nCS<2>: Slot FPGA物理基大小为4K
    #define DEVICE_NAME"PXA270 FPGA"
    #define FPGARAW_MINOR 1
    #define FPGA_Devfs_path"fpga/0"
    static int fpgaMajor = 0;
    
    其中FPGA主设备号定义为零，使得操作系统可以随机为该设备分配主设备号。
    
    ioremap()的作用是把一个物理内存地址点映射为一个内核指针，被映射数据的长度由size参数设定。该函数的实质是把一块物理区域二次映射到一个可以从驱动程序里访问的虚拟地址上去。以下是该函数的定义：
    
    void *ioremap(unsigned long phys_addr, unsigned long size);
    
    设备驱动通过fpga_init()函数初始化FPGA设备，最终通过init_module(fpga_init)在内核启动时初始化FPGA设备。
    
    fpga_init()函数的流程如图3所示。
      

    图3 fpga_init()流程
    
    ioremap（）调用的语句如下：
    
    pxa270_fpga_base= (unsigned long) ioremap(FPGA_PHY_START, SZ_4K);
    
    可以通过ioremap（）调用的返回值pxa270_fpga_base来判断FPGA物理地址到内核虚拟空间是否映射成功。
    
    if(!pxa270_fpga_base) {
    printk("ioremap pxa270 fpga failed\n");
    return -EINVAL;
    }
    
    向设备文件系统注销FPGA设备通过调用cleanup_module（）函数来实现。其代码如下：
    
    void __exit fpga_exit(void) {
    #ifdef CONFIG_DEVFS_FS
    devfs_remove(FPGA_Devfs_path);
    #endif
    unregister_chrdev(fpgaMajor, DEVICE_NAME);
    }
    cleanup_module (fpga_exit);
    
    在向内核设备文件系统注册该FPGA驱动后，还须实现设备驱动的file_operations结构。ACEX1K50的设备驱动定义了如下file_operations成员函数：
    
    static struct file_operations pxa270_fops = {
    owner:THIS_MODULE,
    open:fpga_open,
    mmap:fpga_mmap,
    ioctl:fpga_ioctl,
    release:fpga_release,
    };
    
    其中fpga_open和fpga_release系统调用的功能只简单地实现了FPGA设备使用计数器的递增与递减，fpga_ioctl系统调用也只是简单的打印一条没有ioctl控制的信息提示。这里不再分析实现的具体代码。下面具体分析fpga_mmap的实现过程：
    
    static int fpga_mmap(struct file *filp, struct vm_area_struct *vma) {
    unsigned long off = vma->vm_pgoff << PAGE_SHIFT;
    unsigned long physical = FPGA_PHY_START + off;
    unsigned long vsize = vma->vm_end - vma->vm_start;
    unsigned long psize = FPGA_PHY_SIZE- off;
    if (vsize > psize)
    return -EINVAL; //spans too high
    vma->vm_flags |= VM_IO|VM_RESERVED;
    vma->vm_page_prot=pgprot_noncached(vma->vm_page_prot);
    remap_page_range(vma, vma->vm_start, physical, vsize, vma->vm_page_prot);
    return 0;
    }
    
    fpga_mmap(struct file *filp, struct vm_area_struct *vma)系统调用允许直接将FPGA设备内存线性地映射到用户进程的地址空间中。fpga_mmap系统调用是通过调用 remap_page_range（）函数来实现一段线性物理地址的映射，调用remap_page_range（）函数需要填写 vm_area_struct结构的几个关键字段。
    
    int remap_page_range(struct vm_area_struct *vma, unsigned long from, unsigned long to, unsigned long size, pgprot_t prot)函数每个参数的意义说明如下：
    
    vm_area_struct *//虚拟内存区域（VMA）指针
    unsigned long from//需要映射的用户虚拟地址的起始位置
    unsigned long to//虚拟地址所映射到的物理地址
    unsigned long size//被重映射区域的大小，以字节为单位
    
    4 设备驱动在用户程序中的使用
    
    当设备驱动实现后，就可以在用户空间使用该设备了。在用户空间主要是通过调用mmap（）函数来实现对FPGA设备的访问。以下是用户空间应用程序的一个示例：
   ……………………………………………………………………
    fd = open("/dev/fpga/0",O_RDWR);//打开设备文件
    if(fd < 0){
    printf("####fpgadevice open fail####\n");
    return (-1);//判断打开设备文件是否成功
    }
    iobase = (unsigned char *)mmap(0, 4096,PROT_READ | PROT_WRITE, MAP_SHARED,fd,0);//经过地址映射后，可对FPGA的寄存器进行一系列操作
    ……………………………………………………………………
    close(fd);//关闭设备文件

//////////////////////////////////////////////////////////////////

 

 

根据上述思路的架构我写了一个类似的驱动，它纯粹是一种数据搬移操作。是一种最简单的驱动。唯一与上面描述的区别在于我写的驱动是在2.6内核下的，而上面所有的描述都是针对2.4内核的。

MODULE_LICENSE("Dual BSD/GPL");

#define FPGA_PHY_START 0xD00000000ULL
#define SZ_2M 2*1024*1024
#define MAX_VW_DEV_NUM 16
#define FPGA_PHY_SIZE SZ_2M
#define ANY_MAJOR 0
static int fpgamagor=0;

unsigned long fpga_vp;

#define fpga_dma_channel 0
#define DCG_GPIO1_BASE     0xB1900000
#define DCG_GOIO1_MODE          0x002C
#define DMA_DDMA0_BASE   0xB4002000
#define DMA_GLOBAL_BASE   0xB4003000

struct fpga_dma_device{
unsigned int dma_irq;
unsigned int dma_channel;

};

 

static int fpga_open(struct inode *,struct file*);
static int fpga_release(struct inode *,struct file *);
static ssize_t fpga_read(struct file *filp, char __user *buf, size_t count,loff_t *f_pos);
static ssize_t fpga_write(struct file *filp, const char __user *buf, size_t count,loff_t *f_pos);
static int fpga_mmap( struct file *,struct vm_area_struct *);
static int fpga_ioctl(struct inode *,struct file *);

struct file_operations fpga_fops={
 .open=fpga_open,
 .release=fpga_release,
 .read=fpga_read,
 .write=fpga_write,
 .ioctl=fpga_ioctl,
 .mmap=fpga_mmap,
 .owner=THIS_MODULE
 
};

 

irqreturn_t fpga_dma_interrupt(int irq, void *dev_id)
{
 struct motion_key_dev * motiondev = (struct motion_key_dev *)dev_id;
 //u32 reg_value = 0;
 (motion_key_device->count)++;
 motion_key_device->int_come = 1;
        printk(KERN_WARNING "Enter motion_key_interrup %d \n", motion_key_device->count);
 printk(KERN_WARNING "reg value = 0x%x \n", __raw_readl(S3C24XX_EXTINT2)); 
 wake_up_interruptible(&motiondev->key_queue);
 return IRQ_HANDLED;
}

static int fpga_open(struct inode *ip,struct file *fp)
{
 struct fpga_dma_device *fpga_device;
 
 if((error=request_irq(fpag_device.dma_irq,fpga_dma_interrupt,SA_INTERRUPT,"fpga",NULL)))
 return error;
 
 if((error=request_dma(fpga_device.dma_channel,"fpga"))){
 free_irq(fpga_device.dma_irq,NULL);
 return error;
 }
 
 
 
 fp->f_op=&fpga_fops;
 
 fpga_vp=(unsigned long)ioremap(FPGA_PHY_START,SZ_2M);

 if(!fpga_vp){

 printk("ioremap  fpga failed\n");
 

 return -EINVAL;

 }
 printk("fpga_vp is 0x%.8x \n",fpga_vp); 
 return(0);
 

}

static int fpga_release(struct inode *ip,struct file *fp)
{

 if(fpga_vp)
  iounmap(fpga_vp);
  
  
 struct fpag_dma_device *fpga_device;
 free_dma(fpag_device.dma_channel);
 free_irq(fpga_device.dma_irq,NULL);
     
  
 return(0);
 
 
}

static ssize_t fpga_read(struct file *filp, char __user *buf, size_t count,loff_t *f_pos)
{
 unsigned char *p = (unsigned char *)fpga_vp;
 ssize_t retval = 0;
 if(copy_to_user(buf, p, count))
 {
  retval = -EFAULT;
  goto out;
 }
 retval = count;
 out:
 return retval;
}

static ssize_t fpga_write(struct file *filp, const char __user *buf, size_t count,loff_t *f_pos)
{
 //unsigned char *p = (unsigned char *)fpga_vp;
 ssize_t retval = 0;
 //printk("Enter write\n");
 if(copy_from_user(fpga_vp, buf, count))
 {
  retval = -EFAULT;
  printk("Write error\n");
  goto out;
 }
 retval = count;
 out:
 return retval;
}

void fpga_vma_open(struct vm_area_struct *vma)
{ return; }

void fpga_vma_close(struct vm_area_struct *vma)
{ return; }

 

static struct vm_operations_struct fpga_remap_vm_ops = {
    .open =  fpga_vma_open,
    .close = fpga_vma_close,
};

static int fpga_mmap( struct file *filp,struct vm_area_struct *vma)
{
         unsigned int len;
        unsigned long start=0, off;

        if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
        {
                printk(" Error vma->vm_pgoff > !OUL PAGE_SHIFT \n");
                 return -EINVAL;
                }

//        start = virt_to_phys(mem_buf) & PAGE_MASK;
 start =  FPGA_PHY_START;
 //     len = PAGE_ALIGN((start & ~PAGE_MASK) + 2*MAX_FRAME_SIZE);
 len =  FPGA_PHY_SIZE; 
     off = vma->vm_pgoff << PAGE_SHIFT;

        if ((vma->vm_end - vma->vm_start + off) > len)
         {
                printk(" Error vma->vm_end-vma->vm_start\n");
                return -EINVAL;
         }

        off += start;
        vma->vm_pgoff = off >> PAGE_SHIFT;
        pgprot_val(vma->vm_page_prot) &= ~_CACHE_MASK;
        pgprot_val(vma->vm_page_prot) |= PAGE_CACHABLE_DEFAULT;

       
        vma->vm_flags |= VM_IO;

        if (remap_pfn_range(vma,vma->vm_start, off,
                                vma->vm_end - vma->vm_start,
                                vma->vm_page_prot))
        {
                return -EAGAIN;
        }

        return 0;

}

static int fpga_ioctl(struct inode *ip,struct file *fp)
{

 printk("use fpga_ioctl\n");
 return 0;
}

 

void fpga_dma_init(void)
{
 unsigned int gpio1_mode=0x00000010;
 
 au_writel( gpio1_mode , DCG_GPIO1_BASE + 0x0100 );//sys_triout--->GPIO4
 gpio1_mode=au_readl(DCG_GPIO1_BASE + 0x0100);
 printk(KERN_ALERT "sys_triout--->GPIO4  : %.8x \n",gpio1_mode);

 
 unsigned int dma_val=au_readl(DMA_GLOBAL_BASE+0x0000);//ddma_config

 dma_val |=0x00000000;
 au_writel(dma_val,DMA_GLOBAL_BASE+0x0000);
 
 dma_val=au_readl(DMA_GLOBAL_BASE+0x0008);//ddma_throttle
 dma_val |= 0x80000000;

 au_writel(dma_val,DMA_GLOBAL_BASE+0x0008);

 dma_val=au_readl(DMA_GLOBAL_BASE+0x000c);//ddma_inten
 dma_val |= 0x00000001;

 au_writel(dma_val,DMA_GLOBAL_BASE+0x000c);
   

}

static int __init fpga_init(void)
{
 int fpga_base;
 int fpgamajor;
 unsigned int mac0_phy;
 
 printk("-----fpga----\n"); 
 mac0_phy=au_readl(0xB4001030);
 printk(KERN_ALERT "mem_stcfg3 0xB4001030 : %.8x \n",mac0_phy);
 
 mac0_phy=au_readl(0xB4001034);
 printk(KERN_ALERT "mem_sttime3 0xB4001034: %.8x \n",mac0_phy);
 mac0_phy=au_readl(0xB4001038);
 printk(KERN_ALERT "mem_staddr3 0xB4001038: %.8x \n",mac0_phy);

 printk("-----fpga write----\n"); 

 au_writel(0x00000001,0xB4001030);
 mac0_phy=au_readl(0xB4001030);
 printk(KERN_ALERT "mem_stcfg3 0xB4001030 : %.8x \n",mac0_phy);

 au_writel(0x10003FF8,0xB4001038);
 mac0_phy=au_readl(0xB4001038);
 printk(KERN_ALERT "mem_stcfg3 0xB4001038 : %.8x \n",mac0_phy);
 
 fpga_dma_init();
 

 fpgamajor=register_chrdev(ANY_MAJOR,"fpga",&fpga_fops);
 printk(KERN_INFO "fpga:fpgamajor=0x%x or %d\n",fpgamajor,fpgamajor);
 printk(KERN_INFO "fpga:init_module() OUT \n");
 
 return 0;
}

static void __exit fpga_exit(void)
{
 unregister_chrdev(fpgamagor,"fpga");
 printk(KERN_INFO "fpga cleanup_module OUT \n");

}

module_init(fpga_init);

module_exit(fpga_exit);