0726_驱动1 非阻塞/阻塞

一、非阻塞概念

1.当一个app应用层程序，取读取硬件中的数据

2.不管硬件中的数据是否准备好

3.都会立即返回数据

二、非阻塞模型

应用层：
    fd = open("/dev/myled0",O_RDWR |  O_NONBLOCK); // 以非阻塞方式打开
    read(fd,buf,sizeof(buf));
------------------------------------------------------------
内核层：
    ssize_t myled_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
    {
        if(file->f_flags & O_NONBLOCK) //判断是否以非阻塞方式打开
        {
            //表示以非阻塞方式打开
            //不管硬件中的数据是否准备好
            //都会立即返回数据                 
        }
    }   

------------------------------------------------------------
硬件层：
    /dev/myled0

三、阻塞工作原理

1.当一个app应用程序，去读取硬件中的数据

2.如果硬件数据没有准备好，进程进入休眠状态

3.当硬件数据准备好，硬件会产生中断

4.在中断处理函数中，唤醒休眠的进程

5.当进程唤醒之后，将准备好的硬件中的数据，读取到内核空间

6.在内核空间，通过调用copy_to_user函数，将内核空间读取到的硬件数据，拷贝到用户空间

四、阻塞模型

应用层：
    fd = open("/dev/myled0",O_RDWR); // 以非阻塞方式打开
    read(fd,buf,sizeof(buf));
------------------------------------------------------------
内核层：
    ssize_t myled_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
    {
        if(file->f_flags & O_NONBLOCK) //以非阻塞方式打开
        {
            //表示以非阻塞方式打开
            //不管硬件中的数据是否准备好
            //都会立即返回数据                 
        }
        else //以阻塞方式打开
        {
            //如果硬件数据没有准备好，进程进入休眠状态
            //当硬件数据准备好, 唤醒休眠的进程
            //将准备好的硬件中的数据，读到内核空间
            //调用copy_to_user函数，拷贝到用户空间  
        }
    }   

------------------------------------------------------------
硬件层：
    /dev/myled0

五、阻塞API接口

1.wait_queue_head_t wq; //定义等待队列头
2.init_waitqueue_head(&wq);  //队头初始化
3.int wait_event_interruptible(wq, condition)//让进程进入可中断等待态
i.wq：定义等待队列头
ii.condition = 0：表示数据没有准备好，进程进入休眠状态
iii.condition = 1：表示数据准备好
4.condition = 1; //表示数据准备好
5.wake_up_interruptible(&wq);//唤醒休眠进程
6.int wait_event(wq, condition)//让进程进入不可中断等待态
i.wq：定义等待队列头
ii.condition = 0：表示数据没有准备好，进程进入休眠状态
iii.condition = 1：表示数据准备好
7.condition = 1; //表示数据准备好
8.wake_up(&wq);//唤醒休眠进程

 六、编写代码

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/poll.h>

#define CNAME "myled"
struct cdev *cdev;
char kbuf[128] = {};
#if 0
unsigned int major = 500; //静态指定设备号
#else
unsigned int major = 0; //动态分配设备号
#endif
unsigned int count = 3;
unsigned int minor = 0; 
struct class* cls;
struct device* device;
wait_queue_head_t wq; //定义等待队列头
int condition = 0;

int myled_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}

ssize_t myled_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    if(file->f_flags & O_NONBLOCK) //以非阻塞方式打开
    {
        printk("O_NONBLOCK\n");
        return -EIO;                
    }
    else //以阻塞方式打开
    {
        ret = wait_event_interruptible(wq,condition); //让进程进入可中断等待态
        if(ret)
        {
            printk("signal\n");
            return -EIO;
        }
    }
    //如果用户空间想读的大小256个字节，大于内核空间的大小128个字节，需要更正用户空间读的大小
    if(size > sizeof(kbuf)) size = sizeof(kbuf);
    ret = copy_to_user(ubuf,kbuf,size); //将内核空间的数据，写入到用户空间
    if(ret){
        printk("copy to user is error\n");
        return -EIO;
    }
    condition = 0; //！！！！condition一直都为真，一直数据都可以读！！！！！！！！
    return size; 
}

