Linux UIO驱动实例介绍

小鱼儿 2022-11-21 09:59 340阅读 0赞

接上一篇介绍UIO机制: [https://blog.csdn.net/hpu11/article/details/109395820][https_blog.csdn.net_hpu11_article_details_109395820]

uio驱动详解

为了用最简单的例子说明问题，我们在我们uio驱动的内核部分只映射了一块1024字节的  
逻辑内存。没有申请中断。  
这样加载上我们的驱动后，将会在/sys/class/uio/uio0/maps/map0中看到  
addr name offset size。他们分别是映射内存的起始地址, 映射内存的名字，起始地址的页内偏移,  
映射内存 的大小。 在uio驱动的用户空间部分，我们将打开addr, size以便使用映射好的内存。

//simple.c
    
    /**  
    *  This is a simple demon of uio driver.  
    *  Last modified by   
            09-05-2011   Joseph Yang(Yang Honggang)<ganggexiongqi@gmail.com>  
    *  
    * Compile:    
    *   Save this file name it simple.c  
    *   # echo "obj-m := simple.o" > Makefile  
    *   # make -Wall -C /lib/modules/`uname -r`/build M=`pwd` modules  
    * Load the module:  
    *   #modprobe uio  
    *   #insmod simple.ko  
    */  
      
    #include <linux/module.h>  
    #include <linux/platform_device.h>  
    #include <linux/uio_driver.h>  
    #include <linux/slab.h> /* kmalloc, kfree */  
    struct uio_info kpart_info = {  
            .name = "kpart",  
            .version = "0.1",  
            .irq = UIO_IRQ_NONE,  
    };  
      
    static int drv_kpart_probe(struct device *dev);  
    static int drv_kpart_remove(struct device *dev);  
    static struct device_driver uio_dummy_driver = {  
            .name = "kpart",  
            .bus = &platform_bus_type,  
            .probe = drv_kpart_probe,  
            .remove = drv_kpart_remove,  
    };  
      
    static int drv_kpart_probe(struct device *dev)  
    {  
            printk("drv_kpart_probe( %p)\n", dev);  
            kpart_info.mem[0].addr = (unsigned long)kmalloc(1024,GFP_KERNEL);  
      
            if(kpart_info.mem[0].addr == 0)  
                    return -ENOMEM;  
            kpart_info.mem[0].memtype = UIO_MEM_LOGICAL;  
            kpart_info.mem[0].size = 1024;  
      
            if( uio_register_device(dev, &kpart_info))  
                    return -ENODEV;  
            return 0;  
    }  
      
    static int drv_kpart_remove(struct device *dev)  
    {  
        uio_unregister_device(&kpart_info);  
      
        return 0;  
    }  
      
    static struct platform_device * uio_dummy_device;  
      
    static int __init uio_kpart_init(void)  
    {  
            uio_dummy_device = platform_device_register_simple("kpart", -1,  
                            NULL, 0);  
      
            return driver_register(&uio_dummy_driver);  
    }  
      
    static void __exit uio_kpart_exit(void)  
    {  
            platform_device_unregister(uio_dummy_device);  
            driver_unregister(&uio_dummy_driver);  
    }  
      
    module_init(uio_kpart_init);  
    module_exit(uio_kpart_exit);  
      
    MODULE_LICENSE("GPL");  
    MODULE_DESCRIPTION("UIO dummy driver");

这个文件是我们uio驱动的内核部分。下面做下简要解释。  
一个uio驱动的注册过程简单点说有两个步骤：  
1. 初始化设备相关的 uio\_info结构。  
2. 调用uio\_register\_device 分配并注册一个uio设备。  
  
uio驱动必须要提供并初始化的结构 uio\_info, 它包含了您要注册的uio\_device的重要特性。  
struct uio\_info kpart\_info = \{  
.name = "kpart",  
.version = "0.1",  
.irq = UIO\_IRQ\_NONE,//我们没有使用中断，所以初始为UIO\_IRQ\_NONE  
\};  
当你没有实际的硬件设备，但是，还想产生中断的话，就可以把irq设置为UIO\_IRQ\_CUSTOM，  
并初始化uio\_info的handler字段，那么在产生中断时，你注册的中断处理函数将会被调用。  
如果有实际的硬件设备，那么irq应该是您的硬件设备实际使用的中断号。  
  
然后，在drv\_kpart\_probe函数(先不要管为什么在这个函数中进行这些操作)中，完成了  
kpart\_info.mem\[0\].addr， kpart\_info.mem\[0\].memtype，  
kpart\_info.mem\[0\].size字段的初始化。这是内存映射必须要设置的。  
其中, kpart\_info.mem\[0\].memtype可以是 UIO\_MEM\_PHYS，那么被映射到用户空间的是你  
设备的物理内存。也可以是UIO\_MEM\_LOGICAL，那么被映射到用户空间的是逻辑内存  
(比如使用 kmalloc分配的内存)。还可以是UIO\_MEM\_VIRTUAL,那么被映射到用户空间的是  
虚拟内存(比如用vmalloc分配的内存).这样就完成了uio\_info结构的初始化。  
下一步，还是在drv\_kpart\_probe中，调用uio\_register\_device完成了uio设备向uio core的注册。  
  
下面讲一下，为什么我们的设备跟platform之类的东东扯上了关系?  
我们的驱动不存在真正的物理设备与之对应。而 Platform 驱动“自动探测“，这个特性是  
我们在没有实际硬件的情况下需要的。  
  
先从uio\_kpart\_init开始分析。  
platform\_device\_register\_simple的调用创建了一个简单的platform设备。  
注册device\_driver类型的uio\_dummy\_driver变量到bus。  
这里需要注意一个问题，就是 device\_driver结构中的name为“kpart", 我们创建的platform设备  
名称也是"kpart"。而且先创建platform设备，后注册驱动。这是因为，创建好设备后，注册驱动时，  
驱动依靠name来匹配设备。  
之后 drv\_kpart\_probe就完成了uio\_info的初始化和uio设备的注册。

// user_part.c
    
    #include <stdio.h>  
    #include <fcntl.h>  
    #include <stdlib.h>  
    #include <unistd.h>  
    #include <sys/mman.h>  
    #include <errno.h>  
      
    #define UIO_DEV "/dev/uio0"  
    #define UIO_ADDR "/sys/class/uio/uio0/maps/map0/addr"  
    #define UIO_SIZE "/sys/class/uio/uio0/maps/map0/size"  
      
    static char uio_addr_buf[16], uio_size_buf[16];  
      
    int main(void)  
    {  
      int uio_fd, addr_fd, size_fd;  
      int uio_size;  
      void* uio_addr, *access_address;  
       
      uio_fd = open(UIO_DEV, /*O_RDONLY*/O_RDWR);  
      addr_fd = open(UIO_ADDR, O_RDONLY);  
      size_fd = open(UIO_SIZE, O_RDONLY);  
      if( addr_fd < 0 || size_fd < 0 || uio_fd < 0) {  
           fprintf(stderr, "mmap: %s\n", strerror(errno));  
           exit(-1);  
      }  
      read(addr_fd, uio_addr_buf, sizeof(uio_addr_buf));  
      read(size_fd, uio_size_buf, sizeof(uio_size_buf));  
      uio_addr = (void*)strtoul(uio_addr_buf, NULL, 0);  
      uio_size = (int)strtol(uio_size_buf, NULL, 0);  
      
      access_address = mmap(NULL, uio_size, PROT_READ | PROT_WRITE,  
                         MAP_SHARED, uio_fd, 0);  
      if ( access_address == (void*) -1) {  
          fprintf(stderr, "mmap: %s\n", strerror(errno));  
          exit(-1);  
      }  
      printf("The device address %p (lenth %d)\n"  
             "can be accessed over\n"  
             "logical address %p\n", uio_addr, uio_size, access_address);  
     //读写操作  
    /*  
     access_address = (void*)mremap(access_address, getpagesize(), uio_size + getpagesize() + 11111, MAP_SHARED);  
      
      if ( access_address == (void*) -1) {  
          fprintf(stderr, "mremmap: %s\n", strerror(errno));  
          exit(-1);  
      }   
      printf(">>>AFTER REMAP:"  
             "logical address %p\n", access_address);  
    */  
      return 0;  
    }

测试：

加载uio模块  
\#modprobe uio  
  
加载simple.ko  
\#insmod simple.ko  
\# ls /dev/ | grep uio0  
uio0  
\# ls /sys/class/uio/uio0  
...  
如果相应的文件都存在，那么加载用户空间驱动部分。  
\#./user\_part  
The device address 0xee244400 (lenth 1024)  
can be accessed over  
logical address 0xb78d4000

[https_blog.csdn.net_hpu11_article_details_109395820]: https://blog.csdn.net/hpu11/article/details/109395820