2006-06-29 03:24:53 -06:00
|
|
|
/*
|
|
|
|
* linux/kernel/irq/chip.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
|
|
|
|
* Copyright (C) 2005-2006, Thomas Gleixner, Russell King
|
|
|
|
*
|
|
|
|
* This file contains the core interrupt handling code, for irq-chip
|
|
|
|
* based architectures.
|
|
|
|
*
|
|
|
|
* Detailed information is available in Documentation/DocBook/genericirq
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/irq.h>
|
2007-04-18 03:39:21 -06:00
|
|
|
#include <linux/msi.h>
|
2006-06-29 03:24:53 -06:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/kernel_stat.h>
|
|
|
|
|
|
|
|
#include "internals.h"
|
|
|
|
|
|
|
|
/**
|
2011-02-10 03:36:33 -07:00
|
|
|
* irq_set_chip - set the irq chip for an irq
|
2006-06-29 03:24:53 -06:00
|
|
|
* @irq: irq number
|
|
|
|
* @chip: pointer to irq chip description structure
|
|
|
|
*/
|
2011-02-10 03:36:33 -07:00
|
|
|
int irq_set_chip(unsigned int irq, struct irq_chip *chip)
|
2006-06-29 03:24:53 -06:00
|
|
|
{
|
2008-10-16 01:55:00 -06:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
2006-06-29 03:24:53 -06:00
|
|
|
unsigned long flags;
|
|
|
|
|
2008-08-19 21:50:14 -06:00
|
|
|
if (!desc) {
|
2008-07-25 20:45:37 -06:00
|
|
|
WARN(1, KERN_ERR "Trying to install chip for IRQ%d\n", irq);
|
2006-06-29 03:24:53 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!chip)
|
|
|
|
chip = &no_irq_chip;
|
|
|
|
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
2006-06-29 03:24:53 -06:00
|
|
|
irq_chip_set_defaults(chip);
|
2010-10-01 04:58:38 -06:00
|
|
|
desc->irq_data.chip = chip;
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-02-10 03:36:33 -07:00
|
|
|
EXPORT_SYMBOL(irq_set_chip);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
|
|
|
/**
|
2011-02-10 03:36:33 -07:00
|
|
|
* irq_set_type - set the irq trigger type for an irq
|
2006-06-29 03:24:53 -06:00
|
|
|
* @irq: irq number
|
2008-10-01 15:46:18 -06:00
|
|
|
* @type: IRQ_TYPE_{LEVEL,EDGE}_* value - see include/linux/irq.h
|
2006-06-29 03:24:53 -06:00
|
|
|
*/
|
2011-02-10 03:36:33 -07:00
|
|
|
int irq_set_irq_type(unsigned int irq, unsigned int type)
|
2006-06-29 03:24:53 -06:00
|
|
|
{
|
2008-10-16 01:55:00 -06:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
2006-06-29 03:24:53 -06:00
|
|
|
unsigned long flags;
|
|
|
|
int ret = -ENXIO;
|
|
|
|
|
2008-08-19 21:50:14 -06:00
|
|
|
if (!desc) {
|
2006-06-29 03:24:53 -06:00
|
|
|
printk(KERN_ERR "Trying to set irq type for IRQ%d\n", irq);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2008-12-01 15:31:38 -07:00
|
|
|
type &= IRQ_TYPE_SENSE_MASK;
|
2008-10-01 15:46:18 -06:00
|
|
|
if (type == IRQ_TYPE_NONE)
|
|
|
|
return 0;
|
|
|
|
|
2011-02-12 04:10:49 -07:00
|
|
|
chip_bus_lock(desc);
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
2008-10-20 12:41:58 -06:00
|
|
|
ret = __irq_set_trigger(desc, irq, type);
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
2011-02-12 04:10:49 -07:00
|
|
|
chip_bus_sync_unlock(desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
return ret;
|
|
|
|
}
|
2011-02-10 03:36:33 -07:00
|
|
|
EXPORT_SYMBOL(irq_set_irq_type);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
|
|
|
/**
|
2011-02-10 03:36:33 -07:00
|
|
|
* irq_set_handler_data - set irq handler data for an irq
|
2006-06-29 03:24:53 -06:00
|
|
|
* @irq: Interrupt number
|
|
|
|
* @data: Pointer to interrupt specific data
|
|
|
|
*
|
|
|
|
* Set the hardware irq controller data for an irq
|
|
|
|
*/
|
2011-02-10 03:36:33 -07:00
|
|
|
int irq_set_handler_data(unsigned int irq, void *data)
|
2006-06-29 03:24:53 -06:00
|
|
|
{
|
2008-10-16 01:55:00 -06:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
2006-06-29 03:24:53 -06:00
|
|
|
unsigned long flags;
|
|
|
|
|
2008-08-19 21:50:14 -06:00
|
|
|
if (!desc) {
|
2006-06-29 03:24:53 -06:00
|
|
|
printk(KERN_ERR
|
|
|
|
"Trying to install controller data for IRQ%d\n", irq);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
2010-10-01 04:58:38 -06:00
|
|
|
desc->irq_data.handler_data = data;
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
2006-06-29 03:24:53 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2011-02-10 03:36:33 -07:00
|
|
|
EXPORT_SYMBOL(irq_set_handler_data);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
2007-01-28 12:52:03 -07:00
|
|
|
/**
|
2011-02-10 03:36:33 -07:00
|
|
|
* irq_set_msi_desc - set MSI descriptor data for an irq
|
2007-01-28 12:52:03 -07:00
|
|
|
* @irq: Interrupt number
|
2007-02-16 02:28:25 -07:00
|
|
|
* @entry: Pointer to MSI descriptor data
|
2007-01-28 12:52:03 -07:00
|
|
|
*
|
2009-11-04 05:11:05 -07:00
|
|
|
* Set the MSI descriptor entry for an irq
|
2007-01-28 12:52:03 -07:00
|
|
|
*/
|
2011-02-10 03:36:33 -07:00
|
|
|
int irq_set_msi_desc(unsigned int irq, struct msi_desc *entry)
|
2007-01-28 12:52:03 -07:00
|
|
|
{
|
2008-10-16 01:55:00 -06:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
2007-01-28 12:52:03 -07:00
|
|
|
unsigned long flags;
|
|
|
|
|
2008-08-19 21:50:14 -06:00
|
|
|
if (!desc) {
|
2007-01-28 12:52:03 -07:00
|
|
|
printk(KERN_ERR
|
|
|
|
"Trying to install msi data for IRQ%d\n", irq);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2008-08-19 21:50:14 -06:00
|
|
|
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
2010-10-01 04:58:38 -06:00
|
|
|
desc->irq_data.msi_desc = entry;
|
2007-04-18 03:39:21 -06:00
|
|
|
if (entry)
|
|
|
|
entry->irq = irq;
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
2007-01-28 12:52:03 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-06-29 03:24:53 -06:00
|
|
|
/**
|
2011-02-10 03:36:33 -07:00
|
|
|
* irq_set_chip_data - set irq chip data for an irq
|
2006-06-29 03:24:53 -06:00
|
|
|
* @irq: Interrupt number
|
|
|
|
* @data: Pointer to chip specific data
|
|
|
|
*
|
|
|
|
* Set the hardware irq chip data for an irq
|
|
|
|
*/
|
2011-02-10 03:36:33 -07:00
|
|
|
int irq_set_chip_data(unsigned int irq, void *data)
|
2006-06-29 03:24:53 -06:00
|
|
|
{
|
2008-10-16 01:55:00 -06:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
2006-06-29 03:24:53 -06:00
|
|
|
unsigned long flags;
|
|
|
|
|
2008-08-19 21:50:14 -06:00
|
|
|
if (!desc) {
|
|
|
|
printk(KERN_ERR
|
|
|
|
"Trying to install chip data for IRQ%d\n", irq);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2010-10-01 04:58:38 -06:00
|
|
|
if (!desc->irq_data.chip) {
|
2006-06-29 03:24:53 -06:00
|
|
|
printk(KERN_ERR "BUG: bad set_irq_chip_data(IRQ#%d)\n", irq);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
2010-10-01 04:58:38 -06:00
|
|
|
desc->irq_data.chip_data = data;
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-02-10 03:36:33 -07:00
|
|
|
EXPORT_SYMBOL(irq_set_chip_data);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
2010-09-28 09:34:01 -06: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-07 14:11:30 -07:00
|
|
|
static void irq_state_clr_disabled(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
desc->istate &= ~IRQS_DISABLED;
|
|
|
|
irq_compat_clr_disabled(desc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void irq_state_set_disabled(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
desc->istate |= IRQS_DISABLED;
|
|
|
|
irq_compat_set_disabled(desc);
|
|
|
|
}
|
|
|
|
|
2011-02-08 04:36:06 -07:00
|
|
|
static void irq_state_clr_masked(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
desc->istate &= ~IRQS_MASKED;
|
|
|
|
irq_compat_clr_masked(desc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void irq_state_set_masked(struct irq_desc *desc)
|
|
|
|
{
|
|
|
|
desc->istate |= IRQS_MASKED;
|
|
|
|
irq_compat_set_masked(desc);
|
|
|
|
}
|
|
|
|
|
2011-02-02 14:41:14 -07:00
|
|
|
int irq_startup(struct irq_desc *desc)
|
|
|
|
{
|
2011-02-07 14:11:30 -07:00
|
|
|
irq_state_clr_disabled(desc);
|
2011-02-02 14:41:14 -07:00
|
|
|
desc->depth = 0;
|
|
|
|
|
2011-02-04 02:17:52 -07:00
|
|
|
if (desc->irq_data.chip->irq_startup) {
|
|
|
|
int ret = desc->irq_data.chip->irq_startup(&desc->irq_data);
|
2011-02-08 04:36:06 -07:00
|
|
|
irq_state_clr_masked(desc);
|
2011-02-04 02:17:52 -07:00
|
|
|
return ret;
|
|
|
|
}
|
2011-02-02 14:41:14 -07:00
|
|
|
|
2011-02-03 04:27:44 -07:00
|
|
|
irq_enable(desc);
|
2011-02-02 14:41:14 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void irq_shutdown(struct irq_desc *desc)
|
|
|
|
{
|
2011-02-07 14:11:30 -07:00
|
|
|
irq_state_set_disabled(desc);
|
2011-02-02 14:41:14 -07:00
|
|
|
desc->depth = 1;
|
2011-02-03 05:23:54 -07:00
|
|
|
if (desc->irq_data.chip->irq_shutdown)
|
|
|
|
desc->irq_data.chip->irq_shutdown(&desc->irq_data);
|
|
|
|
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);
|
2011-02-08 04:36:06 -07:00
|
|
|
irq_state_set_masked(desc);
|
2011-02-02 14:41:14 -07:00
|
|
|
}
|
|
|
|
|
2011-02-03 04:27:44 -07:00
|
|
|
void irq_enable(struct irq_desc *desc)
|
|
|
|
{
|
2011-02-07 14:11:30 -07:00
|
|
|
irq_state_clr_disabled(desc);
|
2011-02-03 05:23:54 -07:00
|
|
|
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);
|
2011-02-08 04:36:06 -07:00
|
|
|
irq_state_clr_masked(desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
}
|
|
|
|
|
2011-02-03 05:23:54 -07:00
|
|
|
void irq_disable(struct irq_desc *desc)
|
2008-02-18 10:25:17 -07:00
|
|
|
{
|
2011-02-07 14:11:30 -07:00
|
|
|
irq_state_set_disabled(desc);
|
2011-02-03 05:23:54 -07:00
|
|
|
if (desc->irq_data.chip->irq_disable) {
|
|
|
|
desc->irq_data.chip->irq_disable(&desc->irq_data);
|
|
|
|
}
|
2011-02-08 04:36:06 -07:00
|
|
|
irq_state_set_masked(desc);
|
2008-02-18 10:25:17 -07:00
|
|
|
}
|
|
|
|
|
2010-10-01 07:17:14 -06:00
|
|
|
#ifndef CONFIG_GENERIC_HARDIRQS_NO_DEPRECATED
|
2010-09-27 06:44:35 -06:00
|
|
|
/* Temporary migration helpers */
|
2010-09-27 06:44:42 -06:00
|
|
|
static void compat_irq_mask(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data->chip->mask(data->irq);
|
|
|
|
}
|
|
|
|
|
2010-09-27 06:44:44 -06:00
|
|
|
static void compat_irq_unmask(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data->chip->unmask(data->irq);
|
|
|
|
}
|
|
|
|
|
2010-09-27 06:44:47 -06:00
|
|
|
static void compat_irq_ack(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data->chip->ack(data->irq);
|
|
|
|
}
|
|
|
|
|
2010-09-27 06:44:50 -06:00
|
|
|
static void compat_irq_mask_ack(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data->chip->mask_ack(data->irq);
|
|
|
|
}
|
|
|
|
|
2010-09-27 06:44:53 -06:00
|
|
|
static void compat_irq_eoi(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data->chip->eoi(data->irq);
|
|
|
|
}
|
|
|
|
|
2010-09-27 06:44:56 -06:00
|
|
|
static void compat_irq_enable(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data->chip->enable(data->irq);
|
|
|
|
}
|
|
|
|
|
2010-09-27 06:45:02 -06:00
|
|
|
static void compat_irq_disable(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data->chip->disable(data->irq);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void compat_irq_shutdown(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data->chip->shutdown(data->irq);
|
|
|
|
}
|
|
|
|
|
2010-09-27 06:45:38 -06:00
|
|
|
static unsigned int compat_irq_startup(struct irq_data *data)
|
|
|
|
{
|
|
|
|
return data->chip->startup(data->irq);
|
|
|
|
}
|
|
|
|
|
2010-09-27 06:45:41 -06:00
|
|
|
static int compat_irq_set_affinity(struct irq_data *data,
|
|
|
|
const struct cpumask *dest, bool force)
|
|
|
|
{
|
|
|
|
return data->chip->set_affinity(data->irq, dest);
|
|
|
|
}
|
|
|
|
|
2010-09-27 06:45:47 -06:00
|
|
|
static int compat_irq_set_type(struct irq_data *data, unsigned int type)
|
|
|
|
{
|
|
|
|
return data->chip->set_type(data->irq, type);
|
|
|
|
}
|
|
|
|
|
2010-09-27 06:45:50 -06:00
|
|
|
static int compat_irq_set_wake(struct irq_data *data, unsigned int on)
|
|
|
|
{
|
|
|
|
return data->chip->set_wake(data->irq, on);
|
|
|
|
}
|
|
|
|
|
2010-09-27 06:45:53 -06:00
|
|
|
static int compat_irq_retrigger(struct irq_data *data)
|
|
|
|
{
|
|
|
|
return data->chip->retrigger(data->irq);
|
|
|
|
}
|
|
|
|
|
2010-09-27 06:44:35 -06:00
|
|
|
static void compat_bus_lock(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data->chip->bus_lock(data->irq);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void compat_bus_sync_unlock(struct irq_data *data)
|
|
|
|
{
|
|
|
|
data->chip->bus_sync_unlock(data->irq);
|
|
|
|
}
|
2010-10-01 07:17:14 -06:00
|
|
|
#endif
|
2010-09-27 06:44:35 -06:00
|
|
|
|
2006-06-29 03:24:53 -06:00
|
|
|
/*
|
|
|
|
* Fixup enable/disable function pointers
|
|
|
|
*/
|
|
|
|
void irq_chip_set_defaults(struct irq_chip *chip)
|
|
|
|
{
|
2010-10-01 07:17:14 -06:00
|
|
|
#ifndef CONFIG_GENERIC_HARDIRQS_NO_DEPRECATED
|
2010-09-27 06:44:56 -06:00
|
|
|
if (chip->enable)
|
|
|
|
chip->irq_enable = compat_irq_enable;
|
2010-09-27 06:45:02 -06:00
|
|
|
if (chip->disable)
|
|
|
|
chip->irq_disable = compat_irq_disable;
|
|
|
|
if (chip->shutdown)
|
|
|
|
chip->irq_shutdown = compat_irq_shutdown;
|
2010-09-27 06:45:38 -06:00
|
|
|
if (chip->startup)
|
|
|
|
chip->irq_startup = compat_irq_startup;
|
2006-11-16 02:19:10 -07:00
|
|
|
if (!chip->end)
|
|
|
|
chip->end = dummy_irq_chip.end;
|
2010-09-27 06:44:35 -06:00
|
|
|
if (chip->bus_lock)
|
|
|
|
chip->irq_bus_lock = compat_bus_lock;
|
|
|
|
if (chip->bus_sync_unlock)
|
|
|
|
chip->irq_bus_sync_unlock = compat_bus_sync_unlock;
|
2010-09-27 06:44:42 -06:00
|
|
|
if (chip->mask)
|
|
|
|
chip->irq_mask = compat_irq_mask;
|
2010-09-27 06:44:44 -06:00
|
|
|
if (chip->unmask)
|
|
|
|
chip->irq_unmask = compat_irq_unmask;
|
2010-09-27 06:44:47 -06:00
|
|
|
if (chip->ack)
|
|
|
|
chip->irq_ack = compat_irq_ack;
|
2010-09-27 06:44:50 -06:00
|
|
|
if (chip->mask_ack)
|
|
|
|
chip->irq_mask_ack = compat_irq_mask_ack;
|
2010-09-27 06:44:53 -06:00
|
|
|
if (chip->eoi)
|
|
|
|
chip->irq_eoi = compat_irq_eoi;
|
2010-09-27 06:45:41 -06:00
|
|
|
if (chip->set_affinity)
|
|
|
|
chip->irq_set_affinity = compat_irq_set_affinity;
|
2010-09-27 06:45:47 -06:00
|
|
|
if (chip->set_type)
|
|
|
|
chip->irq_set_type = compat_irq_set_type;
|
2010-09-27 06:45:50 -06:00
|
|
|
if (chip->set_wake)
|
|
|
|
chip->irq_set_wake = compat_irq_set_wake;
|
2010-09-27 06:45:53 -06:00
|
|
|
if (chip->retrigger)
|
|
|
|
chip->irq_retrigger = compat_irq_retrigger;
|
2010-10-01 07:17:14 -06:00
|
|
|
#endif
|
2006-06-29 03:24:53 -06:00
|
|
|
}
|
|
|
|
|
2010-09-27 06:44:50 -06:00
|
|
|
static inline void mask_ack_irq(struct irq_desc *desc)
|
2006-06-29 03:24:53 -06:00
|
|
|
{
|
2010-09-27 06:44:50 -06:00
|
|
|
if (desc->irq_data.chip->irq_mask_ack)
|
|
|
|
desc->irq_data.chip->irq_mask_ack(&desc->irq_data);
|
2006-06-29 03:24:53 -06:00
|
|
|
else {
|
2010-09-27 06:44:42 -06:00
|
|
|
desc->irq_data.chip->irq_mask(&desc->irq_data);
|
2010-09-27 06:44:47 -06:00
|
|
|
if (desc->irq_data.chip->irq_ack)
|
|
|
|
desc->irq_data.chip->irq_ack(&desc->irq_data);
|
2006-06-29 03:24:53 -06:00
|
|
|
}
|
2011-02-08 04:36:06 -07:00
|
|
|
irq_state_set_masked(desc);
|
2010-03-09 11:45:54 -07:00
|
|
|
}
|
|
|
|
|
2010-09-27 06:44:42 -06:00
|
|
|
static inline void mask_irq(struct irq_desc *desc)
|
2010-03-09 11:45:54 -07:00
|
|
|
{
|
2010-09-27 06:44:42 -06:00
|
|
|
if (desc->irq_data.chip->irq_mask) {
|
|
|
|
desc->irq_data.chip->irq_mask(&desc->irq_data);
|
2011-02-08 04:36:06 -07:00
|
|
|
irq_state_set_masked(desc);
|
2010-03-09 11:45:54 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-27 06:44:44 -06:00
|
|
|
static inline void unmask_irq(struct irq_desc *desc)
|
2010-03-09 11:45:54 -07:00
|
|
|
{
|
2010-09-27 06:44:44 -06:00
|
|
|
if (desc->irq_data.chip->irq_unmask) {
|
|
|
|
desc->irq_data.chip->irq_unmask(&desc->irq_data);
|
2011-02-08 04:36:06 -07:00
|
|
|
irq_state_clr_masked(desc);
|
2010-03-09 11:45:54 -07:00
|
|
|
}
|
2006-06-29 03:24:53 -06:00
|
|
|
}
|
|
|
|
|
2009-08-13 05:21:38 -06: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 08:46:45 -07:00
|
|
|
raw_spin_lock_irq(&desc->lock);
|
2009-08-13 05:21:38 -06:00
|
|
|
|
|
|
|
kstat_incr_irqs_this_cpu(irq, desc);
|
|
|
|
|
|
|
|
action = desc->action;
|
2011-02-07 14:11:30 -07:00
|
|
|
if (unlikely(!action || (desc->istate & IRQS_DISABLED)))
|
2009-08-13 05:21:38 -06:00
|
|
|
goto out_unlock;
|
|
|
|
|
2011-02-07 13:48:49 -07:00
|
|
|
irq_compat_set_progress(desc);
|
|
|
|
desc->istate |= IRQS_INPROGRESS;
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_unlock_irq(&desc->lock);
|
2009-08-13 05:21:38 -06:00
|
|
|
|
|
|
|
action_ret = action->thread_fn(action->irq, action->dev_id);
|
|
|
|
if (!noirqdebug)
|
|
|
|
note_interrupt(irq, desc, action_ret);
|
|
|
|
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_lock_irq(&desc->lock);
|
2011-02-07 13:48:49 -07:00
|
|
|
desc->istate &= ~IRQS_INPROGRESS;
|
|
|
|
irq_compat_clr_progress(desc);
|
2009-08-13 05:21:38 -06:00
|
|
|
|
|
|
|
out_unlock:
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_unlock_irq(&desc->lock);
|
2009-08-13 05:21:38 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(handle_nested_irq);
|
|
|
|
|
2011-02-07 02:34:30 -07:00
|
|
|
static bool irq_check_poll(struct irq_desc *desc)
|
|
|
|
{
|
2011-02-07 12:55:35 -07:00
|
|
|
if (!(desc->istate & IRQS_POLL_INPROGRESS))
|
2011-02-07 02:34:30 -07:00
|
|
|
return false;
|
|
|
|
return irq_wait_for_poll(desc);
|
|
|
|
}
|
|
|
|
|
2006-06-29 03:24:53 -06:00
|
|
|
/**
|
|
|
|
* handle_simple_irq - Simple and software-decoded IRQs.
|
|
|
|
* @irq: the interrupt number
|
|
|
|
* @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.
|
|
|
|
*/
|
2008-02-08 05:19:53 -07:00
|
|
|
void
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 07:55:46 -06:00
|
|
|
handle_simple_irq(unsigned int irq, struct irq_desc *desc)
|
2006-06-29 03:24:53 -06:00
|
|
|
{
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_lock(&desc->lock);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
2011-02-07 13:48:49 -07:00
|
|
|
if (unlikely(desc->istate & IRQS_INPROGRESS))
|
2011-02-07 02:34:30 -07:00
|
|
|
if (!irq_check_poll(desc))
|
|
|
|
goto out_unlock;
|
|
|
|
|
2011-02-08 03:39:15 -07:00
|
|
|
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
|
2008-10-15 07:27:23 -06:00
|
|
|
kstat_incr_irqs_this_cpu(irq, desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
2011-02-07 14:11:30 -07:00
|
|
|
if (unlikely(!desc->action || (desc->istate & IRQS_DISABLED)))
|
2006-06-29 03:24:53 -06:00
|
|
|
goto out_unlock;
|
|
|
|
|
2011-02-06 17:21:02 -07:00
|
|
|
handle_irq_event(desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
|
|
|
out_unlock:
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_unlock(&desc->lock);
|
2006-06-29 03:24:53 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* handle_level_irq - Level type irq handler
|
|
|
|
* @irq: the interrupt number
|
|
|
|
* @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.
|
|
|
|
*/
|
2008-02-08 05:19:53 -07:00
|
|
|
void
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 07:55:46 -06:00
|
|
|
handle_level_irq(unsigned int irq, struct irq_desc *desc)
|
2006-06-29 03:24:53 -06:00
|
|
|
{
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_lock(&desc->lock);
|
2010-09-27 06:44:50 -06:00
|
|
|
mask_ack_irq(desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
2011-02-07 13:48:49 -07:00
|
|
|
if (unlikely(desc->istate & IRQS_INPROGRESS))
|
2011-02-07 02:34:30 -07:00
|
|
|
if (!irq_check_poll(desc))
|
|
|
|
goto out_unlock;
|
|
|
|
|
2011-02-08 03:39:15 -07:00
|
|
|
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
|
2008-10-15 07:27:23 -06:00
|
|
|
kstat_incr_irqs_this_cpu(irq, desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If its disabled or no action available
|
|
|
|
* keep it masked and get out of here
|
|
|
|
*/
|
2011-02-07 14:11:30 -07:00
|
|
|
if (unlikely(!desc->action || (desc->istate & IRQS_DISABLED)))
|
2006-09-19 03:14:34 -06:00
|
|
|
goto out_unlock;
|
2006-06-29 03:24:53 -06:00
|
|
|
|
2011-02-06 17:22:17 -07:00
|
|
|
handle_irq_event(desc);
|
2009-08-13 04:17:22 -06:00
|
|
|
|
2011-02-07 14:11:30 -07:00
|
|
|
if (!(desc->istate & (IRQS_DISABLED | IRQS_ONESHOT)))
|
2010-09-27 06:44:44 -06:00
|
|
|
unmask_irq(desc);
|
2006-09-19 03:14:34 -06:00
|
|
|
out_unlock:
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_unlock(&desc->lock);
|
2006-06-29 03:24:53 -06:00
|
|
|
}
|
2009-01-14 04:34:21 -07:00
|
|
|
EXPORT_SYMBOL_GPL(handle_level_irq);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
|
|
|
/**
|
2006-06-29 03:25:03 -06:00
|
|
|
* handle_fasteoi_irq - irq handler for transparent controllers
|
2006-06-29 03:24:53 -06:00
|
|
|
* @irq: the interrupt number
|
|
|
|
* @desc: the interrupt description structure for this irq
|
|
|
|
*
|
2006-06-29 03:25:03 -06:00
|
|
|
* Only a single callback will be issued to the chip: an ->eoi()
|
2006-06-29 03:24:53 -06: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.
|
|
|
|
*/
|
2008-02-08 05:19:53 -07:00
|
|
|
void
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 07:55:46 -06:00
|
|
|
handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
|
2006-06-29 03:24:53 -06:00
|
|
|
{
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_lock(&desc->lock);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
2011-02-07 13:48:49 -07:00
|
|
|
if (unlikely(desc->istate & IRQS_INPROGRESS))
|
2011-02-07 02:34:30 -07:00
|
|
|
if (!irq_check_poll(desc))
|
|
|
|
goto out;
|
2006-06-29 03:24:53 -06:00
|
|
|
|
2011-02-08 03:39:15 -07:00
|
|
|
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
|
2008-10-15 07:27:23 -06:00
|
|
|
kstat_incr_irqs_this_cpu(irq, desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If its disabled or no action available
|
2007-02-16 02:28:24 -07:00
|
|
|
* then mask it and get out of here:
|
2006-06-29 03:24:53 -06:00
|
|
|
*/
|
2011-02-07 14:11:30 -07:00
|
|
|
if (unlikely(!desc->action || (desc->istate & IRQS_DISABLED))) {
|
2011-02-08 04:17:57 -07:00
|
|
|
irq_compat_set_pending(desc);
|
|
|
|
desc->istate |= IRQS_PENDING;
|
2010-09-27 06:44:42 -06:00
|
|
|
mask_irq(desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
goto out;
|
2006-06-29 03:25:01 -06:00
|
|
|
}
|
2011-02-06 17:23:07 -07:00
|
|
|
handle_irq_event(desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
out:
|
2010-09-27 06:44:53 -06:00
|
|
|
desc->irq_data.chip->irq_eoi(&desc->irq_data);
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_unlock(&desc->lock);
|
2006-06-29 03:24:53 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* handle_edge_irq - edge type IRQ handler
|
|
|
|
* @irq: the interrupt number
|
|
|
|
* @desc: the interrupt description structure for this irq
|
|
|
|
*
|
|
|
|
* Interrupt occures on the falling and/or rising edge of a hardware
|
|
|
|
* signal. The occurence is latched into the irq controller hardware
|
|
|
|
* 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-12 13:58:11 -07:00
|
|
|
* is handled by the associated event handler. If this happens it
|
2006-06-29 03:24:53 -06: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.
|
|
|
|
*/
|
2008-02-08 05:19:53 -07:00
|
|
|
void
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 07:55:46 -06:00
|
|
|
handle_edge_irq(unsigned int irq, struct irq_desc *desc)
|
2006-06-29 03:24:53 -06:00
|
|
|
{
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_lock(&desc->lock);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
2011-02-08 03:39:15 -07:00
|
|
|
desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
|
2006-06-29 03:24:53 -06:00
|
|
|
/*
|
|
|
|
* If we're currently running this IRQ, or its disabled,
|
|
|
|
* we shouldn't process the IRQ. Mark it pending, handle
|
|
|
|
* the necessary masking and go out
|
|
|
|
*/
|
2011-02-07 14:11:30 -07:00
|
|
|
if (unlikely((desc->istate & (IRQS_DISABLED | IRQS_INPROGRESS) ||
|
|
|
|
!desc->action))) {
|
2011-02-07 02:34:30 -07:00
|
|
|
if (!irq_check_poll(desc)) {
|
2011-02-08 04:17:57 -07:00
|
|
|
irq_compat_set_pending(desc);
|
|
|
|
desc->istate |= IRQS_PENDING;
|
2011-02-07 02:34:30 -07:00
|
|
|
mask_ack_irq(desc);
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2006-06-29 03:24:53 -06:00
|
|
|
}
|
2008-10-15 07:27:23 -06:00
|
|
|
kstat_incr_irqs_this_cpu(irq, desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
|
|
|
/* Start handling the irq */
|
2010-09-27 06:44:47 -06:00
|
|
|
desc->irq_data.chip->irq_ack(&desc->irq_data);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
|
|
|
do {
|
2011-02-06 17:24:07 -07:00
|
|
|
if (unlikely(!desc->action)) {
|
2010-09-27 06:44:42 -06:00
|
|
|
mask_irq(desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When another irq arrived while we were handling
|
|
|
|
* one, we could have masked the irq.
|
|
|
|
* Renable it, if it was not disabled in meantime.
|
|
|
|
*/
|
2011-02-08 04:17:57 -07:00
|
|
|
if (unlikely(desc->istate & IRQS_PENDING)) {
|
2011-02-07 14:11:30 -07:00
|
|
|
if (!(desc->istate & IRQS_DISABLED) &&
|
2011-02-08 04:36:06 -07:00
|
|
|
(desc->istate & IRQS_MASKED))
|
2011-02-07 14:11:30 -07:00
|
|
|
unmask_irq(desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
}
|
|
|
|
|
2011-02-06 17:24:07 -07:00
|
|
|
handle_irq_event(desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
2011-02-08 04:17:57 -07:00
|
|
|
} while ((desc->istate & IRQS_PENDING) &&
|
2011-02-07 14:11:30 -07:00
|
|
|
!(desc->istate & IRQS_DISABLED));
|
2006-06-29 03:24:53 -06:00
|
|
|
|
|
|
|
out_unlock:
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_unlock(&desc->lock);
|
2006-06-29 03:24:53 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-11-04 05:11:05 -07:00
|
|
|
* handle_percpu_irq - Per CPU local irq handler
|
2006-06-29 03:24:53 -06:00
|
|
|
* @irq: the interrupt number
|
|
|
|
* @desc: the interrupt description structure for this irq
|
|
|
|
*
|
|
|
|
* Per CPU interrupts on SMP machines without locking requirements
|
|
|
|
*/
|
2008-02-08 05:19:53 -07:00
|
|
|
void
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 07:55:46 -06:00
|
|
|
handle_percpu_irq(unsigned int irq, struct irq_desc *desc)
|
2006-06-29 03:24:53 -06:00
|
|
|
{
|
2011-02-10 04:20:23 -07:00
|
|
|
struct irq_chip *chip = irq_desc_get_chip(desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
2008-10-15 07:27:23 -06:00
|
|
|
kstat_incr_irqs_this_cpu(irq, desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
2011-02-06 17:25:41 -07:00
|
|
|
if (chip->irq_ack)
|
|
|
|
chip->irq_ack(&desc->irq_data);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
2011-02-06 17:25:41 -07:00
|
|
|
handle_irq_event_percpu(desc, desc->action);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
2011-02-06 17:25:41 -07:00
|
|
|
if (chip->irq_eoi)
|
|
|
|
chip->irq_eoi(&desc->irq_data);
|
2006-06-29 03:24:53 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2006-10-17 01:10:03 -06:00
|
|
|
__set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
|
|
|
|
const char *name)
|
2006-06-29 03:24:53 -06:00
|
|
|
{
|
2008-10-16 01:55:00 -06:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
2006-06-29 03:24:53 -06:00
|
|
|
unsigned long flags;
|
|
|
|
|
2008-08-19 21:50:14 -06:00
|
|
|
if (!desc) {
|
2006-06-29 03:24:53 -06:00
|
|
|
printk(KERN_ERR
|
|
|
|
"Trying to install type control for IRQ%d\n", irq);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!handle)
|
|
|
|
handle = handle_bad_irq;
|
2010-10-01 04:58:38 -06:00
|
|
|
else if (desc->irq_data.chip == &no_irq_chip) {
|
2006-07-01 15:30:08 -06:00
|
|
|
printk(KERN_WARNING "Trying to install %sinterrupt handler "
|
2006-12-20 07:59:48 -07:00
|
|
|
"for IRQ%d\n", is_chained ? "chained " : "", irq);
|
2006-07-01 15:30:08 -06:00
|
|
|
/*
|
|
|
|
* Some ARM implementations install a handler for really dumb
|
|
|
|
* interrupt hardware without setting an irq_chip. This worked
|
|
|
|
* with the ARM no_irq_chip but the check in setup_irq would
|
|
|
|
* prevent us to setup the interrupt at all. Switch it to
|
|
|
|
* dummy_irq_chip for easy transition.
|
|
|
|
*/
|
2010-10-01 04:58:38 -06:00
|
|
|
desc->irq_data.chip = &dummy_irq_chip;
|
2006-07-01 15:30:08 -06:00
|
|
|
}
|
2006-06-29 03:24:53 -06:00
|
|
|
|
2010-09-27 06:44:35 -06:00
|
|
|
chip_bus_lock(desc);
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
|
|
|
/* Uninstall? */
|
|
|
|
if (handle == handle_bad_irq) {
|
2010-10-01 04:58:38 -06:00
|
|
|
if (desc->irq_data.chip != &no_irq_chip)
|
2010-09-27 06:44:50 -06:00
|
|
|
mask_ack_irq(desc);
|
2011-02-07 14:11:30 -07:00
|
|
|
irq_compat_set_disabled(desc);
|
|
|
|
desc->istate |= IRQS_DISABLED;
|
2006-06-29 03:24:53 -06:00
|
|
|
desc->depth = 1;
|
|
|
|
}
|
|
|
|
desc->handle_irq = handle;
|
2006-10-17 01:10:03 -06:00
|
|
|
desc->name = name;
|
2006-06-29 03:24:53 -06:00
|
|
|
|
|
|
|
if (handle != handle_bad_irq && is_chained) {
|
2011-02-09 06:44:17 -07:00
|
|
|
irq_settings_set_noprobe(desc);
|
|
|
|
irq_settings_set_norequest(desc);
|
2011-02-02 14:41:14 -07:00
|
|
|
irq_startup(desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
}
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
2010-09-27 06:44:35 -06:00
|
|
|
chip_bus_sync_unlock(desc);
|
2006-06-29 03:24:53 -06:00
|
|
|
}
|
2009-01-14 04:34:21 -07:00
|
|
|
EXPORT_SYMBOL_GPL(__set_irq_handler);
|
2006-06-29 03:24:53 -06:00
|
|
|
|
|
|
|
void
|
|
|
|
set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
|
2006-10-05 06:06:34 -06:00
|
|
|
irq_flow_handler_t handle)
|
2006-06-29 03:24:53 -06:00
|
|
|
{
|
2011-02-10 04:20:23 -07:00
|
|
|
irq_set_chip(irq, chip);
|
2006-10-17 01:10:03 -06:00
|
|
|
__set_irq_handler(irq, handle, 0, NULL);
|
2006-06-29 03:24:53 -06:00
|
|
|
}
|
|
|
|
|
2006-10-17 01:10:03 -06:00
|
|
|
void
|
|
|
|
set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
|
|
|
|
irq_flow_handler_t handle, const char *name)
|
2006-06-29 03:24:53 -06:00
|
|
|
{
|
2011-02-10 04:20:23 -07:00
|
|
|
irq_set_chip(irq, chip);
|
2006-10-17 01:10:03 -06:00
|
|
|
__set_irq_handler(irq, handle, 0, name);
|
2006-06-29 03:24:53 -06:00
|
|
|
}
|
2008-02-08 05:22:01 -07:00
|
|
|
|
2010-09-28 02:40:18 -06:00
|
|
|
void irq_modify_status(unsigned int irq, unsigned long clr, unsigned long set)
|
2008-02-08 05:22:01 -07:00
|
|
|
{
|
2008-10-16 01:55:00 -06:00
|
|
|
struct irq_desc *desc = irq_to_desc(irq);
|
2008-02-08 05:22:01 -07:00
|
|
|
unsigned long flags;
|
|
|
|
|
2010-09-28 02:40:18 -06:00
|
|
|
if (!desc)
|
2008-02-08 05:22:01 -07:00
|
|
|
return;
|
|
|
|
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_lock_irqsave(&desc->lock, flags);
|
2011-02-08 09:11:03 -07:00
|
|
|
|
|
|
|
irq_settings_clr_and_set(desc, clr, set);
|
|
|
|
|
2011-02-08 09:28:12 -07:00
|
|
|
irqd_clear(&desc->irq_data, IRQD_NO_BALANCING | IRQD_PER_CPU |
|
|
|
|
IRQD_TRIGGER_MASK | IRQD_LEVEL);
|
2011-02-08 09:11:03 -07: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-08 09:28:12 -07:00
|
|
|
irqd_set(&desc->irq_data, irq_settings_get_trigger_mask(desc));
|
|
|
|
|
2009-11-17 08:46:45 -07:00
|
|
|
raw_spin_unlock_irqrestore(&desc->lock, flags);
|
2008-02-08 05:22:01 -07:00
|
|
|
}
|