Linux驱动——浅谈中断相关零碎内容

我在阳间凑数的一天

在Linux 内核中提供了完善的中断框架，我们只需要申请中断，然后注册中断处理函数即可，使用非常方便，不需要一系列复杂的寄存器配置。

在ARM裸机中对中断发生的处理方式大致为
1、使能中断、初始化对应的寄存器
2、注册中断和中断服务函数
3、中断发生时，进入IRQ中断服务函数

休眠与唤醒：
休眠：
wait_event_interruptible(wq, condition)；等待condition为真
唤醒：
wake_up_interruptible(x)；

POLL：
先在file_operations结构体中，提供对应的.poll 函数；
a、线程挂入队列 poll_wait
b、返回event状态 在应用程序中使用

 poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
 

在应用程序中

struct pollfd {
	int fd;         //文件描述符 
	short events;   //等待的事件 
	short revents;  // 实际发生了的事件 
	}

poll内核机制的详解参考：POLL内核机制详解

异步通知
先在file_operations结构体中，提供对应的.fasync 函数；

在.fasync中，调用用fasync_helper，它会根据 FAYSNC 的值决定是否设置 button_async->fa_file=驱动文件 filp： 驱动文件 filp 结构体里面含有之前设置的 PID。

发送信号：

struct fasync_struct *button_fasync;
kill_fasync (&button_fasync, SIGIO, POLL_IN); 
//一参：要操作的 fasync_struct。  
// 二参sig：要发送的信号。   
//三参band：可读时设置为 POLL_IN，可写时设置为 POLL_OUT

驱动通过内核提供的函数，根据进程号PID将信号SIGIO发送给用户,触发执行函数。
用户程序通过signal来注册处理函数。

应用程序：

signal(SIGIO, sig_func);//注册信号处理函数
//getpid()返回当前进程标识
fcntl(fd, F_SETOWN, getpid());  
//使能驱动的fasync功能
flags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, flags | FASYNC);

Linux信号

#define SIGHUP         1     /* 终端挂起或控制进程终止      */ 
#define SIGINT         2     /* 终端中断(Ctrl+C 组合键)       */ 
#define SIGQUIT        3     /* 终端退出(Ctrl+\组合键)       */ 
#define SIGILL         4        /* 非法指令                     */ 
#define SIGTRAP        5     /* debug 使用，有断点指令产生   */ 
#define SIGABRT        6     /* 由 abort(3)发出的退出指令    */ 
#define SIGIOT         6     /* IOT 指令                       */ 
#define SIGBUS         7     /* 总线错误                     */ 
#define SIGFPE         8     /* 浮点运算错误               */ 
#define SIGKILL        9     /* 杀死、终止进程               */ 
#define SIGUSR1        10    /* 用户自定义信号 1              */ 
#define SIGSEGV        11    /* 段违例(无效的内存段)        */ 
#define SIGUSR2        12    /* 用户自定义信号 2              */ 
#define SIGPIPE        13    /* 向非读管道写入数据          */ 
#define SIGALRM        14    /* 闹钟                       */ 
#define SIGTERM        15     /* 软件终止                     */ 
#define SIGSTKFLT      16    /* 栈异常                       */ 
#define SIGCHLD        17    /* 子进程结束                  */ 
#define SIGCONT        18    /* 进程继续                     */ 
#define SIGSTOP        19    /* 停止进程的执行，只是暂停     */ 
#define SIGTSTP        20    /* 停止进程的运行(Ctrl+Z 组合键)   */ 
#define SIGTTIN        21    /* 后台进程需要从终端读取数据   */ 
#define SIGTTOU        22    /* 后台进程需要向终端写数据    */ 
#define SIGURG         23    /* 有"紧急"数据               */ 
#define SIGXCPU        24    /* 超过 CPU 资源限制              */ 
#define SIGXFSZ        25    /* 文件大小超额              */ 
#define SIGVTALRM      26    /* 虚拟时钟信号              */ 
#define SIGPROF        27     /* 时钟信号描述              */
#define SIGWINCH       28   /* 窗口大小改变              */ 
#define SIGIO          29    /* 可以进行输入/输出操作     */ 
#define SIGPOLL        SIGIO    
#define SIGPWR         30    /* 断点重启                    */ 
#define SIGSYS         31    /* 非法的系统调用              */ 
#define  SIGUNUSED     31    /* 未使用信号                 */ 

阻塞与非阻塞
在应用程序中：

int  fd = open(“/dev/xxx”, O_RDWR | O_NONBLOCK);  /* 非阻塞方式 */
 int  fd = open(“/dev/xxx”, O_RDWR );  /* 阻塞方式 */ 

或者使用fcntl

