am33xx linux中断处理流程
运行环境
kernel 5.10
CPU Ti am33xx
linux中断的3个结构体
struct irq_desc {
struct irq_common_data irq_common_data;
struct irq_data irq_data;
unsigned int __percpu *kstat_irqs;
irq_flow_handler_t handle_irq;
struct irqaction *action; /* IRQ action list */ // 里面存放了用户注册的中断服务代码
unsigned int status_use_accessors;
unsigned int core_internal_state__do_not_mess_with_it;
unsigned int depth; /* nested irq disables */
unsigned int wake_depth; /* nested wake enables */
unsigned int tot_count;
unsigned int irq_count; /* For detecting broken IRQs */
unsigned long last_unhandled; /* Aging timer for unhandled count */
unsigned int irqs_unhandled;
atomic_t threads_handled;
int threads_handled_last;
raw_spinlock_t lock;
struct cpumask *percpu_enabled;
const struct cpumask *percpu_affinity;
#ifdef CONFIG_SMP
const struct cpumask *affinity_hint;
struct irq_affinity_notify *affinity_notify;
#ifdef CONFIG_GENERIC_PENDING_IRQ
cpumask_var_t pending_mask;
#endif
#endif
unsigned long threads_oneshot;
atomic_t threads_active;
wait_queue_head_t wait_for_threads;
#ifdef CONFIG_PM_SLEEP
unsigned int nr_actions;
unsigned int no_suspend_depth;
unsigned int cond_suspend_depth;
unsigned int force_resume_depth;
#endif
#ifdef CONFIG_PROC_FS
struct proc_dir_entry *dir;
#endif
#ifdef CONFIG_GENERIC_IRQ_DEBUGFS
struct dentry *debugfs_file;
const char *dev_name;
#endif
#ifdef CONFIG_SPARSE_IRQ
struct rcu_head rcu;
struct kobject kobj;
#endif
struct mutex request_mutex;
int parent_irq;
struct module *owner;
const char *name;
} ____cacheline_internodealigned_in_smp;
struct irqaction {
irq_handler_t handler; // 用户注册的中断服务代码， 中断发生时就会运行这个中断处理函数
void *dev_id;
void __percpu *percpu_dev_id;
struct irqaction *next;
irq_handler_t thread_fn;
struct task_struct *thread;
struct irqaction *secondary;
unsigned int irq; //hw中断号,
unsigned int flags; //中断标志,注册时设置,比如上升沿中断，下降沿中断等
unsigned long thread_flags;
unsigned long thread_mask;
const char *name; //中断名称,产生中断的硬件的名字
struct proc_dir_entry *dir; // proc/irq/
} ____cacheline_internodealigned_in_smp;
struct irq_data {
u32 mask;
unsigned int irq;
unsigned long hwirq;
struct irq_common_data *common;
struct irq_chip *chip; // 芯片端的中断处理函数
struct irq_domain *domain; // 代表一个interrupt controller 设备树中的INTC
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
struct irq_data *parent_data;
#endif
void *chip_data;
};
整体框图如下：
linux硬件中断处理流程
1. 外设产生中断
2. CPU触发中断
3. 跳转到异常向量入口：
保存现场
执行中断服务
恢复现场
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
我们主要关注如何执行中断服务，在arch\arm\kernel\entry-armv.S中，有如下几条语句
.macro irq_handler #ifdef CONFIG_GENERIC_IRQ_MULTI_HANDLER ldr r1, =handle_arch_irq mov r0, sp badr lr, 9997f ldr pc, [r1] #else arch_irq_handler_default #endif
其中 handle_arch_irq 即为CPU处理中断时会调用到的硬件中断服务入口，handle_arch_irq在 kernel/irq/handle.c 中被赋值
#ifdef CONFIG_GENERIC_IRQ_MULTI_HANDLER
#ifndef CONFIG_IRQCHIP_XILINX_INTC_MODULE_SUPPORT_EXPERIMENTAL
int __init set_handle_irq(void (*handle_irq)(struct pt_regs *))
#else
int set_handle_irq(void (*handle_irq)(struct pt_regs *))
#endif
{
if (handle_arch_irq)
return -EBUSY;
handle_arch_irq = handle_irq;
return 0;
}
#endif
set_handle_irq 被谁调用？主要由CPU厂家的BSP工程师调用，比如TI的AM33xx系列平台，在 drivers/irqchip/irq-omap-intc.c 中的以下接口调用
static int __init intc_of_init(struct device_node *node,
struct device_node *parent)
{
int ret;
omap_nr_pending = 3;
omap_nr_irqs = 96;
if (WARN_ON(!node))
return -ENODEV;
if (of_device_is_compatible(node, "ti,dm814-intc") ||
of_device_is_compatible(node, "ti,dm816-intc") ||
of_device_is_compatible(node, "ti,am33xx-intc")) {
omap_nr_irqs = 128;
omap_nr_pending = 4;
}
ret = omap_init_irq(-1, of_node_get(node));
if (ret < 0)
return ret;
set_handle_irq(omap_intc_handle_irq); // 设置硬中断服务函数入口
return 0;
}
omap_intc_handle_irq便是am33xx触发中断后，需要响应的中断服务入口，该入口做了哪些工作？
static asmlinkage void __exception_irq_entry
omap_intc_handle_irq(struct pt_regs *regs)
{
extern unsigned long irq_err_count;
u32 irqnr;
irqnr = intc_readl(INTC_SIR); // 获取硬件中断号
/*
* A spurious IRQ can result if interrupt that triggered the
* sorting is no longer active during the sorting (10 INTC
* functional clock cycles after interrupt assertion). Or a
* change in interrupt mask affected the result during sorting
* time. There is no special handling required except ignoring
* the SIR register value just read and retrying.
* See section 6.2.5 of AM335x TRM Literature Number: SPRUH73K
*
* Many a times, a spurious interrupt situation has been fixed
* by adding a flush for the posted write acking the IRQ in
* the device driver. Typically, this is going be the device
* driver whose interrupt was handled just before the spurious
* IRQ occurred. Pay attention to those device drivers if you
* run into hitting the spurious IRQ condition below.
*/
if (unlikely((irqnr & SPURIOUSIRQ_MASK) == SPURIOUSIRQ_MASK)) {
pr_err_once("%s: spurious irq!\n", __func__);
irq_err_count++;
omap_ack_irq(NULL);
return;
}
irqnr &= ACTIVEIRQ_MASK;
handle_domain_irq(domain, irqnr, regs); // 根据硬件中断号，在domain链表中查找映射好的IRQ number， 实现原理是怎样的？
}
domain是如何实现HW 中断号和 IRQ number映射的？ 在解析设备树的时候，会调用 irq_of_parse_and_map 接口创建映射；详情参考 linux中断号映射
handle_domain_irq 调用了 __handle_domain_irq, 在__handle_domain_irq中，开始调用硬中断服务函数，也就是中断上半部
int __handle_domain_irq(struct irq_domain *domain, unsigned int hwirq,
bool lookup, struct pt_regs *regs)
{
struct pt_regs *old_regs = set_irq_regs(regs);
unsigned int irq = hwirq;
int ret = 0;
irq_enter();
#ifdef CONFIG_IRQ_DOMAIN
if (lookup)
irq = irq_find_mapping(domain, hwirq); // 根据硬中断号，在映射表中找到对应的 IRQ number
#endif
/*
* Some hardware gives randomly wrong interrupts. Rather
* than crashing, do something sensible.
*/
if (unlikely(!irq || irq >= nr_irqs)) {
ack_bad_irq(irq);
ret = -EINVAL;
} else {
generic_handle_irq(irq); // 根据IRQ number，查找中断服务，并执行
}
irq_exit(); // 退出硬件中断服务，然后 invoke_softirq()，再 __do_softirq()，唤醒softirq队列，进入下半部开始执行
set_irq_regs(old_regs);
return ret;
}
他会调用 generic_handle_irq(irq) ， 以下为 generic_handle_irq 代码
int generic_handle_irq(unsigned int irq)
{
struct irq_desc *desc = irq_to_desc(irq); // 根据IRQ number 找到 中断描述符
struct irq_data *data;
if (!desc)
return -EINVAL;
data = irq_desc_get_irq_data(desc);
if (WARN_ON_ONCE(!in_irq() && handle_enforce_irqctx(data)))
return -EPERM;
generic_handle_irq_desc(desc); // 根据中断描述符，找到对应的 handler
return 0;
}
generic_handle_irq_desc 会调用 desc结构体中的 hande_irq 成员： desc->handle_irq(desc); 他指向哪 ？
desc->handle_irq(desc) 最后会调用到 irqaction 结构体中的 handler 成员，也就是用户通过 request_irq （request_irq详解） 接口注册的中断服务程序，附上网上找的一份简单示意图（kernel2.6）
desc->handle_irq(desc) 是如何关联到 irqaction 结构体中的 handler 成员？
先从设备端看：
拿AM33xx GPIO举例：
在 gpio-omap.c 中的 omap_gpio_probe 里面，会对 irq_chip 结构体的 irq_set_type 赋值 omap_gpio_irq_type，然后将 am33xx芯片端的gpio 中断处理相关的函数注册到linux kernel，kernel调用 desc->handle_irq(desc) 时，即可调用到 am33xx xinp端的 gpio 中断处理函数（具体细节接下来分析）；
omap_gpio_irq_type 函数如下：
static int omap_gpio_irq_type(struct irq_data *d, unsigned type)
{
struct gpio_bank *bank = omap_irq_data_get_bank(d);
int retval;
unsigned long flags;
unsigned offset = d->hwirq;
if (type & ~IRQ_TYPE_SENSE_MASK)
return -EINVAL;
if (!bank->regs->leveldetect0 &&
(type & (IRQ_TYPE_LEVEL_LOW|IRQ_TYPE_LEVEL_HIGH)))
return -EINVAL;
raw_spin_lock_irqsave(&bank->lock, flags);
retval = omap_set_gpio_triggering(bank, offset, type);
if (retval) {
raw_spin_unlock_irqrestore(&bank->lock, flags);
goto error;
}
omap_gpio_init_irq(bank, offset);
if (!omap_gpio_is_input(bank, offset)) {
raw_spin_unlock_irqrestore(&bank->lock, flags);
retval = -EINVAL;
goto error;
}
raw_spin_unlock_irqrestore(&bank->lock, flags);
if (type & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
irq_set_handler_locked(d, handle_level_irq); // 电平触发中断
else if (type & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
/*
* Edge IRQs are already cleared/acked in irq_handler and
* not need to be masked, as result handle_edge_irq()
* logic is excessed here and may cause lose of interrupts.
* So just use handle_simple_irq.
*/
irq_set_handler_locked(d, handle_simple_irq); // 边沿触发中断
return 0;
error:
return retval;
}
该函数主要是设置了 gpio 电平触发， 边沿触发的中断处理服务，先拿边沿触发分析，看看 handle_simple_irq 函数是如何一步步调用到 irqaction 结构体中的 handler 成员的（也就是用户通过request_irq 申请的中断服务）：
void handle_simple_irq(struct irq_desc *desc)
{
raw_spin_lock(&desc->lock);
if (!irq_may_run(desc))
goto out_unlock;
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
desc->istate |= IRQS_PENDING;
goto out_unlock;
}
kstat_incr_irqs_this_cpu(desc); // 设置处理标记，避免多次重复进入中断处理
handle_irq_event(desc); // 中断服务相关
out_unlock:
raw_spin_unlock(&desc->lock);
}
再来看看 handle_irq_event(desc) 做了啥 irqreturn_t handle_irq_event(struct irq_desc *desc)
{
irqreturn_t ret;
desc->istate &= ~IRQS_PENDING;
irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
raw_spin_unlock(&desc->lock);
ret = handle_irq_event_percpu(desc); // 进入中断服务
raw_spin_lock(&desc->lock);
irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
return ret;
}
irqreturn_t handle_irq_event_percpu(struct irq_desc *desc)
{
irqreturn_t retval;
unsigned int flags = 0;
retval = __handle_irq_event_percpu(desc, &flags); // 进入中断服务
add_interrupt_randomness(desc->irq_data.irq);
if (!noirqdebug)
note_interrupt(desc, retval);
return retval;
}
接下来就真正调用到了 irqaction 结构体中的 handler 成员
irqreturn_t __handle_irq_event_percpu(struct irq_desc *desc, unsigned int *flags)
{
irqreturn_t retval = IRQ_NONE;
unsigned int irq = desc->irq_data.irq;
struct irqaction *action;
record_irq_time(desc);
for_each_action_of_desc(desc, action) { // 轮询该中断描述符里面的所有 action
irqreturn_t res;
/*
* If this IRQ would be threaded under force_irqthreads, mark it so.
*/
if (irq_settings_can_thread(desc) &&
!(action->flags & (IRQF_NO_THREAD | IRQF_PERCPU | IRQF_ONESHOT)))
lockdep_hardirq_threaded();
trace_irq_handler_entry(irq, action);
res = action->handler(irq, action->dev_id); // 调用用户注册的中断服务
trace_irq_handler_exit(irq, action, res);
if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pS enabled interrupts\n",
irq, action->handler))
local_irq_disable();
switch (res) {
case IRQ_WAKE_THREAD:
/*
* Catch drivers which return WAKE_THREAD but
* did not set up a thread function
*/
if (unlikely(!action->thread_fn)) {
warn_no_thread(irq, action);
break;
}
__irq_wake_thread(desc, action);
fallthrough; /* to add to randomness */
case IRQ_HANDLED:
*flags |= action->flags;
break;
default:
break;
}
retval |= res;
}
return retval;
}
omap_gpio_probe 是如何将 irq_chip 关联到 irq_desc 结构体的， 也就是说 kernel调用 desc->handle_irq(desc) 时，怎么就能调用到 handle_simple_irq？后续继续分析！
