manage.c 11.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
/*
 * linux/kernel/irq/manage.c
 *
4
5
 * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
 * Copyright (C) 2005-2006 Thomas Gleixner
Linus Torvalds's avatar
Linus Torvalds committed
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 *
 * This file contains driver APIs to the irq subsystem.
 */

#include <linux/irq.h>
#include <linux/module.h>
#include <linux/random.h>
#include <linux/interrupt.h>

#include "internals.h"

#ifdef CONFIG_SMP

/**
 *	synchronize_irq - wait for pending IRQ handlers (on other CPUs)
21
 *	@irq: interrupt number to wait for
Linus Torvalds's avatar
Linus Torvalds committed
22
23
24
25
26
27
28
29
30
31
32
 *
 *	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)
{
	struct irq_desc *desc = irq_desc + irq;

33
34
35
	if (irq >= NR_IRQS)
		return;

Linus Torvalds's avatar
Linus Torvalds committed
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
	while (desc->status & IRQ_INPROGRESS)
		cpu_relax();
}
EXPORT_SYMBOL(synchronize_irq);

#endif

/**
 *	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)
{
56
	struct irq_desc *desc = irq_desc + irq;
Linus Torvalds's avatar
Linus Torvalds committed
57
58
	unsigned long flags;

59
60
61
	if (irq >= NR_IRQS)
		return;

Linus Torvalds's avatar
Linus Torvalds committed
62
63
64
	spin_lock_irqsave(&desc->lock, flags);
	if (!desc->depth++) {
		desc->status |= IRQ_DISABLED;
65
		desc->chip->disable(irq);
Linus Torvalds's avatar
Linus Torvalds committed
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
	}
	spin_unlock_irqrestore(&desc->lock, flags);
}
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)
{
85
	struct irq_desc *desc = irq_desc + irq;
Linus Torvalds's avatar
Linus Torvalds committed
86

87
88
89
	if (irq >= NR_IRQS)
		return;

Linus Torvalds's avatar
Linus Torvalds committed
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
	disable_irq_nosync(irq);
	if (desc->action)
		synchronize_irq(irq);
}
EXPORT_SYMBOL(disable_irq);

/**
 *	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.
 *
 *	This function may be called from IRQ context.
 */
void enable_irq(unsigned int irq)
{
108
	struct irq_desc *desc = irq_desc + irq;
Linus Torvalds's avatar
Linus Torvalds committed
109
110
	unsigned long flags;

111
112
113
	if (irq >= NR_IRQS)
		return;

Linus Torvalds's avatar
Linus Torvalds committed
114
115
116
	spin_lock_irqsave(&desc->lock, flags);
	switch (desc->depth) {
	case 0:
117
		printk(KERN_WARNING "Unablanced enable_irq(%d)\n", irq);
Linus Torvalds's avatar
Linus Torvalds committed
118
119
120
		WARN_ON(1);
		break;
	case 1: {
121
122
123
124
		unsigned int status = desc->status & ~IRQ_DISABLED;

		/* Prevent probing on this irq: */
		desc->status = status | IRQ_NOPROBE;
125
		check_irq_resend(desc, irq);
Linus Torvalds's avatar
Linus Torvalds committed
126
127
128
129
130
131
132
133
134
		/* fall-through */
	}
	default:
		desc->depth--;
	}
	spin_unlock_irqrestore(&desc->lock, flags);
}
EXPORT_SYMBOL(enable_irq);

135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
/**
 *	set_irq_wake - control irq power management wakeup
 *	@irq:	interrupt to control
 *	@on:	enable/disable power management wakeup
 *
 *	Enable/disable power management wakeup mode
 */
int set_irq_wake(unsigned int irq, unsigned int on)
{
	struct irq_desc *desc = irq_desc + irq;
	unsigned long flags;
	int ret = -ENXIO;

	spin_lock_irqsave(&desc->lock, flags);
	if (desc->chip->set_wake)
		ret = desc->chip->set_wake(irq, on);
	spin_unlock_irqrestore(&desc->lock, flags);
	return ret;
}
EXPORT_SYMBOL(set_irq_wake);

