irq.c 26.9 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5
/*
 *  Derived from arch/i386/kernel/irq.c
 *    Copyright (C) 1992 Linus Torvalds
 *  Adapted from arch/i386 by Gary Thomas
 *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
S
Stephen Rothwell 已提交
6 7
 *  Updated and modified by Cort Dougan <cort@fsmlabs.com>
 *    Copyright (C) 1996-2001 Cort Dougan
L
Linus Torvalds 已提交
8 9
 *  Adapted for Power Macintosh by Paul Mackerras
 *    Copyright (C) 1996 Paul Mackerras (paulus@cs.anu.edu.au)
S
Stephen Rothwell 已提交
10
 *
L
Linus Torvalds 已提交
11 12 13 14 15 16 17 18 19 20
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 *
 * This file contains the code used by various IRQ handling routines:
 * asking for different IRQ's should be done through these routines
 * instead of just grabbing them. Thus setups with different IRQ numbers
 * shouldn't result in any weird surprises, and installing new handlers
 * should be easier.
S
Stephen Rothwell 已提交
21 22 23 24 25 26 27 28
 *
 * The MPC8xx has an interrupt mask in the SIU.  If a bit is set, the
 * interrupt is _enabled_.  As expected, IRQ0 is bit 0 in the 32-bit
 * mask register (of which only 16 are defined), hence the weird shifting
 * and complement of the cached_irq_mask.  I want to be able to stuff
 * this right into the SIU SMASK register.
 * Many of the prep/chrp functions are conditional compiled on CONFIG_8xx
 * to reduce code space and undefined function references.
L
Linus Torvalds 已提交
29 30
 */

31 32
#undef DEBUG

L
Linus Torvalds 已提交
33 34 35 36 37
#include <linux/module.h>
#include <linux/threads.h>
#include <linux/kernel_stat.h>
#include <linux/signal.h>
#include <linux/sched.h>
S
Stephen Rothwell 已提交
38
#include <linux/ptrace.h>
L
Linus Torvalds 已提交
39 40 41 42 43 44 45
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/timex.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/irq.h>
S
Stephen Rothwell 已提交
46 47
#include <linux/seq_file.h>
#include <linux/cpumask.h>
L
Linus Torvalds 已提交
48 49
#include <linux/profile.h>
#include <linux/bitops.h>
50 51 52 53
#include <linux/list.h>
#include <linux/radix-tree.h>
#include <linux/mutex.h>
#include <linux/bootmem.h>
J
Jake Moilanen 已提交
54
#include <linux/pci.h>
55
#include <linux/debugfs.h>
56
#include <linux/perf_counter.h>
L
Linus Torvalds 已提交
57 58 59 60 61 62 63 64 65 66

#include <asm/uaccess.h>
#include <asm/system.h>
#include <asm/io.h>
#include <asm/pgtable.h>
#include <asm/irq.h>
#include <asm/cache.h>
#include <asm/prom.h>
#include <asm/ptrace.h>
#include <asm/machdep.h>
67
#include <asm/udbg.h>
68
#ifdef CONFIG_PPC64
L
Linus Torvalds 已提交
69
#include <asm/paca.h>
70
#include <asm/firmware.h>
71
#include <asm/lv1call.h>
S
Stephen Rothwell 已提交
72
#endif
L
Linus Torvalds 已提交
73

74
int __irq_offset_value;
S
Stephen Rothwell 已提交
75 76 77
static int ppc_spurious_interrupts;

#ifdef CONFIG_PPC32
78 79
EXPORT_SYMBOL(__irq_offset_value);
atomic_t ppc_n_lost_interrupts;
S
Stephen Rothwell 已提交
80 81 82 83 84

#ifdef CONFIG_TAU_INT
extern int tau_initialized;
extern int tau_interrupts(int);
#endif
85
#endif /* CONFIG_PPC32 */
S
Stephen Rothwell 已提交
86 87

#ifdef CONFIG_PPC64
L
Linus Torvalds 已提交
88 89 90
EXPORT_SYMBOL(irq_desc);

int distribute_irqs = 1;
91

S
Steven Rostedt 已提交
92
static inline notrace unsigned long get_hard_enabled(void)
93 94 95 96 97 98 99 100 101
{
	unsigned long enabled;

	__asm__ __volatile__("lbz %0,%1(13)"
	: "=r" (enabled) : "i" (offsetof(struct paca_struct, hard_enabled)));

	return enabled;
}

S
Steven Rostedt 已提交
102
static inline notrace void set_soft_enabled(unsigned long enable)
103 104 105 106 107
{
	__asm__ __volatile__("stb %0,%1(13)"
	: : "r" (enable), "i" (offsetof(struct paca_struct, soft_enabled)));
}

