通常这些非标准设备的驱动被实现为字符驱动。这些驱动使用了很多内核内部函数和宏。而这些内部函数和宏是变化的。这样驱动的编写者必须编写一个完全的内核驱动，而且一直维护这些代码。像这种设备如果把驱动放入Linux内核,不但增大了内核的负担，而且还很少使用,更没有人愿意免费的花费大量精力去维护这样的驱动,

使用UIO使驱动的开发可以利用所有的用户空间的应用程序开发工具和库,而且当系统内核发生变化时,只要更改UIO框架与其他内核程序交互的接口即可,不需要更改UIO框架下面的硬件相关的driver。

（2）增加驱动程序编程语言的适应性和方便性。

第二, 如果是内核驱动的开发，则必须使用C语言加上少量汇编代码。

如果是uio用户空间驱动，则可以使用C++，Java ...等高级语言极大的方便了开发。

我们可以发现，有很多的卡的驱动在内核空间已经有实现，这样，我们可以参考已经存在的代码，极大的提高的开发的速度，和降低了开发成本。

而且内核驱动的调试会比用户空间程序调试复杂很多。我们经常遇到死机，涉及到多个子系统，棘手。

放在用户空间的话如果驱动程序死了,并不影响系统的正常运行并且方便了我们的开发。

（3）避免数据拷贝，增加性能。

内核空间与用户空间至少有一次内存拷贝，如果在硬件空间实现硬件的数据收发，则至少进行一次内存拷贝，用户空间才能收到才数据。如果通过UIO，直接在用户空间收发硬件设备的数据，避免了至少一次的内存数据拷贝，增加了系统的性能。

DPDK采用UIO机制，主要的原因就源于此。

第2章如何在用户空间使用UIO设备

2.1 概述

无论是网卡，还是FPGA，如果被设计成UIO设备，在用户空间看到的就是一个个设备文件和一段可以读写操作的内存空间而已。

下图为uio驱动框架的整体框图，在内核空间uio驱动的内核代码部分会在/dev目录下生成uio设备节点，节点名称为/dev/uiox，其中x从0开始递增。

同时，在sysfs文件下还会生成与uio设备相关的属性，读写这些属性文件就可以获得该uio设备的相关信息。

2.2 分层架构

（1）内核空间

UIO Framework：UIO设备文件驱动程序框架。
Driver：UIO设备硬件直接相关程序，操作硬件地址和寄存器。

（2）接口

sysfs：设备信息接口
/dev/uiox：设备文件接口

（3）用于空间

read：读取硬件设备数据
write：向硬件设备写数据
mmap：把映射设备的内核地址映射到用户空间，用户空间可以直接操作这段地址空间。

2.3 操作uio设备的简单流程为:

调用open函数打开uio设备节点/dev/uio0，得到文件描述符fd。
调用write向uio设备写1打开中断，写0会关闭中断。
调用read函数读uio设备，此时会阻塞等待uio设备中断，若产生中断则会继续执行。

第3章 uio驱动程序框架与原理

UIO分成3个部分，主要是内核部分和用户空间部分。

在UIO框架下，用户空间下的驱动程序比运行在内核空间的驱动要多得多。

3.1 在内核硬件硬件相关层（*.ko程序）

（1）分配和记录设备需要的资源和注册uio设备

主要是实现硬件寄存器的内存映射（struct uio_info -> struct uio_mem）及读写操作。
定义设备对象、实现设备操作函数、调用设备对象的注册函数进行注册
内存映射：UIO 核心实现了mmap()可以处理物理内存(physical memory)，逻辑内存(logical memory)，虚拟内存(virtual memory)。UIO驱动的编写是就不需要再考虑这些繁琐的细节。如果有些设备的总线不是PCI总线，那么仍需要做相关的处理
将uio设备的uio_mem映射到本地（mmap），这样就可以实现在用户空间访问硬件设备寄存器的目的，

（2）必须*在内核空间实现的小部分中断应答函数

处理设备产生的中断：对于设备中断的应答必须在内核空间进行。所以在内核空间有一小部分代码用来应答中断和禁止中断，但是其余的工作全部留给用户空间处理。

（3）代码示例

 struct uio_portio 
    struct kobject kobj;
    struct uio_port *port;
;
/**
 * struct uio_port - description of a UIO port region
 * @name:       name of the port region for identification
 * @start:      start of port region
 * @size:       size of port region
 * @porttype:       type of port (see UIO_PORT_* below)
 * @portio:     for use by the UIO core only.
 */
struct uio_port 
    const char      *name;
    unsigned long       start;
    unsigned long       size;
    int         porttype;
    struct uio_portio   *portio;
;
/* defines for uio_port->porttype */
#define UIO_PORT_NONE   0
#define UIO_PORT_X86    1
#define UIO_PORT_GPIO   2
#define UIO_PORT_OTHER  3
  /*
  * struct uio_mem - description of a UIO memory region
 * @name:       name of the memory region for identification
 * @addr:       address of the device's memory
 * @size:       size of IO
 * @memtype:        type of memory addr points to
 * @internal_addr:  ioremap-ped version of addr, for driver internal use
 * @map:        for use by the UIO core only.
 */
struct uio_mem 
    const char      *name;// 内存映射的名字
    unsigned long       addr; // 内存块的地址
    unsigned long       size; //addr所指向的内存块的大小
    int         memtype; //UIO_MEM_PHYS,UIO_MEM_LOGICAL(kmalloc()),UIO_MEM_VIRTUAL( virtual memory)
    void __iomem        *internal_addr; // If you have to access this memory region from within your kernel module,
                                                               // you will want to map it internally by using something like ioremap().
    struct uio_map      *map;
