irq.c 19.0 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

33
#include <linux/export.h>
L
Linus Torvalds 已提交
34 35 36 37
#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
#include <linux/list.h>
#include <linux/radix-tree.h>
#include <linux/mutex.h>
J
Jake Moilanen 已提交
53
#include <linux/pci.h>
54
#include <linux/debugfs.h>
55 56
#include <linux/of.h>
#include <linux/of_irq.h>
L
Linus Torvalds 已提交
57

58
#include <linux/uaccess.h>
L
Linus Torvalds 已提交
59 60 61 62 63 64 65
#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>
66
#include <asm/udbg.h>
67
#include <asm/smp.h>
68
#include <asm/livepatch.h>
69
#include <asm/asm-prototypes.h>
70

71
#ifdef CONFIG_PPC64
L
Linus Torvalds 已提交
72
#include <asm/paca.h>
73
#include <asm/firmware.h>
74
#include <asm/lv1call.h>
S
Stephen Rothwell 已提交
75
#endif
76 77
#define CREATE_TRACE_POINTS
#include <asm/trace.h>
78
#include <asm/cpu_has_feature.h>
L
Linus Torvalds 已提交
79

80 81 82
DEFINE_PER_CPU_SHARED_ALIGNED(irq_cpustat_t, irq_stat);
EXPORT_PER_CPU_SYMBOL(irq_stat);

83
int __irq_offset_value;
S
Stephen Rothwell 已提交
84 85

#ifdef CONFIG_PPC32
86 87
EXPORT_SYMBOL(__irq_offset_value);
atomic_t ppc_n_lost_interrupts;
S
Stephen Rothwell 已提交
88 89 90 91 92

#ifdef CONFIG_TAU_INT
extern int tau_initialized;
extern int tau_interrupts(int);
#endif
93
#endif /* CONFIG_PPC32 */
S
Stephen Rothwell 已提交
94 95

#ifdef CONFIG_PPC64
96

L
Linus Torvalds 已提交
97
int distribute_irqs = 1;
98

99
static inline notrace unsigned long get_irq_happened(void)
100
{
101
	unsigned long happened;
102 103

	__asm__ __volatile__("lbz %0,%1(13)"
104
	: "=r" (happened) : "i" (offsetof(struct paca_struct, irq_happened)));
105

106
	return happened;
107 108
}

S
Steven Rostedt 已提交
109
static inline notrace void set_soft_enabled(unsigned long enable)
110 111 112 113 114
{
	__asm__ __volatile__("stb %0,%1(13)"
	: : "r" (enable), "i" (offsetof(struct paca_struct, soft_enabled)));
}

115
static inline notrace int decrementer_check_overflow(void)
116
{
117
 	u64 now = get_tb_or_rtc();
118
	u64 *next_tb = this_cpu_ptr(&decrementers_next_tb);
119 120
 
	return now >= *next_tb;
121 122
}

123
/* This is called whenever we are re-enabling interrupts
124 125
 * and returns either 0 (nothing to do) or 500/900/280/a00/e80 if
 * there's an EE, DEC or DBELL to generate.
126 127 128 129 130 131 132 133 134 135 136 137
 *
 * This is called in two contexts: From arch_local_irq_restore()
 * before soft-enabling interrupts, and from the exception exit
 * path when returning from an interrupt from a soft-disabled to
 * a soft enabled context. In both case we have interrupts hard
 * disabled.
 *
 * We take care of only clearing the bits we handled in the
 * PACA irq_happened field since we can only re-emit one at a
 * time and we don't want to "lose" one.
 */
