irq.h 22.5 KB
Newer Older
1
2
#ifndef _LINUX_IRQ_H
#define _LINUX_IRQ_H
Linus Torvalds's avatar
Linus Torvalds committed
3
4
5
6
7
8
9
10
11

/*
 * Please do not include this file in generic code.  There is currently
 * no requirement for any architecture to implement anything held
 * within this file.
 *
 * Thanks. --rmk
 */

12
#include <linux/smp.h>
Linus Torvalds's avatar
Linus Torvalds committed
13

14
#ifndef CONFIG_S390
Linus Torvalds's avatar
Linus Torvalds committed
15
16
17
18
19

#include <linux/linkage.h>
#include <linux/cache.h>
#include <linux/spinlock.h>
#include <linux/cpumask.h>
20
#include <linux/gfp.h>
21
#include <linux/irqreturn.h>
22
#include <linux/irqnr.h>
23
#include <linux/errno.h>
24
#include <linux/topology.h>
25
#include <linux/wait.h>
Linus Torvalds's avatar
Linus Torvalds committed
26
27
28

#include <asm/irq.h>
#include <asm/ptrace.h>
29
#include <asm/irq_regs.h>
Linus Torvalds's avatar
Linus Torvalds committed
30

31
struct seq_file;
32
struct module;
33
struct irq_desc;
34
struct irq_data;
35
typedef	void (*irq_flow_handler_t)(unsigned int irq,
36
					    struct irq_desc *desc);
37
typedef	void (*irq_preflow_handler_t)(struct irq_data *data);
38

Linus Torvalds's avatar
Linus Torvalds committed
39
40
/*
 * IRQ line status.
41
 *
Thomas Gleixner's avatar
Thomas Gleixner committed
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 * Bits 0-7 are the same as the IRQF_* bits in linux/interrupt.h
 *
 * IRQ_TYPE_NONE		- default, unspecified type
 * IRQ_TYPE_EDGE_RISING		- rising edge triggered
 * IRQ_TYPE_EDGE_FALLING	- falling edge triggered
 * IRQ_TYPE_EDGE_BOTH		- rising and falling edge triggered
 * IRQ_TYPE_LEVEL_HIGH		- high level triggered
 * IRQ_TYPE_LEVEL_LOW		- low level triggered
 * IRQ_TYPE_LEVEL_MASK		- Mask to filter out the level bits
 * IRQ_TYPE_SENSE_MASK		- Mask for all the above bits
 * IRQ_TYPE_PROBE		- Special flag for probing in progress
 *
 * Bits which can be modified via irq_set/clear/modify_status_flags()
 * IRQ_LEVEL			- Interrupt is level type. Will be also
 *				  updated in the code when the above trigger
57
 *				  bits are modified via irq_set_irq_type()
Thomas Gleixner's avatar
Thomas Gleixner committed
58
59
60
61
62
 * IRQ_PER_CPU			- Mark an interrupt PER_CPU. Will protect
 *				  it from affinity setting
 * IRQ_NOPROBE			- Interrupt cannot be probed by autoprobing
 * IRQ_NOREQUEST		- Interrupt cannot be requested via
 *				  request_irq()
63
 * IRQ_NOTHREAD			- Interrupt cannot be threaded
Thomas Gleixner's avatar
Thomas Gleixner committed
64
65
66
67
68
 * IRQ_NOAUTOEN			- Interrupt is not automatically enabled in
 *				  request/setup_irq()
 * IRQ_NO_BALANCING		- Interrupt cannot be balanced (affinity set)
 * IRQ_MOVE_PCNTXT		- Interrupt can be migrated from process context
 * IRQ_NESTED_TRHEAD		- Interrupt nests into another thread
69
 * IRQ_PER_CPU_DEVID		- Dev_id is a per-cpu variable
Linus Torvalds's avatar
Linus Torvalds committed
70
 */
Thomas Gleixner's avatar
Thomas Gleixner committed
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
enum {
	IRQ_TYPE_NONE		= 0x00000000,
	IRQ_TYPE_EDGE_RISING	= 0x00000001,
	IRQ_TYPE_EDGE_FALLING	= 0x00000002,
	IRQ_TYPE_EDGE_BOTH	= (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING),
	IRQ_TYPE_LEVEL_HIGH	= 0x00000004,
	IRQ_TYPE_LEVEL_LOW	= 0x00000008,
	IRQ_TYPE_LEVEL_MASK	= (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH),
	IRQ_TYPE_SENSE_MASK	= 0x0000000f,