;
 struct uio_map 
    struct kobject kobj;
    struct uio_mem *mem;
;
 static const struct vm_operations_struct uio_vm_ops = 
    .open = uio_vma_open,
    .close = uio_vma_close,
    .fault = uio_vma_fault,
;
 static struct device_attribute uio_class_attributes[] = 
    __ATTR(name, S_IRUGO, show_name, NULL),
    __ATTR(version, S_IRUGO, show_version, NULL),
    __ATTR(event, S_IRUGO, show_event, NULL),
    
;
 /* UIO class infrastructure */
static struct class uio_class = 
    .name = "uio",// /sys/class/uio
    .dev_attrs = uio_class_attributes,
;
static const struct file_operations uio_fops = 
    .owner      = THIS_MODULE,
    .open       = uio_open,
    .release    = uio_release,
    .read       = uio_read,
    .write      = uio_write,
    .mmap       = uio_mmap,
    .poll       = uio_poll,
    .fasync     = uio_fasync,
    .llseek     = noop_llseek,
;
/* Protect idr accesses */
static DEFINE_MUTEX(minor_lock);
static DEFINE_IDR(uio_idr);
//关于idr机制。參见 http://blog.csdn.net/ganggexiongqi/article/details/6737389
struct uio_device 
    struct module       *owner;
    struct device       *dev; //在__uio_register_device中初始化
    int         minor; // 次设备id号，uio_get_minor
    atomic_t        event; //中断事件计数
    struct fasync_struct    *async_queue;//该设备上的异步等待队列//
                                                               // 关于 “异步通知“ //參见LDD3第六章
    wait_queue_head_t   wait; //该设备上的等待队列，在注冊设备时(__uio_register_device)初始化
    int         vma_count;
    struct uio_info     *info;// 指向用户注冊的uio_info，在__uio_register_device中被赋值的
    struct kobject      *map_dir;
    struct kobject      *portio_dir;
;
/*
 * struct uio_info - UIO device capabilities
 * @uio_dev:        the UIO device this info belongs to
 * @name:       device name
 * @version:        device driver version
 * @mem:        list of mappable memory regions, size==0 for end of list
 * @port:       list of port regions, size==0 for end of list
 * @irq:        interrupt number or UIO_IRQ_CUSTOM
 * @irq_flags:      flags for request_irq()
 * @priv:       optional private data
 * @handler:        the device's irq handler
 * @mmap:       mmap operation for this uio device
 * @open:       open operation for this uio device
 * @release:        release operation for this uio device
 * @irqcontrol:     disable/enable irqs when 0/1 is written to /dev/uioX
 */
struct uio_info 
    struct uio_device   *uio_dev; // 在__uio_register_device中初始化
    const char      *name; // 调用__uio_register_device之前必须初始化
    const char      *version; //调用__uio_register_device之前必须初始化
    struct uio_mem      mem[MAX_UIO_MAPS];
    struct uio_port     port[MAX_UIO_PORT_REGIONS];
    long            irq; //分配给uio设备的中断号，调用__uio_register_device之前必须初始化
    unsigned long       irq_flags;// 调用__uio_register_device之前必须初始化
    void            *priv; //
    irqreturn_t (*handler)(int irq, struct uio_info *dev_info); //uio_interrupt中调用。用于中断处理
                                                                // 调用__uio_register_device之前必须初始化
    int (*mmap)(struct uio_info *info, struct vm_area_struct *vma); //在uio_mmap中被调用，
                                                                    // 运行设备打开特定操作
    int (*open)(struct uio_info *info, struct inode *inode);//在uio_open中被调用，运行设备打开特定操作
    int (*release)(struct uio_info *info, struct inode *inode);//在uio_device中被调用。运行设备打开特定操作
    int (*irqcontrol)(struct uio_info *info, s32 irq_on);//在uio_write方法中被调用，运行用户驱动的
                                                                                       //特定操作。
;

3.2 内核核心层（UIO内核驱动框架）

实现类似字符设备注册那一套操作。
实现UIO设备公共的操作。

3.3 在用户空间部分（*.so程序）

（1）用户空间主要操作

控制硬件设备的寄存器。
如果用户空间要等待一个设备中断，它只需要简单的阻塞在对 /dev/uioX的read()操作上。当设备产生中断时，read()操作立即返回。
UIO 也实现了poll()系统调用，你可以使用 select()来等待中断的发生。select()有一个超时参数可以用来实现有限时间内等待中断。
对设备的控制还可以通过/sys/class/uio下的各个文件的读写来完成。你注册的uio设备将会出现在该目录下。假如你的uio设备是uio0那么映射的设备内存文件出现在 /sys/class/uio/uio0/maps/mapX，对该文件的读写就是对设备内存的读写。

（2）用户空间程序案例


    int32_t irq_count;

    int fd = open("/dev/uio0", O_RDWR);

    /* Map the register regions to proccess's virtual memspace */
    void * access = mmap(NULL, 4096,
        // 寄存器的读写操作，可用过普通内存读写的方式完成
        PROT_READ | PROT_WRITE,
        MAP_SHARED, fd, 0);// [1]
    
    while (read(fd, &irq_count, 4) == 4) 
        
        printf("Interrupt number %d\\n", irq_count);