int flags = fcntl(fd, F_GETFL);
 fcntl(fd, F_SETFL, flags | O_NONBLOCK);  /* 非阻塞方式 */ 
 fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);  /* 阻塞方式 */ 

阻塞与非阻塞IO的详解资料参考：阻塞与非阻塞IO的详解

定时器

Linux 内核定时器使用很简单，只需要提供超时时间和定时处理函数即可，当超时时间到了以后设置的定时处理函数就会执行。
中断上下文中执行，无法休眠。

//设置定时器
//初始化timer_list 结构体设置其中的函数、参数，触发fn函数
setup_timer(timer, fn, data)
//向内核添加定时器，timer表示超时间
add_timer(struct timer_list *timer)
//修改定时器的超时时间
 mod_timer(struct timer_list *timer, unsigned long expires)

深入理解内核定时器

中断处理原则：1、不能嵌套 2、越快越好

中断分为：上半部和下半部

上半部处理：紧急任务，中断关，耗时短
下半部处理：非紧急任务，中断开，耗时长

当我们使用request_irq 申请中断的时候，为某个中断 irq 注册中断处理函数 handler，注册的中断服务函数属于中断处理的上半部，只要中断触发，那么中断处理函数就会执行。

我们都知道中断处理函数一定要快点执行完毕，越短越好，但是实际情况总有一些不同，有些中断处理过程就是比较费时间，我们必须要对其进行处理，缩小中断处理函数的执行时间。

int request_irq(unsigned int irq, irq_handler_t handler,
			unsigned long irqflags, const char *devname, void *dev_id)
	//irq ：     		   中断号
	// handler：  		   中断处理函数
	//irqflags：  		   中断属性
	//*dev_iddecname：	   中断名称
	//dev_id：  		   一般设置为这个设备的设备结构体或者NULL

这里又涉及一个概念：程序A被中断时，通过栈保存现场

在程序A运行时，发生中断，触发程序B运行，需要把程序 A 调用程序 B 之前瞬间的 CPU 寄存器的值，保存到栈里保存现场，等程序B执行完，返回执行程序A，通过栈恢复现场。

如果中断不停的嵌套，栈空间将越来越大，栈将消耗殆尽。

下半部的实现：tasklet机制
tasklet机制是通过软件中断来实现，中断上下文中执行，无法休眠。

struct tasklet_struct {   
struct tasklet_struct *next;   
	unsigned long state;  
 	atomic_t count; 
  	void (*func)(unsigned long);   
    unsigned long data;
 }; 

//使用函数初始化tasklet 结构体
static inline void tasklet_init(struct tasklet_struct *tasklet,
         void (*func)(unsigned long),unsigned long data)
         
//调度tasklet，把 tasklet 放入链表，并且设置它的 TASKLET_STATE_SCHED 状态为 1。 
static inline void tasklet_schedule(struct tasklet_struct *t); 
         

下半部的实现：工作队列

内核线程、工作队列(workqueue)都由内核创建了，我们只是使用。使用的核心是一个 work_struct 结构体

struct work_struct {
	atomic_long_t data;
	struct list_head entry;
	work_func_t func;
#ifdef CONFIG_LOCKDEP
	struct lockdep_map lockdep_map;
#endif
};

使用宏定义初始化work_struct

#define INIT_WORK(_work, _func)  

调用 schedule_work 时，就会把 work_struct 结构体放入Linux系统提供的工作队列中，并唤醒对应的内核线程。内核线程就会从队列里把 work_struct 结构体取出来，执行里面的函数_func。

schedule_work(&gpio_key->work);
//函数原型
static inline bool schedule_work(struct work_struct *work)
{
	return queue_work(system_wq, work);
}

销毁工作队列 ：destroy_workqueue
缺点：工作队列中有多个 work，前一个 work 没处理完会影响后面的 work

更深层次的分析，参考资料：
Linux-workqueue机制的实现
Linux-workqueue 讲解

中断线程化处理
复杂、耗时的事情，使用内核线程来处理

关键函数：

int request_threaded_irq(unsigned int irq,
					 irq_handler_t handler,
			 		 irq_handler_t thread_fn, 					
			 		 unsigned long irqflags,
			         const char *devname,
			         void *dev_id)
//irq：			中断号
//handler： 	上半部函数，可以为空，内核提供默认的上半部处理函数，直接返回IRQ_WAKE_THREAD
//thread_fn：	线程执行函数
//irqflags：  	中断类型标志
//devname：   	设备名称
//dev_id:    	通常取描述该设备的结构体

free_irq 卸载中断
threaded_irq 详解

资源分配的单位是进程，调度的单位是线程。

在实际的应用开发中都是多进程多线程的开发，理解学习进程线程是非常有必要的，进程线程的应用学习，日后再写。

2020/7/14 19:00