驱动开发之select与中断下半部分

驱动开发之select与中断下半部分：

中断上半部、下半部：

1、已知中断应该尽快完成，但是很多时候不能保证中断代码一定会及时完成。
2、当不能保证中断尽快完成时，内核将曾经的一个中断处理函数分成了两个中断处理函数
　　其中中断上半部用来处理紧急事件
　　中断下半部用来处理非紧急事件
3、什么是紧急事件：
　　　　　　直接操作硬件时
　　　　　　对时间要求非常敏感
　　　　　　不能被其他中断打断
4，中断下半部分类：
　　　　　　　　软中断(需要使用软中断号，但是所有的软中断号都被占用了)

　　　　　　　　小任务

　　　　　　　　工作队列

小任务:对软中断的二次封装：

初始化小任务：

void tasklet_init(struct tasklet_struct *t,void (*func)(unsigned long), unsigned long data)
参数1:
参数2:中断下半部处理函数
参数3:给中断下半部处理函数传参的

调度小任务：

tasklet_schedule(struct tasklet_struct *t);

什么时候调用下半部？
　　　　　　　　在中断上半部处理函数返回前，或者返回后调用。

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/platform_device.h>
#include <linux/device.h>
#include <asm/uaccess.h>
#include <linux/irqreturn.h>
#include <linux/interrupt.h>
#include <linux/sched.h>

int major;

struct class *cls;
struct device *devs;
struct resource *res_key2;
struct resource *res_key3;

int key;
wait_queue_head_t keyq;
int flag = 0;
struct timer_list t;
int glo_irqno;

struct tasklet_struct ts;

irqreturn_t fs4412_key_handler(int irqno,void *id)
{
    glo_irqno = irqno;
    mod_timer(&t,jiffies + 30);
    return IRQ_HANDLED;
}

void fs4412_key_timer_handler(unsigned long data)
{
    if(glo_irqno == res_key2->start)
        key = 2;
    if(glo_irqno == res_key3->start)
        key = 3;
//    wake_up(&keyq);
    wake_up_interruptible(&keyq);
    flag = 1;
    tasklet_schedule(&ts);
}

