linux驱动编程--中断

一.中断的基本处理：

        简单的中断处理，主要是使用request_irq()和free_irq()。

         In fact, the kernel create a global array( irq_desc[] ) for manage all information about irq.Included
slot-function, irq_chip and so on. By the way.Each irq is corresponding to a member of
irq_desc. 在kernel建立了一个全局变量数组irq_desc[],用来记录每个中断的信息。

        slot-function is used to record what this irq need to do when a new interrupy arrived.(many user function)

        irq_chip is a structure, record many callback-function about how to control this irq.( i.e how to enable/disable irq, how to set handware status)

        the following is some useful function:

/** 中断处理函数*/
can_request_irq(unsigned int irq,unsigned long irqflags);		//查询是否可以申请
request_irq(unsigned int irq,irq_handler_t handler,unsigned long irqflags,const char * devname,void * dev_id);	//申请
free_irq(unsigned int irq,void * dev_id);		//释放中断
/** 扩展处理函数*/
disable_irq(unsigned int irq);				//禁止中断，如果有当前中断，会等待该中断执行完
disable_irq_nosync(unsigned int irq);		//禁止中断，会直接返回
enable_irq(unsigned int irq);
local_irq_disable();
local_irq_save(flags);
local_irq_enable();
local_irq_restore(x);
set_fiq_handler(void * start,unsigned int length);

看一下free_irq的源码，发现对irq资源的回收就是从irq_desc[]中找到该irq对应的信息记录变量desc。然后从desc->action的注册函数链表中取出需要注销的函数。

/*
* Internal function to unregister an irqaction - used to free
* regular and special interrupts that are part of the architecture.
*/
static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
{
struct irq_desc *desc = irq_to_desc(irq);	//kernel建立了一个全局变量数组irq_desc[],用来存放所有的irq中断信息。
struct irqaction *action, **action_ptr; 	//
struct task_struct *irqthread;
unsigned long flags;

WARN(in_interrupt(), "Trying to free IRQ %d from IRQ context!\n", irq);

if (!desc)
return NULL;

spin_lock_irqsave(&desc->lock, flags);

/*
* There can be multiple actions per IRQ descriptor, find the right
* one based on the dev_id:
*/
action_ptr = &desc->action;
for (;;) {//根据dev_id找到该irq对应的链表中的部分
action = *action_ptr;

if (!action) {
WARN(1, "Trying to free already-free IRQ %d\n", irq);
spin_unlock_irqrestore(&desc->lock, flags);

return NULL;
}

if (action->dev_id == dev_id)
break;
action_ptr = &action->next;
}

/* Found it - now remove it from the list of entries: */
*action_ptr = action->next;

/* Currently used only by UML, might disappear one day: */
#ifdef CONFIG_IRQ_RELEASE_METHOD
if (desc->chip->release)
desc->chip->release(irq, dev_id);
#endif

/* If this was the last handler, shut down the IRQ line: */
if (!desc->action) {
desc->status |= IRQ_DISABLED;
if (desc->chip->shutdown)
desc->chip->shutdown(irq);
else
desc->chip->disable(irq);
}

irqthread = action->thread;
action->thread = NULL;

spin_unlock_irqrestore(&desc->lock, flags);

unregister_handler_proc(irq, action);

/* Make sure it's not being used on another CPU: */
synchronize_irq(irq);

if (irqthread) {
if (!test_bit(IRQTF_DIED, &action->thread_flags))
kthread_stop(irqthread);
put_task_struct(irqthread);
}

#ifdef CONFIG_DEBUG_SHIRQ
/*
* It's a shared IRQ -- the driver ought to be prepared for an IRQ
* event to happen even now it's being freed, so let's make sure that
* is so by doing an extra call to the handler ....
*
* ( We do this after actually deregistering it, to make sure that a
*	 'real' IRQ doesn't run in * parallel with our fake. )
*/
if (action->flags & IRQF_SHARED) {
local_irq_save(flags);
action->handler(irq, dev_id);
local_irq_restore(flags);
}
#endif
return action;
}

二.中断处理扩展：

        为了改善中断处理效率，中断处理函数被分成了两部分：顶半部和底半部。底半部有三种实现方式：tasklet，工作队列和软中断。

        2.1 Tasklet

                tasklet运行于软中断上下文，所以在其处理函数中不允许睡眠。在内核有一个全局链表用于记录需要完成的任务，对应的处理进程为守护进程 ksoftirqd/0。一般在执 行中断上半部后会执行下半部，到下半部时如果有新的中断到达，则唤醒ksoftirqd/0来执行当前部分，而自己去处理新中断。其函数解析如下：

