Merge branch 'irq/generic-nmi' of git://git.kernel.org/pub/scm/linux/kernel/git/maz/arm-platforms
* 'irq/generic-nmi' of git://git.kernel.org/pub/scm/linux/kernel/git/maz/arm-platforms: irqdesc: Add domain handler for NMIs genirq: Provide NMI handlers genirq: Provide NMI management for percpu_devid interrupts genirq: Provide basic NMI management for interrupt lineshifive-unleashed-5.1
Catalin Marinas
commit
e26a433147
|
|
@ -156,6 +156,10 @@ __request_percpu_irq(unsigned int irq, irq_handler_t handler,
|
|||
unsigned long flags, const char *devname,
|
||||
void __percpu *percpu_dev_id);
|
||||
|
||||
extern int __must_check
|
||||
request_nmi(unsigned int irq, irq_handler_t handler, unsigned long flags,
|
||||
const char *name, void *dev);
|
||||
|
||||
static inline int __must_check
|
||||
request_percpu_irq(unsigned int irq, irq_handler_t handler,
|
||||
const char *devname, void __percpu *percpu_dev_id)
|
||||
|
|
@ -164,9 +168,16 @@ request_percpu_irq(unsigned int irq, irq_handler_t handler,
|
|||
devname, percpu_dev_id);
|
||||
}
|
||||
|
||||
extern int __must_check
|
||||
request_percpu_nmi(unsigned int irq, irq_handler_t handler,
|
||||
const char *devname, void __percpu *dev);
|
||||
|
||||
extern const void *free_irq(unsigned int, void *);
|
||||
extern void free_percpu_irq(unsigned int, void __percpu *);
|
||||
|
||||
extern const void *free_nmi(unsigned int irq, void *dev_id);
|
||||
extern void free_percpu_nmi(unsigned int irq, void __percpu *percpu_dev_id);
|
||||
|
||||
struct device;
|
||||
|
||||
extern int __must_check
|
||||
|
|
@ -217,6 +228,13 @@ extern void enable_percpu_irq(unsigned int irq, unsigned int type);
|
|||
extern bool irq_percpu_is_enabled(unsigned int irq);
|
||||
extern void irq_wake_thread(unsigned int irq, void *dev_id);
|
||||
|
||||
extern void disable_nmi_nosync(unsigned int irq);
|
||||
extern void disable_percpu_nmi(unsigned int irq);
|
||||
extern void enable_nmi(unsigned int irq);
|
||||
extern void enable_percpu_nmi(unsigned int irq, unsigned int type);
|
||||
extern int prepare_percpu_nmi(unsigned int irq);
|
||||
extern void teardown_percpu_nmi(unsigned int irq);
|
||||
|
||||
/* The following three functions are for the core kernel use only. */
|
||||
extern void suspend_device_irqs(void);
|
||||
extern void resume_device_irqs(void);
|
||||
|
|
|
|||
|
|
@ -442,6 +442,8 @@ static inline irq_hw_number_t irqd_to_hwirq(struct irq_data *d)
|
|||
* @irq_set_vcpu_affinity: optional to target a vCPU in a virtual machine
|
||||
* @ipi_send_single: send a single IPI to destination cpus
|
||||
* @ipi_send_mask: send an IPI to destination cpus in cpumask
|
||||
* @irq_nmi_setup: function called from core code before enabling an NMI
|
||||
* @irq_nmi_teardown: function called from core code after disabling an NMI
|
||||
* @flags: chip specific flags
|
||||
*/
|
||||
struct irq_chip {
|
||||
|
|
@ -490,6 +492,9 @@ struct irq_chip {
|
|||
void (*ipi_send_single)(struct irq_data *data, unsigned int cpu);
|
||||
void (*ipi_send_mask)(struct irq_data *data, const struct cpumask *dest);
|
||||
|
||||
int (*irq_nmi_setup)(struct irq_data *data);
|
||||
void (*irq_nmi_teardown)(struct irq_data *data);
|
||||
|
||||
unsigned long flags;
|
||||
};
|
||||
|
||||
|
|
@ -505,6 +510,7 @@ struct irq_chip {
|
|||
* IRQCHIP_ONESHOT_SAFE: One shot does not require mask/unmask
|
||||
* IRQCHIP_EOI_THREADED: Chip requires eoi() on unmask in threaded mode
|
||||
* IRQCHIP_SUPPORTS_LEVEL_MSI Chip can provide two doorbells for Level MSIs
|
||||
* IRQCHIP_SUPPORTS_NMI: Chip can deliver NMIs, only for root irqchips
|
||||
*/
|
||||
enum {
|
||||
IRQCHIP_SET_TYPE_MASKED = (1 << 0),
|
||||
|
|
@ -515,6 +521,7 @@ enum {
|
|||
IRQCHIP_ONESHOT_SAFE = (1 << 5),
|
||||
IRQCHIP_EOI_THREADED = (1 << 6),
|
||||
IRQCHIP_SUPPORTS_LEVEL_MSI = (1 << 7),
|
||||
IRQCHIP_SUPPORTS_NMI = (1 << 8),
|
||||
};
|
||||
|
||||
#include <linux/irqdesc.h>
|
||||
|
|
@ -594,6 +601,9 @@ extern void handle_percpu_devid_irq(struct irq_desc *desc);
|
|||
extern void handle_bad_irq(struct irq_desc *desc);
|
||||
extern void handle_nested_irq(unsigned int irq);
|
||||
|
||||
extern void handle_fasteoi_nmi(struct irq_desc *desc);
|
||||
extern void handle_percpu_devid_fasteoi_nmi(struct irq_desc *desc);
|
||||
|
||||
extern int irq_chip_compose_msi_msg(struct irq_data *data, struct msi_msg *msg);
|
||||
extern int irq_chip_pm_get(struct irq_data *data);
|
||||
extern int irq_chip_pm_put(struct irq_data *data);
|
||||
|
|
|
|||
|
|
@ -171,6 +171,11 @@ static inline int handle_domain_irq(struct irq_domain *domain,
|
|||
{
|
||||
return __handle_domain_irq(domain, hwirq, true, regs);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_IRQ_DOMAIN
|
||||
int handle_domain_nmi(struct irq_domain *domain, unsigned int hwirq,
|
||||
struct pt_regs *regs);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* Test to see if a driver has successfully requested an irq */
|
||||
|
|
|
|||
|
|
@ -729,6 +729,37 @@ out:
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(handle_fasteoi_irq);
|
||||
|
||||
/**
|
||||
* 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;
|
||||
|
||||
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);
|
||||
|
||||
/**
|
||||
* handle_edge_irq - edge type IRQ handler
|
||||
* @desc: the interrupt description structure for this irq
|
||||
|
|
@ -908,6 +939,29 @@ void handle_percpu_devid_irq(struct irq_desc *desc)
|
|||
chip->irq_eoi(&desc->irq_data);
|
||||
}
|
||||
|
||||
/**
|
||||
* 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;
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
static void
|
||||
__irq_do_set_handler(struct irq_desc *desc, irq_flow_handler_t handle,
|
||||
int is_chained, const char *name)
|
||||
|
|
|
|||
|
|
@ -56,6 +56,7 @@ static const struct irq_bit_descr irqchip_flags[] = {
|
|||
BIT_MASK_DESCR(IRQCHIP_ONESHOT_SAFE),
|
||||
BIT_MASK_DESCR(IRQCHIP_EOI_THREADED),
|
||||
BIT_MASK_DESCR(IRQCHIP_SUPPORTS_LEVEL_MSI),
|
||||
BIT_MASK_DESCR(IRQCHIP_SUPPORTS_NMI),
|
||||
};
|
||||
|
||||
static void
|
||||
|
|
@ -140,6 +141,7 @@ static const struct irq_bit_descr irqdesc_istates[] = {
|
|||
BIT_MASK_DESCR(IRQS_WAITING),
|
||||
BIT_MASK_DESCR(IRQS_PENDING),
|
||||
BIT_MASK_DESCR(IRQS_SUSPENDED),
|
||||
BIT_MASK_DESCR(IRQS_NMI),
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -203,8 +205,8 @@ static ssize_t irq_debug_write(struct file *file, const char __user *user_buf,
|
|||
chip_bus_lock(desc);
|
||||
raw_spin_lock_irqsave(&desc->lock, flags);
|
||||
|
||||
if (irq_settings_is_level(desc)) {
|
||||
/* Can't do level, sorry */
|
||||
if (irq_settings_is_level(desc) || desc->istate & IRQS_NMI) {
|
||||
/* Can't do level nor NMIs, sorry */
|
||||
err = -EINVAL;
|
||||
} else {
|
||||
desc->istate |= IRQS_PENDING;
|
||||
|
|
|
|||
|
|
@ -49,6 +49,7 @@ enum {
|
|||
* IRQS_WAITING - irq is waiting
|
||||
* IRQS_PENDING - irq is pending and replayed later
|
||||
* IRQS_SUSPENDED - irq is suspended
|
||||
* IRQS_NMI - irq line is used to deliver NMIs
|
||||
*/
|
||||
enum {
|
||||
IRQS_AUTODETECT = 0x00000001,
|
||||
|
|
@ -60,6 +61,7 @@ enum {
|
|||
IRQS_PENDING = 0x00000200,
|
||||
IRQS_SUSPENDED = 0x00000800,
|
||||
IRQS_TIMINGS = 0x00001000,
|
||||
IRQS_NMI = 0x00002000,
|
||||
};
|
||||
|
||||
#include "debug.h"
|
||||
|
|
|
|||
|
|
@ -669,6 +669,41 @@ int __handle_domain_irq(struct irq_domain *domain, unsigned int hwirq,
|
|||
set_irq_regs(old_regs);
|
||||
return ret;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_IRQ_DOMAIN
|
||||
/**
|
||||
* handle_domain_nmi - Invoke the handler for a HW irq belonging to a domain
|
||||
* @domain: The domain where to perform the lookup
|
||||
* @hwirq: The HW irq number to convert to a logical one
|
||||
* @regs: Register file coming from the low-level handling code
|
||||
*
|
||||
* Returns: 0 on success, or -EINVAL if conversion has failed
|
||||
*/
|
||||
int handle_domain_nmi(struct irq_domain *domain, unsigned int hwirq,
|
||||
struct pt_regs *regs)
|
||||
{
|
||||
struct pt_regs *old_regs = set_irq_regs(regs);
|
||||
unsigned int irq;
|
||||
int ret = 0;
|
||||
|
||||
nmi_enter();
|
||||
|
||||
irq = irq_find_mapping(domain, hwirq);
|
||||
|
||||
/*
|
||||
* ack_bad_irq is not NMI-safe, just report
|
||||
* an invalid interrupt.
|
||||
*/
|
||||
if (likely(irq))
|
||||
generic_handle_irq(irq);
|
||||
else
|
||||
ret = -EINVAL;
|
||||
|
||||
nmi_exit();
|
||||
set_irq_regs(old_regs);
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* Dynamic interrupt handling */
|
||||
|
|
|
|||
|
|
@ -341,7 +341,7 @@ irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify)
|
|||
/* The release function is promised process context */
|
||||
might_sleep();
|
||||
|
||||
if (!desc)
|
||||
if (!desc || desc->istate & IRQS_NMI)
|
||||
return -EINVAL;
|
||||
|
||||
/* Complete initialisation of *notify */
|
||||
|
|
@ -550,6 +550,21 @@ bool disable_hardirq(unsigned int irq)
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(disable_hardirq);
|
||||
|
||||
/**
|
||||
* disable_nmi_nosync - disable an nmi without waiting
|
||||
* @irq: Interrupt to disable
|
||||
*
|
||||
* Disable the selected interrupt line. Disables and enables are
|
||||
* nested.
|
||||
* The interrupt to disable must have been requested through request_nmi.
|
||||
* Unlike disable_nmi(), this function does not ensure existing
|
||||
* instances of the IRQ handler have completed before returning.
|
||||
*/
|
||||
void disable_nmi_nosync(unsigned int irq)
|
||||
{
|
||||
disable_irq_nosync(irq);
|
||||
}
|
||||
|
||||
void __enable_irq(struct irq_desc *desc)
|
||||
{
|
||||
switch (desc->depth) {
|
||||
|
|
@ -606,6 +621,20 @@ out:
|
|||
}
|
||||
EXPORT_SYMBOL(enable_irq);
|
||||
|
||||
/**
|
||||
* enable_nmi - enable handling of an nmi
|
||||
* @irq: Interrupt to enable
|
||||
*
|
||||
* The interrupt to enable must have been requested through request_nmi.
|
||||
* Undoes the effect of one call to disable_nmi(). If this
|
||||
* matches the last disable, processing of interrupts on this
|
||||
* IRQ line is re-enabled.
|
||||
*/
|
||||
void enable_nmi(unsigned int irq)
|
||||
{
|
||||
enable_irq(irq);
|
||||
}
|
||||
|
||||
static int set_irq_wake_real(unsigned int irq, unsigned int on)
|
||||
{
|
||||
struct irq_desc *desc = irq_to_desc(irq);
|
||||
|
|
@ -641,6 +670,12 @@ int irq_set_irq_wake(unsigned int irq, unsigned int on)
|
|||
if (!desc)
|
||||
return -EINVAL;
|
||||
|
||||
/* Don't use NMIs as wake up interrupts please */
|
||||
if (desc->istate & IRQS_NMI) {
|
||||
ret = -EINVAL;
|
||||
goto out_unlock;
|
||||
}
|
||||
|
||||
/* wakeup-capable irqs can be shared between drivers that
|
||||
* don't need to have the same sleep mode behaviors.
|
||||
*/
|
||||
|
|
@ -663,6 +698,8 @@ int irq_set_irq_wake(unsigned int irq, unsigned int on)
|
|||
irqd_clear(&desc->irq_data, IRQD_WAKEUP_STATE);
|
||||
}
|
||||
}
|
||||
|
||||
out_unlock:
|
||||
irq_put_desc_busunlock(desc, flags);
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -1125,6 +1162,39 @@ static void irq_release_resources(struct irq_desc *desc)
|
|||
c->irq_release_resources(d);
|
||||
}
|
||||
|
||||
static bool irq_supports_nmi(struct irq_desc *desc)
|
||||
{
|
||||
struct irq_data *d = irq_desc_get_irq_data(desc);
|
||||
|
||||
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
|
||||
/* Only IRQs directly managed by the root irqchip can be set as NMI */
|
||||
if (d->parent_data)
|
||||
return false;
|
||||
#endif
|
||||
/* Don't support NMIs for chips behind a slow bus */
|
||||
if (d->chip->irq_bus_lock || d->chip->irq_bus_sync_unlock)
|
||||
return false;
|
||||
|
||||
return d->chip->flags & IRQCHIP_SUPPORTS_NMI;
|
||||
}
|
||||
|
||||
static int irq_nmi_setup(struct irq_desc *desc)
|
||||
{
|
||||
struct irq_data *d = irq_desc_get_irq_data(desc);
|
||||
struct irq_chip *c = d->chip;
|
||||
|
||||
return c->irq_nmi_setup ? c->irq_nmi_setup(d) : -EINVAL;
|
||||
}
|
||||
|
||||
static void irq_nmi_teardown(struct irq_desc *desc)
|
||||
{
|
||||
struct irq_data *d = irq_desc_get_irq_data(desc);
|
||||
struct irq_chip *c = d->chip;
|
||||
|
||||
if (c->irq_nmi_teardown)
|
||||
c->irq_nmi_teardown(d);
|
||||
}
|
||||
|
||||
static int
|
||||
setup_irq_thread(struct irqaction *new, unsigned int irq, bool secondary)
|
||||
{
|
||||
|
|
@ -1299,9 +1369,17 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
|
|||
* fields must have IRQF_SHARED set and the bits which
|
||||
* set the trigger type must match. Also all must
|
||||
* agree on ONESHOT.
|
||||
* Interrupt lines used for NMIs cannot be shared.
|
||||
*/
|
||||
unsigned int oldtype;
|
||||
|
||||
if (desc->istate & IRQS_NMI) {
|
||||
pr_err("Invalid attempt to share NMI for %s (irq %d) on irqchip %s.\n",
|
||||
new->name, irq, desc->irq_data.chip->name);
|
||||
ret = -EINVAL;
|
||||
goto out_unlock;
|
||||
}
|
||||
|
||||
/*
|
||||
* If nobody did set the configuration before, inherit
|
||||
* the one provided by the requester.
|
||||
|
|
@ -1753,6 +1831,59 @@ const void *free_irq(unsigned int irq, void *dev_id)
|
|||
}
|
||||
EXPORT_SYMBOL(free_irq);
|
||||
|
||||
/* This function must be called with desc->lock held */
|
||||
static const void *__cleanup_nmi(unsigned int irq, struct irq_desc *desc)
|
||||
{
|
||||
const char *devname = NULL;
|
||||
|
||||
desc->istate &= ~IRQS_NMI;
|
||||
|
||||
if (!WARN_ON(desc->action == NULL)) {
|
||||
irq_pm_remove_action(desc, desc->action);
|
||||
devname = desc->action->name;
|
||||
unregister_handler_proc(irq, desc->action);
|
||||
|
||||
kfree(desc->action);
|
||||
desc->action = NULL;
|
||||
}
|
||||
|
||||
irq_settings_clr_disable_unlazy(desc);
|
||||
irq_shutdown(desc);
|
||||
|
||||
irq_release_resources(desc);
|
||||
|
||||
irq_chip_pm_put(&desc->irq_data);
|
||||
module_put(desc->owner);
|
||||
|
||||
return devname;
|
||||
}
|
||||
|
||||
const void *free_nmi(unsigned int irq, void *dev_id)
|
||||
{
|
||||
struct irq_desc *desc = irq_to_desc(irq);
|
||||
unsigned long flags;
|
||||
const void *devname;
|
||||
|
||||
if (!desc || WARN_ON(!(desc->istate & IRQS_NMI)))
|
||||
return NULL;
|
||||
|
||||
if (WARN_ON(irq_settings_is_per_cpu_devid(desc)))
|
||||
return NULL;
|
||||
|
||||
/* NMI still enabled */
|
||||
if (WARN_ON(desc->depth == 0))
|
||||
disable_nmi_nosync(irq);
|
||||
|
||||
raw_spin_lock_irqsave(&desc->lock, flags);
|
||||
|
||||
irq_nmi_teardown(desc);
|
||||
devname = __cleanup_nmi(irq, desc);
|
||||
|
||||
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
||||
|
||||
return devname;
|
||||
}
|
||||
|
||||
/**
|
||||
* request_threaded_irq - allocate an interrupt line
|
||||
* @irq: Interrupt line to allocate
|
||||
|
|
@ -1922,6 +2053,101 @@ int request_any_context_irq(unsigned int irq, irq_handler_t handler,
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(request_any_context_irq);
|
||||
|
||||
/**
|
||||
* request_nmi - allocate an interrupt line for NMI delivery
|
||||
* @irq: Interrupt line to allocate
|
||||
* @handler: Function to be called when the IRQ occurs.
|
||||
* Threaded handler for threaded interrupts.
|
||||
* @irqflags: Interrupt type flags
|
||||
* @name: An ascii name for the claiming device
|
||||
* @dev_id: A cookie passed back to the handler function
|
||||
*
|
||||
* This call allocates interrupt resources and enables the
|
||||
* interrupt line and IRQ handling. It sets up the IRQ line
|
||||
* to be handled as an NMI.
|
||||
*
|
||||
* An interrupt line delivering NMIs cannot be shared and IRQ handling
|
||||
* cannot be threaded.
|
||||
*
|
||||
* Interrupt lines requested for NMI delivering must produce per cpu
|
||||
* interrupts and have auto enabling setting disabled.
|
||||
*
|
||||
* Dev_id must be globally unique. Normally the address of the
|
||||
* device data structure is used as the cookie. Since the handler
|
||||
* receives this value it makes sense to use it.
|
||||
*
|
||||
* If the interrupt line cannot be used to deliver NMIs, function
|
||||
* will fail and return a negative value.
|
||||
*/
|
||||
int request_nmi(unsigned int irq, irq_handler_t handler,
|
||||
unsigned long irqflags, const char *name, void *dev_id)
|
||||
{
|
||||
struct irqaction *action;
|
||||
struct irq_desc *desc;
|
||||
unsigned long flags;
|
||||
int retval;
|
||||
|
||||
if (irq == IRQ_NOTCONNECTED)
|
||||
return -ENOTCONN;
|
||||
|
||||
/* NMI cannot be shared, used for Polling */
|
||||
if (irqflags & (IRQF_SHARED | IRQF_COND_SUSPEND | IRQF_IRQPOLL))
|
||||
return -EINVAL;
|
||||
|
||||
if (!(irqflags & IRQF_PERCPU))
|
||||
return -EINVAL;
|
||||
|
||||
if (!handler)
|
||||
return -EINVAL;
|
||||
|
||||
desc = irq_to_desc(irq);
|
||||
|
||||
if (!desc || irq_settings_can_autoenable(desc) ||
|
||||
!irq_settings_can_request(desc) ||
|
||||
WARN_ON(irq_settings_is_per_cpu_devid(desc)) ||
|
||||
!irq_supports_nmi(desc))
|
||||
return -EINVAL;
|
||||
|
||||
action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
|
||||
if (!action)
|
||||
return -ENOMEM;
|
||||
|
||||
action->handler = handler;
|
||||
action->flags = irqflags | IRQF_NO_THREAD | IRQF_NOBALANCING;
|
||||
action->name = name;
|
||||
action->dev_id = dev_id;
|
||||
|
||||
retval = irq_chip_pm_get(&desc->irq_data);
|
||||
if (retval < 0)
|
||||
goto err_out;
|
||||
|
||||
retval = __setup_irq(irq, desc, action);
|
||||
if (retval)
|
||||
goto err_irq_setup;
|
||||
|
||||
raw_spin_lock_irqsave(&desc->lock, flags);
|
||||
|
||||
/* Setup NMI state */
|
||||
desc->istate |= IRQS_NMI;
|
||||
retval = irq_nmi_setup(desc);
|
||||
if (retval) {
|
||||
__cleanup_nmi(irq, desc);
|
||||
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
||||
|
||||
return 0;
|
||||
|
||||
err_irq_setup:
|
||||
irq_chip_pm_put(&desc->irq_data);
|
||||
err_out:
|
||||
kfree(action);
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
void enable_percpu_irq(unsigned int irq, unsigned int type)
|
||||
{
|
||||
unsigned int cpu = smp_processor_id();
|
||||
|
|
@ -1956,6 +2182,11 @@ out:
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(enable_percpu_irq);
|
||||
|
||||
void enable_percpu_nmi(unsigned int irq, unsigned int type)
|
||||
{
|
||||
enable_percpu_irq(irq, type);
|
||||
}
|
||||
|
||||
/**
|
||||
* irq_percpu_is_enabled - Check whether the per cpu irq is enabled
|
||||
* @irq: Linux irq number to check for
|
||||
|
|
@ -1995,6 +2226,11 @@ void disable_percpu_irq(unsigned int irq)
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(disable_percpu_irq);
|
||||
|
||||
void disable_percpu_nmi(unsigned int irq)
|
||||
{
|
||||
disable_percpu_irq(irq);
|
||||
}
|
||||
|
||||
/*
|
||||
* Internal function to unregister a percpu irqaction.
|
||||
*/
|
||||
|
|
@ -2026,6 +2262,8 @@ static struct irqaction *__free_percpu_irq(unsigned int irq, void __percpu *dev_
|
|||
/* Found it - now remove it from the list of entries: */
|
||||
desc->action = NULL;
|
||||
|
||||
desc->istate &= ~IRQS_NMI;
|
||||
|
||||
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
||||
|
||||
unregister_handler_proc(irq, action);
|
||||
|
|
@ -2079,6 +2317,19 @@ void free_percpu_irq(unsigned int irq, void __percpu *dev_id)
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(free_percpu_irq);
|
||||
|
||||
void free_percpu_nmi(unsigned int irq, void __percpu *dev_id)
|
||||
{
|
||||
struct irq_desc *desc = irq_to_desc(irq);
|
||||
|
||||
if (!desc || !irq_settings_is_per_cpu_devid(desc))
|
||||
return;
|
||||
|
||||
if (WARN_ON(!(desc->istate & IRQS_NMI)))
|
||||
return;
|
||||
|
||||
kfree(__free_percpu_irq(irq, dev_id));
|
||||
}
|
||||
|
||||
/**
|
||||
* setup_percpu_irq - setup a per-cpu interrupt
|
||||
* @irq: Interrupt line to setup
|
||||
|
|
@ -2168,6 +2419,158 @@ int __request_percpu_irq(unsigned int irq, irq_handler_t handler,
|
|||
}
|
||||
EXPORT_SYMBOL_GPL(__request_percpu_irq);
|
||||
|
||||
/**
|
||||
* request_percpu_nmi - allocate a percpu interrupt line for NMI delivery
|
||||
* @irq: Interrupt line to allocate
|
||||
* @handler: Function to be called when the IRQ occurs.
|
||||
* @name: An ascii name for the claiming device
|
||||
* @dev_id: A percpu cookie passed back to the handler function
|
||||
*
|
||||
* This call allocates interrupt resources for a per CPU NMI. Per CPU NMIs
|
||||
* have to be setup on each CPU by calling ready_percpu_nmi() before being
|
||||
* enabled on the same CPU by using enable_percpu_nmi().
|
||||
*
|
||||
* Dev_id must be globally unique. It is a per-cpu variable, and
|
||||
* the handler gets called with the interrupted CPU's instance of
|
||||
* that variable.
|
||||
*
|
||||
* Interrupt lines requested for NMI delivering should have auto enabling
|
||||
* setting disabled.
|
||||
*
|
||||
* If the interrupt line cannot be used to deliver NMIs, function
|
||||
* will fail returning a negative value.
|
||||
*/
|
||||
int request_percpu_nmi(unsigned int irq, irq_handler_t handler,
|
||||
const char *name, void __percpu *dev_id)
|
||||
{
|
||||
struct irqaction *action;
|
||||
struct irq_desc *desc;
|
||||
unsigned long flags;
|
||||
int retval;
|
||||
|
||||
if (!handler)
|
||||
return -EINVAL;
|
||||
|
||||
desc = irq_to_desc(irq);
|
||||
|
||||
if (!desc || !irq_settings_can_request(desc) ||
|
||||
!irq_settings_is_per_cpu_devid(desc) ||
|
||||
irq_settings_can_autoenable(desc) ||
|
||||
!irq_supports_nmi(desc))
|
||||
return -EINVAL;
|
||||
|
||||
/* The line cannot already be NMI */
|
||||
if (desc->istate & IRQS_NMI)
|
||||
return -EINVAL;
|
||||
|
||||
action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
|
||||
if (!action)
|
||||
return -ENOMEM;
|
||||
|
||||
action->handler = handler;
|
||||
action->flags = IRQF_PERCPU | IRQF_NO_SUSPEND | IRQF_NO_THREAD
|
||||
| IRQF_NOBALANCING;
|
||||
action->name = name;
|
||||
action->percpu_dev_id = dev_id;
|
||||
|
||||
retval = irq_chip_pm_get(&desc->irq_data);
|
||||
if (retval < 0)
|
||||
goto err_out;
|
||||
|
||||
retval = __setup_irq(irq, desc, action);
|
||||
if (retval)
|
||||
goto err_irq_setup;
|
||||
|
||||
raw_spin_lock_irqsave(&desc->lock, flags);
|
||||
desc->istate |= IRQS_NMI;
|
||||
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
||||
|
||||
return 0;
|
||||
|
||||
err_irq_setup:
|
||||
irq_chip_pm_put(&desc->irq_data);
|
||||
err_out:
|
||||
kfree(action);
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
/**
|
||||
* prepare_percpu_nmi - performs CPU local setup for NMI delivery
|
||||
* @irq: Interrupt line to prepare for NMI delivery
|
||||
*
|
||||
* This call prepares an interrupt line to deliver NMI on the current CPU,
|
||||
* before that interrupt line gets enabled with enable_percpu_nmi().
|
||||
*
|
||||
* As a CPU local operation, this should be called from non-preemptible
|
||||
* context.
|
||||
*
|
||||
* If the interrupt line cannot be used to deliver NMIs, function
|
||||
* will fail returning a negative value.
|
||||
*/
|
||||
int prepare_percpu_nmi(unsigned int irq)
|
||||
{
|
||||
unsigned long flags;
|
||||
struct irq_desc *desc;
|
||||
int ret = 0;
|
||||
|
||||
WARN_ON(preemptible());
|
||||
|
||||
desc = irq_get_desc_lock(irq, &flags,
|
||||
IRQ_GET_DESC_CHECK_PERCPU);
|
||||
if (!desc)
|
||||
return -EINVAL;
|
||||
|
||||
if (WARN(!(desc->istate & IRQS_NMI),
|
||||
KERN_ERR "prepare_percpu_nmi called for a non-NMI interrupt: irq %u\n",
|
||||
irq)) {
|
||||
ret = -EINVAL;
|
||||
goto out;
|
||||
}
|
||||
|
||||
ret = irq_nmi_setup(desc);
|
||||
if (ret) {
|
||||
pr_err("Failed to setup NMI delivery: irq %u\n", irq);
|
||||
goto out;
|
||||
}
|
||||
|
||||
out:
|
||||
irq_put_desc_unlock(desc, flags);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* teardown_percpu_nmi - undoes NMI setup of IRQ line
|
||||
* @irq: Interrupt line from which CPU local NMI configuration should be
|
||||
* removed
|
||||
*
|
||||
* This call undoes the setup done by prepare_percpu_nmi().
|
||||
*
|
||||
* IRQ line should not be enabled for the current CPU.
|
||||
*
|
||||
* As a CPU local operation, this should be called from non-preemptible
|
||||
* context.
|
||||
*/
|
||||
void teardown_percpu_nmi(unsigned int irq)
|
||||
{
|
||||
unsigned long flags;
|
||||
struct irq_desc *desc;
|
||||
|
||||
WARN_ON(preemptible());
|
||||
|
||||
desc = irq_get_desc_lock(irq, &flags,
|
||||
IRQ_GET_DESC_CHECK_PERCPU);
|
||||
if (!desc)
|
||||
return;
|
||||
|
||||
if (WARN_ON(!(desc->istate & IRQS_NMI)))
|
||||
goto out;
|
||||
|
||||
irq_nmi_teardown(desc);
|
||||
out:
|
||||
irq_put_desc_unlock(desc, flags);
|
||||
}
|
||||
|
||||
/**
|
||||
* irq_get_irqchip_state - returns the irqchip state of a interrupt.
|
||||
* @irq: Interrupt line that is forwarded to a VM
|
||||
|
|
|
|||
Loading…
Reference in New Issue