notrace unsigned int __check_irq_replay(void)
138
{
139
	/*
140 141 142
	 * We use local_paca rather than get_paca() to avoid all
	 * the debug_smp_processor_id() business in this low level
	 * function
143
	 */
144
	unsigned char happened = local_paca->irq_happened;
145

146 147
	/* Clear bit 0 which we wouldn't clear otherwise */
	local_paca->irq_happened &= ~PACA_IRQ_HARD_DIS;
148 149 150 151 152 153 154 155 156 157 158 159 160
	if (happened & PACA_IRQ_HARD_DIS) {
		/*
		 * We may have missed a decrementer interrupt if hard disabled.
		 * Check the decrementer register in case we had a rollover
		 * while hard disabled.
		 */
		if (!(happened & PACA_IRQ_DEC)) {
			if (decrementer_check_overflow()) {
				local_paca->irq_happened |= PACA_IRQ_DEC;
				happened |= PACA_IRQ_DEC;
			}
		}
	}
161 162 163 164 165 166 167 168

	/*
	 * 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, tmp2;
		lv1_get_version_info(&tmp, &tmp2);
169 170
	}

171 172 173 174 175 176 177 178 179
	/*
	 * Check if an hypervisor Maintenance interrupt happened.
	 * This is a higher priority interrupt than the others, so
	 * replay it first.
	 */
	local_paca->irq_happened &= ~PACA_IRQ_HMI;
	if (happened & PACA_IRQ_HMI)
		return 0xe60;

180
	/*
181 182 183 184 185
	 * We may have missed a decrementer interrupt. We check the
	 * decrementer itself rather than the paca irq_happened field
	 * in case we also had a rollover while hard disabled
	 */
	local_paca->irq_happened &= ~PACA_IRQ_DEC;
186
	if (happened & PACA_IRQ_DEC)
187 188 189 190 191 192 193 194 195 196 197
		return 0x900;

	/* Finally check if an external interrupt happened */
	local_paca->irq_happened &= ~PACA_IRQ_EE;
	if (happened & PACA_IRQ_EE)
		return 0x500;

#ifdef CONFIG_PPC_BOOK3E
	/* Finally check if an EPR external interrupt happened
	 * this bit is typically set if we need to handle another
	 * "edge" interrupt from within the MPIC "EPR" handler
198
	 */
199 200 201 202 203 204 205
	local_paca->irq_happened &= ~PACA_IRQ_EE_EDGE;
	if (happened & PACA_IRQ_EE_EDGE)
		return 0x500;

	local_paca->irq_happened &= ~PACA_IRQ_DBELL;
	if (happened & PACA_IRQ_DBELL)
		return 0x280;
206 207 208 209 210 211 212
#else
	local_paca->irq_happened &= ~PACA_IRQ_DBELL;
	if (happened & PACA_IRQ_DBELL) {
		if (cpu_has_feature(CPU_FTR_HVMODE))
			return 0xe80;
		return 0xa00;
	}
213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
#endif /* CONFIG_PPC_BOOK3E */

	/* There should be nothing left ! */
	BUG_ON(local_paca->irq_happened != 0);

	return 0;
}

notrace void arch_local_irq_restore(unsigned long en)
{
	unsigned char irq_happened;
	unsigned int replay;

	/* Write the new soft-enabled value */
	set_soft_enabled(en);
	if (!en)
		return;
	/*
	 * From this point onward, we can take interrupts, preempt,
	 * etc... unless we got hard-disabled. We check if an event
	 * happened. If none happened, we know we can just return.
	 *
	 * We may have preempted before the check below, in which case
	 * we are checking the "new" CPU instead of the old one. This
	 * is only a problem if an event happened on the "old" CPU.
	 *
239 240
	 * External interrupt events will have caused interrupts to
	 * be hard-disabled, so there is no problem, we
241
	 * cannot have preempted.
242
	 */
243 244
	irq_happened = get_irq_happened();
	if (!irq_happened)
245
		return;
246 247

	/*
248 249 250 251 252 253 254 255 256
	 * We need to hard disable to get a trusted value from
	 * __check_irq_replay(). We also need to soft-disable
	 * again to avoid warnings in there due to the use of
	 * per-cpu variables.
	 *
	 * We know that if the value in irq_happened is exactly 0x01
	 * then we are already hard disabled (there are other less
	 * common cases that we'll ignore for now), so we skip the
	 * (expensive) mtmsrd.
257
	 */
258 259
	if (unlikely(irq_happened != PACA_IRQ_HARD_DIS))
		__hard_irq_disable();
260
#ifdef CONFIG_TRACE_IRQFLAGS
261 262 263 264 265 266 267 268 269 270
	else {
		/*
		 * We should already be hard disabled here. We had bugs
		 * where that wasn't the case so let's dbl check it and
		 * warn if we are wrong. Only do that when IRQ tracing
		 * is enabled as mfmsr() can be costly.
		 */
		if (WARN_ON(mfmsr() & MSR_EE))
			__hard_irq_disable();
	}
271
#endif /* CONFIG_TRACE_IRQFLAGS */
272

273
	set_soft_enabled(0);
274

275
	/*
276 277 278
	 * Check if anything needs to be re-emitted. We haven't
	 * soft-enabled yet to avoid warnings in decrementer_check_overflow
	 * accessing per-cpu variables
279
	 */
280 281 282 283
	replay = __check_irq_replay();

	/* We can soft-enable now */
	set_soft_enabled(1);
284 285

	/*
286 287
	 * And replay if we have to. This will return with interrupts
	 * hard-enabled.
288
	 */
289 290 291
	if (replay) {
		__replay_interrupt(replay);
		return;
292 293
	}

294
	/* Finally, let's ensure we are hard enabled */
295
	__hard_irq_enable();
296
}
D
David Howells 已提交
297
EXPORT_SYMBOL(arch_local_irq_restore);
298 299 300 301 302 303

