IO模型

【1】IO模型
 1)阻塞IO
 2)非阻塞IO
 3)IO多路复用
 4)异步IO
 
【2】IO多路复用
 多路复用在阻塞IO模型上封装的
 
 应用程序:
        int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
        功能:实现对文件描述符的监听(如果某一个文件描述符准备就绪,select立刻返回)
        函数本身阻塞函数,实现对文件描述符轮询检测

        void FD_CLR(int fd, fd_set *set);  从文件描述符集合中将描述符移除
        int  FD_ISSET(int fd, fd_set *set); 查看当期的文件描述符是否在文件描述符集合中
        void FD_SET(int fd, fd_set *set);  向文件描述符集合中将描述符添加
        void FD_ZERO(fd_set *set);         清空文件描述符集合
        
 驱动:
        unsigned int (*poll) (struct file *, struct poll_table_struct *);
        a)对可能引起设备文件状态变化的等待队列调用poll_wait函数,将对应的等待队列头添加到poll_table
           由内核检测poll_table
           
           static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
           功能:将等待队列加入到poll_table表
           参数:filep
                 wait_address  等待队列头
                 p    poll_table表     
           
        b)返回表示是否能对设备进行无阻塞读,写访问的掩码
                  POLLIN,POLLOUT,POLLRDNORM,POLLERR
                   可读    可写     正常        错误
                   
           return POLLIN|POLLRDNORM
【3】异步IO
 异步通知的意思是:一旦设备就绪,则主动通知应用程序,这样应用程序根本就不需要查询设备状态
 
 应用程序:
    应用程序要捕捉SIGIO信号,注册信号
    signal(SIGIO, handler);  

     应用程序要指定进程为文件的属主
     当前文件描述符属于该进程,进程需要对该文件描述符状态发生改变之后,处理相应的任务
    fcntl(fd, F_SETOWN, getpid());
    
     int fcntl(int fd, int cmd, ... /* arg */ );
     参数:fd  文件描述符
           cmd  定义对文件描述符的操作
           arg  附件参数

    应用程序通过fcntl函数在设备中设置FASYNC标志
    oflags = fcntl(fd, F_GETFL);   获取当前文件描述符的标志位
    fcntl(fd, F_SETFL, oflags | FASYNC); 重新设置标志位

 
   驱动:
       1)支持F_SETOWN命令,能在这个控制命令处理中设置filp->f_owner为对应进程ID。不过此项工作已由内核完成,设备驱动无须处理。
       2)支持F_SETFL命令的处理,每当FASYNC标志改变时,驱动程序中的fasync()函数将得以执行。因此,驱动中应该实现fasync()函数
           fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
           功能:将文件描述符添加到异步通知队列中
           参数:fd  文件描述符
                 filep  
                 on  打开设备的标志位
                 fapp  异步通知队列       
       3)在设备资源可获得时,调用kill_fasync()函数激发相应的信号
          void kill_fasync(struct fasync_struct **fp, int sig, int band)
          功能:向应用程序发送信号
          参数:fp  异步通知队列
                sig  发送的信号类型
                band  掩码  POLLIN可读
                            POLLOUT可写
                            