S
Steven Rostedt 已提交
108
notrace void raw_local_irq_restore(unsigned long en)
109
{
110 111 112 113 114 115 116 117
	/*
	 * get_paca()->soft_enabled = en;
	 * Is it ever valid to use local_irq_restore(0) when soft_enabled is 1?
	 * That was allowed before, and in such a case we do need to take care
	 * that gcc will set soft_enabled directly via r13, not choose to use
	 * an intermediate register, lest we're preempted to a different cpu.
	 */
	set_soft_enabled(en);
118 119 120
	if (!en)
		return;

121
#ifdef CONFIG_PPC_STD_MMU_64
122
	if (firmware_has_feature(FW_FEATURE_ISERIES)) {
123 124 125 126 127 128 129 130 131 132 133 134 135 136
		/*
		 * Do we need to disable preemption here?  Not really: in the
		 * unlikely event that we're preempted to a different cpu in
		 * between getting r13, loading its lppaca_ptr, and loading
		 * its any_int, we might call iseries_handle_interrupts without
		 * an interrupt pending on the new cpu, but that's no disaster,
		 * is it?  And the business of preempting us off the old cpu
		 * would itself involve a local_irq_restore which handles the
		 * interrupt to that cpu.
		 *
		 * But use "local_paca->lppaca_ptr" instead of "get_lppaca()"
		 * to avoid any preemption checking added into get_paca().
		 */
		if (local_paca->lppaca_ptr->int_dword.any_int)
137 138
			iseries_handle_interrupts();
	}
139
#endif /* CONFIG_PPC_STD_MMU_64 */
140

141
	if (test_perf_counter_pending()) {
142
		clear_perf_counter_pending();
143
		perf_counter_do_pending();
144
	}
145

146 147 148 149 150 151 152
	/*
	 * if (get_paca()->hard_enabled) return;
	 * But again we need to take care that gcc gets hard_enabled directly
	 * via r13, not choose to use an intermediate register, lest we're
	 * preempted to a different cpu in between the two instructions.
	 */
	if (get_hard_enabled())
153
		return;
154 155 156 157 158 159 160

	/*
	 * Need to hard-enable interrupts here.  Since currently disabled,
	 * no need to take further asm precautions against preemption; but
	 * use local_paca instead of get_paca() to avoid preemption checking.
	 */
	local_paca->hard_enabled = en;
161 162
	if ((int)mfspr(SPRN_DEC) < 0)
		mtspr(SPRN_DEC, 1);
163 164 165 166 167 168 169 170 171 172

	/*
	 * Force the delivery of pending soft-disabled interrupts on PS3.
	 * Any HV call will have this side effect.
	 */
	if (firmware_has_feature(FW_FEATURE_PS3_LV1)) {
		u64 tmp;
		lv1_get_version_info(&tmp);
	}

173
	__hard_irq_enable();
174
}
175
EXPORT_SYMBOL(raw_local_irq_restore);
S
Stephen Rothwell 已提交
176
#endif /* CONFIG_PPC64 */
L
Linus Torvalds 已提交
177 178 179

int show_interrupts(struct seq_file *p, void *v)
{
S
Stephen Rothwell 已提交
180 181
	int i = *(loff_t *)v, j;
	struct irqaction *action;
182
	struct irq_desc *desc;
L
Linus Torvalds 已提交
183 184 185
	unsigned long flags;

	if (i == 0) {
S
Stephen Rothwell 已提交
186 187 188
		seq_puts(p, "           ");
		for_each_online_cpu(j)
			seq_printf(p, "CPU%d       ", j);
L
Linus Torvalds 已提交
189 190 191 192 193 194 195 196 197 198 199
		seq_putc(p, '\n');
	}

	if (i < NR_IRQS) {
		desc = get_irq_desc(i);
		spin_lock_irqsave(&desc->lock, flags);
		action = desc->action;
		if (!action || !action->handler)
			goto skip;
		seq_printf(p, "%3d: ", i);
#ifdef CONFIG_SMP
S
Stephen Rothwell 已提交
200
		for_each_online_cpu(j)
201
			seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));
L
Linus Torvalds 已提交
202 203 204
#else
		seq_printf(p, "%10u ", kstat_irqs(i));
#endif /* CONFIG_SMP */
205 206
		if (desc->chip)
			seq_printf(p, " %s ", desc->chip->typename);
L
Linus Torvalds 已提交
207
		else
S
Stephen Rothwell 已提交
208
			seq_puts(p, "  None      ");
L
Linus Torvalds 已提交
209
		seq_printf(p, "%s", (desc->status & IRQ_LEVEL) ? "Level " : "Edge  ");
S
Stephen Rothwell 已提交
210 211
		seq_printf(p, "    %s", action->name);
		for (action = action->next; action; action = action->next)
L
Linus Torvalds 已提交
212 213 214 215
			seq_printf(p, ", %s", action->name);
		seq_putc(p, '\n');
skip:
		spin_unlock_irqrestore(&desc->lock, flags);
S
Stephen Rothwell 已提交
216
	} else if (i == NR_IRQS) {
217
#if defined(CONFIG_PPC32) && defined(CONFIG_TAU_INT)
S
Stephen Rothwell 已提交
218 219
		if (tau_initialized){
			seq_puts(p, "TAU: ");
220 221
			for_each_online_cpu(j)
				seq_printf(p, "%10u ", tau_interrupts(j));
S
Stephen Rothwell 已提交
222 223
			seq_puts(p, "  PowerPC             Thermal Assist (cpu temp)\n");
		}
224
#endif /* CONFIG_PPC32 && CONFIG_TAU_INT*/
L
Linus Torvalds 已提交
225
		seq_printf(p, "BAD: %10u\n", ppc_spurious_interrupts);
S
Stephen Rothwell 已提交
226
	}
L
Linus Torvalds 已提交
227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
	return 0;
}

