manage.c 29.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 * linux/kernel/irq/manage.c
 *
I
Ingo Molnar 已提交
4 5
 * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
 * Copyright (C) 2005-2006 Thomas Gleixner
L
Linus Torvalds 已提交
6 7 8 9 10
 *
 * This file contains driver APIs to the irq subsystem.
 */

#include <linux/irq.h>
11
#include <linux/kthread.h>
L
Linus Torvalds 已提交
12 13 14
#include <linux/module.h>
#include <linux/random.h>
#include <linux/interrupt.h>
15
#include <linux/slab.h>
16
#include <linux/sched.h>
L
Linus Torvalds 已提交
17 18 19 20 21

#include "internals.h"

/**
 *	synchronize_irq - wait for pending IRQ handlers (on other CPUs)
22
 *	@irq: interrupt number to wait for
L
Linus Torvalds 已提交
23 24 25 26 27 28 29 30 31
 *
 *	This function waits for any pending IRQ handlers for this interrupt
 *	to complete before returning. If you use this function while
 *	holding a resource the IRQ handler may need you will deadlock.
 *
 *	This function may be called - with care - from IRQ context.
 */
void synchronize_irq(unsigned int irq)
{
32
	struct irq_desc *desc = irq_to_desc(irq);
33
	unsigned int status;
L
Linus Torvalds 已提交
34

35
	if (!desc)
36 37
		return;

38 39 40 41 42 43 44 45 46 47 48
	do {
		unsigned long flags;

		/*
		 * Wait until we're out of the critical section.  This might
		 * give the wrong answer due to the lack of memory barriers.
		 */
		while (desc->status & IRQ_INPROGRESS)
			cpu_relax();

		/* Ok, that indicated we're done: double-check carefully. */
49
		raw_spin_lock_irqsave(&desc->lock, flags);
50
		status = desc->status;
51
		raw_spin_unlock_irqrestore(&desc->lock, flags);
52 53 54

		/* Oops, that failed? */
	} while (status & IRQ_INPROGRESS);
55 56 57 58 59 60

	/*
	 * We made sure that no hardirq handler is running. Now verify
	 * that no threaded handlers are active.
	 */
	wait_event(desc->wait_for_threads, !atomic_read(&desc->threads_active));
L
Linus Torvalds 已提交
61 62 63
}
EXPORT_SYMBOL(synchronize_irq);

64 65 66
#ifdef CONFIG_SMP
cpumask_var_t irq_default_affinity;

67 68 69 70 71 72 73
/**
 *	irq_can_set_affinity - Check if the affinity of a given irq can be set
 *	@irq:		Interrupt to check
 *
 */
int irq_can_set_affinity(unsigned int irq)
{
74
	struct irq_desc *desc = irq_to_desc(irq);
75

76
	if (CHECK_IRQ_PER_CPU(desc->status) || !desc->irq_data.chip ||
77
	    !desc->irq_data.chip->irq_set_affinity)
78 79 80 81 82
		return 0;

	return 1;
}

83 84 85 86 87 88 89 90 91 92
/**
 *	irq_set_thread_affinity - Notify irq threads to adjust affinity
 *	@desc:		irq descriptor which has affitnity changed
 *
 *	We just set IRQTF_AFFINITY and delegate the affinity setting
 *	to the interrupt thread itself. We can not call
 *	set_cpus_allowed_ptr() here as we hold desc->lock and this
 *	code can be called from hard interrupt context.
 */
void irq_set_thread_affinity(struct irq_desc *desc)
93 94 95 96 97
{
	struct irqaction *action = desc->action;

	while (action) {
		if (action->thread)
98
			set_bit(IRQTF_AFFINITY, &action->thread_flags);
99 100 101 102
		action = action->next;
	}
}

103 104 105 106 107 108
/**
 *	irq_set_affinity - Set the irq affinity of a given irq
 *	@irq:		Interrupt to set affinity
 *	@cpumask:	cpumask
 *
 */
109
int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
110
{
111
	struct irq_desc *desc = irq_to_desc(irq);
112
	struct irq_chip *chip = desc->irq_data.chip;
113
	unsigned long flags;
114

115
	if (!chip->irq_set_affinity)
116 117
		return -EINVAL;

118
	raw_spin_lock_irqsave(&desc->lock, flags);
119

120
#ifdef CONFIG_GENERIC_PENDING_IRQ
121
	if (desc->status & IRQ_MOVE_PCNTXT) {
122
		if (!chip->irq_set_affinity(&desc->irq_data, cpumask, false)) {
123
			cpumask_copy(desc->irq_data.affinity, cpumask);
124
			irq_set_thread_affinity(desc);
125 126
		}
	}
127
	else {
128
		desc->status |= IRQ_MOVE_PENDING;
129
		cpumask_copy(desc->pending_mask, cpumask);
130
	}
131
#else
132
	if (!chip->irq_set_affinity(&desc->irq_data, cpumask, false)) {
133
		cpumask_copy(desc->irq_data.affinity, cpumask);
134
		irq_set_thread_affinity(desc);
135
	}
136
#endif
137
	desc->status |= IRQ_AFFINITY_SET;
138
	raw_spin_unlock_irqrestore(&desc->lock, flags);
139 140 141
	return 0;
}

142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
int irq_set_affinity_hint(unsigned int irq, const struct cpumask *m)
{
	struct irq_desc *desc = irq_to_desc(irq);
	unsigned long flags;

	if (!desc)
		return -EINVAL;

	raw_spin_lock_irqsave(&desc->lock, flags);
	desc->affinity_hint = m;
	raw_spin_unlock_irqrestore(&desc->lock, flags);

	return 0;
}
EXPORT_SYMBOL_GPL(irq_set_affinity_hint);

