2018-03-15 00:15:19 +03:00
// SPDX-License-Identifier: GPL-2.0
2012-05-19 10:11:47 +04:00
# define pr_fmt(fmt) "irq: " fmt
2017-07-07 11:39:59 +03:00
# include <linux/acpi.h>
2012-02-16 12:37:49 +04:00
# include <linux/debugfs.h>
# include <linux/hardirq.h>
# include <linux/interrupt.h>
2011-07-26 13:19:06 +04:00
# include <linux/irq.h>
2012-02-16 12:37:49 +04:00
# include <linux/irqdesc.h>
2011-07-26 13:19:06 +04:00
# include <linux/irqdomain.h>
# include <linux/module.h>
# include <linux/mutex.h>
# include <linux/of.h>
2011-07-26 13:19:06 +04:00
# include <linux/of_address.h>
2014-02-27 15:40:12 +04:00
# include <linux/of_irq.h>
2012-06-04 09:04:34 +04:00
# include <linux/topology.h>
2012-02-16 12:37:49 +04:00
# include <linux/seq_file.h>
2011-07-26 13:19:06 +04:00
# include <linux/slab.h>
2012-02-16 12:37:49 +04:00
# include <linux/smp.h>
# include <linux/fs.h>
2011-07-26 13:19:06 +04:00
static LIST_HEAD ( irq_domain_list ) ;
static DEFINE_MUTEX ( irq_domain_mutex ) ;
2012-02-15 01:06:53 +04:00
static struct irq_domain * irq_default_domain ;
2012-02-16 12:37:49 +04:00
2014-11-06 17:20:14 +03:00
static void irq_domain_check_hierarchy ( struct irq_domain * domain ) ;
2015-10-13 14:51:36 +03:00
struct irqchip_fwid {
2017-06-20 02:37:05 +03:00
struct fwnode_handle fwnode ;
unsigned int type ;
char * name ;
2019-07-31 17:13:19 +03:00
phys_addr_t * pa ;
2015-10-13 14:51:36 +03:00
} ;
2017-06-20 02:37:17 +03:00
# ifdef CONFIG_GENERIC_IRQ_DEBUGFS
static void debugfs_add_domain_dir ( struct irq_domain * d ) ;
static void debugfs_remove_domain_dir ( struct irq_domain * d ) ;
# else
static inline void debugfs_add_domain_dir ( struct irq_domain * d ) { }
static inline void debugfs_remove_domain_dir ( struct irq_domain * d ) { }
# endif
2017-07-21 14:39:31 +03:00
const struct fwnode_operations irqchip_fwnode_ops ;
2017-07-26 03:19:35 +03:00
EXPORT_SYMBOL_GPL ( irqchip_fwnode_ops ) ;
2017-07-21 14:39:31 +03:00
2015-10-13 14:51:36 +03:00
/**
2020-03-03 04:48:45 +03:00
* __irq_domain_alloc_fwnode - Allocate a fwnode_handle suitable for
2015-10-13 14:51:36 +03:00
* identifying an irq domain
2017-06-20 02:37:05 +03:00
* @ type : Type of irqchip_fwnode . See linux / irqdomain . h
* @ id : Optional user provided id if name ! = NULL
2020-03-03 04:48:45 +03:00
* @ name : Optional user provided domain name
2019-10-19 12:07:27 +03:00
* @ pa : Optional user - provided physical address
2015-10-13 14:51:36 +03:00
*
2017-06-20 02:37:05 +03:00
* Allocate a struct irqchip_fwid , and return a poiner to the embedded
2015-10-13 14:51:36 +03:00
* fwnode_handle ( or NULL on failure ) .
2017-06-20 02:37:05 +03:00
*
* Note : The types IRQCHIP_FWNODE_NAMED and IRQCHIP_FWNODE_NAMED_ID are
* solely to transport name information to irqdomain creation code . The
* node is not stored . For other types the pointer is kept in the irq
* domain struct .
2015-10-13 14:51:36 +03:00
*/
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 )
2015-10-13 14:51:36 +03:00
{
struct irqchip_fwid * fwid ;
2017-06-20 02:37:05 +03:00
char * n ;
2015-10-13 14:51:36 +03:00
fwid = kzalloc ( sizeof ( * fwid ) , GFP_KERNEL ) ;
2017-06-20 02:37:05 +03:00
switch ( type ) {
case IRQCHIP_FWNODE_NAMED :
n = kasprintf ( GFP_KERNEL , " %s " , name ) ;
break ;
case IRQCHIP_FWNODE_NAMED_ID :
n = kasprintf ( GFP_KERNEL , " %s-%d " , name , id ) ;
break ;
default :
2019-07-31 17:13:19 +03:00
n = kasprintf ( GFP_KERNEL , " irqchip@%pa " , pa ) ;
2017-06-20 02:37:05 +03:00
break ;
}
if ( ! fwid | | ! n ) {
2015-10-13 14:51:36 +03:00
kfree ( fwid ) ;
2017-06-20 02:37:05 +03:00
kfree ( n ) ;
2015-10-13 14:51:36 +03:00
return NULL ;
}
2017-06-20 02:37:05 +03:00
fwid - > type = type ;
fwid - > name = n ;
2019-07-31 17:13:19 +03:00
fwid - > pa = pa ;
2017-07-21 14:39:31 +03:00
fwid - > fwnode . ops = & irqchip_fwnode_ops ;
2015-10-13 14:51:36 +03:00
return & fwid - > fwnode ;
}
2017-06-20 02:37:05 +03:00
EXPORT_SYMBOL_GPL ( __irq_domain_alloc_fwnode ) ;
2015-10-13 14:51:36 +03:00
/**
* irq_domain_free_fwnode - Free a non - OF - backed fwnode_handle
*
* Free a fwnode_handle allocated with irq_domain_alloc_fwnode .
*/
void irq_domain_free_fwnode ( struct fwnode_handle * fwnode )
{
struct irqchip_fwid * fwid ;
2015-12-10 19:55:28 +03:00
if ( WARN_ON ( ! is_fwnode_irqchip ( fwnode ) ) )
2015-10-13 14:51:36 +03:00
return ;
fwid = container_of ( fwnode , struct irqchip_fwid , fwnode ) ;
kfree ( fwid - > name ) ;
kfree ( fwid ) ;
}
2015-12-10 20:52:59 +03:00
EXPORT_SYMBOL_GPL ( irq_domain_free_fwnode ) ;
2015-10-13 14:51:36 +03:00
2012-02-16 12:37:49 +04:00
/**
2013-06-08 15:57:40 +04:00
* __irq_domain_add ( ) - Allocate a new irq_domain data structure
2016-05-31 15:56:48 +03:00
* @ fwnode : firmware node for the interrupt controller
2013-06-08 15:57:40 +04:00
* @ size : Size of linear map ; 0 for radix mapping only
2014-05-27 12:07:37 +04:00
* @ hwirq_max : Maximum number of interrupts supported by controller
2013-06-08 15:57:40 +04:00
* @ direct_max : Maximum value of direct maps ; Use ~ 0 for no limit ; 0 for no
* direct mapping
2014-11-06 17:20:14 +03:00
* @ ops : domain callbacks
2012-02-15 01:06:54 +04:00
* @ host_data : Controller private data pointer
2012-02-16 12:37:49 +04:00
*
2019-07-06 07:41:12 +03:00
* Allocates and initializes an irq_domain structure .
2014-05-27 12:07:37 +04:00
* Returns pointer to IRQ domain , or NULL on failure .
2012-02-16 12:37:49 +04:00
*/
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 )
2012-02-16 12:37:49 +04:00
{
2017-06-20 02:37:05 +03:00
struct irqchip_fwid * fwid ;
2012-02-15 01:06:54 +04:00
struct irq_domain * domain ;
2012-02-16 12:37:49 +04:00
2017-06-20 02:37:05 +03:00
static atomic_t unknown_domains ;
2012-07-11 20:24:31 +04:00
domain = kzalloc_node ( sizeof ( * domain ) + ( sizeof ( unsigned int ) * size ) ,
2020-05-20 19:49:25 +03:00
GFP_KERNEL , of_node_to_nid ( to_of_node ( fwnode ) ) ) ;
2019-05-27 14:57:42 +03:00
if ( ! domain )
2012-02-16 12:37:49 +04:00
return NULL ;
2020-07-16 11:39:05 +03:00
if ( is_fwnode_irqchip ( fwnode ) ) {
2017-06-20 02:37:05 +03:00
fwid = container_of ( fwnode , struct irqchip_fwid , fwnode ) ;
switch ( fwid - > type ) {
case IRQCHIP_FWNODE_NAMED :
case IRQCHIP_FWNODE_NAMED_ID :
irqdomain: Add the missing assignment of domain->fwnode for named fwnode
Recently device pass-through stops working for Linux VM running on Hyper-V.
git-bisect shows the regression is caused by the recent commit
467a3bb97432 ("PCI: hv: Allocate a named fwnode ..."), but the root cause
is that the commit d59f6617eef0 forgets to set the domain->fwnode for
IRQCHIP_FWNODE_NAMED*, and as a result:
1. The domain->fwnode remains to be NULL.
2. irq_find_matching_fwspec() returns NULL since "h->fwnode == fwnode" is
false, and pci_set_bus_msi_domain() sets the Hyper-V PCI root bus's
msi_domain to NULL.
3. When the device is added onto the root bus, the device's dev->msi_domain
is set to NULL in pci_set_msi_domain().
4. When a device driver tries to enable MSI-X, pci_msi_setup_msi_irqs()
calls arch_setup_msi_irqs(), which uses the native MSI chip (i.e.
arch/x86/kernel/apic/msi.c: pci_msi_controller) to set up the irqs, but
actually pci_msi_setup_msi_irqs() is supposed to call
msi_domain_alloc_irqs() with the hbus->irq_domain, which is created in
hv_pcie_init_irq_domain() and is associated with the Hyper-V chip
hv_msi_irq_chip. Consequently, the irq line is not properly set up, and
the device driver can not receive any interrupt.
Fixes: d59f6617eef0 ("genirq: Allow fwnode to carry name information only")
Fixes: 467a3bb97432 ("PCI: hv: Allocate a named fwnode instead of an address-based one")
Reported-by: Lili Deng <v-lide@microsoft.com>
Signed-off-by: Dexuan Cui <decui@microsoft.com>
Signed-off-by: Marc Zyngier <maz@kernel.org>
Link: https://lore.kernel.org/r/PU1P153MB01694D9AF625AC335C600C5FBFBE0@PU1P153MB0169.APCP153.PROD.OUTLOOK.COM
2019-09-03 02:14:56 +03:00
domain - > fwnode = fwnode ;
2017-06-20 02:37:05 +03:00
domain - > name = kstrdup ( fwid - > name , GFP_KERNEL ) ;
if ( ! domain - > name ) {
kfree ( domain ) ;
return NULL ;
}
domain - > flags | = IRQ_DOMAIN_NAME_ALLOCATED ;
break ;
default :
domain - > fwnode = fwnode ;
domain - > name = fwid - > name ;
break ;
}
2020-05-20 19:49:27 +03:00
} else if ( is_of_node ( fwnode ) | | is_acpi_device_node ( fwnode ) | |
is_software_node ( fwnode ) ) {
2017-06-20 02:37:05 +03:00
char * name ;
/*
2020-05-20 19:49:25 +03:00
* fwnode paths contain ' / ' , which debugfs is legitimately
2017-06-20 02:37:05 +03:00
* unhappy about . Replace them with ' : ' , which does
* the trick and is not as offensive as ' \ ' . . .
*/
2020-05-20 19:49:25 +03:00
name = kasprintf ( GFP_KERNEL , " %pfw " , fwnode ) ;
2017-06-20 02:37:05 +03:00
if ( ! name ) {
kfree ( domain ) ;
return NULL ;
}
strreplace ( name , ' / ' , ' : ' ) ;
domain - > name = name ;
domain - > fwnode = fwnode ;
domain - > flags | = IRQ_DOMAIN_NAME_ALLOCATED ;
}
if ( ! domain - > name ) {
2017-07-21 14:39:31 +03:00
if ( fwnode )
pr_err ( " Invalid fwnode type for irqdomain \n " ) ;
2017-06-20 02:37:05 +03:00
domain - > name = kasprintf ( GFP_KERNEL , " unknown-%d " ,
atomic_inc_return ( & unknown_domains ) ) ;
if ( ! domain - > name ) {
kfree ( domain ) ;
return NULL ;
}
domain - > flags | = IRQ_DOMAIN_NAME_ALLOCATED ;
}
2020-05-20 19:49:25 +03:00
fwnode_handle_get ( fwnode ) ;
2015-10-13 14:51:30 +03:00
2012-02-16 12:37:49 +04:00
/* Fill structure */
2013-06-08 15:03:59 +04:00
INIT_RADIX_TREE ( & domain - > revmap_tree , GFP_KERNEL ) ;
2017-10-05 04:44:54 +03:00
mutex_init ( & domain - > revmap_tree_mutex ) ;
2012-02-15 01:06:53 +04:00
domain - > ops = ops ;
2012-02-15 01:06:54 +04:00
domain - > host_data = host_data ;
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
domain - > hwirq_max = hwirq_max ;
2013-06-08 15:03:59 +04:00
domain - > revmap_size = size ;
2013-06-08 15:57:40 +04:00
domain - > revmap_direct_max_irq = direct_max ;
2014-11-06 17:20:14 +03:00
irq_domain_check_hierarchy ( domain ) ;
2012-02-16 12:37:49 +04:00
2012-02-15 01:06:54 +04:00
mutex_lock ( & irq_domain_mutex ) ;
2017-06-20 02:37:17 +03:00
debugfs_add_domain_dir ( domain ) ;
2012-02-15 01:06:54 +04:00
list_add ( & domain - > link , & irq_domain_list ) ;
mutex_unlock ( & irq_domain_mutex ) ;
2013-06-08 15:57:40 +04:00
2013-06-08 15:03:59 +04:00
pr_debug ( " Added domain %s \n " , domain - > name ) ;
2013-06-08 15:57:40 +04:00
return domain ;
2012-02-15 01:06:54 +04:00
}
2013-06-08 15:57:40 +04:00
EXPORT_SYMBOL_GPL ( __irq_domain_add ) ;
2012-02-15 01:06:54 +04:00
2012-05-19 10:11:41 +04:00
/**
* irq_domain_remove ( ) - Remove an irq domain .
* @ domain : domain to remove
*
* This routine is used to remove an irq domain . The caller must ensure
* that all mappings within the domain have been disposed of prior to
* use , depending on the revmap type .
*/
void irq_domain_remove ( struct irq_domain * domain )
{
mutex_lock ( & irq_domain_mutex ) ;
2017-06-20 02:37:17 +03:00
debugfs_remove_domain_dir ( domain ) ;
2012-05-19 10:11:41 +04:00
radix-tree: introduce radix_tree_empty
Commit e61452365372 ("radix_tree: add support for multi-order entries")
left the impression that the support for multiorder radix tree entries
was functional. As soon as Ross tried to use it, it became apparent
that my testing was completely inadequate, and it didn't even work a
little bit for orders that were not a multiple of shift.
This series of patches is the result of about 6 weeks of redesign,
reimplementation, testing, arguing and hair-pulling. The great news is
that the test-suite is now far better than it was. That's reflected in
the diffstat for the test-suite alone:
12 files changed, 436 insertions(+), 28 deletions(-)
The highlight for users of the tree is that the restriction on the order
of inserted entries being >= RADIX_TREE_MAP_SHIFT is now gone; the radix
tree now supports any order between 0 and 64.
For those who are interested in how the tree works, patch 9 is probably
the most interesting one as it introduces the new machinery for handling
sibling entries.
I've tried to be fair in attributing authorship to the person who
contributed the majority of the code in each patch; Ross has been an
invaluable partner in the development of this support and it's fair to
say that each of us has code in every commit.
I should also express my appreciation of the 0day testing. It prompted
me that I was bloating the tinyconfig in an unacceptable way, and it
bisected to a commit which contained a rather nasty memory-corruption
bug.
This patch (of 29):
The irqdomain code was checking for 0 or 1 entries, not 0 entries like
the comment said they were. Introduce a new helper that will actually
check for an empty tree.
Signed-off-by: Matthew Wilcox <willy@linux.intel.com>
Reviewed-by: Ross Zwisler <ross.zwisler@linux.intel.com>
Reviewed-by: Jan Kara <jack@suse.cz>
Cc: Konstantin Khlebnikov <koct9i@gmail.com>
Cc: Kirill Shutemov <kirill.shutemov@linux.intel.com>
Cc: Neil Brown <neilb@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-05-21 03:01:33 +03:00
WARN_ON ( ! radix_tree_empty ( & domain - > revmap_tree ) ) ;
2012-05-19 10:11:41 +04:00
list_del ( & domain - > link ) ;
/*
* If the going away domain is the default one , reset it .
*/
if ( unlikely ( irq_default_domain = = domain ) )
irq_set_default_host ( NULL ) ;
mutex_unlock ( & irq_domain_mutex ) ;
2013-06-08 15:03:59 +04:00
pr_debug ( " Removed domain %s \n " , domain - > name ) ;
2012-05-19 10:11:41 +04:00
2020-05-20 19:49:25 +03:00
fwnode_handle_put ( domain - > fwnode ) ;
2017-06-20 02:37:05 +03:00
if ( domain - > flags & IRQ_DOMAIN_NAME_ALLOCATED )
kfree ( domain - > name ) ;
2013-06-08 15:57:40 +04:00
kfree ( domain ) ;
2012-05-19 10:11:41 +04:00
}
2012-05-19 10:11:42 +04:00
EXPORT_SYMBOL_GPL ( irq_domain_remove ) ;
2012-05-19 10:11:41 +04:00
2017-06-22 13:34:57 +03:00
void irq_domain_update_bus_token ( struct irq_domain * domain ,
enum irq_domain_bus_token bus_token )
{
char * name ;
if ( domain - > bus_token = = bus_token )
return ;
mutex_lock ( & irq_domain_mutex ) ;
domain - > bus_token = bus_token ;
name = kasprintf ( GFP_KERNEL , " %s-%d " , domain - > name , bus_token ) ;
if ( ! name ) {
mutex_unlock ( & irq_domain_mutex ) ;
return ;
}
debugfs_remove_domain_dir ( domain ) ;
if ( domain - > flags & IRQ_DOMAIN_NAME_ALLOCATED )
kfree ( domain - > name ) ;
else
domain - > flags | = IRQ_DOMAIN_NAME_ALLOCATED ;
domain - > name = name ;
debugfs_add_domain_dir ( domain ) ;
mutex_unlock ( & irq_domain_mutex ) ;
}
2020-07-11 02:18:22 +03:00
EXPORT_SYMBOL_GPL ( irq_domain_update_bus_token ) ;
2017-06-22 13:34:57 +03:00
2012-07-05 15:19:19 +04:00
/**
2013-06-08 15:57:40 +04:00
* irq_domain_add_simple ( ) - Register an irq_domain and optionally map a range of irqs
2012-07-05 15:19:19 +04:00
* @ of_node : pointer to interrupt controller ' s device tree node .
* @ size : total number of irqs in mapping
2013-06-06 15:10:23 +04:00
* @ first_irq : first number of irq block assigned to the domain ,
2013-06-08 15:57:40 +04:00
* pass zero to assign irqs on - the - fly . If first_irq is non - zero , then
* pre - map all of the irqs in the domain to virqs starting at first_irq .
2014-11-06 17:20:14 +03:00
* @ ops : domain callbacks
2012-07-05 15:19:19 +04:00
* @ host_data : Controller private data pointer
*
2013-06-08 15:57:40 +04:00
* Allocates an irq_domain , and optionally if first_irq is positive then also
* allocate irq_descs and map all of the hwirqs to virqs starting at first_irq .
2012-07-05 15:19:19 +04:00
*
* This is intended to implement the expected behaviour for most
2013-06-08 15:57:40 +04:00
* interrupt controllers . If device tree is used , then first_irq will be 0 and
* irqs get mapped dynamically on the fly . However , if the controller requires
* static virq assignments ( non - DT boot ) then it will set that up correctly .
2012-07-05 15:19:19 +04:00
*/
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 )
{
2013-06-08 15:57:40 +04:00
struct irq_domain * domain ;
2015-10-13 14:51:35 +03:00
domain = __irq_domain_add ( of_node_to_fwnode ( of_node ) , size , size , 0 , ops , host_data ) ;
2013-06-08 15:57:40 +04:00
if ( ! domain )
return NULL ;
2012-09-27 16:59:39 +04:00
2013-06-08 15:57:40 +04:00
if ( first_irq > 0 ) {
2012-09-27 16:59:39 +04:00
if ( IS_ENABLED ( CONFIG_SPARSE_IRQ ) ) {
2013-06-08 15:57:40 +04:00
/* attempt to allocated irq_descs */
int rc = irq_alloc_descs ( first_irq , first_irq , size ,
of_node_to_nid ( of_node ) ) ;
if ( rc < 0 )
2012-11-27 04:20:32 +04:00
pr_info ( " Cannot allocate irq_descs @ IRQ%d, assuming pre-allocated \n " ,
first_irq ) ;
2013-06-08 15:57:40 +04:00
}
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_domain_associate_many ( domain , first_irq , 0 , size ) ;
2012-09-27 16:59:39 +04:00
}
2013-06-08 15:57:40 +04:00
return domain ;
2012-07-05 15:19:19 +04:00
}
2013-04-25 21:28:54 +04:00
EXPORT_SYMBOL_GPL ( irq_domain_add_simple ) ;
2012-07-05 15:19:19 +04:00
2012-02-15 01:06:54 +04:00
/**
* irq_domain_add_legacy ( ) - Allocate and register a legacy revmap irq_domain .
* @ of_node : pointer to interrupt controller ' s device tree node .
2012-02-15 01:06:55 +04:00
* @ size : total number of irqs in legacy mapping
* @ first_irq : first number of irq block assigned to the domain
* @ first_hwirq : first hwirq number to use for the translation . Should normally
* be ' 0 ' , but a positive integer can be used if the effective
* hwirqs numbering does not begin at zero .
2012-02-15 01:06:54 +04:00
* @ ops : map / unmap domain callbacks
* @ host_data : Controller private data pointer
*
* Note : the map ( ) callback will be called before this function returns
* for all legacy interrupts except 0 ( which is always the invalid irq for
* a legacy controller ) .
*/
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 )
{
2012-02-15 01:06:55 +04:00
struct irq_domain * domain ;
2012-02-15 01:06:54 +04:00
2015-10-13 14:51:35 +03:00
domain = __irq_domain_add ( of_node_to_fwnode ( of_node ) , first_hwirq + 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
first_hwirq + size , 0 , ops , host_data ) ;
2014-11-06 17:20:14 +03:00
if ( domain )
irq_domain_associate_many ( domain , first_irq , first_hwirq , size ) ;
2012-02-15 01:06:55 +04:00
2012-02-15 01:06:54 +04:00
return domain ;
}
2012-05-19 10:11:42 +04:00
EXPORT_SYMBOL_GPL ( irq_domain_add_legacy ) ;
2012-02-15 01:06:54 +04:00
2012-02-16 12:37:49 +04:00
/**
2016-04-11 11:57:51 +03:00
* irq_find_matching_fwspec ( ) - Locates a domain for a given fwspec
* @ fwspec : FW specifier for an interrupt
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
* @ bus_token : domain - specific data
2012-02-16 12:37:49 +04:00
*/
2016-04-11 11:57:51 +03:00
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 )
2012-02-16 12:37:49 +04:00
{
struct irq_domain * h , * found = NULL ;
2016-04-11 11:57:51 +03:00
struct fwnode_handle * fwnode = fwspec - > fwnode ;
2012-01-26 23:12:14 +04:00
int rc ;
2012-02-16 12:37:49 +04:00
/* We might want to match the legacy controller last since
* it might potentially be set to match all interrupts in
* the absence of a device node . This isn ' t a problem so far
* yet though . . .
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
*
* bus_token = = DOMAIN_BUS_ANY matches any domain , any other
* values must generate an exact match for the domain to be
* selected .
2012-02-16 12:37:49 +04:00
*/
mutex_lock ( & irq_domain_mutex ) ;
2012-01-26 23:12:14 +04:00
list_for_each_entry ( h , & irq_domain_list , link ) {
2016-04-11 11:57:51 +03:00
if ( h - > ops - > select & & fwspec - > param_count )
rc = h - > ops - > select ( h , fwspec , bus_token ) ;
else if ( h - > ops - > match )
2015-10-13 14:51:31 +03:00
rc = h - > ops - > match ( h , to_of_node ( fwnode ) , bus_token ) ;
2012-01-26 23:12:14 +04:00
else
2015-10-13 14:51:31 +03:00
rc = ( ( fwnode ! = NULL ) & & ( h - > fwnode = = 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
( ( bus_token = = DOMAIN_BUS_ANY ) | |
( h - > bus_token = = bus_token ) ) ) ;
2012-01-26 23:12:14 +04:00
if ( rc ) {
2012-02-16 12:37:49 +04:00
found = h ;
break ;
}
2012-01-26 23:12:14 +04:00
}
2012-02-16 12:37:49 +04:00
mutex_unlock ( & irq_domain_mutex ) ;
return found ;
}
2016-04-11 11:57:51 +03:00
EXPORT_SYMBOL_GPL ( irq_find_matching_fwspec ) ;
2012-02-16 12:37:49 +04:00
2017-01-19 23:57:59 +03:00
/**
* irq_domain_check_msi_remap - Check whether all MSI irq domains implement
* IRQ remapping
*
* Return : false if any MSI irq domain does not support IRQ remapping ,
* true otherwise ( including if there is no MSI irq domain )
*/
bool irq_domain_check_msi_remap ( void )
{
struct irq_domain * h ;
bool ret = true ;
mutex_lock ( & irq_domain_mutex ) ;
list_for_each_entry ( h , & irq_domain_list , link ) {
if ( irq_domain_is_msi ( h ) & &
! irq_domain_hierarchical_is_msi_remap ( h ) ) {
ret = false ;
break ;
}
}
mutex_unlock ( & irq_domain_mutex ) ;
return ret ;
}
EXPORT_SYMBOL_GPL ( irq_domain_check_msi_remap ) ;
2012-02-16 12:37:49 +04:00
/**
* irq_set_default_host ( ) - Set a " default " irq domain
2012-02-15 01:06:53 +04:00
* @ domain : default domain pointer
2012-02-16 12:37:49 +04:00
*
* For convenience , it ' s possible to set a " default " domain that will be used
* whenever NULL is passed to irq_create_mapping ( ) . It makes life easier for
* platforms that want to manipulate a few hard coded interrupt numbers that
* aren ' t properly represented in the device - tree .
*/
2012-02-15 01:06:53 +04:00
void irq_set_default_host ( struct irq_domain * domain )
2012-02-16 12:37:49 +04:00
{
2012-05-19 10:11:47 +04:00
pr_debug ( " Default domain set to @0x%p \n " , domain ) ;
2012-02-16 12:37:49 +04:00
2012-02-15 01:06:53 +04:00
irq_default_domain = domain ;
2012-02-16 12:37:49 +04:00
}
2012-05-19 10:11:42 +04:00
EXPORT_SYMBOL_GPL ( irq_set_default_host ) ;
2012-02-16 12:37:49 +04:00
2019-02-20 11:59:23 +03:00
/**
* irq_get_default_host ( ) - Retrieve the " default " irq domain
*
* Returns : the default domain , if any .
*
* Modern code should never use this . This should only be used on
* systems that cannot implement a firmware - > fwnode mapping ( which
* both DT and ACPI provide ) .
*/
struct irq_domain * irq_get_default_host ( void )
{
return irq_default_domain ;
}
2017-08-18 03:53:32 +03:00
static void irq_domain_clear_mapping ( struct irq_domain * domain ,
irq_hw_number_t hwirq )
{
if ( hwirq < domain - > revmap_size ) {
domain - > linear_revmap [ hwirq ] = 0 ;
} else {
2017-10-05 04:44:54 +03:00
mutex_lock ( & domain - > revmap_tree_mutex ) ;
2017-08-18 03:53:32 +03:00
radix_tree_delete ( & domain - > revmap_tree , hwirq ) ;
2017-10-05 04:44:54 +03:00
mutex_unlock ( & domain - > revmap_tree_mutex ) ;
2017-08-18 03:53:32 +03:00
}
}
static void irq_domain_set_mapping ( struct irq_domain * domain ,
irq_hw_number_t hwirq ,
struct irq_data * irq_data )
{
if ( hwirq < domain - > revmap_size ) {
domain - > linear_revmap [ hwirq ] = irq_data - > irq ;
} else {
2017-10-05 04:44:54 +03:00
mutex_lock ( & domain - > revmap_tree_mutex ) ;
2017-08-18 03:53:32 +03:00
radix_tree_insert ( & domain - > revmap_tree , hwirq , irq_data ) ;
2017-10-05 04:44:54 +03:00
mutex_unlock ( & domain - > revmap_tree_mutex ) ;
2017-08-18 03:53:32 +03:00
}
}
2014-06-09 12:20:05 +04:00
void irq_domain_disassociate ( struct irq_domain * domain , unsigned int irq )
2012-06-04 09:04:35 +04:00
{
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
struct irq_data * irq_data = irq_get_irq_data ( irq ) ;
irq_hw_number_t hwirq ;
2012-06-04 09:04:35 +04:00
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
if ( WARN ( ! irq_data | | irq_data - > domain ! = domain ,
" virq%i doesn't exist; cannot disassociate \n " , irq ) )
return ;
2012-06-04 09:04:35 +04:00
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
hwirq = irq_data - > hwirq ;
irq_set_status_flags ( irq , IRQ_NOREQUEST ) ;
2012-06-04 09:04:35 +04:00
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
/* remove chip and handler */
irq_set_chip_and_handler ( irq , NULL , NULL ) ;
2012-06-04 09:04:35 +04:00
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
/* Make sure it's completed */
synchronize_irq ( irq ) ;
2012-06-04 09:04:35 +04:00
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
/* Tell the PIC about it */
if ( domain - > ops - > unmap )
domain - > ops - > unmap ( domain , irq ) ;
smp_mb ( ) ;
2012-06-04 09:04:35 +04:00
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_data - > domain = NULL ;
irq_data - > hwirq = 0 ;
2017-06-20 02:37:16 +03:00
domain - > mapcount - - ;
2012-06-04 09:04:35 +04:00
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
/* Clear reverse map for this hwirq */
2017-08-18 03:53:32 +03:00
irq_domain_clear_mapping ( domain , hwirq ) ;
2012-06-04 09:04:35 +04:00
}
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
int irq_domain_associate ( struct irq_domain * domain , unsigned int virq ,
irq_hw_number_t hwirq )
2012-02-16 12:37:49 +04:00
{
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
struct irq_data * irq_data = irq_get_irq_data ( virq ) ;
int ret ;
2012-02-16 12:37:49 +04:00
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
if ( WARN ( hwirq > = domain - > hwirq_max ,
" error: hwirq 0x%x is too large for %s \n " , ( int ) hwirq , domain - > name ) )
return - EINVAL ;
if ( WARN ( ! irq_data , " error: virq%i is not allocated " , virq ) )
return - EINVAL ;
if ( WARN ( irq_data - > domain , " error: virq%i is already associated " , virq ) )
return - EINVAL ;
2012-02-16 12:37:49 +04:00
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
mutex_lock ( & irq_domain_mutex ) ;
irq_data - > hwirq = hwirq ;
irq_data - > domain = domain ;
if ( domain - > ops - > map ) {
ret = domain - > ops - > map ( domain , virq , hwirq ) ;
if ( ret ! = 0 ) {
/*
* If map ( ) returns - EPERM , this interrupt is protected
* by the firmware or some other service and shall not
* be mapped . Don ' t bother telling the user about it .
*/
if ( ret ! = - EPERM ) {
pr_info ( " %s didn't like hwirq-0x%lx to VIRQ%i mapping (rc=%d) \n " ,
domain - > name , hwirq , virq , ret ) ;
2012-07-20 13:33:19 +04:00
}
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_data - > domain = NULL ;
irq_data - > hwirq = 0 ;
mutex_unlock ( & irq_domain_mutex ) ;
return ret ;
2012-06-18 02:17:04 +04:00
}
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
/* If not already assigned, give the domain the chip's name */
if ( ! domain - > name & & irq_data - > chip )
domain - > name = irq_data - > chip - > name ;
}
2012-06-04 09:04:36 +04:00
2017-06-20 02:37:16 +03:00
domain - > mapcount + + ;
2017-08-18 03:53:32 +03:00
irq_domain_set_mapping ( domain , hwirq , irq_data ) ;
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
mutex_unlock ( & irq_domain_mutex ) ;
irq_clear_status_flags ( virq , IRQ_NOREQUEST ) ;
2012-02-16 12:37:49 +04:00
return 0 ;
}
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
EXPORT_SYMBOL_GPL ( irq_domain_associate ) ;
2012-06-18 02:17:04 +04:00
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
void irq_domain_associate_many ( struct irq_domain * domain , unsigned int irq_base ,
irq_hw_number_t hwirq_base , int count )
{
2015-10-13 14:51:29 +03:00
struct device_node * of_node ;
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
int i ;
2015-10-13 14:51:29 +03:00
of_node = irq_domain_get_of_node ( 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
pr_debug ( " %s(%s, irqbase=%i, hwbase=%i, count=%i) \n " , __func__ ,
2015-10-13 14:51:29 +03:00
of_node_full_name ( of_node ) , irq_base , ( int ) hwirq_base , count ) ;
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
for ( i = 0 ; i < count ; i + + ) {
irq_domain_associate ( domain , irq_base + i , hwirq_base + i ) ;
}
2012-02-16 12:37:49 +04:00
}
2012-06-18 02:17:04 +04:00
EXPORT_SYMBOL_GPL ( irq_domain_associate_many ) ;
2012-02-16 12:37:49 +04:00
/**
* irq_create_direct_mapping ( ) - Allocate an irq for direct mapping
2012-02-15 01:06:53 +04:00
* @ domain : domain to allocate the irq for or NULL for default domain
2012-02-16 12:37:49 +04:00
*
* This routine is used for irq controllers which can choose the hardware
* interrupt numbers they generate . In such a case it ' s simplest to use
2013-06-08 15:03:59 +04:00
* the linux irq as the hardware interrupt number . It still uses the linear
* or radix tree to store the mapping , but the irq controller can optimize
* the revmap path by using the hwirq directly .
2012-02-16 12:37:49 +04:00
*/
2012-02-15 01:06:53 +04:00
unsigned int irq_create_direct_mapping ( struct irq_domain * domain )
2012-02-16 12:37:49 +04:00
{
2015-10-13 14:51:29 +03:00
struct device_node * of_node ;
2012-02-16 12:37:49 +04:00
unsigned int virq ;
2012-02-15 01:06:53 +04:00
if ( domain = = NULL )
domain = irq_default_domain ;
2012-02-16 12:37:49 +04:00
2015-10-13 14:51:29 +03:00
of_node = irq_domain_get_of_node ( domain ) ;
virq = irq_alloc_desc_from ( 1 , of_node_to_nid ( of_node ) ) ;
2012-02-15 01:06:52 +04:00
if ( ! virq ) {
2012-05-19 10:11:47 +04:00
pr_debug ( " create_direct virq allocation failed \n " ) ;
2012-02-15 01:06:52 +04:00
return 0 ;
2012-02-16 12:37:49 +04:00
}
2013-06-08 15:03:59 +04:00
if ( virq > = domain - > revmap_direct_max_irq ) {
2012-02-16 12:37:49 +04:00
pr_err ( " ERROR: no free irqs available below %i maximum \n " ,
2013-06-08 15:03:59 +04:00
domain - > revmap_direct_max_irq ) ;
2012-02-16 12:37:49 +04:00
irq_free_desc ( virq ) ;
return 0 ;
}
2012-05-19 10:11:47 +04:00
pr_debug ( " create_direct obtained virq %d \n " , virq ) ;
2012-02-16 12:37:49 +04:00
2012-06-18 02:17:04 +04:00
if ( irq_domain_associate ( domain , virq , virq ) ) {
2012-02-16 12:37:49 +04:00
irq_free_desc ( virq ) ;
2012-02-15 01:06:52 +04:00
return 0 ;
2012-02-16 12:37:49 +04:00
}
return virq ;
}
2012-05-19 10:11:42 +04:00
EXPORT_SYMBOL_GPL ( irq_create_direct_mapping ) ;
2012-02-16 12:37:49 +04:00
/**
* irq_create_mapping ( ) - Map a hardware interrupt into linux irq space
2012-02-15 01:06:53 +04:00
* @ domain : domain owning this hardware interrupt or NULL for default domain
* @ hwirq : hardware irq number in that domain space
2012-02-16 12:37:49 +04:00
*
* Only one mapping per hardware interrupt is permitted . Returns a linux
* irq number .
* If the sense / trigger is to be specified , set_irq_type ( ) should be called
* on the number returned from that call .
*/
2012-02-15 01:06:53 +04:00
unsigned int irq_create_mapping ( struct irq_domain * domain ,
2012-02-16 12:37:49 +04:00
irq_hw_number_t hwirq )
{
2015-10-13 14:51:29 +03:00
struct device_node * of_node ;
2012-04-06 03:52:13 +04:00
int virq ;
2012-02-16 12:37:49 +04:00
2012-05-19 10:11:47 +04:00
pr_debug ( " irq_create_mapping(0x%p, 0x%lx) \n " , domain , hwirq ) ;
2012-02-16 12:37:49 +04:00
2012-02-15 01:06:53 +04:00
/* Look for default domain if nececssary */
if ( domain = = NULL )
domain = irq_default_domain ;
if ( domain = = NULL ) {
2013-06-06 15:20:27 +04:00
WARN ( 1 , " %s(, %lx) called with NULL domain \n " , __func__ , hwirq ) ;
2012-02-15 01:06:52 +04:00
return 0 ;
2012-02-16 12:37:49 +04:00
}
2012-05-19 10:11:47 +04:00
pr_debug ( " -> using domain @%p \n " , domain ) ;
2012-02-16 12:37:49 +04:00
2015-10-13 14:51:29 +03:00
of_node = irq_domain_get_of_node ( domain ) ;
2012-02-16 12:37:49 +04:00
/* Check if mapping already exists */
2012-02-15 01:06:53 +04:00
virq = irq_find_mapping ( domain , hwirq ) ;
2012-02-15 01:06:52 +04:00
if ( virq ) {
2012-05-19 10:11:47 +04:00
pr_debug ( " -> existing mapping on virq %d \n " , virq ) ;
2012-02-16 12:37:49 +04:00
return virq ;
}
2012-02-15 01:06:55 +04:00
/* Allocate a virtual interrupt number */
2016-07-04 11:39:24 +03:00
virq = irq_domain_alloc_descs ( - 1 , 1 , hwirq , of_node_to_nid ( of_node ) , NULL ) ;
2012-04-06 03:52:13 +04:00
if ( virq < = 0 ) {
2012-05-19 10:11:47 +04:00
pr_debug ( " -> virq allocation failed \n " ) ;
2012-02-15 01:06:55 +04:00
return 0 ;
2012-02-16 12:37:49 +04:00
}
2012-06-18 02:17:04 +04:00
if ( irq_domain_associate ( domain , virq , hwirq ) ) {
2012-06-04 09:04:35 +04:00
irq_free_desc ( virq ) ;
2012-02-15 01:06:52 +04:00
return 0 ;
2012-02-16 12:37:49 +04:00
}
2012-05-19 10:11:47 +04:00
pr_debug ( " irq %lu on domain %s mapped to virtual irq %u \n " ,
2015-10-13 14:51:29 +03:00
hwirq , of_node_full_name ( of_node ) , virq ) ;
2012-02-16 12:37:49 +04:00
return virq ;
}
EXPORT_SYMBOL_GPL ( irq_create_mapping ) ;
2012-06-18 02:17:04 +04:00
/**
* irq_create_strict_mappings ( ) - Map a range of hw irqs to fixed linux irqs
* @ domain : domain owning the interrupt range
* @ irq_base : beginning of linux IRQ range
* @ hwirq_base : beginning of hardware IRQ range
* @ count : Number of interrupts to map
*
* This routine is used for allocating and mapping a range of hardware
* irqs to linux irqs where the linux irq numbers are at pre - defined
* locations . For use by controllers that already have static mappings
* to insert in to the domain .
*
* Non - linear users can use irq_create_identity_mapping ( ) for IRQ - at - a - time
* domain insertion .
*
* 0 is returned upon success , while any failure to establish a static
* mapping is treated as an error .
*/
int irq_create_strict_mappings ( struct irq_domain * domain , unsigned int irq_base ,
irq_hw_number_t hwirq_base , int count )
{
2015-10-13 14:51:29 +03:00
struct device_node * of_node ;
2012-06-18 02:17:04 +04:00
int ret ;
2015-10-13 14:51:29 +03:00
of_node = irq_domain_get_of_node ( domain ) ;
2012-06-18 02:17:04 +04:00
ret = irq_alloc_descs ( irq_base , irq_base , count ,
2015-10-13 14:51:29 +03:00
of_node_to_nid ( of_node ) ) ;
2012-06-18 02:17:04 +04:00
if ( unlikely ( ret < 0 ) )
return ret ;
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_domain_associate_many ( domain , irq_base , hwirq_base , count ) ;
2012-06-18 02:17:04 +04:00
return 0 ;
}
EXPORT_SYMBOL_GPL ( irq_create_strict_mappings ) ;
2015-10-13 14:51:32 +03:00
static int irq_domain_translate ( struct irq_domain * d ,
struct irq_fwspec * fwspec ,
irq_hw_number_t * hwirq , unsigned int * type )
{
# ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
if ( d - > ops - > translate )
return d - > ops - > translate ( d , fwspec , hwirq , type ) ;
# endif
if ( d - > ops - > xlate )
return d - > ops - > xlate ( d , to_of_node ( fwspec - > fwnode ) ,
fwspec - > param , fwspec - > param_count ,
hwirq , type ) ;
/* If domain has no translation, then we assume interrupt line */
* hwirq = fwspec - > param [ 0 ] ;
return 0 ;
}
2019-02-08 05:16:22 +03:00
static void of_phandle_args_to_fwspec ( struct device_node * np , const u32 * args ,
unsigned int count ,
2015-10-13 14:51:32 +03:00
struct irq_fwspec * fwspec )
{
int i ;
2019-02-08 05:16:22 +03:00
fwspec - > fwnode = np ? & np - > fwnode : NULL ;
fwspec - > param_count = count ;
2015-10-13 14:51:32 +03:00
2019-02-08 05:16:22 +03:00
for ( i = 0 ; i < count ; i + + )
fwspec - > param [ i ] = args [ i ] ;
2015-10-13 14:51:32 +03:00
}
2015-10-13 14:51:34 +03:00
unsigned int irq_create_fwspec_mapping ( struct irq_fwspec * fwspec )
2012-02-16 12:37:49 +04:00
{
2012-02-15 01:06:53 +04:00
struct irq_domain * domain ;
2016-06-07 18:12:28 +03:00
struct irq_data * irq_data ;
2012-02-16 12:37:49 +04:00
irq_hw_number_t hwirq ;
unsigned int type = IRQ_TYPE_NONE ;
2014-11-06 17:20:14 +03:00
int virq ;
2012-02-16 12:37:49 +04:00
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
if ( fwspec - > fwnode ) {
2016-04-11 11:57:51 +03:00
domain = irq_find_matching_fwspec ( fwspec , DOMAIN_BUS_WIRED ) ;
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
if ( ! domain )
2016-04-11 11:57:51 +03:00
domain = irq_find_matching_fwspec ( fwspec , DOMAIN_BUS_ANY ) ;
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
} else {
2015-10-13 14:51:32 +03:00
domain = irq_default_domain ;
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
}
2015-10-13 14:51:32 +03:00
2012-02-15 01:06:53 +04:00
if ( ! domain ) {
2013-06-06 15:20:27 +04:00
pr_warn ( " no irq domain found for %s ! \n " ,
2015-10-13 14:51:34 +03:00
of_node_full_name ( to_of_node ( fwspec - > fwnode ) ) ) ;
2012-02-15 01:06:52 +04:00
return 0 ;
2012-02-16 12:37:49 +04:00
}
2015-10-13 14:51:34 +03:00
if ( irq_domain_translate ( domain , fwspec , & hwirq , & type ) )
2015-10-13 14:51:32 +03:00
return 0 ;
2012-02-16 12:37:49 +04:00
2016-06-07 18:12:26 +03:00
/*
* WARN if the irqchip returns a type with bits
* outside the sense mask set and clear these bits .
*/
if ( WARN_ON ( type & ~ IRQ_TYPE_SENSE_MASK ) )
type & = IRQ_TYPE_SENSE_MASK ;
/*
* If we ' ve already configured this interrupt ,
* don ' t do it again , or hell will break loose .
*/
virq = irq_find_mapping ( domain , hwirq ) ;
if ( virq ) {
2014-11-06 17:20:15 +03:00
/*
2016-06-07 18:12:26 +03:00
* If the trigger type is not specified or matches the
* current trigger type then we are done so return the
* interrupt number .
2014-11-06 17:20:15 +03:00
*/
2016-06-07 18:12:26 +03:00
if ( type = = IRQ_TYPE_NONE | | type = = irq_get_trigger_type ( virq ) )
2014-11-06 17:20:15 +03:00
return virq ;
2016-06-07 18:12:26 +03:00
/*
* If the trigger type has not been set yet , then set
* it now and return the interrupt number .
*/
if ( irq_get_trigger_type ( virq ) = = IRQ_TYPE_NONE ) {
2016-06-07 18:12:28 +03:00
irq_data = irq_get_irq_data ( virq ) ;
if ( ! irq_data )
return 0 ;
irqd_set_trigger_type ( irq_data , type ) ;
2016-06-07 18:12:26 +03:00
return virq ;
}
pr_warn ( " type mismatch, failed to map hwirq-%lu for %s! \n " ,
hwirq , of_node_full_name ( to_of_node ( fwspec - > fwnode ) ) ) ;
return 0 ;
}
if ( irq_domain_is_hierarchy ( domain ) ) {
2015-10-13 14:51:34 +03:00
virq = irq_domain_alloc_irqs ( domain , 1 , NUMA_NO_NODE , fwspec ) ;
2014-11-06 17:20:15 +03:00
if ( virq < = 0 )
return 0 ;
} else {
/* Create mapping */
virq = irq_create_mapping ( domain , hwirq ) ;
if ( ! virq )
return virq ;
}
2012-02-16 12:37:49 +04:00
2016-06-07 18:12:28 +03:00
irq_data = irq_get_irq_data ( virq ) ;
if ( ! irq_data ) {
if ( irq_domain_is_hierarchy ( domain ) )
irq_domain_free_irqs ( virq , 1 ) ;
else
irq_dispose_mapping ( virq ) ;
return 0 ;
}
/* Store trigger type */
irqd_set_trigger_type ( irq_data , type ) ;
2012-02-16 12:37:49 +04:00
return virq ;
}
2015-10-13 14:51:34 +03:00
EXPORT_SYMBOL_GPL ( irq_create_fwspec_mapping ) ;
unsigned int irq_create_of_mapping ( struct of_phandle_args * irq_data )
{
struct irq_fwspec fwspec ;
2019-02-08 05:16:22 +03:00
of_phandle_args_to_fwspec ( irq_data - > np , irq_data - > args ,
irq_data - > args_count , & fwspec ) ;
2015-10-13 14:51:34 +03:00
return irq_create_fwspec_mapping ( & fwspec ) ;
}
2012-02-16 12:37:49 +04:00
EXPORT_SYMBOL_GPL ( irq_create_of_mapping ) ;
/**
* irq_dispose_mapping ( ) - Unmap an interrupt
* @ virq : linux irq number of the interrupt to unmap
*/
void irq_dispose_mapping ( unsigned int virq )
{
struct irq_data * irq_data = irq_get_irq_data ( virq ) ;
2012-02-15 01:06:53 +04:00
struct irq_domain * domain ;
2012-02-16 12:37:49 +04:00
2012-02-15 01:06:52 +04:00
if ( ! virq | | ! irq_data )
2012-02-16 12:37:49 +04:00
return ;
2012-02-15 01:06:53 +04:00
domain = irq_data - > domain ;
if ( WARN_ON ( domain = = NULL ) )
2012-02-16 12:37:49 +04:00
return ;
2016-06-21 12:23:22 +03:00
if ( irq_domain_is_hierarchy ( domain ) ) {
irq_domain_free_irqs ( virq , 1 ) ;
} else {
irq_domain_disassociate ( domain , virq ) ;
irq_free_desc ( virq ) ;
}
2012-02-16 12:37:49 +04:00
}
EXPORT_SYMBOL_GPL ( irq_dispose_mapping ) ;
/**
2018-10-08 14:17:26 +03:00
* irq_find_mapping ( ) - Find a linux irq from a hw irq number .
2012-02-15 01:06:53 +04:00
* @ domain : domain owning this hardware interrupt
* @ hwirq : hardware irq number in that domain space
2012-02-16 12:37:49 +04:00
*/
2012-02-15 01:06:53 +04:00
unsigned int irq_find_mapping ( struct irq_domain * domain ,
2012-02-16 12:37:49 +04:00
irq_hw_number_t hwirq )
{
2012-06-04 09:04:39 +04:00
struct irq_data * data ;
2012-02-16 12:37:49 +04:00
2012-02-15 01:06:53 +04:00
/* Look for default domain if nececssary */
if ( domain = = NULL )
domain = irq_default_domain ;
if ( domain = = NULL )
2012-02-15 01:06:52 +04:00
return 0 ;
2012-02-16 12:37:49 +04:00
2013-06-08 15:03:59 +04:00
if ( hwirq < domain - > revmap_direct_max_irq ) {
2014-11-06 17:20:14 +03:00
data = irq_domain_get_irq_data ( domain , hwirq ) ;
if ( data & & data - > hwirq = = hwirq )
2012-06-04 09:04:39 +04:00
return hwirq ;
}
2013-06-10 15:19:17 +04:00
/* Check if the hwirq is in the linear revmap. */
if ( hwirq < domain - > revmap_size )
return domain - > linear_revmap [ hwirq ] ;
2012-02-16 12:37:49 +04:00
2013-06-10 15:19:17 +04:00
rcu_read_lock ( ) ;
data = radix_tree_lookup ( & domain - > revmap_tree , hwirq ) ;
rcu_read_unlock ( ) ;
return data ? data - > irq : 0 ;
2012-02-16 12:37:49 +04:00
}
EXPORT_SYMBOL_GPL ( irq_find_mapping ) ;
2012-01-26 22:26:52 +04:00
/**
* irq_domain_xlate_onecell ( ) - Generic xlate for direct one cell bindings
*
* Device Tree IRQ specifier translation function which works with one cell
* bindings where the cell value maps directly to the hwirq number .
*/
int irq_domain_xlate_onecell ( struct irq_domain * d , struct device_node * ctrlr ,
const u32 * intspec , unsigned int intsize ,
unsigned long * out_hwirq , unsigned int * out_type )
2011-07-26 13:19:06 +04:00
{
2012-01-26 22:26:52 +04:00
if ( WARN_ON ( intsize < 1 ) )
2011-07-26 13:19:06 +04:00
return - EINVAL ;
* out_hwirq = intspec [ 0 ] ;
* out_type = IRQ_TYPE_NONE ;
return 0 ;
}
2012-01-26 22:26:52 +04:00
EXPORT_SYMBOL_GPL ( irq_domain_xlate_onecell ) ;
/**
* irq_domain_xlate_twocell ( ) - Generic xlate for direct two cell bindings
*
* Device Tree IRQ specifier translation function which works with two cell
* bindings where the cell values map directly to the hwirq number
* and linux irq flags .
*/
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 )
{
2019-02-08 05:16:22 +03:00
struct irq_fwspec fwspec ;
of_phandle_args_to_fwspec ( ctrlr , intspec , intsize , & fwspec ) ;
return irq_domain_translate_twocell ( d , & fwspec , out_hwirq , out_type ) ;
2012-01-26 22:26:52 +04:00
}
EXPORT_SYMBOL_GPL ( irq_domain_xlate_twocell ) ;
/**
* irq_domain_xlate_onetwocell ( ) - Generic xlate for one or two cell bindings
*
* Device Tree IRQ specifier translation function which works with either one
* or two cell bindings where the cell values map directly to the hwirq number
* and linux irq flags .
*
* Note : don ' t use this function unless your interrupt controller explicitly
* supports both one and two cell bindings . For the majority of controllers
* the _onecell ( ) or _twocell ( ) variants above should be used .
*/
int irq_domain_xlate_onetwocell ( struct irq_domain * d ,
struct device_node * ctrlr ,
const u32 * intspec , unsigned int intsize ,
unsigned long * out_hwirq , unsigned int * out_type )
{
if ( WARN_ON ( intsize < 1 ) )
return - EINVAL ;
* out_hwirq = intspec [ 0 ] ;
2016-08-02 11:52:45 +03:00
if ( intsize > 1 )
* out_type = intspec [ 1 ] & IRQ_TYPE_SENSE_MASK ;
else
* out_type = IRQ_TYPE_NONE ;
2012-01-26 22:26:52 +04:00
return 0 ;
}
EXPORT_SYMBOL_GPL ( irq_domain_xlate_onetwocell ) ;
2011-07-26 13:19:06 +04:00
2012-01-26 23:12:14 +04:00
const struct irq_domain_ops irq_domain_simple_ops = {
2012-01-26 22:26:52 +04:00
. xlate = irq_domain_xlate_onetwocell ,
2012-02-15 01:06:57 +04:00
} ;
EXPORT_SYMBOL_GPL ( irq_domain_simple_ops ) ;
2014-11-06 17:20:14 +03:00
2019-12-10 14:11:09 +03:00
/**
* irq_domain_translate_onecell ( ) - Generic translate for direct one cell
* bindings
*/
int irq_domain_translate_onecell ( struct irq_domain * d ,
struct irq_fwspec * fwspec ,
unsigned long * out_hwirq ,
unsigned int * out_type )
{
if ( WARN_ON ( fwspec - > param_count < 1 ) )
return - EINVAL ;
* out_hwirq = fwspec - > param [ 0 ] ;
* out_type = IRQ_TYPE_NONE ;
return 0 ;
}
EXPORT_SYMBOL_GPL ( irq_domain_translate_onecell ) ;
2019-02-08 05:16:22 +03:00
/**
* irq_domain_translate_twocell ( ) - Generic translate for direct two cell
* bindings
*
* Device Tree IRQ specifier translation function which works with two cell
* bindings where the cell values map directly to the hwirq number
* and linux irq flags .
*/
int irq_domain_translate_twocell ( struct irq_domain * d ,
struct irq_fwspec * fwspec ,
unsigned long * out_hwirq ,
unsigned int * out_type )
{
if ( WARN_ON ( fwspec - > param_count < 2 ) )
return - EINVAL ;
* out_hwirq = fwspec - > param [ 0 ] ;
* out_type = fwspec - > param [ 1 ] & IRQ_TYPE_SENSE_MASK ;
return 0 ;
}
EXPORT_SYMBOL_GPL ( irq_domain_translate_twocell ) ;
2015-12-08 16:20:18 +03:00
int irq_domain_alloc_descs ( int virq , unsigned int cnt , irq_hw_number_t hwirq ,
2018-12-04 18:51:20 +03:00
int node , const struct irq_affinity_desc * affinity )
2014-11-06 17:20:14 +03:00
{
unsigned int hint ;
if ( virq > = 0 ) {
2016-07-04 11:39:24 +03:00
virq = __irq_alloc_descs ( virq , virq , cnt , node , THIS_MODULE ,
affinity ) ;
2014-11-06 17:20:14 +03:00
} else {
hint = hwirq % nr_irqs ;
if ( hint = = 0 )
hint + + ;
2016-07-04 11:39:24 +03:00
virq = __irq_alloc_descs ( - 1 , hint , cnt , node , THIS_MODULE ,
affinity ) ;
if ( virq < = 0 & & hint > 1 ) {
virq = __irq_alloc_descs ( - 1 , 1 , cnt , node , THIS_MODULE ,
affinity ) ;
}
2014-11-06 17:20:14 +03:00
}
return virq ;
}
2020-05-14 11:39:00 +03:00
/**
* irq_domain_reset_irq_data - Clear hwirq , chip and chip_data in @ irq_data
* @ irq_data : The pointer to irq_data
*/
void irq_domain_reset_irq_data ( struct irq_data * irq_data )
{
irq_data - > hwirq = 0 ;
irq_data - > chip = & no_irq_chip ;
irq_data - > chip_data = NULL ;
}
EXPORT_SYMBOL_GPL ( irq_domain_reset_irq_data ) ;
2014-11-06 17:20:14 +03:00
# ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
2014-11-15 17:24:02 +03:00
/**
2015-10-13 14:51:43 +03:00
* irq_domain_create_hierarchy - Add a irqdomain into the hierarchy
2014-11-15 17:24:02 +03:00
* @ parent : Parent irq domain to associate with the new domain
* @ flags : Irq domain flags associated to the domain
* @ size : Size of the domain . See below
2015-10-13 14:51:43 +03:00
* @ fwnode : Optional fwnode of the interrupt controller
2014-11-15 17:24:02 +03:00
* @ ops : Pointer to the interrupt domain callbacks
* @ host_data : Controller private data pointer
*
* If @ size is 0 a tree domain is created , otherwise a linear domain .
*
* If successful the parent is associated to the new domain and the
* domain flags are set .
* Returns pointer to IRQ domain , or NULL on failure .
*/
2015-10-13 14:51:43 +03:00
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 )
{
struct irq_domain * domain ;
if ( size )
2015-10-13 14:51:43 +03:00
domain = irq_domain_create_linear ( fwnode , size , ops , host_data ) ;
2014-11-15 17:24:02 +03:00
else
2015-10-13 14:51:43 +03:00
domain = irq_domain_create_tree ( fwnode , ops , host_data ) ;
2014-11-15 17:24:02 +03:00
if ( domain ) {
domain - > parent = parent ;
domain - > flags | = flags ;
}
return domain ;
}
2016-03-03 17:56:52 +03:00
EXPORT_SYMBOL_GPL ( irq_domain_create_hierarchy ) ;
2014-11-15 17:24:02 +03:00
2014-11-06 17:20:14 +03:00
static void irq_domain_insert_irq ( int virq )
{
struct irq_data * data ;
for ( data = irq_get_irq_data ( virq ) ; data ; data = data - > parent_data ) {
struct irq_domain * domain = data - > domain ;
2017-06-20 02:37:16 +03:00
domain - > mapcount + + ;
2017-08-18 03:53:32 +03:00
irq_domain_set_mapping ( domain , data - > hwirq , data ) ;
2014-11-06 17:20:14 +03:00
/* If not already assigned, give the domain the chip's name */
if ( ! domain - > name & & data - > chip )
domain - > name = data - > chip - > name ;
}
irq_clear_status_flags ( virq , IRQ_NOREQUEST ) ;
}
static void irq_domain_remove_irq ( int virq )
{
struct irq_data * data ;
irq_set_status_flags ( virq , IRQ_NOREQUEST ) ;
irq_set_chip_and_handler ( virq , NULL , NULL ) ;
synchronize_irq ( virq ) ;
smp_mb ( ) ;
for ( data = irq_get_irq_data ( virq ) ; data ; data = data - > parent_data ) {
struct irq_domain * domain = data - > domain ;
irq_hw_number_t hwirq = data - > hwirq ;
2017-06-20 02:37:16 +03:00
domain - > mapcount - - ;
2017-08-18 03:53:32 +03:00
irq_domain_clear_mapping ( domain , hwirq ) ;
2014-11-06 17:20:14 +03:00
}
}
static struct irq_data * irq_domain_insert_irq_data ( struct irq_domain * domain ,
struct irq_data * child )
{
struct irq_data * irq_data ;
2015-06-01 11:05:13 +03:00
irq_data = kzalloc_node ( sizeof ( * irq_data ) , GFP_KERNEL ,
irq_data_get_node ( child ) ) ;
2014-11-06 17:20:14 +03:00
if ( irq_data ) {
child - > parent_data = irq_data ;
irq_data - > irq = child - > irq ;
2015-06-01 11:05:12 +03:00
irq_data - > common = child - > common ;
2014-11-06 17:20:14 +03:00
irq_data - > domain = domain ;
}
return irq_data ;
}
2020-10-06 12:10:20 +03:00
static void __irq_domain_free_hierarchy ( struct irq_data * irq_data )
{
struct irq_data * tmp ;
while ( irq_data ) {
tmp = irq_data ;
irq_data = irq_data - > parent_data ;
kfree ( tmp ) ;
}
}
2014-11-06 17:20:14 +03:00
static void irq_domain_free_irq_data ( unsigned int virq , unsigned int nr_irqs )
{
struct irq_data * irq_data , * tmp ;
int i ;
for ( i = 0 ; i < nr_irqs ; i + + ) {
irq_data = irq_get_irq_data ( virq + i ) ;
tmp = irq_data - > parent_data ;
irq_data - > parent_data = NULL ;
irq_data - > domain = NULL ;
2020-10-06 12:10:20 +03:00
__irq_domain_free_hierarchy ( tmp ) ;
}
}
/**
* irq_domain_disconnect_hierarchy - Mark the first unused level of a hierarchy
* @ domain : IRQ domain from which the hierarchy is to be disconnected
* @ virq : IRQ number where the hierarchy is to be trimmed
*
* Marks the @ virq level belonging to @ domain as disconnected .
* Returns - EINVAL if @ virq doesn ' t have a valid irq_data pointing
* to @ domain .
*
* Its only use is to be able to trim levels of hierarchy that do not
* have any real meaning for this interrupt , and that the driver marks
* as such from its . alloc ( ) callback .
*/
int irq_domain_disconnect_hierarchy ( struct irq_domain * domain ,
unsigned int virq )
{
struct irq_data * irqd ;
irqd = irq_domain_get_irq_data ( domain , virq ) ;
if ( ! irqd )
return - EINVAL ;
irqd - > chip = ERR_PTR ( - ENOTCONN ) ;
return 0 ;
}
static int irq_domain_trim_hierarchy ( unsigned int virq )
{
struct irq_data * tail , * irqd , * irq_data ;
irq_data = irq_get_irq_data ( virq ) ;
tail = NULL ;
/* The first entry must have a valid irqchip */
if ( ! irq_data - > chip | | IS_ERR ( irq_data - > chip ) )
return - EINVAL ;
/*
* Validate that the irq_data chain is sane in the presence of
* a hierarchy trimming marker .
*/
for ( irqd = irq_data - > parent_data ; irqd ; irq_data = irqd , irqd = irqd - > parent_data ) {
/* Can't have a valid irqchip after a trim marker */
if ( irqd - > chip & & tail )
return - EINVAL ;
/* Can't have an empty irqchip before a trim marker */
if ( ! irqd - > chip & & ! tail )
return - EINVAL ;
if ( IS_ERR ( irqd - > chip ) ) {
/* Only -ENOTCONN is a valid trim marker */
if ( PTR_ERR ( irqd - > chip ) ! = - ENOTCONN )
return - EINVAL ;
tail = irq_data ;
2014-11-06 17:20:14 +03:00
}
}
2020-10-06 12:10:20 +03:00
/* No trim marker, nothing to do */
if ( ! tail )
return 0 ;
pr_info ( " IRQ%d: trimming hierarchy from %s \n " ,
virq , tail - > parent_data - > domain - > name ) ;
/* Sever the inner part of the hierarchy... */
irqd = tail ;
tail = tail - > parent_data ;
irqd - > parent_data = NULL ;
__irq_domain_free_hierarchy ( tail ) ;
return 0 ;
2014-11-06 17:20:14 +03:00
}
static int irq_domain_alloc_irq_data ( struct irq_domain * domain ,
unsigned int virq , unsigned int nr_irqs )
{
struct irq_data * irq_data ;
struct irq_domain * parent ;
int i ;
/* The outermost irq_data is embedded in struct irq_desc */
for ( i = 0 ; i < nr_irqs ; i + + ) {
irq_data = irq_get_irq_data ( virq + i ) ;
irq_data - > domain = domain ;
for ( parent = domain - > parent ; parent ; parent = parent - > parent ) {
irq_data = irq_domain_insert_irq_data ( parent , irq_data ) ;
if ( ! irq_data ) {
irq_domain_free_irq_data ( virq , i + 1 ) ;
return - ENOMEM ;
}
}
}
return 0 ;
}
/**
* irq_domain_get_irq_data - Get irq_data associated with @ virq and @ domain
* @ domain : domain to match
* @ virq : IRQ number to get irq_data
*/
struct irq_data * irq_domain_get_irq_data ( struct irq_domain * domain ,
unsigned int virq )
{
struct irq_data * irq_data ;
for ( irq_data = irq_get_irq_data ( virq ) ; irq_data ;
irq_data = irq_data - > parent_data )
if ( irq_data - > domain = = domain )
return irq_data ;
return NULL ;
}
2015-12-10 20:52:59 +03:00
EXPORT_SYMBOL_GPL ( irq_domain_get_irq_data ) ;
2014-11-06 17:20:14 +03:00
/**
* irq_domain_set_hwirq_and_chip - Set hwirq and irqchip of @ virq at @ domain
* @ domain : Interrupt domain to match
* @ virq : IRQ number
* @ hwirq : The hwirq number
* @ chip : The associated interrupt chip
* @ chip_data : The associated chip data
*/
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 )
{
struct irq_data * irq_data = irq_domain_get_irq_data ( domain , virq ) ;
if ( ! irq_data )
return - ENOENT ;
irq_data - > hwirq = hwirq ;
irq_data - > chip = chip ? chip : & no_irq_chip ;
irq_data - > chip_data = chip_data ;
return 0 ;
}
2016-03-03 17:56:52 +03:00
EXPORT_SYMBOL_GPL ( irq_domain_set_hwirq_and_chip ) ;
2014-11-06 17:20:14 +03:00
2014-11-09 18:10:24 +03:00
/**
* irq_domain_set_info - Set the complete data for a @ virq in @ domain
* @ domain : Interrupt domain to match
* @ virq : IRQ number
* @ hwirq : The hardware interrupt number
* @ chip : The associated interrupt chip
* @ chip_data : The associated interrupt chip data
* @ handler : The interrupt flow handler
* @ handler_data : The interrupt flow handler data
* @ handler_name : The interrupt handler name
*/
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 )
{
irq_domain_set_hwirq_and_chip ( domain , virq , hwirq , chip , chip_data ) ;
__irq_set_handler ( virq , handler , 0 , handler_name ) ;
irq_set_handler_data ( virq , handler_data ) ;
}
2016-01-12 23:18:07 +03:00
EXPORT_SYMBOL ( irq_domain_set_info ) ;
2014-11-09 18:10:24 +03:00
2014-11-06 17:20:14 +03:00
/**
* irq_domain_free_irqs_common - Clear irq_data and free the parent
* @ domain : Interrupt domain to match
* @ virq : IRQ number to start with
* @ nr_irqs : The number of irqs to free
*/
void irq_domain_free_irqs_common ( struct irq_domain * domain , unsigned int virq ,
unsigned int nr_irqs )
{
struct irq_data * irq_data ;
int i ;
for ( i = 0 ; i < nr_irqs ; i + + ) {
irq_data = irq_domain_get_irq_data ( domain , virq + i ) ;
if ( irq_data )
irq_domain_reset_irq_data ( irq_data ) ;
}
irq_domain_free_irqs_parent ( domain , virq , nr_irqs ) ;
}
2016-03-17 07:00:31 +03:00
EXPORT_SYMBOL_GPL ( irq_domain_free_irqs_common ) ;
2014-11-06 17:20:14 +03:00
/**
* irq_domain_free_irqs_top - Clear handler and handler data , clear irqdata and free parent
* @ domain : Interrupt domain to match
* @ virq : IRQ number to start with
* @ nr_irqs : The number of irqs to free
*/
void irq_domain_free_irqs_top ( struct irq_domain * domain , unsigned int virq ,
unsigned int nr_irqs )
{
int i ;
for ( i = 0 ; i < nr_irqs ; i + + ) {
irq_set_handler_data ( virq + i , NULL ) ;
irq_set_handler ( virq + i , NULL ) ;
}
irq_domain_free_irqs_common ( domain , virq , nr_irqs ) ;
}
2017-06-21 00:17:44 +03:00
static void irq_domain_free_irqs_hierarchy ( struct irq_domain * domain ,
2014-11-15 17:24:01 +03:00
unsigned int irq_base ,
unsigned int nr_irqs )
{
2017-08-18 03:53:33 +03:00
if ( domain - > ops - > free )
domain - > ops - > free ( domain , irq_base , nr_irqs ) ;
2014-11-15 17:24:01 +03:00
}
2017-06-21 00:17:44 +03:00
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-15 17:24:01 +03:00
{
2020-03-06 20:47:20 +03:00
if ( ! domain - > ops - > alloc ) {
pr_debug ( " domain->ops->alloc() is NULL \n " ) ;
return - ENOSYS ;
}
2017-06-21 00:17:44 +03:00
return domain - > ops - > alloc ( domain , irq_base , nr_irqs , arg ) ;
2014-11-15 17:24:01 +03:00
}
2014-11-06 17:20:14 +03:00
/**
* __irq_domain_alloc_irqs - Allocate IRQs from domain
* @ domain : domain to allocate from
2019-04-18 18:54:01 +03:00
* @ irq_base : allocate specified IRQ number if irq_base > = 0
2014-11-06 17:20:14 +03:00
* @ nr_irqs : number of IRQs to allocate
* @ node : NUMA node id for memory allocation
* @ arg : domain specific argument
* @ realloc : IRQ descriptors have already been allocated if true
2016-07-04 11:39:24 +03:00
* @ affinity : Optional irq affinity mask for multiqueue devices
2014-11-06 17:20:14 +03:00
*
* Allocate IRQ numbers and initialized all data structures to support
* hierarchy IRQ domains .
* Parameter @ realloc is mainly to support legacy IRQs .
* Returns error code or allocated IRQ number
*
* The whole process to setup an IRQ has been split into two steps .
* The first step , __irq_domain_alloc_irqs ( ) , is to allocate IRQ
* descriptor and required hardware resources . The second step ,
* irq_domain_activate_irq ( ) , is to program hardwares with preallocated
* resources . In this way , it ' s easier to rollback when failing to
* allocate resources .
*/
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
{
int i , ret , virq ;
if ( domain = = NULL ) {
domain = irq_default_domain ;
if ( WARN ( ! domain , " domain is NULL; cannot allocate IRQ \n " ) )
return - EINVAL ;
}
if ( realloc & & irq_base > = 0 ) {
virq = irq_base ;
} else {
2016-07-04 11:39:24 +03:00
virq = irq_domain_alloc_descs ( irq_base , nr_irqs , 0 , node ,
affinity ) ;
2014-11-06 17:20:14 +03:00
if ( virq < 0 ) {
pr_debug ( " cannot allocate IRQ(base %d, count %d) \n " ,
irq_base , nr_irqs ) ;
return virq ;
}
}
if ( irq_domain_alloc_irq_data ( domain , virq , nr_irqs ) ) {
pr_debug ( " cannot allocate memory for IRQ%d \n " , virq ) ;
ret = - ENOMEM ;
goto out_free_desc ;
}
mutex_lock ( & irq_domain_mutex ) ;
2017-06-21 00:17:44 +03:00
ret = irq_domain_alloc_irqs_hierarchy ( domain , virq , nr_irqs , arg ) ;
2014-11-06 17:20:14 +03:00
if ( ret < 0 ) {
mutex_unlock ( & irq_domain_mutex ) ;
goto out_free_irq_data ;
}
2020-10-06 12:10:20 +03:00
for ( i = 0 ; i < nr_irqs ; i + + ) {
ret = irq_domain_trim_hierarchy ( virq + i ) ;
if ( ret ) {
mutex_unlock ( & irq_domain_mutex ) ;
goto out_free_irq_data ;
}
}
2014-11-06 17:20:14 +03:00
for ( i = 0 ; i < nr_irqs ; i + + )
irq_domain_insert_irq ( virq + i ) ;
mutex_unlock ( & irq_domain_mutex ) ;
return virq ;
out_free_irq_data :
irq_domain_free_irq_data ( virq , nr_irqs ) ;
out_free_desc :
irq_free_descs ( virq , nr_irqs ) ;
return ret ;
}
2017-08-18 03:53:34 +03:00
/* The irq_data was moved, fix the revmap to refer to the new location */
static void irq_domain_fix_revmap ( struct irq_data * d )
{
2017-09-22 15:20:41 +03:00
void __rcu * * slot ;
2017-08-18 03:53:34 +03:00
if ( d - > hwirq < d - > domain - > revmap_size )
return ; /* Not using radix tree. */
/* Fix up the revmap. */
2017-10-05 04:44:54 +03:00
mutex_lock ( & d - > domain - > revmap_tree_mutex ) ;
2017-08-18 03:53:34 +03:00
slot = radix_tree_lookup_slot ( & d - > domain - > revmap_tree , d - > hwirq ) ;
if ( slot )
radix_tree_replace_slot ( & d - > domain - > revmap_tree , slot , d ) ;
2017-10-05 04:44:54 +03:00
mutex_unlock ( & d - > domain - > revmap_tree_mutex ) ;
2017-08-18 03:53:34 +03:00
}
/**
* irq_domain_push_irq ( ) - Push a domain in to the top of a hierarchy .
* @ domain : Domain to push .
* @ virq : Irq to push the domain in to .
* @ arg : Passed to the irq_domain_ops alloc ( ) function .
*
* For an already existing irqdomain hierarchy , as might be obtained
* via a call to pci_enable_msix ( ) , add an additional domain to the
* head of the processing chain . Must be called before request_irq ( )
* has been called .
*/
int irq_domain_push_irq ( struct irq_domain * domain , int virq , void * arg )
{
struct irq_data * child_irq_data ;
struct irq_data * root_irq_data = irq_get_irq_data ( virq ) ;
struct irq_desc * desc ;
int rv = 0 ;
/*
* Check that no action has been set , which indicates the virq
* is in a state where this function doesn ' t have to deal with
* races between interrupt handling and maintaining the
* hierarchy . This will catch gross misuse . Attempting to
* make the check race free would require holding locks across
* calls to struct irq_domain_ops - > alloc ( ) , which could lead
* to deadlock , so we just do a simple check before starting .
*/
desc = irq_to_desc ( virq ) ;
if ( ! desc )
return - EINVAL ;
if ( WARN_ON ( desc - > action ) )
return - EBUSY ;
if ( domain = = NULL )
return - EINVAL ;
if ( WARN_ON ( ! irq_domain_is_hierarchy ( domain ) ) )
return - EINVAL ;
2017-08-25 15:14:09 +03:00
if ( ! root_irq_data )
2017-08-18 03:53:34 +03:00
return - EINVAL ;
2017-08-25 15:14:09 +03:00
if ( domain - > parent ! = root_irq_data - > domain )
2017-08-18 03:53:34 +03:00
return - EINVAL ;
child_irq_data = kzalloc_node ( sizeof ( * child_irq_data ) , GFP_KERNEL ,
irq_data_get_node ( root_irq_data ) ) ;
if ( ! child_irq_data )
return - ENOMEM ;
mutex_lock ( & irq_domain_mutex ) ;
/* Copy the original irq_data. */
* child_irq_data = * root_irq_data ;
/*
* Overwrite the root_irq_data , which is embedded in struct
* irq_desc , with values for this domain .
*/
root_irq_data - > parent_data = child_irq_data ;
root_irq_data - > domain = domain ;
root_irq_data - > mask = 0 ;
root_irq_data - > hwirq = 0 ;
root_irq_data - > chip = NULL ;
root_irq_data - > chip_data = NULL ;
/* May (probably does) set hwirq, chip, etc. */
rv = irq_domain_alloc_irqs_hierarchy ( domain , virq , 1 , arg ) ;
if ( rv ) {
/* Restore the original irq_data. */
* root_irq_data = * child_irq_data ;
2020-01-20 07:35:47 +03:00
kfree ( child_irq_data ) ;
2017-08-18 03:53:34 +03:00
goto error ;
}
irq_domain_fix_revmap ( child_irq_data ) ;
irq_domain_set_mapping ( domain , root_irq_data - > hwirq , root_irq_data ) ;
error :
mutex_unlock ( & irq_domain_mutex ) ;
return rv ;
}
EXPORT_SYMBOL_GPL ( irq_domain_push_irq ) ;
/**
* irq_domain_pop_irq ( ) - Remove a domain from the top of a hierarchy .
* @ domain : Domain to remove .
* @ virq : Irq to remove the domain from .
*
* Undo the effects of a call to irq_domain_push_irq ( ) . Must be
* called either before request_irq ( ) or after free_irq ( ) .
*/
int irq_domain_pop_irq ( struct irq_domain * domain , int virq )
{
struct irq_data * root_irq_data = irq_get_irq_data ( virq ) ;
struct irq_data * child_irq_data ;
struct irq_data * tmp_irq_data ;
struct irq_desc * desc ;
/*
* Check that no action is set , which indicates the virq is in
* a state where this function doesn ' t have to deal with races
* between interrupt handling and maintaining the hierarchy .
* This will catch gross misuse . Attempting to make the check
* race free would require holding locks across calls to
* struct irq_domain_ops - > free ( ) , which could lead to
* deadlock , so we just do a simple check before starting .
*/
desc = irq_to_desc ( virq ) ;
if ( ! desc )
return - EINVAL ;
if ( WARN_ON ( desc - > action ) )
return - EBUSY ;
if ( domain = = NULL )
return - EINVAL ;
if ( ! root_irq_data )
return - EINVAL ;
tmp_irq_data = irq_domain_get_irq_data ( domain , virq ) ;
/* We can only "pop" if this domain is at the top of the list */
if ( WARN_ON ( root_irq_data ! = tmp_irq_data ) )
return - EINVAL ;
if ( WARN_ON ( root_irq_data - > domain ! = domain ) )
return - EINVAL ;
child_irq_data = root_irq_data - > parent_data ;
if ( WARN_ON ( ! child_irq_data ) )
return - EINVAL ;
mutex_lock ( & irq_domain_mutex ) ;
root_irq_data - > parent_data = NULL ;
irq_domain_clear_mapping ( domain , root_irq_data - > hwirq ) ;
irq_domain_free_irqs_hierarchy ( domain , virq , 1 ) ;
/* Restore the original irq_data. */
* root_irq_data = * child_irq_data ;
irq_domain_fix_revmap ( root_irq_data ) ;
mutex_unlock ( & irq_domain_mutex ) ;
kfree ( child_irq_data ) ;
return 0 ;
}
EXPORT_SYMBOL_GPL ( irq_domain_pop_irq ) ;
2014-11-06 17:20:14 +03:00
/**
* irq_domain_free_irqs - Free IRQ number and associated data structures
* @ virq : base IRQ number
* @ nr_irqs : number of IRQs to free
*/
void irq_domain_free_irqs ( unsigned int virq , unsigned int nr_irqs )
{
struct irq_data * data = irq_get_irq_data ( virq ) ;
int i ;
if ( WARN ( ! data | | ! data - > domain | | ! data - > domain - > ops - > free ,
" NULL pointer, cannot free irq \n " ) )
return ;
mutex_lock ( & irq_domain_mutex ) ;
for ( i = 0 ; i < nr_irqs ; i + + )
irq_domain_remove_irq ( virq + i ) ;
2017-06-21 00:17:44 +03:00
irq_domain_free_irqs_hierarchy ( data - > domain , virq , nr_irqs ) ;
2014-11-06 17:20:14 +03:00
mutex_unlock ( & irq_domain_mutex ) ;
irq_domain_free_irq_data ( virq , nr_irqs ) ;
irq_free_descs ( virq , nr_irqs ) ;
}
2014-11-15 17:24:01 +03:00
/**
* irq_domain_alloc_irqs_parent - Allocate interrupts from parent domain
* @ irq_base : Base IRQ number
* @ nr_irqs : Number of IRQs to allocate
* @ arg : Allocation data ( arch / domain specific )
*
* Check whether the domain has been setup recursive . If not allocate
* through the parent domain .
*/
int irq_domain_alloc_irqs_parent ( struct irq_domain * domain ,
unsigned int irq_base , unsigned int nr_irqs ,
void * arg )
{
2017-06-21 00:17:44 +03:00
if ( ! domain - > parent )
return - ENOSYS ;
2014-11-15 17:24:01 +03:00
2017-06-21 00:17:44 +03:00
return irq_domain_alloc_irqs_hierarchy ( domain - > parent , irq_base ,
nr_irqs , arg ) ;
2014-11-15 17:24:01 +03:00
}
2016-03-03 17:56:52 +03:00
EXPORT_SYMBOL_GPL ( irq_domain_alloc_irqs_parent ) ;
2014-11-15 17:24:01 +03:00
/**
* irq_domain_free_irqs_parent - Free interrupts from parent domain
* @ irq_base : Base IRQ number
* @ nr_irqs : Number of IRQs to free
*
* Check whether the domain has been setup recursive . If not free
* through the parent domain .
*/
void irq_domain_free_irqs_parent ( struct irq_domain * domain ,
unsigned int irq_base , unsigned int nr_irqs )
{
2017-06-21 00:17:44 +03:00
if ( ! domain - > parent )
return ;
irq_domain_free_irqs_hierarchy ( domain - > parent , irq_base , nr_irqs ) ;
2014-11-15 17:24:01 +03:00
}
2016-03-03 17:56:52 +03:00
EXPORT_SYMBOL_GPL ( irq_domain_free_irqs_parent ) ;
2014-11-15 17:24:01 +03:00
2017-01-17 19:00:48 +03:00
static void __irq_domain_deactivate_irq ( struct irq_data * irq_data )
{
if ( irq_data & & irq_data - > domain ) {
struct irq_domain * domain = irq_data - > domain ;
if ( domain - > ops - > deactivate )
domain - > ops - > deactivate ( domain , irq_data ) ;
if ( irq_data - > parent_data )
__irq_domain_deactivate_irq ( irq_data - > parent_data ) ;
}
}
2017-12-29 18:59:06 +03:00
static int __irq_domain_activate_irq ( struct irq_data * irqd , bool reserve )
2017-09-14 00:29:11 +03:00
{
int ret = 0 ;
if ( irqd & & irqd - > domain ) {
struct irq_domain * domain = irqd - > domain ;
if ( irqd - > parent_data )
2017-09-14 00:29:12 +03:00
ret = __irq_domain_activate_irq ( irqd - > parent_data ,
2017-12-29 18:59:06 +03:00
reserve ) ;
2017-09-14 00:29:11 +03:00
if ( ! ret & & domain - > ops - > activate ) {
2017-12-29 18:59:06 +03:00
ret = domain - > ops - > activate ( domain , irqd , reserve ) ;
2017-09-14 00:29:11 +03:00
/* Rollback in case of error */
if ( ret & & irqd - > parent_data )
__irq_domain_deactivate_irq ( irqd - > parent_data ) ;
}
}
return ret ;
}
2014-11-06 17:20:14 +03:00
/**
* irq_domain_activate_irq - Call domain_ops - > activate recursively to activate
* interrupt
2017-12-29 18:59:06 +03:00
* @ irq_data : Outermost irq_data associated with interrupt
* @ reserve : If set only reserve an interrupt vector instead of assigning one
2014-11-06 17:20:14 +03:00
*
* This is the second step to call domain_ops - > activate to program interrupt
* controllers , so the interrupt could actually get delivered .
*/
2017-12-29 18:59:06 +03:00
int irq_domain_activate_irq ( struct irq_data * irq_data , bool reserve )
2014-11-06 17:20:14 +03:00
{
2017-09-14 00:29:11 +03:00
int ret = 0 ;
if ( ! irqd_is_activated ( irq_data ) )
2017-12-29 18:59:06 +03:00
ret = __irq_domain_activate_irq ( irq_data , reserve ) ;
2017-09-14 00:29:11 +03:00
if ( ! ret )
2017-01-17 19:00:48 +03:00
irqd_set_activated ( irq_data ) ;
2017-09-14 00:29:11 +03:00
return ret ;
2014-11-06 17:20:14 +03:00
}
/**
* irq_domain_deactivate_irq - Call domain_ops - > deactivate recursively to
* deactivate interrupt
* @ irq_data : outermost irq_data associated with interrupt
*
* It calls domain_ops - > deactivate to program interrupt controllers to disable
* interrupt delivery .
*/
void irq_domain_deactivate_irq ( struct irq_data * irq_data )
{
2017-01-17 19:00:48 +03:00
if ( irqd_is_activated ( irq_data ) ) {
__irq_domain_deactivate_irq ( irq_data ) ;
irqd_clr_activated ( irq_data ) ;
2014-11-06 17:20:14 +03:00
}
}
static void irq_domain_check_hierarchy ( struct irq_domain * domain )
{
/* Hierarchy irq_domains must implement callback alloc() */
if ( domain - > ops - > alloc )
domain - > flags | = IRQ_DOMAIN_FLAG_HIERARCHY ;
}
2017-01-19 23:57:57 +03:00
/**
* irq_domain_hierarchical_is_msi_remap - Check if the domain or any
* parent has MSI remapping support
* @ domain : domain pointer
*/
bool irq_domain_hierarchical_is_msi_remap ( struct irq_domain * domain )
{
for ( ; domain ; domain = domain - > parent ) {
if ( irq_domain_is_msi_remap ( domain ) )
return true ;
}
return false ;
}
2014-11-06 17:20:14 +03:00
# else /* CONFIG_IRQ_DOMAIN_HIERARCHY */
/**
* irq_domain_get_irq_data - Get irq_data associated with @ virq and @ domain
* @ domain : domain to match
* @ virq : IRQ number to get irq_data
*/
struct irq_data * irq_domain_get_irq_data ( struct irq_domain * domain ,
unsigned int virq )
{
struct irq_data * irq_data = irq_get_irq_data ( virq ) ;
return ( irq_data & & irq_data - > domain = = domain ) ? irq_data : NULL ;
}
2015-12-10 20:52:59 +03:00
EXPORT_SYMBOL_GPL ( irq_domain_get_irq_data ) ;
2014-11-06 17:20:14 +03:00
2015-05-16 12:44:13 +03:00
/**
* irq_domain_set_info - Set the complete data for a @ virq in @ domain
* @ domain : Interrupt domain to match
* @ virq : IRQ number
* @ hwirq : The hardware interrupt number
* @ chip : The associated interrupt chip
* @ chip_data : The associated interrupt chip data
* @ handler : The interrupt flow handler
* @ handler_data : The interrupt flow handler data
* @ handler_name : The interrupt handler name
*/
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 )
{
irq_set_chip_and_handler_name ( virq , chip , handler , handler_name ) ;
irq_set_chip_data ( virq , chip_data ) ;
irq_set_handler_data ( virq , handler_data ) ;
}
2014-11-06 17:20:14 +03:00
static void irq_domain_check_hierarchy ( struct irq_domain * domain )
{
}
# endif /* CONFIG_IRQ_DOMAIN_HIERARCHY */
2017-06-20 02:37:17 +03:00
# ifdef CONFIG_GENERIC_IRQ_DEBUGFS
static struct dentry * domain_dir ;
static void
irq_domain_debug_show_one ( struct seq_file * m , struct irq_domain * d , int ind )
{
seq_printf ( m , " %*sname: %s \n " , ind , " " , d - > name ) ;
seq_printf ( m , " %*ssize: %u \n " , ind + 1 , " " ,
d - > revmap_size + d - > revmap_direct_max_irq ) ;
seq_printf ( m , " %*smapped: %u \n " , ind + 1 , " " , d - > mapcount ) ;
seq_printf ( m , " %*sflags: 0x%08x \n " , ind + 1 , " " , d - > flags ) ;
2017-09-14 00:29:06 +03:00
if ( d - > ops & & d - > ops - > debug_show )
d - > ops - > debug_show ( m , d , NULL , ind + 1 ) ;
2017-06-20 02:37:17 +03:00
# ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
if ( ! d - > parent )
return ;
seq_printf ( m , " %*sparent: %s \n " , ind + 1 , " " , d - > parent - > name ) ;
irq_domain_debug_show_one ( m , d - > parent , ind + 4 ) ;
# endif
}
static int irq_domain_debug_show ( struct seq_file * m , void * p )
{
struct irq_domain * d = m - > private ;
/* Default domain? Might be NULL */
if ( ! d ) {
if ( ! irq_default_domain )
return 0 ;
d = irq_default_domain ;
}
irq_domain_debug_show_one ( m , d , 0 ) ;
return 0 ;
}
2018-02-14 18:47:35 +03:00
DEFINE_SHOW_ATTRIBUTE ( irq_domain_debug ) ;
2017-06-20 02:37:17 +03:00
static void debugfs_add_domain_dir ( struct irq_domain * d )
{
if ( ! d - > name | | ! domain_dir | | d - > debugfs_file )
return ;
d - > debugfs_file = debugfs_create_file ( d - > name , 0444 , domain_dir , d ,
2018-02-14 18:47:35 +03:00
& irq_domain_debug_fops ) ;
2017-06-20 02:37:17 +03:00
}
static void debugfs_remove_domain_dir ( struct irq_domain * d )
{
2017-07-07 09:57:57 +03:00
debugfs_remove ( d - > debugfs_file ) ;
2018-10-01 13:05:21 +03:00
d - > debugfs_file = NULL ;
2017-06-20 02:37:17 +03:00
}
void __init irq_domain_debugfs_init ( struct dentry * root )
{
struct irq_domain * d ;
domain_dir = debugfs_create_dir ( " domains " , root ) ;
2018-02-14 18:47:35 +03:00
debugfs_create_file ( " default " , 0444 , domain_dir , NULL ,
& irq_domain_debug_fops ) ;
2017-06-20 02:37:17 +03:00
mutex_lock ( & irq_domain_mutex ) ;
list_for_each_entry ( d , & irq_domain_list , link )
debugfs_add_domain_dir ( d ) ;
mutex_unlock ( & irq_domain_mutex ) ;
}
# endif