LinuxARM中断后的处理(5)【转】

  • Z时代
  • 2024-01-10
  • 分类：综合

编程

转自：https://blog.csdn.net/zgtzqzg2020/article/details/105703394

1. 中断进入自定义函数 

在中断发生后，经历ARM通用的处理阶段,到达irq_handler宏，转入C语言阶段。

  1. //arch/arm/kernel/entry-armv.S
  2. /*
  3. *注释：
  4. *宏CONFIG_MULTI_IRQ_HANDLER在.config中有定义，会将handle_arch_irq里的值赋值给pc去执行。
  5. *给handle_arch_irq请看后面的C语言阶段分析
  6. */
  7. /*
  8. * Interrupt handling.
  9. */
  10.         .macro irq_handler
  11. #ifdef CONFIG_MULTI_IRQ_HANDLER
  12.         ldr r1, =handle_arch_irq
  13.         mov r0, sp
  14.         badr lr, 9997f
  15.         ldr pc, [r1] //进入C语言阶段的中断处理
  16. #else
  17.         arch_irq_handler_default
  18. #endif
  19. 9997:
  20.         .endm
  23. //arch/arm/kernel/entry-armv.S
  24. #ifdef CONFIG_MULTI_IRQ_HANDLER
  25.         .globl handle_arch_irq
  26. handle_arch_irq:
  27.         .space 4
  28. #endif

2. handle_arch_irq

