内核初始化
内核启动由这两个函数，完成中断的的初始化，包括硬件中断号和virq的映射
start_kernel{
....
early_irq_init();
init_IRQ();
....
}early_irq_init
early_irq_init给前16个核内中断分配irq_desc，并通过arch_early_irq_init初始化；打印如下：NR_IRQS: 16, nr_irqs: 16, preallocated irqs: 16
int __init early_irq_init(void)
{
int i, initcnt, node = first_online_node;
struct irq_desc *desc;
init_irq_default_affinity();
/* Let arch update nr_irqs and return the nr of preallocated irqs */
initcnt = arch_probe_nr_irqs();
printk(KERN_INFO "NR_IRQS: %d, nr_irqs: %d, preallocated irqs: %d\n",
NR_IRQS, nr_irqs, initcnt);
if (WARN_ON(nr_irqs > IRQ_BITMAP_BITS))
nr_irqs = IRQ_BITMAP_BITS;
if (WARN_ON(initcnt > IRQ_BITMAP_BITS))
initcnt = IRQ_BITMAP_BITS;
if (initcnt > nr_irqs)
nr_irqs = initcnt;
for (i = 0; i < initcnt; i++) {
desc = alloc_desc(i, node, 0, NULL, NULL);
set_bit(i, allocated_irqs);
irq_insert_desc(i, desc);
}
return arch_early_irq_init();
}所以可以看到有些控制器驱动，不去通过map找irq ；而是直接从设备树读出硬件中断号+16，来得出irq；但是建议还是规范的通过platform_get_irq获取映射后的irq
err = of_property_read_u32(node, "interrupts", &(port->irq));
if (err)
return err;
#ifndef CONFIG_PCI_MSI
port->irq += 16;
err = devm_request_irq(dev, port->irq, pcie_irq_handler,
IRQF_SHARED, "pcie", port);
if (err) {
dev_err(dev, "failed to request irq %d\n", port->irq);
return err;
}
#endifIRQCHIP_DECLARE
IRQCHIP_DECLARE定义的中断chip跟设备树匹配上，详情见《这篇》 ; set_handle_irq设置中断入口；
static int __init mmp_of_init(struct device_node *node,
struct device_node *parent)
{
int ret;
ret = mmp_init_bases(node);
if (ret < 0)
return ret;
icu_data[0].conf_enable = mmp_conf.conf_enable;
icu_data[0].conf_disable = mmp_conf.conf_disable;
icu_data[0].conf_mask = mmp_conf.conf_mask;
set_handle_irq(mmp_handle_irq);
max_icu_nr = 1;
return 0;
}
IRQCHIP_DECLARE(mmp_intc, "mrvl,mmp-intc", mmp_of_init);映射virq
mmp_init_bases映射硬件中断跟irq;有多少硬件中断，就调用多少次irq_create_mapping来静态创建映射
static int __init mmp_init_bases(struct device_node *node)
{
int ret, nr_irqs, irq, i = 0;
ret = of_property_read_u32(node, "mrvl,intc-nr-irqs", &nr_irqs);
if (ret) {
pr_err("Not found mrvl,intc-nr-irqs property\n");
return ret;
}
g_nr_irqs = nr_irqs;
mmp_icu_base = of_iomap(node, 0);
if (!mmp_icu_base) {
pr_err("Failed to get interrupt controller register\n");
return -ENOMEM;
}
if (g_nr_irqs > ICU_BASE1_NR_IRQS)
icu_data[0].reg_base2 = mmp_icu_base + ICU_CFG2_OFFSET;
else
icu_data[0].reg_base2 = 0;
icu_data[0].virq_base = 0;
icu_data[0].domain = irq_domain_add_linear(node, nr_irqs,
&mmp_irq_domain_ops,
&icu_data[0]);
for (irq = 0; irq < nr_irqs; irq++) {
ret = irq_create_mapping(icu_data[0].domain, irq);
if (!ret) {
pr_err("Failed to mapping hwirq\n");
goto err;
}
if (!irq)
icu_data[0].virq_base = ret;
}
icu_data[0].nr_irqs = nr_irqs;
return 0;
err:
if (icu_data[0].virq_base) {
for (i = 0; i < irq; i++)
irq_dispose_mapping(icu_data[0].virq_base + i);
}
irq_domain_remove(icu_data[0].domain);
iounmap(mmp_icu_base);
return -EINVAL;
}irq_create_mapping
上面从从设备树获取当前中断控制器多少个中断，然后通过irq_create_mapping创建映射
static inline unsigned int irq_create_mapping(struct irq_domain *host,
irq_hw_number_t hwirq)
{
return irq_create_mapping_affinity(host, hwirq, NULL);
}irq_create_mapping_affinity
主要通过irq_domain_alloc_descs分配virq
unsigned int irq_create_mapping_affinity(struct irq_domain *domain,
irq_hw_number_t hwirq,
const struct irq_affinity_desc *affinity)
{
struct device_node *of_node;
int virq;
pr_debug("irq_create_mapping(0x%p, 0x%lx)\n", domain, hwirq);
/* Look for default domain if nececssary */
if (domain == NULL)
domain = irq_default_domain;
if (domain == NULL) {
WARN(1, "%s(, %lx) called with NULL domain\n", __func__, hwirq);
return 0;
}
pr_debug("-> using domain @%p\n", domain);
of_node = irq_domain_get_of_node(domain);
/* Check if mapping already exists */
virq = irq_find_mapping(domain, hwirq);
if (virq) {
pr_debug("-> existing mapping on virq %d\n", virq);
return virq;
}
/* Allocate a virtual interrupt number */
virq = irq_domain_alloc_descs(-1, 1, hwirq, of_node_to_nid(of_node),
affinity);
if (virq <= 0) {
pr_debug("-> virq allocation failed\n");
return 0;
}
if (irq_domain_associate(domain, virq, hwirq)) {
irq_free_desc(virq);
return 0;
}
pr_debug("irq %lu on domain %s mapped to virtual irq %u\n",
hwirq, of_node_full_name(of_node), virq);
return virq;
}irq_domain_alloc_descs
计算得出偏移hint；一般就是硬件中断号；cnt一般是1 ；按此分配virq
int irq_domain_alloc_descs(int virq, unsigned int cnt, irq_hw_number_t hwirq,
int node, const struct irq_affinity_desc *affinity)
{
unsigned int hint;
if (virq >= 0) {
virq = __irq_alloc_descs(virq, virq, cnt, node, THIS_MODULE,
affinity);
} else {
hint = hwirq % nr_irqs;
if (hint == 0)
hint++;
virq = __irq_alloc_descs(-1, hint, cnt, node, THIS_MODULE,
affinity);
if (virq <= 0 && hint > 1) {
virq = __irq_alloc_descs(-1, 1, cnt, node, THIS_MODULE,
affinity);
}
+ printk("hint = %d, hwirq = %ld, nr_irqs = %d virq = %d", hint, hwirq, nr_irqs, virq);
}
return virq;加入的打印如下
[ 0.000000] hint = 1, hwirq = 0, nr_irqs = 17 virq = 16
[ 0.000000] hint = 1, hwirq = 1, nr_irqs = 18 virq = 17
[ 0.000000] hint = 2, hwirq = 2, nr_irqs = 19 virq = 18
[ 0.000000] hint = 3, hwirq = 3, nr_irqs = 20 virq = 19
[ 0.000000] hint = 4, hwirq = 4, nr_irqs = 21 virq = 20
......
[ 0.000000] hint = 62, hwirq = 62, nr_irqs = 79 virq = 78
[ 0.000000] hint = 63, hwirq = 63, nr_irqs = 80 virq = 79__irq_alloc_descs
经过__irq_alloc_descs后，nr_irq就被irq_expand_nr_irqs赋值为上一次irq_domain_alloc_descs的start + cnt
int __ref
__irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node,
struct module *owner, const struct irq_affinity_desc *affinity)
{
int start, ret;
if (!cnt)
return -EINVAL;
if (irq >= 0) {
if (from > irq)
return -EINVAL;
from = irq;
} else {
/*
* For interrupts which are freely allocated the
* architecture can force a lower bound to the @from
* argument. x86 uses this to exclude the GSI space.
*/
from = arch_dynirq_lower_bound(from);
}
mutex_lock(&sparse_irq_lock);
start = bitmap_find_next_zero_area(allocated_irqs, IRQ_BITMAP_BITS,
from, cnt, 0);
ret = -EEXIST;
if (irq >=0 && start != irq)
goto unlock;
if (start + cnt > nr_irqs) {
ret = irq_expand_nr_irqs(start + cnt);
if (ret)
goto unlock;
}
ret = alloc_descs(start, cnt, node, affinity, owner);
unlock:
mutex_unlock(&sparse_irq_lock);
return ret;
}中断级联
1.其他控制器，比如gpio控制器的中断控制单元，最终也是用不同的接口调用到__irq_alloc_descs分配irq_des
2.如果有gpio等控制器级联到这个父中断控制器下面；那么gpio控制器的的中断处理函数------会读出是那个gpio的触发的中断，然后找到gpio映射的irq，再去执行irq注册的中断处理函数