158 159 160 161
#ifndef CONFIG_AUTO_IRQ_AFFINITY
/*
 * Generic version of the affinity autoselector.
 */
162
static int setup_affinity(unsigned int irq, struct irq_desc *desc)
163 164 165 166
{
	if (!irq_can_set_affinity(irq))
		return 0;

167 168 169 170
	/*
	 * Preserve an userspace affinity setup, but make sure that
	 * one of the targets is online.
	 */
171
	if (desc->status & (IRQ_AFFINITY_SET | IRQ_NO_BALANCING)) {
172
		if (cpumask_any_and(desc->irq_data.affinity, cpu_online_mask)
173 174
		    < nr_cpu_ids)
			goto set_affinity;
175 176 177 178
		else
			desc->status &= ~IRQ_AFFINITY_SET;
	}

179
	cpumask_and(desc->irq_data.affinity, cpu_online_mask, irq_default_affinity);
180
set_affinity:
181
	desc->irq_data.chip->irq_set_affinity(&desc->irq_data, desc->irq_data.affinity, false);
182 183 184

	return 0;
}
185
#else
186
static inline int setup_affinity(unsigned int irq, struct irq_desc *d)
187 188 189
{
	return irq_select_affinity(irq);
}
190 191
#endif

192 193 194 195 196 197 198 199 200
/*
 * Called when affinity is set via /proc/irq
 */
int irq_select_affinity_usr(unsigned int irq)
{
	struct irq_desc *desc = irq_to_desc(irq);
	unsigned long flags;
	int ret;

201
	raw_spin_lock_irqsave(&desc->lock, flags);
202
	ret = setup_affinity(irq, desc);
203
	if (!ret)
204
		irq_set_thread_affinity(desc);
205
	raw_spin_unlock_irqrestore(&desc->lock, flags);
206 207 208 209 210

	return ret;
}

#else
211
static inline int setup_affinity(unsigned int irq, struct irq_desc *desc)
212 213 214
{
	return 0;
}
L
Linus Torvalds 已提交
215 216
#endif

217 218 219
void __disable_irq(struct irq_desc *desc, unsigned int irq, bool suspend)
{
	if (suspend) {
220
		if (!desc->action || (desc->action->flags & IRQF_NO_SUSPEND))
221 222 223 224 225 226
			return;
		desc->status |= IRQ_SUSPENDED;
	}

	if (!desc->depth++) {
		desc->status |= IRQ_DISABLED;
227
		desc->irq_data.chip->irq_disable(&desc->irq_data);
228 229 230
	}
}

L
Linus Torvalds 已提交
231 232 233 234 235 236 237 238 239 240 241 242 243
/**
 *	disable_irq_nosync - disable an irq without waiting
 *	@irq: Interrupt to disable
 *
 *	Disable the selected interrupt line.  Disables and Enables are
 *	nested.
 *	Unlike disable_irq(), this function does not ensure existing
 *	instances of the IRQ handler have completed before returning.
 *
 *	This function may be called from IRQ context.
 */
void disable_irq_nosync(unsigned int irq)
{
244
	struct irq_desc *desc = irq_to_desc(irq);
L
Linus Torvalds 已提交
245 246
	unsigned long flags;

247
	if (!desc)
248 249
		return;

250
	chip_bus_lock(desc);
251
	raw_spin_lock_irqsave(&desc->lock, flags);
252
	__disable_irq(desc, irq, false);
253
	raw_spin_unlock_irqrestore(&desc->lock, flags);
254
	chip_bus_sync_unlock(desc);
L
Linus Torvalds 已提交
255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
}
EXPORT_SYMBOL(disable_irq_nosync);

/**
 *	disable_irq - disable an irq and wait for completion
 *	@irq: Interrupt to disable
 *
 *	Disable the selected interrupt line.  Enables and Disables are
 *	nested.
 *	This function waits for any pending IRQ handlers for this interrupt
 *	to complete before returning. If you use this function while
 *	holding a resource the IRQ handler may need you will deadlock.
 *
 *	This function may be called - with care - from IRQ context.
 */
void disable_irq(unsigned int irq)
{
272
	struct irq_desc *desc = irq_to_desc(irq);
L
Linus Torvalds 已提交
273

274
	if (!desc)
275 276
		return;

L
Linus Torvalds 已提交
277 278 279 280 281 282
	disable_irq_nosync(irq);
	if (desc->action)
		synchronize_irq(irq);
}
EXPORT_SYMBOL(disable_irq);

283
void __enable_irq(struct irq_desc *desc, unsigned int irq, bool resume)
284
{
285 286 287
	if (resume)
		desc->status &= ~IRQ_SUSPENDED;

288 289
	switch (desc->depth) {
	case 0:
290
 err_out:
291
		WARN(1, KERN_WARNING "Unbalanced enable for IRQ %d\n", irq);
292 293 294 295
		break;
	case 1: {
		unsigned int status = desc->status & ~IRQ_DISABLED;

296 297
		if (desc->status & IRQ_SUSPENDED)
			goto err_out;
298 299 300 301 302 303 304 305 306 307
		/* Prevent probing on this irq: */
		desc->status = status | IRQ_NOPROBE;
		check_irq_resend(desc, irq);
		/* fall-through */
	}
	default:
		desc->depth--;
	}
}