handle_arch_irq赋值在/drivers/irqchip/irq-vic.c的vic_register函数中调用set_handle_irq进行赋值

  1. //driver/irqchip/irq-vic.c
  2. /**
  3.  * vic_register() - Register a VIC.
  4.  * @base: The base address of the VIC.
  5.  * @parent_irq: The parent IRQ if cascaded, else 0.
  6.  * @irq: The base IRQ for the VIC.
  7.  * @valid_sources: bitmask of valid interrupts
  8.  * @resume_sources: bitmask of interrupts allowed for resume sources.
  9.  * @node: The device tree node associated with the VIC.
  10.  *
  11.  * Register the VIC with the system device tree so that it can be notified
  12.  * of suspend and resume requests and ensure that the correct actions are
  13.  * taken to re-instate the settings on resume.
  14.  *
  15.  * This also configures the IRQ domain for the VIC.
  16.  */
  17. // __vic_init(regs, 0, 0, interrupt_mask, wakeup_mask, node);
  18. //vic_register(base, 0, irq_start, vic_sources, 0, node);
  19. staticvoid __initvic_register(void __iomem *base, unsigned int parent_irq,
  20.                                 unsigned int irq,
  21.                                 u32 valid_sources, u32 resume_sources,
  22. struct device_node *node)
  23. {
  24. struct vic_device *v; 
  25. int i;
  27. if (vic_id >= ARRAY_SIZE(vic_devices)) {
  28.                 printk(KERN_ERR "%s: too few VICs, increase CONFIG_ARM_VIC_NR
    ", __func__);
  29. return;
  30.         }
  32.          v = &vic_devices[vic_id];
  33.         v->base = base;
  34.         v->valid_sources = valid_sources;
  35.         v->resume_sources = resume_sources;
  36.         set_handle_irq(vic_handle_irq);  //此处被调用
  37.         vic_id++;
  39. if (parent_irq) {
  40.                 irq_set_chained_handler_and_data(parent_irq,
  41.                                                  vic_handle_irq_cascaded, v);
  42.         }
  44.         v->domain = irq_domain_add_simple(node, fls(valid_sources), irq,
  45.                                           &vic_irqdomain_ops, v);
  46. /* create an IRQ mapping for each valid IRQ */
  47. for (i = 0; i < fls(valid_sources); i++) {
  49. if (valid_sources & (1 << i)) {
  50.                         irq_create_mapping(v->domain, i);
  51.                 }
  52.         }
  53. /* If no base IRQ was passed, figure out our allocated base */
  54. if (irq)
  55.                 v->irq = irq;
  56. else
  57.                 v->irq = irq_find_mapping(v->domain, 0);
  58. }
  61. //arch/arm/kernel/irq.c
  62. #ifdef CONFIG_MULTI_IRQ_HANDLER
  63. void __initset_handle_irq(void (*handle_irq)(struct pt_regs *))
  64. {
  65. if (handle_arch_irq)
  66. return;
  68.         handle_arch_irq = handle_irq;
  69. }
  70. #endif

3. vic_handle_irq

  1. //drivers/irqchip/irq-vic.c
  2. /*
  3.  * Keep iterating over all registered VIC"s until there are no pending
  4.  * interrupts.
  5.  */
  6. staticvoid __exception_irq_entry vic_handle_irq(struct pt_regs *regs)
  7. {
  8. int i, handled;
  10. do {
  11. for (i = 0, handled = 0; i < vic_id; ++i)
  12.                         handled |= handle_one_vic(&vic_devices[i], regs);
  13.         } while (handled);
  14. }

4. handle_one_vic

  1. //drivers/irqchip/irq-vic.c
  2. /*
  3.  * Handle each interrupt in a single VIC.  Returns non-zero if we"ve
  4.  * handled at least one interrupt.  This reads the status register
  5.  * before handling each interrupt, which is necessary given that
  6.  * handle_IRQ may briefly re-enable interrupts for soft IRQ handling.
  7.  */
  8. staticinthandle_one_vic(struct vic_device *vic, struct pt_regs *regs)
  9. {
  10.         u32 stat, irq;
  11. int handled = 0;
  13. while ((stat = readl_relaxed(vic->base + VIC_IRQ_STATUS))) {
  14.                 irq = ffs(stat) - 1;
  15.                 handle_domain_irq(vic->domain, irq, regs);
  16.                 handled = 1;
  17.         }
  19. return handled;
  20. }
  23. //具体代码参看arch/arm/include/asm/io.h 
  24. /*
  25.  *  Memory access primitives
  26.  *  ------------------------
  27.  *
  28.  * These perform PCI memory accesses via an ioremap region.  They don"t
  29.  * take an address as such, but a cookie.
  30.  *
  31.  * Again, this are defined to perform little endian accesses.  See the
  32.  * IO port primitives for more information.
  33.  */
  34. #ifndef readl
  35. #define readb_relaxed(c) ({ u8  __r = __raw_readb(c); __r; })
  36. #define readw_relaxed(c) ({ u16 __r = le16_to_cpu((__force __le16) 
  37.                                         __raw_readw(c)); __r; })
  38. #define readl_relaxed(c) ({ u32 __r = le32_to_cpu((__force __le32) 
  39.                                         __raw_readl(c)); __r; })
  41. #define writeb_relaxed(v,c)     __raw_writeb(v,c)
  42. #define writew_relaxed(v,c)     __raw_writew((__force u16) cpu_to_le16(v),c)
  43. #define writel_relaxed(v,c)     __raw_writel((__force u32) cpu_to_le32(v),c)
  45. #define readb(c)                ({ u8  __v = readb_relaxed(c); __iormb(); __v; })
  46. #define readw(c)                ({ u16 __v = readw_relaxed(c); __iormb(); __v; })
  47. #define readl(c)                ({ u32 __v = readl_relaxed(c); __iormb(); __v; })
  49. #define writeb(v,c)             ({ __iowmb(); writeb_relaxed(v,c); })
  50. #define writew(v,c)             ({ __iowmb(); writew_relaxed(v,c); })
  51. #define writel(v,c)             ({ __iowmb(); writel_relaxed(v,c); })
  53. #define readsb(p,d,l)           __raw_readsb(p,d,l)
  54. #define readsw(p,d,l)           __raw_readsw(p,d,l)
  55. #define readsl(p,d,l)           __raw_readsl(p,d,l)
  57. #define writesb(p,d,l)          __raw_writesb(p,d,l)
  58. #define writesw(p,d,l)          __raw_writesw(p,d,l)
  59. #define writesl(p,d,l)          __raw_writesl(p,d,l)