	IRQ_TYPE_PROBE		= 0x00000010,

	IRQ_LEVEL		= (1 <<  8),
	IRQ_PER_CPU		= (1 <<  9),
	IRQ_NOPROBE		= (1 << 10),
	IRQ_NOREQUEST		= (1 << 11),
	IRQ_NOAUTOEN		= (1 << 12),
	IRQ_NO_BALANCING	= (1 << 13),
	IRQ_MOVE_PCNTXT		= (1 << 14),
	IRQ_NESTED_THREAD	= (1 << 15),
91
	IRQ_NOTHREAD		= (1 << 16),
92
	IRQ_PER_CPU_DEVID	= (1 << 17),
Thomas Gleixner's avatar
Thomas Gleixner committed
93
};
94

95
96
#define IRQF_MODIFY_MASK	\
	(IRQ_TYPE_SENSE_MASK | IRQ_NOPROBE | IRQ_NOREQUEST | \
97
	 IRQ_NOAUTOEN | IRQ_MOVE_PCNTXT | IRQ_LEVEL | IRQ_NO_BALANCING | \
98
	 IRQ_PER_CPU | IRQ_NESTED_THREAD | IRQ_NOTHREAD | IRQ_PER_CPU_DEVID)
99

100
101
#define IRQ_NO_BALANCING_MASK	(IRQ_PER_CPU | IRQ_NO_BALANCING)

102
103
104
105
106
107
108
109
110
111
112
/*
 * Return value for chip->irq_set_affinity()
 *
 * IRQ_SET_MASK_OK	- OK, core updates irq_data.affinity
 * IRQ_SET_MASK_NOCPY	- OK, chip did update irq_data.affinity
 */
enum {
	IRQ_SET_MASK_OK = 0,
	IRQ_SET_MASK_OK_NOCOPY,
};

113
struct msi_desc;
114
struct irq_domain;
Thomas Gleixner's avatar
Thomas Gleixner committed
115

Thomas Gleixner's avatar
Thomas Gleixner committed
116
117
118
/**
 * struct irq_data - per irq and irq chip data passed down to chip functions
 * @irq:		interrupt number
119
 * @hwirq:		hardware interrupt number, local to the interrupt domain
Thomas Gleixner's avatar
Thomas Gleixner committed
120
 * @node:		node index useful for balancing
121
 * @state_use_accessors: status information for irq chip functions.
122
 *			Use accessor functions to deal with it
Thomas Gleixner's avatar
Thomas Gleixner committed
123
 * @chip:		low level interrupt hardware access
124
125
 * @domain:		Interrupt translation domain; responsible for mapping
 *			between hwirq number and linux irq number.
Thomas Gleixner's avatar
Thomas Gleixner committed
126
127
128
129
130
131
132
133
134
135
136
137
 * @handler_data:	per-IRQ data for the irq_chip methods
 * @chip_data:		platform-specific per-chip private data for the chip
 *			methods, to allow shared chip implementations
 * @msi_desc:		MSI descriptor
 * @affinity:		IRQ affinity on SMP
 *
 * The fields here need to overlay the ones in irq_desc until we
 * cleaned up the direct references and switched everything over to
 * irq_data.
 */
struct irq_data {
	unsigned int		irq;
138
	unsigned long		hwirq;
Thomas Gleixner's avatar
Thomas Gleixner committed
139
	unsigned int		node;
140
	unsigned int		state_use_accessors;
Thomas Gleixner's avatar
Thomas Gleixner committed
141
	struct irq_chip		*chip;
142
	struct irq_domain	*domain;
Thomas Gleixner's avatar
Thomas Gleixner committed
143
144
145
146
147
148
149
150
	void			*handler_data;
	void			*chip_data;
	struct msi_desc		*msi_desc;
#ifdef CONFIG_SMP
	cpumask_var_t		affinity;
#endif
};

151
152
153
/*
 * Bit masks for irq_data.state
 *
154
 * IRQD_TRIGGER_MASK		- Mask for the trigger type bits
155
 * IRQD_SETAFFINITY_PENDING	- Affinity setting is pending
156
157
 * IRQD_NO_BALANCING		- Balancing disabled for this IRQ
 * IRQD_PER_CPU			- Interrupt is per cpu
158
 * IRQD_AFFINITY_SET		- Interrupt affinity was set
159
 * IRQD_LEVEL			- Interrupt is level triggered
160
161
 * IRQD_WAKEUP_STATE		- Interrupt is configured for wakeup
 *				  from suspend
162
163
 * IRDQ_MOVE_PCNTXT		- Interrupt can be moved in process
 *				  context
164
165
166
 * IRQD_IRQ_DISABLED		- Disabled state of the interrupt
 * IRQD_IRQ_MASKED		- Masked state of the interrupt
 * IRQD_IRQ_INPROGRESS		- In progress state of the interrupt
167
168
 */
