三读内核中断处理（5）：中断系统提供的API

快乐虾

http://blog.csdn.net/lights_joy/

[e-mail]

本文适用于

ADSP-BF561

优视BF561EVB开发板

uclinux-2008r1.5-rc3(smp patch)

Visual DSP++ 5.0(update 5)

欢迎转载，但请保留作者信息

中断系统提供的API大都在kernel/irq/manage.c中。

1.1 synchronize_irq

这个函数用于在两个核间进行中断的同步：

/**

* synchronize_irq - wait for pending IRQ handlers (on other CPUs)

* @irq: interrupt number to wait for

*

* This function waits for any pending IRQ handlers for this interrupt

* to complete before returning. If you use this function while

* holding a resource the IRQ handler may need you will deadlock.

*

* This function may be called - with care - from IRQ context.

*/

void synchronize_irq(unsigned int irq)

{

struct irq_desc *desc = irq_desc + irq;

if (irq >= NR_IRQS)

return;

while (desc->status & IRQ_INPROGRESS)

cpu_relax();

}

这个函数仅用于使用SMP的情况。由于每一个核都可以同等地处理每一个外部中断，因此有时候需要进行同步，从代码可以看出，它就是简单地等待一个中断处理完成。

1.2 disable_irq_nosync

这个函数用于关闭指定中断：

/**

* disable_irq_nosync - disable an irq without waiting

* @irq: Interrupt to disable

*

* Disable the selected interrupt line. Disables and Enables are

* nested.

* Unlike disable_irq(), this function does not ensure existing

* instances of the IRQ handler have completed before returning.

*

* This function may be called from IRQ context.

*/

void disable_irq_nosync(unsigned int irq)

{

struct irq_desc *desc = irq_desc + irq;

unsigned long flags;

if (irq >= NR_IRQS)

return;

spin_lock_irqsave(&desc->lock, flags);

if (!desc->depth++) {

desc->status |= IRQ_DISABLED;

desc->chip->disable(irq);

}

spin_unlock_irqrestore(&desc->lock, flags);

}

可以看出，这个函数直接调用irq_chip的成员disable这一回调函数，野蛮的关闭硬件中断！

1.3 disable_irq

这个函数将关闭硬件中断并等待（可能有的）中断处理完成。

/**

* disable_irq - disable an irq and wait for completion

* @irq: Interrupt to disable

*

* Disable the selected interrupt line. Enables and Disables are

* nested.

* This function waits for any pending IRQ handlers for this interrupt

* to complete before returning. If you use this function while

* holding a resource the IRQ handler may need you will deadlock.

*

* This function may be called - with care - from IRQ context.

*/

void disable_irq(unsigned int irq)

{

struct irq_desc *desc = irq_desc + irq;

if (irq >= NR_IRQS)

return;

disable_irq_nosync(irq);

if (desc->action)

synchronize_irq(irq);

}

1.4 enable_irq

这个函数用于启用一个指定的中断。

/**

* enable_irq - enable handling of an irq

* @irq: Interrupt to enable

*

* Undoes the effect of one call to disable_irq(). If this

* matches the last disable, processing of interrupts on this

* IRQ line is re-enabled.

*

* This function may be called from IRQ context.

*/

void enable_irq(unsigned int irq)

{

struct irq_desc *desc = irq_desc + irq;

unsigned long flags;

if (irq >= NR_IRQS)

return;

spin_lock_irqsave(&desc->lock, flags);

switch (desc->depth) {

case 0:

printk(KERN_WARNING "Unbalanced enable for IRQ %d\n", irq);

WARN_ON(1);

break;

case 1: {

unsigned int status = desc->status & ~IRQ_DISABLED;

/* Prevent probing on this irq: */

desc->status = status | IRQ_NOPROBE;

check_irq_resend(desc, irq);

/* fall-through */

}

default:

desc->depth--;

}

spin_unlock_irqrestore(&desc->lock, flags);

}

在系统初始化完成的时候，每个irq_desc->depth值都将初始化为1。因而这个函数将直接执行check_irq_resend启用中断。

1.5 free_irq

这个函数用于释放中断：

/**

* free_irq - free an interrupt

* @irq: Interrupt line to free

* @dev_id: Device identity to free

*

* Remove an interrupt handler. The handler is removed and if the

* interrupt line is no longer in use by any driver it is disabled.

* On a shared IRQ the caller must ensure the interrupt is disabled

* on the card it drives before calling this function. The function

* does not return until any executing interrupts for this IRQ

* have completed.

*

* This function must not be called from interrupt context.

*/