L
Linus Torvalds 已提交
308 309 310 311 312 313 314 315
/**
 *	enable_irq - enable handling of an irq
 *	@irq: Interrupt to enable
 *
 *	Undoes the effect of one call to disable_irq().  If this
 *	matches the last disable, processing of interrupts on this
 *	IRQ line is re-enabled.
 *
T
Thomas Gleixner 已提交
316
 *	This function may be called from IRQ context only when
317
 *	desc->irq_data.chip->bus_lock and desc->chip->bus_sync_unlock are NULL !
L
Linus Torvalds 已提交
318 319 320
 */
void enable_irq(unsigned int irq)
{
321
	struct irq_desc *desc = irq_to_desc(irq);
L
Linus Torvalds 已提交
322 323
	unsigned long flags;

324
	if (!desc)
325 326
		return;

327 328 329 330
	if (WARN(!desc->irq_data.chip || !desc->irq_data.chip->irq_enable,
	    KERN_ERR "enable_irq before setup/request_irq: irq %u\n", irq))
		return;

331
	chip_bus_lock(desc);
332
	raw_spin_lock_irqsave(&desc->lock, flags);
333
	__enable_irq(desc, irq, false);
334
	raw_spin_unlock_irqrestore(&desc->lock, flags);
335
	chip_bus_sync_unlock(desc);
L
Linus Torvalds 已提交
336 337 338
}
EXPORT_SYMBOL(enable_irq);

D
David Brownell 已提交
339
static int set_irq_wake_real(unsigned int irq, unsigned int on)
340
{
341
	struct irq_desc *desc = irq_to_desc(irq);
342 343
	int ret = -ENXIO;

344 345
	if (desc->irq_data.chip->irq_set_wake)
		ret = desc->irq_data.chip->irq_set_wake(&desc->irq_data, on);
346 347 348 349

	return ret;
}

350 351 352 353 354
/**
 *	set_irq_wake - control irq power management wakeup
 *	@irq:	interrupt to control
 *	@on:	enable/disable power management wakeup
 *
355 356 357 358 359 360
 *	Enable/disable power management wakeup mode, which is
 *	disabled by default.  Enables and disables must match,
 *	just as they match for non-wakeup mode support.
 *
 *	Wakeup mode lets this IRQ wake the system from sleep
 *	states like "suspend to RAM".
361 362 363
 */
int set_irq_wake(unsigned int irq, unsigned int on)
{
364
	struct irq_desc *desc = irq_to_desc(irq);
365
	unsigned long flags;
366
	int ret = 0;
367

368 369 370
	/* wakeup-capable irqs can be shared between drivers that
	 * don't need to have the same sleep mode behaviors.
	 */
371
	raw_spin_lock_irqsave(&desc->lock, flags);
372
	if (on) {
373 374 375 376 377 378 379
		if (desc->wake_depth++ == 0) {
			ret = set_irq_wake_real(irq, on);
			if (ret)
				desc->wake_depth = 0;
			else
				desc->status |= IRQ_WAKEUP;
		}
380 381
	} else {
		if (desc->wake_depth == 0) {
382
			WARN(1, "Unbalanced IRQ %d wake disable\n", irq);
383 384 385 386 387 388 389
		} else if (--desc->wake_depth == 0) {
			ret = set_irq_wake_real(irq, on);
			if (ret)
				desc->wake_depth = 1;
			else
				desc->status &= ~IRQ_WAKEUP;
		}
390
	}
391

392
	raw_spin_unlock_irqrestore(&desc->lock, flags);
393 394 395 396
	return ret;
}
EXPORT_SYMBOL(set_irq_wake);

L
Linus Torvalds 已提交
397 398 399 400 401 402 403
/*
 * Internal function that tells the architecture code whether a
 * particular irq has been exclusively allocated or is available
 * for driver use.
 */
int can_request_irq(unsigned int irq, unsigned long irqflags)
{
404
	struct irq_desc *desc = irq_to_desc(irq);
L
Linus Torvalds 已提交
405
	struct irqaction *action;
406
	unsigned long flags;
L
Linus Torvalds 已提交
407

408 409 410 411
	if (!desc)
		return 0;

	if (desc->status & IRQ_NOREQUEST)
L
Linus Torvalds 已提交
412 413
		return 0;

414
	raw_spin_lock_irqsave(&desc->lock, flags);
415
	action = desc->action;
L
Linus Torvalds 已提交
416
	if (action)
417
		if (irqflags & action->flags & IRQF_SHARED)
L
Linus Torvalds 已提交
418 419
			action = NULL;

420 421
	raw_spin_unlock_irqrestore(&desc->lock, flags);

L
Linus Torvalds 已提交
422 423 424
	return !action;
}

T
Thomas Gleixner 已提交
425 426 427 428 429 430 431 432 433 434 435
void compat_irq_chip_set_default_handler(struct irq_desc *desc)
{
	/*
	 * If the architecture still has not overriden
	 * the flow handler then zap the default. This
	 * should catch incorrect flow-type setting.
	 */
	if (desc->handle_irq == &handle_bad_irq)
		desc->handle_irq = NULL;
}

D
David Brownell 已提交
436
int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
437
		      unsigned long flags)