enum {
169
	IRQD_TRIGGER_MASK		= 0xf,
170
171
172
	IRQD_SETAFFINITY_PENDING	= (1 <<  8),
	IRQD_NO_BALANCING		= (1 << 10),
	IRQD_PER_CPU			= (1 << 11),
173
	IRQD_AFFINITY_SET		= (1 << 12),
174
	IRQD_LEVEL			= (1 << 13),
175
	IRQD_WAKEUP_STATE		= (1 << 14),
176
	IRQD_MOVE_PCNTXT		= (1 << 15),
177
	IRQD_IRQ_DISABLED		= (1 << 16),
178
179
	IRQD_IRQ_MASKED			= (1 << 17),
	IRQD_IRQ_INPROGRESS		= (1 << 18),
180
181
182
183
184
185
186
};

static inline bool irqd_is_setaffinity_pending(struct irq_data *d)
{
	return d->state_use_accessors & IRQD_SETAFFINITY_PENDING;
}

187
188
189
190
191
192
193
194
195
196
static inline bool irqd_is_per_cpu(struct irq_data *d)
{
	return d->state_use_accessors & IRQD_PER_CPU;
}

static inline bool irqd_can_balance(struct irq_data *d)
{
	return !(d->state_use_accessors & (IRQD_PER_CPU | IRQD_NO_BALANCING));
}

197
198
199
200
201
static inline bool irqd_affinity_was_set(struct irq_data *d)
{
	return d->state_use_accessors & IRQD_AFFINITY_SET;
}

202
203
204
205
206
static inline void irqd_mark_affinity_was_set(struct irq_data *d)
{
	d->state_use_accessors |= IRQD_AFFINITY_SET;
}

207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
static inline u32 irqd_get_trigger_type(struct irq_data *d)
{
	return d->state_use_accessors & IRQD_TRIGGER_MASK;
}

/*
 * Must only be called inside irq_chip.irq_set_type() functions.
 */
static inline void irqd_set_trigger_type(struct irq_data *d, u32 type)
{
	d->state_use_accessors &= ~IRQD_TRIGGER_MASK;
	d->state_use_accessors |= type & IRQD_TRIGGER_MASK;
}

static inline bool irqd_is_level_type(struct irq_data *d)
{
	return d->state_use_accessors & IRQD_LEVEL;
}

226
227
228
229
230
static inline bool irqd_is_wakeup_set(struct irq_data *d)
{
	return d->state_use_accessors & IRQD_WAKEUP_STATE;
}

231
232
233
234
235
static inline bool irqd_can_move_in_process_context(struct irq_data *d)
{
	return d->state_use_accessors & IRQD_MOVE_PCNTXT;
}

236
237
238
239
240
static inline bool irqd_irq_disabled(struct irq_data *d)
{
	return d->state_use_accessors & IRQD_IRQ_DISABLED;
}

241
242
243
244
245
246
247
248
249
250
static inline bool irqd_irq_masked(struct irq_data *d)
{
	return d->state_use_accessors & IRQD_IRQ_MASKED;
}

static inline bool irqd_irq_inprogress(struct irq_data *d)
{
	return d->state_use_accessors & IRQD_IRQ_INPROGRESS;
}

251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
/*
 * Functions for chained handlers which can be enabled/disabled by the
 * standard disable_irq/enable_irq calls. Must be called with
 * irq_desc->lock held.
 */
static inline void irqd_set_chained_irq_inprogress(struct irq_data *d)
{
	d->state_use_accessors |= IRQD_IRQ_INPROGRESS;
}

static inline void irqd_clr_chained_irq_inprogress(struct irq_data *d)
{
	d->state_use_accessors &= ~IRQD_IRQ_INPROGRESS;
}

266
267
268
269
270
static inline irq_hw_number_t irqd_to_hwirq(struct irq_data *d)
{
	return d->hwirq;
}

