irq.h 16.9 KB
Newer Older
1 2
#ifndef _LINUX_IRQ_H
#define _LINUX_IRQ_H
L
Linus Torvalds 已提交
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>
L
Linus Torvalds 已提交
13

14
#ifndef CONFIG_S390
L
Linus Torvalds 已提交
15 16 17 18 19

#include <linux/linkage.h>
#include <linux/cache.h>
#include <linux/spinlock.h>
#include <linux/cpumask.h>
R
Ralf Baechle 已提交
20
#include <linux/gfp.h>
21
#include <linux/irqreturn.h>
T
Thomas Gleixner 已提交
22
#include <linux/irqnr.h>
D
David Howells 已提交
23
#include <linux/errno.h>
R
Ralf Baechle 已提交
24
#include <linux/topology.h>
25
#include <linux/wait.h>
L
Linus Torvalds 已提交
26 27 28

#include <asm/irq.h>
#include <asm/ptrace.h>
29
#include <asm/irq_regs.h>
L
Linus Torvalds 已提交
30

31
struct irq_desc;
32
typedef	void (*irq_flow_handler_t)(unsigned int irq,
33
					    struct irq_desc *desc);
34 35


L
Linus Torvalds 已提交
36 37
/*
 * IRQ line status.
38
 *
T
Thomas Gleixner 已提交
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
 * 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
 *				  bits are modified via set_irq_type()
 * 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()
 * 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
 *
 * Deprecated bits. They are kept updated as long as
 * CONFIG_GENERIC_HARDIRQS_NO_COMPAT is not set. Will go away soon. These bits
 * are internal state of the core code and if you really need to acces
 * them then talk to the genirq maintainer instead of hacking
 * something weird.
71
 *
L
Linus Torvalds 已提交
72
 */
T
Thomas Gleixner 已提交
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
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),
93 94

#ifndef CONFIG_GENERIC_HARDIRQS_NO_COMPAT
T
Thomas Gleixner 已提交
95 96 97 98 99 100 101 102 103
	IRQ_INPROGRESS		= (1 << 16),
	IRQ_REPLAY		= (1 << 17),
	IRQ_WAITING		= (1 << 18),
	IRQ_DISABLED		= (1 << 19),
	IRQ_PENDING		= (1 << 20),
	IRQ_MASKED		= (1 << 21),
	IRQ_MOVE_PENDING	= (1 << 22),
	IRQ_AFFINITY_SET	= (1 << 23),
	IRQ_WAKEUP		= (1 << 24),
104
#endif
T
Thomas Gleixner 已提交
105
};
106

T
Thomas Gleixner 已提交
107 108
#define IRQF_MODIFY_MASK	\
	(IRQ_TYPE_SENSE_MASK | IRQ_NOPROBE | IRQ_NOREQUEST | \
109
	 IRQ_NOAUTOEN | IRQ_MOVE_PCNTXT | IRQ_LEVEL | IRQ_NO_BALANCING | \
110
	 IRQ_PER_CPU | IRQ_NESTED_THREAD)
T
Thomas Gleixner 已提交
111

112 113 114 115 116 117
#define IRQ_NO_BALANCING_MASK	(IRQ_PER_CPU | IRQ_NO_BALANCING)

static inline __deprecated bool CHECK_IRQ_PER_CPU(unsigned int status)
{
	return status & IRQ_PER_CPU;
}
L
Linus Torvalds 已提交
118

119 120 121 122 123 124 125 126 127 128 129
/*
 * 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,
};

130
struct msi_desc;
T
Thomas Gleixner 已提交
131

T
Thomas Gleixner 已提交
132 133 134 135
/**
 * struct irq_data - per irq and irq chip data passed down to chip functions
 * @irq:		interrupt number
 * @node:		node index useful for balancing
136 137
 * @state_use_accessor: status information for irq chip functions.
 *			Use accessor functions to deal with it
T
Thomas Gleixner 已提交
138 139 140 141 142 143 144 145 146 147 148 149 150 151
 * @chip:		low level interrupt hardware access
 * @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;
	unsigned int		node;
152
	unsigned int		state_use_accessors;
T
Thomas Gleixner 已提交
153 154 155 156 157 158 159 160 161
	struct irq_chip		*chip;
	void			*handler_data;
	void			*chip_data;
	struct msi_desc		*msi_desc;
#ifdef CONFIG_SMP
	cpumask_var_t		affinity;
#endif
};

162 163 164
/*
 * Bit masks for irq_data.state
 *
165
 * IRQD_TRIGGER_MASK		- Mask for the trigger type bits
166
 * IRQD_SETAFFINITY_PENDING	- Affinity setting is pending
167 168
 * IRQD_NO_BALANCING		- Balancing disabled for this IRQ
 * IRQD_PER_CPU			- Interrupt is per cpu
169
 * IRQD_AFFINITY_SET		- Interrupt affinity was set
170
 * IRQD_LEVEL			- Interrupt is level triggered
171 172
 */