void fs4412_key_task(unsigned long data)
{
    printk("task schedule
");
}

int fs4412_key_open(struct inode *inode ,struct file *filp)
{
    return 0;
}

ssize_t fs4412_key_read(struct file *filp,char __user *ubuf,size_t size,loff_t *off)
{
    int ret;
    
//    wait_event(keyq,flag != 0);
    wait_event_interruptible(keyq,flag != 0);
    ret = copy_to_user(ubuf,&key,sizeof(key));

    flag = 0;
    return sizeof(key);
}

struct file_operations fops = {
    .owner = THIS_MODULE,
    .open = fs4412_key_open,
    .read = fs4412_key_read,
};

int fs4412_key_probe(struct platform_device *pdev)
{
    int ret;
    printk("match ok
");

    major = register_chrdev(0,"key",&fops);
    cls = class_create(THIS_MODULE,"key");
    devs = device_create(cls,NULL,MKDEV(major,0),NULL,"key");
    
    res_key2 = platform_get_resource(pdev,IORESOURCE_IRQ,0);//索引interrupts = <>,<>第一个<>
    res_key3 = platform_get_resource(pdev,IORESOURCE_IRQ,1);
    ret = request_irq(res_key2->start,fs4412_key_handler,IRQF_TRIGGER_FALLING,"key2",NULL);
    ret = request_irq(res_key3->start,fs4412_key_handler,IRQF_TRIGGER_FALLING,"key3",NULL);

    init_waitqueue_head(&keyq);

    init_timer(&t);
    t.function = fs4412_key_timer_handler;//定时器中断处理函数
    add_timer(&t);//让内核认识定时器中断处理函数

    tasklet_init(&ts,fs4412_key_task,0);
    return 0;
}

int fs4412_key_remove(struct platform_device *pdev)
{
    del_timer(&t);
    free_irq(res_key3->start,NULL);
    free_irq(res_key2->start,NULL);
    device_destroy(cls,MKDEV(major,0));
    class_destroy(cls);
    unregister_chrdev(major,"key");
    return 0;
}

struct of_device_id fs4412_dt_tbl[] = {
    {
        .compatible = "fs4412,key",
    },
    {},
};


struct platform_driver pdrv = {
    .driver = {
        .name = "fs4412-key",
        .of_match_table = fs4412_dt_tbl,
    },
    .probe = fs4412_key_probe,
    .remove = fs4412_key_remove,
};

module_platform_driver(pdrv);
MODULE_LICENSE("GPL");

工作队列：

INIT_WORK(struct work_struct *,void (*)(struct work_struct *work))

static inline bool schedule_work(struct work_struct *work) 

如何选择下半部的使用方法？
　　　　小任务运行在中断上下文中(内核空间)，对时间要求敏感
　　　　工作队列运行在进程上下文中(用户空间和内核空间)，对时间不敏感

　　　　在工作队列中可以使用等待队列，互斥锁，信号量。小任务不可以。

应用层：
int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set*exceptfds, struct timeval *timeout);
参数1:文件描述符最大值+1
参数2:读表
参数3:写表
参数4:异常表
参数5:超时检测
返回值:出错返回-1，超时返回0，成功返回>0
功能:如果没有就绪的文件描述符则阻塞，如果有就绪的文件描述符则唤醒，唤醒的同时会将未就绪的文件描述符清空。

FD_SET();将指定文件描述符加入表中
FD_ZERO();清空文件描述符表
FD_CLR();删除指定的文件描述符
FD_ISSET();判断fd是否在表中

内核源码分析：
struct file_operations 
{
unsigned int (*poll) (struct file *, struct poll_table_struct *);//被select调用
}

vi fs/select.c 
找到do_select函数
mask = (*f_op->poll)(f.file, wait);

poll_initwait(&table); 

--->void poll_initwait(struct poll_wqueues *pwq) 
{ 
    init_poll_funcptr(&pwq->pt, __pollwait);
    pwq->polling_task = current;//当前进程
} 

--->static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc) 
{ 
     pt->_qproc = qproc;//将__pollwait赋值给了_qproc
 } 

如果想要调用__pollwait,需要使用
static inline void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
{
     if (p && p->_qproc && wait_address)
    p->_qproc(filp, wait_address, p);//调用__pollwait
}

--->static void __pollwait(struct file *filp, wait_queue_head_t *wait_address, poll_table *p)
{
     struct poll_wqueues *pwq = container_of(p, struct poll_wqueues, pt);
    struct poll_table_entry *entry = poll_get_entry(pwq); 
     if (!entry)
    return;
    entry->filp = get_file(filp);
    entry->wait_address = wait_address;
    entry->key = p->_key;
     init_waitqueue_func_entry(&entry->wait, pollwake);//唤醒接口
    entry->wait.private = pwq;
    add_wait_queue(wait_address, &entry->wait);//将等待队列项添加到等待队列中
}

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/platform_device.h>
#include <linux/device.h>
#include <asm/uaccess.h>
#include <linux/irqreturn.h>
#include <linux/interrupt.h>
#include <linux/sched.h>

int major;

struct class *cls;
struct device *devs;
struct resource *res_key2;
struct resource *res_key3;

int key;
wait_queue_head_t keyq;
int flag = 0;
struct timer_list t;
int glo_irqno;

struct work_struct ws;

irqreturn_t fs4412_key_handler(int irqno,void *id)
{
    glo_irqno = irqno;
    mod_timer(&t,jiffies + 30);
    return IRQ_HANDLED;
}

void fs4412_key_timer_handler(unsigned long data)
{
    if(glo_irqno == res_key2->start)
        key = 2;
    if(glo_irqno == res_key3->start)
        key = 3;
//    wake_up(&keyq);
    wake_up_interruptible(&keyq);
    flag = 1;
    schedule_work(&ws);
}