void free_irq(unsigned int irq, void *dev_id)

{

struct irq_desc *desc;

struct irqaction **p;

unsigned long flags;

irqreturn_t (*handler)(int, void *) = NULL;

WARN_ON(in_interrupt());

if (irq >= NR_IRQS)

return;

desc = irq_desc + irq;

spin_lock_irqsave(&desc->lock, flags);

p = &desc->action;

for (;;) {

struct irqaction *action = *p;

if (action) {

struct irqaction **pp = p;

p = &action->next;

if (action->dev_id != dev_id)

continue;

/* Found it - now remove it from the list of entries */

*pp = action->next;

/* Currently used only by UML, might disappear one day.*/

#ifdef CONFIG_IRQ_RELEASE_METHOD

if (desc->chip->release)

desc->chip->release(irq, dev_id);

#endif

if (!desc->action) {

desc->status |= IRQ_DISABLED;

if (desc->chip->shutdown)

desc->chip->shutdown(irq);

else

desc->chip->disable(irq);

}

spin_unlock_irqrestore(&desc->lock, flags);

unregister_handler_proc(irq, action);

/* Make sure it's not being used on another CPU */

synchronize_irq(irq);

if (action->flags & IRQF_SHARED)

handler = action->handler;

kfree(action);

return;

}

printk(KERN_ERR "Trying to free already-free IRQ %d\n", irq);

spin_unlock_irqrestore(&desc->lock, flags);

return;

}

#ifdef CONFIG_DEBUG_SHIRQ

if (handler) {

/*

* It's a shared IRQ -- the driver ought to be prepared for it

* to happen even now it's being freed, so let's make sure....

* We do this after actually deregistering it, to make sure that

* a 'real' IRQ doesn't run in parallel with our fake

*/

handler(irq, dev_id);

}

#endif

}

1.6 request_irq

这个函数用以自己指定一个中断的处理函数。

/**

* request_irq - allocate an interrupt line

* @irq: Interrupt line to allocate

* @handler: Function to be called when the IRQ occurs

* @irqflags: Interrupt type flags

* @devname: 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. From the point this

* call is made your handler function may be invoked. Since

* your handler function must clear any interrupt the board

* raises, you must take care both to initialise your hardware

* and to set up the interrupt handler in the right order.

*

* 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 your interrupt is shared you must pass a non NULL dev_id

* as this is required when freeing the interrupt.

*

* Flags:

*

* IRQF_SHARED Interrupt is shared

* IRQF_DISABLED Disable local interrupts while processing

* IRQF_SAMPLE_RANDOM The interrupt can be used for entropy

*

*/

int request_irq(unsigned int irq, irq_handler_t handler,

unsigned long irqflags, const char *devname, void *dev_id)

{

struct irqaction *action;

int retval;

#ifdef CONFIG_LOCKDEP

/*

* Lockdep wants atomic interrupt handlers:

*/

irqflags |= IRQF_DISABLED;

#endif

/*

* Sanity-check: shared interrupts must pass in a real dev-ID,

* otherwise we'll have trouble later trying to figure out

* which interrupt is which (messes up the interrupt freeing

* logic etc).

*/

if ((irqflags & IRQF_SHARED) && !dev_id)

return -EINVAL;

if (irq >= NR_IRQS)

return -EINVAL;

if (irq_desc[irq].status & IRQ_NOREQUEST)

return -EINVAL;

if (!handler)

return -EINVAL;

action = kmalloc(sizeof(struct irqaction), GFP_ATOMIC);

if (!action)

return -ENOMEM;

action->handler = handler;

action->flags = irqflags;

cpus_clear(action->mask);

action->name = devname;

action->next = NULL;

action->dev_id = dev_id;

select_smp_affinity(irq);

#ifdef CONFIG_DEBUG_SHIRQ

if (irqflags & IRQF_SHARED) {

/*

* It's a shared IRQ -- the driver ought to be prepared for it

* to happen immediately, so let's make sure....

* We do this before actually registering it, to make sure that

* a 'real' IRQ doesn't run in parallel with our fake

*/

if (irqflags & IRQF_DISABLED) {

unsigned long flags;

local_irq_save(flags);

handler(irq, dev_id);

local_irq_restore(flags);

} else

handler(irq, dev_id);

}

#endif

retval = setup_irq(irq, action);

if (retval)

kfree(action);

return retval;

}

这里直接用kmalloc来分配irqaction其实挺浪费空间的。当然由于中断个数有限，其浪费的空间数量也有限，呵呵。