irq.c 6.6 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2 3 4 5
 *    Copyright IBM Corp. 2004,2011
 *    Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>,
 *		 Holger Smolinski <Holger.Smolinski@de.ibm.com>,
 *		 Thomas Spatzier <tspat@de.ibm.com>,
L
Linus Torvalds 已提交
6 7 8 9 10 11 12
 *
 * This file contains interrupt related functions.
 */

#include <linux/kernel_stat.h>
#include <linux/interrupt.h>
#include <linux/seq_file.h>
13 14
#include <linux/proc_fs.h>
#include <linux/profile.h>
15 16 17 18 19 20 21 22 23 24 25
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/ftrace.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/cpu.h>
#include <asm/irq_regs.h>
#include <asm/cputime.h>
#include <asm/lowcore.h>
#include <asm/irq.h>
#include "entry.h"
L
Linus Torvalds 已提交
26

27 28 29 30 31 32 33 34 35
struct irq_class {
	char *name;
	char *desc;
};

static const struct irq_class intrclass_names[] = {
	{.name = "EXT" },
	{.name = "I/O" },
	{.name = "CLK", .desc = "[EXT] Clock Comparator" },
36 37
	{.name = "EXC", .desc = "[EXT] External Call" },
	{.name = "EMS", .desc = "[EXT] Emergency Signal" },
38 39 40 41 42 43 44
	{.name = "TMR", .desc = "[EXT] CPU Timer" },
	{.name = "TAL", .desc = "[EXT] Timing Alert" },
	{.name = "PFL", .desc = "[EXT] Pseudo Page Fault" },
	{.name = "DSD", .desc = "[EXT] DASD Diag" },
	{.name = "VRT", .desc = "[EXT] Virtio" },
	{.name = "SCP", .desc = "[EXT] Service Call" },
	{.name = "IUC", .desc = "[EXT] IUCV" },
45
	{.name = "CPM", .desc = "[EXT] CPU Measurement" },
46
	{.name = "CIO", .desc = "[I/O] Common I/O Layer Interrupt" },
47
	{.name = "QAI", .desc = "[I/O] QDIO Adapter Interrupt" },
48
	{.name = "DAS", .desc = "[I/O] DASD" },
49
	{.name = "C15", .desc = "[I/O] 3215" },
50
	{.name = "C70", .desc = "[I/O] 3270" },
51
	{.name = "TAP", .desc = "[I/O] Tape" },
52
	{.name = "VMR", .desc = "[I/O] Unit Record Devices" },
53
	{.name = "LCS", .desc = "[I/O] LCS" },
54
	{.name = "CLW", .desc = "[I/O] CLAW" },
55
	{.name = "CTC", .desc = "[I/O] CTC" },
56
	{.name = "APB", .desc = "[I/O] AP Bus" },
57
	{.name = "CSC", .desc = "[I/O] CHSC Subchannel" },
58 59 60
	{.name = "NMI", .desc = "[NMI] Machine Check" },
};

L
Linus Torvalds 已提交
61 62 63 64 65 66 67
/*
 * show_interrupts is needed by /proc/interrupts.
 */
int show_interrupts(struct seq_file *p, void *v)
{
	int i = *(loff_t *) v, j;

68
	get_online_cpus();
L
Linus Torvalds 已提交
69 70 71 72 73 74 75 76
	if (i == 0) {
		seq_puts(p, "           ");
		for_each_online_cpu(j)
			seq_printf(p, "CPU%d       ",j);
		seq_putc(p, '\n');
	}

	if (i < NR_IRQS) {
77
		seq_printf(p, "%s: ", intrclass_names[i].name);
L
Linus Torvalds 已提交
78 79 80 81 82 83
#ifndef CONFIG_SMP
		seq_printf(p, "%10u ", kstat_irqs(i));
#else
		for_each_online_cpu(j)
			seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
#endif
84 85
		if (intrclass_names[i].desc)
			seq_printf(p, "  %s", intrclass_names[i].desc);
L
Linus Torvalds 已提交
86 87
                seq_putc(p, '\n');
        }
88
	put_online_cpus();
L
Linus Torvalds 已提交
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
        return 0;
}

/*
 * Switch to the asynchronous interrupt stack for softirq execution.
 */
asmlinkage void do_softirq(void)
{
	unsigned long flags, old, new;

	if (in_interrupt())
		return;

	local_irq_save(flags);

	if (local_softirq_pending()) {
		/* Get current stack pointer. */
		asm volatile("la %0,0(15)" : "=a" (old));
		/* Check against async. stack address range. */
		new = S390_lowcore.async_stack;
		if (((new - old) >> (PAGE_SHIFT + THREAD_ORDER)) != 0) {
			/* Need to switch to the async. stack. */
			new -= STACK_FRAME_OVERHEAD;
			((struct stack_frame *) new)->back_chain = old;

			asm volatile("   la    15,0(%0)\n"
				     "   basr  14,%2\n"
				     "   la    15,0(%1)\n"
				     : : "a" (new), "a" (old),
				         "a" (__do_softirq)
				     : "0", "1", "2", "3", "4", "5", "14",
				       "cc", "memory" );
		} else
			/* We are already on the async stack. */
			__do_softirq();
	}

	local_irq_restore(flags);
}
128