#ifdef CONFIG_HOTPLUG_CPU
void fixup_irqs(cpumask_t map)
{
	unsigned int irq;
	static int warned;

	for_each_irq(irq) {
		cpumask_t mask;

		if (irq_desc[irq].status & IRQ_PER_CPU)
			continue;

242
		cpumask_and(&mask, irq_desc[irq].affinity, &map);
L
Linus Torvalds 已提交
243 244 245 246
		if (any_online_cpu(mask) == NR_CPUS) {
			printk("Breaking affinity for irq %i\n", irq);
			mask = map;
		}
247
		if (irq_desc[irq].chip->set_affinity)
248
			irq_desc[irq].chip->set_affinity(irq, &mask);
L
Linus Torvalds 已提交
249 250 251 252 253 254 255 256 257 258
		else if (irq_desc[irq].action && !(warned++))
			printk("Cannot set affinity for irq %i\n", irq);
	}

	local_irq_enable();
	mdelay(1);
	local_irq_disable();
}
#endif

259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
#ifdef CONFIG_IRQSTACKS
static inline void handle_one_irq(unsigned int irq)
{
	struct thread_info *curtp, *irqtp;
	unsigned long saved_sp_limit;
	struct irq_desc *desc;

	/* Switch to the irq stack to handle this */
	curtp = current_thread_info();
	irqtp = hardirq_ctx[smp_processor_id()];

	if (curtp == irqtp) {
		/* We're already on the irq stack, just handle it */
		generic_handle_irq(irq);
		return;
	}

	desc = irq_desc + irq;
	saved_sp_limit = current->thread.ksp_limit;

	irqtp->task = curtp->task;
	irqtp->flags = 0;

	/* Copy the softirq bits in preempt_count so that the
	 * softirq checks work in the hardirq context. */
	irqtp->preempt_count = (irqtp->preempt_count & ~SOFTIRQ_MASK) |
			       (curtp->preempt_count & SOFTIRQ_MASK);

	current->thread.ksp_limit = (unsigned long)irqtp +
		_ALIGN_UP(sizeof(struct thread_info), 16);

290
	call_handle_irq(irq, desc, irqtp, desc->handle_irq);
291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
	current->thread.ksp_limit = saved_sp_limit;
	irqtp->task = NULL;

	/* Set any flag that may have been set on the
	 * alternate stack
	 */
	if (irqtp->flags)
		set_bits(irqtp->flags, &curtp->flags);
}
#else
static inline void handle_one_irq(unsigned int irq)
{
	generic_handle_irq(irq);
}
#endif

307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
static inline void check_stack_overflow(void)
{
#ifdef CONFIG_DEBUG_STACKOVERFLOW
	long sp;

	sp = __get_SP() & (THREAD_SIZE-1);

	/* check for stack overflow: is there less than 2KB free? */
	if (unlikely(sp < (sizeof(struct thread_info) + 2048))) {
		printk("do_IRQ: stack overflow: %ld\n",
			sp - sizeof(struct thread_info));
		dump_stack();
	}
#endif
}

L
Linus Torvalds 已提交
323 324
void do_IRQ(struct pt_regs *regs)
{
325
	struct pt_regs *old_regs = set_irq_regs(regs);
326
	unsigned int irq;
L
Linus Torvalds 已提交
327

328
	irq_enter();
L
Linus Torvalds 已提交
329

330
	check_stack_overflow();
L
Linus Torvalds 已提交
331

O
Olaf Hering 已提交
332
	irq = ppc_md.get_irq();
L
Linus Torvalds 已提交
333

334 335 336
	if (irq != NO_IRQ && irq != NO_IRQ_IGNORE)
		handle_one_irq(irq);
	else if (irq != NO_IRQ_IGNORE)
337 338 339
		/* That's not SMP safe ... but who cares ? */
		ppc_spurious_interrupts++;

340
	irq_exit();
341
	set_irq_regs(old_regs);
S
Stephen Rothwell 已提交
342

343
#ifdef CONFIG_PPC_ISERIES
344 345
	if (firmware_has_feature(FW_FEATURE_ISERIES) &&
			get_lppaca()->int_dword.fields.decr_int) {
346 347 348
		get_lppaca()->int_dword.fields.decr_int = 0;
		/* Signal a fake decrementer interrupt */
		timer_interrupt(regs);
349 350 351
	}
#endif
}
L
Linus Torvalds 已提交
352 353 354

void __init init_IRQ(void)
{
355 356
	if (ppc_md.init_IRQ)
		ppc_md.init_IRQ();
357 358 359

	exc_lvl_ctx_init();

L
Linus Torvalds 已提交
360 361 362
	irq_ctx_init();
}

363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392
#if defined(CONFIG_BOOKE) || defined(CONFIG_40x)
struct thread_info   *critirq_ctx[NR_CPUS] __read_mostly;
struct thread_info    *dbgirq_ctx[NR_CPUS] __read_mostly;
struct thread_info *mcheckirq_ctx[NR_CPUS] __read_mostly;

void exc_lvl_ctx_init(void)
{
	struct thread_info *tp;
	int i;

	for_each_possible_cpu(i) {
		memset((void *)critirq_ctx[i], 0, THREAD_SIZE);
		tp = critirq_ctx[i];
		tp->cpu = i;
		tp->preempt_count = 0;

#ifdef CONFIG_BOOKE
		memset((void *)dbgirq_ctx[i], 0, THREAD_SIZE);
		tp = dbgirq_ctx[i];
		tp->cpu = i;
		tp->preempt_count = 0;

		memset((void *)mcheckirq_ctx[i], 0, THREAD_SIZE);
		tp = mcheckirq_ctx[i];
		tp->cpu = i;
		tp->preempt_count = HARDIRQ_OFFSET;
#endif
	}
}
#endif
L
Linus Torvalds 已提交
393 394