ssize_t myled_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    
    //如果用户空间想写的大小256个字节，大于内核空间的大小128个字节，需要更正用户空间写的大小
    if(size > sizeof(kbuf)) size = sizeof(kbuf);
    ret = copy_from_user(kbuf,ubuf,size); //将用户空间的数据，写入到内核空间
    if(ret){
        printk("copy from user is error\n");
        return -EIO;
    }
    condition = 1; //表示数据准备好
    wake_up_interruptible(&wq);//唤醒可中断等待态
    return size; 
}

int myled_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0; 
}

//操作方法结构体
const struct file_operations fops = {
    .open = myled_open,
    .read = myled_read,
    .write = myled_write,
    .release = myled_close,
};

//入口
static int __init demo_init(void)
{
    int ret;
    dev_t devno;
    int i  = 0;
    //分配对象
    cdev = cdev_alloc();
    if(cdev == NULL){
        printk("cdev alloc is error\n");
        ret = -EIO;
        goto ERR1;
    }
    //对象初始化
    cdev_init(cdev,&fops);

    if(major > 0)
    {
        //静态指定设备号
    ret = register_chrdev_region(MKDEV(major,minor), count, CNAME);
        if(ret){
            printk("register chrdev region is error\n");
            ret = -EIO;
            goto ERR2;
        }
    }else{ //动态指定设备号
        ret = alloc_chrdev_region(&devno, 0, count,CNAME);
        if(ret){
            printk("alloc chrdev region is error\n");
            ret = -EIO;
            goto ERR2;
        }    
        major = MAJOR(devno);//根据设备号，获取主设备号的值
        minor = MINOR(devno);//根据设备号，获取次设备号的值    
    }
        
    //对象注册
    ret = cdev_add(cdev,MKDEV(major,minor),count);
    if(ret){
        printk("dev add is error\n");
        ret = -EIO;
        goto ERR3;
    }  

    //三盏灯，自动创建三个设备节点 /dev/myled0 /dev/myled1 /dev/myled2
    cls = class_create(THIS_MODULE, CNAME);  //向上层提交目录信息
    if(IS_ERR(cls))
    {
        printk("class create is error\n");
        ret = EIO;
        goto ERR4;
    }
    for(i=0;i<count;i++) //向上层提交设备节点信息
    {
        device = device_create(cls, NULL, MKDEV(major,i),NULL, "myled%d", i);
        if(IS_ERR(device))
        {
            printk("device create is error\n");
            ret = EIO;
            goto ERR5;
        }
    }
    init_waitqueue_head(&wq); //初始化等待队列头
    return 0; //!!!!!!!!!!!!!!!一定不能省略!!!!!!!!!!!!!!!

ERR5:
    //如果第一个设备节点和第二个设备节点创建成功，第三个设备节点创建失败，取消向上层提交第一个和第二个设备节点信息
    for(--i;i>=0;i--)
    {
        device_destroy(cls, MKDEV(major,i)); //取消向上层提交设备节点信息
    }
    class_destroy(cls); //取消向上层提交目录信息
ERR4:
    cdev_del(cdev); //对象注销
ERR3:
    unregister_chrdev_region(MKDEV(major,minor), count); //注销设备号
ERR2:
    kfree(cdev); //释放结构体指针
ERR1:
    return ret;
}

//出口
static void __exit demo_exit(void)
{
    int i = 0;
    for(i=0;i<count;i++)
    {
        device_destroy(cls, MKDEV(major,i)); //取消向上层提交设备节点信息
    }
    class_destroy(cls); //取消向上层提交目录信息
    cdev_del(cdev); //对象注销
    unregister_chrdev_region(MKDEV(major,minor), count); //注销设备号
    kfree(cdev); //释放结构体指针
}

module_init(demo_init); //指定入口地址

module_exit(demo_exit); //指定出口地址

MODULE_LICENSE("GPL");//许可证