/*
 * This is specifically called by assembly code to re-enable interrupts
 * if they are currently disabled. This is typically called before
 * schedule() or do_signal() when returning to userspace. We do it
 * in C to avoid the burden of dealing with lockdep etc...
304 305 306
 *
 * NOTE: This is called with interrupts hard disabled but not marked
 * as such in paca->irq_happened, so we need to resync this.
307
 */
308
void notrace restore_interrupts(void)
309
{
310 311
	if (irqs_disabled()) {
		local_paca->irq_happened |= PACA_IRQ_HARD_DIS;
312
		local_irq_enable();
313 314
	} else
		__hard_irq_enable();
315 316
}

317 318 319 320 321 322 323 324 325 326 327 328 329
/*
 * This is a helper to use when about to go into idle low-power
 * when the latter has the side effect of re-enabling interrupts
 * (such as calling H_CEDE under pHyp).
 *
 * You call this function with interrupts soft-disabled (this is
 * already the case when ppc_md.power_save is called). The function
 * will return whether to enter power save or just return.
 *
 * In the former case, it will have notified lockdep of interrupts
 * being re-enabled and generally sanitized the lazy irq state,
 * and in the latter case it will leave with interrupts hard
 * disabled and marked as such, so the local_irq_enable() call
330
 * in arch_cpu_idle() will properly re-enable everything.
331 332 333 334 335 336 337
 */
bool prep_irq_for_idle(void)
{
	/*
	 * First we need to hard disable to ensure no interrupt
	 * occurs before we effectively enter the low power state
	 */
338 339
	__hard_irq_disable();
	local_paca->irq_happened |= PACA_IRQ_HARD_DIS;
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363

	/*
	 * If anything happened while we were soft-disabled,
	 * we return now and do not enter the low power state.
	 */
	if (lazy_irq_pending())
		return false;

	/* Tell lockdep we are about to re-enable */
	trace_hardirqs_on();

	/*
	 * Mark interrupts as soft-enabled and clear the
	 * PACA_IRQ_HARD_DIS from the pending mask since we
	 * are about to hard enable as well as a side effect
	 * of entering the low power state.
	 */
	local_paca->irq_happened &= ~PACA_IRQ_HARD_DIS;
	local_paca->soft_enabled = 1;

	/* Tell the caller to enter the low power state */
	return true;
}

364
#ifdef CONFIG_PPC_BOOK3S
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 393 394
/*
 * This is for idle sequences that return with IRQs off, but the
 * idle state itself wakes on interrupt. Tell the irq tracer that
 * IRQs are enabled for the duration of idle so it does not get long
 * off times. Must be paired with fini_irq_for_idle_irqsoff.
 */
bool prep_irq_for_idle_irqsoff(void)
{
	WARN_ON(!irqs_disabled());

	/*
	 * First we need to hard disable to ensure no interrupt
	 * occurs before we effectively enter the low power state
	 */
	__hard_irq_disable();
	local_paca->irq_happened |= PACA_IRQ_HARD_DIS;

	/*
	 * If anything happened while we were soft-disabled,
	 * we return now and do not enter the low power state.
	 */
	if (lazy_irq_pending())
		return false;

	/* Tell lockdep we are about to re-enable */
	trace_hardirqs_on();

	return true;
}

