chip.c 15.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 * linux/kernel/irq/chip.c
 *
 * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
 * Copyright (C) 2005-2006, Thomas Gleixner, Russell King
 *
 * This file contains the core interrupt handling code, for irq-chip
 * based architectures.
 *
 * Detailed information is available in Documentation/DocBook/genericirq
 */

#include <linux/irq.h>
14
#include <linux/msi.h>
15 16 17 18 19 20
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/kernel_stat.h>

#include "internals.h"

21 22 23 24 25 26
/**
 *	dynamic_irq_init - initialize a dynamically allocated irq
 *	@irq:	irq number to initialize
 */
void dynamic_irq_init(unsigned int irq)
{
27
	struct irq_desc *desc;
28 29
	unsigned long flags;

30
	desc = irq_to_desc(irq);
31
	if (!desc) {
32
		WARN(1, KERN_ERR "Trying to initialize invalid IRQ%d\n", irq);
33 34 35 36 37 38 39 40 41
		return;
	}

	/* Ensure we don't have left over values from a previous use of this irq */
	spin_lock_irqsave(&desc->lock, flags);
	desc->status = IRQ_DISABLED;
	desc->chip = &no_irq_chip;
	desc->handle_irq = handle_bad_irq;
	desc->depth = 1;
42
	desc->msi_desc = NULL;
43 44 45 46 47 48
	desc->handler_data = NULL;
	desc->chip_data = NULL;
	desc->action = NULL;
	desc->irq_count = 0;
	desc->irqs_unhandled = 0;
#ifdef CONFIG_SMP
49
	cpus_setall(desc->affinity);
50 51 52 53 54 55 56 57 58 59
#endif
	spin_unlock_irqrestore(&desc->lock, flags);
}

/**
 *	dynamic_irq_cleanup - cleanup a dynamically allocated irq
 *	@irq:	irq number to initialize
 */
void dynamic_irq_cleanup(unsigned int irq)
{
60
	struct irq_desc *desc = irq_to_desc(irq);
61 62
	unsigned long flags;

63
	if (!desc) {
64
		WARN(1, KERN_ERR "Trying to cleanup invalid IRQ%d\n", irq);
65 66 67 68
		return;
	}

	spin_lock_irqsave(&desc->lock, flags);
69 70
	if (desc->action) {
		spin_unlock_irqrestore(&desc->lock, flags);
71
		WARN(1, KERN_ERR "Destroying IRQ%d without calling free_irq\n",
72 73 74
			irq);
		return;
	}
75 76 77
	desc->msi_desc = NULL;
	desc->handler_data = NULL;
	desc->chip_data = NULL;
78 79
	desc->handle_irq = handle_bad_irq;
	desc->chip = &no_irq_chip;
80
	desc->name = NULL;
81 82 83 84
	spin_unlock_irqrestore(&desc->lock, flags);
}


85 86 87 88 89 90 91
/**
 *	set_irq_chip - set the irq chip for an irq
 *	@irq:	irq number
 *	@chip:	pointer to irq chip description structure
 */
int set_irq_chip(unsigned int irq, struct irq_chip *chip)
{
92
	struct irq_desc *desc = irq_to_desc(irq);
93 94
	unsigned long flags;

95
	if (!desc) {
96
		WARN(1, KERN_ERR "Trying to install chip for IRQ%d\n", irq);
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
		return -EINVAL;
	}

	if (!chip)
		chip = &no_irq_chip;

	spin_lock_irqsave(&desc->lock, flags);
	irq_chip_set_defaults(chip);
	desc->chip = chip;
	spin_unlock_irqrestore(&desc->lock, flags);

	return 0;
}
EXPORT_SYMBOL(set_irq_chip);

/**
D
David Brownell 已提交
113
 *	set_irq_type - set the irq trigger type for an irq
114
 *	@irq:	irq number
D
David Brownell 已提交
115
 *	@type:	IRQ_TYPE_{LEVEL,EDGE}_* value - see include/linux/irq.h
116 117 118
 */
