1/*
  2 *  linux/arch/arm/kernel/irq.c
  3 *
  4 *  Copyright (C) 1992 Linus Torvalds
  5 *  Modifications for ARM processor Copyright (C) 1995-2000 Russell King.
  6 *
  7 *  Support for Dynamic Tick Timer Copyright (C) 2004-2005 Nokia Corporation.
  8 *  Dynamic Tick Timer written by Tony Lindgren <tony@atomide.com> and
  9 *  Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com>.
 10 *
 11 * This program is free software; you can redistribute it and/or modify
 12 * it under the terms of the GNU General Public License version 2 as
 13 * published by the Free Software Foundation.
 14 *
 15 *  This file contains the code used by various IRQ handling routines:
 16 *  asking for different IRQ's should be done through these routines
 17 *  instead of just grabbing them. Thus setups with different IRQ numbers
 18 *  shouldn't result in any weird surprises, and installing new handlers
 19 *  should be easier.
 20 *
 21 *  IRQ's are in fact implemented a bit like signal handlers for the kernel.
 22 *  Naturally it's not a 1:1 relation, but there are similarities.
 23 */
 24#include <linux/kernel_stat.h>
 25#include <linux/module.h>
 26#include <linux/signal.h>
 27#include <linux/ioport.h>
 28#include <linux/interrupt.h>
 29#include <linux/irq.h>
 
 30#include <linux/random.h>
 31#include <linux/smp.h>
 32#include <linux/init.h>
 33#include <linux/seq_file.h>
 34#include <linux/errno.h>
 35#include <linux/list.h>
 36#include <linux/kallsyms.h>
 37#include <linux/proc_fs.h>
 38#include <linux/ftrace.h>
 39
 40#include <asm/system.h>
 
 
 
 41#include <asm/mach/arch.h>
 42#include <asm/mach/irq.h>
 43#include <asm/mach/time.h>
 44
 45/*
 46 * No architecture-specific irq_finish function defined in arm/arch/irqs.h.
 47 */
 48#ifndef irq_finish
 49#define irq_finish(irq) do { } while (0)
 50#endif
 51
 52unsigned long irq_err_count;
 53
 54int arch_show_interrupts(struct seq_file *p, int prec)
 55{
 56#ifdef CONFIG_FIQ
 57	show_fiq_list(p, prec);
 58#endif
 59#ifdef CONFIG_SMP
 60	show_ipi_list(p, prec);
 61#endif
 62#ifdef CONFIG_LOCAL_TIMERS
 63	show_local_irqs(p, prec);
 64#endif
 65	seq_printf(p, "%*s: %10lu\n", prec, "Err", irq_err_count);
 66	return 0;
 67}
 68
 69/*
 70 * handle_IRQ handles all hardware IRQ's.  Decoded IRQs should
 71 * not come via this function.  Instead, they should provide their
 72 * own 'handler'.  Used by platform code implementing C-based 1st
 73 * level decoding.
 74 */
 75void handle_IRQ(unsigned int irq, struct pt_regs *regs)
 76{
 77	struct pt_regs *old_regs = set_irq_regs(regs);
 
 78
 79	irq_enter();
 80
 81	/*
 82	 * Some hardware gives randomly wrong interrupts.  Rather
 83	 * than crashing, do something sensible.
 84	 */
 85	if (unlikely(irq >= nr_irqs)) {
 86		if (printk_ratelimit())
 87			printk(KERN_WARNING "Bad IRQ%u\n", irq);
 88		ack_bad_irq(irq);
 89	} else {
 90		generic_handle_irq(irq);
 91	}
 92
 93	/* AT91 specific workaround */
 94	irq_finish(irq);
 
 
 95
 96	irq_exit();
 97	set_irq_regs(old_regs);
 98}
 99