395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
/*
 * Take the SRR1 wakeup reason, index into this table to find the
 * appropriate irq_happened bit.
 */
static const u8 srr1_to_lazyirq[0x10] = {
	0, 0, 0,
	PACA_IRQ_DBELL,
	0,
	PACA_IRQ_DBELL,
	PACA_IRQ_DEC,
	0,
	PACA_IRQ_EE,
	PACA_IRQ_EE,
	PACA_IRQ_HMI,
	0, 0, 0, 0, 0 };

void irq_set_pending_from_srr1(unsigned long srr1)
{
	unsigned int idx = (srr1 & SRR1_WAKEMASK_P8) >> 18;

	/*
	 * The 0 index (SRR1[42:45]=b0000) must always evaluate to 0,
	 * so this can be called unconditionally with srr1 wake reason.
	 */
	local_paca->irq_happened |= srr1_to_lazyirq[idx];
}
#endif /* CONFIG_PPC_BOOK3S */

423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
/*
 * Force a replay of the external interrupt handler on this CPU.
 */
void force_external_irq_replay(void)
{
	/*
	 * This must only be called with interrupts soft-disabled,
	 * the replay will happen when re-enabling.
	 */
	WARN_ON(!arch_irqs_disabled());

	/* Indicate in the PACA that we have an interrupt to replay */
	local_paca->irq_happened |= PACA_IRQ_EE;
}

S
Stephen Rothwell 已提交
438
#endif /* CONFIG_PPC64 */
L
Linus Torvalds 已提交
439

440
int arch_show_interrupts(struct seq_file *p, int prec)
441 442 443 444 445 446 447 448 449 450 451 452
{
	int j;

#if defined(CONFIG_PPC32) && defined(CONFIG_TAU_INT)
	if (tau_initialized) {
		seq_printf(p, "%*s: ", prec, "TAU");
		for_each_online_cpu(j)
			seq_printf(p, "%10u ", tau_interrupts(j));
		seq_puts(p, "  PowerPC             Thermal Assist (cpu temp)\n");
	}
#endif /* CONFIG_PPC32 && CONFIG_TAU_INT */

453 454
	seq_printf(p, "%*s: ", prec, "LOC");
	for_each_online_cpu(j)
455 456 457 458 459 460 461
		seq_printf(p, "%10u ", per_cpu(irq_stat, j).timer_irqs_event);
        seq_printf(p, "  Local timer interrupts for timer event device\n");

	seq_printf(p, "%*s: ", prec, "LOC");
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", per_cpu(irq_stat, j).timer_irqs_others);
        seq_printf(p, "  Local timer interrupts for others\n");
462

463 464 465 466 467
	seq_printf(p, "%*s: ", prec, "SPU");
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", per_cpu(irq_stat, j).spurious_irqs);
	seq_printf(p, "  Spurious interrupts\n");

468
	seq_printf(p, "%*s: ", prec, "PMI");
469 470 471 472 473 474 475 476 477
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", per_cpu(irq_stat, j).pmu_irqs);
	seq_printf(p, "  Performance monitoring interrupts\n");

	seq_printf(p, "%*s: ", prec, "MCE");
	for_each_online_cpu(j)
		seq_printf(p, "%10u ", per_cpu(irq_stat, j).mce_exceptions);
	seq_printf(p, "  Machine check exceptions\n");

478 479 480 481 482 483 484 485
	if (cpu_has_feature(CPU_FTR_HVMODE)) {
		seq_printf(p, "%*s: ", prec, "HMI");
		for_each_online_cpu(j)
			seq_printf(p, "%10u ",
					per_cpu(irq_stat, j).hmi_exceptions);
		seq_printf(p, "  Hypervisor Maintenance Interrupts\n");
	}

486 487 488 489 490 491 492 493 494
#ifdef CONFIG_PPC_DOORBELL
	if (cpu_has_feature(CPU_FTR_DBELL)) {
		seq_printf(p, "%*s: ", prec, "DBL");
		for_each_online_cpu(j)
			seq_printf(p, "%10u ", per_cpu(irq_stat, j).doorbell_irqs);
		seq_printf(p, "  Doorbell interrupts\n");
	}
#endif

495 496 497
	return 0;
}