271
/**
Thomas Gleixner's avatar
Thomas Gleixner committed
272
 * struct irq_chip - hardware interrupt chip descriptor
273
274
 *
 * @name:		name for /proc/interrupts
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
 * @irq_startup:	start up the interrupt (defaults to ->enable if NULL)
 * @irq_shutdown:	shut down the interrupt (defaults to ->disable if NULL)
 * @irq_enable:		enable the interrupt (defaults to chip->unmask if NULL)
 * @irq_disable:	disable the interrupt
 * @irq_ack:		start of a new interrupt
 * @irq_mask:		mask an interrupt source
 * @irq_mask_ack:	ack and mask an interrupt source
 * @irq_unmask:		unmask an interrupt source
 * @irq_eoi:		end of interrupt
 * @irq_set_affinity:	set the CPU affinity on SMP machines
 * @irq_retrigger:	resend an IRQ to the CPU
 * @irq_set_type:	set the flow type (IRQ_TYPE_LEVEL/etc.) of an IRQ
 * @irq_set_wake:	enable/disable power-management wake-on of an IRQ
 * @irq_bus_lock:	function to lock access to slow bus (i2c) chips
 * @irq_bus_sync_unlock:function to sync and unlock slow bus (i2c) chips
290
291
 * @irq_cpu_online:	configure an interrupt source for a secondary CPU
 * @irq_cpu_offline:	un-configure an interrupt source for a secondary CPU
292
293
294
 * @irq_suspend:	function called from core code on suspend once per chip
 * @irq_resume:		function called from core code on resume once per chip
 * @irq_pm_shutdown:	function called from core code on shutdown once per chip
295
 * @irq_print_chip:	optional to print special chip info in show_interrupts
296
 * @flags:		chip specific flags
Thomas Gleixner's avatar
Thomas Gleixner committed
297
 *
298
 * @release:		release function solely used by UML
Linus Torvalds's avatar
Linus Torvalds committed
299
 */
Thomas Gleixner's avatar
Thomas Gleixner committed
300
301
struct irq_chip {
	const char	*name;
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
	unsigned int	(*irq_startup)(struct irq_data *data);
	void		(*irq_shutdown)(struct irq_data *data);
	void		(*irq_enable)(struct irq_data *data);
	void		(*irq_disable)(struct irq_data *data);

	void		(*irq_ack)(struct irq_data *data);
	void		(*irq_mask)(struct irq_data *data);
	void		(*irq_mask_ack)(struct irq_data *data);
	void		(*irq_unmask)(struct irq_data *data);
	void		(*irq_eoi)(struct irq_data *data);

	int		(*irq_set_affinity)(struct irq_data *data, const struct cpumask *dest, bool force);
	int		(*irq_retrigger)(struct irq_data *data);
	int		(*irq_set_type)(struct irq_data *data, unsigned int flow_type);
	int		(*irq_set_wake)(struct irq_data *data, unsigned int on);

	void		(*irq_bus_lock)(struct irq_data *data);
	void		(*irq_bus_sync_unlock)(struct irq_data *data);

321
322
323
	void		(*irq_cpu_online)(struct irq_data *data);
	void		(*irq_cpu_offline)(struct irq_data *data);

324
325
326
327
	void		(*irq_suspend)(struct irq_data *data);
	void		(*irq_resume)(struct irq_data *data);
	void		(*irq_pm_shutdown)(struct irq_data *data);

328
329
	void		(*irq_print_chip)(struct irq_data *data, struct seq_file *p);

330
331
	unsigned long	flags;

332
333
	/* Currently used only by UML, might disappear one day.*/
#ifdef CONFIG_IRQ_RELEASE_METHOD
334
	void		(*release)(unsigned int irq, void *dev_id);
335
#endif
Linus Torvalds's avatar
Linus Torvalds committed
336
337
};

338
339
340
/*
 * irq_chip specific flags
 *
341
342
 * IRQCHIP_SET_TYPE_MASKED:	Mask before calling chip.irq_set_type()
 * IRQCHIP_EOI_IF_HANDLED:	Only issue irq_eoi() when irq was handled
343
 * IRQCHIP_MASK_ON_SUSPEND:	Mask non wake irqs in the suspend path
344
345
 * IRQCHIP_ONOFFLINE_ENABLED:	Only call irq_on/off_line callbacks
 *				when irq enabled
346
 * IRQCHIP_SKIP_SET_WAKE:	Skip chip.irq_set_wake(), for this irq chip
347
348
349
 */
enum {
	IRQCHIP_SET_TYPE_MASKED		= (1 <<  0),
350
	IRQCHIP_EOI_IF_HANDLED		= (1 <<  1),
351
	IRQCHIP_MASK_ON_SUSPEND		= (1 <<  2),
352
	IRQCHIP_ONOFFLINE_ENABLED	= (1 <<  3),
353
	IRQCHIP_SKIP_SET_WAKE		= (1 <<  4),
354
355
};

