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 17:07:57 +03:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2011-07-26 13:19:06 +04:00
|
|
|
/*
|
|
|
|
|
* irq_domain - IRQ translation domains
|
|
|
|
|
*
|
|
|
|
|
* Translation infrastructure between hw and linux irq numbers. This is
|
|
|
|
|
* helpful for interrupt controllers to implement mapping between hardware
|
|
|
|
|
* irq numbers and the Linux irq number space.
|
|
|
|
|
*
|
2015-10-13 14:51:45 +03:00
|
|
|
* irq_domains also have hooks for translating device tree or other
|
|
|
|
|
* firmware interrupt representations into a hardware irq number that
|
|
|
|
|
* can be mapped back to a Linux irq number without any extra platform
|
|
|
|
|
* support code.
|
2011-07-26 13:19:06 +04:00
|
|
|
*
|
2012-02-15 01:06:48 +04:00
|
|
|
* Interrupt controller "domain" data structure. This could be defined as a
|
|
|
|
|
* irq domain controller. That is, it handles the mapping between hardware
|
|
|
|
|
* and virtual interrupt numbers for a given interrupt domain. The domain
|
|
|
|
|
* structure is generally created by the PIC code for a given PIC instance
|
|
|
|
|
* (though a domain can cover more than one PIC if they have a flat number
|
|
|
|
|
* model). It's the domain callbacks that are responsible for setting the
|
|
|
|
|
* irq_chip on a given irq_desc after it's been mapped.
|
2012-02-16 12:37:49 +04:00
|
|
|
*
|
2015-10-13 14:51:45 +03:00
|
|
|
* The host code and data structures use a fwnode_handle pointer to
|
|
|
|
|
* identify the domain. In some cases, and in order to preserve source
|
|
|
|
|
* code compatibility, this fwnode pointer is "upgraded" to a DT
|
|
|
|
|
* device_node. For those firmware infrastructures that do not provide
|
|
|
|
|
* a unique identifier for an interrupt controller, the irq_domain
|
|
|
|
|
* code offers a fwnode allocator.
|
2011-07-26 13:19:06 +04:00
|
|
|
*/
|
2012-02-15 01:06:48 +04:00
|
|
|
|
2011-07-26 13:19:06 +04:00
|
|
|
#ifndef _LINUX_IRQDOMAIN_H
|
|
|
|
|
#define _LINUX_IRQDOMAIN_H
|
|
|
|
|
|
2012-02-15 01:06:48 +04:00
|
|
|
#include <linux/types.h>
|
2014-11-09 18:10:24 +03:00
|
|
|
#include <linux/irqhandler.h>
|
2015-10-13 14:51:30 +03:00
|
|
|
#include <linux/of.h>
|
2017-10-05 04:44:54 +03:00
|
|
|
#include <linux/mutex.h>
|
2012-02-15 01:06:48 +04:00
|
|
|
#include <linux/radix-tree.h>
|
2011-07-26 13:19:06 +04:00
|
|
|
|
|
|
|
|
struct device_node;
|
2020-10-30 19:59:16 +03:00
|
|
|
struct fwnode_handle;
|
2011-07-26 13:19:06 +04:00
|
|
|
struct irq_domain;
|
2014-11-06 17:20:14 +03:00
|
|
|
struct irq_chip;
|
|
|
|
|
struct irq_data;
|
2021-05-04 16:00:13 +03:00
|
|
|
struct irq_desc;
|
2016-07-04 11:39:24 +03:00
|
|
|
struct cpumask;
|
2017-09-14 00:29:06 +03:00
|
|
|
struct seq_file;
|
2018-12-04 18:51:20 +03:00
|
|
|
struct irq_affinity_desc;
|
2012-02-15 01:06:48 +04:00
|
|
|
|
2015-10-13 14:51:32 +03:00
|
|
|
#define IRQ_DOMAIN_IRQ_SPEC_PARAMS 16
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct irq_fwspec - generic IRQ specifier structure
|
|
|
|
|
*
|
|
|
|
|
* @fwnode: Pointer to a firmware-specific descriptor
|
|
|
|
|
* @param_count: Number of device-specific parameters
|
|
|
|
|
* @param: Device-specific parameters
|
|
|
|
|
*
|
|
|
|
|
* This structure, directly modeled after of_phandle_args, is used to
|
|
|
|
|
* pass a device-specific description of an interrupt.
|
|
|
|
|
*/
|
|
|
|
|
struct irq_fwspec {
|
|
|
|
|
struct fwnode_handle *fwnode;
|
|
|
|
|
int param_count;
|
|
|
|
|
u32 param[IRQ_DOMAIN_IRQ_SPEC_PARAMS];
|
|
|
|
|
};
|
|
|
|
|
|
genirq/irqdomain: Allow irq domain aliasing
It is not uncommon (at least with the ARM stuff) to have a piece
of hardware that implements different flavours of "interrupts".
A typical example of this is the GICv3 ITS, which implements
standard PCI/MSI support, but also some form of "generic MSI".
So far, the PCI/MSI domain is registered using the ITS device_node,
so that irq_find_host can return it. On the contrary, the raw MSI
domain is not registered with an device_node, making it impossible
to be looked up by another subsystem (obviously, using the same
device_node twice would only result in confusion, as it is not
defined which one irq_find_host would return).
A solution to this is to "type" domains that may be aliasing, and
to be able to lookup an device_node that matches a given type.
For this, we introduce irq_find_matching_host() as a superset
of irq_find_host:
struct irq_domain *irq_find_matching_host(struct device_node *node,
enum irq_domain_bus_token bus_token);
where bus_token is the "type" we want to match the domain against
(so far, only DOMAIN_BUS_ANY is defined). This result in some
moderately invasive changes on the PPC side (which is the only
user of the .match method).
This has otherwise no functionnal change.
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: <linux-arm-kernel@lists.infradead.org>
Cc: Yijing Wang <wangyijing@huawei.com>
Cc: Ma Jun <majun258@huawei.com>
Cc: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
Cc: Duc Dang <dhdang@apm.com>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Jiang Liu <jiang.liu@linux.intel.com>
Cc: Jason Cooper <jason@lakedaemon.net>
Link: http://lkml.kernel.org/r/1438091186-10244-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2015-07-28 16:46:08 +03:00
|
|
|
/*
|
|
|
|
|
* Should several domains have the same device node, but serve
|
|
|
|
|
* different purposes (for example one domain is for PCI/MSI, and the
|
|
|
|
|
* other for wired IRQs), they can be distinguished using a
|
|
|
|
|
* bus-specific token. Most domains are expected to only carry
|
|
|
|
|
* DOMAIN_BUS_ANY.
|
|
|
|
|
*/
|
|
|
|
|
enum irq_domain_bus_token {
|
|
|
|
|
DOMAIN_BUS_ANY = 0,
|
irqdomain: Allow domain lookup with DOMAIN_BUS_WIRED token
Let's take the (outlandish) example of an interrupt controller
capable of handling both wired interrupts and PCI MSIs.
With the current code, the PCI MSI domain is going to be tagged
with DOMAIN_BUS_PCI_MSI, and the wired domain with DOMAIN_BUS_ANY.
Things get hairy when we start looking up the domain for a wired
interrupt (typically when creating it based on some firmware
information - DT or ACPI).
In irq_create_fwspec_mapping(), we perform the lookup using
DOMAIN_BUS_ANY, which is actually used as a wildcard. This gives
us one chance out of two to end up with the wrong domain, and
we try to configure a wired interrupt with the MSI domain.
Everything grinds to a halt pretty quickly.
What we really need to do is to start looking for a domain that
would uniquely identify a wired interrupt domain, and only use
DOMAIN_BUS_ANY as a fallback.
In order to solve this, let's introduce a new DOMAIN_BUS_WIRED
token, which is going to be used exactly as described above.
Of course, this depends on the irqchip to setup the domain
bus_token, and nobody had to implement this so far.
Only so far.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Rob Herring <robh+dt@kernel.org>
Cc: Frank Rowand <frowand.list@gmail.com>
Cc: Grant Likely <grant.likely@linaro.org>
Cc: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
Cc: Jiang Liu <jiang.liu@linux.intel.com>
Link: http://lkml.kernel.org/r/1453816347-32720-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2016-01-26 16:52:25 +03:00
|
|
|
DOMAIN_BUS_WIRED,
|
2018-10-01 17:13:51 +03:00
|
|
|
DOMAIN_BUS_GENERIC_MSI,
|
2015-07-28 16:46:09 +03:00
|
|
|
DOMAIN_BUS_PCI_MSI,
|
2015-07-28 16:46:15 +03:00
|
|
|
DOMAIN_BUS_PLATFORM_MSI,
|
2015-07-28 16:46:17 +03:00
|
|
|
DOMAIN_BUS_NEXUS,
|
2015-12-08 16:20:13 +03:00
|
|
|
DOMAIN_BUS_IPI,
|
2016-01-07 01:03:19 +03:00
|
|
|
DOMAIN_BUS_FSL_MC_MSI,
|
2019-04-30 13:12:28 +03:00
|
|
|
DOMAIN_BUS_TI_SCI_INTA_MSI,
|
2019-11-16 01:11:44 +03:00
|
|
|
DOMAIN_BUS_WAKEUP,
|
2020-08-26 14:16:51 +03:00
|
|
|
DOMAIN_BUS_VMD_MSI,
|
genirq/irqdomain: Allow irq domain aliasing
It is not uncommon (at least with the ARM stuff) to have a piece
of hardware that implements different flavours of "interrupts".
A typical example of this is the GICv3 ITS, which implements
standard PCI/MSI support, but also some form of "generic MSI".
So far, the PCI/MSI domain is registered using the ITS device_node,
so that irq_find_host can return it. On the contrary, the raw MSI
domain is not registered with an device_node, making it impossible
to be looked up by another subsystem (obviously, using the same
device_node twice would only result in confusion, as it is not
defined which one irq_find_host would return).
A solution to this is to "type" domains that may be aliasing, and
to be able to lookup an device_node that matches a given type.
For this, we introduce irq_find_matching_host() as a superset
of irq_find_host:
struct irq_domain *irq_find_matching_host(struct device_node *node,
enum irq_domain_bus_token bus_token);
where bus_token is the "type" we want to match the domain against
(so far, only DOMAIN_BUS_ANY is defined). This result in some
moderately invasive changes on the PPC side (which is the only
user of the .match method).
This has otherwise no functionnal change.
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: <linux-arm-kernel@lists.infradead.org>
Cc: Yijing Wang <wangyijing@huawei.com>
Cc: Ma Jun <majun258@huawei.com>
Cc: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
Cc: Duc Dang <dhdang@apm.com>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Jiang Liu <jiang.liu@linux.intel.com>
Cc: Jason Cooper <jason@lakedaemon.net>
Link: http://lkml.kernel.org/r/1438091186-10244-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2015-07-28 16:46:08 +03:00
|
|
|
};
|
|
|
|
|
|
2011-07-26 13:19:06 +04:00
|
|
|
/**
|
|
|
|
|
* struct irq_domain_ops - Methods for irq_domain objects
|
2012-02-15 01:06:48 +04:00
|
|
|
* @match: Match an interrupt controller device node to a host, returns
|
|
|
|
|
* 1 on a match
|
|
|
|
|
* @map: Create or update a mapping between a virtual irq number and a hw
|
|
|
|
|
* irq number. This is called only once for a given mapping.
|
|
|
|
|
* @unmap: Dispose of such a mapping
|
|
|
|
|
* @xlate: Given a device tree node and interrupt specifier, decode
|
|
|
|
|
* the hardware irq number and linux irq type value.
|
|
|
|
|
*
|
|
|
|
|
* Functions below are provided by the driver and called whenever a new mapping
|
|
|
|
|
* is created or an old mapping is disposed. The driver can then proceed to
|
|
|
|
|
* whatever internal data structures management is required. It also needs
|
|
|
|
|
* to setup the irq_desc when returning from map().
|
2011-07-26 13:19:06 +04:00
|
|
|
*/
|
|
|
|
|
struct irq_domain_ops {
|
genirq/irqdomain: Allow irq domain aliasing
It is not uncommon (at least with the ARM stuff) to have a piece
of hardware that implements different flavours of "interrupts".
A typical example of this is the GICv3 ITS, which implements
standard PCI/MSI support, but also some form of "generic MSI".
So far, the PCI/MSI domain is registered using the ITS device_node,
so that irq_find_host can return it. On the contrary, the raw MSI
domain is not registered with an device_node, making it impossible
to be looked up by another subsystem (obviously, using the same
device_node twice would only result in confusion, as it is not
defined which one irq_find_host would return).
A solution to this is to "type" domains that may be aliasing, and
to be able to lookup an device_node that matches a given type.
For this, we introduce irq_find_matching_host() as a superset
of irq_find_host:
struct irq_domain *irq_find_matching_host(struct device_node *node,
enum irq_domain_bus_token bus_token);
where bus_token is the "type" we want to match the domain against
(so far, only DOMAIN_BUS_ANY is defined). This result in some
moderately invasive changes on the PPC side (which is the only
user of the .match method).
This has otherwise no functionnal change.
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: <linux-arm-kernel@lists.infradead.org>
Cc: Yijing Wang <wangyijing@huawei.com>
Cc: Ma Jun <majun258@huawei.com>
Cc: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
Cc: Duc Dang <dhdang@apm.com>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Jiang Liu <jiang.liu@linux.intel.com>
Cc: Jason Cooper <jason@lakedaemon.net>
Link: http://lkml.kernel.org/r/1438091186-10244-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2015-07-28 16:46:08 +03:00
|
|
|
int (*match)(struct irq_domain *d, struct device_node *node,
|
|
|
|
|
enum irq_domain_bus_token bus_token);
|
2016-04-11 11:57:51 +03:00
|
|
|
int (*select)(struct irq_domain *d, struct irq_fwspec *fwspec,
|
|
|
|
|
enum irq_domain_bus_token bus_token);
|
2012-02-15 01:06:48 +04:00
|
|
|
int (*map)(struct irq_domain *d, unsigned int virq, irq_hw_number_t hw);
|
|
|
|
|
void (*unmap)(struct irq_domain *d, unsigned int virq);
|
|
|
|
|
int (*xlate)(struct irq_domain *d, struct device_node *node,
|
|
|
|
|
const u32 *intspec, unsigned int intsize,
|
|
|
|
|
unsigned long *out_hwirq, unsigned int *out_type);
|
2014-11-06 17:20:14 +03:00
|
|
|
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
|
|
|
|
|
/* extended V2 interfaces to support hierarchy irq_domains */
|
|
|
|
|
int (*alloc)(struct irq_domain *d, unsigned int virq,
|
|
|
|
|
unsigned int nr_irqs, void *arg);
|
|
|
|
|
void (*free)(struct irq_domain *d, unsigned int virq,
|
|
|
|
|
unsigned int nr_irqs);
|
2017-12-29 18:59:06 +03:00
|
|
|
int (*activate)(struct irq_domain *d, struct irq_data *irqd, bool reserve);
|
2014-11-06 17:20:14 +03:00
|
|
|
void (*deactivate)(struct irq_domain *d, struct irq_data *irq_data);
|
2015-10-13 14:51:32 +03:00
|
|
|
int (*translate)(struct irq_domain *d, struct irq_fwspec *fwspec,
|
|
|
|
|
unsigned long *out_hwirq, unsigned int *out_type);
|
2014-11-06 17:20:14 +03:00
|
|
|
#endif
|
2017-09-14 00:29:06 +03:00
|
|
|
#ifdef CONFIG_GENERIC_IRQ_DEBUGFS
|
|
|
|
|
void (*debug_show)(struct seq_file *m, struct irq_domain *d,
|
|
|
|
|
struct irq_data *irqd, int ind);
|
|
|
|
|
#endif
|
2011-07-26 13:19:06 +04:00
|
|
|
};
|
|
|
|
|
|
2013-05-06 18:30:27 +04:00
|
|
|
extern struct irq_domain_ops irq_generic_chip_ops;
|
|
|
|
|
|
|
|
|
|
struct irq_domain_chip_generic;
|
|
|
|
|
|
2011-07-26 13:19:06 +04:00
|
|
|
/**
|
|
|
|
|
* struct irq_domain - Hardware interrupt number translation object
|
2012-02-15 01:06:48 +04:00
|
|
|
* @link: Element in global irq_domain list.
|
2013-06-08 15:03:59 +04:00
|
|
|
* @name: Name of interrupt domain
|
2012-02-15 01:06:48 +04:00
|
|
|
* @ops: pointer to irq_domain methods
|
|
|
|
|
* @host_data: private data pointer for use by owner. Not touched by irq_domain
|
|
|
|
|
* core code.
|
2014-11-06 17:20:14 +03:00
|
|
|
* @flags: host per irq_domain flags
|
2017-06-20 02:37:16 +03:00
|
|
|
* @mapcount: The number of mapped interrupts
|
2013-06-08 15:03:59 +04:00
|
|
|
*
|
|
|
|
|
* Optional elements
|
2017-10-30 05:15:00 +03:00
|
|
|
* @fwnode: Pointer to firmware node associated with the irq_domain. Pretty easy
|
|
|
|
|
* to swap it for the of_node via the irq_domain_get_of_node accessor
|
2013-06-08 15:03:59 +04:00
|
|
|
* @gc: Pointer to a list of generic chips. There is a helper function for
|
|
|
|
|
* setting up one or more generic chips for interrupt controllers
|
|
|
|
|
* drivers using the generic chip library which uses this pointer.
|
2014-11-06 17:20:14 +03:00
|
|
|
* @parent: Pointer to parent irq_domain to support hierarchy irq_domains
|
2013-06-08 15:03:59 +04:00
|
|
|
*
|
|
|
|
|
* Revmap data, used internally by irq_domain
|
2021-04-02 14:50:14 +03:00
|
|
|
* @revmap_size: Size of the linear map table @revmap[]
|
2013-06-08 15:03:59 +04:00
|
|
|
* @revmap_tree: Radix map tree for hwirqs that don't fit in the linear map
|
2021-04-05 14:57:27 +03:00
|
|
|
* @revmap_mutex: Lock for the revmap
|
2021-04-05 13:46:53 +03:00
|
|
|
* @revmap: Linear table of irq_data pointers
|
2011-07-26 13:19:06 +04:00
|
|
|
*/
|
|
|
|
|
struct irq_domain {
|
2012-02-15 01:06:48 +04:00
|
|
|
struct list_head link;
|
2013-06-06 17:23:30 +04:00
|
|
|
const char *name;
|
2012-01-26 23:12:14 +04:00
|
|
|
const struct irq_domain_ops *ops;
|
2012-02-15 01:06:48 +04:00
|
|
|
void *host_data;
|
2014-11-06 17:20:14 +03:00
|
|
|
unsigned int flags;
|
2017-06-20 02:37:16 +03:00
|
|
|
unsigned int mapcount;
|
2012-02-15 01:06:48 +04:00
|
|
|
|
2013-06-08 15:03:59 +04:00
|
|
|
/* Optional data */
|
2015-10-13 14:51:30 +03:00
|
|
|
struct fwnode_handle *fwnode;
|
genirq/irqdomain: Allow irq domain aliasing
It is not uncommon (at least with the ARM stuff) to have a piece
of hardware that implements different flavours of "interrupts".
A typical example of this is the GICv3 ITS, which implements
standard PCI/MSI support, but also some form of "generic MSI".
So far, the PCI/MSI domain is registered using the ITS device_node,
so that irq_find_host can return it. On the contrary, the raw MSI
domain is not registered with an device_node, making it impossible
to be looked up by another subsystem (obviously, using the same
device_node twice would only result in confusion, as it is not
defined which one irq_find_host would return).
A solution to this is to "type" domains that may be aliasing, and
to be able to lookup an device_node that matches a given type.
For this, we introduce irq_find_matching_host() as a superset
of irq_find_host:
struct irq_domain *irq_find_matching_host(struct device_node *node,
enum irq_domain_bus_token bus_token);
where bus_token is the "type" we want to match the domain against
(so far, only DOMAIN_BUS_ANY is defined). This result in some
moderately invasive changes on the PPC side (which is the only
user of the .match method).
This has otherwise no functionnal change.
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: <linux-arm-kernel@lists.infradead.org>
Cc: Yijing Wang <wangyijing@huawei.com>
Cc: Ma Jun <majun258@huawei.com>
Cc: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
Cc: Duc Dang <dhdang@apm.com>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Jiang Liu <jiang.liu@linux.intel.com>
Cc: Jason Cooper <jason@lakedaemon.net>
Link: http://lkml.kernel.org/r/1438091186-10244-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2015-07-28 16:46:08 +03:00
|
|
|
enum irq_domain_bus_token bus_token;
|
2013-05-06 18:30:27 +04:00
|
|
|
struct irq_domain_chip_generic *gc;
|
2014-11-06 17:20:14 +03:00
|
|
|
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
|
|
|
|
|
struct irq_domain *parent;
|
|
|
|
|
#endif
|
2012-07-11 20:24:31 +04:00
|
|
|
|
2013-06-08 15:03:59 +04:00
|
|
|
/* reverse map data. The linear map gets appended to the irq_domain */
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 04:06:02 +04:00
|
|
|
irq_hw_number_t hwirq_max;
|
2013-06-08 15:03:59 +04:00
|
|
|
unsigned int revmap_size;
|
|
|
|
|
struct radix_tree_root revmap_tree;
|
2021-04-05 14:57:27 +03:00
|
|
|
struct mutex revmap_mutex;
|
|
|
|
|
struct irq_data __rcu *revmap[];
|
2011-07-26 13:19:06 +04:00
|
|
|
};
|
|
|
|
|
|
2014-11-06 17:20:14 +03:00
|
|
|
/* Irq domain flags */
|
|
|
|
|
enum {
|
|
|
|
|
/* Irq domain is hierarchical */
|
|
|
|
|
IRQ_DOMAIN_FLAG_HIERARCHY = (1 << 0),
|
|
|
|
|
|
2017-06-21 00:17:44 +03:00
|
|
|
/* Irq domain name was allocated in __irq_domain_add() */
|
2020-02-21 05:07:25 +03:00
|
|
|
IRQ_DOMAIN_NAME_ALLOCATED = (1 << 1),
|
2014-11-15 17:24:01 +03:00
|
|
|
|
2015-12-08 16:20:12 +03:00
|
|
|
/* Irq domain is an IPI domain with virq per cpu */
|
|
|
|
|
IRQ_DOMAIN_FLAG_IPI_PER_CPU = (1 << 2),
|
|
|
|
|
|
|
|
|
|
/* Irq domain is an IPI domain with single virq */
|
|
|
|
|
IRQ_DOMAIN_FLAG_IPI_SINGLE = (1 << 3),
|
|
|
|
|
|
2017-01-19 23:57:57 +03:00
|
|
|
/* Irq domain implements MSIs */
|
|
|
|
|
IRQ_DOMAIN_FLAG_MSI = (1 << 4),
|
|
|
|
|
|
|
|
|
|
/* Irq domain implements MSI remapping */
|
|
|
|
|
IRQ_DOMAIN_FLAG_MSI_REMAP = (1 << 5),
|
|
|
|
|
|
2020-01-31 17:26:52 +03:00
|
|
|
/*
|
|
|
|
|
* Quirk to handle MSI implementations which do not provide
|
|
|
|
|
* masking. Currently known to affect x86, but partially
|
|
|
|
|
* handled in core code.
|
|
|
|
|
*/
|
|
|
|
|
IRQ_DOMAIN_MSI_NOMASK_QUIRK = (1 << 6),
|
|
|
|
|
|
2018-09-10 20:33:46 +03:00
|
|
|
/* Irq domain doesn't translate anything */
|
|
|
|
|
IRQ_DOMAIN_FLAG_NO_MAP = (1 << 7),
|
|
|
|
|
|
2014-11-06 17:20:14 +03:00
|
|
|
/*
|
|
|
|
|
* Flags starting from IRQ_DOMAIN_FLAG_NONCORE are reserved
|
|
|
|
|
* for implementation specific purposes and ignored by the
|
|
|
|
|
* core code.
|
|
|
|
|
*/
|
|
|
|
|
IRQ_DOMAIN_FLAG_NONCORE = (1 << 16),
|
|
|
|
|
};
|
|
|
|
|
|
2015-10-09 17:50:11 +03:00
|
|
|
static inline struct device_node *irq_domain_get_of_node(struct irq_domain *d)
|
|
|
|
|
{
|
2015-10-13 14:51:30 +03:00
|
|
|
return to_of_node(d->fwnode);
|
2015-10-09 17:50:11 +03:00
|
|
|
}
|
|
|
|
|
|
2012-02-15 01:06:48 +04:00
|
|
|
#ifdef CONFIG_IRQ_DOMAIN
|
2017-06-20 02:37:05 +03:00
|
|
|
struct fwnode_handle *__irq_domain_alloc_fwnode(unsigned int type, int id,
|
2019-07-31 17:13:19 +03:00
|
|
|
const char *name, phys_addr_t *pa);
|
2017-06-20 02:37:05 +03:00
|
|
|
|
|
|
|
|
enum {
|
|
|
|
|
IRQCHIP_FWNODE_REAL,
|
|
|
|
|
IRQCHIP_FWNODE_NAMED,
|
|
|
|
|
IRQCHIP_FWNODE_NAMED_ID,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static inline
|
|
|
|
|
struct fwnode_handle *irq_domain_alloc_named_fwnode(const char *name)
|
|
|
|
|
{
|
|
|
|
|
return __irq_domain_alloc_fwnode(IRQCHIP_FWNODE_NAMED, 0, name, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline
|
|
|
|
|
struct fwnode_handle *irq_domain_alloc_named_id_fwnode(const char *name, int id)
|
|
|
|
|
{
|
|
|
|
|
return __irq_domain_alloc_fwnode(IRQCHIP_FWNODE_NAMED_ID, id, name,
|
|
|
|
|
NULL);
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-31 17:13:19 +03:00
|
|
|
static inline struct fwnode_handle *irq_domain_alloc_fwnode(phys_addr_t *pa)
|
2017-06-20 02:37:05 +03:00
|
|
|
{
|
2019-07-31 17:13:19 +03:00
|
|
|
return __irq_domain_alloc_fwnode(IRQCHIP_FWNODE_REAL, 0, NULL, pa);
|
2017-06-20 02:37:05 +03:00
|
|
|
}
|
|
|
|
|
|
2015-10-13 14:51:36 +03:00
|
|
|
void irq_domain_free_fwnode(struct fwnode_handle *fwnode);
|
2015-10-13 14:51:35 +03:00
|
|
|
struct irq_domain *__irq_domain_add(struct fwnode_handle *fwnode, int size,
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 04:06:02 +04:00
|
|
|
irq_hw_number_t hwirq_max, int direct_max,
|
2013-06-08 15:57:40 +04:00
|
|
|
const struct irq_domain_ops *ops,
|
|
|
|
|
void *host_data);
|
2021-03-09 12:37:31 +03:00
|
|
|
struct irq_domain *irq_domain_create_simple(struct fwnode_handle *fwnode,
|
|
|
|
|
unsigned int size,
|
|
|
|
|
unsigned int first_irq,
|
|
|
|
|
const struct irq_domain_ops *ops,
|
|
|
|
|
void *host_data);
|
2012-02-15 01:06:54 +04:00
|
|
|
struct irq_domain *irq_domain_add_legacy(struct device_node *of_node,
|
2012-02-15 01:06:55 +04:00
|
|
|
unsigned int size,
|
|
|
|
|
unsigned int first_irq,
|
|
|
|
|
irq_hw_number_t first_hwirq,
|
2012-01-26 23:12:14 +04:00
|
|
|
const struct irq_domain_ops *ops,
|
2012-02-15 01:06:54 +04:00
|
|
|
void *host_data);
|
2020-10-30 19:59:18 +03:00
|
|
|
struct irq_domain *irq_domain_create_legacy(struct fwnode_handle *fwnode,
|
|
|
|
|
unsigned int size,
|
|
|
|
|
unsigned int first_irq,
|
|
|
|
|
irq_hw_number_t first_hwirq,
|
|
|
|
|
const struct irq_domain_ops *ops,
|
|
|
|
|
void *host_data);
|
2016-04-11 11:57:51 +03:00
|
|
|
extern struct irq_domain *irq_find_matching_fwspec(struct irq_fwspec *fwspec,
|
2015-10-13 14:51:31 +03:00
|
|
|
enum irq_domain_bus_token bus_token);
|
2017-01-19 23:57:59 +03:00
|
|
|
extern bool irq_domain_check_msi_remap(void);
|
2013-06-08 15:57:40 +04:00
|
|
|
extern void irq_set_default_host(struct irq_domain *host);
|
2019-02-20 11:59:23 +03:00
|
|
|
extern struct irq_domain *irq_get_default_host(void);
|
2015-12-08 16:20:18 +03:00
|
|
|
extern int irq_domain_alloc_descs(int virq, unsigned int nr_irqs,
|
2016-07-04 11:39:24 +03:00
|
|
|
irq_hw_number_t hwirq, int node,
|
2018-12-04 18:51:20 +03:00
|
|
|
const struct irq_affinity_desc *affinity);
|
2013-06-08 15:57:40 +04:00
|
|
|
|
2015-10-13 14:51:35 +03:00
|
|
|
static inline struct fwnode_handle *of_node_to_fwnode(struct device_node *node)
|
|
|
|
|
{
|
|
|
|
|
return node ? &node->fwnode : NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2017-07-21 14:39:31 +03:00
|
|
|
extern const struct fwnode_operations irqchip_fwnode_ops;
|
|
|
|
|
|
2015-12-10 19:55:28 +03:00
|
|
|
static inline bool is_fwnode_irqchip(struct fwnode_handle *fwnode)
|
|
|
|
|
{
|
2017-07-21 14:39:31 +03:00
|
|
|
return fwnode && fwnode->ops == &irqchip_fwnode_ops;
|
2015-12-10 19:55:28 +03:00
|
|
|
}
|
|
|
|
|
|
2017-06-22 13:34:57 +03:00
|
|
|
extern void irq_domain_update_bus_token(struct irq_domain *domain,
|
|
|
|
|
enum irq_domain_bus_token bus_token);
|
|
|
|
|
|
2016-04-11 11:57:51 +03:00
|
|
|
static inline
|
|
|
|
|
struct irq_domain *irq_find_matching_fwnode(struct fwnode_handle *fwnode,
|
|
|
|
|
enum irq_domain_bus_token bus_token)
|
|
|
|
|
{
|
|
|
|
|
struct irq_fwspec fwspec = {
|
|
|
|
|
.fwnode = fwnode,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return irq_find_matching_fwspec(&fwspec, bus_token);
|
|
|
|
|
}
|
|
|
|
|
|
2015-10-13 14:51:31 +03:00
|
|
|
static inline struct irq_domain *irq_find_matching_host(struct device_node *node,
|
|
|
|
|
enum irq_domain_bus_token bus_token)
|
|
|
|
|
{
|
2015-10-13 14:51:35 +03:00
|
|
|
return irq_find_matching_fwnode(of_node_to_fwnode(node), bus_token);
|
2015-10-13 14:51:31 +03:00
|
|
|
}
|
|
|
|
|
|
genirq/irqdomain: Allow irq domain aliasing
It is not uncommon (at least with the ARM stuff) to have a piece
of hardware that implements different flavours of "interrupts".
A typical example of this is the GICv3 ITS, which implements
standard PCI/MSI support, but also some form of "generic MSI".
So far, the PCI/MSI domain is registered using the ITS device_node,
so that irq_find_host can return it. On the contrary, the raw MSI
domain is not registered with an device_node, making it impossible
to be looked up by another subsystem (obviously, using the same
device_node twice would only result in confusion, as it is not
defined which one irq_find_host would return).
A solution to this is to "type" domains that may be aliasing, and
to be able to lookup an device_node that matches a given type.
For this, we introduce irq_find_matching_host() as a superset
of irq_find_host:
struct irq_domain *irq_find_matching_host(struct device_node *node,
enum irq_domain_bus_token bus_token);
where bus_token is the "type" we want to match the domain against
(so far, only DOMAIN_BUS_ANY is defined). This result in some
moderately invasive changes on the PPC side (which is the only
user of the .match method).
This has otherwise no functionnal change.
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: <linux-arm-kernel@lists.infradead.org>
Cc: Yijing Wang <wangyijing@huawei.com>
Cc: Ma Jun <majun258@huawei.com>
Cc: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
Cc: Duc Dang <dhdang@apm.com>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Jiang Liu <jiang.liu@linux.intel.com>
Cc: Jason Cooper <jason@lakedaemon.net>
Link: http://lkml.kernel.org/r/1438091186-10244-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2015-07-28 16:46:08 +03:00
|
|
|
static inline struct irq_domain *irq_find_host(struct device_node *node)
|
|
|
|
|
{
|
2018-05-08 15:14:34 +03:00
|
|
|
struct irq_domain *d;
|
|
|
|
|
|
|
|
|
|
d = irq_find_matching_host(node, DOMAIN_BUS_WIRED);
|
|
|
|
|
if (!d)
|
|
|
|
|
d = irq_find_matching_host(node, DOMAIN_BUS_ANY);
|
|
|
|
|
|
|
|
|
|
return d;
|
genirq/irqdomain: Allow irq domain aliasing
It is not uncommon (at least with the ARM stuff) to have a piece
of hardware that implements different flavours of "interrupts".
A typical example of this is the GICv3 ITS, which implements
standard PCI/MSI support, but also some form of "generic MSI".
So far, the PCI/MSI domain is registered using the ITS device_node,
so that irq_find_host can return it. On the contrary, the raw MSI
domain is not registered with an device_node, making it impossible
to be looked up by another subsystem (obviously, using the same
device_node twice would only result in confusion, as it is not
defined which one irq_find_host would return).
A solution to this is to "type" domains that may be aliasing, and
to be able to lookup an device_node that matches a given type.
For this, we introduce irq_find_matching_host() as a superset
of irq_find_host:
struct irq_domain *irq_find_matching_host(struct device_node *node,
enum irq_domain_bus_token bus_token);
where bus_token is the "type" we want to match the domain against
(so far, only DOMAIN_BUS_ANY is defined). This result in some
moderately invasive changes on the PPC side (which is the only
user of the .match method).
This has otherwise no functionnal change.
Reviewed-by: Hanjun Guo <hanjun.guo@linaro.org>
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: <linux-arm-kernel@lists.infradead.org>
Cc: Yijing Wang <wangyijing@huawei.com>
Cc: Ma Jun <majun258@huawei.com>
Cc: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
Cc: Duc Dang <dhdang@apm.com>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Jiang Liu <jiang.liu@linux.intel.com>
Cc: Jason Cooper <jason@lakedaemon.net>
Link: http://lkml.kernel.org/r/1438091186-10244-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2015-07-28 16:46:08 +03:00
|
|
|
}
|
|
|
|
|
|
2021-03-09 12:37:31 +03:00
|
|
|
static inline struct irq_domain *irq_domain_add_simple(struct device_node *of_node,
|
|
|
|
|
unsigned int size,
|
|
|
|
|
unsigned int first_irq,
|
|
|
|
|
const struct irq_domain_ops *ops,
|
|
|
|
|
void *host_data)
|
|
|
|
|
{
|
|
|
|
|
return irq_domain_create_simple(of_node_to_fwnode(of_node), size, first_irq, ops, host_data);
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-08 15:57:40 +04:00
|
|
|
/**
|
|
|
|
|
* irq_domain_add_linear() - Allocate and register a linear revmap irq_domain.
|
|
|
|
|
* @of_node: pointer to interrupt controller's device tree node.
|
|
|
|
|
* @size: Number of interrupts in the domain.
|
|
|
|
|
* @ops: map/unmap domain callbacks
|
|
|
|
|
* @host_data: Controller private data pointer
|
|
|
|
|
*/
|
|
|
|
|
static inline struct irq_domain *irq_domain_add_linear(struct device_node *of_node,
|
2012-02-15 01:06:54 +04:00
|
|
|
unsigned int size,
|
2012-01-26 23:12:14 +04:00
|
|
|
const struct irq_domain_ops *ops,
|
2013-06-08 15:57:40 +04:00
|
|
|
void *host_data)
|
|
|
|
|
{
|
2015-10-13 14:51:35 +03:00
|
|
|
return __irq_domain_add(of_node_to_fwnode(of_node), size, size, 0, ops, host_data);
|
2013-06-08 15:57:40 +04:00
|
|
|
}
|
2021-04-04 15:06:39 +03:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_IRQ_DOMAIN_NOMAP
|
2013-06-08 15:57:40 +04:00
|
|
|
static inline struct irq_domain *irq_domain_add_nomap(struct device_node *of_node,
|
2012-02-16 02:06:08 +04:00
|
|
|
unsigned int max_irq,
|
2012-01-26 23:12:14 +04:00
|
|
|
const struct irq_domain_ops *ops,
|
2013-06-08 15:57:40 +04:00
|
|
|
void *host_data)
|
|
|
|
|
{
|
2015-10-13 14:51:35 +03:00
|
|
|
return __irq_domain_add(of_node_to_fwnode(of_node), 0, max_irq, max_irq, ops, host_data);
|
2013-06-08 15:57:40 +04:00
|
|
|
}
|
2021-04-04 15:06:39 +03:00
|
|
|
|
|
|
|
|
extern unsigned int irq_create_direct_mapping(struct irq_domain *host);
|
|
|
|
|
#endif
|
|
|
|
|
|
2012-07-11 20:24:31 +04:00
|
|
|
static inline struct irq_domain *irq_domain_add_tree(struct device_node *of_node,
|
|
|
|
|
const struct irq_domain_ops *ops,
|
|
|
|
|
void *host_data)
|
|
|
|
|
{
|
2015-10-13 14:51:35 +03:00
|
|
|
return __irq_domain_add(of_node_to_fwnode(of_node), 0, ~0, 0, ops, host_data);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline struct irq_domain *irq_domain_create_linear(struct fwnode_handle *fwnode,
|
|
|
|
|
unsigned int size,
|
|
|
|
|
const struct irq_domain_ops *ops,
|
|
|
|
|
void *host_data)
|
|
|
|
|
{
|
|
|
|
|
return __irq_domain_add(fwnode, size, size, 0, ops, host_data);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline struct irq_domain *irq_domain_create_tree(struct fwnode_handle *fwnode,
|
|
|
|
|
const struct irq_domain_ops *ops,
|
|
|
|
|
void *host_data)
|
|
|
|
|
{
|
|
|
|
|
return __irq_domain_add(fwnode, 0, ~0, 0, ops, host_data);
|
2012-07-11 20:24:31 +04:00
|
|
|
}
|
2012-05-19 10:11:41 +04:00
|
|
|
|
|
|
|
|
extern void irq_domain_remove(struct irq_domain *host);
|
|
|
|
|
|
irqdomain: Refactor irq_domain_associate_many()
Originally, irq_domain_associate_many() was designed to unwind the
mapped irqs on a failure of any individual association. However, that
proved to be a problem with certain IRQ controllers. Some of them only
support a subset of irqs, and will fail when attempting to map a
reserved IRQ. In those cases we want to map as many IRQs as possible, so
instead it is better for irq_domain_associate_many() to make a
best-effort attempt to map irqs, but not fail if any or all of them
don't succeed. If a caller really cares about how many irqs got
associated, then it should instead go back and check that all of the
irqs is cares about were mapped.
The original design open-coded the individual association code into the
body of irq_domain_associate_many(), but with no longer needing to
unwind associations, the code becomes simpler to split out
irq_domain_associate() to contain the bulk of the logic, and
irq_domain_associate_many() to be a simple loop wrapper.
This patch also adds a new error check to the associate path to make
sure it isn't called for an irq larger than the controller can handle,
and adds locking so that the irq_domain_mutex is held while setting up a
new association.
v3: Fixup missing change to irq_domain_add_tree()
v2: Fixup x86 warning. irq_domain_associate_many() no longer returns an
error code, but reports errors to the printk log directly. In the
majority of cases we don't actually want to fail if there is a
problem, but rather log it and still try to boot the system.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
irqdomain: Fix flubbed irq_domain_associate_many refactoring
commit d39046ec72, "irqdomain: Refactor irq_domain_associate_many()" was
missing the following hunk which causes a boot failure on anything using
irq_domain_add_tree() to allocate an irq domain.
Signed-off-by: Grant Likely <grant.likely@linaro.org>
Cc: Michael Neuling <mikey@neuling.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>,
Cc: Thomas Gleixner <tglx@linutronix.de>,
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
2013-06-10 04:06:02 +04:00
|
|
|
extern int irq_domain_associate(struct irq_domain *domain, unsigned int irq,
|
|
|
|
|
irq_hw_number_t hwirq);
|
|
|
|
|
extern void irq_domain_associate_many(struct irq_domain *domain,
|
|
|
|
|
unsigned int irq_base,
|
|
|
|
|
irq_hw_number_t hwirq_base, int count);
|
2012-06-18 02:17:04 +04:00
|
|
|
|
2020-11-26 11:28:51 +03:00
|
|
|
extern unsigned int irq_create_mapping_affinity(struct irq_domain *host,
|
|
|
|
|
irq_hw_number_t hwirq,
|
|
|
|
|
const struct irq_affinity_desc *affinity);
|
2015-10-13 14:51:34 +03:00
|
|
|
extern unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec);
|
2012-02-16 12:37:49 +04:00
|
|
|
extern void irq_dispose_mapping(unsigned int virq);
|
2013-06-10 15:19:17 +04:00
|
|
|
|
2020-11-26 11:28:51 +03:00
|
|
|
static inline unsigned int irq_create_mapping(struct irq_domain *host,
|
|
|
|
|
irq_hw_number_t hwirq)
|
|
|
|
|
{
|
|
|
|
|
return irq_create_mapping_affinity(host, hwirq, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
2021-05-04 16:00:13 +03:00
|
|
|
extern struct irq_desc *__irq_resolve_mapping(struct irq_domain *domain,
|
|
|
|
|
irq_hw_number_t hwirq,
|
|
|
|
|
unsigned int *irq);
|
|
|
|
|
|
|
|
|
|
static inline struct irq_desc *irq_resolve_mapping(struct irq_domain *domain,
|
|
|
|
|
irq_hw_number_t hwirq)
|
|
|
|
|
{
|
|
|
|
|
return __irq_resolve_mapping(domain, hwirq, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-10 15:19:17 +04:00
|
|
|
/**
|
2021-04-02 14:50:14 +03:00
|
|
|
* irq_find_mapping() - Find a linux irq from a hw irq number.
|
2013-06-10 15:19:17 +04:00
|
|
|
* @domain: domain owning this hardware interrupt
|
|
|
|
|
* @hwirq: hardware irq number in that domain space
|
|
|
|
|
*/
|
2021-05-04 16:00:13 +03:00
|
|
|
static inline unsigned int irq_find_mapping(struct irq_domain *domain,
|
|
|
|
|
irq_hw_number_t hwirq)
|
|
|
|
|
{
|
|
|
|
|
unsigned int irq;
|
|
|
|
|
|
|
|
|
|
if (__irq_resolve_mapping(domain, hwirq, &irq))
|
|
|
|
|
return irq;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2021-04-02 14:50:14 +03:00
|
|
|
|
2013-06-10 15:19:17 +04:00
|
|
|
static inline unsigned int irq_linear_revmap(struct irq_domain *domain,
|
|
|
|
|
irq_hw_number_t hwirq)
|
|
|
|
|
{
|
2021-04-02 14:50:14 +03:00
|
|
|
return irq_find_mapping(domain, hwirq);
|
2013-06-10 15:19:17 +04:00
|
|
|
}
|
2021-04-02 14:50:14 +03:00
|
|
|
|
2012-01-26 23:12:14 +04:00
|
|
|
extern const struct irq_domain_ops irq_domain_simple_ops;
|
2012-01-26 22:26:52 +04:00
|
|
|
|
|
|
|
|
/* stock xlate functions */
|
|
|
|
|
int irq_domain_xlate_onecell(struct irq_domain *d, struct device_node *ctrlr,
|
|
|
|
|
const u32 *intspec, unsigned int intsize,
|
|
|
|
|
irq_hw_number_t *out_hwirq, unsigned int *out_type);
|
|
|
|
|
int irq_domain_xlate_twocell(struct irq_domain *d, struct device_node *ctrlr,
|
|
|
|
|
const u32 *intspec, unsigned int intsize,
|
|
|
|
|
irq_hw_number_t *out_hwirq, unsigned int *out_type);
|
|
|
|
|
int irq_domain_xlate_onetwocell(struct irq_domain *d, struct device_node *ctrlr,
|
|
|
|
|
const u32 *intspec, unsigned int intsize,
|
|
|
|
|
irq_hw_number_t *out_hwirq, unsigned int *out_type);
|
|
|
|
|
|
2019-02-08 05:16:22 +03:00
|
|
|
int irq_domain_translate_twocell(struct irq_domain *d,
|
|
|
|
|
struct irq_fwspec *fwspec,
|
|
|
|
|
unsigned long *out_hwirq,
|
|
|
|
|
unsigned int *out_type);
|
|
|
|
|
|
2019-12-10 14:11:09 +03:00
|
|
|
int irq_domain_translate_onecell(struct irq_domain *d,
|
|
|
|
|
struct irq_fwspec *fwspec,
|
|
|
|
|
unsigned long *out_hwirq,
|
|
|
|
|
unsigned int *out_type);
|
|
|
|
|
|
2015-12-08 16:20:19 +03:00
|
|
|
/* IPI functions */
|
2016-04-25 10:14:24 +03:00
|
|
|
int irq_reserve_ipi(struct irq_domain *domain, const struct cpumask *dest);
|
|
|
|
|
int irq_destroy_ipi(unsigned int irq, const struct cpumask *dest);
|
2015-12-08 16:20:19 +03:00
|
|
|
|
2014-11-06 17:20:14 +03:00
|
|
|
/* V2 interfaces to support hierarchy IRQ domains. */
|
|
|
|
|
extern struct irq_data *irq_domain_get_irq_data(struct irq_domain *domain,
|
|
|
|
|
unsigned int virq);
|
2015-05-16 12:44:13 +03:00
|
|
|
extern void irq_domain_set_info(struct irq_domain *domain, unsigned int virq,
|
|
|
|
|
irq_hw_number_t hwirq, struct irq_chip *chip,
|
|
|
|
|
void *chip_data, irq_flow_handler_t handler,
|
|
|
|
|
void *handler_data, const char *handler_name);
|
2020-05-14 11:39:00 +03:00
|
|
|
extern void irq_domain_reset_irq_data(struct irq_data *irq_data);
|
2014-11-06 17:20:14 +03:00
|
|
|
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
|
2015-10-13 14:51:43 +03:00
|
|
|
extern struct irq_domain *irq_domain_create_hierarchy(struct irq_domain *parent,
|
2014-11-15 17:24:02 +03:00
|
|
|
unsigned int flags, unsigned int size,
|
2015-10-13 14:51:43 +03:00
|
|
|
struct fwnode_handle *fwnode,
|
2014-11-15 17:24:02 +03:00
|
|
|
const struct irq_domain_ops *ops, void *host_data);
|
2015-10-13 14:51:43 +03:00
|
|
|
|
|
|
|
|
static inline struct irq_domain *irq_domain_add_hierarchy(struct irq_domain *parent,
|
|
|
|
|
unsigned int flags,
|
|
|
|
|
unsigned int size,
|
|
|
|
|
struct device_node *node,
|
|
|
|
|
const struct irq_domain_ops *ops,
|
|
|
|
|
void *host_data)
|
|
|
|
|
{
|
|
|
|
|
return irq_domain_create_hierarchy(parent, flags, size,
|
|
|
|
|
of_node_to_fwnode(node),
|
|
|
|
|
ops, host_data);
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-06 17:20:14 +03:00
|
|
|
extern int __irq_domain_alloc_irqs(struct irq_domain *domain, int irq_base,
|
|
|
|
|
unsigned int nr_irqs, int node, void *arg,
|
2018-12-04 18:51:20 +03:00
|
|
|
bool realloc,
|
|
|
|
|
const struct irq_affinity_desc *affinity);
|
2014-11-06 17:20:14 +03:00
|
|
|
extern void irq_domain_free_irqs(unsigned int virq, unsigned int nr_irqs);
|
2017-09-14 00:29:12 +03:00
|
|
|
extern int irq_domain_activate_irq(struct irq_data *irq_data, bool early);
|
2014-11-06 17:20:14 +03:00
|
|
|
extern void irq_domain_deactivate_irq(struct irq_data *irq_data);
|
|
|
|
|
|
|
|
|
|
static inline int irq_domain_alloc_irqs(struct irq_domain *domain,
|
|
|
|
|
unsigned int nr_irqs, int node, void *arg)
|
|
|
|
|
{
|
2016-07-04 11:39:24 +03:00
|
|
|
return __irq_domain_alloc_irqs(domain, -1, nr_irqs, node, arg, false,
|
|
|
|
|
NULL);
|
2014-11-06 17:20:14 +03:00
|
|
|
}
|
|
|
|
|
|
2017-06-21 00:17:44 +03:00
|
|
|
extern int irq_domain_alloc_irqs_hierarchy(struct irq_domain *domain,
|
2015-11-23 11:26:04 +03:00
|
|
|
unsigned int irq_base,
|
|
|
|
|
unsigned int nr_irqs, void *arg);
|
2014-11-06 17:20:14 +03:00
|
|
|
extern int irq_domain_set_hwirq_and_chip(struct irq_domain *domain,
|
|
|
|
|
unsigned int virq,
|
|
|
|
|
irq_hw_number_t hwirq,
|
|
|
|
|
struct irq_chip *chip,
|
|
|
|
|
void *chip_data);
|
|
|
|
|
extern void irq_domain_free_irqs_common(struct irq_domain *domain,
|
|
|
|
|
unsigned int virq,
|
|
|
|
|
unsigned int nr_irqs);
|
|
|
|
|
extern void irq_domain_free_irqs_top(struct irq_domain *domain,
|
|
|
|
|
unsigned int virq, unsigned int nr_irqs);
|
|
|
|
|
|
2017-08-18 03:53:34 +03:00
|
|
|
extern int irq_domain_push_irq(struct irq_domain *domain, int virq, void *arg);
|
|
|
|
|
extern int irq_domain_pop_irq(struct irq_domain *domain, int virq);
|
|
|
|
|
|
2014-11-15 17:24:01 +03:00
|
|
|
extern int irq_domain_alloc_irqs_parent(struct irq_domain *domain,
|
|
|
|
|
unsigned int irq_base,
|
|
|
|
|
unsigned int nr_irqs, void *arg);
|
2014-11-06 17:20:14 +03:00
|
|
|
|
2014-11-15 17:24:01 +03:00
|
|
|
extern void irq_domain_free_irqs_parent(struct irq_domain *domain,
|
|
|
|
|
unsigned int irq_base,
|
|
|
|
|
unsigned int nr_irqs);
|
2014-11-06 17:20:14 +03:00
|
|
|
|
2020-10-06 12:10:20 +03:00
|
|
|
extern int irq_domain_disconnect_hierarchy(struct irq_domain *domain,
|
|
|
|
|
unsigned int virq);
|
|
|
|
|
|
2014-11-06 17:20:14 +03:00
|
|
|
static inline bool irq_domain_is_hierarchy(struct irq_domain *domain)
|
|
|
|
|
{
|
|
|
|
|
return domain->flags & IRQ_DOMAIN_FLAG_HIERARCHY;
|
|
|
|
|
}
|
2015-12-08 16:20:12 +03:00
|
|
|
|
|
|
|
|
static inline bool irq_domain_is_ipi(struct irq_domain *domain)
|
|
|
|
|
{
|
|
|
|
|
return domain->flags &
|
|
|
|
|
(IRQ_DOMAIN_FLAG_IPI_PER_CPU | IRQ_DOMAIN_FLAG_IPI_SINGLE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline bool irq_domain_is_ipi_per_cpu(struct irq_domain *domain)
|
|
|
|
|
{
|
|
|
|
|
return domain->flags & IRQ_DOMAIN_FLAG_IPI_PER_CPU;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline bool irq_domain_is_ipi_single(struct irq_domain *domain)
|
|
|
|
|
{
|
|
|
|
|
return domain->flags & IRQ_DOMAIN_FLAG_IPI_SINGLE;
|
|
|
|
|
}
|
2017-01-19 23:57:57 +03:00
|
|
|
|
|
|
|
|
static inline bool irq_domain_is_msi(struct irq_domain *domain)
|
|
|
|
|
{
|
|
|
|
|
return domain->flags & IRQ_DOMAIN_FLAG_MSI;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline bool irq_domain_is_msi_remap(struct irq_domain *domain)
|
|
|
|
|
{
|
|
|
|
|
return domain->flags & IRQ_DOMAIN_FLAG_MSI_REMAP;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern bool irq_domain_hierarchical_is_msi_remap(struct irq_domain *domain);
|
|
|
|
|
|
2014-11-06 17:20:14 +03:00
|
|
|
#else /* CONFIG_IRQ_DOMAIN_HIERARCHY */
|
|
|
|
|
static inline int irq_domain_alloc_irqs(struct irq_domain *domain,
|
|
|
|
|
unsigned int nr_irqs, int node, void *arg)
|
|
|
|
|
{
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
2016-06-07 18:12:28 +03:00
|
|
|
static inline void irq_domain_free_irqs(unsigned int virq,
|
|
|
|
|
unsigned int nr_irqs) { }
|
|
|
|
|
|
2014-11-06 17:20:14 +03:00
|
|
|
static inline bool irq_domain_is_hierarchy(struct irq_domain *domain)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2015-12-08 16:20:12 +03:00
|
|
|
|
|
|
|
|
static inline bool irq_domain_is_ipi(struct irq_domain *domain)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline bool irq_domain_is_ipi_per_cpu(struct irq_domain *domain)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline bool irq_domain_is_ipi_single(struct irq_domain *domain)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2017-01-19 23:57:57 +03:00
|
|
|
|
|
|
|
|
static inline bool irq_domain_is_msi(struct irq_domain *domain)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline bool irq_domain_is_msi_remap(struct irq_domain *domain)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
|
irq_domain_hierarchical_is_msi_remap(struct irq_domain *domain)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2014-11-06 17:20:14 +03:00
|
|
|
#endif /* CONFIG_IRQ_DOMAIN_HIERARCHY */
|
|
|
|
|
|
2012-02-24 19:24:17 +04:00
|
|
|
#else /* CONFIG_IRQ_DOMAIN */
|
|
|
|
|
static inline void irq_dispose_mapping(unsigned int virq) { }
|
2015-12-10 19:55:27 +03:00
|
|
|
static inline struct irq_domain *irq_find_matching_fwnode(
|
|
|
|
|
struct fwnode_handle *fwnode, enum irq_domain_bus_token bus_token)
|
|
|
|
|
{
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2017-03-02 18:11:47 +03:00
|
|
|
static inline bool irq_domain_check_msi_remap(void)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2012-02-24 19:24:17 +04:00
|
|
|
#endif /* !CONFIG_IRQ_DOMAIN */
|
2011-07-26 13:19:06 +04:00
|
|
|
|
2011-07-26 13:19:06 +04:00
|
|
|
#endif /* _LINUX_IRQDOMAIN_H */
|