enum {
173
	IRQD_TRIGGER_MASK		= 0xf,
174 175 176
	IRQD_SETAFFINITY_PENDING	= (1 <<  8),
	IRQD_NO_BALANCING		= (1 << 10),
	IRQD_PER_CPU			= (1 << 11),
177
	IRQD_AFFINITY_SET		= (1 << 12),
178
	IRQD_LEVEL			= (1 << 13),
179 180 181 182 183 184 185
};

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

186 187 188 189 190 191 192 193 194 195
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));
}

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

201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
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;
}

220
/**
T
Thomas Gleixner 已提交
221
 * struct irq_chip - hardware interrupt chip descriptor
222 223
 *
 * @name:		name for /proc/interrupts
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
 * @startup:		deprecated, replaced by irq_startup
 * @shutdown:		deprecated, replaced by irq_shutdown
 * @enable:		deprecated, replaced by irq_enable
 * @disable:		deprecated, replaced by irq_disable
 * @ack:		deprecated, replaced by irq_ack
 * @mask:		deprecated, replaced by irq_mask
 * @mask_ack:		deprecated, replaced by irq_mask_ack
 * @unmask:		deprecated, replaced by irq_unmask
 * @eoi:		deprecated, replaced by irq_eoi
 * @end:		deprecated, will go away with __do_IRQ()
 * @set_affinity:	deprecated, replaced by irq_set_affinity
 * @retrigger:		deprecated, replaced by irq_retrigger
 * @set_type:		deprecated, replaced by irq_set_type
 * @set_wake:		deprecated, replaced by irq_wake
 * @bus_lock:		deprecated, replaced by irq_bus_lock
 * @bus_sync_unlock:	deprecated, replaced by irq_bus_sync_unlock
240
 *
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
 * @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
T
Thomas Gleixner 已提交
256
 * @flags:		chip specific flags
T
Thomas Gleixner 已提交
257
 *
258
 * @release:		release function solely used by UML
L
Linus Torvalds 已提交
259
 */
T
Thomas Gleixner 已提交
260 261
struct irq_chip {
	const char	*name;
262
#ifndef CONFIG_GENERIC_HARDIRQS_NO_DEPRECATED
263 264 265 266
	unsigned int	(*startup)(unsigned int irq);
	void		(*shutdown)(unsigned int irq);
	void		(*enable)(unsigned int irq);
	void		(*disable)(unsigned int irq);
T
Thomas Gleixner 已提交
267

268
	void		(*ack)(unsigned int irq);
T
Thomas Gleixner 已提交
269 270 271
	void		(*mask)(unsigned int irq);
	void		(*mask_ack)(unsigned int irq);
	void		(*unmask)(unsigned int irq);
272
	void		(*eoi)(unsigned int irq);
T
Thomas Gleixner 已提交
273

274
	void		(*end)(unsigned int irq);
275
	int		(*set_affinity)(unsigned int irq,
276
					const struct cpumask *dest);
277
	int		(*retrigger)(unsigned int irq);
T
Thomas Gleixner 已提交
278 279
	int		(*set_type)(unsigned int irq, unsigned int flow_type);
	int		(*set_wake)(unsigned int irq, unsigned int on);
280

T
Thomas Gleixner 已提交
281 282
	void		(*bus_lock)(unsigned int irq);
	void		(*bus_sync_unlock)(unsigned int irq);
283
#endif
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
	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);

T
Thomas Gleixner 已提交
303 304
	unsigned long	flags;

305 306
	/* Currently used only by UML, might disappear one day.*/
#ifdef CONFIG_IRQ_RELEASE_METHOD
307
	void		(*release)(unsigned int irq, void *dev_id);
308
#endif
L
Linus Torvalds 已提交
309 310
};

T
Thomas Gleixner 已提交
311 312
/* This include will go away once we isolated irq_desc usage to core code */
#include <linux/irqdesc.h>
313

314 315 316 317
/*
 * Pick up the arch-dependent methods:
 */
#include <asm/hw_irq.h>
L
Linus Torvalds 已提交
318

