2018-03-15 05:15:19 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2006-06-29 17:24:53 +08:00
|
|
|
/*
|
|
|
|
* Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
|
|
|
|
* Copyright (C) 2005-2006, Thomas Gleixner, Russell King
|
|
|
|
*
|
2018-03-15 05:15:16 +08:00
|
|
|
* This file contains the core interrupt handling code, for irq-chip based
|
|
|
|
* architectures. Detailed information is available in
|
|
|
|
* Documentation/core-api/genericirq.rst
|
2006-06-29 17:24:53 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/irq.h>
|
2007-04-18 17:39:21 +08:00
|
|
|
#include <linux/msi.h>
|
2006-06-29 17:24:53 +08:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/kernel_stat.h>
|
2014-11-06 22:20:14 +08:00
|
|
|
#include <linux/irqdomain.h>
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2012-01-26 09:18:55 +08:00
|
|
|
#include <trace/events/irq.h>
|
|
|
|
|
2006-06-29 17:24:53 +08:00
|
|
|
#include "internals.h"
|
|
|
|
|
genirq: Allow migration of chained interrupts by installing default action
When a CPU is offlined all interrupts that have an action are migrated to
other still online CPUs. However, if the interrupt has chained handler
installed this is not done. Chained handlers are used by GPIO drivers which
support interrupts, for instance.
When the affinity is not corrected properly we end up in situation where
most interrupts are not arriving to the online CPUs anymore. For example on
Intel Braswell system which has SD-card card detection signal connected to
a GPIO the IO-APIC routing entries look like below after CPU1 is offlined:
pin30, enabled , level, low , V(52), IRR(0), S(0), logical , D(03), M(1)
pin31, enabled , level, low , V(42), IRR(0), S(0), logical , D(03), M(1)
pin32, enabled , level, low , V(62), IRR(0), S(0), logical , D(03), M(1)
pin5b, enabled , level, low , V(72), IRR(0), S(0), logical , D(03), M(1)
The problem here is that the destination mask still contains both CPUs even
if CPU1 is already offline. This means that the IO-APIC still routes
interrupts to the other CPU as well.
We solve the problem by providing a default action for chained interrupts.
This action allows the migration code to correct affinity (as it finds
desc->action != NULL).
Also make the default action handler to emit a warning if for some reason a
chained handler ends up calling it.
Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Cc: Jiang Liu <jiang.liu@linux.intel.com>
Link: http://lkml.kernel.org/r/1444039935-30475-1-git-send-email-mika.westerberg@linux.intel.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2015-10-05 18:12:15 +08:00
|
|
|
static irqreturn_t bad_chained_irq(int irq, void *dev_id)
|
|
|
|
{
|
|
|
|
WARN_ONCE(1, "Chained irq %d should not call an action\n", irq);
|
|
|
|
return IRQ_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Chained handlers should never call action on their IRQ. This default
|
|
|
|
* action will emit warning if such thing happens.
|
|
|
|
*/
|
|
|
|
struct irqaction chained_action = {
|
|
|
|
.handler = bad_chained_irq,
|
|
|
|
};
|
|
|
|
|
2006-06-29 17:24:53 +08:00
|
|
|
/**
|
2011-02-10 18:36:33 +08:00
|
|
|
* irq_set_chip - set the irq chip for an irq
|
2006-06-29 17:24:53 +08:00
|
|
|
* @irq: irq number
|
|
|
|
* @chip: pointer to irq chip description structure
|
|
|
|
*/
|
2022-02-10 00:25:59 +08:00
|
|
|
int irq_set_chip(unsigned int irq, const struct irq_chip *chip)
|
2006-06-29 17:24:53 +08:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-24 00:03:06 +08:00
|
|
|
struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2011-02-12 17:37:36 +08:00
|
|
|
if (!desc)
|
2006-06-29 17:24:53 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2022-02-10 00:25:59 +08:00
|
|
|
desc->irq_data.chip = (struct irq_chip *)(chip ?: &no_irq_chip);
|
2011-02-12 17:37:36 +08:00
|
|
|
irq_put_desc_unlock(desc, flags);
|
2011-03-26 03:38:48 +08:00
|
|
|
/*
|
|
|
|
* For !CONFIG_SPARSE_IRQ make the irq show up in
|
2014-05-07 23:44:21 +08:00
|
|
|
* allocated_irqs.
|
2011-03-26 03:38:48 +08:00
|
|
|
*/
|
2014-05-07 23:44:21 +08:00
|
|
|
irq_mark_irq(irq);
|
2006-06-29 17:24:53 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2011-02-10 18:36:33 +08:00
|
|
|
EXPORT_SYMBOL(irq_set_chip);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
|
|
|
/**
|
2020-11-16 18:18:15 +08:00
|
|
|
* irq_set_irq_type - set the irq trigger type for an irq
|
2006-06-29 17:24:53 +08:00
|
|
|
* @irq: irq number
|
2008-10-02 05:46:18 +08:00
|
|
|
* @type: IRQ_TYPE_{LEVEL,EDGE}_* value - see include/linux/irq.h
|
2006-06-29 17:24:53 +08:00
|
|
|
*/
|
2011-02-10 18:36:33 +08:00
|
|
|
int irq_set_irq_type(unsigned int irq, unsigned int type)
|
2006-06-29 17:24:53 +08:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-24 00:03:06 +08:00
|
|
|
struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
|
2011-02-12 17:37:36 +08:00
|
|
|
int ret = 0;
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2011-02-12 17:37:36 +08:00
|
|
|
if (!desc)
|
|
|
|
return -EINVAL;
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2015-06-24 01:47:29 +08:00
|
|
|
ret = __irq_set_trigger(desc, type);
|
2011-02-12 17:37:36 +08:00
|
|
|
irq_put_desc_busunlock(desc, flags);
|
2006-06-29 17:24:53 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2011-02-10 18:36:33 +08:00
|
|
|
EXPORT_SYMBOL(irq_set_irq_type);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
|
|
|
/**
|
2011-02-10 18:36:33 +08:00
|
|
|
* irq_set_handler_data - set irq handler data for an irq
|
2006-06-29 17:24:53 +08:00
|
|
|
* @irq: Interrupt number
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
*
|
|
|
|
* Set the hardware irq controller data for an irq
|
|
|
|
*/
|
2011-02-10 18:36:33 +08:00
|
|
|
int irq_set_handler_data(unsigned int irq, void *data)
|
2006-06-29 17:24:53 +08:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-24 00:03:06 +08:00
|
|
|
struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2011-02-12 17:37:36 +08:00
|
|
|
if (!desc)
|
2006-06-29 17:24:53 +08:00
|
|
|
return -EINVAL;
|
2015-06-01 16:05:21 +08:00
|
|
|
desc->irq_common_data.handler_data = data;
|
2011-02-12 17:37:36 +08:00
|
|
|
irq_put_desc_unlock(desc, flags);
|
2006-06-29 17:24:53 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2011-02-10 18:36:33 +08:00
|
|
|
EXPORT_SYMBOL(irq_set_handler_data);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2007-01-29 03:52:03 +08:00
|
|
|
/**
|
2012-11-19 23:01:29 +08:00
|
|
|
* irq_set_msi_desc_off - set MSI descriptor data for an irq at offset
|
|
|
|
* @irq_base: Interrupt number base
|
|
|
|
* @irq_offset: Interrupt number offset
|
|
|
|
* @entry: Pointer to MSI descriptor data
|
2007-01-29 03:52:03 +08:00
|
|
|
*
|
2012-11-19 23:01:29 +08:00
|
|
|
* Set the MSI descriptor entry for an irq at offset
|
2007-01-29 03:52:03 +08:00
|
|
|
*/
|
2012-11-19 23:01:29 +08:00
|
|
|
int irq_set_msi_desc_off(unsigned int irq_base, unsigned int irq_offset,
|
|
|
|
struct msi_desc *entry)
|
2007-01-29 03:52:03 +08:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2012-11-19 23:01:29 +08:00
|
|
|
struct irq_desc *desc = irq_get_desc_lock(irq_base + irq_offset, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
|
2007-01-29 03:52:03 +08:00
|
|
|
|
2011-02-12 17:37:36 +08:00
|
|
|
if (!desc)
|
2007-01-29 03:52:03 +08:00
|
|
|
return -EINVAL;
|
2015-06-01 16:05:43 +08:00
|
|
|
desc->irq_common_data.msi_desc = entry;
|
2012-11-19 23:01:29 +08:00
|
|
|
if (entry && !irq_offset)
|
|
|
|
entry->irq = irq_base;
|
2011-02-12 17:37:36 +08:00
|
|
|
irq_put_desc_unlock(desc, flags);
|
2007-01-29 03:52:03 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-19 23:01:29 +08:00
|
|
|
/**
|
|
|
|
* irq_set_msi_desc - set MSI descriptor data for an irq
|
|
|
|
* @irq: Interrupt number
|
|
|
|
* @entry: Pointer to MSI descriptor data
|
|
|
|
*
|
|
|
|
* Set the MSI descriptor entry for an irq
|
|
|
|
*/
|
|
|
|
int irq_set_msi_desc(unsigned int irq, struct msi_desc *entry)
|
|
|
|
{
|
|
|
|
return irq_set_msi_desc_off(irq, 0, entry);
|
|
|
|
}
|
|
|
|
|
2006-06-29 17:24:53 +08:00
|
|
|
/**
|
2011-02-10 18:36:33 +08:00
|
|
|
* irq_set_chip_data - set irq chip data for an irq
|
2006-06-29 17:24:53 +08:00
|
|
|
* @irq: Interrupt number
|
|
|
|
* @data: Pointer to chip specific data
|
|
|
|
*
|
|
|
|
* Set the hardware irq chip data for an irq
|
|
|
|
*/
|
2011-02-10 18:36:33 +08:00
|
|
|
int irq_set_chip_data(unsigned int irq, void *data)
|
2006-06-29 17:24:53 +08:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-24 00:03:06 +08:00
|
|
|
struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2011-02-12 17:37:36 +08:00
|
|
|
if (!desc)
|
2006-06-29 17:24:53 +08:00
|
|
|
return -EINVAL;
|
2010-10-01 18:58:38 +08:00
|
|
|
desc->irq_data.chip_data = data;
|
2011-02-12 17:37:36 +08:00
|
|
|
irq_put_desc_unlock(desc, flags);
|
2006-06-29 17:24:53 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2011-02-10 18:36:33 +08:00
|
|
|
EXPORT_SYMBOL(irq_set_chip_data);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2010-09-28 23:34:01 +08:00
|
|
|
struct irq_data *irq_get_irq_data(unsigned int irq)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
|
|
|
|
return desc ? &desc->irq_data : NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(irq_get_irq_data);
|
|
|
|
|
2011-02-08 05:11:30 +08:00
|
|
|
static void irq_state_clr_disabled(struct irq_desc *desc)
|
|
|
|
{
|
2011-03-27 17:02:49 +08:00
|
|
|
irqd_clear(&desc->irq_data, IRQD_IRQ_DISABLED);
|
2011-02-08 05:11:30 +08:00
|
|
|
}
|
|
|
|
|
2011-02-08 19:36:06 +08:00
|
|
|
static void irq_state_clr_masked(struct irq_desc *desc)
|
|
|
|
{
|
2011-03-28 20:10:52 +08:00
|
|
|
irqd_clear(&desc->irq_data, IRQD_IRQ_MASKED);
|
2011-02-08 19:36:06 +08:00
|
|
|
}
|
|
|
|
|
2017-05-31 17:58:32 +08:00
|
|
|
static void irq_state_clr_started(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
irqd_clear(&desc->irq_data, IRQD_IRQ_STARTED);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void irq_state_set_started(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
irqd_set(&desc->irq_data, IRQD_IRQ_STARTED);
|
|
|
|
}
|
|
|
|
|
2017-06-20 07:37:50 +08:00
|
|
|
enum {
|
|
|
|
IRQ_STARTUP_NORMAL,
|
|
|
|
IRQ_STARTUP_MANAGED,
|
|
|
|
IRQ_STARTUP_ABORT,
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
static int
|
2022-07-02 04:00:55 +08:00
|
|
|
__irq_startup_managed(struct irq_desc *desc, const struct cpumask *aff,
|
|
|
|
bool force)
|
2017-06-20 07:37:50 +08:00
|
|
|
{
|
|
|
|
struct irq_data *d = irq_desc_get_irq_data(desc);
|
|
|
|
|
|
|
|
if (!irqd_affinity_is_managed(d))
|
|
|
|
return IRQ_STARTUP_NORMAL;
|
|
|
|
|
|
|
|
irqd_clr_managed_shutdown(d);
|
|
|
|
|
2017-09-14 05:29:03 +08:00
|
|
|
if (cpumask_any_and(aff, cpu_online_mask) >= nr_cpu_ids) {
|
2017-06-20 07:37:50 +08:00
|
|
|
/*
|
|
|
|
* Catch code which fiddles with enable_irq() on a managed
|
|
|
|
* and potentially shutdown IRQ. Chained interrupt
|
|
|
|
* installment or irq auto probing should not happen on
|
2017-09-14 05:29:09 +08:00
|
|
|
* managed irqs either.
|
2017-06-20 07:37:50 +08:00
|
|
|
*/
|
|
|
|
if (WARN_ON_ONCE(force))
|
2017-09-14 05:29:09 +08:00
|
|
|
return IRQ_STARTUP_ABORT;
|
2017-06-20 07:37:50 +08:00
|
|
|
/*
|
|
|
|
* The interrupt was requested, but there is no online CPU
|
|
|
|
* in it's affinity mask. Put it into managed shutdown
|
|
|
|
* state and let the cpu hotplug mechanism start it up once
|
|
|
|
* a CPU in the mask becomes available.
|
|
|
|
*/
|
|
|
|
return IRQ_STARTUP_ABORT;
|
|
|
|
}
|
2017-09-14 05:29:11 +08:00
|
|
|
/*
|
|
|
|
* Managed interrupts have reserved resources, so this should not
|
|
|
|
* happen.
|
|
|
|
*/
|
2017-09-14 05:29:12 +08:00
|
|
|
if (WARN_ON(irq_domain_activate_irq(d, false)))
|
2017-09-14 05:29:11 +08:00
|
|
|
return IRQ_STARTUP_ABORT;
|
2017-06-20 07:37:50 +08:00
|
|
|
return IRQ_STARTUP_MANAGED;
|
|
|
|
}
|
|
|
|
#else
|
2017-07-04 18:06:01 +08:00
|
|
|
static __always_inline int
|
2022-07-02 04:00:55 +08:00
|
|
|
__irq_startup_managed(struct irq_desc *desc, const struct cpumask *aff,
|
|
|
|
bool force)
|
2017-06-20 07:37:50 +08:00
|
|
|
{
|
|
|
|
return IRQ_STARTUP_NORMAL;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2017-06-20 07:37:48 +08:00
|
|
|
static int __irq_startup(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
struct irq_data *d = irq_desc_get_irq_data(desc);
|
|
|
|
int ret = 0;
|
|
|
|
|
2017-09-14 05:29:09 +08:00
|
|
|
/* Warn if this interrupt is not activated but try nevertheless */
|
|
|
|
WARN_ON_ONCE(!irqd_is_activated(d));
|
|
|
|
|
2017-06-20 07:37:48 +08:00
|
|
|
if (d->chip->irq_startup) {
|
|
|
|
ret = d->chip->irq_startup(d);
|
|
|
|
irq_state_clr_disabled(desc);
|
|
|
|
irq_state_clr_masked(desc);
|
|
|
|
} else {
|
|
|
|
irq_enable(desc);
|
|
|
|
}
|
|
|
|
irq_state_set_started(desc);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-06-20 07:37:49 +08:00
|
|
|
int irq_startup(struct irq_desc *desc, bool resend, bool force)
|
2011-02-03 05:41:14 +08:00
|
|
|
{
|
2017-06-20 07:37:50 +08:00
|
|
|
struct irq_data *d = irq_desc_get_irq_data(desc);
|
2022-07-02 04:00:55 +08:00
|
|
|
const struct cpumask *aff = irq_data_get_affinity_mask(d);
|
2012-02-08 18:57:52 +08:00
|
|
|
int ret = 0;
|
|
|
|
|
2011-02-03 05:41:14 +08:00
|
|
|
desc->depth = 0;
|
|
|
|
|
2017-06-20 07:37:50 +08:00
|
|
|
if (irqd_is_started(d)) {
|
2012-02-08 18:57:52 +08:00
|
|
|
irq_enable(desc);
|
2017-05-31 17:58:32 +08:00
|
|
|
} else {
|
2017-06-20 07:37:50 +08:00
|
|
|
switch (__irq_startup_managed(desc, aff, force)) {
|
|
|
|
case IRQ_STARTUP_NORMAL:
|
2021-07-30 05:51:48 +08:00
|
|
|
if (d->chip->flags & IRQCHIP_AFFINITY_PRE_STARTUP)
|
|
|
|
irq_setup_affinity(desc);
|
2017-06-20 07:37:50 +08:00
|
|
|
ret = __irq_startup(desc);
|
2021-07-30 05:51:48 +08:00
|
|
|
if (!(d->chip->flags & IRQCHIP_AFFINITY_PRE_STARTUP))
|
|
|
|
irq_setup_affinity(desc);
|
2017-06-20 07:37:50 +08:00
|
|
|
break;
|
|
|
|
case IRQ_STARTUP_MANAGED:
|
2017-10-05 03:07:38 +08:00
|
|
|
irq_do_set_affinity(d, aff, false);
|
2017-06-20 07:37:50 +08:00
|
|
|
ret = __irq_startup(desc);
|
|
|
|
break;
|
|
|
|
case IRQ_STARTUP_ABORT:
|
2017-09-14 05:29:09 +08:00
|
|
|
irqd_set_managed_shutdown(d);
|
2017-06-20 07:37:50 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2011-02-04 17:17:52 +08:00
|
|
|
}
|
2012-02-08 18:57:52 +08:00
|
|
|
if (resend)
|
2020-03-06 21:03:47 +08:00
|
|
|
check_irq_resend(desc, false);
|
2017-05-31 17:58:32 +08:00
|
|
|
|
2012-02-08 18:57:52 +08:00
|
|
|
return ret;
|
2011-02-03 05:41:14 +08:00
|
|
|
}
|
|
|
|
|
2017-09-14 05:29:09 +08:00
|
|
|
int irq_activate(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
struct irq_data *d = irq_desc_get_irq_data(desc);
|
|
|
|
|
|
|
|
if (!irqd_affinity_is_managed(d))
|
2017-09-14 05:29:12 +08:00
|
|
|
return irq_domain_activate_irq(d, false);
|
2017-09-14 05:29:09 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-01-31 02:36:32 +08:00
|
|
|
int irq_activate_and_startup(struct irq_desc *desc, bool resend)
|
2017-09-14 05:29:09 +08:00
|
|
|
{
|
|
|
|
if (WARN_ON(irq_activate(desc)))
|
2018-01-31 02:36:32 +08:00
|
|
|
return 0;
|
|
|
|
return irq_startup(desc, resend, IRQ_START_FORCE);
|
2017-09-14 05:29:09 +08:00
|
|
|
}
|
|
|
|
|
2017-05-31 17:58:32 +08:00
|
|
|
static void __irq_disable(struct irq_desc *desc, bool mask);
|
|
|
|
|
2011-02-03 05:41:14 +08:00
|
|
|
void irq_shutdown(struct irq_desc *desc)
|
|
|
|
{
|
2017-05-31 17:58:32 +08:00
|
|
|
if (irqd_is_started(&desc->irq_data)) {
|
|
|
|
desc->depth = 1;
|
|
|
|
if (desc->irq_data.chip->irq_shutdown) {
|
|
|
|
desc->irq_data.chip->irq_shutdown(&desc->irq_data);
|
|
|
|
irq_state_set_disabled(desc);
|
|
|
|
irq_state_set_masked(desc);
|
|
|
|
} else {
|
|
|
|
__irq_disable(desc, true);
|
|
|
|
}
|
|
|
|
irq_state_clr_started(desc);
|
|
|
|
}
|
2019-06-28 19:11:49 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void irq_shutdown_and_deactivate(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
irq_shutdown(desc);
|
2017-05-31 17:58:32 +08:00
|
|
|
/*
|
|
|
|
* This must be called even if the interrupt was never started up,
|
|
|
|
* because the activation can happen before the interrupt is
|
|
|
|
* available for request/startup. It has it's own state tracking so
|
|
|
|
* it's safe to call it unconditionally.
|
|
|
|
*/
|
2014-11-06 22:20:14 +08:00
|
|
|
irq_domain_deactivate_irq(&desc->irq_data);
|
2011-02-03 05:41:14 +08:00
|
|
|
}
|
|
|
|
|
2011-02-03 19:27:44 +08:00
|
|
|
void irq_enable(struct irq_desc *desc)
|
|
|
|
{
|
2017-06-26 19:33:34 +08:00
|
|
|
if (!irqd_irq_disabled(&desc->irq_data)) {
|
|
|
|
unmask_irq(desc);
|
|
|
|
} else {
|
|
|
|
irq_state_clr_disabled(desc);
|
|
|
|
if (desc->irq_data.chip->irq_enable) {
|
|
|
|
desc->irq_data.chip->irq_enable(&desc->irq_data);
|
|
|
|
irq_state_clr_masked(desc);
|
|
|
|
} else {
|
|
|
|
unmask_irq(desc);
|
|
|
|
}
|
|
|
|
}
|
2006-06-29 17:24:53 +08:00
|
|
|
}
|
|
|
|
|
2017-05-31 17:58:32 +08:00
|
|
|
static void __irq_disable(struct irq_desc *desc, bool mask)
|
|
|
|
{
|
2017-06-26 19:33:34 +08:00
|
|
|
if (irqd_irq_disabled(&desc->irq_data)) {
|
|
|
|
if (mask)
|
|
|
|
mask_irq(desc);
|
|
|
|
} else {
|
|
|
|
irq_state_set_disabled(desc);
|
|
|
|
if (desc->irq_data.chip->irq_disable) {
|
|
|
|
desc->irq_data.chip->irq_disable(&desc->irq_data);
|
|
|
|
irq_state_set_masked(desc);
|
|
|
|
} else if (mask) {
|
|
|
|
mask_irq(desc);
|
|
|
|
}
|
2017-05-31 17:58:32 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-10 18:21:30 +08:00
|
|
|
/**
|
2013-10-18 09:12:04 +08:00
|
|
|
* irq_disable - Mark interrupt disabled
|
2013-05-10 18:21:30 +08:00
|
|
|
* @desc: irq descriptor which should be disabled
|
|
|
|
*
|
|
|
|
* If the chip does not implement the irq_disable callback, we
|
|
|
|
* use a lazy disable approach. That means we mark the interrupt
|
|
|
|
* disabled, but leave the hardware unmasked. That's an
|
|
|
|
* optimization because we avoid the hardware access for the
|
|
|
|
* common case where no interrupt happens after we marked it
|
|
|
|
* disabled. If an interrupt happens, then the interrupt flow
|
|
|
|
* handler masks the line at the hardware level and marks it
|
|
|
|
* pending.
|
2015-10-10 05:28:58 +08:00
|
|
|
*
|
|
|
|
* If the interrupt chip does not implement the irq_disable callback,
|
|
|
|
* a driver can disable the lazy approach for a particular irq line by
|
|
|
|
* calling 'irq_set_status_flags(irq, IRQ_DISABLE_UNLAZY)'. This can
|
|
|
|
* be used for devices which cannot disable the interrupt at the
|
|
|
|
* device level under certain circumstances and have to use
|
|
|
|
* disable_irq[_nosync] instead.
|
2013-05-10 18:21:30 +08:00
|
|
|
*/
|
2011-02-03 20:23:54 +08:00
|
|
|
void irq_disable(struct irq_desc *desc)
|
2008-02-19 01:25:17 +08:00
|
|
|
{
|
2017-05-31 17:58:32 +08:00
|
|
|
__irq_disable(desc, irq_settings_disable_unlazy(desc));
|
2008-02-19 01:25:17 +08:00
|
|
|
}
|
|
|
|
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-24 00:03:06 +08:00
|
|
|
void irq_percpu_enable(struct irq_desc *desc, unsigned int cpu)
|
|
|
|
{
|
|
|
|
if (desc->irq_data.chip->irq_enable)
|
|
|
|
desc->irq_data.chip->irq_enable(&desc->irq_data);
|
|
|
|
else
|
|
|
|
desc->irq_data.chip->irq_unmask(&desc->irq_data);
|
|
|
|
cpumask_set_cpu(cpu, desc->percpu_enabled);
|
|
|
|
}
|
|
|
|
|
|
|
|
void irq_percpu_disable(struct irq_desc *desc, unsigned int cpu)
|
|
|
|
{
|
|
|
|
if (desc->irq_data.chip->irq_disable)
|
|
|
|
desc->irq_data.chip->irq_disable(&desc->irq_data);
|
|
|
|
else
|
|
|
|
desc->irq_data.chip->irq_mask(&desc->irq_data);
|
|
|
|
cpumask_clear_cpu(cpu, desc->percpu_enabled);
|
|
|
|
}
|
|
|
|
|
2010-09-27 20:44:50 +08:00
|
|
|
static inline void mask_ack_irq(struct irq_desc *desc)
|
2006-06-29 17:24:53 +08:00
|
|
|
{
|
2017-06-26 19:33:34 +08:00
|
|
|
if (desc->irq_data.chip->irq_mask_ack) {
|
2010-09-27 20:44:50 +08:00
|
|
|
desc->irq_data.chip->irq_mask_ack(&desc->irq_data);
|
2017-06-26 19:33:34 +08:00
|
|
|
irq_state_set_masked(desc);
|
|
|
|
} else {
|
|
|
|
mask_irq(desc);
|
2010-09-27 20:44:47 +08:00
|
|
|
if (desc->irq_data.chip->irq_ack)
|
|
|
|
desc->irq_data.chip->irq_ack(&desc->irq_data);
|
2006-06-29 17:24:53 +08:00
|
|
|
}
|
2010-03-10 02:45:54 +08:00
|
|
|
}
|
|
|
|
|
2011-02-10 20:16:14 +08:00
|
|
|
void mask_irq(struct irq_desc *desc)
|
2010-03-10 02:45:54 +08:00
|
|
|
{
|
2017-06-26 19:33:34 +08:00
|
|
|
if (irqd_irq_masked(&desc->irq_data))
|
|
|
|
return;
|
|
|
|
|
2010-09-27 20:44:42 +08:00
|
|
|
if (desc->irq_data.chip->irq_mask) {
|
|
|
|
desc->irq_data.chip->irq_mask(&desc->irq_data);
|
2011-02-08 19:36:06 +08:00
|
|
|
irq_state_set_masked(desc);
|
2010-03-10 02:45:54 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-10 20:16:14 +08:00
|
|
|
void unmask_irq(struct irq_desc *desc)
|
2010-03-10 02:45:54 +08:00
|
|
|
{
|
2017-06-26 19:33:34 +08:00
|
|
|
if (!irqd_irq_masked(&desc->irq_data))
|
|
|
|
return;
|
|
|
|
|
2010-09-27 20:44:44 +08:00
|
|
|
if (desc->irq_data.chip->irq_unmask) {
|
|
|
|
desc->irq_data.chip->irq_unmask(&desc->irq_data);
|
2011-02-08 19:36:06 +08:00
|
|
|
irq_state_clr_masked(desc);
|
2010-03-10 02:45:54 +08:00
|
|
|
}
|
2006-06-29 17:24:53 +08:00
|
|
|
}
|
|
|
|
|
2014-03-14 02:03:51 +08:00
|
|
|
void unmask_threaded_irq(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
struct irq_chip *chip = desc->irq_data.chip;
|
|
|
|
|
|
|
|
if (chip->flags & IRQCHIP_EOI_THREADED)
|
|
|
|
chip->irq_eoi(&desc->irq_data);
|
|
|
|
|
2017-06-26 19:33:34 +08:00
|
|
|
unmask_irq(desc);
|
2014-03-14 02:03:51 +08:00
|
|
|
}
|
|
|
|
|
2009-08-13 19:21:38 +08:00
|
|
|
/*
|
|
|
|
* handle_nested_irq - Handle a nested irq from a irq thread
|
|
|
|
* @irq: the interrupt number
|
|
|
|
*
|
|
|
|
* Handle interrupts which are nested into a threaded interrupt
|
|
|
|
* handler. The handler function is called inside the calling
|
|
|
|
* threads context.
|
|
|
|
*/
|
|
|
|
void handle_nested_irq(unsigned int irq)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
|
|
|
struct irqaction *action;
|
|
|
|
irqreturn_t action_ret;
|
|
|
|
|
|
|
|
might_sleep();
|
|
|
|
|
2009-11-17 23:46:45 +08:00
|
|
|
raw_spin_lock_irq(&desc->lock);
|
2009-08-13 19:21:38 +08:00
|
|
|
|
2012-10-17 06:07:49 +08:00
|
|
|
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
|
2009-08-13 19:21:38 +08:00
|
|
|
|
|
|
|
action = desc->action;
|
2012-05-22 00:19:20 +08:00
|
|
|
if (unlikely(!action || irqd_irq_disabled(&desc->irq_data))) {
|
|
|
|
desc->istate |= IRQS_PENDING;
|
2009-08-13 19:21:38 +08:00
|
|
|
goto out_unlock;
|
2012-05-22 00:19:20 +08:00
|
|
|
}
|
2009-08-13 19:21:38 +08:00
|
|
|
|
2015-11-05 02:32:37 +08:00
|
|
|
kstat_incr_irqs_this_cpu(desc);
|
2011-03-28 20:10:52 +08:00
|
|
|
irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
|
2009-11-17 23:46:45 +08:00
|
|
|
raw_spin_unlock_irq(&desc->lock);
|
2009-08-13 19:21:38 +08:00
|
|
|
|
2017-03-08 00:28:18 +08:00
|
|
|
action_ret = IRQ_NONE;
|
|
|
|
for_each_action_of_desc(desc, action)
|
|
|
|
action_ret |= action->thread_fn(action->irq, action->dev_id);
|
|
|
|
|
2021-04-02 14:23:25 +08:00
|
|
|
if (!irq_settings_no_debug(desc))
|
2015-06-04 12:13:28 +08:00
|
|
|
note_interrupt(desc, action_ret);
|
2009-08-13 19:21:38 +08:00
|
|
|
|
2009-11-17 23:46:45 +08:00
|
|
|
raw_spin_lock_irq(&desc->lock);
|
2011-03-28 20:10:52 +08:00
|
|
|
irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
|
2009-08-13 19:21:38 +08:00
|
|
|
|
|
|
|
out_unlock:
|
2009-11-17 23:46:45 +08:00
|
|
|
raw_spin_unlock_irq(&desc->lock);
|
2009-08-13 19:21:38 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(handle_nested_irq);
|
|
|
|
|
2011-02-07 17:34:30 +08:00
|
|
|
static bool irq_check_poll(struct irq_desc *desc)
|
|
|
|
{
|
2011-02-08 03:55:35 +08:00
|
|
|
if (!(desc->istate & IRQS_POLL_INPROGRESS))
|
2011-02-07 17:34:30 +08:00
|
|
|
return false;
|
|
|
|
return irq_wait_for_poll(desc);
|
|
|
|
}
|
|
|
|
|
2014-08-29 19:39:37 +08:00
|
|
|
static bool irq_may_run(struct irq_desc *desc)
|
|
|
|
{
|
2014-08-29 20:00:16 +08:00
|
|
|
unsigned int mask = IRQD_IRQ_INPROGRESS | IRQD_WAKEUP_ARMED;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the interrupt is not in progress and is not an armed
|
|
|
|
* wakeup interrupt, proceed.
|
|
|
|
*/
|
|
|
|
if (!irqd_has_set(&desc->irq_data, mask))
|
2014-08-29 19:39:37 +08:00
|
|
|
return true;
|
2014-08-29 20:00:16 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the interrupt is an armed wakeup source, mark it pending
|
|
|
|
* and suspended, disable it and notify the pm core about the
|
|
|
|
* event.
|
|
|
|
*/
|
|
|
|
if (irq_pm_check_wakeup(desc))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle a potential concurrent poll on a different core.
|
|
|
|
*/
|
2014-08-29 19:39:37 +08:00
|
|
|
return irq_check_poll(desc);
|
|
|
|
}
|
|
|
|
|
2006-06-29 17:24:53 +08:00
|
|
|
/**
|
|
|
|
* handle_simple_irq - Simple and software-decoded IRQs.
|
|
|
|
* @desc: the interrupt description structure for this irq
|
|
|
|
*
|
|
|
|
* Simple interrupts are either sent from a demultiplexing interrupt
|
|
|
|
* handler or come from hardware, where no interrupt hardware control
|
|
|
|
* is necessary.
|
|
|
|
*
|
|
|
|
* Note: The caller is expected to handle the ack, clear, mask and
|
|
|
|
* unmask issues if necessary.
|
|
|
|
*/
|
2015-09-14 16:42:37 +08:00
|
|
|
void handle_simple_irq(struct irq_desc *desc)
|
2006-06-29 17:24:53 +08:00
|
|
|
{
|
2009-11-17 23:46:45 +08:00
|
|
|
raw_spin_lock(&desc->lock);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2014-08-29 19:39:37 +08:00
|
|
|
if (!irq_may_run(desc))
|
|
|
|
goto out_unlock;
|
2011-02-07 17:34:30 +08:00
|
|
|
|
2011-02-08 18:39:15 +08:00
|
|
|
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2012-05-22 00:19:20 +08:00
|
|
|
if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
|
|
|
|
desc->istate |= IRQS_PENDING;
|
2006-06-29 17:24:53 +08:00
|
|
|
goto out_unlock;
|
2012-05-22 00:19:20 +08:00
|
|
|
}
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2015-11-05 02:32:37 +08:00
|
|
|
kstat_incr_irqs_this_cpu(desc);
|
2011-02-07 08:21:02 +08:00
|
|
|
handle_irq_event(desc);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
|
|
|
out_unlock:
|
2009-11-17 23:46:45 +08:00
|
|
|
raw_spin_unlock(&desc->lock);
|
2006-06-29 17:24:53 +08:00
|
|
|
}
|
2011-05-18 17:39:04 +08:00
|
|
|
EXPORT_SYMBOL_GPL(handle_simple_irq);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2016-06-18 06:00:20 +08:00
|
|
|
/**
|
|
|
|
* handle_untracked_irq - Simple and software-decoded IRQs.
|
|
|
|
* @desc: the interrupt description structure for this irq
|
|
|
|
*
|
|
|
|
* Untracked interrupts are sent from a demultiplexing interrupt
|
|
|
|
* handler when the demultiplexer does not know which device it its
|
|
|
|
* multiplexed irq domain generated the interrupt. IRQ's handled
|
|
|
|
* through here are not subjected to stats tracking, randomness, or
|
|
|
|
* spurious interrupt detection.
|
|
|
|
*
|
|
|
|
* Note: Like handle_simple_irq, the caller is expected to handle
|
|
|
|
* the ack, clear, mask and unmask issues if necessary.
|
|
|
|
*/
|
|
|
|
void handle_untracked_irq(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
raw_spin_lock(&desc->lock);
|
|
|
|
|
|
|
|
if (!irq_may_run(desc))
|
|
|
|
goto out_unlock;
|
|
|
|
|
|
|
|
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
|
|
|
|
|
|
|
|
if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
|
|
|
|
desc->istate |= IRQS_PENDING;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
desc->istate &= ~IRQS_PENDING;
|
|
|
|
irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
|
|
|
|
raw_spin_unlock(&desc->lock);
|
|
|
|
|
2021-12-07 20:17:34 +08:00
|
|
|
__handle_irq_event_percpu(desc);
|
2016-06-18 06:00:20 +08:00
|
|
|
|
|
|
|
raw_spin_lock(&desc->lock);
|
|
|
|
irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
|
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
raw_spin_unlock(&desc->lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(handle_untracked_irq);
|
|
|
|
|
2012-02-08 00:58:03 +08:00
|
|
|
/*
|
|
|
|
* Called unconditionally from handle_level_irq() and only for oneshot
|
|
|
|
* interrupts from handle_fasteoi_irq()
|
|
|
|
*/
|
|
|
|
static void cond_unmask_irq(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We need to unmask in the following cases:
|
|
|
|
* - Standard level irq (IRQF_ONESHOT is not set)
|
|
|
|
* - Oneshot irq which did not wake the thread (caused by a
|
|
|
|
* spurious interrupt or a primary handler handling it
|
|
|
|
* completely).
|
|
|
|
*/
|
|
|
|
if (!irqd_irq_disabled(&desc->irq_data) &&
|
|
|
|
irqd_irq_masked(&desc->irq_data) && !desc->threads_oneshot)
|
|
|
|
unmask_irq(desc);
|
|
|
|
}
|
|
|
|
|
2006-06-29 17:24:53 +08:00
|
|
|
/**
|
|
|
|
* handle_level_irq - Level type irq handler
|
|
|
|
* @desc: the interrupt description structure for this irq
|
|
|
|
*
|
|
|
|
* Level type interrupts are active as long as the hardware line has
|
|
|
|
* the active level. This may require to mask the interrupt and unmask
|
|
|
|
* it after the associated handler has acknowledged the device, so the
|
|
|
|
* interrupt line is back to inactive.
|
|
|
|
*/
|
2015-09-14 16:42:37 +08:00
|
|
|
void handle_level_irq(struct irq_desc *desc)
|
2006-06-29 17:24:53 +08:00
|
|
|
{
|
2009-11-17 23:46:45 +08:00
|
|
|
raw_spin_lock(&desc->lock);
|
2010-09-27 20:44:50 +08:00
|
|
|
mask_ack_irq(desc);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2014-08-29 19:39:37 +08:00
|
|
|
if (!irq_may_run(desc))
|
|
|
|
goto out_unlock;
|
2011-02-07 17:34:30 +08:00
|
|
|
|
2011-02-08 18:39:15 +08:00
|
|
|
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If its disabled or no action available
|
|
|
|
* keep it masked and get out of here
|
|
|
|
*/
|
2012-04-25 18:54:54 +08:00
|
|
|
if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
|
|
|
|
desc->istate |= IRQS_PENDING;
|
2006-09-19 17:14:34 +08:00
|
|
|
goto out_unlock;
|
2012-04-25 18:54:54 +08:00
|
|
|
}
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2015-11-05 02:32:37 +08:00
|
|
|
kstat_incr_irqs_this_cpu(desc);
|
2011-02-07 08:22:17 +08:00
|
|
|
handle_irq_event(desc);
|
2009-08-13 18:17:22 +08:00
|
|
|
|
2012-02-08 00:58:03 +08:00
|
|
|
cond_unmask_irq(desc);
|
|
|
|
|
2006-09-19 17:14:34 +08:00
|
|
|
out_unlock:
|
2009-11-17 23:46:45 +08:00
|
|
|
raw_spin_unlock(&desc->lock);
|
2006-06-29 17:24:53 +08:00
|
|
|
}
|
2009-01-14 19:34:21 +08:00
|
|
|
EXPORT_SYMBOL_GPL(handle_level_irq);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2014-03-14 02:03:51 +08:00
|
|
|
static void cond_unmask_eoi_irq(struct irq_desc *desc, struct irq_chip *chip)
|
|
|
|
{
|
|
|
|
if (!(desc->istate & IRQS_ONESHOT)) {
|
|
|
|
chip->irq_eoi(&desc->irq_data);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* We need to unmask in the following cases:
|
|
|
|
* - Oneshot irq which did not wake the thread (caused by a
|
|
|
|
* spurious interrupt or a primary handler handling it
|
|
|
|
* completely).
|
|
|
|
*/
|
|
|
|
if (!irqd_irq_disabled(&desc->irq_data) &&
|
|
|
|
irqd_irq_masked(&desc->irq_data) && !desc->threads_oneshot) {
|
|
|
|
chip->irq_eoi(&desc->irq_data);
|
|
|
|
unmask_irq(desc);
|
|
|
|
} else if (!(chip->flags & IRQCHIP_EOI_THREADED)) {
|
|
|
|
chip->irq_eoi(&desc->irq_data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-06-29 17:24:53 +08:00
|
|
|
/**
|
2006-06-29 17:25:03 +08:00
|
|
|
* handle_fasteoi_irq - irq handler for transparent controllers
|
2006-06-29 17:24:53 +08:00
|
|
|
* @desc: the interrupt description structure for this irq
|
|
|
|
*
|
2006-06-29 17:25:03 +08:00
|
|
|
* Only a single callback will be issued to the chip: an ->eoi()
|
2006-06-29 17:24:53 +08:00
|
|
|
* call when the interrupt has been serviced. This enables support
|
|
|
|
* for modern forms of interrupt handlers, which handle the flow
|
|
|
|
* details in hardware, transparently.
|
|
|
|
*/
|
2015-09-14 16:42:37 +08:00
|
|
|
void handle_fasteoi_irq(struct irq_desc *desc)
|
2006-06-29 17:24:53 +08:00
|
|
|
{
|
2014-03-14 02:03:51 +08:00
|
|
|
struct irq_chip *chip = desc->irq_data.chip;
|
|
|
|
|
2009-11-17 23:46:45 +08:00
|
|
|
raw_spin_lock(&desc->lock);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2014-08-29 19:39:37 +08:00
|
|
|
if (!irq_may_run(desc))
|
|
|
|
goto out;
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2011-02-08 18:39:15 +08:00
|
|
|
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If its disabled or no action available
|
2007-02-16 17:28:24 +08:00
|
|
|
* then mask it and get out of here:
|
2006-06-29 17:24:53 +08:00
|
|
|
*/
|
2011-03-28 20:10:52 +08:00
|
|
|
if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
|
2011-02-08 19:17:57 +08:00
|
|
|
desc->istate |= IRQS_PENDING;
|
2010-09-27 20:44:42 +08:00
|
|
|
mask_irq(desc);
|
2006-06-29 17:24:53 +08:00
|
|
|
goto out;
|
2006-06-29 17:25:01 +08:00
|
|
|
}
|
2011-03-02 18:49:21 +08:00
|
|
|
|
2015-11-05 02:32:37 +08:00
|
|
|
kstat_incr_irqs_this_cpu(desc);
|
2011-03-02 18:49:21 +08:00
|
|
|
if (desc->istate & IRQS_ONESHOT)
|
|
|
|
mask_irq(desc);
|
|
|
|
|
2011-02-07 08:23:07 +08:00
|
|
|
handle_irq_event(desc);
|
2011-02-15 17:33:57 +08:00
|
|
|
|
2014-03-14 02:03:51 +08:00
|
|
|
cond_unmask_eoi_irq(desc, chip);
|
2012-02-08 00:58:03 +08:00
|
|
|
|
2009-11-17 23:46:45 +08:00
|
|
|
raw_spin_unlock(&desc->lock);
|
2011-02-15 17:33:57 +08:00
|
|
|
return;
|
|
|
|
out:
|
2014-03-14 02:03:51 +08:00
|
|
|
if (!(chip->flags & IRQCHIP_EOI_IF_HANDLED))
|
|
|
|
chip->irq_eoi(&desc->irq_data);
|
|
|
|
raw_spin_unlock(&desc->lock);
|
2006-06-29 17:24:53 +08:00
|
|
|
}
|
2014-08-22 07:31:20 +08:00
|
|
|
EXPORT_SYMBOL_GPL(handle_fasteoi_irq);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2019-01-31 22:54:00 +08:00
|
|
|
/**
|
|
|
|
* handle_fasteoi_nmi - irq handler for NMI interrupt lines
|
|
|
|
* @desc: the interrupt description structure for this irq
|
|
|
|
*
|
|
|
|
* A simple NMI-safe handler, considering the restrictions
|
|
|
|
* from request_nmi.
|
|
|
|
*
|
|
|
|
* Only a single callback will be issued to the chip: an ->eoi()
|
|
|
|
* call when the interrupt has been serviced. This enables support
|
|
|
|
* for modern forms of interrupt handlers, which handle the flow
|
|
|
|
* details in hardware, transparently.
|
|
|
|
*/
|
|
|
|
void handle_fasteoi_nmi(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
struct irq_chip *chip = irq_desc_get_chip(desc);
|
|
|
|
struct irqaction *action = desc->action;
|
|
|
|
unsigned int irq = irq_desc_get_irq(desc);
|
|
|
|
irqreturn_t res;
|
|
|
|
|
2019-07-05 15:56:20 +08:00
|
|
|
__kstat_incr_irqs_this_cpu(desc);
|
|
|
|
|
2019-01-31 22:54:00 +08:00
|
|
|
trace_irq_handler_entry(irq, action);
|
|
|
|
/*
|
|
|
|
* NMIs cannot be shared, there is only one action.
|
|
|
|
*/
|
|
|
|
res = action->handler(irq, action->dev_id);
|
|
|
|
trace_irq_handler_exit(irq, action, res);
|
|
|
|
|
|
|
|
if (chip->irq_eoi)
|
|
|
|
chip->irq_eoi(&desc->irq_data);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(handle_fasteoi_nmi);
|
|
|
|
|
2006-06-29 17:24:53 +08:00
|
|
|
/**
|
|
|
|
* handle_edge_irq - edge type IRQ handler
|
|
|
|
* @desc: the interrupt description structure for this irq
|
|
|
|
*
|
2021-03-16 18:02:05 +08:00
|
|
|
* Interrupt occurs on the falling and/or rising edge of a hardware
|
2011-03-31 09:57:33 +08:00
|
|
|
* signal. The occurrence is latched into the irq controller hardware
|
2006-06-29 17:24:53 +08:00
|
|
|
* and must be acked in order to be reenabled. After the ack another
|
|
|
|
* interrupt can happen on the same source even before the first one
|
2010-02-13 04:58:11 +08:00
|
|
|
* is handled by the associated event handler. If this happens it
|
2006-06-29 17:24:53 +08:00
|
|
|
* might be necessary to disable (mask) the interrupt depending on the
|
|
|
|
* controller hardware. This requires to reenable the interrupt inside
|
|
|
|
* of the loop which handles the interrupts which have arrived while
|
|
|
|
* the handler was running. If all pending interrupts are handled, the
|
|
|
|
* loop is left.
|
|
|
|
*/
|
2015-09-14 16:42:37 +08:00
|
|
|
void handle_edge_irq(struct irq_desc *desc)
|
2006-06-29 17:24:53 +08:00
|
|
|
{
|
2009-11-17 23:46:45 +08:00
|
|
|
raw_spin_lock(&desc->lock);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2011-02-08 18:39:15 +08:00
|
|
|
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
|
2014-08-29 19:46:08 +08:00
|
|
|
|
2014-08-29 19:39:37 +08:00
|
|
|
if (!irq_may_run(desc)) {
|
|
|
|
desc->istate |= IRQS_PENDING;
|
|
|
|
mask_ack_irq(desc);
|
|
|
|
goto out_unlock;
|
2006-06-29 17:24:53 +08:00
|
|
|
}
|
2014-08-29 19:46:08 +08:00
|
|
|
|
2006-06-29 17:24:53 +08:00
|
|
|
/*
|
2014-08-29 19:46:08 +08:00
|
|
|
* If its disabled or no action available then mask it and get
|
|
|
|
* out of here.
|
2006-06-29 17:24:53 +08:00
|
|
|
*/
|
2014-08-29 19:46:08 +08:00
|
|
|
if (irqd_irq_disabled(&desc->irq_data) || !desc->action) {
|
|
|
|
desc->istate |= IRQS_PENDING;
|
|
|
|
mask_ack_irq(desc);
|
|
|
|
goto out_unlock;
|
2006-06-29 17:24:53 +08:00
|
|
|
}
|
2014-08-29 19:46:08 +08:00
|
|
|
|
2015-06-04 12:13:25 +08:00
|
|
|
kstat_incr_irqs_this_cpu(desc);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
|
|
|
/* Start handling the irq */
|
2010-09-27 20:44:47 +08:00
|
|
|
desc->irq_data.chip->irq_ack(&desc->irq_data);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
|
|
|
do {
|
2011-02-07 08:24:07 +08:00
|
|
|
if (unlikely(!desc->action)) {
|
2010-09-27 20:44:42 +08:00
|
|
|
mask_irq(desc);
|
2006-06-29 17:24:53 +08:00
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When another irq arrived while we were handling
|
|
|
|
* one, we could have masked the irq.
|
2021-03-22 11:21:30 +08:00
|
|
|
* Reenable it, if it was not disabled in meantime.
|
2006-06-29 17:24:53 +08:00
|
|
|
*/
|
2011-02-08 19:17:57 +08:00
|
|
|
if (unlikely(desc->istate & IRQS_PENDING)) {
|
2011-03-28 20:10:52 +08:00
|
|
|
if (!irqd_irq_disabled(&desc->irq_data) &&
|
|
|
|
irqd_irq_masked(&desc->irq_data))
|
2011-02-08 05:11:30 +08:00
|
|
|
unmask_irq(desc);
|
2006-06-29 17:24:53 +08:00
|
|
|
}
|
|
|
|
|
2011-02-07 08:24:07 +08:00
|
|
|
handle_irq_event(desc);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2011-02-08 19:17:57 +08:00
|
|
|
} while ((desc->istate & IRQS_PENDING) &&
|
2011-03-28 20:10:52 +08:00
|
|
|
!irqd_irq_disabled(&desc->irq_data));
|
2006-06-29 17:24:53 +08:00
|
|
|
|
|
|
|
out_unlock:
|
2009-11-17 23:46:45 +08:00
|
|
|
raw_spin_unlock(&desc->lock);
|
2006-06-29 17:24:53 +08:00
|
|
|
}
|
2012-05-13 18:13:15 +08:00
|
|
|
EXPORT_SYMBOL(handle_edge_irq);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2011-03-28 22:13:24 +08:00
|
|
|
#ifdef CONFIG_IRQ_EDGE_EOI_HANDLER
|
|
|
|
/**
|
|
|
|
* handle_edge_eoi_irq - edge eoi type IRQ handler
|
|
|
|
* @desc: the interrupt description structure for this irq
|
|
|
|
*
|
|
|
|
* Similar as the above handle_edge_irq, but using eoi and w/o the
|
|
|
|
* mask/unmask logic.
|
|
|
|
*/
|
2015-09-14 16:42:37 +08:00
|
|
|
void handle_edge_eoi_irq(struct irq_desc *desc)
|
2011-03-28 22:13:24 +08:00
|
|
|
{
|
|
|
|
struct irq_chip *chip = irq_desc_get_chip(desc);
|
|
|
|
|
|
|
|
raw_spin_lock(&desc->lock);
|
|
|
|
|
|
|
|
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
|
2014-08-29 19:46:08 +08:00
|
|
|
|
2014-08-29 19:39:37 +08:00
|
|
|
if (!irq_may_run(desc)) {
|
|
|
|
desc->istate |= IRQS_PENDING;
|
|
|
|
goto out_eoi;
|
2011-03-28 22:13:24 +08:00
|
|
|
}
|
2014-08-29 19:46:08 +08:00
|
|
|
|
2011-03-28 22:13:24 +08:00
|
|
|
/*
|
2014-08-29 19:46:08 +08:00
|
|
|
* If its disabled or no action available then mask it and get
|
|
|
|
* out of here.
|
2011-03-28 22:13:24 +08:00
|
|
|
*/
|
2014-08-29 19:46:08 +08:00
|
|
|
if (irqd_irq_disabled(&desc->irq_data) || !desc->action) {
|
|
|
|
desc->istate |= IRQS_PENDING;
|
|
|
|
goto out_eoi;
|
2011-03-28 22:13:24 +08:00
|
|
|
}
|
2014-08-29 19:46:08 +08:00
|
|
|
|
2015-06-04 12:13:25 +08:00
|
|
|
kstat_incr_irqs_this_cpu(desc);
|
2011-03-28 22:13:24 +08:00
|
|
|
|
|
|
|
do {
|
|
|
|
if (unlikely(!desc->action))
|
|
|
|
goto out_eoi;
|
|
|
|
|
|
|
|
handle_irq_event(desc);
|
|
|
|
|
|
|
|
} while ((desc->istate & IRQS_PENDING) &&
|
|
|
|
!irqd_irq_disabled(&desc->irq_data));
|
|
|
|
|
2011-03-30 07:55:12 +08:00
|
|
|
out_eoi:
|
2011-03-28 22:13:24 +08:00
|
|
|
chip->irq_eoi(&desc->irq_data);
|
|
|
|
raw_spin_unlock(&desc->lock);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-06-29 17:24:53 +08:00
|
|
|
/**
|
2009-11-04 20:11:05 +08:00
|
|
|
* handle_percpu_irq - Per CPU local irq handler
|
2006-06-29 17:24:53 +08:00
|
|
|
* @desc: the interrupt description structure for this irq
|
|
|
|
*
|
|
|
|
* Per CPU interrupts on SMP machines without locking requirements
|
|
|
|
*/
|
2015-09-14 16:42:37 +08:00
|
|
|
void handle_percpu_irq(struct irq_desc *desc)
|
2006-06-29 17:24:53 +08:00
|
|
|
{
|
2011-02-10 19:20:23 +08:00
|
|
|
struct irq_chip *chip = irq_desc_get_chip(desc);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2019-02-08 21:48:03 +08:00
|
|
|
/*
|
|
|
|
* PER CPU interrupts are not serialized. Do not touch
|
|
|
|
* desc->tot_count.
|
|
|
|
*/
|
|
|
|
__kstat_incr_irqs_this_cpu(desc);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2011-02-07 08:25:41 +08:00
|
|
|
if (chip->irq_ack)
|
|
|
|
chip->irq_ack(&desc->irq_data);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2015-09-02 10:24:55 +08:00
|
|
|
handle_irq_event_percpu(desc);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2011-02-07 08:25:41 +08:00
|
|
|
if (chip->irq_eoi)
|
|
|
|
chip->irq_eoi(&desc->irq_data);
|
2006-06-29 17:24:53 +08:00
|
|
|
}
|
|
|
|
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-24 00:03:06 +08:00
|
|
|
/**
|
|
|
|
* handle_percpu_devid_irq - Per CPU local irq handler with per cpu dev ids
|
|
|
|
* @desc: the interrupt description structure for this irq
|
|
|
|
*
|
|
|
|
* Per CPU interrupts on SMP machines without locking requirements. Same as
|
|
|
|
* handle_percpu_irq() above but with the following extras:
|
|
|
|
*
|
|
|
|
* action->percpu_dev_id is a pointer to percpu variables which
|
|
|
|
* contain the real device id for the cpu on which this handler is
|
|
|
|
* called
|
|
|
|
*/
|
2015-09-14 16:42:37 +08:00
|
|
|
void handle_percpu_devid_irq(struct irq_desc *desc)
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-24 00:03:06 +08:00
|
|
|
{
|
|
|
|
struct irq_chip *chip = irq_desc_get_chip(desc);
|
|
|
|
struct irqaction *action = desc->action;
|
2015-09-14 16:42:37 +08:00
|
|
|
unsigned int irq = irq_desc_get_irq(desc);
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-24 00:03:06 +08:00
|
|
|
irqreturn_t res;
|
|
|
|
|
2019-02-08 21:48:03 +08:00
|
|
|
/*
|
|
|
|
* PER CPU interrupts are not serialized. Do not touch
|
|
|
|
* desc->tot_count.
|
|
|
|
*/
|
|
|
|
__kstat_incr_irqs_this_cpu(desc);
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-24 00:03:06 +08:00
|
|
|
|
|
|
|
if (chip->irq_ack)
|
|
|
|
chip->irq_ack(&desc->irq_data);
|
|
|
|
|
2016-09-02 20:45:19 +08:00
|
|
|
if (likely(action)) {
|
|
|
|
trace_irq_handler_entry(irq, action);
|
|
|
|
res = action->handler(irq, raw_cpu_ptr(action->percpu_dev_id));
|
|
|
|
trace_irq_handler_exit(irq, action, res);
|
|
|
|
} else {
|
|
|
|
unsigned int cpu = smp_processor_id();
|
|
|
|
bool enabled = cpumask_test_cpu(cpu, desc->percpu_enabled);
|
|
|
|
|
|
|
|
if (enabled)
|
|
|
|
irq_percpu_disable(desc, cpu);
|
|
|
|
|
|
|
|
pr_err_once("Spurious%s percpu IRQ%u on CPU%u\n",
|
|
|
|
enabled ? " and unmasked" : "", irq, cpu);
|
|
|
|
}
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-24 00:03:06 +08:00
|
|
|
|
|
|
|
if (chip->irq_eoi)
|
|
|
|
chip->irq_eoi(&desc->irq_data);
|
|
|
|
}
|
|
|
|
|
2019-01-31 22:54:00 +08:00
|
|
|
/**
|
|
|
|
* handle_percpu_devid_fasteoi_nmi - Per CPU local NMI handler with per cpu
|
|
|
|
* dev ids
|
|
|
|
* @desc: the interrupt description structure for this irq
|
|
|
|
*
|
|
|
|
* Similar to handle_fasteoi_nmi, but handling the dev_id cookie
|
|
|
|
* as a percpu pointer.
|
|
|
|
*/
|
|
|
|
void handle_percpu_devid_fasteoi_nmi(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
struct irq_chip *chip = irq_desc_get_chip(desc);
|
|
|
|
struct irqaction *action = desc->action;
|
|
|
|
unsigned int irq = irq_desc_get_irq(desc);
|
|
|
|
irqreturn_t res;
|
|
|
|
|
2019-07-05 15:56:20 +08:00
|
|
|
__kstat_incr_irqs_this_cpu(desc);
|
|
|
|
|
2019-01-31 22:54:00 +08:00
|
|
|
trace_irq_handler_entry(irq, action);
|
|
|
|
res = action->handler(irq, raw_cpu_ptr(action->percpu_dev_id));
|
|
|
|
trace_irq_handler_exit(irq, action, res);
|
|
|
|
|
|
|
|
if (chip->irq_eoi)
|
|
|
|
chip->irq_eoi(&desc->irq_data);
|
|
|
|
}
|
|
|
|
|
2016-09-25 23:36:39 +08:00
|
|
|
static void
|
2015-06-17 06:06:20 +08:00
|
|
|
__irq_do_set_handler(struct irq_desc *desc, irq_flow_handler_t handle,
|
|
|
|
int is_chained, const char *name)
|
2006-06-29 17:24:53 +08:00
|
|
|
{
|
2011-02-15 03:16:43 +08:00
|
|
|
if (!handle) {
|
2006-06-29 17:24:53 +08:00
|
|
|
handle = handle_bad_irq;
|
2011-02-15 03:16:43 +08:00
|
|
|
} else {
|
2014-11-15 18:49:13 +08:00
|
|
|
struct irq_data *irq_data = &desc->irq_data;
|
|
|
|
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
|
|
|
|
/*
|
|
|
|
* With hierarchical domains we might run into a
|
|
|
|
* situation where the outermost chip is not yet set
|
|
|
|
* up, but the inner chips are there. Instead of
|
|
|
|
* bailing we install the handler, but obviously we
|
|
|
|
* cannot enable/startup the interrupt at this point.
|
|
|
|
*/
|
|
|
|
while (irq_data) {
|
|
|
|
if (irq_data->chip != &no_irq_chip)
|
|
|
|
break;
|
|
|
|
/*
|
|
|
|
* Bail out if the outer chip is not set up
|
2018-12-03 18:44:51 +08:00
|
|
|
* and the interrupt supposed to be started
|
2014-11-15 18:49:13 +08:00
|
|
|
* right away.
|
|
|
|
*/
|
|
|
|
if (WARN_ON(is_chained))
|
2015-06-17 06:06:20 +08:00
|
|
|
return;
|
2014-11-15 18:49:13 +08:00
|
|
|
/* Try the parent */
|
|
|
|
irq_data = irq_data->parent_data;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if (WARN_ON(!irq_data || irq_data->chip == &no_irq_chip))
|
2015-06-17 06:06:20 +08:00
|
|
|
return;
|
2006-07-02 05:30:08 +08:00
|
|
|
}
|
2006-06-29 17:24:53 +08:00
|
|
|
|
|
|
|
/* Uninstall? */
|
|
|
|
if (handle == handle_bad_irq) {
|
2010-10-01 18:58:38 +08:00
|
|
|
if (desc->irq_data.chip != &no_irq_chip)
|
2010-09-27 20:44:50 +08:00
|
|
|
mask_ack_irq(desc);
|
2011-03-27 17:02:49 +08:00
|
|
|
irq_state_set_disabled(desc);
|
2022-06-08 21:45:35 +08:00
|
|
|
if (is_chained) {
|
genirq: Allow migration of chained interrupts by installing default action
When a CPU is offlined all interrupts that have an action are migrated to
other still online CPUs. However, if the interrupt has chained handler
installed this is not done. Chained handlers are used by GPIO drivers which
support interrupts, for instance.
When the affinity is not corrected properly we end up in situation where
most interrupts are not arriving to the online CPUs anymore. For example on
Intel Braswell system which has SD-card card detection signal connected to
a GPIO the IO-APIC routing entries look like below after CPU1 is offlined:
pin30, enabled , level, low , V(52), IRR(0), S(0), logical , D(03), M(1)
pin31, enabled , level, low , V(42), IRR(0), S(0), logical , D(03), M(1)
pin32, enabled , level, low , V(62), IRR(0), S(0), logical , D(03), M(1)
pin5b, enabled , level, low , V(72), IRR(0), S(0), logical , D(03), M(1)
The problem here is that the destination mask still contains both CPUs even
if CPU1 is already offline. This means that the IO-APIC still routes
interrupts to the other CPU as well.
We solve the problem by providing a default action for chained interrupts.
This action allows the migration code to correct affinity (as it finds
desc->action != NULL).
Also make the default action handler to emit a warning if for some reason a
chained handler ends up calling it.
Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Cc: Jiang Liu <jiang.liu@linux.intel.com>
Link: http://lkml.kernel.org/r/1444039935-30475-1-git-send-email-mika.westerberg@linux.intel.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2015-10-05 18:12:15 +08:00
|
|
|
desc->action = NULL;
|
2022-06-08 21:45:35 +08:00
|
|
|
WARN_ON(irq_chip_pm_put(irq_desc_get_irq_data(desc)));
|
|
|
|
}
|
2006-06-29 17:24:53 +08:00
|
|
|
desc->depth = 1;
|
|
|
|
}
|
|
|
|
desc->handle_irq = handle;
|
2006-10-17 15:10:03 +08:00
|
|
|
desc->name = name;
|
2006-06-29 17:24:53 +08:00
|
|
|
|
|
|
|
if (handle != handle_bad_irq && is_chained) {
|
2016-09-19 16:49:27 +08:00
|
|
|
unsigned int type = irqd_get_trigger_type(&desc->irq_data);
|
|
|
|
|
2016-08-11 21:19:42 +08:00
|
|
|
/*
|
|
|
|
* We're about to start this interrupt immediately,
|
|
|
|
* hence the need to set the trigger configuration.
|
|
|
|
* But the .set_type callback may have overridden the
|
|
|
|
* flow handler, ignoring that we're dealing with a
|
|
|
|
* chained interrupt. Reset it immediately because we
|
|
|
|
* do know better.
|
|
|
|
*/
|
2016-09-19 16:49:27 +08:00
|
|
|
if (type != IRQ_TYPE_NONE) {
|
|
|
|
__irq_set_trigger(desc, type);
|
|
|
|
desc->handle_irq = handle;
|
|
|
|
}
|
2016-08-11 21:19:42 +08:00
|
|
|
|
2011-02-09 21:44:17 +08:00
|
|
|
irq_settings_set_noprobe(desc);
|
|
|
|
irq_settings_set_norequest(desc);
|
2011-04-07 05:01:44 +08:00
|
|
|
irq_settings_set_nothread(desc);
|
genirq: Allow migration of chained interrupts by installing default action
When a CPU is offlined all interrupts that have an action are migrated to
other still online CPUs. However, if the interrupt has chained handler
installed this is not done. Chained handlers are used by GPIO drivers which
support interrupts, for instance.
When the affinity is not corrected properly we end up in situation where
most interrupts are not arriving to the online CPUs anymore. For example on
Intel Braswell system which has SD-card card detection signal connected to
a GPIO the IO-APIC routing entries look like below after CPU1 is offlined:
pin30, enabled , level, low , V(52), IRR(0), S(0), logical , D(03), M(1)
pin31, enabled , level, low , V(42), IRR(0), S(0), logical , D(03), M(1)
pin32, enabled , level, low , V(62), IRR(0), S(0), logical , D(03), M(1)
pin5b, enabled , level, low , V(72), IRR(0), S(0), logical , D(03), M(1)
The problem here is that the destination mask still contains both CPUs even
if CPU1 is already offline. This means that the IO-APIC still routes
interrupts to the other CPU as well.
We solve the problem by providing a default action for chained interrupts.
This action allows the migration code to correct affinity (as it finds
desc->action != NULL).
Also make the default action handler to emit a warning if for some reason a
chained handler ends up calling it.
Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Cc: Jiang Liu <jiang.liu@linux.intel.com>
Link: http://lkml.kernel.org/r/1444039935-30475-1-git-send-email-mika.westerberg@linux.intel.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2015-10-05 18:12:15 +08:00
|
|
|
desc->action = &chained_action;
|
2022-06-08 21:45:35 +08:00
|
|
|
WARN_ON(irq_chip_pm_get(irq_desc_get_irq_data(desc)));
|
2017-09-14 05:29:09 +08:00
|
|
|
irq_activate_and_startup(desc, IRQ_RESEND);
|
2006-06-29 17:24:53 +08:00
|
|
|
}
|
2015-06-17 06:06:20 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
__irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, 0);
|
|
|
|
|
|
|
|
if (!desc)
|
|
|
|
return;
|
|
|
|
|
|
|
|
__irq_do_set_handler(desc, handle, is_chained, name);
|
2011-02-12 17:37:36 +08:00
|
|
|
irq_put_desc_busunlock(desc, flags);
|
2006-06-29 17:24:53 +08:00
|
|
|
}
|
2011-02-15 03:09:19 +08:00
|
|
|
EXPORT_SYMBOL_GPL(__irq_set_handler);
|
2006-06-29 17:24:53 +08:00
|
|
|
|
2015-06-17 06:06:20 +08:00
|
|
|
void
|
|
|
|
irq_set_chained_handler_and_data(unsigned int irq, irq_flow_handler_t handle,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, 0);
|
|
|
|
|
|
|
|
if (!desc)
|
|
|
|
return;
|
|
|
|
|
2015-06-01 16:05:21 +08:00
|
|
|
desc->irq_common_data.handler_data = data;
|
2017-05-11 19:54:11 +08:00
|
|
|
__irq_do_set_handler(desc, handle, 1, NULL);
|
2015-06-17 06:06:20 +08:00
|
|
|
|
|
|
|
irq_put_desc_busunlock(desc, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(irq_set_chained_handler_and_data);
|
|
|
|
|
2006-06-29 17:24:53 +08:00
|
|
|
void
|
2022-02-10 00:25:59 +08:00
|
|
|
irq_set_chip_and_handler_name(unsigned int irq, const struct irq_chip *chip,
|
2006-10-17 15:10:03 +08:00
|
|
|
irq_flow_handler_t handle, const char *name)
|
2006-06-29 17:24:53 +08:00
|
|
|
{
|
2011-02-10 19:20:23 +08:00
|
|
|
irq_set_chip(irq, chip);
|
2011-02-15 03:09:19 +08:00
|
|
|
__irq_set_handler(irq, handle, 0, name);
|
2006-06-29 17:24:53 +08:00
|
|
|
}
|
2012-07-31 13:39:06 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_set_chip_and_handler_name);
|
2008-02-08 20:22:01 +08:00
|
|
|
|
2010-09-28 16:40:18 +08:00
|
|
|
void irq_modify_status(unsigned int irq, unsigned long clr, unsigned long set)
|
2008-02-08 20:22:01 +08:00
|
|
|
{
|
2017-08-18 17:53:45 +08:00
|
|
|
unsigned long flags, trigger, tmp;
|
genirq: Add support for per-cpu dev_id interrupts
The ARM GIC interrupt controller offers per CPU interrupts (PPIs),
which are usually used to connect local timers to each core. Each CPU
has its own private interface to the GIC, and only sees the PPIs that
are directly connect to it.
While these timers are separate devices and have a separate interrupt
line to a core, they all use the same IRQ number.
For these devices, request_irq() is not the right API as it assumes
that an IRQ number is visible by a number of CPUs (through the
affinity setting), but makes it very awkward to express that an IRQ
number can be handled by all CPUs, and yet be a different interrupt
line on each CPU, requiring a different dev_id cookie to be passed
back to the handler.
The *_percpu_irq() functions is designed to overcome these
limitations, by providing a per-cpu dev_id vector:
int request_percpu_irq(unsigned int irq, irq_handler_t handler,
const char *devname, void __percpu *percpu_dev_id);
void free_percpu_irq(unsigned int, void __percpu *);
int setup_percpu_irq(unsigned int irq, struct irqaction *new);
void remove_percpu_irq(unsigned int irq, struct irqaction *act);
void enable_percpu_irq(unsigned int irq);
void disable_percpu_irq(unsigned int irq);
The API has a number of limitations:
- no interrupt sharing
- no threading
- common handler across all the CPUs
Once the interrupt is requested using setup_percpu_irq() or
request_percpu_irq(), it must be enabled by each core that wishes its
local interrupt to be delivered.
Based on an initial patch by Thomas Gleixner.
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1316793788-14500-2-git-send-email-marc.zyngier@arm.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
2011-09-24 00:03:06 +08:00
|
|
|
struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
|
2008-02-08 20:22:01 +08:00
|
|
|
|
2010-09-28 16:40:18 +08:00
|
|
|
if (!desc)
|
2008-02-08 20:22:01 +08:00
|
|
|
return;
|
2017-05-31 17:58:33 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Warn when a driver sets the no autoenable flag on an already
|
|
|
|
* active interrupt.
|
|
|
|
*/
|
|
|
|
WARN_ON_ONCE(!desc->depth && (set & _IRQ_NOAUTOEN));
|
|
|
|
|
2011-02-09 00:11:03 +08:00
|
|
|
irq_settings_clr_and_set(desc, clr, set);
|
|
|
|
|
2017-08-18 17:53:45 +08:00
|
|
|
trigger = irqd_get_trigger_type(&desc->irq_data);
|
|
|
|
|
2011-02-09 00:28:12 +08:00
|
|
|
irqd_clear(&desc->irq_data, IRQD_NO_BALANCING | IRQD_PER_CPU |
|
2011-02-11 05:25:31 +08:00
|
|
|
IRQD_TRIGGER_MASK | IRQD_LEVEL | IRQD_MOVE_PCNTXT);
|
2011-02-09 00:11:03 +08:00
|
|
|
if (irq_settings_has_no_balance_set(desc))
|
|
|
|
irqd_set(&desc->irq_data, IRQD_NO_BALANCING);
|
|
|
|
if (irq_settings_is_per_cpu(desc))
|
|
|
|
irqd_set(&desc->irq_data, IRQD_PER_CPU);
|
2011-02-11 05:25:31 +08:00
|
|
|
if (irq_settings_can_move_pcntxt(desc))
|
|
|
|
irqd_set(&desc->irq_data, IRQD_MOVE_PCNTXT);
|
2011-03-29 03:59:37 +08:00
|
|
|
if (irq_settings_is_level(desc))
|
|
|
|
irqd_set(&desc->irq_data, IRQD_LEVEL);
|
2011-02-09 00:11:03 +08:00
|
|
|
|
2017-08-18 17:53:45 +08:00
|
|
|
tmp = irq_settings_get_trigger_mask(desc);
|
|
|
|
if (tmp != IRQ_TYPE_NONE)
|
|
|
|
trigger = tmp;
|
|
|
|
|
|
|
|
irqd_set(&desc->irq_data, trigger);
|
2011-02-09 00:28:12 +08:00
|
|
|
|
2011-02-12 17:37:36 +08:00
|
|
|
irq_put_desc_unlock(desc, flags);
|
2008-02-08 20:22:01 +08:00
|
|
|
}
|
2011-05-18 17:39:04 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_modify_status);
|
2011-03-26 03:38:49 +08:00
|
|
|
|
2021-10-22 01:04:14 +08:00
|
|
|
#ifdef CONFIG_DEPRECATED_IRQ_CPU_ONOFFLINE
|
2011-03-26 03:38:49 +08:00
|
|
|
/**
|
|
|
|
* irq_cpu_online - Invoke all irq_cpu_online functions.
|
|
|
|
*
|
|
|
|
* Iterate through all irqs and invoke the chip.irq_cpu_online()
|
|
|
|
* for each.
|
|
|
|
*/
|
|
|
|
void irq_cpu_online(void)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc;
|
|
|
|
struct irq_chip *chip;
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned int irq;
|
|
|
|
|
|
|
|
for_each_active_irq(irq) {
|
|
|
|
desc = irq_to_desc(irq);
|
|
|
|
if (!desc)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
|
|
|
|
|
|
|
chip = irq_data_get_irq_chip(&desc->irq_data);
|
2011-03-27 22:05:36 +08:00
|
|
|
if (chip && chip->irq_cpu_online &&
|
|
|
|
(!(chip->flags & IRQCHIP_ONOFFLINE_ENABLED) ||
|
2011-03-28 20:10:52 +08:00
|
|
|
!irqd_irq_disabled(&desc->irq_data)))
|
2011-03-26 03:38:49 +08:00
|
|
|
chip->irq_cpu_online(&desc->irq_data);
|
|
|
|
|
|
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* irq_cpu_offline - Invoke all irq_cpu_offline functions.
|
|
|
|
*
|
|
|
|
* Iterate through all irqs and invoke the chip.irq_cpu_offline()
|
|
|
|
* for each.
|
|
|
|
*/
|
|
|
|
void irq_cpu_offline(void)
|
|
|
|
{
|
|
|
|
struct irq_desc *desc;
|
|
|
|
struct irq_chip *chip;
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned int irq;
|
|
|
|
|
|
|
|
for_each_active_irq(irq) {
|
|
|
|
desc = irq_to_desc(irq);
|
|
|
|
if (!desc)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
|
|
|
|
|
|
|
chip = irq_data_get_irq_chip(&desc->irq_data);
|
2011-03-27 22:05:36 +08:00
|
|
|
if (chip && chip->irq_cpu_offline &&
|
|
|
|
(!(chip->flags & IRQCHIP_ONOFFLINE_ENABLED) ||
|
2011-03-28 20:10:52 +08:00
|
|
|
!irqd_irq_disabled(&desc->irq_data)))
|
2011-03-26 03:38:49 +08:00
|
|
|
chip->irq_cpu_offline(&desc->irq_data);
|
|
|
|
|
|
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
|
|
|
}
|
|
|
|
}
|
2021-10-22 01:04:14 +08:00
|
|
|
#endif
|
2014-11-06 22:20:16 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
|
2017-08-18 08:53:31 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_IRQ_FASTEOI_HIERARCHY_HANDLERS
|
|
|
|
/**
|
|
|
|
* handle_fasteoi_ack_irq - irq handler for edge hierarchy
|
|
|
|
* stacked on transparent controllers
|
|
|
|
*
|
|
|
|
* @desc: the interrupt description structure for this irq
|
|
|
|
*
|
|
|
|
* Like handle_fasteoi_irq(), but for use with hierarchy where
|
|
|
|
* the irq_chip also needs to have its ->irq_ack() function
|
|
|
|
* called.
|
|
|
|
*/
|
|
|
|
void handle_fasteoi_ack_irq(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
struct irq_chip *chip = desc->irq_data.chip;
|
|
|
|
|
|
|
|
raw_spin_lock(&desc->lock);
|
|
|
|
|
|
|
|
if (!irq_may_run(desc))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If its disabled or no action available
|
|
|
|
* then mask it and get out of here:
|
|
|
|
*/
|
|
|
|
if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
|
|
|
|
desc->istate |= IRQS_PENDING;
|
|
|
|
mask_irq(desc);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
kstat_incr_irqs_this_cpu(desc);
|
|
|
|
if (desc->istate & IRQS_ONESHOT)
|
|
|
|
mask_irq(desc);
|
|
|
|
|
|
|
|
/* Start handling the irq */
|
|
|
|
desc->irq_data.chip->irq_ack(&desc->irq_data);
|
|
|
|
|
|
|
|
handle_irq_event(desc);
|
|
|
|
|
|
|
|
cond_unmask_eoi_irq(desc, chip);
|
|
|
|
|
|
|
|
raw_spin_unlock(&desc->lock);
|
|
|
|
return;
|
|
|
|
out:
|
|
|
|
if (!(chip->flags & IRQCHIP_EOI_IF_HANDLED))
|
|
|
|
chip->irq_eoi(&desc->irq_data);
|
|
|
|
raw_spin_unlock(&desc->lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(handle_fasteoi_ack_irq);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* handle_fasteoi_mask_irq - irq handler for level hierarchy
|
|
|
|
* stacked on transparent controllers
|
|
|
|
*
|
|
|
|
* @desc: the interrupt description structure for this irq
|
|
|
|
*
|
|
|
|
* Like handle_fasteoi_irq(), but for use with hierarchy where
|
|
|
|
* the irq_chip also needs to have its ->irq_mask_ack() function
|
|
|
|
* called.
|
|
|
|
*/
|
|
|
|
void handle_fasteoi_mask_irq(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
struct irq_chip *chip = desc->irq_data.chip;
|
|
|
|
|
|
|
|
raw_spin_lock(&desc->lock);
|
|
|
|
mask_ack_irq(desc);
|
|
|
|
|
|
|
|
if (!irq_may_run(desc))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If its disabled or no action available
|
|
|
|
* then mask it and get out of here:
|
|
|
|
*/
|
|
|
|
if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
|
|
|
|
desc->istate |= IRQS_PENDING;
|
|
|
|
mask_irq(desc);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
kstat_incr_irqs_this_cpu(desc);
|
|
|
|
if (desc->istate & IRQS_ONESHOT)
|
|
|
|
mask_irq(desc);
|
|
|
|
|
|
|
|
handle_irq_event(desc);
|
|
|
|
|
|
|
|
cond_unmask_eoi_irq(desc, chip);
|
|
|
|
|
|
|
|
raw_spin_unlock(&desc->lock);
|
|
|
|
return;
|
|
|
|
out:
|
|
|
|
if (!(chip->flags & IRQCHIP_EOI_IF_HANDLED))
|
|
|
|
chip->irq_eoi(&desc->irq_data);
|
|
|
|
raw_spin_unlock(&desc->lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(handle_fasteoi_mask_irq);
|
|
|
|
|
|
|
|
#endif /* CONFIG_IRQ_FASTEOI_HIERARCHY_HANDLERS */
|
|
|
|
|
2019-11-16 06:11:49 +08:00
|
|
|
/**
|
|
|
|
* irq_chip_set_parent_state - set the state of a parent interrupt.
|
|
|
|
*
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
* @which: State to be restored (one of IRQCHIP_STATE_*)
|
|
|
|
* @val: Value corresponding to @which
|
|
|
|
*
|
|
|
|
* Conditional success, if the underlying irqchip does not implement it.
|
|
|
|
*/
|
|
|
|
int irq_chip_set_parent_state(struct irq_data *data,
|
|
|
|
enum irqchip_irq_state which,
|
|
|
|
bool val)
|
|
|
|
{
|
|
|
|
data = data->parent_data;
|
|
|
|
|
|
|
|
if (!data || !data->chip->irq_set_irqchip_state)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return data->chip->irq_set_irqchip_state(data, which, val);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(irq_chip_set_parent_state);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* irq_chip_get_parent_state - get the state of a parent interrupt.
|
|
|
|
*
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
* @which: one of IRQCHIP_STATE_* the caller wants to know
|
|
|
|
* @state: a pointer to a boolean where the state is to be stored
|
|
|
|
*
|
|
|
|
* Conditional success, if the underlying irqchip does not implement it.
|
|
|
|
*/
|
|
|
|
int irq_chip_get_parent_state(struct irq_data *data,
|
|
|
|
enum irqchip_irq_state which,
|
|
|
|
bool *state)
|
|
|
|
{
|
|
|
|
data = data->parent_data;
|
|
|
|
|
|
|
|
if (!data || !data->chip->irq_get_irqchip_state)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return data->chip->irq_get_irqchip_state(data, which, state);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(irq_chip_get_parent_state);
|
|
|
|
|
2015-05-16 17:44:14 +08:00
|
|
|
/**
|
|
|
|
* irq_chip_enable_parent - Enable the parent interrupt (defaults to unmask if
|
|
|
|
* NULL)
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
*/
|
|
|
|
void irq_chip_enable_parent(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data = data->parent_data;
|
|
|
|
if (data->chip->irq_enable)
|
|
|
|
data->chip->irq_enable(data);
|
|
|
|
else
|
|
|
|
data->chip->irq_unmask(data);
|
|
|
|
}
|
2017-08-18 08:53:30 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_chip_enable_parent);
|
2015-05-16 17:44:14 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* irq_chip_disable_parent - Disable the parent interrupt (defaults to mask if
|
|
|
|
* NULL)
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
*/
|
|
|
|
void irq_chip_disable_parent(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data = data->parent_data;
|
|
|
|
if (data->chip->irq_disable)
|
|
|
|
data->chip->irq_disable(data);
|
|
|
|
else
|
|
|
|
data->chip->irq_mask(data);
|
|
|
|
}
|
2017-08-18 08:53:30 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_chip_disable_parent);
|
2015-05-16 17:44:14 +08:00
|
|
|
|
2014-11-06 22:20:16 +08:00
|
|
|
/**
|
|
|
|
* irq_chip_ack_parent - Acknowledge the parent interrupt
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
*/
|
|
|
|
void irq_chip_ack_parent(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data = data->parent_data;
|
|
|
|
data->chip->irq_ack(data);
|
|
|
|
}
|
2015-12-11 01:52:59 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_chip_ack_parent);
|
2014-11-06 22:20:16 +08:00
|
|
|
|
2014-11-13 23:37:05 +08:00
|
|
|
/**
|
|
|
|
* irq_chip_mask_parent - Mask the parent interrupt
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
*/
|
|
|
|
void irq_chip_mask_parent(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data = data->parent_data;
|
|
|
|
data->chip->irq_mask(data);
|
|
|
|
}
|
2016-03-03 22:56:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_chip_mask_parent);
|
2014-11-13 23:37:05 +08:00
|
|
|
|
2019-02-08 10:16:23 +08:00
|
|
|
/**
|
|
|
|
* irq_chip_mask_ack_parent - Mask and acknowledge the parent interrupt
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
*/
|
|
|
|
void irq_chip_mask_ack_parent(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data = data->parent_data;
|
|
|
|
data->chip->irq_mask_ack(data);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(irq_chip_mask_ack_parent);
|
|
|
|
|
2014-11-13 23:37:05 +08:00
|
|
|
/**
|
|
|
|
* irq_chip_unmask_parent - Unmask the parent interrupt
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
*/
|
|
|
|
void irq_chip_unmask_parent(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data = data->parent_data;
|
|
|
|
data->chip->irq_unmask(data);
|
|
|
|
}
|
2016-03-03 22:56:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_chip_unmask_parent);
|
2014-11-13 23:37:05 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* irq_chip_eoi_parent - Invoke EOI on the parent interrupt
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
*/
|
|
|
|
void irq_chip_eoi_parent(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data = data->parent_data;
|
|
|
|
data->chip->irq_eoi(data);
|
|
|
|
}
|
2016-03-03 22:56:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_chip_eoi_parent);
|
2014-11-13 23:37:05 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* irq_chip_set_affinity_parent - Set affinity on the parent interrupt
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
* @dest: The affinity mask to set
|
|
|
|
* @force: Flag to enforce setting (disable online checks)
|
|
|
|
*
|
2021-03-16 18:02:05 +08:00
|
|
|
* Conditional, as the underlying parent chip might not implement it.
|
2014-11-13 23:37:05 +08:00
|
|
|
*/
|
|
|
|
int irq_chip_set_affinity_parent(struct irq_data *data,
|
|
|
|
const struct cpumask *dest, bool force)
|
|
|
|
{
|
|
|
|
data = data->parent_data;
|
|
|
|
if (data->chip->irq_set_affinity)
|
|
|
|
return data->chip->irq_set_affinity(data, dest, force);
|
2015-08-14 20:20:26 +08:00
|
|
|
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
2017-08-18 08:53:30 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_chip_set_affinity_parent);
|
2015-08-14 20:20:26 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* irq_chip_set_type_parent - Set IRQ type on the parent interrupt
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
* @type: IRQ_TYPE_{LEVEL,EDGE}_* value - see include/linux/irq.h
|
|
|
|
*
|
|
|
|
* Conditional, as the underlying parent chip might not implement it.
|
|
|
|
*/
|
|
|
|
int irq_chip_set_type_parent(struct irq_data *data, unsigned int type)
|
|
|
|
{
|
|
|
|
data = data->parent_data;
|
|
|
|
|
|
|
|
if (data->chip->irq_set_type)
|
|
|
|
return data->chip->irq_set_type(data, type);
|
2014-11-13 23:37:05 +08:00
|
|
|
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
2016-03-03 22:56:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_chip_set_type_parent);
|
2014-11-13 23:37:05 +08:00
|
|
|
|
2014-11-06 22:20:16 +08:00
|
|
|
/**
|
|
|
|
* irq_chip_retrigger_hierarchy - Retrigger an interrupt in hardware
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
*
|
|
|
|
* Iterate through the domain hierarchy of the interrupt and check
|
|
|
|
* whether a hw retrigger function exists. If yes, invoke it.
|
|
|
|
*/
|
|
|
|
int irq_chip_retrigger_hierarchy(struct irq_data *data)
|
|
|
|
{
|
|
|
|
for (data = data->parent_data; data; data = data->parent_data)
|
|
|
|
if (data->chip && data->chip->irq_retrigger)
|
|
|
|
return data->chip->irq_retrigger(data);
|
|
|
|
|
2015-08-14 20:20:25 +08:00
|
|
|
return 0;
|
2014-11-06 22:20:16 +08:00
|
|
|
}
|
2020-07-11 07:18:23 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_chip_retrigger_hierarchy);
|
2015-03-11 23:43:43 +08:00
|
|
|
|
2015-05-19 17:07:14 +08:00
|
|
|
/**
|
|
|
|
* irq_chip_set_vcpu_affinity_parent - Set vcpu affinity on the parent interrupt
|
|
|
|
* @data: Pointer to interrupt specific data
|
2015-07-29 18:09:36 +08:00
|
|
|
* @vcpu_info: The vcpu affinity information
|
2015-05-19 17:07:14 +08:00
|
|
|
*/
|
|
|
|
int irq_chip_set_vcpu_affinity_parent(struct irq_data *data, void *vcpu_info)
|
|
|
|
{
|
|
|
|
data = data->parent_data;
|
|
|
|
if (data->chip->irq_set_vcpu_affinity)
|
|
|
|
return data->chip->irq_set_vcpu_affinity(data, vcpu_info);
|
|
|
|
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
2020-07-11 07:18:23 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_chip_set_vcpu_affinity_parent);
|
2015-03-11 23:43:43 +08:00
|
|
|
/**
|
|
|
|
* irq_chip_set_wake_parent - Set/reset wake-up on the parent interrupt
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
* @on: Whether to set or reset the wake-up capability of this irq
|
|
|
|
*
|
|
|
|
* Conditional, as the underlying parent chip might not implement it.
|
|
|
|
*/
|
|
|
|
int irq_chip_set_wake_parent(struct irq_data *data, unsigned int on)
|
|
|
|
{
|
|
|
|
data = data->parent_data;
|
2019-03-26 02:10:26 +08:00
|
|
|
|
|
|
|
if (data->chip->flags & IRQCHIP_SKIP_SET_WAKE)
|
|
|
|
return 0;
|
|
|
|
|
2015-03-11 23:43:43 +08:00
|
|
|
if (data->chip->irq_set_wake)
|
|
|
|
return data->chip->irq_set_wake(data, on);
|
|
|
|
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
2019-02-04 17:58:52 +08:00
|
|
|
EXPORT_SYMBOL_GPL(irq_chip_set_wake_parent);
|
2019-04-30 18:12:22 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* irq_chip_request_resources_parent - Request resources on the parent interrupt
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
*/
|
|
|
|
int irq_chip_request_resources_parent(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data = data->parent_data;
|
|
|
|
|
|
|
|
if (data->chip->irq_request_resources)
|
|
|
|
return data->chip->irq_request_resources(data);
|
|
|
|
|
2022-05-13 00:05:44 +08:00
|
|
|
/* no error on missing optional irq_chip::irq_request_resources */
|
|
|
|
return 0;
|
2019-04-30 18:12:22 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(irq_chip_request_resources_parent);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* irq_chip_release_resources_parent - Release resources on the parent interrupt
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
*/
|
|
|
|
void irq_chip_release_resources_parent(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data = data->parent_data;
|
|
|
|
if (data->chip->irq_release_resources)
|
|
|
|
data->chip->irq_release_resources(data);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(irq_chip_release_resources_parent);
|
2014-11-06 22:20:16 +08:00
|
|
|
#endif
|
2014-11-06 22:20:17 +08:00
|
|
|
|
|
|
|
/**
|
2021-03-16 18:02:05 +08:00
|
|
|
* irq_chip_compose_msi_msg - Compose msi message for a irq chip
|
2014-11-06 22:20:17 +08:00
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
* @msg: Pointer to the MSI message
|
|
|
|
*
|
|
|
|
* For hierarchical domains we find the first chip in the hierarchy
|
|
|
|
* which implements the irq_compose_msi_msg callback. For non
|
|
|
|
* hierarchical we use the top level chip.
|
|
|
|
*/
|
|
|
|
int irq_chip_compose_msi_msg(struct irq_data *data, struct msi_msg *msg)
|
|
|
|
{
|
2020-08-26 19:16:32 +08:00
|
|
|
struct irq_data *pos;
|
2014-11-06 22:20:17 +08:00
|
|
|
|
2020-08-26 19:16:32 +08:00
|
|
|
for (pos = NULL; !pos && data; data = irqd_get_parent_data(data)) {
|
2014-11-06 22:20:17 +08:00
|
|
|
if (data->chip && data->chip->irq_compose_msi_msg)
|
|
|
|
pos = data;
|
2020-08-26 19:16:32 +08:00
|
|
|
}
|
|
|
|
|
2014-11-06 22:20:17 +08:00
|
|
|
if (!pos)
|
|
|
|
return -ENOSYS;
|
|
|
|
|
|
|
|
pos->chip->irq_compose_msi_msg(pos, msg);
|
|
|
|
return 0;
|
|
|
|
}
|
2016-06-07 23:12:29 +08:00
|
|
|
|
2022-02-01 20:02:59 +08:00
|
|
|
static struct device *irq_get_parent_device(struct irq_data *data)
|
|
|
|
{
|
|
|
|
if (data->domain)
|
|
|
|
return data->domain->dev;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-06-07 23:12:29 +08:00
|
|
|
/**
|
|
|
|
* irq_chip_pm_get - Enable power for an IRQ chip
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
*
|
|
|
|
* Enable the power to the IRQ chip referenced by the interrupt data
|
|
|
|
* structure.
|
|
|
|
*/
|
|
|
|
int irq_chip_pm_get(struct irq_data *data)
|
|
|
|
{
|
2022-02-01 20:02:59 +08:00
|
|
|
struct device *dev = irq_get_parent_device(data);
|
2022-04-18 19:07:16 +08:00
|
|
|
int retval = 0;
|
2016-06-07 23:12:29 +08:00
|
|
|
|
2022-04-18 19:07:16 +08:00
|
|
|
if (IS_ENABLED(CONFIG_PM) && dev)
|
|
|
|
retval = pm_runtime_resume_and_get(dev);
|
2016-06-07 23:12:29 +08:00
|
|
|
|
2022-04-18 19:07:16 +08:00
|
|
|
return retval;
|
2016-06-07 23:12:29 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* irq_chip_pm_put - Disable power for an IRQ chip
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
*
|
|
|
|
* Disable the power to the IRQ chip referenced by the interrupt data
|
|
|
|
* structure, belongs. Note that power will only be disabled, once this
|
|
|
|
* function has been called for all IRQs that have called irq_chip_pm_get().
|
|
|
|
*/
|
|
|
|
int irq_chip_pm_put(struct irq_data *data)
|
|
|
|
{
|
2022-02-01 20:02:59 +08:00
|
|
|
struct device *dev = irq_get_parent_device(data);
|
2016-06-07 23:12:29 +08:00
|
|
|
int retval = 0;
|
|
|
|
|
2022-02-01 20:02:59 +08:00
|
|
|
if (IS_ENABLED(CONFIG_PM) && dev)
|
|
|
|
retval = pm_runtime_put(dev);
|
2016-06-07 23:12:29 +08:00
|
|
|
|
|
|
|
return (retval < 0) ? retval : 0;
|
|
|
|
}
|