Thomas Gleixner's avatar
Thomas Gleixner committed
356
357
/* This include will go away once we isolated irq_desc usage to core code */
#include <linux/irqdesc.h>
358

359
360
361
362
/*
 * Pick up the arch-dependent methods:
 */
#include <asm/hw_irq.h>
Linus Torvalds's avatar
Linus Torvalds committed
363

364
365
366
367
#ifndef NR_IRQS_LEGACY
# define NR_IRQS_LEGACY 0
#endif

368
369
370
371
#ifndef ARCH_IRQ_INIT_FLAGS
# define ARCH_IRQ_INIT_FLAGS	0
#endif

372
#define IRQ_DEFAULT_INIT_FLAGS	ARCH_IRQ_INIT_FLAGS
373

Thomas Gleixner's avatar
Thomas Gleixner committed
374
struct irqaction;
375
extern int setup_irq(unsigned int irq, struct irqaction *new);
376
extern void remove_irq(unsigned int irq, struct irqaction *act);
377
378
extern int setup_percpu_irq(unsigned int irq, struct irqaction *new);
extern void remove_percpu_irq(unsigned int irq, struct irqaction *act);
Linus Torvalds's avatar
Linus Torvalds committed
379

380
381
extern void irq_cpu_online(void);
extern void irq_cpu_offline(void);
382
extern int __irq_set_affinity_locked(struct irq_data *data,  const struct cpumask *cpumask);
383

Linus Torvalds's avatar
Linus Torvalds committed
384
#ifdef CONFIG_GENERIC_HARDIRQS
385

386
#if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_PENDING_IRQ)
387
388
void irq_move_irq(struct irq_data *data);
void irq_move_masked_irq(struct irq_data *data);
Thomas Gleixner's avatar
Thomas Gleixner committed
389
#else
390
391
static inline void irq_move_irq(struct irq_data *data) { }
static inline void irq_move_masked_irq(struct irq_data *data) { }
Thomas Gleixner's avatar
Thomas Gleixner committed
392
#endif
393

Linus Torvalds's avatar
Linus Torvalds committed
394
395
extern int no_irq_affinity;

Thomas Gleixner's avatar
Thomas Gleixner committed
396
397
/*
 * Built-in IRQ handlers for various IRQ types,
Krzysztof Halasa's avatar
Krzysztof Halasa committed
398
 * callable via desc->handle_irq()
Thomas Gleixner's avatar
Thomas Gleixner committed
399
 */
400
401
402
extern void handle_level_irq(unsigned int irq, struct irq_desc *desc);
extern void handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc);
extern void handle_edge_irq(unsigned int irq, struct irq_desc *desc);
403
extern void handle_edge_eoi_irq(unsigned int irq, struct irq_desc *desc);
404
405
extern void handle_simple_irq(unsigned int irq, struct irq_desc *desc);
extern void handle_percpu_irq(unsigned int irq, struct irq_desc *desc);
406
extern void handle_percpu_devid_irq(unsigned int irq, struct irq_desc *desc);
407
extern void handle_bad_irq(unsigned int irq, struct irq_desc *desc);
408
extern void handle_nested_irq(unsigned int irq);
Thomas Gleixner's avatar
Thomas Gleixner committed
409
410

/* Handling of unhandled and spurious interrupts: */
411
extern void note_interrupt(unsigned int irq, struct irq_desc *desc,
412
			   irqreturn_t action_ret);
Linus Torvalds's avatar
Linus Torvalds committed
413

414

Thomas Gleixner's avatar
Thomas Gleixner committed
415
416
417
418
419
420
/* Enable/disable irq debugging output: */
extern int noirqdebug_setup(char *str);

/* Checks whether the interrupt can be requested by request_irq(): */
extern int can_request_irq(unsigned int irq, unsigned long irqflags);

421
/* Dummy irq-chip implementations: */
Thomas Gleixner's avatar
Thomas Gleixner committed
422
extern struct irq_chip no_irq_chip;
423
extern struct irq_chip dummy_irq_chip;
Thomas Gleixner's avatar
Thomas Gleixner committed
424

425
extern void
426
irq_set_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
427
428
			      irq_flow_handler_t handle, const char *name);