5. handle_domain_irq

  1. //include/linux/irqdesc.h
  2. #ifdef CONFIG_HANDLE_DOMAIN_IRQ
  3. /*
  4.  * Convert a HW interrupt number to a logical one using a IRQ domain,
  5.  * and handle the result interrupt number. Return -EINVAL if
  6.  * conversion failed. Providing a NULL domain indicates that the
  7.  * conversion has already been done.
  8.  */
  9. int __handle_domain_irq(struct irq_domain *domain, unsignedint hwirq,
  10. bool lookup, struct pt_regs *regs);
  12. staticinlineinthandle_domain_irq(struct irq_domain *domain,
  13. unsignedint hwirq, struct pt_regs *regs)
  14. {
  15. return __handle_domain_irq(domain, hwirq, true, regs);
  16. }
  17. #endif

6. __handle_domain_irq

  1. //kernel/irq/irqdesc.c
  2. #ifdef CONFIG_HANDLE_DOMAIN_IRQ
  3. /**
  4.  * __handle_domain_irq - Invoke the handler for a HW irq belonging to a domain
  5.  * @domain:     The domain where to perform the lookup
  6.  * @hwirq:      The HW irq number to convert to a logical one
  7.  * @lookup:     Whether to perform the domain lookup or not
  8.  * @regs:       Register file coming from the low-level handling code
  9.  *
  10.  * Returns:     0 on success, or -EINVAL if conversion has failed
  11.  */
  12. int __handle_domain_irq(struct irq_domain *domain, unsignedint hwirq,
  13. bool lookup, struct pt_regs *regs)
  14. {
  15. structpt_regs *old_regs = set_irq_regs(regs);
  16. unsignedint irq = hwirq;
  17. int ret = 0;
  19. irq_enter();
  21. #ifdef CONFIG_IRQ_DOMAIN
  22. if (lookup)
  23.                 irq = irq_find_mapping(domain, hwirq);
  24. #endif
  26. /*
  27.          * Some hardware gives randomly wrong interrupts.  Rather
  28.          * than crashing, do something sensible.
  29.          */
  30. if (unlikely(!irq || irq >= nr_irqs)) {
  31. ack_bad_irq(irq);
  32.                 ret = -EINVAL;
  33.         } else {
  34. generic_handle_irq(irq);
  35.         }
  37. irq_exit();
  38. set_irq_regs(old_regs);
  39. return ret;
  40. }
  41. #endif

7. generic_handle_irq

  1. //kernel/irq/irqdesc.c
  2. /**
  3.  * generic_handle_irq - Invoke the handler for a particular irq
  4.  * @irq:        The irq number to handle
  5.  *
  6.  */
  7. intgeneric_handle_irq(unsignedint irq)
  8. {
  9. structirq_desc *desc = irq_to_desc(irq);
  11. if (!desc)
  12. return -EINVAL;
  13. generic_handle_irq_desc(desc);
  14. return0;
  15. }
  16. EXPORT_SYMBOL_GPL(generic_handle_irq);

8. generic_handle_irq_desc

  1. //include/linux/irqdesc.h
  2. /*
  3.  * Architectures call this to let the generic IRQ layer
  4.  * handle an interrupt.
  5.  */
  6. staticinlinevoidgeneric_handle_irq_desc(struct irq_desc *desc)
  7. {
  8. /*
  9.          *handle_irq在struct domain的struct domain_ops的map函数中调用 
  10.          *irq_set_chip_and_handler赋值为handle_level_irq
  11.          */
  12.         desc->handle_irq(desc);  
  13. }
  15. intgeneric_handle_irq(unsignedint irq);