438 439
{
	int ret;
440
	struct irq_chip *chip = desc->irq_data.chip;
441

442
	if (!chip || !chip->irq_set_type) {
443 444 445 446
		/*
		 * IRQF_TRIGGER_* but the PIC does not support multiple
		 * flow-types?
		 */
447
		pr_debug("No set_type function for IRQ %d (%s)\n", irq,
448 449 450 451
				chip ? (chip->name ? : "unknown") : "unknown");
		return 0;
	}

452
	/* caller masked out all except trigger mode flags */
453
	ret = chip->irq_set_type(&desc->irq_data, flags);
454 455

	if (ret)
456 457
		pr_err("setting trigger mode %lu for irq %u failed (%pF)\n",
		       flags, irq, chip->irq_set_type);
D
David Brownell 已提交
458
	else {
459 460
		if (flags & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
			flags |= IRQ_LEVEL;
D
David Brownell 已提交
461
		/* note that IRQF_TRIGGER_MASK == IRQ_TYPE_SENSE_MASK */
462 463
		desc->status &= ~(IRQ_LEVEL | IRQ_TYPE_SENSE_MASK);
		desc->status |= flags;
464

465 466
		if (chip != desc->irq_data.chip)
			irq_chip_set_defaults(desc->irq_data.chip);
D
David Brownell 已提交
467
	}
468 469 470 471

	return ret;
}

T
Thomas Gleixner 已提交
472 473 474 475 476 477 478 479 480 481
/*
 * Default primary interrupt handler for threaded interrupts. Is
 * assigned as primary handler when request_threaded_irq is called
 * with handler == NULL. Useful for oneshot interrupts.
 */
static irqreturn_t irq_default_primary_handler(int irq, void *dev_id)
{
	return IRQ_WAKE_THREAD;
}

482 483 484 485 486 487 488 489 490 491
/*
 * Primary handler for nested threaded interrupts. Should never be
 * called.
 */
static irqreturn_t irq_nested_primary_handler(int irq, void *dev_id)
{
	WARN(1, "Primary handler called for nested irq %d\n", irq);
	return IRQ_NONE;
}

492 493 494 495
static int irq_wait_for_interrupt(struct irqaction *action)
{
	while (!kthread_should_stop()) {
		set_current_state(TASK_INTERRUPTIBLE);
496 497 498

		if (test_and_clear_bit(IRQTF_RUNTHREAD,
				       &action->thread_flags)) {
499 500
			__set_current_state(TASK_RUNNING);
			return 0;
501 502
		}
		schedule();
503 504 505 506
	}
	return -1;
}

T
Thomas Gleixner 已提交
507 508 509 510 511 512 513
/*
 * Oneshot interrupts keep the irq line masked until the threaded
 * handler finished. unmask if the interrupt has not been disabled and
 * is marked MASKED.
 */
static void irq_finalize_oneshot(unsigned int irq, struct irq_desc *desc)
{
514
again:
515
	chip_bus_lock(desc);
516
	raw_spin_lock_irq(&desc->lock);
517 518 519 520 521 522 523 524 525 526 527 528

	/*
	 * Implausible though it may be we need to protect us against
	 * the following scenario:
	 *
	 * The thread is faster done than the hard interrupt handler
	 * on the other CPU. If we unmask the irq line then the
	 * interrupt can come in again and masks the line, leaves due
	 * to IRQ_INPROGRESS and the irq line is masked forever.
	 */
	if (unlikely(desc->status & IRQ_INPROGRESS)) {
		raw_spin_unlock_irq(&desc->lock);
529
		chip_bus_sync_unlock(desc);
530 531 532 533
		cpu_relax();
		goto again;
	}

T
Thomas Gleixner 已提交
534 535
	if (!(desc->status & IRQ_DISABLED) && (desc->status & IRQ_MASKED)) {
		desc->status &= ~IRQ_MASKED;
536
		desc->irq_data.chip->irq_unmask(&desc->irq_data);
T
Thomas Gleixner 已提交
537
	}
538
	raw_spin_unlock_irq(&desc->lock);
539
	chip_bus_sync_unlock(desc);
T
Thomas Gleixner 已提交
540 541
}

542
#ifdef CONFIG_SMP
543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
/*
 * Check whether we need to change the affinity of the interrupt thread.
 */
static void
irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action)
{
	cpumask_var_t mask;

	if (!test_and_clear_bit(IRQTF_AFFINITY, &action->thread_flags))
		return;

	/*
	 * In case we are out of memory we set IRQTF_AFFINITY again and
	 * try again next time
	 */
	if (!alloc_cpumask_var(&mask, GFP_KERNEL)) {
		set_bit(IRQTF_AFFINITY, &action->thread_flags);
		return;
	}

563
	raw_spin_lock_irq(&desc->lock);
564
	cpumask_copy(mask, desc->irq_data.affinity);
565
	raw_spin_unlock_irq(&desc->lock);
566 567 568 569

	set_cpus_allowed_ptr(current, mask);
	free_cpumask_var(mask);
}
570 571 572 573
#else
static inline void
irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action) { }
#endif
574

575 576 577 578 579
/*
 * Interrupt handler thread
 */