429
430
431
432
433
434
static inline void irq_set_chip_and_handler(unsigned int irq, struct irq_chip *chip,
					    irq_flow_handler_t handle)
{
	irq_set_chip_and_handler_name(irq, chip, handle, NULL);
}

435
436
extern int irq_set_percpu_devid(unsigned int irq);

Thomas Gleixner's avatar
Thomas Gleixner committed
437
extern void
438
__irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
439
		  const char *name);
Linus Torvalds's avatar
Linus Torvalds committed
440

Thomas Gleixner's avatar
Thomas Gleixner committed
441
static inline void
442
irq_set_handler(unsigned int irq, irq_flow_handler_t handle)
Thomas Gleixner's avatar
Thomas Gleixner committed
443
{
444
	__irq_set_handler(irq, handle, 0, NULL);
Thomas Gleixner's avatar
Thomas Gleixner committed
445
446
447
448
449
}

/*
 * Set a highlevel chained flow handler for a given IRQ.
 * (a chained handler is automatically enabled and set to
450
 *  IRQ_NOREQUEST, IRQ_NOPROBE, and IRQ_NOTHREAD)
Thomas Gleixner's avatar
Thomas Gleixner committed
451
452
 */
static inline void
453
irq_set_chained_handler(unsigned int irq, irq_flow_handler_t handle)
Thomas Gleixner's avatar
Thomas Gleixner committed
454
{
455
	__irq_set_handler(irq, handle, 1, NULL);
Thomas Gleixner's avatar
Thomas Gleixner committed
456
457
}

458
459
460
461
462
463
464
465
466
467
468
469
void irq_modify_status(unsigned int irq, unsigned long clr, unsigned long set);

static inline void irq_set_status_flags(unsigned int irq, unsigned long set)
{
	irq_modify_status(irq, 0, set);
}

static inline void irq_clear_status_flags(unsigned int irq, unsigned long clr)
{
	irq_modify_status(irq, clr, 0);
}

Thomas Gleixner's avatar
Thomas Gleixner committed
470
static inline void irq_set_noprobe(unsigned int irq)
471
472
473
474
{
	irq_modify_status(irq, 0, IRQ_NOPROBE);
}

Thomas Gleixner's avatar
Thomas Gleixner committed
475
static inline void irq_set_probe(unsigned int irq)
476
477
478
{
	irq_modify_status(irq, IRQ_NOPROBE, 0);
}
Ralf Baechle's avatar
Ralf Baechle committed
479

480
481
482
483
484
485
486
487
488
489
static inline void irq_set_nothread(unsigned int irq)
{
	irq_modify_status(irq, 0, IRQ_NOTHREAD);
}

static inline void irq_set_thread(unsigned int irq)
{
	irq_modify_status(irq, IRQ_NOTHREAD, 0);
}

490
491
492
493
494
495
496
497
static inline void irq_set_nested_thread(unsigned int irq, bool nest)
{
	if (nest)
		irq_set_status_flags(irq, IRQ_NESTED_THREAD);
	else
		irq_clear_status_flags(irq, IRQ_NESTED_THREAD);
}

498
499
500
501
502
503
504
static inline void irq_set_percpu_devid_flags(unsigned int irq)
{
	irq_set_status_flags(irq,
			     IRQ_NOAUTOEN | IRQ_PER_CPU | IRQ_NOTHREAD |
			     IRQ_NOPROBE | IRQ_PER_CPU_DEVID);
}

505
/* Handle dynamic irq creation and destruction */
506
extern unsigned int create_irq_nr(unsigned int irq_want, int node);
507
508
509
extern int create_irq(void);
extern void destroy_irq(unsigned int irq);

510
511
512
513
/*
 * Dynamic irq helper functions. Obsolete. Use irq_alloc_desc* and
 * irq_free_desc instead.
 */
514
extern void dynamic_irq_cleanup(unsigned int irq);
515
516
517
518
static inline void dynamic_irq_init(unsigned int irq)
{
	dynamic_irq_cleanup(irq);
}
519

520
/* Set/get chip/data for an IRQ: */
Thomas Gleixner's avatar
Thomas Gleixner committed
521
522
523
524
525
extern int irq_set_chip(unsigned int irq, struct irq_chip *chip);
extern int irq_set_handler_data(unsigned int irq, void *data);
extern int irq_set_chip_data(unsigned int irq, void *data);
extern int irq_set_irq_type(unsigned int irq, unsigned int type);
extern int irq_set_msi_desc(unsigned int irq, struct msi_desc *entry);
526
extern struct irq_data *irq_get_irq_data(unsigned int irq);
527