498 499 500 501 502
/*
 * /proc/stat helpers
 */
u64 arch_irq_stat_cpu(unsigned int cpu)
{
503
	u64 sum = per_cpu(irq_stat, cpu).timer_irqs_event;
504 505 506

	sum += per_cpu(irq_stat, cpu).pmu_irqs;
	sum += per_cpu(irq_stat, cpu).mce_exceptions;
507
	sum += per_cpu(irq_stat, cpu).spurious_irqs;
508
	sum += per_cpu(irq_stat, cpu).timer_irqs_others;
509
	sum += per_cpu(irq_stat, cpu).hmi_exceptions;
510 511 512
#ifdef CONFIG_PPC_DOORBELL
	sum += per_cpu(irq_stat, cpu).doorbell_irqs;
#endif
513 514 515 516

	return sum;
}

517 518 519 520 521
static inline void check_stack_overflow(void)
{
#ifdef CONFIG_DEBUG_STACKOVERFLOW
	long sp;

522
	sp = current_stack_pointer() & (THREAD_SIZE-1);
523 524 525

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

533
void __do_irq(struct pt_regs *regs)
L
Linus Torvalds 已提交
534
{
535
	unsigned int irq;
L
Linus Torvalds 已提交
536

537
	irq_enter();
L
Linus Torvalds 已提交
538

539 540
	trace_irq_entry(regs);

541
	check_stack_overflow();
L
Linus Torvalds 已提交
542

543 544 545 546 547
	/*
	 * Query the platform PIC for the interrupt & ack it.
	 *
	 * This will typically lower the interrupt line to the CPU
	 */
O
Olaf Hering 已提交
548
	irq = ppc_md.get_irq();
L
Linus Torvalds 已提交
549

550
	/* We can hard enable interrupts now to allow perf interrupts */
551 552 553
	may_hard_irq_enable();

	/* And finally process it */
554
	if (unlikely(!irq))
555
		__this_cpu_inc(irq_stat.spurious_irqs);
556
	else
557
		generic_handle_irq(irq);
558

559 560
	trace_irq_exit(regs);

561
	irq_exit();
562 563 564 565 566
}

void do_IRQ(struct pt_regs *regs)
{
	struct pt_regs *old_regs = set_irq_regs(regs);
567
	struct thread_info *curtp, *irqtp, *sirqtp;
568 569 570 571

	/* Switch to the irq stack to handle this */
	curtp = current_thread_info();
	irqtp = hardirq_ctx[raw_smp_processor_id()];
572
	sirqtp = softirq_ctx[raw_smp_processor_id()];
573 574

	/* Already there ? */
575
	if (unlikely(curtp == irqtp || curtp == sirqtp)) {
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
		__do_irq(regs);
		set_irq_regs(old_regs);
		return;
	}

	/* Prepare the thread_info in the irq stack */
	irqtp->task = curtp->task;
	irqtp->flags = 0;

	/* Copy the preempt_count so that the [soft]irq checks work. */
	irqtp->preempt_count = curtp->preempt_count;

	/* Switch stack and call */
	call_do_irq(regs, irqtp);

	/* Restore stack limit */
	irqtp->task = NULL;

	/* Copy back updates to the thread_info */
	if (irqtp->flags)
		set_bits(irqtp->flags, &curtp->flags);

598
	set_irq_regs(old_regs);
599
}
L
Linus Torvalds 已提交
600 601 602

void __init init_IRQ(void)
{
603 604
	if (ppc_md.init_IRQ)
		ppc_md.init_IRQ();
605 606 607

	exc_lvl_ctx_init();

L
Linus Torvalds 已提交
608 609 610
	irq_ctx_init();
}

611 612 613 614 615 616 617 618
#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;
619
	int i, cpu_nr;
620 621

	for_each_possible_cpu(i) {
622 623 624
#ifdef CONFIG_PPC64
		cpu_nr = i;
#else
625
#ifdef CONFIG_SMP
626
		cpu_nr = get_hard_smp_processor_id(i);
627 628 629
#else
		cpu_nr = 0;
#endif
630
#endif
631

632 633 634
		memset((void *)critirq_ctx[cpu_nr], 0, THREAD_SIZE);
		tp = critirq_ctx[cpu_nr];
		tp->cpu = cpu_nr;
635 636 637
		tp->preempt_count = 0;

#ifdef CONFIG_BOOKE
638 639 640
		memset((void *)dbgirq_ctx[cpu_nr], 0, THREAD_SIZE);
		tp = dbgirq_ctx[cpu_nr];
		tp->cpu = cpu_nr;
641 642
		tp->preempt_count = 0;

643 644 645
		memset((void *)mcheckirq_ctx[cpu_nr], 0, THREAD_SIZE);
		tp = mcheckirq_ctx[cpu_nr];
		tp->cpu = cpu_nr;
646 647 648 649 650
		tp->preempt_count = HARDIRQ_OFFSET;
#endif
	}
}
#endif
L
Linus Torvalds 已提交
651