static int irq_thread(void *data)
{
580 581 582
	static struct sched_param param = {
		.sched_priority = MAX_USER_RT_PRIO/2,
	};
583 584
	struct irqaction *action = data;
	struct irq_desc *desc = irq_to_desc(action->irq);
T
Thomas Gleixner 已提交
585
	int wake, oneshot = desc->status & IRQ_ONESHOT;
586 587 588 589 590 591

	sched_setscheduler(current, SCHED_FIFO, &param);
	current->irqaction = action;

	while (!irq_wait_for_interrupt(action)) {

592 593
		irq_thread_check_affinity(desc, action);

594 595
		atomic_inc(&desc->threads_active);

596
		raw_spin_lock_irq(&desc->lock);
597 598 599 600 601 602 603 604 605
		if (unlikely(desc->status & IRQ_DISABLED)) {
			/*
			 * CHECKME: We might need a dedicated
			 * IRQ_THREAD_PENDING flag here, which
			 * retriggers the thread in check_irq_resend()
			 * but AFAICT IRQ_PENDING should be fine as it
			 * retriggers the interrupt itself --- tglx
			 */
			desc->status |= IRQ_PENDING;
606
			raw_spin_unlock_irq(&desc->lock);
607
		} else {
608
			raw_spin_unlock_irq(&desc->lock);
609 610

			action->thread_fn(action->irq, action->dev_id);
T
Thomas Gleixner 已提交
611 612 613

			if (oneshot)
				irq_finalize_oneshot(action->irq, desc);
614 615 616 617 618 619 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 645 646 647 648 649 650
		}

		wake = atomic_dec_and_test(&desc->threads_active);

		if (wake && waitqueue_active(&desc->wait_for_threads))
			wake_up(&desc->wait_for_threads);
	}

	/*
	 * Clear irqaction. Otherwise exit_irq_thread() would make
	 * fuzz about an active irq thread going into nirvana.
	 */
	current->irqaction = NULL;
	return 0;
}

/*
 * Called from do_exit()
 */
void exit_irq_thread(void)
{
	struct task_struct *tsk = current;

	if (!tsk->irqaction)
		return;

	printk(KERN_ERR
	       "exiting task \"%s\" (%d) is an active IRQ thread (irq %d)\n",
	       tsk->comm ? tsk->comm : "", tsk->pid, tsk->irqaction->irq);

	/*
	 * Set the THREAD DIED flag to prevent further wakeups of the
	 * soon to be gone threaded handler.
	 */
	set_bit(IRQTF_DIED, &tsk->irqaction->flags);
}

L
Linus Torvalds 已提交
651 652 653 654
/*
 * Internal function to register an irqaction - typically used to
 * allocate special interrupts that are part of the architecture.
 */