#ifdef CONFIG_IRQSTACKS
395 396
struct thread_info *softirq_ctx[NR_CPUS] __read_mostly;
struct thread_info *hardirq_ctx[NR_CPUS] __read_mostly;
L
Linus Torvalds 已提交
397 398 399 400 401 402

void irq_ctx_init(void)
{
	struct thread_info *tp;
	int i;

403
	for_each_possible_cpu(i) {
L
Linus Torvalds 已提交
404 405 406
		memset((void *)softirq_ctx[i], 0, THREAD_SIZE);
		tp = softirq_ctx[i];
		tp->cpu = i;
407
		tp->preempt_count = 0;
L
Linus Torvalds 已提交
408 409 410 411 412 413 414 415

		memset((void *)hardirq_ctx[i], 0, THREAD_SIZE);
		tp = hardirq_ctx[i];
		tp->cpu = i;
		tp->preempt_count = HARDIRQ_OFFSET;
	}
}

416 417 418
static inline void do_softirq_onstack(void)
{
	struct thread_info *curtp, *irqtp;
419
	unsigned long saved_sp_limit = current->thread.ksp_limit;
420 421 422 423

	curtp = current_thread_info();
	irqtp = softirq_ctx[smp_processor_id()];
	irqtp->task = curtp->task;
424 425
	current->thread.ksp_limit = (unsigned long)irqtp +
				    _ALIGN_UP(sizeof(struct thread_info), 16);
426
	call_do_softirq(irqtp);
427
	current->thread.ksp_limit = saved_sp_limit;
428 429
	irqtp->task = NULL;
}
L
Linus Torvalds 已提交
430

431 432 433 434
#else
#define do_softirq_onstack()	__do_softirq()
#endif /* CONFIG_IRQSTACKS */

L
Linus Torvalds 已提交
435 436 437 438 439 440 441 442 443
void do_softirq(void)
{
	unsigned long flags;

	if (in_interrupt())
		return;

	local_irq_save(flags);

444
	if (local_softirq_pending())
445
		do_softirq_onstack();
L
Linus Torvalds 已提交
446 447 448 449 450 451

	local_irq_restore(flags);
}


/*
452
 * IRQ controller and virtual interrupts
L
Linus Torvalds 已提交
453 454
 */

455
static LIST_HEAD(irq_hosts);
456
static DEFINE_SPINLOCK(irq_big_lock);
457
static unsigned int revmap_trees_allocated;
458
static DEFINE_MUTEX(revmap_trees_mutex);
459 460 461
struct irq_map_entry irq_map[NR_IRQS];
static unsigned int irq_virq_count = NR_IRQS;
static struct irq_host *irq_default_host;
L
Linus Torvalds 已提交
462

463 464 465 466 467 468
irq_hw_number_t virq_to_hw(unsigned int virq)
{
	return irq_map[virq].hwirq;
}
EXPORT_SYMBOL_GPL(virq_to_hw);

469 470 471 472 473
static int default_irq_host_match(struct irq_host *h, struct device_node *np)
{
	return h->of_node != NULL && h->of_node == np;
}

474
struct irq_host *irq_alloc_host(struct device_node *of_node,
475 476 477 478
				unsigned int revmap_type,
				unsigned int revmap_arg,
				struct irq_host_ops *ops,
				irq_hw_number_t inval_irq)
L
Linus Torvalds 已提交
479
{
480 481 482 483 484 485 486 487 488
	struct irq_host *host;
	unsigned int size = sizeof(struct irq_host);
	unsigned int i;
	unsigned int *rmap;
	unsigned long flags;

	/* Allocate structure and revmap table if using linear mapping */
	if (revmap_type == IRQ_HOST_MAP_LINEAR)
		size += revmap_arg * sizeof(unsigned int);
489
	host = zalloc_maybe_bootmem(size, GFP_KERNEL);
490 491
	if (host == NULL)
		return NULL;
492

493 494 495 496
	/* Fill structure */
	host->revmap_type = revmap_type;
	host->inval_irq = inval_irq;
	host->ops = ops;
497
	host->of_node = of_node_get(of_node);
498

499 500
	if (host->ops->match == NULL)
		host->ops->match = default_irq_host_match;
501

502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
	spin_lock_irqsave(&irq_big_lock, flags);

	/* If it's a legacy controller, check for duplicates and
	 * mark it as allocated (we use irq 0 host pointer for that
	 */
	if (revmap_type == IRQ_HOST_MAP_LEGACY) {
		if (irq_map[0].host != NULL) {
			spin_unlock_irqrestore(&irq_big_lock, flags);
			/* If we are early boot, we can't free the structure,
			 * too bad...
			 * this will be fixed once slab is made available early
			 * instead of the current cruft
			 */
			if (mem_init_done)
				kfree(host);
			return NULL;
		}
		irq_map[0].host = host;
	}

	list_add(&host->link, &irq_hosts);
	spin_unlock_irqrestore(&irq_big_lock, flags);

	/* Additional setups per revmap type */
	switch(revmap_type) {
	case IRQ_HOST_MAP_LEGACY:
		/* 0 is always the invalid number for legacy */
		host->inval_irq = 0;
		/* setup us as the host for all legacy interrupts */
		for (i = 1; i < NUM_ISA_INTERRUPTS; i++) {
532
			irq_map[i].hwirq = i;
533 534 535 536
			smp_wmb();
			irq_map[i].host = host;
			smp_wmb();

537 538
			/* Clear norequest flags */
			get_irq_desc(i)->status &= ~IRQ_NOREQUEST;
539 540 541

			/* Legacy flags are left to default at this point,
			 * one can then use irq_create_mapping() to
J
Jean Delvare 已提交
542
			 * explicitly change them
543
			 */
544
			ops->map(host, i, i);
545 546 547 548 549
		}
		break;
	case IRQ_HOST_MAP_LINEAR:
		rmap = (unsigned int *)(host + 1);
		for (i = 0; i < revmap_arg; i++)
550
			rmap[i] = NO_IRQ;
551 552 553 554 555 556 557 558 559 560 561
		host->revmap_data.linear.size = revmap_arg;
		smp_wmb();
		host->revmap_data.linear.revmap = rmap;
		break;
	default:
		break;
	}

	pr_debug("irq: Allocated host of type %d @0x%p\n", revmap_type, host);

	return host;
L
Linus Torvalds 已提交
562 563
}

