/** * 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_exit(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_exit(irq, action, 1); }
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; }