/**

 * struct irq_chip - hardware interrupt chip descriptor

 *

 * @name:		name for /proc/interrupts

 * @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

 * @irq_cpu_online:	configure an interrupt source for a secondary CPU

 * @irq_cpu_offline:	un-configure an interrupt source for a secondary CPU

 * @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

 * @irq_print_chip:	optional to print special chip info in show_interrupts

 * @flags:		chip specific flags

 */

struct irq_chip {

	const char	*name;

	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);

	void		(*irq_cpu_online)(struct irq_data *data);

	void		(*irq_cpu_offline)(struct irq_data *data);

	void		(*irq_suspend)(struct irq_data *data);

	void		(*irq_resume)(struct irq_data *data);

	void		(*irq_pm_shutdown)(struct irq_data *data);

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

	unsigned long	flags;

};

/**

 * struct irq_data - per irq and irq chip data passed down to chip functions

 * @irq:		interrupt number

 * @hwirq:		hardware interrupt number, local to the interrupt domain

 * @node:		node index useful for balancing

 * @state_use_accessors: status information for irq chip functions.

 *			Use accessor functions to deal with it

 * @chip:		low level interrupt hardware access

 * @domain:		Interrupt translation domain; responsible for mapping

 *			between hwirq number and linux irq number.

 * @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 long		hwirq;

	unsigned int		node;

	unsigned int		state_use_accessors;

	struct irq_chip		*chip;

	struct irq_domain	*domain;

	void			*handler_data;

	void			*chip_data;

	struct msi_desc		*msi_desc;

	cpumask_var_t		affinity;

};

/**

 * struct irq_desc - interrupt descriptor

 * @irq_data:		per irq and chip data passed down to chip functions

 * @kstat_irqs:		irq stats per cpu

 * @handle_irq:		highlevel irq-events handler

 * @preflow_handler:	handler called before the flow handler (currently used by sparc)

 * @action:		the irq action chain

 * @status:		status information

 * @core_internal_state__do_not_mess_with_it: core internal status information

 * @depth:		disable-depth, for nested irq_disable() calls

 * @wake_depth:		enable depth, for multiple irq_set_irq_wake() callers

 * @irq_count:		stats field to detect stalled irqs

 * @last_unhandled:	aging timer for unhandled count

 * @irqs_unhandled:	stats field for spurious unhandled interrupts

 * @lock:		locking for SMP

 * @affinity_hint:	hint to user space for preferred irq affinity

 * @affinity_notify:	context for notification of affinity changes

 * @pending_mask:	pending rebalanced interrupts

 * @threads_oneshot:	bitfield to handle shared oneshot threads

 * @threads_active:	number of irqaction threads currently running

 * @wait_for_threads:	wait queue for sync_irq to wait for threaded handlers

 * @dir:		/proc/irq/ procfs entry

 * @name:		flow handler name for /proc/interrupts output

 */

struct irq_desc {

	struct irq_data		irq_data;

	unsigned int __percpu	*kstat_irqs;

	irq_flow_handler_t	handle_irq;

#ifdef CONFIG_IRQ_PREFLOW_FASTEOI

	irq_preflow_handler_t	preflow_handler;

#endif

	struct irqaction	*action;	/* IRQ action list */

	unsigned int		status_use_accessors;

	unsigned int		core_internal_state__do_not_mess_with_it;

	unsigned int		depth;		/* nested irq disables */

	unsigned int		wake_depth;	/* nested wake enables */

	unsigned int		irq_count;	/* For detecting broken IRQs */

	unsigned long		last_unhandled;	/* Aging timer for unhandled count */

	unsigned int		irqs_unhandled;

	u64			random_ip;

	raw_spinlock_t		lock;

	struct cpumask		*percpu_enabled;

#ifdef CONFIG_SMP

	const struct cpumask	*affinity_hint;

	struct irq_affinity_notify *affinity_notify;

#ifdef CONFIG_GENERIC_PENDING_IRQ

	cpumask_var_t		pending_mask;

#endif

#endif

	unsigned long		threads_oneshot;

	atomic_t		threads_active;

	wait_queue_head_t       wait_for_threads;

#ifdef CONFIG_PROC_FS

	struct proc_dir_entry	*dir;

#endif

	int			parent_irq;

	struct module		*owner;

	const char		*name;

} ____cacheline_internodealigned_in_smp;