/**
* 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
*/
void handle_percpu_devid_irq(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;
kstat_incr_irqs_this_cpu(desc);
if (chip->irq_ack)
chip->irq_ack(&desc->irq_data);
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);
}
if (chip->irq_eoi)
chip->irq_eoi(&desc->irq_data);
}
/**
* handle_IRQ_event - irq action chain handler
* @irq: the interrupt number
* @action: the interrupt action chain for this irq
*
* Handles the action chain of an irq event
*/
irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
{
irqreturn_t ret, retval = IRQ_NONE;
unsigned int status = 0;
do {
trace_irq_handler_entry(irq, action);
ret = action->handler(irq, action->dev_id);
trace_irq_handler_exit(irq, action, ret);
switch (ret) {
case IRQ_WAKE_THREAD:
/*
* Set result to handled so the spurious check
* does not trigger.
*/
ret = IRQ_HANDLED;
/*
* Catch drivers which return WAKE_THREAD but
* did not set up a thread function
*/
if (unlikely(!action->thread_fn)) {
warn_no_thread(irq, action);
break;
}
/*
* Wake up the handler thread for this
* action. In case the thread crashed and was
* killed we just pretend that we handled the
* interrupt. The hardirq handler above has
* disabled the device interrupt, so no irq
* storm is lurking.
*/
if (likely(!test_bit(IRQTF_DIED,
&action->thread_flags))) {
set_bit(IRQTF_RUNTHREAD, &action->thread_flags);
wake_up_process(action->thread);
}
/* Fall through to add to randomness */
case IRQ_HANDLED:
status |= action->flags;
break;
default:
break;
}
retval |= ret;
action = action->next;
} while (action);
if (status & IRQF_SAMPLE_RANDOM)
add_interrupt_randomness(irq);
local_irq_disable();
return retval;
}
irqreturn_t
handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)
{
irqreturn_t retval = IRQ_NONE;
unsigned int random = 0, irq = desc->irq_data.irq;
do {
irqreturn_t res;
#ifdef CONFIG_SEC_DEBUG
sec_debug_timer_log(4444, (int)irqs_disabled(),
(void *)action->handler);
#endif
trace_irq_handler_entry(irq, action);
res = action->handler(irq, action->dev_id);
trace_irq_handler_exit(irq, action, res);
#ifdef CONFIG_SEC_DEBUG
sec_debug_timer_log(5555, (int)irqs_disabled(),
(void *)action->handler);
/* sec_debug_irq_sched_log(irq, (void *)action->handler, 2); */
#endif
if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts\n",
irq, action->handler))
local_irq_disable();
switch (res) {
case IRQ_WAKE_THREAD:
/*
* Catch drivers which return WAKE_THREAD but
* did not set up a thread function
*/
if (unlikely(!action->thread_fn)) {
warn_no_thread(irq, action);
break;
}
irq_wake_thread(desc, action);
/* Fall through to add to randomness */
case IRQ_HANDLED:
random |= action->flags;
break;
default:
break;
}
retval |= res;
action = action->next;
} while (action);
if (random & IRQF_SAMPLE_RANDOM)
add_interrupt_randomness(irq);
if (!noirqdebug)
note_interrupt(irq, desc, retval);
return retval;
}
irqreturn_t
handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)
{
irqreturn_t retval = IRQ_NONE;
unsigned int flags = 0, irq = desc->irq_data.irq;
#ifdef CONFIG_FOOTPRINT_IRQ
update_handle_irqs_this_cpu(irq);
#endif
do {
irqreturn_t res;
trace_irq_handler_entry(irq, action);
res = action->handler(irq, action->dev_id);
trace_irq_handler_exit(irq, action, res);
if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts\n",
irq, action->handler))
local_irq_disable();
switch (res) {
case IRQ_WAKE_THREAD:
/*
* Catch drivers which return WAKE_THREAD but
* did not set up a thread function
*/
if (unlikely(!action->thread_fn)) {
warn_no_thread(irq, action);
break;
}
irq_wake_thread(desc, action);
/* Fall through to add to randomness */
case IRQ_HANDLED:
flags |= action->flags;
break;
default:
break;
}
retval |= res;
action = action->next;
} while (action);
add_interrupt_randomness(irq, flags);
if (!noirqdebug)
note_interrupt(irq, desc, retval);
#ifdef CONFIG_FOOTPRINT_IRQ
release_handle_irqs_this_cpu(irq);
#endif
return retval;
}
irqreturn_t
handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)
{
irqreturn_t retval = IRQ_NONE;
unsigned int random = 0, irq = desc->irq_data.irq;
do {
irqreturn_t res;
trace_irq_handler_entry(irq, action);
res = action->handler(irq, action->dev_id);
trace_irq_handler_exit(irq, action, res);
if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts\n",
irq, action->handler))
local_irq_disable();
switch (res) {
case IRQ_WAKE_THREAD:
/*
* Set result to handled so the spurious check
* does not trigger.
*/
res = IRQ_HANDLED;
/*
* Catch drivers which return WAKE_THREAD but
* did not set up a thread function
*/
if (unlikely(!action->thread_fn)) {
warn_no_thread(irq, action);
break;
}
irq_wake_thread(desc, action);
/* Fall through to add to randomness */
case IRQ_HANDLED:
random |= action->flags;
break;
default:
break;
}
retval |= res;
action = action->next;
} while (action);
if (random & IRQF_SAMPLE_RANDOM)
add_interrupt_randomness(irq);
if (!noirqdebug)
note_interrupt(irq, desc, retval);
return retval;
}
irqreturn_t
handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)
{
irqreturn_t retval = IRQ_NONE;
unsigned int flags = 0, irq = desc->irq_data.irq;
while (action) {
irqreturn_t res;
if(!action->handler) {
printk(KERN_WARNING "IRQ %d device %s get event "
"but no action handle function available.", irq, action->name);
action = action->next;
continue;
}
trace_irq_handler_entry(irq, action);
res = action->handler(irq, action->dev_id);
trace_irq_handler_exit(irq, action, res);
if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts\n",
irq, action->handler))
local_irq_disable();
switch (res) {
case IRQ_WAKE_THREAD:
/*
* Catch drivers which return WAKE_THREAD but
* did not set up a thread function
*/
if (unlikely(!action->thread_fn)) {
warn_no_thread(irq, action);
break;
}
irq_wake_thread(desc, action);
/* Fall through to add to randomness */
case IRQ_HANDLED:
flags |= action->flags;
break;
default:
break;
}
retval |= res;
action = action->next;
}
add_interrupt_randomness(irq, flags);
if (!noirqdebug)
note_interrupt(irq, desc, retval);
return retval;
}
/**
* handle_percpu_devid_irq - Per CPU local irq handler with per cpu dev ids
* @irq: the interrupt number
* @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
*/
void handle_percpu_devid_irq(unsigned int irq, struct irq_desc *desc)
{
struct irq_chip *chip = irq_desc_get_chip(desc);
struct irqaction *action = desc->action;
void *dev_id = __this_cpu_ptr(action->percpu_dev_id);
irqreturn_t res;
kstat_incr_irqs_this_cpu(irq, desc);
if (chip->irq_ack)
chip->irq_ack(&desc->irq_data);
trace_irq_handler_entry(irq, action);
res = action->handler(irq, dev_id);
trace_irq_handler_exit(irq, action, res);
if (chip->irq_eoi)
chip->irq_eoi(&desc->irq_data);
}
static inline void __mt_irq_enter(int irq){
struct irq_desc *desc ;
struct irqaction *action ;
#ifdef CONFIG_SMP
if (irq >= IPI_CPU_START && irq < IPI_TIMER + NR_IPI){
action = &mt_trace_ipiaction[irq - IPI_CPU_START];
}else{
#endif
desc = irq_to_desc(irq);
if(likely(desc && desc->action))
action = desc->action;
else
action = &mt_trace_unknown_irqaction;
#ifdef CONFIG_SMP
}
#endif
trace_irq_handler_entry(irq, action);
}
irqreturn_t __handle_irq_event_percpu(struct irq_desc *desc, unsigned int *flags)
{
irqreturn_t retval = IRQ_NONE;
unsigned int irq = desc->irq_data.irq;
struct irqaction *action;
for_each_action_of_desc(desc, action) {
irqreturn_t res;
trace_irq_handler_entry(irq, action);
res = action->handler(irq, action->dev_id);
trace_irq_handler_exit(irq, action, res);
if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts\n",
irq, action->handler))
local_irq_disable();
switch (res) {
case IRQ_WAKE_THREAD:
/*
* Catch drivers which return WAKE_THREAD but
* did not set up a thread function
*/
if (unlikely(!action->thread_fn)) {
warn_no_thread(irq, action);
break;
}
__irq_wake_thread(desc, action);
/* Fall through to add to randomness */
case IRQ_HANDLED:
*flags |= action->flags;
break;
default:
break;
}
retval |= res;
}
irqreturn_t
handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)
{
irqreturn_t retval = IRQ_NONE;
unsigned int flags = 0, irq = desc->irq_data.irq;
do {
irqreturn_t res;
#ifdef CONFIG_SEC_DEBUG_RT_THROTTLE_ACTIVE
unsigned long long start_time, end_time;
start_time = sec_debug_clock();
#endif
sec_debug_irq_log(irq, (void *)action->handler, 1);
trace_irq_handler_entry(irq, action);
exynos_ss_irq(irq, (void *)action->handler, (int)irqs_disabled(), ESS_FLAG_IN);
res = action->handler(irq, action->dev_id);
exynos_ss_irq(irq, (void *)action->handler, (int)irqs_disabled(), ESS_FLAG_OUT);
trace_irq_handler_exit(irq, action, res);
sec_debug_irq_log(irq, (void *)action->handler, 2);
#ifdef CONFIG_SEC_DEBUG_RT_THROTTLE_ACTIVE
end_time = sec_debug_clock();
if (start_time + 950000000 < end_time) {
sec_debug_aux_log(SEC_DEBUG_AUXLOG_IRQ, "I:%llu %pf", start_time, action->handler);
}
#endif
if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts\n",
irq, action->handler))
local_irq_disable();
switch (res) {
case IRQ_WAKE_THREAD:
/*
* Catch drivers which return WAKE_THREAD but
* did not set up a thread function
*/
if (unlikely(!action->thread_fn)) {
warn_no_thread(irq, action);
break;
}
irq_wake_thread(desc, action);
/* Fall through to add to randomness */
case IRQ_HANDLED:
flags |= action->flags;
break;
default:
break;
}
retval |= res;
action = action->next;
} while (action);
add_interrupt_randomness(irq, flags);
if (!noirqdebug)
note_interrupt(irq, desc, retval);
return retval;
}
irqreturn_t
handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)
{
irqreturn_t retval = IRQ_NONE;
unsigned int random = 0, irq = desc->irq_data.irq;
#ifdef CONFIG_MTPROF_IRQ_DURATION
unsigned long long t1, t2, dur;
#ifdef CONFIG_ISR_MONITOR
char aee_str[40];
#endif
#endif
do {
irqreturn_t res;
trace_irq_handler_entry(irq, action);
#ifdef CONFIG_MTPROF_IRQ_DURATION
t1 = sched_clock();
res = action->handler(irq, action->dev_id);
t2 = sched_clock();
dur = t2 - t1;
action->duration += dur;
action->count++;
action->dur_max = max(dur,action->dur_max);
action->dur_min = min(dur,action->dur_min);
#ifdef CONFIG_MTPROF_CPUTIME
if(mtsched_enabled == 1)
{
int isr_find = 0;
struct mtk_isr_info *mtk_isr_point = current->se.mtk_isr;
struct mtk_isr_info *mtk_isr_current = mtk_isr_point;
char *isr_name = NULL;
current->se.mtk_isr_time += dur;
while(mtk_isr_point != NULL)
{
if(mtk_isr_point->isr_num == irq)
{
mtk_isr_point->isr_time += dur;
mtk_isr_point->isr_count++;
isr_find = 1;
break;
}
mtk_isr_current = mtk_isr_point;
mtk_isr_point = mtk_isr_point -> next;
}
if(isr_find == 0)
{
mtk_isr_point = kmalloc(sizeof(struct mtk_isr_info), GFP_ATOMIC);
if(mtk_isr_point == NULL)
{
printk(KERN_ERR"cant' alloc mtk_isr_info mem!\n");
}
else
{
mtk_isr_point->isr_num = irq;
mtk_isr_point->isr_time = dur;
mtk_isr_point->isr_count = 1;
mtk_isr_point->next = NULL;
if(mtk_isr_current == NULL)
{
current->se.mtk_isr = mtk_isr_point;
}
else
{
mtk_isr_current->next = mtk_isr_point;
}
isr_name = kmalloc(sizeof(action->name),GFP_ATOMIC);
if(isr_name != NULL)
{
strcpy(isr_name, action->name);
mtk_isr_point->isr_name = isr_name;
}
else
{
printk(KERN_ERR"cant' alloc isr_name mem!\n");
}
current->se.mtk_isr_count++;
}
}
}
#endif
#ifdef CONFIG_ISR_MONITOR
if(unlikely(dur>TIME_3MS)){
if(in_white_list(irq)){
printk("[ISR Monitor] Warning! ISR%d:%s too long, %llu ns > 3 ms, t1:%llu, t2:%llu\n", irq, action->name, dur, t1, t2);
}else if(dur>TIME_6MS){
sprintf( aee_str, "ISR#%d:%s too long>6ms\n", irq, action->name);
aee_kernel_exception( aee_str,"isr_monitor\n");
printk("[ISR Monitor] Warning! ISR%d:%s too long, %llu ns > 10 ms, t1:%llu, t2:%llu\n", irq, action->name, dur, t1, t2);
}else{
sprintf( aee_str, "ISR#%d:%s too long>3ms\n", irq, action->name);
aee_kernel_warning( aee_str,"isr_monitor\n");
printk("[ISR Monitor] Warning! ISR%d:%s too long, %llu ns > 3 ms, t1:%llu, t2:%llu\n", irq, action->name, dur, t1, t2);
}
}
#endif
#else
res = action->handler(irq, action->dev_id);
#endif
trace_irq_handler_exit(irq, action, res);
if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts\n",
irq, action->handler))
local_irq_disable();
switch (res) {
case IRQ_WAKE_THREAD:
/*
* Catch drivers which return WAKE_THREAD but
* did not set up a thread function
*/
if (unlikely(!action->thread_fn)) {
warn_no_thread(irq, action);
break;
}
irq_wake_thread(desc, action);
/* Fall through to add to randomness */
case IRQ_HANDLED:
random |= action->flags;
break;
default:
break;
}
retval |= res;
action = action->next;
} while (action);
if (random & IRQF_SAMPLE_RANDOM)
add_interrupt_randomness(irq);
if (!noirqdebug)
note_interrupt(irq, desc, retval);
return retval;
}
irqreturn_t
handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)
{
irqreturn_t retval = IRQ_NONE;
unsigned int random = 0, irq = desc->irq_data.irq;
#ifdef CONFIG_MSM_SM_EVENT
sm_msm_irq_data_t sm_irq;
#endif
if (irq==32) //the smd dev irq is 32
{
smd_irq_stamp[smd_irq_stamp_index++] = jiffies;
smd_irq_stamp_index = smd_irq_stamp_index & (MAX_SMD_IRQ_STAMP_NUM - 1 );
}
last_irq_stamp = jiffies;
do {
irqreturn_t res;
trace_irq_handler_entry(irq, action);
#ifdef CONFIG_MSM_SM_EVENT
sm_irq.func_addr = (unsigned int)action->handler;
sm_irq.irq_num = irq;
sm_add_event(SM_IRQ_EVENT | IRQ_EVENT_ENTER,
SM_EVENT_START, 0, &sm_irq, sizeof(sm_msm_irq_data_t));
#endif
res = action->handler(irq, action->dev_id);
trace_irq_handler_exit(irq, action, res);
/*
#ifdef CONFIG_MSM_SM_EVENT
sm_add_event(SM_IRQ_EVENT | IRQ_EVENT_LEAVE,
SM_EVENT_END, 0, &sm_irq, sizeof(sm_msm_irq_data_t));
#endif
*/
if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts\n",
irq, action->handler))
local_irq_disable();
switch (res) {
case IRQ_WAKE_THREAD:
/*
* Catch drivers which return WAKE_THREAD but
* did not set up a thread function
*/
if (unlikely(!action->thread_fn)) {
warn_no_thread(irq, action);
break;
}
irq_wake_thread(desc, action);
/* Fall through to add to randomness */
case IRQ_HANDLED:
random |= action->flags;
break;
default:
break;
}
retval |= res;
action = action->next;
} while (action);
if (random & IRQF_SAMPLE_RANDOM)
add_interrupt_randomness(irq);
if (!noirqdebug)
note_interrupt(irq, desc, retval);
return retval;
}
/**
* handle_IRQ_event - irq action chain handler
* @irq: the interrupt number
* @action: the interrupt action chain for this irq
*
* Handles the action chain of an irq event
*/
irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
{
irqreturn_t ret, retval = IRQ_NONE;
unsigned int status = 0;
#ifdef CONFIG_SAMSUNG_KERNEL_DEBUG// klaatu
int cpu;
cpu = smp_processor_id();
#endif
do {
#ifdef CONFIG_SAMSUNG_KERNEL_DEBUG// klaatu
gExcpTaskLog[gExcpTaskLogIdx].time = cpu_clock(cpu);
gExcpTaskLog[gExcpTaskLogIdx].log.irq.dummy = 0;
gExcpTaskLog[gExcpTaskLogIdx].log.irq.fn = (void *)action->handler;
gExcpTaskLogIdx = (++gExcpTaskLogIdx >= SCHED_LOG_MAX)? 0:gExcpTaskLogIdx;
#endif
trace_irq_handler_entry(irq, action);
ret = action->handler(irq, action->dev_id);
trace_irq_handler_exit(irq, action, ret);
switch (ret) {
case IRQ_WAKE_THREAD:
/*
* Set result to handled so the spurious check
* does not trigger.
*/
ret = IRQ_HANDLED;
/*
* Catch drivers which return WAKE_THREAD but
* did not set up a thread function
*/
if (unlikely(!action->thread_fn)) {
warn_no_thread(irq, action);
break;
}
/*
* Wake up the handler thread for this
* action. In case the thread crashed and was
* killed we just pretend that we handled the
* interrupt. The hardirq handler above has
* disabled the device interrupt, so no irq
* storm is lurking.
*/
if (likely(!test_bit(IRQTF_DIED,
&action->thread_flags))) {
set_bit(IRQTF_RUNTHREAD, &action->thread_flags);
wake_up_process(action->thread);
}
/* Fall through to add to randomness */
case IRQ_HANDLED:
status |= action->flags;
break;
default:
break;
}
retval |= ret;
action = action->next;
} while (action);
if (status & IRQF_SAMPLE_RANDOM)
add_interrupt_randomness(irq);
local_irq_disable();
return retval;
}
irqreturn_t
handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)
{
irqreturn_t retval = IRQ_NONE;
unsigned int random = 0, irq = desc->irq_data.irq;
#ifdef CONFIG_SAMSUNG_KERNEL_DEBUG
int cpu;
cpu = smp_processor_id();
#endif
do {
irqreturn_t res;
trace_irq_handler_entry(irq, action);
#ifdef CONFIG_SAMSUNG_KERNEL_DEBUG
#ifdef CONFIG_SAMSUNG_LOG_BUF
if (a_log_irq) {
log_idx++;
if ((unsigned int)log_idx >= IRQ_LOG_MAX)
log_idx = 0;
a_log_irq[log_idx].time = cpu_clock(cpu);
a_log_irq[log_idx].cpu = cpu;
a_log_irq[log_idx].id = irq;
a_log_irq[log_idx].ret = -1;
} else if (log_buf_irq) {
a_log_irq = (irq_log_t*)log_buf_irq;
}
#endif
#endif
res = action->handler(irq, action->dev_id);
trace_irq_handler_exit(irq, action, res);
#ifdef CONFIG_SAMSUNG_KERNEL_DEBUG
#ifdef CONFIG_SAMSUNG_LOG_BUF
if (a_log_irq) {
log_idx++;
if ((unsigned int)log_idx >= IRQ_LOG_MAX)
log_idx = 0;
a_log_irq[log_idx].time = cpu_clock(cpu);
a_log_irq[log_idx].cpu = cpu;
a_log_irq[log_idx].id = irq;
a_log_irq[log_idx].ret = res;
}
#endif
#endif
if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interrupts\n",
irq, action->handler))
local_irq_disable();
switch (res) {
case IRQ_WAKE_THREAD:
/*
* Catch drivers which return WAKE_THREAD but
* did not set up a thread function
*/
if (unlikely(!action->thread_fn)) {
warn_no_thread(irq, action);
break;
}
irq_wake_thread(desc, action);
/* Fall through to add to randomness */
case IRQ_HANDLED:
random |= action->flags;
break;
default:
break;
}
retval |= res;
action = action->next;
} while (action);
if (random & IRQF_SAMPLE_RANDOM)
add_interrupt_randomness(irq);
if (!noirqdebug)
note_interrupt(irq, desc, retval);
return retval;
}
/**
* handle_IRQ_event - irq action chain handler
* @irq: the interrupt number
* @action: the interrupt action chain for this irq
*
* Handles the action chain of an irq event
*/
irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
{
irqreturn_t ret, retval = IRQ_NONE;
unsigned int status = 0;
#ifdef ALRAN_IRQ
int cpu;
unsigned long long t;
cpu = smp_processor_id();
t = cpu_clock(cpu);
Airq_stats[Acount].usec = do_div(t, 1000000000) / 1000;
Airq_stats[Acount].sec = (unsigned long) t;
Airq_stats[Acount].irq = irq;
Airq_stats[Acount].cpu = cpu;
Airq_stats[Acount].handler = (action->handler);
irq_desc[irq].Alast_usec = Airq_stats[Acount].usec;
irq_desc[irq].Alast_sec = Airq_stats[Acount].sec;
#if 0
if (Acount % 20 == 0)
printk (KERN_ERR "Airq %d [%5lu.%06lu] irq %d, cpu %d, handler %08x\n", Acount,
Airq_stats[Acount].sec, Airq_stats[Acount].usec, irq, cpu, (unsigned int) Airq_stats[Acount].handler);
#endif
Acount++;
if (Acount == ASIZE) Acount = 0;
#endif
do {
trace_irq_handler_entry(irq, action);
ret = action->handler(irq, action->dev_id);
trace_irq_handler_exit(irq, action, ret);
switch (ret) {
case IRQ_WAKE_THREAD:
/*
* Set result to handled so the spurious check
* does not trigger.
*/
ret = IRQ_HANDLED;
/*
* Catch drivers which return WAKE_THREAD but
* did not set up a thread function
*/
if (unlikely(!action->thread_fn)) {
warn_no_thread(irq, action);
break;
}
/*
* Wake up the handler thread for this
* action. In case the thread crashed and was
* killed we just pretend that we handled the
* interrupt. The hardirq handler above has
* disabled the device interrupt, so no irq
* storm is lurking.
*/
if (likely(!test_bit(IRQTF_DIED,
&action->thread_flags))) {
set_bit(IRQTF_RUNTHREAD, &action->thread_flags);
wake_up_process(action->thread);
}
/* Fall through to add to randomness */
case IRQ_HANDLED:
status |= action->flags;
break;
default:
break;
}
retval |= ret;
action = action->next;
} while (action);
if (status & IRQF_SAMPLE_RANDOM)
add_interrupt_randomness(irq);
local_irq_disable();
return retval;
}