9. handle_level_irq

  1. //kernel/irq/chip.c
  2. /**
  3.  *      handle_level_irq - Level type irq handler
  4.  *      @desc:  the interrupt description structure for this irq
  5.  *
  6.  *      Level type interrupts are active as long as the hardware line has
  7.  *      the active level. This may require to mask the interrupt and unmask
  8.  *      it after the associated handler has acknowledged the device, so the
  9.  *      interrupt line is back to inactive.
  10.  */
  11. voidhandle_level_irq(struct irq_desc *desc)
  12. {
  13. raw_spin_lock(&desc->lock);
  14. mask_ack_irq(desc);
  16. if (!irq_may_run(desc))
  17. goto out_unlock;
  19.         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
  20. kstat_incr_irqs_this_cpu(desc);
  22. /*
  23.          * If its disabled or no action available
  24.          * keep it masked and get out of here
  25.          */
  26. if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
  27.                 desc->istate |= IRQS_PENDING;
  28. goto out_unlock;
  29.         }
  31. handle_irq_event(desc);
  33. cond_unmask_irq(desc);
  35. out_unlock:
  36. raw_spin_unlock(&desc->lock);
  37. }
  38. EXPORT_SYMBOL_GPL(handle_level_irq);
  42. //kernel/irq/chip.c
  43. staticinlinevoidmask_ack_irq(struct irq_desc *desc)
  44. {
  45. /*desc->irq_data.chip在struct domain的struct domain_ops的map函数中调用 
  46.           *irq_set_chip_and_handler赋值为vic_chip.
  47.           */
  48. if (desc->irq_data.chip->irq_mask_ack)
  49.                 desc->irq_data.chip->irq_mask_ack(&desc->irq_data);
  50. else {
  51.                 desc->irq_data.chip->irq_mask(&desc->irq_data);
  52. if (desc->irq_data.chip->irq_ack)
  53.                         desc->irq_data.chip->irq_ack(&desc->irq_data);
  54.         }
  55. irq_state_set_masked(desc);
  56. }
  59. //include/linux/irq.h
  60. /**
  61.  * struct irq_chip - hardware interrupt chip descriptor
  62.  *
  63.  * @name:               name for /proc/interrupts
  64.  * @irq_startup:        start up the interrupt (defaults to ->enable if NULL)
  65.  * @irq_shutdown:       shut down the interrupt (defaults to ->disable if NULL)
  66.  * @irq_enable:         enable the interrupt (defaults to chip->unmask if NULL)
  67.  * @irq_disable:        disable the interrupt
  68.  * @irq_ack:            start of a new interrupt
  69.  * @irq_mask:           mask an interrupt source
  70.  * @irq_mask_ack:       ack and mask an interrupt source
  71.  * @irq_unmask:         unmask an interrupt source
  72.  * @irq_eoi:            end of interrupt
  73.  * @irq_set_affinity:   set the CPU affinity on SMP machines
  74.  * @irq_retrigger:      resend an IRQ to the CPU
  75.  * @irq_set_type:       set the flow type (IRQ_TYPE_LEVEL/etc.) of an IRQ
  76.  * @irq_set_wake:       enable/disable power-management wake-on of an IRQ
  77.  * @irq_bus_lock:       function to lock access to slow bus (i2c) chips
  78.  * @irq_bus_sync_unlock:function to sync and unlock slow bus (i2c) chips
  79.  * @irq_cpu_online:     configure an interrupt source for a secondary CPU
  80.  * @irq_cpu_offline:    un-configure an interrupt source for a secondary CPU
  81.  * @irq_suspend:        function called from core code on suspend once per
  82.  *                      chip, when one or more interrupts are installed
  83.  * @irq_resume:         function called from core code on resume once per chip,
  84.  *                      when one ore more interrupts are installed
  85.  * @irq_pm_shutdown:    function called from core code on shutdown once per chip
  86.  * @irq_calc_mask:      Optional function to set irq_data.mask for special cases
  87.  * @irq_print_chip:     optional to print special chip info in show_interrupts
  88.  * @irq_request_resources:      optional to request resources before calling
  89.  *                              any other callback related to this irq
  90.  * @irq_release_resources:      optional to release resources acquired with
  91.  *                              irq_request_resources
  92.  * @irq_compose_msi_msg:        optional to compose message content for MSI
  93.  * @irq_write_msi_msg:  optional to write message content for MSI
  94.  * @irq_get_irqchip_state:      return the internal state of an interrupt
  95.  * @irq_set_irqchip_state:      set the internal state of a interrupt
  96.  * @irq_set_vcpu_affinity:      optional to target a vCPU in a virtual machine
  97.  * @flags:              chip specific flags
  98.  */
  99. structirq_chip {
  100. constchar      *name;
  101. unsignedint(*irq_startup)(struct irq_data *data);
  102. void            (*irq_shutdown)(struct irq_data *data);
  103. void            (*irq_enable)(struct irq_data *data);
  104. void            (*irq_disable)(struct irq_data *data);
  106. void            (*irq_ack)(struct irq_data *data);
  107. void            (*irq_mask)(struct irq_data *data);
  108. void            (*irq_mask_ack)(struct irq_data *data);
  109. void            (*irq_unmask)(struct irq_data *data);
  110. void            (*irq_eoi)(struct irq_data *data);
  112. int             (*irq_set_affinity)(struct irq_data *data, conststruct cpumask *dest, bool force);
  113. int             (*irq_retrigger)(struct irq_data *data);
  114. int             (*irq_set_type)(struct irq_data *data, unsignedint flow_type);
  115. int             (*irq_set_wake)(struct irq_data *data, unsignedint on);
  117. void            (*irq_bus_lock)(struct irq_data *data);
  118. void            (*irq_bus_sync_unlock)(struct irq_data *data);
  120. void            (*irq_cpu_online)(struct irq_data *data);
  121. void            (*irq_cpu_offline)(struct irq_data *data);
  122. void            (*irq_suspend)(struct irq_data *data);
  123. void            (*irq_resume)(struct irq_data *data);
  124. void            (*irq_pm_shutdown)(struct irq_data *data);
  126. void            (*irq_calc_mask)(struct irq_data *data);
  128. void            (*irq_print_chip)(struct irq_data *data, struct seq_file *p);
  129. int             (*irq_request_resources)(struct irq_data *data);
  130. void            (*irq_release_resources)(struct irq_data *data);
  132. void            (*irq_compose_msi_msg)(struct irq_data *data, struct msi_msg *msg);
  133. void            (*irq_write_msi_msg)(struct irq_data *data, struct msi_msg *msg);
  135. int             (*irq_get_irqchip_state)(struct irq_data *data, enum irqchip_irq_state which, bool *state);
  136. int             (*irq_set_irqchip_state)(struct irq_data *data, enum irqchip_irq_state which, bool state);
  138. int             (*irq_set_vcpu_affinity)(struct irq_data *data, void *vcpu_info);
  140. unsignedlong   flags;
  141. };
  144. //drivers/irqchip/irq-vic.c  在
  145. staticstructirq_chip vic_chip = { 
  146.         .name           = "VIC",
  147.         .irq_ack        = vic_ack_irq,
  148.         .irq_mask       = vic_mask_irq,
  149.         .irq_unmask     = vic_unmask_irq,
  150.         .irq_set_wake   = vic_set_wake,
  151. };
  155. staticvoidvic_ack_irq(struct irq_data *d)
  156. {
  157. void __iomem *base = irq_data_get_irq_chip_data(d);
  158. unsignedint irq = d->hwirq;
  159. writel(1 << irq, base + VIC_INT_ENABLE_CLEAR);
  160. /* moreover, clear the soft-triggered, in case it was the reason */
  161. writel(1 << irq, base + VIC_INT_SOFT_CLEAR);
  162. }
  164. staticvoidvic_mask_irq(struct irq_data *d)
  165. {
  166. void __iomem *base = irq_data_get_irq_chip_data(d);
  167. unsignedint irq = d->hwirq;
  168. writel(1 << irq, base + VIC_INT_ENABLE_CLEAR);
  169. }
  171. staticvoidvic_unmask_irq(struct irq_data *d)
  172. {
  173. void __iomem *base = irq_data_get_irq_chip_data(d);
  174. unsignedint irq = d->hwirq;
  175. writel(1 << irq, base + VIC_INT_ENABLE);
  176. }
  178. #if defined(CONFIG_PM)
  179. staticstructvic_device *vic_from_irq(unsignedint irq)
  180. {
  181. structvic_device *v = vic_devices;
  182. unsignedint base_irq = irq & ~31;
  183. int id;
  185. for (id = 0; id < vic_id; id++, v++) {
  186. if (v->irq == base_irq)
  187. return v;
  188.         }
  190. returnNULL;
  191. }
  192. staticintvic_set_wake(struct irq_data *d, unsignedint on)
  193. {
  194. structvic_device *v = vic_from_irq(d->irq);
  195. unsignedint off = d->hwirq;
  196.         u32 bit = 1 << off;
  198. if (!v)
  199. return -EINVAL;
  201. if (!(bit & v->resume_sources))
  202. return -EINVAL;
  204. if (on)
  205.                 v->resume_irqs |= bit;
  206. else
  207.                 v->resume_irqs &= ~bit;
  209. return0;
  210. }
  211. #else
  212. #define vic_set_wake NULL
  213. #endif/* CONFIG_PM */
  216. //include/linux/irq.h
  217. staticinlinevoid *irq_data_get_irq_chip_data(struct irq_data *d)
  218. {
  219. /*
  220.          *d->chip_data在struct domain的struct domain_ops的map函数中调用 
  221.          *irq_set_chip_data赋值为中断控制器寄存器的虚拟地址
  222.          *
  223.          */
  224. return d->chip_data;
  225. }