/** 信息结构体*/
struct tasklet_struct
{
struct tasklet_struct *next;	//信息结构体被做成链表
unsigned long state;			//
atomic_t count;			//
void (*func)(unsigned long);	//回调函数
unsigned long data;		//传给回调函数的参数
};
/** 初始化*/
tasklet_init(struct tasklet_struct * t,void(* func)(unsigned long),unsigned long data);
DECLARE_TASKLET(name,func,data);

#define DECLARE_TASKLET(name, func, data) \
struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }
/** schedule*/
tasklet_schedule(a);
static inline void tasklet_schedule(struct tasklet_struct *t)
{
if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
__tasklet_schedule(t);
}
void __tasklet_schedule(struct tasklet_struct *t)
{
unsigned long flags;

local_irq_save(flags);
t->next = NULL;
*__get_cpu_var(tasklet_vec).tail = t;			//??将新task添加到全局task链表中
__get_cpu_var(tasklet_vec).tail = &(t->next);		//
raise_softirq_irqoff(TASKLET_SOFTIRQ);		//挂起TASKLET_SOFTIRQ类型的软中断，并根据需要唤醒守护进程
local_irq_restore(flags);
}
/*
* This function must run with irqs disabled!
*/
inline void raise_softirq_irqoff(unsigned int nr)
{
__raise_softirq_irqoff(nr); //挂起软中断nr

/*
* If we're in an interrupt or softirq, we're done
* (this also catches softirq-disabled code). We will
* actually run the softirq once we return from
* the irq or softirq.(假如在中断中，该函数一定会被执行)
*
* Otherwise we wake up ksoftirqd to make sure we
* schedule the softirq soon.(否则就叫醒守护进程)
*/
if (!in_interrupt())	//假如不在中断上下文
wakeup_softirqd();	//叫醒softirq守护进程，它会保证该函数执行一次
}

        2.2 工作队列

        工作队列是一个直接将一个任务封包挂到全局链表上交给一个worker process处理，所以是工作在进程上下文，允许睡眠以及进程调度操作。

//重要结构体
struct work_struct;
struct workqueue_struct;
struct cpu_workqueue_struct;
//初始化
INIT_WORK(_work,_func);
DECLARE_WORK(n,f);
//常用函数
schedule_work(a);			--将新工作a添加到一个全局的工作队列中，一般由守护进程events复制处理;但如果需要可以创建自定义					的worker process。

 

       2.3 软中断


        处理器的所有状态中有一种是软中断状态，这是一种可被打断的中断状态(其他中断是不允许被打断的)。 one of most important feasure, for softirq, is interruptible.this is very important for ensure the system quickly answer a new interrupt  ,because the rest of all interrupt
can't be interrupt.

        为了方便事物分类处理又在内部进行了逻辑分类，

        for example, tasklet is corresponding to TASKLET_SOFTIRQ. we often raise the softirq( the
TASKLET_SOFTIRQ type) when a new tasklet arrived. 
        the type of softirq is

enum
{
HI_SOFTIRQ=0,
TIMER_SOFTIRQ,
NET_TX_SOFTIRQ,
NET_RX_SOFTIRQ,
BLOCK_SOFTIRQ,
TASKLET_SOFTIRQ,	// this is a tasklet thing
SCHED_SOFTIRQ,
HRTIMER_SOFTIRQ,
RCU_SOFTIRQ,	/* Preferable RCU should always be the last softirq */

NR_SOFTIRQS
};

       In the next is some common function:

//重要结构体
struct softirq_action;
struct softirq_action
{
void	(*action)(struct softirq_action *);
};
//常用函数
open_softirq(int nr,void(* action)(struct softirq_action *));	//reigister a function for a softirq( 注册软中断对应的处理函数)
raise_softirq(unsigned int nr);		//raise a softirq(触发一个软中断)
local_bh_disable(void);			//禁止软中断，tasklet底半部机制
local_bh_enable(void);			//

        一个非常棒的关于软中断的说明在这里，：

void open_softirq(int nr, void (*action)(struct softirq_action *))
{
softirq_vec[nr].action = action;
}

 

 

 

a49e