564
struct irq_host *irq_find_host(struct device_node *node)
L
Linus Torvalds 已提交
565
{
566 567 568 569 570 571 572 573 574 575
	struct irq_host *h, *found = NULL;
	unsigned long flags;

	/* We might want to match the legacy controller last since
	 * it might potentially be set to match all interrupts in
	 * the absence of a device node. This isn't a problem so far
	 * yet though...
	 */
	spin_lock_irqsave(&irq_big_lock, flags);
	list_for_each_entry(h, &irq_hosts, link)
576
		if (h->ops->match(h, node)) {
577 578 579 580 581 582 583 584 585 586 587
			found = h;
			break;
		}
	spin_unlock_irqrestore(&irq_big_lock, flags);
	return found;
}
EXPORT_SYMBOL_GPL(irq_find_host);

void irq_set_default_host(struct irq_host *host)
{
	pr_debug("irq: Default host set to @0x%p\n", host);
L
Linus Torvalds 已提交
588

589 590
	irq_default_host = host;
}
L
Linus Torvalds 已提交
591

592 593 594
void irq_set_virq_count(unsigned int count)
{
	pr_debug("irq: Trying to set virq count to %d\n", count);
595

596 597 598 599 600
	BUG_ON(count < NUM_ISA_INTERRUPTS);
	if (count < NR_IRQS)
		irq_virq_count = count;
}

601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619
static int irq_setup_virq(struct irq_host *host, unsigned int virq,
			    irq_hw_number_t hwirq)
{
	/* Clear IRQ_NOREQUEST flag */
	get_irq_desc(virq)->status &= ~IRQ_NOREQUEST;

	/* map it */
	smp_wmb();
	irq_map[virq].hwirq = hwirq;
	smp_mb();

	if (host->ops->map(host, virq, hwirq)) {
		pr_debug("irq: -> mapping failed, freeing\n");
		irq_free_virt(virq, 1);
		return -1;
	}

	return 0;
}
620

621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644
unsigned int irq_create_direct_mapping(struct irq_host *host)
{
	unsigned int virq;

	if (host == NULL)
		host = irq_default_host;

	BUG_ON(host == NULL);
	WARN_ON(host->revmap_type != IRQ_HOST_MAP_NOMAP);

	virq = irq_alloc_virt(host, 1, 0);
	if (virq == NO_IRQ) {
		pr_debug("irq: create_direct virq allocation failed\n");
		return NO_IRQ;
	}

	pr_debug("irq: create_direct obtained virq %d\n", virq);

	if (irq_setup_virq(host, virq, virq))
		return NO_IRQ;

	return virq;
}

645
unsigned int irq_create_mapping(struct irq_host *host,
646
				irq_hw_number_t hwirq)
647 648 649
{
	unsigned int virq, hint;

650
	pr_debug("irq: irq_create_mapping(0x%p, 0x%lx)\n", host, hwirq);
651 652 653 654 655 656 657 658 659

	/* Look for default host if nececssary */
	if (host == NULL)
		host = irq_default_host;
	if (host == NULL) {
		printk(KERN_WARNING "irq_create_mapping called for"
		       " NULL host, hwirq=%lx\n", hwirq);
		WARN_ON(1);
		return NO_IRQ;
L
Linus Torvalds 已提交
660
	}
661
	pr_debug("irq: -> using host @%p\n", host);
L
Linus Torvalds 已提交
662

663 664 665 666
	/* Check if mapping already exist, if it does, call
	 * host->ops->map() to update the flags
	 */
	virq = irq_find_mapping(host, hwirq);
667
	if (virq != NO_IRQ) {
I
Ishizaki Kou 已提交
668 669
		if (host->ops->remap)
			host->ops->remap(host, virq, hwirq);
670 671
		pr_debug("irq: -> existing mapping on virq %d\n", virq);
		return virq;
L
Linus Torvalds 已提交
672 673
	}

674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690
	/* Get a virtual interrupt number */
	if (host->revmap_type == IRQ_HOST_MAP_LEGACY) {
		/* Handle legacy */
		virq = (unsigned int)hwirq;
		if (virq == 0 || virq >= NUM_ISA_INTERRUPTS)
			return NO_IRQ;
		return virq;
	} else {
		/* Allocate a virtual interrupt number */
		hint = hwirq % irq_virq_count;
		virq = irq_alloc_virt(host, 1, hint);
		if (virq == NO_IRQ) {
			pr_debug("irq: -> virq allocation failed\n");
			return NO_IRQ;
		}
	}

691
	if (irq_setup_virq(host, virq, hwirq))
692
		return NO_IRQ;
693

694 695 696
	printk(KERN_DEBUG "irq: irq %lu on host %s mapped to virtual irq %u\n",
		hwirq, host->of_node ? host->of_node->full_name : "null", virq);

L
Linus Torvalds 已提交
697
	return virq;
698 699 700
}
EXPORT_SYMBOL_GPL(irq_create_mapping);