void fs4412_key_work(struct work_struct *work)
{
    printk("work schedule
");
}

int fs4412_key_open(struct inode *inode ,struct file *filp)
{
    return 0;
}

ssize_t fs4412_key_read(struct file *filp,char __user *ubuf,size_t size,loff_t *off)
{
    int ret;
    
//    wait_event(keyq,flag != 0);
    wait_event_interruptible(keyq,flag != 0);
    ret = copy_to_user(ubuf,&key,sizeof(key));

    flag = 0;
    return sizeof(key);
}

struct file_operations fops = {
    .owner = THIS_MODULE,
    .open = fs4412_key_open,
    .read = fs4412_key_read,
};

int fs4412_key_probe(struct platform_device *pdev)
{
    int ret;
    printk("match ok
");

    major = register_chrdev(0,"key",&fops);
    cls = class_create(THIS_MODULE,"key");
    devs = device_create(cls,NULL,MKDEV(major,0),NULL,"key");
    
    res_key2 = platform_get_resource(pdev,IORESOURCE_IRQ,0);//索引interrupts = <>,<>第一个<>
    res_key3 = platform_get_resource(pdev,IORESOURCE_IRQ,1);
    ret = request_irq(res_key2->start,fs4412_key_handler,IRQF_TRIGGER_FALLING,"key2",NULL);
    ret = request_irq(res_key3->start,fs4412_key_handler,IRQF_TRIGGER_FALLING,"key3",NULL);

    init_waitqueue_head(&keyq);

    init_timer(&t);
    t.function = fs4412_key_timer_handler;//定时器中断处理函数
    add_timer(&t);//让内核认识定时器中断处理函数

    INIT_WORK(&ws,fs4412_key_work);
    return 0;
}

int fs4412_key_remove(struct platform_device *pdev)
{
    del_timer(&t);
    free_irq(res_key3->start,NULL);
    free_irq(res_key2->start,NULL);
    device_destroy(cls,MKDEV(major,0));
    class_destroy(cls);
    unregister_chrdev(major,"key");
    return 0;
}

struct of_device_id fs4412_dt_tbl[] = {
    {
        .compatible = "fs4412,key",
    },
    {},
};


struct platform_driver pdrv = {
    .driver = {
        .name = "fs4412-key",
        .of_match_table = fs4412_dt_tbl,
    },
    .probe = fs4412_key_probe,
    .remove = fs4412_key_remove,
};

module_platform_driver(pdrv);
MODULE_LICENSE("GPL");

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc, const char *argv[])
{
    int fd;

    fd = open("/dev/key",O_RDWR);
    if(fd == -1)
    {
        perror("open");
        return -1;
    }
    
    int key;
    while(1)
    {
        read(fd,&key,sizeof(key));
        printf("key = %d
",key);
    }
    return 0;
}

异步通知(信号操作)： 

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<errno.h>
#include<stdlib.h>
#include<signal.h>
int fd;
char buf[64] = {0};

void func(int sig)
{
    read(fd,buf,sizeof(buf));
    printf("%s
",buf);
}

int main(int argc, const char *argv[])
{
    
    char buf1[64] = {0};
    if(mkfifo("./fifo",0664) == -1)
    {
        if(errno == EEXIST)
        {
            fd = open("./fifo",O_RDONLY);    
        }
        else 
        {
            perror("mkfifo");
            exit(1);
        }
    }
    else 
    {
        fd = open("./fifo",O_RDONLY);
    }
    
    signal(SIGIO,func);

    int flag;
    flag = fcntl(fd,F_GETFL);
    flag = flag | O_ASYNC;
    fcntl(fd,F_SETFL,flag);
    fcntl(fd,F_SETOWN,getpid());
    while(1)
    {
        printf("hello
");
        sleep(1);
    }
    return 0;
}

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<errno.h>
#include<stdlib.h>
#include<string.h>

int main(int argc, const char *argv[])
{
    int fd;

    char buf[64] = {0};
    if(mkfifo("./fifo",0664) == -1)
    {
        if(errno == EEXIST)
        {
            fd = open("./fifo",O_WRONLY);    
        }
        else 
        {
            perror("mkfifo");
            exit(1);
        }
    }
    else 
    {
        fd = open("./fifo",O_WRONLY);
    }

    while(1)
    {
        fgets(buf,sizeof(buf),stdin);
        write(fd,buf,strlen(buf) + 1);
    }
    return 0;
}

应用程序:
int flag;
fd = open("1.txt",O_RDONLY);//一旦打开文件，内核会创建file结构体,其中有一个f_flags成员，此时f_flags = O_RDONLY
flag = fcntl(fd,F_GETFL);//从file结构体中获取O_RDONLY保存到flag变量中
flag |= O_ASYNC;//将O_RDONLY | O_ASYNC保存到flag变量中（flag是自定义的变量不是内核的）
fctnl(fd,F_SETFL,flag);//将O_RDONLY | O_ASYNC保存到file结构体的f_flags成员中，内核会指定如果使用了O_ASYNC属性则默认会使用SIGIO信号

fcntl(fd,F_SETOWN,getpid());//需要注册信号，但是这个函数只指定了给哪个进程注册，谁在给进程注册信号？内核实现注册功能

内核源码分析：
vi arch/arm/include/uapi/asm/unistd.h

#define __NR_fcntl (__NR_SYSCALL_BASE+ 55)

--->__SYSCALL(__NR_fcntl, sys_fcntl)

--->err = do_fcntl(fd, cmd, arg, f.file);

--->case F_GETFL: 
err = filp->f_flags;对应了flag = fcntl(fd,F_GETFL);
    break;
    case F_SETFL:
    err = setfl(fd, filp, arg);fctnl(fd,F_SETFL,flag)

---> if (((arg ^ filp->f_flags) & FASYNC) && filp->f_op->fasync) {
error = filp->f_op->fasync(fd, filp, (arg & FASYNC) != 0); 
}    
上层如果执行fctnl(fd,F_SETFL,flag)，驱动层可能执行fasync接口,前提是flag |= O_ASYNC;改成flag |= FASYNC;

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/platform_device.h>
#include <linux/device.h>
#include <asm/uaccess.h>
#include <linux/irqreturn.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <linux/poll.h>

int major;

struct class *cls;
struct device *devs;
struct resource *res_key2;
struct resource *res_key3;

int key;
wait_queue_head_t keyq;
int flag = 0;
struct timer_list t;
int glo_irqno;

struct fasync_struct *fa;

irqreturn_t fs4412_key_handler(int irqno,void *id)
{
    glo_irqno = irqno;
    mod_timer(&t,jiffies + 30);
    return IRQ_HANDLED;
}

void fs4412_key_timer_handler(unsigned long data)
{
    if(glo_irqno == res_key2->start)
        key = 2;
    if(glo_irqno == res_key3->start)
        key = 3;
//    wake_up(&keyq);
    wake_up_interruptible(&keyq);
    flag = 1;
    
    //注册SIGIO信号
    kill_fasync(&fa,SIGIO,POLLIN);
}

int fs4412_key_open(struct inode *inode ,struct file *filp)
{
    return 0;
}

ssize_t fs4412_key_read(struct file *filp,char __user *ubuf,size_t size,loff_t *off)
{
    int ret;
    
//    wait_event(keyq,flag != 0);
    wait_event_interruptible(keyq,flag != 0);
    ret = copy_to_user(ubuf,&key,sizeof(key));

    flag = 0;
    return sizeof(key);
}

int fs4412_key_fasync(int fd,struct file *filp,int on)
{
    fasync_helper(fd,filp,on,&fa);//为了kill_fasync函数做一些成员赋值
    return 0;
}

struct file_operations fops = {
    .owner = THIS_MODULE,
    .open = fs4412_key_open,
    .read = fs4412_key_read,
    .fasync = fs4412_key_fasync,
};

int fs4412_key_probe(struct platform_device *pdev)
{
    int ret;
    printk("match ok
");

    major = register_chrdev(0,"key",&fops);
    cls = class_create(THIS_MODULE,"key");
    devs = device_create(cls,NULL,MKDEV(major,0),NULL,"key");
    
    res_key2 = platform_get_resource(pdev,IORESOURCE_IRQ,0);//索引interrupts = <>,<>第一个<>
    res_key3 = platform_get_resource(pdev,IORESOURCE_IRQ,1);
    ret = request_irq(res_key2->start,fs4412_key_handler,IRQF_TRIGGER_FALLING,"key2",NULL);
    ret = request_irq(res_key3->start,fs4412_key_handler,IRQF_TRIGGER_FALLING,"key3",NULL);

    init_waitqueue_head(&keyq);

    init_timer(&t);
    t.function = fs4412_key_timer_handler;//定时器中断处理函数
    add_timer(&t);//让内核认识定时器中断处理函数
    return 0;
}

int fs4412_key_remove(struct platform_device *pdev)
{
    del_timer(&t);
    free_irq(res_key3->start,NULL);
    free_irq(res_key2->start,NULL);
    device_destroy(cls,MKDEV(major,0));
    class_destroy(cls);
    unregister_chrdev(major,"key");
    return 0;
}

struct of_device_id fs4412_dt_tbl[] = {
    {
        .compatible = "fs4412,key",
    },
    {
     
       },
};


struct platform_driver pdrv = {
    .driver = {
        .name = "fs4412-key",
        .of_match_table = fs4412_dt_tbl,
    },
    .probe = fs4412_key_probe,
    .remove = fs4412_key_remove,
};

module_platform_driver(pdrv);
MODULE_LICENSE("GPL");
    

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>

int fd;
int key;
void func(int signo)
{
    if(signo == SIGIO)
    {
        read(fd,&key,sizeof(key));
        printf("key = %d
",key);
    }
}

int main(int argc, const char *argv[])
{
    signal(SIGIO,func);

    fd = open("/dev/key",O_RDWR);
    if(fd == -1)
    {
        perror("open");
        return -1;
    }
    
    int flag;
    flag = fcntl(fd,F_GETFL);
    flag |= FASYNC;
    fcntl(fd,F_SETFL,flag);//主要功能为了调用驱动中的fasync接口
    fcntl(fd,F_SETOWN,getpid());
    
    while(1)
    {
        printf("hello
");
        sleep(1);
    }
    return 0;
}

总结：

中断上半部和下半部
将一个中断处理函数分成了2个函数。

上半部用来处理紧急事件

紧急事件:
1、直接操作硬件
2、对时间敏感
3、不能被打断的

下半部:
软中断:
    open_softirq();
    raise_softirq();
几乎不会使用软中断，内核提供的软中断号都已经被占用了，对应的接口也没有导出符号表。

小任务:属于一种特殊的软中断,运行在中断上下文,中断处理函数中不能有延时，只能自旋锁。
    tasklet_init();//初始化小任务
    tasklet_schedule();//调度小任务
    
工作队列:运行在进程上下文,可以有延时，可以使用互斥锁，信号量，等待队列。
    INIT_WORK();
    schedule_work();
    
什么时候调度中断下半部？
一般都是在上半部中断处理函数返回前或者返回后。

多路复用:
int select(文件描述符最大值+1,读表,写表,异常表,超时);
功能:如果文件描述符没有就绪则阻塞。
     如果文件描述符就绪则唤醒,唤醒后会清除未就绪的文件描述符。

vi arch/arm/include/uapi/asm/unistd.h


异步通知:当一种事件(按键按下)发生时会在应用层产生一个SIGIO信号，进而捕捉SIGIO信号

应用层:

signal(SIGIO，func);
fd = open();

flag = fcntl(fd,F_GETFL);//从file结构体的f_flags成员中获取属性存放给flag
flag |= FASYNC;
fcntl(fd,F_SETFL,flag);//会和FASYNC进行&,如果成功则会执行驱动中的fasync接口。
fcntl(fd,F_SETOWN,getpid());//明确给哪个进程注册SIGIO信号(还没有真正注册)。

while(1)
{
    功能;
}

驱动层:
中断处理函数
{
    kill_fasync();
    //给进程注册信号，但是注册信号时需要使用到一下变量内容，需要准备这些内容
}

fasync()
{
    fasync_helper();//为kill_fasync的功能实现做准备。
}