Thomas Gleixner's avatar
Thomas Gleixner committed
528
static inline struct irq_chip *irq_get_chip(unsigned int irq)
529
530
531
532
533
534
535
536
537
538
{
	struct irq_data *d = irq_get_irq_data(irq);
	return d ? d->chip : NULL;
}

static inline struct irq_chip *irq_data_get_irq_chip(struct irq_data *d)
{
	return d->chip;
}

Thomas Gleixner's avatar
Thomas Gleixner committed
539
static inline void *irq_get_chip_data(unsigned int irq)
540
541
542
543
544
545
546
547
548
549
{
	struct irq_data *d = irq_get_irq_data(irq);
	return d ? d->chip_data : NULL;
}

static inline void *irq_data_get_irq_chip_data(struct irq_data *d)
{
	return d->chip_data;
}

Thomas Gleixner's avatar
Thomas Gleixner committed
550
static inline void *irq_get_handler_data(unsigned int irq)
551
552
553
554
555
{
	struct irq_data *d = irq_get_irq_data(irq);
	return d ? d->handler_data : NULL;
}

Thomas Gleixner's avatar
Thomas Gleixner committed
556
static inline void *irq_data_get_irq_handler_data(struct irq_data *d)
557
558
559
560
{
	return d->handler_data;
}

Thomas Gleixner's avatar
Thomas Gleixner committed
561
static inline struct msi_desc *irq_get_msi_desc(unsigned int irq)
562
563
564
565
566
567
568
569
570
571
{
	struct irq_data *d = irq_get_irq_data(irq);
	return d ? d->msi_desc : NULL;
}

static inline struct msi_desc *irq_data_get_msi(struct irq_data *d)
{
	return d->msi_desc;
}

572
573
574
int __irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node,
		struct module *owner);

575
576
577
/* use macros to avoid needing export.h for THIS_MODULE */
#define irq_alloc_descs(irq, from, cnt, node)	\
	__irq_alloc_descs(irq, from, cnt, node, THIS_MODULE)
578

579
580
#define irq_alloc_desc(node)			\
	irq_alloc_descs(-1, 0, 1, node)
581

582
583
#define irq_alloc_desc_at(at, node)		\
	irq_alloc_descs(at, at, 1, node)
584

585
586
#define irq_alloc_desc_from(from, node)		\
	irq_alloc_descs(-1, from, 1, node)
587

588
589
void irq_free_descs(unsigned int irq, unsigned int cnt);
int irq_reserve_irqs(unsigned int from, unsigned int cnt);
590
591
592
593
594
595

static inline void irq_free_desc(unsigned int irq)
{
	irq_free_descs(irq, 1);
}

596
597
598
599
600
static inline int irq_reserve_irq(unsigned int irq)
{
	return irq_reserve_irqs(irq, 1);
}

601
602
603
604
605
606
607
608
609
610
611
612
613
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
651
652
653
654
655
656
657
658
#ifndef irq_reg_writel
# define irq_reg_writel(val, addr)	writel(val, addr)
#endif
#ifndef irq_reg_readl
# define irq_reg_readl(addr)		readl(addr)
#endif

/**
 * struct irq_chip_regs - register offsets for struct irq_gci
 * @enable:	Enable register offset to reg_base
 * @disable:	Disable register offset to reg_base
 * @mask:	Mask register offset to reg_base
 * @ack:	Ack register offset to reg_base
 * @eoi:	Eoi register offset to reg_base
 * @type:	Type configuration register offset to reg_base
 * @polarity:	Polarity configuration register offset to reg_base
 */
struct irq_chip_regs {
	unsigned long		enable;
	unsigned long		disable;
	unsigned long		mask;
	unsigned long		ack;
	unsigned long		eoi;
	unsigned long		type;
	unsigned long		polarity;
};

/**
 * struct irq_chip_type - Generic interrupt chip instance for a flow type
 * @chip:		The real interrupt chip which provides the callbacks
 * @regs:		Register offsets for this chip
 * @handler:		Flow handler associated with this chip
 * @type:		Chip can handle these flow types
 *
 * A irq_generic_chip can have several instances of irq_chip_type when
 * it requires different functions and register offsets for different
 * flow types.
 */
struct irq_chip_type {
	struct irq_chip		chip;
	struct irq_chip_regs	regs;
	irq_flow_handler_t	handler;
	u32			type;
};