129
#ifdef CONFIG_PROC_FS
130 131 132 133 134 135 136
void init_irq_proc(void)
{
	struct proc_dir_entry *root_irq_dir;

	root_irq_dir = proc_mkdir("irq", NULL);
	create_prof_cpu_mask(root_irq_dir);
}
137
#endif
138 139

/*
140 141
 * ext_int_hash[index] is the list head for all external interrupts that hash
 * to this index.
142
 */
143
static struct list_head ext_int_hash[256];
144 145 146 147

struct ext_int_info {
	ext_int_handler_t handler;
	u16 code;
148 149
	struct list_head entry;
	struct rcu_head rcu;
150 151
};

152 153 154 155 156 157 158 159 160 161
/* ext_int_hash_lock protects the handler lists for external interrupts */
DEFINE_SPINLOCK(ext_int_hash_lock);

static void __init init_external_interrupts(void)
{
	int idx;

	for (idx = 0; idx < ARRAY_SIZE(ext_int_hash); idx++)
		INIT_LIST_HEAD(&ext_int_hash[idx]);
}
162 163 164 165 166 167

static inline int ext_hash(u16 code)
{
	return (code + (code >> 9)) & 0xff;
}

168 169 170 171 172 173 174
static void ext_int_hash_update(struct rcu_head *head)
{
	struct ext_int_info *p = container_of(head, struct ext_int_info, rcu);

	kfree(p);
}

175 176 177
int register_external_interrupt(u16 code, ext_int_handler_t handler)
{
	struct ext_int_info *p;
178
	unsigned long flags;
179 180 181 182 183 184 185 186
	int index;

	p = kmalloc(sizeof(*p), GFP_ATOMIC);
	if (!p)
		return -ENOMEM;
	p->code = code;
	p->handler = handler;
	index = ext_hash(code);
187 188 189 190

	spin_lock_irqsave(&ext_int_hash_lock, flags);
	list_add_rcu(&p->entry, &ext_int_hash[index]);
	spin_unlock_irqrestore(&ext_int_hash_lock, flags);
191 192 193 194 195 196
	return 0;
}
EXPORT_SYMBOL(register_external_interrupt);

int unregister_external_interrupt(u16 code, ext_int_handler_t handler)
{
197 198 199
	struct ext_int_info *p;
	unsigned long flags;
	int index = ext_hash(code);
200

201 202 203 204 205 206 207
	spin_lock_irqsave(&ext_int_hash_lock, flags);
	list_for_each_entry_rcu(p, &ext_int_hash[index], entry)
		if (p->code == code && p->handler == handler) {
			list_del_rcu(&p->entry);
			call_rcu(&p->rcu, ext_int_hash_update);
		}
	spin_unlock_irqrestore(&ext_int_hash_lock, flags);
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
	return 0;
}
EXPORT_SYMBOL(unregister_external_interrupt);

void __irq_entry do_extint(struct pt_regs *regs, unsigned int ext_int_code,
			   unsigned int param32, unsigned long param64)
{
	struct pt_regs *old_regs;
	unsigned short code;
	struct ext_int_info *p;
	int index;

	code = (unsigned short) ext_int_code;
	old_regs = set_irq_regs(regs);
	irq_enter();
	if (S390_lowcore.int_clock >= S390_lowcore.clock_comparator)
		/* Serve timer interrupts first. */
		clock_comparator_work();
	kstat_cpu(smp_processor_id()).irqs[EXTERNAL_INTERRUPT]++;
	if (code != 0x1004)
		__get_cpu_var(s390_idle).nohz_delay = 1;
229

230
	index = ext_hash(code);
231 232
	rcu_read_lock();
	list_for_each_entry_rcu(p, &ext_int_hash[index], entry)
233 234
		if (likely(p->code == code))
			p->handler(ext_int_code, param32, param64);
235
	rcu_read_unlock();
236 237 238 239
	irq_exit();
	set_irq_regs(old_regs);
}

240 241 242 243 244
void __init init_IRQ(void)
{
	init_external_interrupts();
}

245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
static DEFINE_SPINLOCK(sc_irq_lock);
static int sc_irq_refcount;

void service_subclass_irq_register(void)
{
	spin_lock(&sc_irq_lock);
	if (!sc_irq_refcount)
		ctl_set_bit(0, 9);
	sc_irq_refcount++;
	spin_unlock(&sc_irq_lock);
}
EXPORT_SYMBOL(service_subclass_irq_register);

void service_subclass_irq_unregister(void)
{
	spin_lock(&sc_irq_lock);
	sc_irq_refcount--;
	if (!sc_irq_refcount)
		ctl_clear_bit(0, 9);
	spin_unlock(&sc_irq_lock);
}
EXPORT_SYMBOL(service_subclass_irq_unregister);