100/*
101 * asm_do_IRQ is the interface to be used from assembly code.
102 */
103asmlinkage void __exception_irq_entry
104asm_do_IRQ(unsigned int irq, struct pt_regs *regs)
105{
106	handle_IRQ(irq, regs);
107}
108
109void set_irq_flags(unsigned int irq, unsigned int iflags)
110{
111	unsigned long clr = 0, set = IRQ_NOREQUEST | IRQ_NOPROBE | IRQ_NOAUTOEN;
 
 
 
 
 
112
113	if (irq >= nr_irqs) {
114		printk(KERN_ERR "Trying to set irq flags for IRQ%d\n", irq);
115		return;
 
 
 
 
 
116	}
117
118	if (iflags & IRQF_VALID)
119		clr |= IRQ_NOREQUEST;
120	if (iflags & IRQF_PROBE)
121		clr |= IRQ_NOPROBE;
122	if (!(iflags & IRQF_NOAUTOEN))
123		clr |= IRQ_NOAUTOEN;
124	/* Order is clear bits in "clr" then set bits in "set" */
125	irq_modify_status(irq, clr, set & ~clr);
126}
127
128void __init init_IRQ(void)
129{
130	machine_desc->init_irq();
131}
132
133#ifdef CONFIG_SPARSE_IRQ
134int __init arch_probe_nr_irqs(void)
135{
136	nr_irqs = machine_desc->nr_irqs ? machine_desc->nr_irqs : NR_IRQS;
137	return nr_irqs;
138}
139#endif
140
141#ifdef CONFIG_HOTPLUG_CPU
142
143static bool migrate_one_irq(struct irq_desc *desc)
144{
145	struct irq_data *d = irq_desc_get_irq_data(desc);
146	const struct cpumask *affinity = d->affinity;
147	struct irq_chip *c;
148	bool ret = false;
149
150	/*
151	 * If this is a per-CPU interrupt, or the affinity does not
152	 * include this CPU, then we have nothing to do.
153	 */
154	if (irqd_is_per_cpu(d) || !cpumask_test_cpu(smp_processor_id(), affinity))
155		return false;
156
157	if (cpumask_any_and(affinity, cpu_online_mask) >= nr_cpu_ids) {
158		affinity = cpu_online_mask;
159		ret = true;
160	}
161
162	c = irq_data_get_irq_chip(d);
163	if (c->irq_set_affinity)
164		c->irq_set_affinity(d, affinity, true);
165	else
166		pr_debug("IRQ%u: unable to set affinity\n", d->irq);
167
168	return ret;
169}
170
171/*
172 * The current CPU has been marked offline.  Migrate IRQs off this CPU.
173 * If the affinity settings do not allow other CPUs, force them onto any
174 * available CPU.
175 *
176 * Note: we must iterate over all IRQs, whether they have an attached
177 * action structure or not, as we need to get chained interrupts too.
178 */
179void migrate_irqs(void)
180{
181	unsigned int i;
182	struct irq_desc *desc;
183	unsigned long flags;
184
185	local_irq_save(flags);
186
187	for_each_irq_desc(i, desc) {
188		bool affinity_broken = false;
189
190		if (!desc)
191			continue;
192
193		raw_spin_lock(&desc->lock);
194		affinity_broken = migrate_one_irq(desc);
195		raw_spin_unlock(&desc->lock);
196
197		if (affinity_broken && printk_ratelimit())
198			pr_warning("IRQ%u no longer affine to CPU%u\n", i,
199				smp_processor_id());
200	}
201
202	local_irq_restore(flags);
203}
204#endif /* CONFIG_HOTPLUG_CPU */

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 *  linux/arch/arm/kernel/irq.c
  4 *
  5 *  Copyright (C) 1992 Linus Torvalds
  6 *  Modifications for ARM processor Copyright (C) 1995-2000 Russell King.
  7 *
  8 *  Support for Dynamic Tick Timer Copyright (C) 2004-2005 Nokia Corporation.
  9 *  Dynamic Tick Timer written by Tony Lindgren <tony@atomide.com> and
 10 *  Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com>.
 11 *
 
 
 
 
 12 *  This file contains the code used by various IRQ handling routines:
 13 *  asking for different IRQ's should be done through these routines
 14 *  instead of just grabbing them. Thus setups with different IRQ numbers
 15 *  shouldn't result in any weird surprises, and installing new handlers
 16 *  should be easier.
 17 *
 18 *  IRQ's are in fact implemented a bit like signal handlers for the kernel.
 19 *  Naturally it's not a 1:1 relation, but there are similarities.
 20 */
 
 
 21#include <linux/signal.h>
 22#include <linux/ioport.h>
 23#include <linux/interrupt.h>
 24#include <linux/irq.h>
 25#include <linux/irqchip.h>
 26#include <linux/random.h>
 27#include <linux/smp.h>
 28#include <linux/init.h>
 29#include <linux/seq_file.h>
 30#include <linux/errno.h>
 31#include <linux/list.h>
 32#include <linux/kallsyms.h>
 33#include <linux/proc_fs.h>
 34#include <linux/export.h>
 35
 36#include <asm/hardware/cache-l2x0.h>
 37#include <asm/hardware/cache-uniphier.h>
 38#include <asm/outercache.h>
 39#include <asm/exception.h>
 40#include <asm/mach/arch.h>
 41#include <asm/mach/irq.h>
 42#include <asm/mach/time.h>
 43
 
 
 
 
 
 
 
 44unsigned long irq_err_count;
 45
 46int arch_show_interrupts(struct seq_file *p, int prec)
 47{
 48#ifdef CONFIG_FIQ
 49	show_fiq_list(p, prec);
 50#endif
 51#ifdef CONFIG_SMP
 52	show_ipi_list(p, prec);
 53#endif
 
 
 
 54	seq_printf(p, "%*s: %10lu\n", prec, "Err", irq_err_count);
 55	return 0;
 56}
 57
 58/*
 59 * handle_IRQ handles all hardware IRQ's.  Decoded IRQs should
 60 * not come via this function.  Instead, they should provide their
 61 * own 'handler'.  Used by platform code implementing C-based 1st
 62 * level decoding.
 63 */
 64void handle_IRQ(unsigned int irq, struct pt_regs *regs)
 65{
 66	struct pt_regs *old_regs = set_irq_regs(regs);
 67	struct irq_desc *desc;
 68
 69	irq_enter();
 70
 71	/*
 72	 * Some hardware gives randomly wrong interrupts.  Rather
 73	 * than crashing, do something sensible.
 74	 */
 75	if (unlikely(!irq || irq >= nr_irqs))
 76		desc = NULL;
 77	else
 78		desc = irq_to_desc(irq);
 
 
 
 79
 80	if (likely(desc))
 81		handle_irq_desc(desc);
 82	else
 83		ack_bad_irq(irq);
 84
 85	irq_exit();
 86	set_irq_regs(old_regs);
 87}
 88
 89/*
 90 * asm_do_IRQ is the interface to be used from assembly code.
 91 */
 92asmlinkage void __exception_irq_entry
 93asm_do_IRQ(unsigned int irq, struct pt_regs *regs)
 94{
 95	handle_IRQ(irq, regs);
 96}
 97
 98void __init init_IRQ(void)
 99{
100	int ret;
101
102	if (IS_ENABLED(CONFIG_OF) && !machine_desc->init_irq)
103		irqchip_init();
104	else
105		machine_desc->init_irq();
106
107	if (IS_ENABLED(CONFIG_OF) && IS_ENABLED(CONFIG_CACHE_L2X0) &&
108	    (machine_desc->l2c_aux_mask || machine_desc->l2c_aux_val)) {
109		if (!outer_cache.write_sec)
110			outer_cache.write_sec = machine_desc->l2c_write_sec;
111		ret = l2x0_of_init(machine_desc->l2c_aux_val,
112				   machine_desc->l2c_aux_mask);
113		if (ret && ret != -ENODEV)
114			pr_err("L2C: failed to init: %d\n", ret);
115	}
116
117	uniphier_cache_init();
 
 
 
 
 
 
 
 
 
 
 
 
118}
119
120#ifdef CONFIG_SPARSE_IRQ
121int __init arch_probe_nr_irqs(void)
122{
123	nr_irqs = machine_desc->nr_irqs ? machine_desc->nr_irqs : NR_IRQS;
124	return nr_irqs;
125}
126#endif