652 653
struct thread_info *softirq_ctx[NR_CPUS] __read_mostly;
struct thread_info *hardirq_ctx[NR_CPUS] __read_mostly;
L
Linus Torvalds 已提交
654 655 656 657 658 659

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

660
	for_each_possible_cpu(i) {
L
Linus Torvalds 已提交
661 662 663
		memset((void *)softirq_ctx[i], 0, THREAD_SIZE);
		tp = softirq_ctx[i];
		tp->cpu = i;
664
		klp_init_thread_info(tp);
L
Linus Torvalds 已提交
665 666 667 668

		memset((void *)hardirq_ctx[i], 0, THREAD_SIZE);
		tp = hardirq_ctx[i];
		tp->cpu = i;
669
		klp_init_thread_info(tp);
L
Linus Torvalds 已提交
670 671 672
	}
}

673
void do_softirq_own_stack(void)
674 675 676 677 678 679
{
	struct thread_info *curtp, *irqtp;

	curtp = current_thread_info();
	irqtp = softirq_ctx[smp_processor_id()];
	irqtp->task = curtp->task;
680
	irqtp->flags = 0;
681 682
	call_do_softirq(irqtp);
	irqtp->task = NULL;
683 684 685 686 687 688

	/* Set any flag that may have been set on the
	 * alternate stack
	 */
	if (irqtp->flags)
		set_bits(irqtp->flags, &curtp->flags);
689
}
L
Linus Torvalds 已提交
690

691 692
irq_hw_number_t virq_to_hw(unsigned int virq)
{
693 694
	struct irq_data *irq_data = irq_get_irq_data(virq);
	return WARN_ON(!irq_data) ? 0 : irq_data->hwirq;
695 696 697
}
EXPORT_SYMBOL_GPL(virq_to_hw);

698 699 700 701 702
#ifdef CONFIG_SMP
int irq_choose_cpu(const struct cpumask *mask)
{
	int cpuid;

K
Kim Phillips 已提交
703
	if (cpumask_equal(mask, cpu_online_mask)) {
704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732
		static int irq_rover;
		static DEFINE_RAW_SPINLOCK(irq_rover_lock);
		unsigned long flags;

		/* Round-robin distribution... */
do_round_robin:
		raw_spin_lock_irqsave(&irq_rover_lock, flags);

		irq_rover = cpumask_next(irq_rover, cpu_online_mask);
		if (irq_rover >= nr_cpu_ids)
			irq_rover = cpumask_first(cpu_online_mask);

		cpuid = irq_rover;

		raw_spin_unlock_irqrestore(&irq_rover_lock, flags);
	} else {
		cpuid = cpumask_first_and(mask, cpu_online_mask);
		if (cpuid >= nr_cpu_ids)
			goto do_round_robin;
	}

	return get_hard_smp_processor_id(cpuid);
}
#else
int irq_choose_cpu(const struct cpumask *mask)
{
	return hard_smp_processor_id();
}
#endif
733

734
int arch_early_irq_init(void)
735
{
736
	return 0;
737 738
}

739
#ifdef CONFIG_PPC64
L
Linus Torvalds 已提交
740 741 742 743 744 745 746
static int __init setup_noirqdistrib(char *str)
{
	distribute_irqs = 0;
	return 1;
}

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