int set_irq_type(unsigned int irq, unsigned int type)
{
119
	struct irq_desc *desc = irq_to_desc(irq);
120 121 122
	unsigned long flags;
	int ret = -ENXIO;

123
	if (!desc) {
124 125 126 127
		printk(KERN_ERR "Trying to set irq type for IRQ%d\n", irq);
		return -ENODEV;
	}

128
	type &= IRQ_TYPE_SENSE_MASK;
D
David Brownell 已提交
129 130 131 132
	if (type == IRQ_TYPE_NONE)
		return 0;

	spin_lock_irqsave(&desc->lock, flags);
133
	ret = __irq_set_trigger(desc, irq, type);
D
David Brownell 已提交
134
	spin_unlock_irqrestore(&desc->lock, flags);
135 136 137 138 139 140 141 142 143 144 145 146 147
	return ret;
}
EXPORT_SYMBOL(set_irq_type);

/**
 *	set_irq_data - set irq type data for an irq
 *	@irq:	Interrupt number
 *	@data:	Pointer to interrupt specific data
 *
 *	Set the hardware irq controller data for an irq
 */
int set_irq_data(unsigned int irq, void *data)
{
148
	struct irq_desc *desc = irq_to_desc(irq);
149 150
	unsigned long flags;

151
	if (!desc) {
152 153 154 155 156 157 158 159 160 161 162 163
		printk(KERN_ERR
		       "Trying to install controller data for IRQ%d\n", irq);
		return -EINVAL;
	}

	spin_lock_irqsave(&desc->lock, flags);
	desc->handler_data = data;
	spin_unlock_irqrestore(&desc->lock, flags);
	return 0;
}
EXPORT_SYMBOL(set_irq_data);

164 165 166
/**
 *	set_irq_data - set irq type data for an irq
 *	@irq:	Interrupt number
R
Randy Dunlap 已提交
167
 *	@entry:	Pointer to MSI descriptor data
168 169 170 171 172
 *
 *	Set the hardware irq controller data for an irq
 */
int set_irq_msi(unsigned int irq, struct msi_desc *entry)
{
173
	struct irq_desc *desc = irq_to_desc(irq);
174 175
	unsigned long flags;

176
	if (!desc) {
177 178 179 180
		printk(KERN_ERR
		       "Trying to install msi data for IRQ%d\n", irq);
		return -EINVAL;
	}
181

182 183
	spin_lock_irqsave(&desc->lock, flags);
	desc->msi_desc = entry;
184 185
	if (entry)
		entry->irq = irq;
186 187 188 189
	spin_unlock_irqrestore(&desc->lock, flags);
	return 0;
}

190 191 192 193 194 195 196 197 198
/**
 *	set_irq_chip_data - set irq chip data for an irq
 *	@irq:	Interrupt number
 *	@data:	Pointer to chip specific data
 *
 *	Set the hardware irq chip data for an irq
 */
int set_irq_chip_data(unsigned int irq, void *data)
{
199
	struct irq_desc *desc = irq_to_desc(irq);
200 201
	unsigned long flags;

202 203 204 205 206 207 208
	if (!desc) {
		printk(KERN_ERR
		       "Trying to install chip data for IRQ%d\n", irq);
		return -EINVAL;
	}

	if (!desc->chip) {
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
		printk(KERN_ERR "BUG: bad set_irq_chip_data(IRQ#%d)\n", irq);
		return -EINVAL;
	}

	spin_lock_irqsave(&desc->lock, flags);
	desc->chip_data = data;
	spin_unlock_irqrestore(&desc->lock, flags);

	return 0;
}
EXPORT_SYMBOL(set_irq_chip_data);

/*
 * default enable function
 */
static void default_enable(unsigned int irq)
{
226
	struct irq_desc *desc = irq_to_desc(irq);
227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243

	desc->chip->unmask(irq);
	desc->status &= ~IRQ_MASKED;
}

/*
 * default disable function
 */
static void default_disable(unsigned int irq)
{
}

/*
 * default startup function
 */
static unsigned int default_startup(unsigned int irq)
{
244
	struct irq_desc *desc = irq_to_desc(irq);
245 246

	desc->chip->enable(irq);
247 248 249
	return 0;
}

250 251 252 253 254
/*
 * default shutdown function
 */
static void default_shutdown(unsigned int irq)
{
255
	struct irq_desc *desc = irq_to_desc(irq);
256 257 258 259 260

	desc->chip->mask(irq);
	desc->status |= IRQ_MASKED;
}

261 262 263 264 265 266 267 268 269 270 271
/*
 * Fixup enable/disable function pointers
 */