655
static int
I
Ingo Molnar 已提交
656
__setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
L
Linus Torvalds 已提交
657
{
658
	struct irqaction *old, **old_ptr;
659
	const char *old_name = NULL;
L
Linus Torvalds 已提交
660
	unsigned long flags;
661
	int nested, shared = 0;
662
	int ret;
L
Linus Torvalds 已提交
663

664
	if (!desc)
665 666
		return -EINVAL;

667
	if (desc->irq_data.chip == &no_irq_chip)
L
Linus Torvalds 已提交
668 669 670 671 672 673
		return -ENOSYS;
	/*
	 * Some drivers like serial.c use request_irq() heavily,
	 * so we have to be careful not to interfere with a
	 * running system.
	 */
674
	if (new->flags & IRQF_SAMPLE_RANDOM) {
L
Linus Torvalds 已提交
675 676 677 678 679 680 681 682 683 684 685
		/*
		 * This function might sleep, we want to call it first,
		 * outside of the atomic block.
		 * Yes, this might clear the entropy pool if the wrong
		 * driver is attempted to be loaded, without actually
		 * installing a new handler, but is this really a problem,
		 * only the sysadmin is able to do this.
		 */
		rand_initialize_irq(irq);
	}

T
Thomas Gleixner 已提交
686 687 688 689
	/* Oneshot interrupts are not allowed with shared */
	if ((new->flags & IRQF_ONESHOT) && (new->flags & IRQF_SHARED))
		return -EINVAL;

690
	/*
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705
	 * Check whether the interrupt nests into another interrupt
	 * thread.
	 */
	nested = desc->status & IRQ_NESTED_THREAD;
	if (nested) {
		if (!new->thread_fn)
			return -EINVAL;
		/*
		 * Replace the primary handler which was provided from
		 * the driver for non nested interrupt handling by the
		 * dummy function which warns when called.
		 */
		new->handler = irq_nested_primary_handler;
	}

706
	/*
707 708 709
	 * Create a handler thread when a thread function is supplied
	 * and the interrupt does not nest into another interrupt
	 * thread.
710
	 */
711
	if (new->thread_fn && !nested) {
712 713 714 715 716 717 718 719 720 721 722 723 724 725 726
		struct task_struct *t;

		t = kthread_create(irq_thread, new, "irq/%d-%s", irq,
				   new->name);
		if (IS_ERR(t))
			return PTR_ERR(t);
		/*
		 * We keep the reference to the task struct even if
		 * the thread dies to avoid that the interrupt code
		 * references an already freed task_struct.
		 */
		get_task_struct(t);
		new->thread = t;
	}

L
Linus Torvalds 已提交
727 728 729
	/*
	 * The following block of code has to be executed atomically
	 */
730
	raw_spin_lock_irqsave(&desc->lock, flags);
731 732
	old_ptr = &desc->action;
	old = *old_ptr;
733
	if (old) {
734 735 736
		/*
		 * Can't share interrupts unless both agree to and are
		 * the same type (level, edge, polarity). So both flag
737
		 * fields must have IRQF_SHARED set and the bits which
738 739
		 * set the trigger type must match.
		 */
740
		if (!((old->flags & new->flags) & IRQF_SHARED) ||
741 742
		    ((old->flags ^ new->flags) & IRQF_TRIGGER_MASK)) {
			old_name = old->name;
743
			goto mismatch;
744
		}
745

746
#if defined(CONFIG_IRQ_PER_CPU)
747
		/* All handlers must agree on per-cpuness */
748 749
		if ((old->flags & IRQF_PERCPU) !=
		    (new->flags & IRQF_PERCPU))
750 751
			goto mismatch;
#endif
L
Linus Torvalds 已提交
752 753 754

		/* add new interrupt at end of irq queue */
		do {
755 756
			old_ptr = &old->next;
			old = *old_ptr;
L
Linus Torvalds 已提交
757 758 759 760 761
		} while (old);
		shared = 1;
	}

	if (!shared) {
762
		irq_chip_set_defaults(desc->irq_data.chip);
763

764 765
		init_waitqueue_head(&desc->wait_for_threads);

766
		/* Setup the type (level, edge polarity) if configured: */
767
		if (new->flags & IRQF_TRIGGER_MASK) {
768 769
			ret = __irq_set_trigger(desc, irq,
					new->flags & IRQF_TRIGGER_MASK);
770

771 772
			if (ret)
				goto out_thread;
773 774
		} else
			compat_irq_chip_set_default_handler(desc);
775 776 777 778
#if defined(CONFIG_IRQ_PER_CPU)
		if (new->flags & IRQF_PERCPU)
			desc->status |= IRQ_PER_CPU;
#endif
T
Thomas Gleixner 已提交
779

T
Thomas Gleixner 已提交
780
		desc->status &= ~(IRQ_AUTODETECT | IRQ_WAITING | IRQ_ONESHOT |
781
				  IRQ_INPROGRESS | IRQ_SPURIOUS_DISABLED);
782

T
Thomas Gleixner 已提交
783 784 785
		if (new->flags & IRQF_ONESHOT)
			desc->status |= IRQ_ONESHOT;

786 787 788
		if (!(desc->status & IRQ_NOAUTOEN)) {
			desc->depth = 0;
			desc->status &= ~IRQ_DISABLED;
789
			desc->irq_data.chip->irq_startup(&desc->irq_data);
790 791 792
		} else
			/* Undo nested disables: */
			desc->depth = 1;
793

794 795 796 797
		/* Exclude IRQ from balancing if requested */
		if (new->flags & IRQF_NOBALANCING)
			desc->status |= IRQ_NO_BALANCING;

798
		/* Set default affinity mask once everything is setup */
799
		setup_affinity(irq, desc);
D
David Brownell 已提交
800 801 802 803 804 805 806 807

	} else if ((new->flags & IRQF_TRIGGER_MASK)
			&& (new->flags & IRQF_TRIGGER_MASK)
				!= (desc->status & IRQ_TYPE_SENSE_MASK)) {
		/* hope the handler works with the actual trigger mode... */
		pr_warning("IRQ %d uses trigger mode %d; requested %d\n",
				irq, (int)(desc->status & IRQ_TYPE_SENSE_MASK),
				(int)(new->flags & IRQF_TRIGGER_MASK));
L
Linus Torvalds 已提交
808
	}
809

810
	new->irq = irq;
811
	*old_ptr = new;
812

813 814 815
	/* Reset broken irq detection when installing new handler */
	desc->irq_count = 0;
	desc->irqs_unhandled = 0;
816 817 818 819 820 821 822

	/*
	 * Check whether we disabled the irq via the spurious handler
	 * before. Reenable it and give it another chance.
	 */
	if (shared && (desc->status & IRQ_SPURIOUS_DISABLED)) {
		desc->status &= ~IRQ_SPURIOUS_DISABLED;
823
		__enable_irq(desc, irq, false);
824 825
	}

826
	raw_spin_unlock_irqrestore(&desc->lock, flags);
L
Linus Torvalds 已提交
827

828 829 830 831 832 833 834
	/*
	 * Strictly no need to wake it up, but hung_task complains
	 * when no hard interrupt wakes the thread up.
	 */
	if (new->thread)
		wake_up_process(new->thread);

835
	register_irq_proc(irq, desc);
L
Linus Torvalds 已提交
836 837 838 839
	new->dir = NULL;
	register_handler_proc(irq, new);

	return 0;
840 841

mismatch:
842
#ifdef CONFIG_DEBUG_SHIRQ
843
	if (!(new->flags & IRQF_PROBE_SHARED)) {
844
		printk(KERN_ERR "IRQ handler type mismatch for IRQ %d\n", irq);
845 846
		if (old_name)
			printk(KERN_ERR "current handler: %s\n", old_name);
847 848
		dump_stack();
	}
849
#endif
850 851 852
	ret = -EBUSY;

out_thread:
853
	raw_spin_unlock_irqrestore(&desc->lock, flags);
854 855 856 857 858 859 860 861 862
	if (new->thread) {
		struct task_struct *t = new->thread;

		new->thread = NULL;
		if (likely(!test_bit(IRQTF_DIED, &new->thread_flags)))
			kthread_stop(t);
		put_task_struct(t);
	}
	return ret;
L
Linus Torvalds 已提交
863 864
}

865 866 867 868 869 870 871 872 873 874 875 876 877
/**
 *	setup_irq - setup an interrupt
 *	@irq: Interrupt line to setup
 *	@act: irqaction for the interrupt
 *
 * Used to statically setup interrupts in the early boot process.
 */
int setup_irq(unsigned int irq, struct irqaction *act)
{
	struct irq_desc *desc = irq_to_desc(irq);

	return __setup_irq(irq, desc, act);
}
878
EXPORT_SYMBOL_GPL(setup_irq);
879

880 881 882
 /*
 * Internal function to unregister an irqaction - used to free
 * regular and special interrupts that are part of the architecture.
L
Linus Torvalds 已提交
883
 */
