License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 21:07:57 +07:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2006-06-29 16:24:40 +07:00
|
|
|
#ifndef _LINUX_IRQ_H
|
|
|
|
|
#define _LINUX_IRQ_H
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/cache.h>
|
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
|
#include <linux/cpumask.h>
|
2014-11-12 03:58:34 +07:00
|
|
|
#include <linux/irqhandler.h>
|
2006-06-23 16:06:00 +07:00
|
|
|
#include <linux/irqreturn.h>
|
2008-10-16 23:20:58 +07:00
|
|
|
#include <linux/irqnr.h>
|
2009-03-29 17:59:50 +07:00
|
|
|
#include <linux/topology.h>
|
2014-11-07 13:44:17 +07:00
|
|
|
#include <linux/io.h>
|
2017-05-31 23:06:56 +07:00
|
|
|
#include <linux/slab.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
#include <asm/irq.h>
|
|
|
|
|
#include <asm/ptrace.h>
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 20:55:46 +07:00
|
|
|
#include <asm/irq_regs.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-03-25 22:48:50 +07:00
|
|
|
struct seq_file;
|
2011-09-20 07:33:19 +07:00
|
|
|
struct module;
|
2014-11-06 21:20:17 +07:00
|
|
|
struct msi_msg;
|
2015-03-18 18:01:22 +07:00
|
|
|
enum irqchip_irq_state;
|
2006-10-05 19:06:34 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
|
* IRQ line status.
|
2006-07-02 09:29:03 +07:00
|
|
|
*
|
2011-02-08 23:27:18 +07:00
|
|
|
* 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
|
2012-04-20 00:29:42 +07:00
|
|
|
* IRQ_TYPE_DEFAULT - For use by some PICs to ask irq_set_type
|
|
|
|
|
* to setup the HW to a sane default (used
|
|
|
|
|
* by irqdomain map() callbacks to synchronize
|
|
|
|
|
* the HW state and SW flags for a newly
|
|
|
|
|
* allocated descriptor).
|
|
|
|
|
*
|
2011-02-08 23:27:18 +07:00
|
|
|
* 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
|
2011-04-10 16:01:51 +07:00
|
|
|
* bits are modified via irq_set_irq_type()
|
2011-02-08 23:27:18 +07:00
|
|
|
* 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()
|
2011-04-07 04:01:44 +07:00
|
|
|
* IRQ_NOTHREAD - Interrupt cannot be threaded
|
2011-02-08 23:27:18 +07:00
|
|
|
* 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
|
2015-10-01 19:54:52 +07:00
|
|
|
* IRQ_NESTED_THREAD - Interrupt nests into another thread
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-23 23:03:06 +07:00
|
|
|
* IRQ_PER_CPU_DEVID - Dev_id is a per-cpu variable
|
2013-11-06 18:30:07 +07:00
|
|
|
* IRQ_IS_POLLED - Always polled by another interrupt. Exclude
|
|
|
|
|
* it from the spurious interrupt detection
|
|
|
|
|
* mechanism and from core side polling.
|
2015-10-10 04:28:58 +07:00
|
|
|
* IRQ_DISABLE_UNLAZY - Disable lazy irq disable
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2011-02-08 23:27:18 +07:00
|
|
|
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,
|
2012-04-20 00:29:42 +07:00
|
|
|
IRQ_TYPE_DEFAULT = IRQ_TYPE_SENSE_MASK,
|
2011-02-08 23:27:18 +07:00
|
|
|
|
|
|
|
|
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),
|
2011-04-07 04:01:44 +07:00
|
|
|
IRQ_NOTHREAD = (1 << 16),
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-23 23:03:06 +07:00
|
|
|
IRQ_PER_CPU_DEVID = (1 << 17),
|
2013-11-06 18:30:07 +07:00
|
|
|
IRQ_IS_POLLED = (1 << 18),
|
2015-10-10 04:28:58 +07:00
|
|
|
IRQ_DISABLE_UNLAZY = (1 << 19),
|
2011-02-08 23:27:18 +07:00
|
|
|
};
|
2007-02-16 16:27:24 +07:00
|
|
|
|
2010-09-28 15:40:18 +07:00
|
|
|
#define IRQF_MODIFY_MASK \
|
|
|
|
|
(IRQ_TYPE_SENSE_MASK | IRQ_NOPROBE | IRQ_NOREQUEST | \
|
2011-02-05 22:25:25 +07:00
|
|
|
IRQ_NOAUTOEN | IRQ_MOVE_PCNTXT | IRQ_LEVEL | IRQ_NO_BALANCING | \
|
2013-11-06 18:30:07 +07:00
|
|
|
IRQ_PER_CPU | IRQ_NESTED_THREAD | IRQ_NOTHREAD | IRQ_PER_CPU_DEVID | \
|
2015-10-10 04:28:58 +07:00
|
|
|
IRQ_IS_POLLED | IRQ_DISABLE_UNLAZY)
|
2010-09-28 15:40:18 +07:00
|
|
|
|
2011-02-08 22:50:00 +07:00
|
|
|
#define IRQ_NO_BALANCING_MASK (IRQ_PER_CPU | IRQ_NO_BALANCING)
|
|
|
|
|
|
2011-02-07 22:02:20 +07:00
|
|
|
/*
|
|
|
|
|
* Return value for chip->irq_set_affinity()
|
|
|
|
|
*
|
2015-06-03 10:47:50 +07:00
|
|
|
* IRQ_SET_MASK_OK - OK, core updates irq_common_data.affinity
|
|
|
|
|
* IRQ_SET_MASK_NOCPY - OK, chip did update irq_common_data.affinity
|
2014-11-06 21:20:18 +07:00
|
|
|
* IRQ_SET_MASK_OK_DONE - Same as IRQ_SET_MASK_OK for core. Special code to
|
|
|
|
|
* support stacked irqchips, which indicates skipping
|
|
|
|
|
* all descendent irqchips.
|
2011-02-07 22:02:20 +07:00
|
|
|
*/
|
|
|
|
|
enum {
|
|
|
|
|
IRQ_SET_MASK_OK = 0,
|
|
|
|
|
IRQ_SET_MASK_OK_NOCOPY,
|
2014-11-06 21:20:18 +07:00
|
|
|
IRQ_SET_MASK_OK_DONE,
|
2011-02-07 22:02:20 +07:00
|
|
|
};
|
|
|
|
|
|
2007-01-29 02:52:03 +07:00
|
|
|
struct msi_desc;
|
2011-07-26 16:19:06 +07:00
|
|
|
struct irq_domain;
|
2006-06-29 16:24:51 +07:00
|
|
|
|
2010-09-27 19:44:25 +07:00
|
|
|
/**
|
2015-06-01 15:05:12 +07:00
|
|
|
* struct irq_common_data - per irq data shared by all irqchips
|
|
|
|
|
* @state_use_accessors: status information for irq chip functions.
|
|
|
|
|
* Use accessor functions to deal with it
|
2015-06-01 15:05:16 +07:00
|
|
|
* @node: node index useful for balancing
|
2015-06-01 15:05:21 +07:00
|
|
|
* @handler_data: per-IRQ data for the irq_chip methods
|
2015-12-08 20:20:17 +07:00
|
|
|
* @affinity: IRQ affinity on SMP. If this is an IPI
|
|
|
|
|
* related irq, then this is the mask of the
|
|
|
|
|
* CPUs to which an IPI can be sent.
|
2017-06-20 06:37:38 +07:00
|
|
|
* @effective_affinity: The effective IRQ affinity on SMP as some irq
|
|
|
|
|
* chips do not allow multi CPU destinations.
|
|
|
|
|
* A subset of @affinity.
|
2015-06-01 15:05:43 +07:00
|
|
|
* @msi_desc: MSI descriptor
|
2015-12-08 20:20:16 +07:00
|
|
|
* @ipi_offset: Offset of first IPI target cpu in @affinity. Optional.
|
2015-06-01 15:05:12 +07:00
|
|
|
*/
|
|
|
|
|
struct irq_common_data {
|
2015-12-29 11:18:48 +07:00
|
|
|
unsigned int __private state_use_accessors;
|
2015-06-01 15:05:16 +07:00
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
|
unsigned int node;
|
|
|
|
|
#endif
|
2015-06-01 15:05:21 +07:00
|
|
|
void *handler_data;
|
2015-06-01 15:05:43 +07:00
|
|
|
struct msi_desc *msi_desc;
|
2015-06-03 10:47:50 +07:00
|
|
|
cpumask_var_t affinity;
|
2017-06-20 06:37:38 +07:00
|
|
|
#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
|
|
|
|
|
cpumask_var_t effective_affinity;
|
|
|
|
|
#endif
|
2015-12-08 20:20:16 +07:00
|
|
|
#ifdef CONFIG_GENERIC_IRQ_IPI
|
|
|
|
|
unsigned int ipi_offset;
|
|
|
|
|
#endif
|
2015-06-01 15:05:12 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct irq_data - per irq chip data passed down to chip functions
|
2013-05-06 21:30:22 +07:00
|
|
|
* @mask: precomputed bitmask for accessing the chip registers
|
2010-09-27 19:44:25 +07:00
|
|
|
* @irq: interrupt number
|
2011-07-26 16:19:06 +07:00
|
|
|
* @hwirq: hardware interrupt number, local to the interrupt domain
|
2015-06-01 15:05:12 +07:00
|
|
|
* @common: point to data shared by all irqchips
|
2010-09-27 19:44:25 +07:00
|
|
|
* @chip: low level interrupt hardware access
|
2011-07-26 16:19:06 +07:00
|
|
|
* @domain: Interrupt translation domain; responsible for mapping
|
|
|
|
|
* between hwirq number and linux irq number.
|
2014-11-06 21:20:14 +07:00
|
|
|
* @parent_data: pointer to parent struct irq_data to support hierarchy
|
|
|
|
|
* irq_domain
|
2010-09-27 19:44:25 +07:00
|
|
|
* @chip_data: platform-specific per-chip private data for the chip
|
|
|
|
|
* methods, to allow shared chip implementations
|
|
|
|
|
*/
|
|
|
|
|
struct irq_data {
|
2013-05-06 21:30:22 +07:00
|
|
|
u32 mask;
|
2010-09-27 19:44:25 +07:00
|
|
|
unsigned int irq;
|
2011-07-26 16:19:06 +07:00
|
|
|
unsigned long hwirq;
|
2015-06-01 15:05:12 +07:00
|
|
|
struct irq_common_data *common;
|
2010-09-27 19:44:25 +07:00
|
|
|
struct irq_chip *chip;
|
2011-07-26 16:19:06 +07:00
|
|
|
struct irq_domain *domain;
|
2014-11-06 21:20:14 +07:00
|
|
|
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
|
|
|
|
|
struct irq_data *parent_data;
|
|
|
|
|
#endif
|
2010-09-27 19:44:25 +07:00
|
|
|
void *chip_data;
|
|
|
|
|
};
|
|
|
|
|
|
2011-02-05 21:20:04 +07:00
|
|
|
/*
|
2015-06-01 15:05:12 +07:00
|
|
|
* Bit masks for irq_common_data.state_use_accessors
|
2011-02-05 21:20:04 +07:00
|
|
|
*
|
2011-02-08 23:28:12 +07:00
|
|
|
* IRQD_TRIGGER_MASK - Mask for the trigger type bits
|
2011-02-05 21:20:04 +07:00
|
|
|
* IRQD_SETAFFINITY_PENDING - Affinity setting is pending
|
2017-01-17 23:00:48 +07:00
|
|
|
* IRQD_ACTIVATED - Interrupt has already been activated
|
2011-02-08 23:11:03 +07:00
|
|
|
* IRQD_NO_BALANCING - Balancing disabled for this IRQ
|
|
|
|
|
* IRQD_PER_CPU - Interrupt is per cpu
|
2011-02-08 23:22:00 +07:00
|
|
|
* IRQD_AFFINITY_SET - Interrupt affinity was set
|
2011-02-08 23:28:12 +07:00
|
|
|
* IRQD_LEVEL - Interrupt is level triggered
|
2011-02-11 01:46:26 +07:00
|
|
|
* IRQD_WAKEUP_STATE - Interrupt is configured for wakeup
|
|
|
|
|
* from suspend
|
2011-02-11 04:25:31 +07:00
|
|
|
* IRDQ_MOVE_PCNTXT - Interrupt can be moved in process
|
|
|
|
|
* context
|
2011-03-28 19:10:52 +07:00
|
|
|
* 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
|
2014-08-29 18:54:09 +07:00
|
|
|
* IRQD_WAKEUP_ARMED - Wakeup mode armed
|
2015-09-15 17:33:42 +07:00
|
|
|
* IRQD_FORWARDED_TO_VCPU - The interrupt is forwarded to a VCPU
|
2016-07-04 15:39:23 +07:00
|
|
|
* IRQD_AFFINITY_MANAGED - Affinity is auto-managed by the kernel
|
2017-06-20 06:37:18 +07:00
|
|
|
* IRQD_IRQ_STARTED - Startup state of the interrupt
|
2017-06-20 06:37:47 +07:00
|
|
|
* IRQD_MANAGED_SHUTDOWN - Interrupt was shutdown due to empty affinity
|
|
|
|
|
* mask. Applies only to affinity managed irqs.
|
2017-06-20 06:37:52 +07:00
|
|
|
* IRQD_SINGLE_TARGET - IRQ allows only a single affinity target
|
2017-11-09 21:17:59 +07:00
|
|
|
* IRQD_DEFAULT_TRIGGER_SET - Expected trigger already been set
|
2017-12-29 22:44:34 +07:00
|
|
|
* IRQD_CAN_RESERVE - Can use reservation mode
|
2011-02-05 21:20:04 +07:00
|
|
|
*/
|
|
|
|
|
enum {
|
2011-02-08 23:28:12 +07:00
|
|
|
IRQD_TRIGGER_MASK = 0xf,
|
2011-02-08 23:11:03 +07:00
|
|
|
IRQD_SETAFFINITY_PENDING = (1 << 8),
|
2017-01-17 23:00:48 +07:00
|
|
|
IRQD_ACTIVATED = (1 << 9),
|
2011-02-08 23:11:03 +07:00
|
|
|
IRQD_NO_BALANCING = (1 << 10),
|
|
|
|
|
IRQD_PER_CPU = (1 << 11),
|
2011-02-08 23:22:00 +07:00
|
|
|
IRQD_AFFINITY_SET = (1 << 12),
|
2011-02-08 23:28:12 +07:00
|
|
|
IRQD_LEVEL = (1 << 13),
|
2011-02-11 01:46:26 +07:00
|
|
|
IRQD_WAKEUP_STATE = (1 << 14),
|
2011-02-11 04:25:31 +07:00
|
|
|
IRQD_MOVE_PCNTXT = (1 << 15),
|
2011-03-27 16:02:49 +07:00
|
|
|
IRQD_IRQ_DISABLED = (1 << 16),
|
2011-03-28 19:10:52 +07:00
|
|
|
IRQD_IRQ_MASKED = (1 << 17),
|
|
|
|
|
IRQD_IRQ_INPROGRESS = (1 << 18),
|
2014-08-29 18:54:09 +07:00
|
|
|
IRQD_WAKEUP_ARMED = (1 << 19),
|
2015-09-15 17:33:42 +07:00
|
|
|
IRQD_FORWARDED_TO_VCPU = (1 << 20),
|
2016-07-04 15:39:23 +07:00
|
|
|
IRQD_AFFINITY_MANAGED = (1 << 21),
|
2017-05-31 16:58:32 +07:00
|
|
|
IRQD_IRQ_STARTED = (1 << 22),
|
2017-06-20 06:37:47 +07:00
|
|
|
IRQD_MANAGED_SHUTDOWN = (1 << 23),
|
2017-06-20 06:37:52 +07:00
|
|
|
IRQD_SINGLE_TARGET = (1 << 24),
|
2017-11-09 21:17:59 +07:00
|
|
|
IRQD_DEFAULT_TRIGGER_SET = (1 << 25),
|
2017-12-29 22:44:34 +07:00
|
|
|
IRQD_CAN_RESERVE = (1 << 26),
|
2011-02-05 21:20:04 +07:00
|
|
|
};
|
|
|
|
|
|
2015-12-29 11:18:48 +07:00
|
|
|
#define __irqd_to_state(d) ACCESS_PRIVATE((d)->common, state_use_accessors)
|
2015-06-01 15:05:12 +07:00
|
|
|
|
2011-02-05 21:20:04 +07:00
|
|
|
static inline bool irqd_is_setaffinity_pending(struct irq_data *d)
|
|
|
|
|
{
|
2015-06-01 15:05:12 +07:00
|
|
|
return __irqd_to_state(d) & IRQD_SETAFFINITY_PENDING;
|
2011-02-05 21:20:04 +07:00
|
|
|
}
|
|
|
|
|
|
2011-02-08 23:11:03 +07:00
|
|
|
static inline bool irqd_is_per_cpu(struct irq_data *d)
|
|
|
|
|
{
|
2015-06-01 15:05:12 +07:00
|
|
|
return __irqd_to_state(d) & IRQD_PER_CPU;
|
2011-02-08 23:11:03 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline bool irqd_can_balance(struct irq_data *d)
|
|
|
|
|
{
|
2015-06-01 15:05:12 +07:00
|
|
|
return !(__irqd_to_state(d) & (IRQD_PER_CPU | IRQD_NO_BALANCING));
|
2011-02-08 23:11:03 +07:00
|
|
|
}
|
|
|
|
|
|
2011-02-08 23:22:00 +07:00
|
|
|
static inline bool irqd_affinity_was_set(struct irq_data *d)
|
|
|
|
|
{
|
2015-06-01 15:05:12 +07:00
|
|
|
return __irqd_to_state(d) & IRQD_AFFINITY_SET;
|
2011-02-08 23:22:00 +07:00
|
|
|
}
|
|
|
|
|
|
2011-03-28 22:11:13 +07:00
|
|
|
static inline void irqd_mark_affinity_was_set(struct irq_data *d)
|
|
|
|
|
{
|
2015-06-01 15:05:12 +07:00
|
|
|
__irqd_to_state(d) |= IRQD_AFFINITY_SET;
|
2011-03-28 22:11:13 +07:00
|
|
|
}
|
|
|
|
|
|
2017-11-09 21:17:59 +07:00
|
|
|
static inline bool irqd_trigger_type_was_set(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
return __irqd_to_state(d) & IRQD_DEFAULT_TRIGGER_SET;
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-08 23:28:12 +07:00
|
|
|
static inline u32 irqd_get_trigger_type(struct irq_data *d)
|
|
|
|
|
{
|
2015-06-01 15:05:12 +07:00
|
|
|
return __irqd_to_state(d) & IRQD_TRIGGER_MASK;
|
2011-02-08 23:28:12 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2017-11-09 21:17:59 +07:00
|
|
|
* Must only be called inside irq_chip.irq_set_type() functions or
|
|
|
|
|
* from the DT/ACPI setup code.
|
2011-02-08 23:28:12 +07:00
|
|
|
*/
|
|
|
|
|
static inline void irqd_set_trigger_type(struct irq_data *d, u32 type)
|
|
|
|
|
{
|
2015-06-01 15:05:12 +07:00
|
|
|
__irqd_to_state(d) &= ~IRQD_TRIGGER_MASK;
|
|
|
|
|
__irqd_to_state(d) |= type & IRQD_TRIGGER_MASK;
|
2017-11-09 21:17:59 +07:00
|
|
|
__irqd_to_state(d) |= IRQD_DEFAULT_TRIGGER_SET;
|
2011-02-08 23:28:12 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline bool irqd_is_level_type(struct irq_data *d)
|
|
|
|
|
{
|
2015-06-01 15:05:12 +07:00
|
|
|
return __irqd_to_state(d) & IRQD_LEVEL;
|
2011-02-08 23:28:12 +07:00
|
|
|
}
|
|
|
|
|
|
2017-06-20 06:37:52 +07:00
|
|
|
/*
|
|
|
|
|
* Must only be called of irqchip.irq_set_affinity() or low level
|
|
|
|
|
* hieararchy domain allocation functions.
|
|
|
|
|
*/
|
|
|
|
|
static inline void irqd_set_single_target(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
__irqd_to_state(d) |= IRQD_SINGLE_TARGET;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline bool irqd_is_single_target(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
return __irqd_to_state(d) & IRQD_SINGLE_TARGET;
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-11 01:46:26 +07:00
|
|
|
static inline bool irqd_is_wakeup_set(struct irq_data *d)
|
|
|
|
|
{
|
2015-06-01 15:05:12 +07:00
|
|
|
return __irqd_to_state(d) & IRQD_WAKEUP_STATE;
|
2011-02-11 01:46:26 +07:00
|
|
|
}
|
|
|
|
|
|
2011-02-11 04:25:31 +07:00
|
|
|
static inline bool irqd_can_move_in_process_context(struct irq_data *d)
|
|
|
|
|
{
|
2015-06-01 15:05:12 +07:00
|
|
|
return __irqd_to_state(d) & IRQD_MOVE_PCNTXT;
|
2011-02-11 04:25:31 +07:00
|
|
|
}
|
|
|
|
|
|
2011-03-27 16:02:49 +07:00
|
|
|
static inline bool irqd_irq_disabled(struct irq_data *d)
|
|
|
|
|
{
|
2015-06-01 15:05:12 +07:00
|
|
|
return __irqd_to_state(d) & IRQD_IRQ_DISABLED;
|
2011-03-27 16:02:49 +07:00
|
|
|
}
|
|
|
|
|
|
2011-03-28 19:10:52 +07:00
|
|
|
static inline bool irqd_irq_masked(struct irq_data *d)
|
|
|
|
|
{
|
2015-06-01 15:05:12 +07:00
|
|
|
return __irqd_to_state(d) & IRQD_IRQ_MASKED;
|
2011-03-28 19:10:52 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline bool irqd_irq_inprogress(struct irq_data *d)
|
|
|
|
|
{
|
2015-06-01 15:05:12 +07:00
|
|
|
return __irqd_to_state(d) & IRQD_IRQ_INPROGRESS;
|
2011-03-28 19:10:52 +07:00
|
|
|
}
|
|
|
|
|
|
2014-08-29 18:54:09 +07:00
|
|
|
static inline bool irqd_is_wakeup_armed(struct irq_data *d)
|
|
|
|
|
{
|
2015-06-01 15:05:12 +07:00
|
|
|
return __irqd_to_state(d) & IRQD_WAKEUP_ARMED;
|
2014-08-29 18:54:09 +07:00
|
|
|
}
|
|
|
|
|
|
2015-09-15 17:33:42 +07:00
|
|
|
static inline bool irqd_is_forwarded_to_vcpu(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
return __irqd_to_state(d) & IRQD_FORWARDED_TO_VCPU;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void irqd_set_forwarded_to_vcpu(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
__irqd_to_state(d) |= IRQD_FORWARDED_TO_VCPU;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void irqd_clr_forwarded_to_vcpu(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
__irqd_to_state(d) &= ~IRQD_FORWARDED_TO_VCPU;
|
|
|
|
|
}
|
2014-08-29 18:54:09 +07:00
|
|
|
|
2016-07-04 15:39:23 +07:00
|
|
|
static inline bool irqd_affinity_is_managed(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
return __irqd_to_state(d) & IRQD_AFFINITY_MANAGED;
|
|
|
|
|
}
|
|
|
|
|
|
2017-01-17 23:00:48 +07:00
|
|
|
static inline bool irqd_is_activated(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
return __irqd_to_state(d) & IRQD_ACTIVATED;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void irqd_set_activated(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
__irqd_to_state(d) |= IRQD_ACTIVATED;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void irqd_clr_activated(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
__irqd_to_state(d) &= ~IRQD_ACTIVATED;
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-31 16:58:32 +07:00
|
|
|
static inline bool irqd_is_started(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
return __irqd_to_state(d) & IRQD_IRQ_STARTED;
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-20 06:37:50 +07:00
|
|
|
static inline bool irqd_is_managed_and_shutdown(struct irq_data *d)
|
2017-06-20 06:37:47 +07:00
|
|
|
{
|
|
|
|
|
return __irqd_to_state(d) & IRQD_MANAGED_SHUTDOWN;
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-29 22:44:34 +07:00
|
|
|
static inline void irqd_set_can_reserve(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
__irqd_to_state(d) |= IRQD_CAN_RESERVE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void irqd_clr_can_reserve(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
__irqd_to_state(d) &= ~IRQD_CAN_RESERVE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline bool irqd_can_reserve(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
return __irqd_to_state(d) & IRQD_CAN_RESERVE;
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-29 11:18:48 +07:00
|
|
|
#undef __irqd_to_state
|
|
|
|
|
|
2012-04-03 20:11:04 +07:00
|
|
|
static inline irq_hw_number_t irqd_to_hwirq(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
return d->hwirq;
|
|
|
|
|
}
|
|
|
|
|
|
2006-06-29 16:24:45 +07:00
|
|
|
/**
|
2006-06-29 16:24:51 +07:00
|
|
|
* struct irq_chip - hardware interrupt chip descriptor
|
2006-06-29 16:24:45 +07:00
|
|
|
*
|
2016-06-07 22:12:29 +07:00
|
|
|
* @parent_device: pointer to parent device for irqchip
|
2006-06-29 16:24:45 +07:00
|
|
|
* @name: name for /proc/interrupts
|
2010-09-27 19:44:32 +07:00
|
|
|
* @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
|
2017-07-27 17:21:11 +07:00
|
|
|
* @irq_set_affinity: Set the CPU affinity on SMP machines. If the force
|
|
|
|
|
* argument is true, it tells the driver to
|
|
|
|
|
* unconditionally apply the affinity setting. Sanity
|
|
|
|
|
* checks against the supplied affinity mask are not
|
|
|
|
|
* required. This is used for CPU hotplug where the
|
|
|
|
|
* target CPU is not yet set in the cpu_online_mask.
|
2010-09-27 19:44:32 +07:00
|
|
|
* @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
|
2011-03-26 02:38:49 +07:00
|
|
|
* @irq_cpu_online: configure an interrupt source for a secondary CPU
|
|
|
|
|
* @irq_cpu_offline: un-configure an interrupt source for a secondary CPU
|
2015-07-23 06:21:39 +07:00
|
|
|
* @irq_suspend: function called from core code on suspend once per
|
|
|
|
|
* chip, when one or more interrupts are installed
|
|
|
|
|
* @irq_resume: function called from core code on resume once per chip,
|
|
|
|
|
* when one ore more interrupts are installed
|
2011-04-16 03:36:08 +07:00
|
|
|
* @irq_pm_shutdown: function called from core code on shutdown once per chip
|
2013-05-06 21:30:24 +07:00
|
|
|
* @irq_calc_mask: Optional function to set irq_data.mask for special cases
|
2011-03-25 22:48:50 +07:00
|
|
|
* @irq_print_chip: optional to print special chip info in show_interrupts
|
2014-03-08 14:59:58 +07:00
|
|
|
* @irq_request_resources: optional to request resources before calling
|
|
|
|
|
* any other callback related to this irq
|
|
|
|
|
* @irq_release_resources: optional to release resources acquired with
|
|
|
|
|
* irq_request_resources
|
2014-11-06 21:20:17 +07:00
|
|
|
* @irq_compose_msi_msg: optional to compose message content for MSI
|
2014-11-09 22:10:28 +07:00
|
|
|
* @irq_write_msi_msg: optional to write message content for MSI
|
2015-03-18 18:01:22 +07:00
|
|
|
* @irq_get_irqchip_state: return the internal state of an interrupt
|
|
|
|
|
* @irq_set_irqchip_state: set the internal state of a interrupt
|
2015-05-19 16:07:14 +07:00
|
|
|
* @irq_set_vcpu_affinity: optional to target a vCPU in a virtual machine
|
2015-12-08 20:20:21 +07:00
|
|
|
* @ipi_send_single: send a single IPI to destination cpus
|
|
|
|
|
* @ipi_send_mask: send an IPI to destination cpus in cpumask
|
2011-02-10 19:08:38 +07:00
|
|
|
* @flags: chip specific flags
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2006-06-29 16:24:51 +07:00
|
|
|
struct irq_chip {
|
2016-06-07 22:12:29 +07:00
|
|
|
struct device *parent_device;
|
2006-06-29 16:24:51 +07:00
|
|
|
const char *name;
|
2010-09-27 19:44:32 +07:00
|
|
|
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);
|
|
|
|
|
|
2011-03-26 02:38:49 +07:00
|
|
|
void (*irq_cpu_online)(struct irq_data *data);
|
|
|
|
|
void (*irq_cpu_offline)(struct irq_data *data);
|
|
|
|
|
|
2011-04-16 03:36:08 +07:00
|
|
|
void (*irq_suspend)(struct irq_data *data);
|
|
|
|
|
void (*irq_resume)(struct irq_data *data);
|
|
|
|
|
void (*irq_pm_shutdown)(struct irq_data *data);
|
|
|
|
|
|
2013-05-06 21:30:24 +07:00
|
|
|
void (*irq_calc_mask)(struct irq_data *data);
|
|
|
|
|
|
2011-03-25 22:48:50 +07:00
|
|
|
void (*irq_print_chip)(struct irq_data *data, struct seq_file *p);
|
2014-03-08 14:59:58 +07:00
|
|
|
int (*irq_request_resources)(struct irq_data *data);
|
|
|
|
|
void (*irq_release_resources)(struct irq_data *data);
|
2011-03-25 22:48:50 +07:00
|
|
|
|
2014-11-06 21:20:17 +07:00
|
|
|
void (*irq_compose_msi_msg)(struct irq_data *data, struct msi_msg *msg);
|
2014-11-09 22:10:28 +07:00
|
|
|
void (*irq_write_msi_msg)(struct irq_data *data, struct msi_msg *msg);
|
2014-11-06 21:20:17 +07:00
|
|
|
|
2015-03-18 18:01:22 +07:00
|
|
|
int (*irq_get_irqchip_state)(struct irq_data *data, enum irqchip_irq_state which, bool *state);
|
|
|
|
|
int (*irq_set_irqchip_state)(struct irq_data *data, enum irqchip_irq_state which, bool state);
|
|
|
|
|
|
2015-05-19 16:07:14 +07:00
|
|
|
int (*irq_set_vcpu_affinity)(struct irq_data *data, void *vcpu_info);
|
|
|
|
|
|
2015-12-08 20:20:21 +07:00
|
|
|
void (*ipi_send_single)(struct irq_data *data, unsigned int cpu);
|
|
|
|
|
void (*ipi_send_mask)(struct irq_data *data, const struct cpumask *dest);
|
|
|
|
|
|
2011-02-10 19:08:38 +07:00
|
|
|
unsigned long flags;
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
2011-02-10 19:16:14 +07:00
|
|
|
/*
|
|
|
|
|
* irq_chip specific flags
|
|
|
|
|
*
|
2011-02-15 16:33:57 +07:00
|
|
|
* IRQCHIP_SET_TYPE_MASKED: Mask before calling chip.irq_set_type()
|
|
|
|
|
* IRQCHIP_EOI_IF_HANDLED: Only issue irq_eoi() when irq was handled
|
2011-03-12 03:22:14 +07:00
|
|
|
* IRQCHIP_MASK_ON_SUSPEND: Mask non wake irqs in the suspend path
|
2011-03-27 21:05:36 +07:00
|
|
|
* IRQCHIP_ONOFFLINE_ENABLED: Only call irq_on/off_line callbacks
|
|
|
|
|
* when irq enabled
|
2011-09-09 15:29:35 +07:00
|
|
|
* IRQCHIP_SKIP_SET_WAKE: Skip chip.irq_set_wake(), for this irq chip
|
2014-03-13 21:32:47 +07:00
|
|
|
* IRQCHIP_ONESHOT_SAFE: One shot does not require mask/unmask
|
2014-03-14 01:03:51 +07:00
|
|
|
* IRQCHIP_EOI_THREADED: Chip requires eoi() on unmask in threaded mode
|
2018-06-22 16:52:48 +07:00
|
|
|
* IRQCHIP_SUPPORTS_LEVEL_MSI Chip can provide two doorbells for Level MSIs
|
2011-02-10 19:16:14 +07:00
|
|
|
*/
|
|
|
|
|
enum {
|
|
|
|
|
IRQCHIP_SET_TYPE_MASKED = (1 << 0),
|
2011-02-15 16:33:57 +07:00
|
|
|
IRQCHIP_EOI_IF_HANDLED = (1 << 1),
|
2011-03-12 03:22:14 +07:00
|
|
|
IRQCHIP_MASK_ON_SUSPEND = (1 << 2),
|
2011-03-27 21:05:36 +07:00
|
|
|
IRQCHIP_ONOFFLINE_ENABLED = (1 << 3),
|
2011-09-09 15:29:35 +07:00
|
|
|
IRQCHIP_SKIP_SET_WAKE = (1 << 4),
|
2012-07-14 00:29:45 +07:00
|
|
|
IRQCHIP_ONESHOT_SAFE = (1 << 5),
|
2014-03-14 01:03:51 +07:00
|
|
|
IRQCHIP_EOI_THREADED = (1 << 6),
|
2018-05-08 19:14:31 +07:00
|
|
|
IRQCHIP_SUPPORTS_LEVEL_MSI = (1 << 7),
|
2011-02-10 19:16:14 +07:00
|
|
|
};
|
|
|
|
|
|
2010-10-01 21:03:45 +07:00
|
|
|
#include <linux/irqdesc.h>
|
2008-12-06 09:58:31 +07:00
|
|
|
|
2006-06-29 16:24:40 +07:00
|
|
|
/*
|
|
|
|
|
* Pick up the arch-dependent methods:
|
|
|
|
|
*/
|
|
|
|
|
#include <asm/hw_irq.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2010-09-28 01:55:03 +07:00
|
|
|
#ifndef NR_IRQS_LEGACY
|
|
|
|
|
# define NR_IRQS_LEGACY 0
|
|
|
|
|
#endif
|
|
|
|
|
|
2010-09-28 02:01:37 +07:00
|
|
|
#ifndef ARCH_IRQ_INIT_FLAGS
|
|
|
|
|
# define ARCH_IRQ_INIT_FLAGS 0
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-02-08 04:11:30 +07:00
|
|
|
#define IRQ_DEFAULT_INIT_FLAGS ARCH_IRQ_INIT_FLAGS
|
2010-09-28 02:01:37 +07:00
|
|
|
|
2010-10-01 21:03:45 +07:00
|
|
|
struct irqaction;
|
2006-06-29 16:24:40 +07:00
|
|
|
extern int setup_irq(unsigned int irq, struct irqaction *new);
|
2009-03-12 19:05:51 +07:00
|
|
|
extern void remove_irq(unsigned int irq, struct irqaction *act);
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-23 23:03:06 +07:00
|
|
|
extern int setup_percpu_irq(unsigned int irq, struct irqaction *new);
|
|
|
|
|
extern void remove_percpu_irq(unsigned int irq, struct irqaction *act);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2011-03-26 02:38:49 +07:00
|
|
|
extern void irq_cpu_online(void);
|
|
|
|
|
extern void irq_cpu_offline(void);
|
2014-04-16 21:36:44 +07:00
|
|
|
extern int irq_set_affinity_locked(struct irq_data *data,
|
|
|
|
|
const struct cpumask *cpumask, bool force);
|
2015-05-19 16:07:14 +07:00
|
|
|
extern int irq_set_vcpu_affinity(unsigned int irq, void *vcpu_info);
|
2011-03-26 02:38:49 +07:00
|
|
|
|
2017-06-20 06:37:51 +07:00
|
|
|
#if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_IRQ_MIGRATION)
|
2015-09-24 16:32:13 +07:00
|
|
|
extern void irq_migrate_all_off_this_cpu(void);
|
2017-06-20 06:37:51 +07:00
|
|
|
extern int irq_affinity_online_cpu(unsigned int cpu);
|
|
|
|
|
#else
|
|
|
|
|
# define irq_affinity_online_cpu NULL
|
|
|
|
|
#endif
|
2015-09-24 16:32:13 +07:00
|
|
|
|
2010-10-04 18:47:12 +07:00
|
|
|
#if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_PENDING_IRQ)
|
2018-06-06 19:46:59 +07:00
|
|
|
void __irq_move_irq(struct irq_data *data);
|
|
|
|
|
static inline void irq_move_irq(struct irq_data *data)
|
|
|
|
|
{
|
|
|
|
|
if (unlikely(irqd_is_setaffinity_pending(data)))
|
|
|
|
|
__irq_move_irq(data);
|
|
|
|
|
}
|
2011-02-05 00:46:16 +07:00
|
|
|
void irq_move_masked_irq(struct irq_data *data);
|
2017-06-20 06:37:29 +07:00
|
|
|
void irq_force_complete_move(struct irq_desc *desc);
|
2010-10-01 21:03:45 +07:00
|
|
|
#else
|
2011-02-05 00:46:16 +07:00
|
|
|
static inline void irq_move_irq(struct irq_data *data) { }
|
|
|
|
|
static inline void irq_move_masked_irq(struct irq_data *data) { }
|
2017-06-20 06:37:29 +07:00
|
|
|
static inline void irq_force_complete_move(struct irq_desc *desc) { }
|
2010-10-01 21:03:45 +07:00
|
|
|
#endif
|
[PATCH] x86/x86_64: deferred handling of writes to /proc/irqxx/smp_affinity
When handling writes to /proc/irq, current code is re-programming rte
entries directly. This is not recommended and could potentially cause
chipset's to lockup, or cause missing interrupts.
CONFIG_IRQ_BALANCE does this correctly, where it re-programs only when the
interrupt is pending. The same needs to be done for /proc/irq handling as well.
Otherwise user space irq balancers are really not doing the right thing.
- Changed pending_irq_balance_cpumask to pending_irq_migrate_cpumask for
lack of a generic name.
- added move_irq out of IRQ_BALANCE, and added this same to X86_64
- Added new proc handler for write, so we can do deferred write at irq
handling time.
- Display of /proc/irq/XX/smp_affinity used to display CPU_MASKALL, instead
it now shows only active cpu masks, or exactly what was set.
- Provided a common move_irq implementation, instead of duplicating
when using generic irq framework.
Tested on i386/x86_64 and ia64 with CONFIG_PCI_MSI turned on and off.
Tested UP builds as well.
MSI testing: tbd: I have cards, need to look for a x-over cable, although I
did test an earlier version of this patch. Will test in a couple days.
Signed-off-by: Ashok Raj <ashok.raj@intel.com>
Acked-by: Zwane Mwaikambo <zwane@holomorphy.com>
Grudgingly-acked-by: Andi Kleen <ak@muc.de>
Signed-off-by: Coywolf Qi Hunt <coywolf@lovecn.org>
Signed-off-by: Ashok Raj <ashok.raj@intel.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-07 05:16:15 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
extern int no_irq_affinity;
|
|
|
|
|
|
2012-10-17 05:07:49 +07:00
|
|
|
#ifdef CONFIG_HARDIRQS_SW_RESEND
|
|
|
|
|
int irq_set_parent(int irq, int parent_irq);
|
|
|
|
|
#else
|
|
|
|
|
static inline int irq_set_parent(int irq, int parent_irq)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2006-06-29 16:24:51 +07:00
|
|
|
/*
|
|
|
|
|
* Built-in IRQ handlers for various IRQ types,
|
2009-11-16 00:57:24 +07:00
|
|
|
* callable via desc->handle_irq()
|
2006-06-29 16:24:51 +07:00
|
|
|
*/
|
2015-09-14 15:42:37 +07:00
|
|
|
extern void handle_level_irq(struct irq_desc *desc);
|
|
|
|
|
extern void handle_fasteoi_irq(struct irq_desc *desc);
|
|
|
|
|
extern void handle_edge_irq(struct irq_desc *desc);
|
|
|
|
|
extern void handle_edge_eoi_irq(struct irq_desc *desc);
|
|
|
|
|
extern void handle_simple_irq(struct irq_desc *desc);
|
2016-06-18 05:00:20 +07:00
|
|
|
extern void handle_untracked_irq(struct irq_desc *desc);
|
2015-09-14 15:42:37 +07:00
|
|
|
extern void handle_percpu_irq(struct irq_desc *desc);
|
|
|
|
|
extern void handle_percpu_devid_irq(struct irq_desc *desc);
|
|
|
|
|
extern void handle_bad_irq(struct irq_desc *desc);
|
2009-08-25 02:28:04 +07:00
|
|
|
extern void handle_nested_irq(unsigned int irq);
|
2006-06-29 16:24:51 +07:00
|
|
|
|
2014-11-06 21:20:17 +07:00
|
|
|
extern int irq_chip_compose_msi_msg(struct irq_data *data, struct msi_msg *msg);
|
2016-06-07 22:12:29 +07:00
|
|
|
extern int irq_chip_pm_get(struct irq_data *data);
|
|
|
|
|
extern int irq_chip_pm_put(struct irq_data *data);
|
2014-11-06 21:20:16 +07:00
|
|
|
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
|
2017-08-18 07:53:31 +07:00
|
|
|
extern void handle_fasteoi_ack_irq(struct irq_desc *desc);
|
|
|
|
|
extern void handle_fasteoi_mask_irq(struct irq_desc *desc);
|
2015-05-16 16:44:14 +07:00
|
|
|
extern void irq_chip_enable_parent(struct irq_data *data);
|
|
|
|
|
extern void irq_chip_disable_parent(struct irq_data *data);
|
2014-11-06 21:20:16 +07:00
|
|
|
extern void irq_chip_ack_parent(struct irq_data *data);
|
|
|
|
|
extern int irq_chip_retrigger_hierarchy(struct irq_data *data);
|
2014-11-13 22:37:05 +07:00
|
|
|
extern void irq_chip_mask_parent(struct irq_data *data);
|
|
|
|
|
extern void irq_chip_unmask_parent(struct irq_data *data);
|
|
|
|
|
extern void irq_chip_eoi_parent(struct irq_data *data);
|
|
|
|
|
extern int irq_chip_set_affinity_parent(struct irq_data *data,
|
|
|
|
|
const struct cpumask *dest,
|
|
|
|
|
bool force);
|
2015-03-11 22:43:43 +07:00
|
|
|
extern int irq_chip_set_wake_parent(struct irq_data *data, unsigned int on);
|
2015-05-19 16:07:14 +07:00
|
|
|
extern int irq_chip_set_vcpu_affinity_parent(struct irq_data *data,
|
|
|
|
|
void *vcpu_info);
|
2015-08-14 19:20:26 +07:00
|
|
|
extern int irq_chip_set_type_parent(struct irq_data *data, unsigned int type);
|
2014-11-06 21:20:16 +07:00
|
|
|
#endif
|
|
|
|
|
|
2006-06-29 16:24:51 +07:00
|
|
|
/* Handling of unhandled and spurious interrupts: */
|
2015-06-04 11:13:28 +07:00
|
|
|
extern void note_interrupt(struct irq_desc *desc, irqreturn_t action_ret);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-29 16:24:48 +07:00
|
|
|
|
2006-06-29 16:24:51 +07:00
|
|
|
/* 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);
|
|
|
|
|
|
2006-07-02 04:30:08 +07:00
|
|
|
/* Dummy irq-chip implementations: */
|
2006-06-29 16:24:51 +07:00
|
|
|
extern struct irq_chip no_irq_chip;
|
2006-07-02 04:30:08 +07:00
|
|
|
extern struct irq_chip dummy_irq_chip;
|
2006-06-29 16:24:51 +07:00
|
|
|
|
2006-10-20 13:28:28 +07:00
|
|
|
extern void
|
2011-02-15 02:09:19 +07:00
|
|
|
irq_set_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
|
2006-10-17 14:10:03 +07:00
|
|
|
irq_flow_handler_t handle, const char *name);
|
|
|
|
|
|
2011-02-15 02:09:19 +07:00
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-23 23:03:06 +07:00
|
|
|
extern int irq_set_percpu_devid(unsigned int irq);
|
2016-04-11 15:57:52 +07:00
|
|
|
extern int irq_set_percpu_devid_partition(unsigned int irq,
|
|
|
|
|
const struct cpumask *affinity);
|
|
|
|
|
extern int irq_get_percpu_devid_partition(unsigned int irq,
|
|
|
|
|
struct cpumask *affinity);
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-23 23:03:06 +07:00
|
|
|
|
2006-06-29 16:24:51 +07:00
|
|
|
extern void
|
2011-02-15 02:09:19 +07:00
|
|
|
__irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
|
2006-10-17 14:10:03 +07:00
|
|
|
const char *name);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-06-29 16:24:51 +07:00
|
|
|
static inline void
|
2011-02-15 02:09:19 +07:00
|
|
|
irq_set_handler(unsigned int irq, irq_flow_handler_t handle)
|
2006-06-29 16:24:51 +07:00
|
|
|
{
|
2011-02-15 02:09:19 +07:00
|
|
|
__irq_set_handler(irq, handle, 0, NULL);
|
2006-06-29 16:24:51 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Set a highlevel chained flow handler for a given IRQ.
|
|
|
|
|
* (a chained handler is automatically enabled and set to
|
2011-04-07 04:01:44 +07:00
|
|
|
* IRQ_NOREQUEST, IRQ_NOPROBE, and IRQ_NOTHREAD)
|
2006-06-29 16:24:51 +07:00
|
|
|
*/
|
|
|
|
|
static inline void
|
2011-02-15 02:09:19 +07:00
|
|
|
irq_set_chained_handler(unsigned int irq, irq_flow_handler_t handle)
|
2006-06-29 16:24:51 +07:00
|
|
|
{
|
2011-02-15 02:09:19 +07:00
|
|
|
__irq_set_handler(irq, handle, 1, NULL);
|
2006-06-29 16:24:51 +07:00
|
|
|
}
|
|
|
|
|
|
2015-06-17 05:06:20 +07:00
|
|
|
/*
|
|
|
|
|
* Set a highlevel chained flow handler and its data for a given IRQ.
|
|
|
|
|
* (a chained handler is automatically enabled and set to
|
|
|
|
|
* IRQ_NOREQUEST, IRQ_NOPROBE, and IRQ_NOTHREAD)
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
irq_set_chained_handler_and_data(unsigned int irq, irq_flow_handler_t handle,
|
|
|
|
|
void *data);
|
|
|
|
|
|
2010-09-28 15:40:18 +07:00
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-10 17:36:33 +07:00
|
|
|
static inline void irq_set_noprobe(unsigned int irq)
|
2010-09-28 15:40:18 +07:00
|
|
|
{
|
|
|
|
|
irq_modify_status(irq, 0, IRQ_NOPROBE);
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-10 17:36:33 +07:00
|
|
|
static inline void irq_set_probe(unsigned int irq)
|
2010-09-28 15:40:18 +07:00
|
|
|
{
|
|
|
|
|
irq_modify_status(irq, IRQ_NOPROBE, 0);
|
|
|
|
|
}
|
2008-02-08 19:22:01 +07:00
|
|
|
|
2011-04-07 04:01:44 +07:00
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-14 19:33:16 +07:00
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-23 23:03:06 +07:00
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2006-10-04 16:16:37 +07:00
|
|
|
/* Set/get chip/data for an IRQ: */
|
2011-02-10 17:36:33 +07:00
|
|
|
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);
|
2012-11-19 22:01:29 +07:00
|
|
|
extern int irq_set_msi_desc_off(unsigned int irq_base, unsigned int irq_offset,
|
|
|
|
|
struct msi_desc *entry);
|
2010-09-28 22:34:01 +07:00
|
|
|
extern struct irq_data *irq_get_irq_data(unsigned int irq);
|
2006-06-29 16:24:53 +07:00
|
|
|
|
2011-02-10 17:36:33 +07:00
|
|
|
static inline struct irq_chip *irq_get_chip(unsigned int irq)
|
2010-09-28 22:34:01 +07:00
|
|
|
{
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-10 17:36:33 +07:00
|
|
|
static inline void *irq_get_chip_data(unsigned int irq)
|
2010-09-28 22:34:01 +07:00
|
|
|
{
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-10 17:36:33 +07:00
|
|
|
static inline void *irq_get_handler_data(unsigned int irq)
|
2010-09-28 22:34:01 +07:00
|
|
|
{
|
|
|
|
|
struct irq_data *d = irq_get_irq_data(irq);
|
2015-06-01 15:05:21 +07:00
|
|
|
return d ? d->common->handler_data : NULL;
|
2010-09-28 22:34:01 +07:00
|
|
|
}
|
|
|
|
|
|
2011-02-10 17:36:33 +07:00
|
|
|
static inline void *irq_data_get_irq_handler_data(struct irq_data *d)
|
2010-09-28 22:34:01 +07:00
|
|
|
{
|
2015-06-01 15:05:21 +07:00
|
|
|
return d->common->handler_data;
|
2010-09-28 22:34:01 +07:00
|
|
|
}
|
|
|
|
|
|
2011-02-10 17:36:33 +07:00
|
|
|
static inline struct msi_desc *irq_get_msi_desc(unsigned int irq)
|
2010-09-28 22:34:01 +07:00
|
|
|
{
|
|
|
|
|
struct irq_data *d = irq_get_irq_data(irq);
|
2015-06-01 15:05:43 +07:00
|
|
|
return d ? d->common->msi_desc : NULL;
|
2010-09-28 22:34:01 +07:00
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:05:41 +07:00
|
|
|
static inline struct msi_desc *irq_data_get_msi_desc(struct irq_data *d)
|
2010-09-28 22:34:01 +07:00
|
|
|
{
|
2015-06-01 15:05:43 +07:00
|
|
|
return d->common->msi_desc;
|
2010-09-28 22:34:01 +07:00
|
|
|
}
|
|
|
|
|
|
2013-06-14 23:40:43 +07:00
|
|
|
static inline u32 irq_get_trigger_type(unsigned int irq)
|
|
|
|
|
{
|
|
|
|
|
struct irq_data *d = irq_get_irq_data(irq);
|
|
|
|
|
return d ? irqd_get_trigger_type(d) : 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:05:16 +07:00
|
|
|
static inline int irq_common_data_get_node(struct irq_common_data *d)
|
2015-06-01 15:05:13 +07:00
|
|
|
{
|
2015-06-01 15:05:16 +07:00
|
|
|
#ifdef CONFIG_NUMA
|
2015-06-01 15:05:13 +07:00
|
|
|
return d->node;
|
2015-06-01 15:05:16 +07:00
|
|
|
#else
|
|
|
|
|
return 0;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int irq_data_get_node(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
return irq_common_data_get_node(d->common);
|
2015-06-01 15:05:13 +07:00
|
|
|
}
|
|
|
|
|
|
2015-06-01 15:05:23 +07:00
|
|
|
static inline struct cpumask *irq_get_affinity_mask(int irq)
|
|
|
|
|
{
|
|
|
|
|
struct irq_data *d = irq_get_irq_data(irq);
|
|
|
|
|
|
2015-06-03 10:47:50 +07:00
|
|
|
return d ? d->common->affinity : NULL;
|
2015-06-01 15:05:23 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline struct cpumask *irq_data_get_affinity_mask(struct irq_data *d)
|
|
|
|
|
{
|
2015-06-03 10:47:50 +07:00
|
|
|
return d->common->affinity;
|
2015-06-01 15:05:23 +07:00
|
|
|
}
|
|
|
|
|
|
2017-06-20 06:37:38 +07:00
|
|
|
#ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK
|
|
|
|
|
static inline
|
|
|
|
|
struct cpumask *irq_data_get_effective_affinity_mask(struct irq_data *d)
|
|
|
|
|
{
|
2017-09-21 16:54:44 +07:00
|
|
|
return d->common->effective_affinity;
|
2017-06-20 06:37:38 +07:00
|
|
|
}
|
|
|
|
|
static inline void irq_data_update_effective_affinity(struct irq_data *d,
|
|
|
|
|
const struct cpumask *m)
|
|
|
|
|
{
|
|
|
|
|
cpumask_copy(d->common->effective_affinity, m);
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
static inline void irq_data_update_effective_affinity(struct irq_data *d,
|
|
|
|
|
const struct cpumask *m)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
static inline
|
|
|
|
|
struct cpumask *irq_data_get_effective_affinity_mask(struct irq_data *d)
|
|
|
|
|
{
|
|
|
|
|
return d->common->affinity;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-04-24 14:50:53 +07:00
|
|
|
unsigned int arch_dynirq_lower_bound(unsigned int from);
|
|
|
|
|
|
2011-07-11 17:17:31 +07:00
|
|
|
int __irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node,
|
2016-07-04 15:39:24 +07:00
|
|
|
struct module *owner, const struct cpumask *affinity);
|
2011-07-11 17:17:31 +07:00
|
|
|
|
2017-02-10 19:23:23 +07:00
|
|
|
int __devm_irq_alloc_descs(struct device *dev, int irq, unsigned int from,
|
|
|
|
|
unsigned int cnt, int node, struct module *owner,
|
|
|
|
|
const struct cpumask *affinity);
|
|
|
|
|
|
2011-09-20 07:33:19 +07:00
|
|
|
/* use macros to avoid needing export.h for THIS_MODULE */
|
|
|
|
|
#define irq_alloc_descs(irq, from, cnt, node) \
|
2016-07-04 15:39:24 +07:00
|
|
|
__irq_alloc_descs(irq, from, cnt, node, THIS_MODULE, NULL)
|
2011-07-11 17:17:31 +07:00
|
|
|
|
2011-09-20 07:33:19 +07:00
|
|
|
#define irq_alloc_desc(node) \
|
|
|
|
|
irq_alloc_descs(-1, 0, 1, node)
|
2010-09-27 22:48:26 +07:00
|
|
|
|
2011-09-20 07:33:19 +07:00
|
|
|
#define irq_alloc_desc_at(at, node) \
|
|
|
|
|
irq_alloc_descs(at, at, 1, node)
|
2010-09-27 22:48:26 +07:00
|
|
|
|
2011-09-20 07:33:19 +07:00
|
|
|
#define irq_alloc_desc_from(from, node) \
|
|
|
|
|
irq_alloc_descs(-1, from, 1, node)
|
2010-09-27 22:48:26 +07:00
|
|
|
|
2012-11-19 22:01:29 +07:00
|
|
|
#define irq_alloc_descs_from(from, cnt, node) \
|
|
|
|
|
irq_alloc_descs(-1, from, cnt, node)
|
|
|
|
|
|
2017-02-10 19:23:23 +07:00
|
|
|
#define devm_irq_alloc_descs(dev, irq, from, cnt, node) \
|
|
|
|
|
__devm_irq_alloc_descs(dev, irq, from, cnt, node, THIS_MODULE, NULL)
|
|
|
|
|
|
|
|
|
|
#define devm_irq_alloc_desc(dev, node) \
|
|
|
|
|
devm_irq_alloc_descs(dev, -1, 0, 1, node)
|
|
|
|
|
|
|
|
|
|
#define devm_irq_alloc_desc_at(dev, at, node) \
|
|
|
|
|
devm_irq_alloc_descs(dev, at, at, 1, node)
|
|
|
|
|
|
|
|
|
|
#define devm_irq_alloc_desc_from(dev, from, node) \
|
|
|
|
|
devm_irq_alloc_descs(dev, -1, from, 1, node)
|
|
|
|
|
|
|
|
|
|
#define devm_irq_alloc_descs_from(dev, from, cnt, node) \
|
|
|
|
|
devm_irq_alloc_descs(dev, -1, from, cnt, node)
|
|
|
|
|
|
2011-09-20 07:33:19 +07:00
|
|
|
void irq_free_descs(unsigned int irq, unsigned int cnt);
|
2010-09-27 22:48:26 +07:00
|
|
|
static inline void irq_free_desc(unsigned int irq)
|
|
|
|
|
{
|
|
|
|
|
irq_free_descs(irq, 1);
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-07 22:44:05 +07:00
|
|
|
#ifdef CONFIG_GENERIC_IRQ_LEGACY_ALLOC_HWIRQ
|
|
|
|
|
unsigned int irq_alloc_hwirqs(int cnt, int node);
|
|
|
|
|
static inline unsigned int irq_alloc_hwirq(int node)
|
|
|
|
|
{
|
|
|
|
|
return irq_alloc_hwirqs(1, node);
|
|
|
|
|
}
|
|
|
|
|
void irq_free_hwirqs(unsigned int from, int cnt);
|
|
|
|
|
static inline void irq_free_hwirq(unsigned int irq)
|
|
|
|
|
{
|
|
|
|
|
return irq_free_hwirqs(irq, 1);
|
|
|
|
|
}
|
|
|
|
|
int arch_setup_hwirq(unsigned int irq, int node);
|
|
|
|
|
void arch_teardown_hwirq(unsigned int irq);
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-05-07 22:44:22 +07:00
|
|
|
#ifdef CONFIG_GENERIC_IRQ_LEGACY
|
|
|
|
|
void irq_init_desc(unsigned int irq);
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-04-03 16:42:53 +07:00
|
|
|
/**
|
|
|
|
|
* 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
|
2013-05-06 21:30:19 +07:00
|
|
|
* @mask_cache_priv: Cached mask register private to the chip type
|
|
|
|
|
* @mask_cache: Pointer to cached mask register
|
2011-04-03 16:42:53 +07:00
|
|
|
*
|
|
|
|
|
* 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;
|
2013-05-06 21:30:19 +07:00
|
|
|
u32 mask_cache_priv;
|
|
|
|
|
u32 *mask_cache;
|
2011-04-03 16:42:53 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct irq_chip_generic - Generic irq chip data structure
|
|
|
|
|
* @lock: Lock to protect register and cache data access
|
|
|
|
|
* @reg_base: Register base address (virtual)
|
2014-11-07 13:44:18 +07:00
|
|
|
* @reg_readl: Alternate I/O accessor (defaults to readl if NULL)
|
|
|
|
|
* @reg_writel: Alternate I/O accessor (defaults to writel if NULL)
|
2015-07-23 06:21:39 +07:00
|
|
|
* @suspend: Function called from core code on suspend once per
|
|
|
|
|
* chip; can be useful instead of irq_chip::suspend to
|
|
|
|
|
* handle chip details even when no interrupts are in use
|
|
|
|
|
* @resume: Function called from core code on resume once per chip;
|
|
|
|
|
* can be useful instead of irq_chip::suspend to handle
|
|
|
|
|
* chip details even when no interrupts are in use
|
2011-04-03 16:42:53 +07:00
|
|
|
* @irq_base: Interrupt base nr for this chip
|
|
|
|
|
* @irq_cnt: Number of interrupts handled by this chip
|
2013-05-06 21:30:19 +07:00
|
|
|
* @mask_cache: Cached mask register shared between all chip types
|
2011-04-03 16:42:53 +07:00
|
|
|
* @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
|
2013-05-06 21:30:27 +07:00
|
|
|
* @installed: bitfield to denote installed interrupts
|
2013-05-29 09:10:52 +07:00
|
|
|
* @unused: bitfield to denote unused interrupts
|
2013-05-06 21:30:27 +07:00
|
|
|
* @domain: irq domain pointer
|
2011-04-16 03:36:08 +07:00
|
|
|
* @list: List head for keeping track of instances
|
2011-04-03 16:42:53 +07:00
|
|
|
* @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;
|
2014-11-07 13:44:18 +07:00
|
|
|
u32 (*reg_readl)(void __iomem *addr);
|
|
|
|
|
void (*reg_writel)(u32 val, void __iomem *addr);
|
2015-07-23 06:21:39 +07:00
|
|
|
void (*suspend)(struct irq_chip_generic *gc);
|
|
|
|
|
void (*resume)(struct irq_chip_generic *gc);
|
2011-04-03 16:42:53 +07:00
|
|
|
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;
|
2013-05-06 21:30:27 +07:00
|
|
|
unsigned long installed;
|
2013-05-29 09:10:52 +07:00
|
|
|
unsigned long unused;
|
2013-05-06 21:30:27 +07:00
|
|
|
struct irq_domain *domain;
|
2011-04-16 03:36:08 +07:00
|
|
|
struct list_head list;
|
2011-04-03 16:42:53 +07:00
|
|
|
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
|
2013-05-06 21:30:21 +07:00
|
|
|
* @IRQ_GC_MASK_CACHE_PER_TYPE: Mask cache is chip type private
|
2013-05-06 21:30:22 +07:00
|
|
|
* @IRQ_GC_NO_MASK: Do not calculate irq_data->mask
|
2014-11-07 13:44:19 +07:00
|
|
|
* @IRQ_GC_BE_IO: Use big-endian register accesses (default: LE)
|
2011-04-03 16:42:53 +07:00
|
|
|
*/
|
|
|
|
|
enum irq_gc_flags {
|
|
|
|
|
IRQ_GC_INIT_MASK_CACHE = 1 << 0,
|
|
|
|
|
IRQ_GC_INIT_NESTED_LOCK = 1 << 1,
|
2013-05-06 21:30:21 +07:00
|
|
|
IRQ_GC_MASK_CACHE_PER_TYPE = 1 << 2,
|
2013-05-06 21:30:22 +07:00
|
|
|
IRQ_GC_NO_MASK = 1 << 3,
|
2014-11-07 13:44:19 +07:00
|
|
|
IRQ_GC_BE_IO = 1 << 4,
|
2011-04-03 16:42:53 +07:00
|
|
|
};
|
|
|
|
|
|
2013-05-06 21:30:27 +07:00
|
|
|
/*
|
|
|
|
|
* struct irq_domain_chip_generic - Generic irq chip data structure for irq domains
|
|
|
|
|
* @irqs_per_chip: Number of interrupts per chip
|
|
|
|
|
* @num_chips: Number of chips
|
|
|
|
|
* @irq_flags_to_set: IRQ* flags to set on irq setup
|
|
|
|
|
* @irq_flags_to_clear: IRQ* flags to clear on irq setup
|
|
|
|
|
* @gc_flags: Generic chip specific setup flags
|
|
|
|
|
* @gc: Array of pointers to generic interrupt chips
|
|
|
|
|
*/
|
|
|
|
|
struct irq_domain_chip_generic {
|
|
|
|
|
unsigned int irqs_per_chip;
|
|
|
|
|
unsigned int num_chips;
|
|
|
|
|
unsigned int irq_flags_to_clear;
|
|
|
|
|
unsigned int irq_flags_to_set;
|
|
|
|
|
enum irq_gc_flags gc_flags;
|
|
|
|
|
struct irq_chip_generic *gc[0];
|
|
|
|
|
};
|
|
|
|
|
|
2011-04-03 16:42:53 +07:00
|
|
|
/* 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);
|
2011-07-06 23:41:31 +07:00
|
|
|
void irq_gc_ack_set_bit(struct irq_data *d);
|
|
|
|
|
void irq_gc_ack_clr_bit(struct irq_data *d);
|
2017-10-04 19:26:26 +07:00
|
|
|
void irq_gc_mask_disable_and_ack_set(struct irq_data *d);
|
2011-04-03 16:42:53 +07:00
|
|
|
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 */
|
2014-07-11 00:14:16 +07:00
|
|
|
int irq_map_generic_chip(struct irq_domain *d, unsigned int virq,
|
|
|
|
|
irq_hw_number_t hw_irq);
|
2011-04-03 16:42:53 +07:00
|
|
|
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);
|
2011-04-16 03:36:08 +07:00
|
|
|
void irq_remove_generic_chip(struct irq_chip_generic *gc, u32 msk,
|
|
|
|
|
unsigned int clr, unsigned int set);
|
2011-04-03 16:42:53 +07:00
|
|
|
|
2017-05-31 23:06:59 +07:00
|
|
|
struct irq_chip_generic *
|
|
|
|
|
devm_irq_alloc_generic_chip(struct device *dev, const char *name, int num_ct,
|
|
|
|
|
unsigned int irq_base, void __iomem *reg_base,
|
|
|
|
|
irq_flow_handler_t handler);
|
2017-05-31 23:07:00 +07:00
|
|
|
int devm_irq_setup_generic_chip(struct device *dev, struct irq_chip_generic *gc,
|
|
|
|
|
u32 msk, enum irq_gc_flags flags,
|
|
|
|
|
unsigned int clr, unsigned int set);
|
2017-05-31 23:06:59 +07:00
|
|
|
|
2013-05-06 21:30:27 +07:00
|
|
|
struct irq_chip_generic *irq_get_domain_generic_chip(struct irq_domain *d, unsigned int hw_irq);
|
|
|
|
|
|
2016-08-16 21:05:08 +07:00
|
|
|
int __irq_alloc_domain_generic_chips(struct irq_domain *d, int irqs_per_chip,
|
|
|
|
|
int num_ct, const char *name,
|
|
|
|
|
irq_flow_handler_t handler,
|
|
|
|
|
unsigned int clr, unsigned int set,
|
|
|
|
|
enum irq_gc_flags flags);
|
|
|
|
|
|
|
|
|
|
#define irq_alloc_domain_generic_chips(d, irqs_per_chip, num_ct, name, \
|
|
|
|
|
handler, clr, set, flags) \
|
|
|
|
|
({ \
|
|
|
|
|
MAYBE_BUILD_BUG_ON(irqs_per_chip > 32); \
|
|
|
|
|
__irq_alloc_domain_generic_chips(d, irqs_per_chip, num_ct, name,\
|
|
|
|
|
handler, clr, set, flags); \
|
|
|
|
|
})
|
2013-05-06 21:30:27 +07:00
|
|
|
|
2017-05-31 23:06:56 +07:00
|
|
|
static inline void irq_free_generic_chip(struct irq_chip_generic *gc)
|
|
|
|
|
{
|
|
|
|
|
kfree(gc);
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-31 23:06:57 +07:00
|
|
|
static inline void irq_destroy_generic_chip(struct irq_chip_generic *gc,
|
|
|
|
|
u32 msk, unsigned int clr,
|
|
|
|
|
unsigned int set)
|
|
|
|
|
{
|
|
|
|
|
irq_remove_generic_chip(gc, msk, clr, set);
|
|
|
|
|
irq_free_generic_chip(gc);
|
|
|
|
|
}
|
|
|
|
|
|
2011-04-03 16:42:53 +07:00
|
|
|
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
|
|
|
|
|
|
2016-09-13 20:58:28 +07:00
|
|
|
/*
|
|
|
|
|
* The irqsave variants are for usage in non interrupt code. Do not use
|
|
|
|
|
* them in irq_chip callbacks. Use irq_gc_lock() instead.
|
|
|
|
|
*/
|
|
|
|
|
#define irq_gc_lock_irqsave(gc, flags) \
|
|
|
|
|
raw_spin_lock_irqsave(&(gc)->lock, flags)
|
|
|
|
|
|
|
|
|
|
#define irq_gc_unlock_irqrestore(gc, flags) \
|
|
|
|
|
raw_spin_unlock_irqrestore(&(gc)->lock, flags)
|
|
|
|
|
|
2014-11-07 13:44:17 +07:00
|
|
|
static inline void irq_reg_writel(struct irq_chip_generic *gc,
|
|
|
|
|
u32 val, int reg_offset)
|
|
|
|
|
{
|
2014-11-07 13:44:18 +07:00
|
|
|
if (gc->reg_writel)
|
|
|
|
|
gc->reg_writel(val, gc->reg_base + reg_offset);
|
|
|
|
|
else
|
|
|
|
|
writel(val, gc->reg_base + reg_offset);
|
2014-11-07 13:44:17 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline u32 irq_reg_readl(struct irq_chip_generic *gc,
|
|
|
|
|
int reg_offset)
|
|
|
|
|
{
|
2014-11-07 13:44:18 +07:00
|
|
|
if (gc->reg_readl)
|
|
|
|
|
return gc->reg_readl(gc->reg_base + reg_offset);
|
|
|
|
|
else
|
|
|
|
|
return readl(gc->reg_base + reg_offset);
|
2014-11-07 13:44:17 +07:00
|
|
|
}
|
|
|
|
|
|
2017-09-14 04:29:14 +07:00
|
|
|
struct irq_matrix;
|
|
|
|
|
struct irq_matrix *irq_alloc_matrix(unsigned int matrix_bits,
|
|
|
|
|
unsigned int alloc_start,
|
|
|
|
|
unsigned int alloc_end);
|
|
|
|
|
void irq_matrix_online(struct irq_matrix *m);
|
|
|
|
|
void irq_matrix_offline(struct irq_matrix *m);
|
|
|
|
|
void irq_matrix_assign_system(struct irq_matrix *m, unsigned int bit, bool replace);
|
|
|
|
|
int irq_matrix_reserve_managed(struct irq_matrix *m, const struct cpumask *msk);
|
|
|
|
|
void irq_matrix_remove_managed(struct irq_matrix *m, const struct cpumask *msk);
|
2018-09-09 00:58:38 +07:00
|
|
|
int irq_matrix_alloc_managed(struct irq_matrix *m, const struct cpumask *msk,
|
|
|
|
|
unsigned int *mapped_cpu);
|
2017-09-14 04:29:14 +07:00
|
|
|
void irq_matrix_reserve(struct irq_matrix *m);
|
|
|
|
|
void irq_matrix_remove_reserved(struct irq_matrix *m);
|
|
|
|
|
int irq_matrix_alloc(struct irq_matrix *m, const struct cpumask *msk,
|
|
|
|
|
bool reserved, unsigned int *mapped_cpu);
|
|
|
|
|
void irq_matrix_free(struct irq_matrix *m, unsigned int cpu,
|
|
|
|
|
unsigned int bit, bool managed);
|
|
|
|
|
void irq_matrix_assign(struct irq_matrix *m, unsigned int bit);
|
|
|
|
|
unsigned int irq_matrix_available(struct irq_matrix *m, bool cpudown);
|
|
|
|
|
unsigned int irq_matrix_allocated(struct irq_matrix *m);
|
|
|
|
|
unsigned int irq_matrix_reserved(struct irq_matrix *m);
|
|
|
|
|
void irq_matrix_debug_show(struct seq_file *sf, struct irq_matrix *m, int ind);
|
|
|
|
|
|
2015-12-08 20:20:19 +07:00
|
|
|
/* Contrary to Linux irqs, for hardware irqs the irq number 0 is valid */
|
|
|
|
|
#define INVALID_HWIRQ (~0UL)
|
2015-12-08 20:20:20 +07:00
|
|
|
irq_hw_number_t ipi_get_hwirq(unsigned int irq, unsigned int cpu);
|
2015-12-08 20:20:22 +07:00
|
|
|
int __ipi_send_single(struct irq_desc *desc, unsigned int cpu);
|
|
|
|
|
int __ipi_send_mask(struct irq_desc *desc, const struct cpumask *dest);
|
|
|
|
|
int ipi_send_single(unsigned int virq, unsigned int cpu);
|
|
|
|
|
int ipi_send_mask(unsigned int virq, const struct cpumask *dest);
|
2015-12-08 20:20:19 +07:00
|
|
|
|
2018-03-08 06:57:27 +07:00
|
|
|
#ifdef CONFIG_GENERIC_IRQ_MULTI_HANDLER
|
|
|
|
|
/*
|
|
|
|
|
* Registers a generic IRQ handling function as the top-level IRQ handler in
|
|
|
|
|
* the system, which is generally the first C code called from an assembly
|
|
|
|
|
* architecture-specific interrupt handler.
|
|
|
|
|
*
|
|
|
|
|
* Returns 0 on success, or -EBUSY if an IRQ handler has already been
|
|
|
|
|
* registered.
|
|
|
|
|
*/
|
|
|
|
|
int __init set_handle_irq(void (*handle_irq)(struct pt_regs *));
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Allows interrupt handlers to find the irqchip that's been registered as the
|
|
|
|
|
* top-level IRQ handler.
|
|
|
|
|
*/
|
|
|
|
|
extern void (*handle_arch_irq)(struct pt_regs *) __ro_after_init;
|
|
|
|
|
#endif
|
|
|
|
|
|
2006-06-29 16:24:40 +07:00
|
|
|
#endif /* _LINUX_IRQ_H */
|