void irq_chip_set_defaults(struct irq_chip *chip)
{
	if (!chip->enable)
		chip->enable = default_enable;
	if (!chip->disable)
		chip->disable = default_disable;
	if (!chip->startup)
		chip->startup = default_startup;
272 273 274 275 276 277
	/*
	 * We use chip->disable, when the user provided its own. When
	 * we have default_disable set for chip->disable, then we need
	 * to use default_shutdown, otherwise the irq line is not
	 * disabled on free_irq():
	 */
278
	if (!chip->shutdown)
279 280
		chip->shutdown = chip->disable != default_disable ?
			chip->disable : default_shutdown;
281 282
	if (!chip->name)
		chip->name = chip->typename;
283 284
	if (!chip->end)
		chip->end = dummy_irq_chip.end;
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
}

static inline void mask_ack_irq(struct irq_desc *desc, int irq)
{
	if (desc->chip->mask_ack)
		desc->chip->mask_ack(irq);
	else {
		desc->chip->mask(irq);
		desc->chip->ack(irq);
	}
}

/**
 *	handle_simple_irq - Simple and software-decoded IRQs.
 *	@irq:	the interrupt number
 *	@desc:	the interrupt description structure for this irq
 *
 *	Simple interrupts are either sent from a demultiplexing interrupt
 *	handler or come from hardware, where no interrupt hardware control
 *	is necessary.
 *
 *	Note: The caller is expected to handle the ack, clear, mask and
 *	unmask issues if necessary.
 */
309
void
310
handle_simple_irq(unsigned int irq, struct irq_desc *desc)
311 312 313 314 315 316 317 318
{
	struct irqaction *action;
	irqreturn_t action_ret;

	spin_lock(&desc->lock);

	if (unlikely(desc->status & IRQ_INPROGRESS))
		goto out_unlock;
319
	desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
T
Thomas Gleixner 已提交
320
	kstat_incr_irqs_this_cpu(irq, desc);
321 322

	action = desc->action;
323
	if (unlikely(!action || (desc->status & IRQ_DISABLED)))
324 325 326 327 328
		goto out_unlock;

	desc->status |= IRQ_INPROGRESS;
	spin_unlock(&desc->lock);

329
	action_ret = handle_IRQ_event(irq, action);
330
	if (!noirqdebug)
331
		note_interrupt(irq, desc, action_ret);
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348

	spin_lock(&desc->lock);
	desc->status &= ~IRQ_INPROGRESS;
out_unlock:
	spin_unlock(&desc->lock);
}

/**
 *	handle_level_irq - Level type irq handler
 *	@irq:	the interrupt number
 *	@desc:	the interrupt description structure for this irq
 *
 *	Level type interrupts are active as long as the hardware line has
 *	the active level. This may require to mask the interrupt and unmask
 *	it after the associated handler has acknowledged the device, so the
 *	interrupt line is back to inactive.
 */
349
void
350
handle_level_irq(unsigned int irq, struct irq_desc *desc)
351 352 353 354 355 356
{
	struct irqaction *action;
	irqreturn_t action_ret;

	spin_lock(&desc->lock);
	mask_ack_irq(desc, irq);
357
	desc = irq_remap_to_desc(irq, desc);
358 359

	if (unlikely(desc->status & IRQ_INPROGRESS))
360
		goto out_unlock;
361
	desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
T
Thomas Gleixner 已提交
362
	kstat_incr_irqs_this_cpu(irq, desc);
363 364 365 366 367 368

	/*
	 * If its disabled or no action available
	 * keep it masked and get out of here
	 */
	action = desc->action;
369
	if (unlikely(!action || (desc->status & IRQ_DISABLED)))
370
		goto out_unlock;
371 372 373 374

	desc->status |= IRQ_INPROGRESS;
	spin_unlock(&desc->lock);

375
	action_ret = handle_IRQ_event(irq, action);
376
	if (!noirqdebug)
377
		note_interrupt(irq, desc, action_ret);
378 379 380 381 382

	spin_lock(&desc->lock);
	desc->status &= ~IRQ_INPROGRESS;
	if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
		desc->chip->unmask(irq);
383
out_unlock:
384 385 386 387
	spin_unlock(&desc->lock);
}

/**
388
 *	handle_fasteoi_irq - irq handler for transparent controllers
389 390 391
 *	@irq:	the interrupt number
 *	@desc:	the interrupt description structure for this irq
 *
392
 *	Only a single callback will be issued to the chip: an ->eoi()
393 394 395 396
 *	call when the interrupt has been serviced. This enables support
 *	for modern forms of interrupt handlers, which handle the flow
 *	details in hardware, transparently.
 */