319 320 321 322
#ifndef NR_IRQS_LEGACY
# define NR_IRQS_LEGACY 0
#endif

323 324 325 326
#ifndef ARCH_IRQ_INIT_FLAGS
# define ARCH_IRQ_INIT_FLAGS	0
#endif

327
#define IRQ_DEFAULT_INIT_FLAGS	ARCH_IRQ_INIT_FLAGS
328

T
Thomas Gleixner 已提交
329
struct irqaction;
330
extern int setup_irq(unsigned int irq, struct irqaction *new);
331
extern void remove_irq(unsigned int irq, struct irqaction *act);
L
Linus Torvalds 已提交
332 333

#ifdef CONFIG_GENERIC_HARDIRQS
334

T
Thomas Gleixner 已提交
335
#if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_PENDING_IRQ)
336
void move_native_irq(int irq);
337
void move_masked_irq(int irq);
T
Thomas Gleixner 已提交
338 339 340 341
#else
static inline void move_native_irq(int irq) { }
static inline void move_masked_irq(int irq) { }
#endif
342

L
Linus Torvalds 已提交
343 344
extern int no_irq_affinity;

T
Thomas Gleixner 已提交
345
/* Handle irq action chains: */
346
extern irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action);
T
Thomas Gleixner 已提交
347 348 349

/*
 * Built-in IRQ handlers for various IRQ types,
K
Krzysztof Halasa 已提交
350
 * callable via desc->handle_irq()
T
Thomas Gleixner 已提交
351
 */
352 353 354 355 356 357
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);
extern void handle_simple_irq(unsigned int irq, struct irq_desc *desc);
extern void handle_percpu_irq(unsigned int irq, struct irq_desc *desc);
extern void handle_bad_irq(unsigned int irq, struct irq_desc *desc);
358
extern void handle_nested_irq(unsigned int irq);
T
Thomas Gleixner 已提交
359 360

/* Handling of unhandled and spurious interrupts: */
361
extern void note_interrupt(unsigned int irq, struct irq_desc *desc,
362
			   irqreturn_t action_ret);
L
Linus Torvalds 已提交
363

364

T
Thomas Gleixner 已提交
365 366 367 368 369 370
/* 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);

371
/* Dummy irq-chip implementations: */
T
Thomas Gleixner 已提交
372
extern struct irq_chip no_irq_chip;
373
extern struct irq_chip dummy_irq_chip;
T
Thomas Gleixner 已提交
374

375 376 377
extern void
set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
			 irq_flow_handler_t handle);
T
Thomas Gleixner 已提交
378
extern void
379 380 381
set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
			      irq_flow_handler_t handle, const char *name);

T
Thomas Gleixner 已提交
382
extern void
383 384
__set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
		  const char *name);
L
Linus Torvalds 已提交
385

T
Thomas Gleixner 已提交
386 387 388 389
/*
 * Set a highlevel flow handler for a given IRQ:
 */
static inline void
390
set_irq_handler(unsigned int irq, irq_flow_handler_t handle)
T
Thomas Gleixner 已提交
391
{
392
	__set_irq_handler(irq, handle, 0, NULL);
T
Thomas Gleixner 已提交
393 394 395 396 397 398 399 400
}

/*
 * Set a highlevel chained flow handler for a given IRQ.
 * (a chained handler is automatically enabled and set to
 *  IRQ_NOREQUEST and IRQ_NOPROBE)
 */
static inline void
T
Thomas Gleixner 已提交
401
set_irq_chained_handler(unsigned int irq, irq_flow_handler_t handle)
T
Thomas Gleixner 已提交
402
{
403
	__set_irq_handler(irq, handle, 1, NULL);
T
Thomas Gleixner 已提交
404 405
}

T
Thomas Gleixner 已提交
406 407 408 409 410 411 412 413 414 415 416 417
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);
}

T
Thomas Gleixner 已提交
418
static inline void irq_set_noprobe(unsigned int irq)
T
Thomas Gleixner 已提交
419 420 421 422
{
	irq_modify_status(irq, 0, IRQ_NOPROBE);
}

T
Thomas Gleixner 已提交
423
static inline void irq_set_probe(unsigned int irq)
T
Thomas Gleixner 已提交
424 425 426
{
	irq_modify_status(irq, IRQ_NOPROBE, 0);
}
R
Ralf Baechle 已提交
427

428 429 430 431 432 433 434 435
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);
}