701 702
unsigned int irq_create_of_mapping(struct device_node *controller,
				   u32 *intspec, unsigned int intsize)
703 704 705
{
	struct irq_host *host;
	irq_hw_number_t hwirq;
706 707
	unsigned int type = IRQ_TYPE_NONE;
	unsigned int virq;
L
Linus Torvalds 已提交
708

709 710 711 712
	if (controller == NULL)
		host = irq_default_host;
	else
		host = irq_find_host(controller);
713 714 715
	if (host == NULL) {
		printk(KERN_WARNING "irq: no irq host found for %s !\n",
		       controller->full_name);
716
		return NO_IRQ;
717
	}
718 719 720 721 722 723

	/* If host has no translation, then we assume interrupt line */
	if (host->ops->xlate == NULL)
		hwirq = intspec[0];
	else {
		if (host->ops->xlate(host, controller, intspec, intsize,
724
				     &hwirq, &type))
725
			return NO_IRQ;
L
Linus Torvalds 已提交
726
	}
727

728 729 730 731 732 733 734 735 736 737
	/* Create mapping */
	virq = irq_create_mapping(host, hwirq);
	if (virq == NO_IRQ)
		return virq;

	/* Set type if specified and different than the current one */
	if (type != IRQ_TYPE_NONE &&
	    type != (get_irq_desc(virq)->status & IRQF_TRIGGER_MASK))
		set_irq_type(virq, type);
	return virq;
L
Linus Torvalds 已提交
738
}
739
EXPORT_SYMBOL_GPL(irq_create_of_mapping);
L
Linus Torvalds 已提交
740

741
unsigned int irq_of_parse_and_map(struct device_node *dev, int index)
L
Linus Torvalds 已提交
742
{
743
	struct of_irq oirq;
L
Linus Torvalds 已提交
744

745 746
	if (of_irq_map_one(dev, index, &oirq))
		return NO_IRQ;
L
Linus Torvalds 已提交
747

748 749 750 751
	return irq_create_of_mapping(oirq.controller, oirq.specifier,
				     oirq.size);
}
EXPORT_SYMBOL_GPL(irq_of_parse_and_map);
L
Linus Torvalds 已提交
752

753 754
void irq_dispose_mapping(unsigned int virq)
{
755
	struct irq_host *host;
756
	irq_hw_number_t hwirq;
L
Linus Torvalds 已提交
757

758 759 760 761
	if (virq == NO_IRQ)
		return;

	host = irq_map[virq].host;
762 763 764
	WARN_ON (host == NULL);
	if (host == NULL)
		return;
L
Linus Torvalds 已提交
765

766 767 768
	/* Never unmap legacy interrupts */
	if (host->revmap_type == IRQ_HOST_MAP_LEGACY)
		return;
L
Linus Torvalds 已提交
769

770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785
	/* remove chip and handler */
	set_irq_chip_and_handler(virq, NULL, NULL);

	/* Make sure it's completed */
	synchronize_irq(virq);

	/* Tell the PIC about it */
	if (host->ops->unmap)
		host->ops->unmap(host, virq);
	smp_mb();

	/* Clear reverse map */
	hwirq = irq_map[virq].hwirq;
	switch(host->revmap_type) {
	case IRQ_HOST_MAP_LINEAR:
		if (hwirq < host->revmap_data.linear.size)
786
			host->revmap_data.linear.revmap[hwirq] = NO_IRQ;
787 788
		break;
	case IRQ_HOST_MAP_TREE:
789 790 791 792 793 794
		/*
		 * Check if radix tree allocated yet, if not then nothing to
		 * remove.
		 */
		smp_rmb();
		if (revmap_trees_allocated < 1)
795
			break;
796
		mutex_lock(&revmap_trees_mutex);
797
		radix_tree_delete(&host->revmap_data.tree, hwirq);
798
		mutex_unlock(&revmap_trees_mutex);
799 800
		break;
	}
L
Linus Torvalds 已提交
801

802 803 804
	/* Destroy map */
	smp_mb();
	irq_map[virq].hwirq = host->inval_irq;
L
Linus Torvalds 已提交
805

806 807
	/* Set some flags */
	get_irq_desc(virq)->status |= IRQ_NOREQUEST;
L
Linus Torvalds 已提交
808

809 810
	/* Free it */
	irq_free_virt(virq, 1);
L
Linus Torvalds 已提交
811
}
812
EXPORT_SYMBOL_GPL(irq_dispose_mapping);
L
Linus Torvalds 已提交
813

