一，认识几个重要结构体：
1.中断描述符
对于每一条中断线都由一个irq_desc结构来描述。
//在include/linux/irq.h中
struct irq_desc {
unsigned int irq;//中断号
struct timer_rand_state *timer_rand_state;
unsigned int *kstat_irqs;
#ifdef CONFIG_INTR_REMAP
struct irq_2_iommu *irq_2_iommu;
#endif
irq_flow_handler_t handle_irq;//上层中断处理函数，
struct irq_chip *chip;//底层硬件操作
struct msi_desc *msi_desc;
void *handler_data;//附加参数，用于handle_irq
void *chip_data;//平台相关附加参数，用于chip
struct irqaction *action; //中断服务例程链表
unsigned int status; //中断当前的状态
//中断关闭打开层数调用一次disable_irq( ) ，depth加1；调用一次enable_irq( )该值减1，
//如果depth等于0就开启这条中断线，如果depth大于0就关闭中断线。
unsigned int depth;
unsigned int wake_depth; * 唤醒次数 */
unsigned int irq_count; /* 发生的中断次数 */
unsigned long last_unhandled;
unsigned int irqs_unhandled;
spinlock_t lock;
#ifdef CONFIG_SMP
cpumask_var_t affinity;
unsigned int cpu;
#ifdef CONFIG_GENERIC_PENDING_IRQ
cpumask_var_t pending_mask;
#endif
#endif
atomic_t threads_active;
wait_queue_head_t wait_for_threads;
#ifdef CONFIG_PROC_FS
struct proc_dir_entry *dir;///proc/irq/ 入口
#endif
const char *name;///proc/interrupts 中显示的中断名称
} ____cacheline_internodealigned_in_smp;
2. 中断硬件操作函数集
//在include/linux/irq.h中定义
//该结构体中各函数在文件linux/arch/arm/plat-s3c24xx/irq.c中实现
struct irq_chip {
const char *name; //用于 /proc/interrupts
unsigned int (*startup)(unsigned int irq); //默认为 enable 如果为NULL
void (*shutdown)(unsigned int irq); //默认为 disable 如果为NULL
void (*enable)(unsigned int irq); //允许中断，默认为 unmask 如果为NULL
void (*disable)(unsigned int irq); //禁止中断，默认为 mask 如果为 NULL
void (*ack)(unsigned int irq); //响应一个中断，清除中断标志
void (*mask)(unsigned int irq); //mask 一个中断源，通常是关闭中断
void (*mask_ack)(unsigned int irq); //响应并 mask 中断源
void (*unmask)(unsigned int irq); //unmask 中断源
void (*eoi)(unsigned int irq);
void (*end)(unsigned int irq);
void (*set_affinity)(unsigned int irq,
const struct cpumask *dest);
int (*retrigger)(unsigned int irq);
int (*set_type)(unsigned int irq, unsigned int flow_type); //设置中断触发方式 IRQ_TYPE_LEVEL
int (*set_wake)(unsigned int irq, unsigned int on);
#ifdef CONFIG_IRQ_RELEASE_METHOD
void (*release)(unsigned int irq, void *dev_id);
#endif
const char *typename;
};
3.中断处理例程描述符
//在include/linux/interrupt.h中
struct irqaction {
irq_handler_t handler;
unsigned long flags; //用一组标志描述中断线与 I/O 设备之间的关系。
cpumask_t mask;
const char *name;
void *dev_id;
struct irqaction *next;
int irq;
struct proc_dir_entry *dir;
irq_handler_t thread_fn;
struct task_struct *thread;
unsigned long thread_flags;
};
这三个结构体间的关系表示如下
二，中断初始化过程
中断机制的初始化通过 两个函数完成：early_trap_init()和init_IRQ()，在此我们先讨论函数init_IRQ()。
//函数
init_IRQ在文件linux/arch/arm/kernel/irq.c中实现。
void __init init_IRQ(void)
{
int irq;
for (irq = 0; irq < NR_IRQS; irq++)
irq_desc[irq].status |= IRQ_NOREQUEST | IRQ_NOPROBE;
#ifdef CONFIG_SMP
cpumask_setall(bad_irq_desc.affinity);
bad_irq_desc.cpu = smp_processor_id();
#endif
init_arch_irq();
}
//函数s3c24xx_init_irq在文件linux/arch/arm/plat-s3c24xx/irq.c中实现
void __init s3c24xx_init_irq(void)
{
unsigned long pend;
unsigned long last;
int irqno;
int i;
irqdbf("s3c2410_init_irq: clearing interrupt status flags\n");
last = 0;
for (i = 0; i < 4; i++) {
pend = __raw_readl(S3C24XX_EINTPEND);
if (pend == 0 || pend == last)
break;
__raw_writel(pend, S3C24XX_EINTPEND);
//清除外部中断寄存器EINTPEND中的请求标志，
printk("irq: clearing pending ext status x\n", (int)pend);
last = pend;
}
last = 0;
。。。。。。
//设置各中断的底层硬件操作函数集desc->chip，中断上层处理函数desc->handle_irq
for (irqno = IRQ_EINT4t7; irqno <= IRQ_ADCPARENT; irqno++) {
switch (irqno) {
case IRQ_EINT4t7:
case IRQ_EINT8t23:
case IRQ_UART0:
case IRQ_UART1:
case IRQ_UART2:
case IRQ_ADCPARENT:
set_irq_chip(irqno, &s3c_irq_level_chip);
set_irq_handler(irqno, handle_level_irq);
break;
case IRQ_RESERVED6:
case IRQ_RESERVED24:
break;
default:
//irqdbf("registering irq %d (s3c irq)\n", irqno);
set_irq_chip(irqno, &s3c_irq_chip);
set_irq_handler(irqno, handle_edge_irq);
set_irq_flags(irqno, IRQF_VALID);
}
}
//以下几个中断都有多个中断源，每一个中断源也都有各自的中断号，它们的多个中断源中任意一个产生中断
//该中断都会被触发，而不是直接出发子中断。这几个中断并不处理中断函数，它们的中作是计算子中断的中断号，
//并根据子中断的中断号在数组irq_desc[NR_IRQS]中去找出该中断号对应的irq_desc结构，并调用该结构中的中断处理函数。
set_irq_chained_handler(IRQ_EINT4t7, s3c_irq_demux_extint4t7);
set_irq_chained_handler(IRQ_EINT8t23, s3c_irq_demux_extint8);
set_irq_chained_handler(IRQ_UART0, s3c_irq_demux_uart0);
set_irq_chained_handler(IRQ_UART1, s3c_irq_demux_uart1);
set_irq_chained_handler(IRQ_UART2, s3c_irq_demux_uart2);
set_irq_chained_handler(IRQ_ADCPARENT, s3c_irq_demux_adc);
。。。。。。
for (irqno = IRQ_EINT4; irqno <= IRQ_EINT23; irqno++) {
irqdbf("registering irq %d (extended s3c irq)\n", irqno);
set_irq_chip(irqno, &s3c_irqext_chip);
//设置子中断的硬件操作函数集
set_irq_handler(irqno, handle_edge_irq);
//设置子中断的上层处理函数
set_irq_flags(irqno, IRQF_VALID);
}
。。。。。。
}
比如此时外部中断10产生了中断，中断号为IRQ_EINT8t23的中断被触发，执行函数s3c_irq_demux_extint8()。
static void
s3c_irq_demux_extint8(unsigned int irq,
struct irq_desc *desc)
{
unsigned long eintpnd = __raw_readl(S3C24XX_EINTPEND);
unsigned long eintmsk = __raw_readl(S3C24XX_EINTMASK);
eintpnd &= ~eintmsk;
eintpnd &= ~0xff;
while (eintpnd) {
irq = __ffs(eintpnd); //计算该中断在外部中断寄存器EINTPEND中的偏移量
eintpnd &= ~(1<<irq);
irq += (IRQ_EINT4 - 4); //根据这个偏移量重新计算中断号
generic_handle_irq(irq); //根据重新计算的中断号获取对应的结构体irq_desc，并调用它的上层中断处理函数。
}
}
static inline void generic_handle_irq_desc(unsigned int irq, struct irq_desc *desc)
{
#ifdef CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ
desc->handle_irq(irq, desc); //直接调用上层中断处理函数
#else
if (likely(desc->handle_irq))
desc->handle_irq(irq, desc);
else
__do_IRQ(irq); //通用中断处理函数，该函数最终调用desc->handle_irq(irq, desc);
#endif
}
上层中断处理函数
上层中断处理函数有5个分别为：handle_simple_irq(),handle_level_irq(),
handle_edge_irq(),handle_fasteoi_irq()以及handle_percpu_irq()。
这几个函数在文件kernel/irq/chip.c中实现。常用的有两个handle_level_irq(),和handle_edge_irq()。
这5个上层中断处理函数都是通过调用函数handle_IRQ_event()来做进一步处理。
irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
{
irqreturn_t ret, retval = IRQ_NONE;
unsigned int status = 0;
if (!(action->flags & IRQF_DISABLED))
local_irq_enable_in_hardirq();
do {
。。。。。。
ret = action->handler(irq, action->dev_id); //执行中断处理函数。
。。。。。。
retval |= ret;
action = action->next;
} while (action); //调用该中断线上的所有例程
if (status & IRQF_SAMPLE_RANDOM)
add_interrupt_randomness(irq);
local_irq_disable();
return retval;
}
void
handle_level_irq(unsigned int irq, struct irq_desc *desc)
{
struct irqaction *action;
irqreturn_t action_ret;
。。。。。。
desc = irq_remap_to_desc(irq, desc);
。。。。。。
action = desc->action;
action_ret = handle_IRQ_event(irq, action);
。。。。。。
}
void
handle_edge_irq(unsigned int irq, struct irq_desc *desc)
{
spin_lock(&desc->lock);
。。。。。。
desc = irq_remap_to_desc(irq, desc);
。。。。。。
desc->status |= IRQ_INPROGRESS;
do {
struct irqaction *action = desc->action;
。。。。。。
desc->status &= ~IRQ_PENDING;
spin_unlock(&desc->lock);
action_ret = handle_IRQ_event(irq, action);
if (!noirqdebug)
note_interrupt(irq, desc, action_ret);
spin_lock(&desc->lock);
//该函数与函数handle_level_irq不太一样的是，该函数多了一个循环。即如果在本次中断
//的处理过程中该中断线上又有中断产生,则再次执行该中断线上的处理例程
#define IRQ_DISABLED 2
#define IRQ_PENDING 4
#define IRQ_REPLAY 8
#define IRQ_WAITING 32
*/
} while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);
desc->status &= ~IRQ_INPROGRESS;
out_unlock:
spin_unlock(&desc->lock);
}
788
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
