Linux UIO（Userspace I/O）驱动模型技术详解

struct uio_portio {
    struct kobjectkobj;
    structuio_port *port;
};
 
/** * struct uio_port - description of a UIO port region* @name: name of the port region for identification * @start: start of portregion * @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;
    structuio_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 memoryregion * @name: name of the memory region for identification * @addr: addressof the device's memory * @size: size of IO * @memtype: type of memory addrpoints to * @internal_addr: ioremap-ped version of addr, for driver internaluse * @map: for use by the UIO core only. */
struct uio_mem {
    const char      *name;
    unsigned long       addr;
    unsigned long       size;
    int         memtype;
    void __iomem       *internal_addr;
    structuio_map      *map;
};
 
struct uio_map {
    struct kobjectkobj;
    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);
 
struct uio_device {
    structmodule       *owner;
    structdevice       *dev;
    int         minor;
    atomic_t        event;
    structfasync_struct    *async_queue;
    wait_queue_head_t   wait;
    int         vma_count;
    structuio_info     *info;
    structkobject      *map_dir;
    structkobject      *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 endof 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: mmapoperation for this uio device 
 * @open: open operation for this uio device 
 * @release: release operation for this uio device 
 * @irqcontrol: disable/enableirqs when 0/1 is written to /dev/uioX
 */    
struct uio_info {
    structuio_device   *uio_dev;
    const char      *name;
    const char      *version;
    structuio_mem      mem[MAX_UIO_MAPS];
    structuio_port     port[MAX_UIO_PORT_REGIONS];
    long            irq;
    unsigned long       irq_flags;
    void            *priv;
    irqreturn_t(*handler)(int irq, struct uio_info *dev_info);
    int (*mmap)(structuio_info *info, struct vm_area_struct *vma);
    int (*open)(structuio_info *info, struct inode *inode);
    int(*release)(struct uio_info *info, struct inode *inode);
    int(*irqcontrol)(struct uio_info *info, s32 irq_on);
};

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);
 
while (read(fd, &irq_count, 4) == 4) 
{
    printf("Interrupt number %dn", irq_count);
}