397
void
398
handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
399 400 401 402 403 404 405 406 407 408
{
	struct irqaction *action;
	irqreturn_t action_ret;

	spin_lock(&desc->lock);

	if (unlikely(desc->status & IRQ_INPROGRESS))
		goto out;

	desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
T
Thomas Gleixner 已提交
409
	kstat_incr_irqs_this_cpu(irq, desc);
410 411 412

	/*
	 * If its disabled or no action available
413
	 * then mask it and get out of here:
414 415
	 */
	action = desc->action;
416 417
	if (unlikely(!action || (desc->status & IRQ_DISABLED))) {
		desc->status |= IRQ_PENDING;
418 419
		if (desc->chip->mask)
			desc->chip->mask(irq);
420
		goto out;
421
	}
422 423

	desc->status |= IRQ_INPROGRESS;
424
	desc->status &= ~IRQ_PENDING;
425 426
	spin_unlock(&desc->lock);

427
	action_ret = handle_IRQ_event(irq, action);
428
	if (!noirqdebug)
429
		note_interrupt(irq, desc, action_ret);
430 431 432 433

	spin_lock(&desc->lock);
	desc->status &= ~IRQ_INPROGRESS;
out:
434
	desc->chip->eoi(irq);
435
	desc = irq_remap_to_desc(irq, desc);
436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455

	spin_unlock(&desc->lock);
}

/**
 *	handle_edge_irq - edge type IRQ handler
 *	@irq:	the interrupt number
 *	@desc:	the interrupt description structure for this irq
 *
 *	Interrupt occures on the falling and/or rising edge of a hardware
 *	signal. The occurence is latched into the irq controller hardware
 *	and must be acked in order to be reenabled. After the ack another
 *	interrupt can happen on the same source even before the first one
 *	is handled by the assosiacted event handler. If this happens it
 *	might be necessary to disable (mask) the interrupt depending on the
 *	controller hardware. This requires to reenable the interrupt inside
 *	of the loop which handles the interrupts which have arrived while
 *	the handler was running. If all pending interrupts are handled, the
 *	loop is left.
 */
456
void
457
handle_edge_irq(unsigned int irq, struct irq_desc *desc)
458 459 460 461 462 463 464 465 466 467 468 469 470 471
{
	spin_lock(&desc->lock);

	desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);

	/*
	 * If we're currently running this IRQ, or its disabled,
	 * we shouldn't process the IRQ. Mark it pending, handle
	 * the necessary masking and go out
	 */
	if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) ||
		    !desc->action)) {
		desc->status |= (IRQ_PENDING | IRQ_MASKED);
		mask_ack_irq(desc, irq);
472
		desc = irq_remap_to_desc(irq, desc);
473 474
		goto out_unlock;
	}
T
Thomas Gleixner 已提交
475
	kstat_incr_irqs_this_cpu(irq, desc);
476 477 478

	/* Start handling the irq */
	desc->chip->ack(irq);
479
	desc = irq_remap_to_desc(irq, desc);
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506

	/* Mark the IRQ currently in progress.*/
	desc->status |= IRQ_INPROGRESS;

	do {
		struct irqaction *action = desc->action;
		irqreturn_t action_ret;

		if (unlikely(!action)) {
			desc->chip->mask(irq);
			goto out_unlock;
		}

		/*
		 * When another irq arrived while we were handling
		 * one, we could have masked the irq.
		 * Renable it, if it was not disabled in meantime.
		 */
		if (unlikely((desc->status &
			       (IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) ==
			      (IRQ_PENDING | IRQ_MASKED))) {
			desc->chip->unmask(irq);
			desc->status &= ~IRQ_MASKED;
		}

		desc->status &= ~IRQ_PENDING;
		spin_unlock(&desc->lock);
507
		action_ret = handle_IRQ_event(irq, action);
508
		if (!noirqdebug)
509
			note_interrupt(irq, desc, action_ret);
510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525
		spin_lock(&desc->lock);

	} while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);

	desc->status &= ~IRQ_INPROGRESS;
out_unlock:
	spin_unlock(&desc->lock);
}

