1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 *	linux/arch/alpha/kernel/irq.c
  4 *
  5 *	Copyright (C) 1995 Linus Torvalds
  6 *
  7 * This file contains the code used by various IRQ handling routines:
  8 * asking for different IRQ's should be done through these routines
  9 * instead of just grabbing them. Thus setups with different IRQ numbers
 10 * shouldn't result in any weird surprises, and installing new handlers
 11 * should be easier.
 12 */
 13
 14#include <linux/kernel.h>
 15#include <linux/module.h>
 16#include <linux/errno.h>
 17#include <linux/kernel_stat.h>
 18#include <linux/signal.h>
 19#include <linux/sched.h>
 20#include <linux/ptrace.h>
 21#include <linux/interrupt.h>
 22#include <linux/random.h>
 
 23#include <linux/irq.h>
 24#include <linux/proc_fs.h>
 25#include <linux/seq_file.h>
 26#include <linux/profile.h>
 27#include <linux/bitops.h>
 28
 
 29#include <asm/io.h>
 30#include <linux/uaccess.h>
 31#include "irq_impl.h"
 32
 33volatile unsigned long irq_err_count;
 34DEFINE_PER_CPU(unsigned long, irq_pmi_count);
 35
 36void ack_bad_irq(unsigned int irq)
 37{
 38	irq_err_count++;
 39	printk(KERN_CRIT "Unexpected IRQ trap at vector %u\n", irq);
 40}
 41
 42#ifdef CONFIG_SMP 
 43static char irq_user_affinity[NR_IRQS];
 44
 45int irq_select_affinity(unsigned int irq)
 46{
 47	struct irq_data *data = irq_get_irq_data(irq);
 48	struct irq_chip *chip;
 49	static int last_cpu;
 50	int cpu = last_cpu + 1;
 51
 52	if (!data)
 53		return 1;
 54	chip = irq_data_get_irq_chip(data);
 55
 56	if (!chip->irq_set_affinity || irq_user_affinity[irq])
 57		return 1;
 58
 59	while (!cpu_possible(cpu) ||
 60	       !cpumask_test_cpu(cpu, irq_default_affinity))
 61		cpu = (cpu < (NR_CPUS-1) ? cpu + 1 : 0);
 62	last_cpu = cpu;
 63
 64	irq_data_update_affinity(data, cpumask_of(cpu));
 65	chip->irq_set_affinity(data, cpumask_of(cpu), false);
 66	return 0;
 67}
 68#endif /* CONFIG_SMP */
 69
 70int arch_show_interrupts(struct seq_file *p, int prec)
 71{
 72	int j;
 73
 74#ifdef CONFIG_SMP
 75	seq_puts(p, "IPI: ");
 76	for_each_online_cpu(j)
 77		seq_printf(p, "%10lu ", cpu_data[j].ipi_count);
 78	seq_putc(p, '\n');
 79#endif
 80	seq_puts(p, "PMI: ");
 81	for_each_online_cpu(j)
 82		seq_printf(p, "%10lu ", per_cpu(irq_pmi_count, j));
 83	seq_puts(p, "          Performance Monitoring\n");
 84	seq_printf(p, "ERR: %10lu\n", irq_err_count);
 85	return 0;
 86}
 87
 88/*
 89 * handle_irq handles all normal device IRQ's (the special
 90 * SMP cross-CPU interrupts have their own specific
 91 * handlers).
 92 */
 93
 94#define MAX_ILLEGAL_IRQS 16
 95
 96void
 97handle_irq(int irq)
 98{	
 99	/* 
100	 * We ack quickly, we don't want the irq controller
101	 * thinking we're snobs just because some other CPU has
102	 * disabled global interrupts (we have already done the
103	 * INT_ACK cycles, it's too late to try to pretend to the
104	 * controller that we aren't taking the interrupt).
105	 *
106	 * 0 return value means that this irq is already being
107	 * handled by some other CPU. (or is disabled)
108	 */
109	static unsigned int illegal_count=0;
110	struct irq_desc *desc = irq_to_desc(irq);
111	
112	if (!desc || ((unsigned) irq > ACTUAL_NR_IRQS &&
113	    illegal_count < MAX_ILLEGAL_IRQS)) {
114		irq_err_count++;
115		illegal_count++;
116		printk(KERN_CRIT "device_interrupt: invalid interrupt %d\n",
117		       irq);
118		return;
119	}
120
 
 
 
 
 
 
 
121	irq_enter();
122	generic_handle_irq_desc(desc);
123	irq_exit();
124}

 
  1/*
  2 *	linux/arch/alpha/kernel/irq.c
  3 *
  4 *	Copyright (C) 1995 Linus Torvalds
  5 *
  6 * This file contains the code used by various IRQ handling routines:
  7 * asking for different IRQ's should be done through these routines
  8 * instead of just grabbing them. Thus setups with different IRQ numbers
  9 * shouldn't result in any weird surprises, and installing new handlers
 10 * should be easier.
 11 */
 12
 13#include <linux/kernel.h>
 14#include <linux/module.h>
 15#include <linux/errno.h>
 16#include <linux/kernel_stat.h>
 17#include <linux/signal.h>
 18#include <linux/sched.h>
 19#include <linux/ptrace.h>
 20#include <linux/interrupt.h>
 21#include <linux/random.h>
 22#include <linux/init.h>
 23#include <linux/irq.h>
 24#include <linux/proc_fs.h>
 25#include <linux/seq_file.h>
 26#include <linux/profile.h>
 27#include <linux/bitops.h>
 28
 29#include <asm/system.h>
 30#include <asm/io.h>
 31#include <asm/uaccess.h>
 
 32
 33volatile unsigned long irq_err_count;
 34DEFINE_PER_CPU(unsigned long, irq_pmi_count);
 35
 36void ack_bad_irq(unsigned int irq)
 37{
 38	irq_err_count++;
 39	printk(KERN_CRIT "Unexpected IRQ trap at vector %u\n", irq);
 40}
 41
 42#ifdef CONFIG_SMP 
 43static char irq_user_affinity[NR_IRQS];
 44
 45int irq_select_affinity(unsigned int irq)
 46{
 47	struct irq_data *data = irq_get_irq_data(irq);
 48	struct irq_chip *chip;
 49	static int last_cpu;
 50	int cpu = last_cpu + 1;
 51
 52	if (!data)
 53		return 1;
 54	chip = irq_data_get_irq_chip(data);
 55
 56	if (!chip->irq_set_affinity || irq_user_affinity[irq])
 57		return 1;
 58
 59	while (!cpu_possible(cpu) ||
 60	       !cpumask_test_cpu(cpu, irq_default_affinity))
 61		cpu = (cpu < (NR_CPUS-1) ? cpu + 1 : 0);
 62	last_cpu = cpu;
 63
 64	cpumask_copy(data->affinity, cpumask_of(cpu));
 65	chip->irq_set_affinity(data, cpumask_of(cpu), false);
 66	return 0;
 67}
 68#endif /* CONFIG_SMP */
 69
 70int arch_show_interrupts(struct seq_file *p, int prec)
 71{
 72	int j;
 73
 74#ifdef CONFIG_SMP
 75	seq_puts(p, "IPI: ");
 76	for_each_online_cpu(j)
 77		seq_printf(p, "%10lu ", cpu_data[j].ipi_count);
 78	seq_putc(p, '\n');
 79#endif
 80	seq_puts(p, "PMI: ");
 81	for_each_online_cpu(j)
 82		seq_printf(p, "%10lu ", per_cpu(irq_pmi_count, j));
 83	seq_puts(p, "          Performance Monitoring\n");
 84	seq_printf(p, "ERR: %10lu\n", irq_err_count);
 85	return 0;
 86}
 87
 88/*
 89 * handle_irq handles all normal device IRQ's (the special
 90 * SMP cross-CPU interrupts have their own specific
 91 * handlers).
 92 */
 93
 94#define MAX_ILLEGAL_IRQS 16
 95
 96void
 97handle_irq(int irq)
 98{	
 99	/* 
100	 * We ack quickly, we don't want the irq controller
101	 * thinking we're snobs just because some other CPU has
102	 * disabled global interrupts (we have already done the
103	 * INT_ACK cycles, it's too late to try to pretend to the
104	 * controller that we aren't taking the interrupt).
105	 *
106	 * 0 return value means that this irq is already being
107	 * handled by some other CPU. (or is disabled)
108	 */
109	static unsigned int illegal_count=0;
110	struct irq_desc *desc = irq_to_desc(irq);
111	
112	if (!desc || ((unsigned) irq > ACTUAL_NR_IRQS &&
113	    illegal_count < MAX_ILLEGAL_IRQS)) {
114		irq_err_count++;
115		illegal_count++;
116		printk(KERN_CRIT "device_interrupt: invalid interrupt %d\n",
117		       irq);
118		return;
119	}
120
121	/*
122	 * From here we must proceed with IPL_MAX. Note that we do not
123	 * explicitly enable interrupts afterwards - some MILO PALcode
124	 * (namely LX164 one) seems to have severe problems with RTI
125	 * at IPL 0.
126	 */
127	local_irq_disable();
128	irq_enter();
129	generic_handle_irq_desc(irq, desc);
130	irq_exit();
131}