10. handle_irq_event

  1. //kernel/irq/handle.c
  2. irqreturn_thandle_irq_event(struct irq_desc *desc)
  3. {
  4. irqreturn_t ret;
  6.         desc->istate &= ~IRQS_PENDING;
  7. irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
  8. raw_spin_unlock(&desc->lock);
  10.         ret = handle_irq_event_percpu(desc);
  12. raw_spin_lock(&desc->lock);
  13. irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
  14. return ret;
  15. }

11. handle_irq_event_percpu：

  1. //kernel/irq/handle.c
  2. irqreturn_thandle_irq_event_percpu(struct irq_desc *desc)
  3. {
  4. irqreturn_t retval = IRQ_NONE;
  5. unsignedint flags = 0, irq = desc->irq_data.irq;
  6. structirqaction *action = desc->action;
  8. /* action might have become NULL since we dropped the lock */
  9. while (action) {
  10. irqreturn_t res;
  12. trace_irq_handler_entry(irq, action);
  13. /*
  14.                  *action->handler处理函数为驱动中注册的处理函数
  15.                  */
  16.                 res = action->handler(irq, action->dev_id);
  17. trace_irq_handler_exit(irq, action, res);
  19. if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts
    ",
  20.                               irq, action->handler))
  21. local_irq_disable();
  23. switch (res) {
  24. case IRQ_WAKE_THREAD:
  25. /*
  26.                          * Catch drivers which return WAKE_THREAD but
  27.                          * did not set up a thread function
  28.                         */
  29. if (unlikely(!action->thread_fn)) {
  30. warn_no_thread(irq, action);
  31. break;
  32.                         }
  34.                         __irq_wake_thread(desc, action);
  36. /* Fall through to add to randomness */
  37. case IRQ_HANDLED:
  38.                         flags |= action->flags;
  39. break;
  41. default:
  42. break;
  43.                 }
  45.                 retval |= res;
  46.                 action = action->next;
  47.         }
  49. add_interrupt_randomness(irq, flags);
  51. if (!noirqdebug)
  52. note_interrupt(desc, retval);
  53. return retval;
  54. }

【作者】陈金

【出处】https://www.cnblogs.com/yifeichongtian2021/

【云海天】https://www.cnblogs.com/yifeichongtian2021/

本文版权归作者和云海天共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利.

以上是 LinuxARM中断后的处理(5)【转】 的全部内容， 来源链接： utcz.com/z/520014.html

回到顶部