436
/* Handle dynamic irq creation and destruction */
437
extern unsigned int create_irq_nr(unsigned int irq_want, int node);
438 439 440
extern int create_irq(void);
extern void destroy_irq(unsigned int irq);

441 442 443 444
/*
 * Dynamic irq helper functions. Obsolete. Use irq_alloc_desc* and
 * irq_free_desc instead.
 */
445
extern void dynamic_irq_cleanup(unsigned int irq);
446 447 448 449
static inline void dynamic_irq_init(unsigned int irq)
{
	dynamic_irq_cleanup(irq);
}
450

451
/* Set/get chip/data for an IRQ: */
T
Thomas Gleixner 已提交
452 453 454 455 456
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);
457
extern struct irq_data *irq_get_irq_data(unsigned int irq);
458

T
Thomas Gleixner 已提交
459
static inline struct irq_chip *irq_get_chip(unsigned int irq)
460 461 462 463 464 465 466 467 468 469
{
	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;
}

T
Thomas Gleixner 已提交
470
static inline void *irq_get_chip_data(unsigned int irq)
471 472 473 474 475 476 477 478 479 480
{
	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;
}

T
Thomas Gleixner 已提交
481
static inline void *irq_get_handler_data(unsigned int irq)
482 483 484 485 486
{
	struct irq_data *d = irq_get_irq_data(irq);
	return d ? d->handler_data : NULL;
}

T
Thomas Gleixner 已提交
487
static inline void *irq_data_get_irq_handler_data(struct irq_data *d)
488 489 490 491
{
	return d->handler_data;
}

T
Thomas Gleixner 已提交
492
static inline struct msi_desc *irq_get_msi_desc(unsigned int irq)
493 494 495 496 497 498 499 500 501 502
{
	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;
}

T
Thomas Gleixner 已提交
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552
#ifndef CONFIG_GENERIC_HARDIRQS_NO_COMPAT
/* Please do not use: Use the replacement functions instead */
static inline int set_irq_chip(unsigned int irq, struct irq_chip *chip)
{
	return irq_set_chip(irq, chip);
}
static inline int set_irq_data(unsigned int irq, void *data)
{
	return irq_set_handler_data(irq, data);
}
static inline int set_irq_chip_data(unsigned int irq, void *data)
{
	return irq_set_chip_data(irq, data);
}
static inline int set_irq_type(unsigned int irq, unsigned int type)
{
	return irq_set_irq_type(irq, type);
}
static inline int set_irq_msi(unsigned int irq, struct msi_desc *entry)
{
	return irq_set_msi_desc(irq, entry);
}
static inline struct irq_chip *get_irq_chip(unsigned int irq)
{
	return irq_get_chip(irq);
}
static inline void *get_irq_chip_data(unsigned int irq)
{
	return irq_get_chip_data(irq);
}
static inline void *get_irq_data(unsigned int irq)
{
	return irq_get_handler_data(irq);
}
static inline void *irq_data_get_irq_data(struct irq_data *d)
{
	return irq_data_get_irq_handler_data(d);
}
static inline struct msi_desc *get_irq_msi(unsigned int irq)
{
	return irq_get_msi_desc(irq);
}
static inline void set_irq_noprobe(unsigned int irq)
{
	irq_set_noprobe(irq);
}
static inline void set_irq_probe(unsigned int irq)
{
	irq_set_probe(irq);
}
553 554 555 556
static inline void set_irq_nested_thread(unsigned int irq, int nest)
{
	irq_set_nested_thread(irq, nest);
}
T
Thomas Gleixner 已提交
557 558
#endif

559 560
int irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node);
void irq_free_descs(unsigned int irq, unsigned int cnt);
561
int irq_reserve_irqs(unsigned int from, unsigned int cnt);
562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582

static inline int irq_alloc_desc(int node)
{
	return irq_alloc_descs(-1, 0, 1, node);
}

static inline int irq_alloc_desc_at(unsigned int at, int node)
{
	return irq_alloc_descs(at, at, 1, node);
}

static inline int irq_alloc_desc_from(unsigned int from, int node)
{
	return irq_alloc_descs(-1, from, 1, node);
}

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

583 584 585 586 587
static inline int irq_reserve_irq(unsigned int irq)
{
	return irq_reserve_irqs(irq, 1);
}

T
Thomas Gleixner 已提交
588
#endif /* CONFIG_GENERIC_HARDIRQS */
L
Linus Torvalds 已提交
589

590
#endif /* !CONFIG_S390 */
L
Linus Torvalds 已提交
591

592
#endif /* _LINUX_IRQ_H */