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 36 37 38 39 40 41 42 43
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" },
	{.name = "IPI", .desc = "[EXT] Signal Processor" },
	{.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" },
44
	{.name = "CPM", .desc = "[EXT] CPU Measurement" },
45 46
	{.name = "QAI", .desc = "[I/O] QDIO Adapter Interrupt" },
	{.name = "QDI", .desc = "[I/O] QDIO Interrupt" },
47
	{.name = "DAS", .desc = "[I/O] DASD" },
48
	{.name = "C15", .desc = "[I/O] 3215" },
49
	{.name = "C70", .desc = "[I/O] 3270" },
50
	{.name = "TAP", .desc = "[I/O] Tape" },
51
	{.name = "VMR", .desc = "[I/O] Unit Record Devices" },
52
	{.name = "LCS", .desc = "[I/O] LCS" },
53
	{.name = "CLW", .desc = "[I/O] CLAW" },
54
	{.name = "CTC", .desc = "[I/O] CTC" },
55
	{.name = "APB", .desc = "[I/O] AP Bus" },
56 57 58
	{.name = "NMI", .desc = "[NMI] Machine Check" },
};

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

66
	get_online_cpus();
L
Linus Torvalds 已提交
67 68 69 70 71 72 73 74
	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) {
75
		seq_printf(p, "%s: ", intrclass_names[i].name);
L
Linus Torvalds 已提交
76 77 78 79 80 81
#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
82 83
		if (intrclass_names[i].desc)
			seq_printf(p, "  %s", intrclass_names[i].desc);
L
Linus Torvalds 已提交
84 85
                seq_putc(p, '\n');
        }
86
	put_online_cpus();
L
Linus Torvalds 已提交
87 88 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
        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);
}
126

127
#ifdef CONFIG_PROC_FS
128 129 130 131 132 133 134
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);
}
135
#endif
136 137

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

struct ext_int_info {
	ext_int_handler_t handler;
	u16 code;
146 147
	struct list_head entry;
	struct rcu_head rcu;
148 149
};

150 151 152 153 154 155 156 157 158 159
/* 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]);
}
160 161 162 163 164 165

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

166 167 168 169 170 171 172
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);
}

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

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

	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);
189 190 191 192 193 194
	return 0;
}
EXPORT_SYMBOL(register_external_interrupt);

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

199 200 201 202 203 204 205
	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);
206 207 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);
	s390_idle_check(regs, S390_lowcore.int_clock,
			S390_lowcore.async_enter_timer);
	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);