884
static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
L
Linus Torvalds 已提交
885
{
886
	struct irq_desc *desc = irq_to_desc(irq);
887
	struct irqaction *action, **action_ptr;
L
Linus Torvalds 已提交
888 889
	unsigned long flags;

890
	WARN(in_interrupt(), "Trying to free IRQ %d from IRQ context!\n", irq);
891 892

	if (!desc)
893
		return NULL;
L
Linus Torvalds 已提交
894

895
	raw_spin_lock_irqsave(&desc->lock, flags);
896 897 898 899 900

	/*
	 * There can be multiple actions per IRQ descriptor, find the right
	 * one based on the dev_id:
	 */
901
	action_ptr = &desc->action;
L
Linus Torvalds 已提交
902
	for (;;) {
903
		action = *action_ptr;
L
Linus Torvalds 已提交
904

905 906
		if (!action) {
			WARN(1, "Trying to free already-free IRQ %d\n", irq);
907
			raw_spin_unlock_irqrestore(&desc->lock, flags);
L
Linus Torvalds 已提交
908

909
			return NULL;
910
		}
L
Linus Torvalds 已提交
911

912 913
		if (action->dev_id == dev_id)
			break;
914
		action_ptr = &action->next;
915
	}
916

917
	/* Found it - now remove it from the list of entries: */
918
	*action_ptr = action->next;
919 920

	/* Currently used only by UML, might disappear one day: */
921
#ifdef CONFIG_IRQ_RELEASE_METHOD
922 923
	if (desc->irq_data.chip->release)
		desc->irq_data.chip->release(irq, dev_id);
924
#endif
925

926 927 928
	/* If this was the last handler, shut down the IRQ line: */
	if (!desc->action) {
		desc->status |= IRQ_DISABLED;
929 930
		if (desc->irq_data.chip->irq_shutdown)
			desc->irq_data.chip->irq_shutdown(&desc->irq_data);
931
		else
932
			desc->irq_data.chip->irq_disable(&desc->irq_data);
933
	}
934

935 936 937 938 939 940
#ifdef CONFIG_SMP
	/* make sure affinity_hint is cleaned up */
	if (WARN_ON_ONCE(desc->affinity_hint))
		desc->affinity_hint = NULL;
#endif

941
	raw_spin_unlock_irqrestore(&desc->lock, flags);
942 943 944 945 946

	unregister_handler_proc(irq, action);

	/* Make sure it's not being used on another CPU: */
	synchronize_irq(irq);
L
Linus Torvalds 已提交
947

948
#ifdef CONFIG_DEBUG_SHIRQ
949 950 951 952 953 954 955 956 957 958 959 960
	/*
	 * It's a shared IRQ -- the driver ought to be prepared for an IRQ
	 * event to happen even now it's being freed, so let's make sure that
	 * is so by doing an extra call to the handler ....
	 *
	 * ( We do this after actually deregistering it, to make sure that a
	 *   'real' IRQ doesn't run in * parallel with our fake. )
	 */
	if (action->flags & IRQF_SHARED) {
		local_irq_save(flags);
		action->handler(irq, dev_id);
		local_irq_restore(flags);
L
Linus Torvalds 已提交
961
	}
962
#endif
963 964 965 966 967 968 969

	if (action->thread) {
		if (!test_bit(IRQTF_DIED, &action->thread_flags))
			kthread_stop(action->thread);
		put_task_struct(action->thread);
	}

970 971 972
	return action;
}

973 974 975 976 977 978 979 980 981 982 983
/**
 *	remove_irq - free an interrupt
 *	@irq: Interrupt line to free
 *	@act: irqaction for the interrupt
 *
 * Used to remove interrupts statically setup by the early boot process.
 */
void remove_irq(unsigned int irq, struct irqaction *act)
{
	__free_irq(irq, act->dev_id);
}
984
EXPORT_SYMBOL_GPL(remove_irq);
985

986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001
/**
 *	free_irq - free an interrupt allocated with request_irq
 *	@irq: Interrupt line to free
 *	@dev_id: Device identity to free
 *
 *	Remove an interrupt handler. The handler is removed and if the
 *	interrupt line is no longer in use by any driver it is disabled.
 *	On a shared IRQ the caller must ensure the interrupt is disabled
 *	on the card it drives before calling this function. The function
 *	does not return until any executing interrupts for this IRQ
 *	have completed.
 *
 *	This function must not be called from interrupt context.
 */
void free_irq(unsigned int irq, void *dev_id)
{
T
Thomas Gleixner 已提交
1002 1003 1004 1005 1006
	struct irq_desc *desc = irq_to_desc(irq);

	if (!desc)
		return;

1007
	chip_bus_lock(desc);
1008
	kfree(__free_irq(irq, dev_id));
1009
	chip_bus_sync_unlock(desc);
L
Linus Torvalds 已提交
1010 1011 1012 1013
}
EXPORT_SYMBOL(free_irq);