【4】Linux驱动中设备模型
 在Linux内核中,将对设备的操作代码抽象成一个对象(驱动)
                将对设备的硬件描述抽象成一个对象(设备)
                将该设备使用的总线抽象成一个对象(总线)
 
 在系统每注册一个设备的时候,会寻找与之匹配的驱动;相反的,在系统每注册一个驱动的时候,会寻找与之匹配的设备,而匹配由总线完成
 
 总线可以是物理存在的,也可以是虚拟的。内核中对应的结构为struct bus_type(描述一个总线对象)
   struct bus_type {
          const char        *name; 总线的名称
          int (*match)(struct device *dev, struct device_driver *drv); 实现设备与驱动的匹配
   }
 设备是连接到某条物理或者虚拟总线上的对象。可能是真正物理对象,也可能是虚拟对象。内核中对应的结构为struct device
   struct device{
         struct kobject kobj;  所有的设备对象的父亲
         const char        *init_name;   设备的名称
         struct bus_type    *bus;    总线的名称
         void        *platform_data;    私有数据,存放的是硬件的信息
         void    (*release)(struct device *dev);      卸载设备模块时,自动执行此函数    
   }
 
 驱动是用来和设备通信的软件程序。驱动可以从设备中获取数据,也可以把相应数据发给设备进行处理。内核中对应的结构为struct devicc_driver
   struct device_driver{
        const char        *name;  名称
        struct bus_type        *bus; 总线的名称
        struct module        *owner;  THIS_MODULE
        const struct of_device_id    *of_match_table;  设备树匹配
        int (*probe) (struct device *dev);  回调函数(一但设备与驱动匹配成功,自动执行此函数,存放对设备的操作的代码)
        int (*remove) (struct device *dev); 卸载函数(存放的与probe执行相反的代码)
        
   }
 
 如何实现Linux设备模型:
     1)构建总线对象,并且向内核完成注册
            注册:int bus_register(struct bus_type *bus)
            注销:void bus_unregister(struct bus_type *bus)
     2)构建设备对象,并且向内核完成注册
            注册:int device_register(struct device *dev)  
            注销:void device_unregister(struct device *dev)            
     3)构建驱动对象,并且向内核完成注册
            注册:int driver_register(struct device_driver *drv)
            注销:void driver_unregister(struct device_driver *drv)
     4)实现设备与驱动的匹配
            实现匹配操作
     5)实现驱动对设备的操作    
    
【5】platform设备模型
 将设备,驱动,总线抽象成一个对象
 
 设备对象:描述硬件信息
     struct platform_device {
           const char    *name;  设备的名称
           struct device    dev;   描述设备对象的结构体
                  void    (*release)(struct device *dev);
           u32        num_resources;   描述硬件资源的数量
           struct resource    *resource;   描述硬件资源的信息
    };
    
    struct resource {
    resource_size_t start;   起始地址
    resource_size_t end;     结束地址
    unsigned long flags      标志-描述地址属性
    };    
    
    #define IORESOURCE_MEM        0x00000200  内存地址
    #define IORESOURCE_REG        0x00000300    寄存器的偏移量
    #define IORESOURCE_IRQ        0x00000400  中断
 
 驱动对象:描述驱动代码
    struct platform_driver {
         int (*probe)(struct platform_device *);    回调函数(一但设备与驱动匹配成功,自动执行此函数,存放对设备的操作的代码)
         int (*remove)(struct platform_device *);   卸载函数(存放的与probe执行相反的代码)
         struct device_driver driver;    描述所有驱动对象的结构体
                const char        *name;
                struct module        *owner;  
                const struct of_device_id    *of_match_table;  实现设备树的匹配
         const struct platform_device_id *id_table;  匹配表
        };
 总线对象:描述总线信息
     struct bus_type platform_bus_type = {
           .name        = "platform",      总线的名称
           .match        = platform_match,  匹配方法
     };
 
 platform平台匹配方法
      static int platform_match(struct device *dev, struct device_driver *drv)
     {
    struct platform_device *pdev = to_platform_device(dev);
    struct platform_driver *pdrv = to_platform_driver(drv);

    /* Attempt an OF style match first */          设备树匹配
    if (of_driver_match_device(dev, drv))
        return 1;
    /* Then try to match against the id table */   匹配表匹配
    if (pdrv->id_table)  
        return platform_match_id(pdrv->id_table, pdev) != NULL;   

    /* fall-back to driver name match */
    return (strcmp(pdev->name, drv->name) == 0);    名字匹配
    }
 
 如何实现platform平台模型:
    1)构建设备对象,并且向内核完成注册
           注册:int platform_device_register(struct platform_device *pdev)
           注销:void platform_device_unregister(struct platform_device *pdev)           
    2)构建驱动对象,并且向内核完成注册
           注册:#define platform_driver_register(drv)   __platform_driver_register(drv, THIS_MODULE)
           注销:platform_driver_unregister(struct platform_driver *);
    3)实现设备与驱动的匹配
           匹配方法已实现
    4)实现驱动对设备的操作
           获取硬件资源,实现对设备操作
 

posted @ 2017-08-06 10:28  专注it  阅读(488)  评论(0编辑  收藏  举报