814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844
unsigned int irq_find_mapping(struct irq_host *host,
			      irq_hw_number_t hwirq)
{
	unsigned int i;
	unsigned int hint = hwirq % irq_virq_count;

	/* Look for default host if nececssary */
	if (host == NULL)
		host = irq_default_host;
	if (host == NULL)
		return NO_IRQ;

	/* legacy -> bail early */
	if (host->revmap_type == IRQ_HOST_MAP_LEGACY)
		return hwirq;

	/* Slow path does a linear search of the map */
	if (hint < NUM_ISA_INTERRUPTS)
		hint = NUM_ISA_INTERRUPTS;
	i = hint;
	do  {
		if (irq_map[i].host == host &&
		    irq_map[i].hwirq == hwirq)
			return i;
		i++;
		if (i >= irq_virq_count)
			i = NUM_ISA_INTERRUPTS;
	} while(i != hint);
	return NO_IRQ;
}
EXPORT_SYMBOL_GPL(irq_find_mapping);
L
Linus Torvalds 已提交
845

846

847 848
unsigned int irq_radix_revmap_lookup(struct irq_host *host,
				     irq_hw_number_t hwirq)
L
Linus Torvalds 已提交
849
{
850 851
	struct irq_map_entry *ptr;
	unsigned int virq;
L
Linus Torvalds 已提交
852

853
	WARN_ON(host->revmap_type != IRQ_HOST_MAP_TREE);
L
Linus Torvalds 已提交
854

855 856 857
	/*
	 * Check if the radix tree exists and has bee initialized.
	 * If not, we fallback to slow mode
858
	 */
859
	if (revmap_trees_allocated < 2)
860 861 862
		return irq_find_mapping(host, hwirq);

	/* Now try to resolve */
863 864 865 866
	/*
	 * No rcu_read_lock(ing) needed, the ptr returned can't go under us
	 * as it's referencing an entry in the static irq_map table.
	 */
867
	ptr = radix_tree_lookup(&host->revmap_data.tree, hwirq);
868

869 870 871 872 873 874
	/*
	 * If found in radix tree, then fine.
	 * Else fallback to linear lookup - this should not happen in practice
	 * as it means that we failed to insert the node in the radix tree.
	 */
	if (ptr)
875
		virq = ptr - irq_map;
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895
	else
		virq = irq_find_mapping(host, hwirq);

	return virq;
}

void irq_radix_revmap_insert(struct irq_host *host, unsigned int virq,
			     irq_hw_number_t hwirq)
{

	WARN_ON(host->revmap_type != IRQ_HOST_MAP_TREE);

	/*
	 * Check if the radix tree exists yet.
	 * If not, then the irq will be inserted into the tree when it gets
	 * initialized.
	 */
	smp_rmb();
	if (revmap_trees_allocated < 1)
		return;
896

897
	if (virq != NO_IRQ) {
898
		mutex_lock(&revmap_trees_mutex);
899 900
		radix_tree_insert(&host->revmap_data.tree, hwirq,
				  &irq_map[virq]);
901
		mutex_unlock(&revmap_trees_mutex);
902
	}
L
Linus Torvalds 已提交
903 904
}

905 906
unsigned int irq_linear_revmap(struct irq_host *host,
			       irq_hw_number_t hwirq)
907
{
908
	unsigned int *revmap;
909

910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925
	WARN_ON(host->revmap_type != IRQ_HOST_MAP_LINEAR);

	/* Check revmap bounds */
	if (unlikely(hwirq >= host->revmap_data.linear.size))
		return irq_find_mapping(host, hwirq);

	/* Check if revmap was allocated */
	revmap = host->revmap_data.linear.revmap;
	if (unlikely(revmap == NULL))
		return irq_find_mapping(host, hwirq);

	/* Fill up revmap with slow path if no mapping found */
	if (unlikely(revmap[hwirq] == NO_IRQ))
		revmap[hwirq] = irq_find_mapping(host, hwirq);

	return revmap[hwirq];
926 927
}

928 929 930 931 932 933
unsigned int irq_alloc_virt(struct irq_host *host,
			    unsigned int count,
			    unsigned int hint)
{
	unsigned long flags;
	unsigned int i, j, found = NO_IRQ;
934

935 936 937 938 939 940 941 942 943 944 945 946 947 948 949
	if (count == 0 || count > (irq_virq_count - NUM_ISA_INTERRUPTS))
		return NO_IRQ;

	spin_lock_irqsave(&irq_big_lock, flags);

	/* Use hint for 1 interrupt if any */
	if (count == 1 && hint >= NUM_ISA_INTERRUPTS &&
	    hint < irq_virq_count && irq_map[hint].host == NULL) {
		found = hint;
		goto hint_found;
	}

	/* Look for count consecutive numbers in the allocatable
	 * (non-legacy) space
	 */
950 951 952 953 954 955 956 957 958 959
	for (i = NUM_ISA_INTERRUPTS, j = 0; i < irq_virq_count; i++) {
		if (irq_map[i].host != NULL)
			j = 0;
		else
			j++;

		if (j == count) {
			found = i - count + 1;
			break;
		}
960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975
	}
	if (found == NO_IRQ) {
		spin_unlock_irqrestore(&irq_big_lock, flags);
		return NO_IRQ;
	}
 hint_found:
	for (i = found; i < (found + count); i++) {
		irq_map[i].hwirq = host->inval_irq;
		smp_wmb();
		irq_map[i].host = host;
	}
	spin_unlock_irqrestore(&irq_big_lock, flags);
	return found;
}

