irq.c 6.7 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
	{.name = "CIO", .desc = "[I/O] Common I/O Layer Interrupt" },
46
	{.name = "QAI", .desc = "[I/O] QDIO Adapter 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
	{.name = "CSC", .desc = "[I/O] CHSC Subchannel" },
57 58 59
	{.name = "NMI", .desc = "[NMI] Machine Check" },
};

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

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

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

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

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

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

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

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

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

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

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

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

200 201 202 203 204 205 206
	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);
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
	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;
230

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

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

246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
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);