/**
1014
 *	request_threaded_irq - allocate an interrupt line
L
Linus Torvalds 已提交
1015
 *	@irq: Interrupt line to allocate
1016 1017
 *	@handler: Function to be called when the IRQ occurs.
 *		  Primary handler for threaded interrupts
T
Thomas Gleixner 已提交
1018 1019
 *		  If NULL and thread_fn != NULL the default
 *		  primary handler is installed
1020 1021
 *	@thread_fn: Function called from the irq handler thread
 *		    If NULL, no irq thread is created
L
Linus Torvalds 已提交
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
 *	@irqflags: Interrupt type flags
 *	@devname: An ascii name for the claiming device
 *	@dev_id: A cookie passed back to the handler function
 *
 *	This call allocates interrupt resources and enables the
 *	interrupt line and IRQ handling. From the point this
 *	call is made your handler function may be invoked. Since
 *	your handler function must clear any interrupt the board
 *	raises, you must take care both to initialise your hardware
 *	and to set up the interrupt handler in the right order.
 *
1033 1034 1035 1036 1037
 *	If you want to set up a threaded irq handler for your device
 *	then you need to supply @handler and @thread_fn. @handler ist
 *	still called in hard interrupt context and has to check
 *	whether the interrupt originates from the device. If yes it
 *	needs to disable the interrupt on the device and return
1038
 *	IRQ_WAKE_THREAD which will wake up the handler thread and run
1039 1040 1041
 *	@thread_fn. This split handler design is necessary to support
 *	shared interrupts.
 *
L
Linus Torvalds 已提交
1042 1043 1044 1045 1046 1047 1048 1049 1050
 *	Dev_id must be globally unique. Normally the address of the
 *	device data structure is used as the cookie. Since the handler
 *	receives this value it makes sense to use it.
 *
 *	If your interrupt is shared you must pass a non NULL dev_id
 *	as this is required when freeing the interrupt.
 *
 *	Flags:
 *
1051 1052
 *	IRQF_SHARED		Interrupt is shared
 *	IRQF_SAMPLE_RANDOM	The interrupt can be used for entropy
D
David Brownell 已提交
1053
 *	IRQF_TRIGGER_*		Specify active edge(s) or level
L
Linus Torvalds 已提交
1054 1055
 *
 */
1056 1057 1058
int request_threaded_irq(unsigned int irq, irq_handler_t handler,
			 irq_handler_t thread_fn, unsigned long irqflags,
			 const char *devname, void *dev_id)
L
Linus Torvalds 已提交
1059
{
1060
	struct irqaction *action;
1061
	struct irq_desc *desc;
1062
	int retval;
L
Linus Torvalds 已提交
1063 1064 1065 1066 1067 1068 1069

	/*
	 * Sanity-check: shared interrupts must pass in a real dev-ID,
	 * otherwise we'll have trouble later trying to figure out
	 * which interrupt is which (messes up the interrupt freeing
	 * logic etc).
	 */
1070
	if ((irqflags & IRQF_SHARED) && !dev_id)
L
Linus Torvalds 已提交
1071
		return -EINVAL;
1072

1073
	desc = irq_to_desc(irq);
1074
	if (!desc)
L
Linus Torvalds 已提交
1075
		return -EINVAL;
1076

1077
	if (desc->status & IRQ_NOREQUEST)
1078
		return -EINVAL;
T
Thomas Gleixner 已提交
1079 1080 1081 1082 1083 1084

	if (!handler) {
		if (!thread_fn)
			return -EINVAL;
		handler = irq_default_primary_handler;
	}
L
Linus Torvalds 已提交
1085

1086
	action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
L
Linus Torvalds 已提交
1087 1088 1089 1090
	if (!action)
		return -ENOMEM;

	action->handler = handler;
1091
	action->thread_fn = thread_fn;
L
Linus Torvalds 已提交
1092 1093 1094 1095
	action->flags = irqflags;
	action->name = devname;
	action->dev_id = dev_id;

1096
	chip_bus_lock(desc);
1097
	retval = __setup_irq(irq, desc, action);
1098
	chip_bus_sync_unlock(desc);
T
Thomas Gleixner 已提交
1099

1100 1101 1102
	if (retval)
		kfree(action);

D
David Woodhouse 已提交
1103
#ifdef CONFIG_DEBUG_SHIRQ
1104
	if (!retval && (irqflags & IRQF_SHARED)) {
D
David Woodhouse 已提交
1105 1106 1107
		/*
		 * It's a shared IRQ -- the driver ought to be prepared for it
		 * to happen immediately, so let's make sure....
1108 1109
		 * We disable the irq to make sure that a 'real' IRQ doesn't
		 * run in parallel with our fake.
D
David Woodhouse 已提交
1110
		 */
1111
		unsigned long flags;
D
David Woodhouse 已提交
1112

1113
		disable_irq(irq);
1114
		local_irq_save(flags);
1115

1116
		handler(irq, dev_id);
1117

1118
		local_irq_restore(flags);
1119
		enable_irq(irq);
D
David Woodhouse 已提交
1120 1121
	}
#endif
L
Linus Torvalds 已提交
1122 1123
	return retval;
}
1124
EXPORT_SYMBOL(request_threaded_irq);
1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161

/**
 *	request_any_context_irq - allocate an interrupt line
 *	@irq: Interrupt line to allocate
 *	@handler: Function to be called when the IRQ occurs.
 *		  Threaded handler for threaded interrupts.
 *	@flags: Interrupt type flags
 *	@name: An ascii name for the claiming device
 *	@dev_id: A cookie passed back to the handler function
 *
 *	This call allocates interrupt resources and enables the
 *	interrupt line and IRQ handling. It selects either a
 *	hardirq or threaded handling method depending on the
 *	context.
 *
 *	On failure, it returns a negative value. On success,
 *	it returns either IRQC_IS_HARDIRQ or IRQC_IS_NESTED.
 */
int request_any_context_irq(unsigned int irq, irq_handler_t handler,
			    unsigned long flags, const char *name, void *dev_id)
{
	struct irq_desc *desc = irq_to_desc(irq);
	int ret;

	if (!desc)
		return -EINVAL;

	if (desc->status & IRQ_NESTED_THREAD) {
		ret = request_threaded_irq(irq, NULL, handler,
					   flags, name, dev_id);
		return !ret ? IRQC_IS_NESTED : ret;
	}

	ret = request_irq(irq, handler, flags, name, dev_id);
	return !ret ? IRQC_IS_HARDIRQ : ret;
}
EXPORT_SYMBOL_GPL(request_any_context_irq);