Linus Torvalds's avatar
Linus Torvalds committed
156
157
158
159
160
161
162
163
164
/*
 * 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)
{
	struct irqaction *action;

165
	if (irq >= NR_IRQS || irq_desc[irq].status & IRQ_NOREQUEST)
Linus Torvalds's avatar
Linus Torvalds committed
166
167
168
169
170
171
172
173
174
175
		return 0;

	action = irq_desc[irq].action;
	if (action)
		if (irqflags & action->flags & SA_SHIRQ)
			action = NULL;

	return !action;
}

Thomas Gleixner's avatar
Thomas Gleixner committed
176
177
178
179
180
181
182
183
184
185
186
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;
}

Linus Torvalds's avatar
Linus Torvalds committed
187
188
189
190
/*
 * Internal function to register an irqaction - typically used to
 * allocate special interrupts that are part of the architecture.
 */
191
int setup_irq(unsigned int irq, struct irqaction *new)
Linus Torvalds's avatar
Linus Torvalds committed
192
193
194
195
196
197
{
	struct irq_desc *desc = irq_desc + irq;
	struct irqaction *old, **p;
	unsigned long flags;
	int shared = 0;

198
199
200
	if (irq >= NR_IRQS)
		return -EINVAL;

201
	if (desc->chip == &no_irq_chip)
Linus Torvalds's avatar
Linus Torvalds committed
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
		return -ENOSYS;
	/*
	 * Some drivers like serial.c use request_irq() heavily,
	 * so we have to be careful not to interfere with a
	 * running system.
	 */
	if (new->flags & SA_SAMPLE_RANDOM) {
		/*
		 * 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);
	}

	/*
	 * The following block of code has to be executed atomically
	 */
223
	spin_lock_irqsave(&desc->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
224
	p = &desc->action;
225
226
	old = *p;
	if (old) {
227
228
229
230
231
232
233
234
		/*
		 * Can't share interrupts unless both agree to and are
		 * the same type (level, edge, polarity). So both flag
		 * fields must have SA_SHIRQ set and the bits which
		 * set the trigger type must match.
		 */
		if (!((old->flags & new->flags) & SA_SHIRQ) ||
		    ((old->flags ^ new->flags) & SA_TRIGGER_MASK))
235
236
			goto mismatch;

237
#if defined(CONFIG_IRQ_PER_CPU) && defined(SA_PERCPU_IRQ)
238
		/* All handlers must agree on per-cpuness */
239
240
		if ((old->flags & SA_PERCPU_IRQ) !=
		    (new->flags & SA_PERCPU_IRQ))
241
242
			goto mismatch;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
243
244
245
246
247
248
249
250
251
252

		/* add new interrupt at end of irq queue */
		do {
			p = &old->next;
			old = *p;
		} while (old);
		shared = 1;
	}

	*p = new;
253
#if defined(CONFIG_IRQ_PER_CPU) && defined(SA_PERCPU_IRQ)
254
255
256
	if (new->flags & SA_PERCPU_IRQ)
		desc->status |= IRQ_PER_CPU;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
257
	if (!shared) {
Thomas Gleixner's avatar
Thomas Gleixner committed
258
		irq_chip_set_defaults(desc->chip);
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274

		/* Setup the type (level, edge polarity) if configured: */
		if (new->flags & SA_TRIGGER_MASK) {
			if (desc->chip && desc->chip->set_type)
				desc->chip->set_type(irq,
						new->flags & SA_TRIGGER_MASK);
			else
				/*
				 * SA_TRIGGER_* but the PIC does not support
				 * multiple flow-types?
				 */
				printk(KERN_WARNING "setup_irq(%d) SA_TRIGGER"
				       "set. No set_type function available\n",
				       irq);
		} else
			compat_irq_chip_set_default_handler(desc);
Thomas Gleixner's avatar
Thomas Gleixner committed
275

276
277
278
279
280
281
282
283
284
285
		desc->status &= ~(IRQ_AUTODETECT | IRQ_WAITING |
				  IRQ_INPROGRESS);

		if (!(desc->status & IRQ_NOAUTOEN)) {
			desc->depth = 0;
			desc->status &= ~IRQ_DISABLED;
			if (desc->chip->startup)
				desc->chip->startup(irq);
			else
				desc->chip->enable(irq);
286
287
288
		} else
			/* Undo nested disables: */
			desc->depth = 1;
Linus Torvalds's avatar
Linus Torvalds committed
289
	}
290
	spin_unlock_irqrestore(&desc->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
291
292
293
294
295
296
297

	new->irq = irq;
	register_irq_proc(irq);
	new->dir = NULL;
	register_handler_proc(irq, new);

	return 0;
298
299
300

mismatch:
	spin_unlock_irqrestore(&desc->lock, flags);
301
302
303
304
	if (!(new->flags & SA_PROBEIRQ)) {
		printk(KERN_ERR "%s: irq handler mismatch\n", __FUNCTION__);
		dump_stack();
	}
305
	return -EBUSY;
Linus Torvalds's avatar
Linus Torvalds committed
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
}

/**
 *	free_irq - free an interrupt
 *	@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)
{
	struct irq_desc *desc;
	struct irqaction **p;
	unsigned long flags;

328
	WARN_ON(in_interrupt());
Linus Torvalds's avatar
Linus Torvalds committed
329
330
331
332
	if (irq >= NR_IRQS)
		return;

	desc = irq_desc + irq;
333
	spin_lock_irqsave(&desc->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
334
335
	p = &desc->action;
	for (;;) {
336
		struct irqaction *action = *p;
Linus Torvalds's avatar
Linus Torvalds committed
337
338
339
340
341
342
343
344
345
346

		if (action) {
			struct irqaction **pp = p;

			p = &action->next;
			if (action->dev_id != dev_id)
				continue;

			/* Found it - now remove it from the list of entries */
			*pp = action->next;
347

348
349
			/* Currently used only by UML, might disappear one day.*/
#ifdef CONFIG_IRQ_RELEASE_METHOD
350
351
			if (desc->chip->release)
				desc->chip->release(irq, dev_id);
352
#endif
353

Linus Torvalds's avatar
Linus Torvalds committed
354
355
			if (!desc->action) {
				desc->status |= IRQ_DISABLED;
356
357
				if (desc->chip->shutdown)
					desc->chip->shutdown(irq);
Linus Torvalds's avatar
Linus Torvalds committed
358
				else
359
					desc->chip->disable(irq);
Linus Torvalds's avatar
Linus Torvalds committed
360
			}
361
			spin_unlock_irqrestore(&desc->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
362
363
364
365
366
367
368
			unregister_handler_proc(irq, action);

			/* Make sure it's not being used on another CPU */
			synchronize_irq(irq);
			kfree(action);
			return;
		}
369
370
		printk(KERN_ERR "Trying to free free IRQ%d\n", irq);
		spin_unlock_irqrestore(&desc->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
		return;
	}
}
EXPORT_SYMBOL(free_irq);

/**
 *	request_irq - allocate an interrupt line
 *	@irq: Interrupt line to allocate
 *	@handler: Function to be called when the IRQ occurs
 *	@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.
 *
 *	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:
 *
 *	SA_SHIRQ		Interrupt is shared
 *	SA_INTERRUPT		Disable local interrupts while processing
 *	SA_SAMPLE_RANDOM	The interrupt can be used for entropy
 *
 */
int request_irq(unsigned int irq,
		irqreturn_t (*handler)(int, void *, struct pt_regs *),
407
		unsigned long irqflags, const char *devname, void *dev_id)
Linus Torvalds's avatar
Linus Torvalds committed
408
{
409
	struct irqaction *action;
Linus Torvalds's avatar
Linus Torvalds committed
410
411
412
413
414
415
416
417
418
419
420
421
	int retval;

	/*
	 * 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).
	 */
	if ((irqflags & SA_SHIRQ) && !dev_id)
		return -EINVAL;
	if (irq >= NR_IRQS)
		return -EINVAL;
422
423
	if (irq_desc[irq].status & IRQ_NOREQUEST)
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
424
425
426
427
428
429
430
431
432
433
434
435
436
437
	if (!handler)
		return -EINVAL;

	action = kmalloc(sizeof(struct irqaction), GFP_ATOMIC);
	if (!action)
		return -ENOMEM;

	action->handler = handler;
	action->flags = irqflags;
	cpus_clear(action->mask);
	action->name = devname;
	action->next = NULL;
	action->dev_id = dev_id;

438
439
	select_smp_affinity(irq);

Linus Torvalds's avatar
Linus Torvalds committed
440
441
442
443
444
445
446
447
	retval = setup_irq(irq, action);
	if (retval)
		kfree(action);

	return retval;
}
EXPORT_SYMBOL(request_irq);