void irq_free_virt(unsigned int virq, unsigned int count)
L
Linus Torvalds 已提交
976 977
{
	unsigned long flags;
978
	unsigned int i;
L
Linus Torvalds 已提交
979

980 981
	WARN_ON (virq < NUM_ISA_INTERRUPTS);
	WARN_ON (count == 0 || (virq + count) > irq_virq_count);
L
Linus Torvalds 已提交
982

983 984 985
	spin_lock_irqsave(&irq_big_lock, flags);
	for (i = virq; i < (virq + count); i++) {
		struct irq_host *host;
L
Linus Torvalds 已提交
986

987 988 989
		if (i < NUM_ISA_INTERRUPTS ||
		    (virq + count) > irq_virq_count)
			continue;
L
Linus Torvalds 已提交
990

991 992 993 994 995 996
		host = irq_map[i].host;
		irq_map[i].hwirq = host->inval_irq;
		smp_wmb();
		irq_map[i].host = NULL;
	}
	spin_unlock_irqrestore(&irq_big_lock, flags);
L
Linus Torvalds 已提交
997
}
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010

void irq_early_init(void)
{
	unsigned int i;

	for (i = 0; i < NR_IRQS; i++)
		get_irq_desc(i)->status |= IRQ_NOREQUEST;
}

/* We need to create the radix trees late */
static int irq_late_init(void)
{
	struct irq_host *h;
1011
	unsigned int i;
1012

1013 1014 1015 1016 1017
	/*
	 * No mutual exclusion with respect to accessors of the tree is needed
	 * here as the synchronization is done via the state variable
	 * revmap_trees_allocated.
	 */
1018 1019
	list_for_each_entry(h, &irq_hosts, link) {
		if (h->revmap_type == IRQ_HOST_MAP_TREE)
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
			INIT_RADIX_TREE(&h->revmap_data.tree, GFP_KERNEL);
	}

	/*
	 * Make sure the radix trees inits are visible before setting
	 * the flag
	 */
	smp_wmb();
	revmap_trees_allocated = 1;

	/*
	 * Insert the reverse mapping for those interrupts already present
	 * in irq_map[].
	 */
1034
	mutex_lock(&revmap_trees_mutex);
1035 1036 1037 1038 1039
	for (i = 0; i < irq_virq_count; i++) {
		if (irq_map[i].host &&
		    (irq_map[i].host->revmap_type == IRQ_HOST_MAP_TREE))
			radix_tree_insert(&irq_map[i].host->revmap_data.tree,
					  irq_map[i].hwirq, &irq_map[i]);
1040
	}
1041
	mutex_unlock(&revmap_trees_mutex);
1042

1043 1044 1045 1046 1047 1048 1049
	/*
	 * Make sure the radix trees insertions are visible before setting
	 * the flag
	 */
	smp_wmb();
	revmap_trees_allocated = 2;

1050 1051 1052 1053
	return 0;
}
arch_initcall(irq_late_init);

1054 1055 1056 1057
#ifdef CONFIG_VIRQ_DEBUG
static int virq_debug_show(struct seq_file *m, void *private)
{
	unsigned long flags;
1058
	struct irq_desc *desc;
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107
	const char *p;
	char none[] = "none";
	int i;

	seq_printf(m, "%-5s  %-7s  %-15s  %s\n", "virq", "hwirq",
		      "chip name", "host name");

	for (i = 1; i < NR_IRQS; i++) {
		desc = get_irq_desc(i);
		spin_lock_irqsave(&desc->lock, flags);

		if (desc->action && desc->action->handler) {
			seq_printf(m, "%5d  ", i);
			seq_printf(m, "0x%05lx  ", virq_to_hw(i));

			if (desc->chip && desc->chip->typename)
				p = desc->chip->typename;
			else
				p = none;
			seq_printf(m, "%-15s  ", p);

			if (irq_map[i].host && irq_map[i].host->of_node)
				p = irq_map[i].host->of_node->full_name;
			else
				p = none;
			seq_printf(m, "%s\n", p);
		}

		spin_unlock_irqrestore(&desc->lock, flags);
	}

	return 0;
}

static int virq_debug_open(struct inode *inode, struct file *file)
{
	return single_open(file, virq_debug_show, inode->i_private);
}

static const struct file_operations virq_debug_fops = {
	.open = virq_debug_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
};

static int __init irq_debugfs_init(void)
{
	if (debugfs_create_file("virq_mapping", S_IRUGO, powerpc_debugfs_root,
1108
				 NULL, &virq_debug_fops) == NULL)
1109 1110 1111 1112 1113 1114 1115
		return -ENOMEM;

	return 0;
}
__initcall(irq_debugfs_init);
#endif /* CONFIG_VIRQ_DEBUG */

1116
#ifdef CONFIG_PPC64
L
Linus Torvalds 已提交
1117 1118 1119 1120 1121 1122 1123
static int __init setup_noirqdistrib(char *str)
{
	distribute_irqs = 0;
	return 1;
}

__setup("noirqdistrib", setup_noirqdistrib);
S
Stephen Rothwell 已提交
1124
#endif /* CONFIG_PPC64 */