/**
 *	handle_percpu_IRQ - Per CPU local irq handler
 *	@irq:	the interrupt number
 *	@desc:	the interrupt description structure for this irq
 *
 *	Per CPU interrupts on SMP machines without locking requirements
 */
526
void
527
handle_percpu_irq(unsigned int irq, struct irq_desc *desc)
528 529 530
{
	irqreturn_t action_ret;

T
Thomas Gleixner 已提交
531
	kstat_incr_irqs_this_cpu(irq, desc);
532 533 534 535

	if (desc->chip->ack)
		desc->chip->ack(irq);

536
	action_ret = handle_IRQ_event(irq, desc->action);
537
	if (!noirqdebug)
538
		note_interrupt(irq, desc, action_ret);
539

540
	if (desc->chip->eoi) {
541
		desc->chip->eoi(irq);
542 543
		desc = irq_remap_to_desc(irq, desc);
	}
544 545 546
}

void
547 548
__set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
		  const char *name)
549
{
550
	struct irq_desc *desc = irq_to_desc(irq);
551 552
	unsigned long flags;

553
	if (!desc) {
554 555 556 557 558 559 560
		printk(KERN_ERR
		       "Trying to install type control for IRQ%d\n", irq);
		return;
	}

	if (!handle)
		handle = handle_bad_irq;
561
	else if (desc->chip == &no_irq_chip) {
562
		printk(KERN_WARNING "Trying to install %sinterrupt handler "
563
		       "for IRQ%d\n", is_chained ? "chained " : "", irq);
564 565 566 567 568 569 570 571 572
		/*
		 * Some ARM implementations install a handler for really dumb
		 * interrupt hardware without setting an irq_chip. This worked
		 * with the ARM no_irq_chip but the check in setup_irq would
		 * prevent us to setup the interrupt at all. Switch it to
		 * dummy_irq_chip for easy transition.
		 */
		desc->chip = &dummy_irq_chip;
	}
573 574 575 576 577

	spin_lock_irqsave(&desc->lock, flags);

	/* Uninstall? */
	if (handle == handle_bad_irq) {
578
		if (desc->chip != &no_irq_chip) {
579
			mask_ack_irq(desc, irq);
580 581
			desc = irq_remap_to_desc(irq, desc);
		}
582 583 584 585
		desc->status |= IRQ_DISABLED;
		desc->depth = 1;
	}
	desc->handle_irq = handle;
586
	desc->name = name;
587 588 589 590 591

	if (handle != handle_bad_irq && is_chained) {
		desc->status &= ~IRQ_DISABLED;
		desc->status |= IRQ_NOREQUEST | IRQ_NOPROBE;
		desc->depth = 0;
592
		desc->chip->startup(irq);
593 594 595 596 597 598
	}
	spin_unlock_irqrestore(&desc->lock, flags);
}

void
set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
599
			 irq_flow_handler_t handle)
600 601
{
	set_irq_chip(irq, chip);
602
	__set_irq_handler(irq, handle, 0, NULL);
603 604
}

605 606 607
void
set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
			      irq_flow_handler_t handle, const char *name)
608
{
609 610
	set_irq_chip(irq, chip);
	__set_irq_handler(irq, handle, 0, name);
611
}
R
Ralf Baechle 已提交
612 613 614

void __init set_irq_noprobe(unsigned int irq)
{
615
	struct irq_desc *desc = irq_to_desc(irq);
R
Ralf Baechle 已提交
616 617
	unsigned long flags;

618
	if (!desc) {
R
Ralf Baechle 已提交
619 620 621 622 623 624 625 626 627 628 629
		printk(KERN_ERR "Trying to mark IRQ%d non-probeable\n", irq);
		return;
	}

	spin_lock_irqsave(&desc->lock, flags);
	desc->status |= IRQ_NOPROBE;
	spin_unlock_irqrestore(&desc->lock, flags);
}

void __init set_irq_probe(unsigned int irq)
{
630
	struct irq_desc *desc = irq_to_desc(irq);
R
Ralf Baechle 已提交
631 632
	unsigned long flags;

633
	if (!desc) {
R
Ralf Baechle 已提交
634 635 636 637 638 639 640 641
		printk(KERN_ERR "Trying to mark IRQ%d probeable\n", irq);
		return;
	}

	spin_lock_irqsave(&desc->lock, flags);
	desc->status &= ~IRQ_NOPROBE;
	spin_unlock_irqrestore(&desc->lock, flags);
}