/**
 * struct irq_chip_generic - Generic irq chip data structure
 * @lock:		Lock to protect register and cache data access
 * @reg_base:		Register base address (virtual)
 * @irq_base:		Interrupt base nr for this chip
 * @irq_cnt:		Number of interrupts handled by this chip
 * @mask_cache:		Cached mask register
 * @type_cache:		Cached type register
 * @polarity_cache:	Cached polarity register
 * @wake_enabled:	Interrupt can wakeup from suspend
 * @wake_active:	Interrupt is marked as an wakeup from suspend source
 * @num_ct:		Number of available irq_chip_type instances (usually 1)
 * @private:		Private data for non generic chip callbacks
659
 * @list:		List head for keeping track of instances
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
 * @chip_types:		Array of interrupt irq_chip_types
 *
 * Note, that irq_chip_generic can have multiple irq_chip_type
 * implementations which can be associated to a particular irq line of
 * an irq_chip_generic instance. That allows to share and protect
 * state in an irq_chip_generic instance when we need to implement
 * different flow mechanisms (level/edge) for it.
 */
struct irq_chip_generic {
	raw_spinlock_t		lock;
	void __iomem		*reg_base;
	unsigned int		irq_base;
	unsigned int		irq_cnt;
	u32			mask_cache;
	u32			type_cache;
	u32			polarity_cache;
	u32			wake_enabled;
	u32			wake_active;
	unsigned int		num_ct;
	void			*private;
680
	struct list_head	list;
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
	struct irq_chip_type	chip_types[0];
};

/**
 * enum irq_gc_flags - Initialization flags for generic irq chips
 * @IRQ_GC_INIT_MASK_CACHE:	Initialize the mask_cache by reading mask reg
 * @IRQ_GC_INIT_NESTED_LOCK:	Set the lock class of the irqs to nested for
 *				irq chips which need to call irq_set_wake() on
 *				the parent irq. Usually GPIO implementations
 */
enum irq_gc_flags {
	IRQ_GC_INIT_MASK_CACHE		= 1 << 0,
	IRQ_GC_INIT_NESTED_LOCK		= 1 << 1,
};

/* Generic chip callback functions */
void irq_gc_noop(struct irq_data *d);
void irq_gc_mask_disable_reg(struct irq_data *d);
void irq_gc_mask_set_bit(struct irq_data *d);
void irq_gc_mask_clr_bit(struct irq_data *d);
void irq_gc_unmask_enable_reg(struct irq_data *d);
702
703
void irq_gc_ack_set_bit(struct irq_data *d);
void irq_gc_ack_clr_bit(struct irq_data *d);
704
705
706
707
708
709
710
711
712
713
714
715
void irq_gc_mask_disable_reg_and_ack(struct irq_data *d);
void irq_gc_eoi(struct irq_data *d);
int irq_gc_set_wake(struct irq_data *d, unsigned int on);

/* Setup functions for irq_chip_generic */
struct irq_chip_generic *
irq_alloc_generic_chip(const char *name, int nr_ct, unsigned int irq_base,
		       void __iomem *reg_base, irq_flow_handler_t handler);
void irq_setup_generic_chip(struct irq_chip_generic *gc, u32 msk,
			    enum irq_gc_flags flags, unsigned int clr,
			    unsigned int set);
int irq_setup_alt_chip(struct irq_data *d, unsigned int type);
716
717
void irq_remove_generic_chip(struct irq_chip_generic *gc, u32 msk,
			     unsigned int clr, unsigned int set);
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740

static inline struct irq_chip_type *irq_data_get_chip_type(struct irq_data *d)
{
	return container_of(d->chip, struct irq_chip_type, chip);
}

#define IRQ_MSK(n) (u32)((n) < 32 ? ((1 << (n)) - 1) : UINT_MAX)

#ifdef CONFIG_SMP
static inline void irq_gc_lock(struct irq_chip_generic *gc)
{
	raw_spin_lock(&gc->lock);
}

static inline void irq_gc_unlock(struct irq_chip_generic *gc)
{
	raw_spin_unlock(&gc->lock);
}
#else
static inline void irq_gc_lock(struct irq_chip_generic *gc) { }
static inline void irq_gc_unlock(struct irq_chip_generic *gc) { }
#endif

Thomas Gleixner's avatar
Thomas Gleixner committed
741
#endif /* CONFIG_GENERIC_HARDIRQS */
Linus Torvalds's avatar
Linus Torvalds committed
742

743
#endif /* !CONFIG_S390 */
Linus Torvalds's avatar
Linus Torvalds committed
744

745
#endif /* _LINUX_IRQ_H */