Merge branch 'irq/for-arm' into irq/core

Pull the functionality which is required to cleanup sdhci/sdio in. It's in a separate branch so it can be pulled from others Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
author: Thomas Gleixner <tglx@linutronix.de> 2014-02-19 11:23:52 -0500
committer: Thomas Gleixner <tglx@linutronix.de> 2014-02-19 11:23:52 -0500
commit: 1bc38a1d33a09949cfb6a12349e3c8dac867a5ab (patch)
tree: e3fa41f522857e3416854368b59e2e08c571f55d /kernel
parent: ddf2965d77558eefee745c9dce22ad7ef5c7b88e (diff)
parent: a92444c6b2225a9115d661c950cb48a22aeace20 (diff)
7 files changed, 95 insertions, 22 deletions
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index 131ca176b497..bfec453557b4 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -51,7 +51,7 @@ static void warn_no_thread(unsigned int irq, struct irqaction *action)
               "but no thread function available.", irq, action->name);
 }
-static void irq_wake_thread(struct irq_desc *desc, struct irqaction *action)
+void __irq_wake_thread(struct irq_desc *desc, struct irqaction *action)
 {
        /*
         * In case the thread crashed and was killed we just pretend that
@@ -157,7 +157,7 @@ handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)
                                break;
                        }
-                        irq_wake_thread(desc, action);
+                        __irq_wake_thread(desc, action);
                        /* Fall through to add to randomness */
                case IRQ_HANDLED:
diff --git a/kernel/irq/internals.h b/kernel/irq/internals.h
index 001fa5bab490..d61ac29e32d0 100644
--- a/kernel/irq/internals.h
+++ b/kernel/irq/internals.h
@@ -82,6 +82,7 @@ irqreturn_t handle_irq_event(struct irq_desc *desc);
 /* Resending of interrupts :*/
 void check_irq_resend(struct irq_desc *desc, unsigned int irq);
 bool irq_wait_for_poll(struct irq_desc *desc);
+void __irq_wake_thread(struct irq_desc *desc, struct irqaction *action);
 #ifdef CONFIG_PROC_FS
 extern void register_irq_proc(unsigned int irq, struct irq_desc *desc);
diff --git a/kernel/irq/irqdesc.c b/kernel/irq/irqdesc.c
index 192a302d6cfd..8ab8e9390297 100644
--- a/kernel/irq/irqdesc.c
+++ b/kernel/irq/irqdesc.c
@@ -274,6 +274,7 @@ struct irq_desc *irq_to_desc(unsigned int irq)
 {
        return (irq < NR_IRQS) ? irq_desc + irq : NULL;
 }
+EXPORT_SYMBOL(irq_to_desc);
 static void free_desc(unsigned int irq)
 {
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 481a13c43b17..54eb5c99351b 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -32,24 +32,10 @@ static int __init setup_forced_irqthreads(char *arg)
 early_param("threadirqs", setup_forced_irqthreads);
 #endif
-/**
+static void __synchronize_hardirq(struct irq_desc *desc)
- *      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_to_desc(irq);
        bool inprogress;
-        if (!desc)
-                return;
        do {
                unsigned long flags;
@@ -67,12 +53,56 @@ void synchronize_irq(unsigned int irq)
                /* Oops, that failed? */
        } while (inprogress);
+}
-        /*
+/**
-         * We made sure that no hardirq handler is running. Now verify
+ *      synchronize_hardirq - wait for pending hard IRQ handlers (on other CPUs)
-         * that no threaded handlers are active.
+ *      @irq: interrupt number to wait for
-         */
+ *
-        wait_event(desc->wait_for_threads, !atomic_read(&desc->threads_active));
+ *      This function waits for any pending hard 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. It does not take associated threaded handlers
+ *      into account.
+ *
+ *      Do not use this for shutdown scenarios where you must be sure
+ *      that all parts (hardirq and threaded handler) have completed.
+ *
+ *      This function may be called - with care - from IRQ context.
+ */
+void synchronize_hardirq(unsigned int irq)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+        if (desc)
+                __synchronize_hardirq(desc);
+}
+EXPORT_SYMBOL(synchronize_hardirq);
+/**
+ *      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_to_desc(irq);
+        if (desc) {
+                __synchronize_hardirq(desc);
+                /*
+                 * We made sure that no hardirq handler is
+                 * running. Now verify that no threaded handlers are
+                 * active.
+                 */
+                wait_event(desc->wait_for_threads,
+                           !atomic_read(&desc->threads_active));
+        }
 }
 EXPORT_SYMBOL(synchronize_irq);
@@ -881,6 +911,33 @@ static int irq_thread(void *data)
        return 0;
 }
+/**
+ *      irq_wake_thread - wake the irq thread for the action identified by dev_id
+ *      @irq:           Interrupt line
+ *      @dev_id:        Device identity for which the thread should be woken
+ *
+ */
+void irq_wake_thread(unsigned int irq, void *dev_id)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+        struct irqaction *action;
+        unsigned long flags;
+        if (!desc || WARN_ON(irq_settings_is_per_cpu_devid(desc)))
+                return;
+        raw_spin_lock_irqsave(&desc->lock, flags);
+        for (action = desc->action; action; action = action->next) {
+                if (action->dev_id == dev_id) {
+                        if (action->thread)
+                                __irq_wake_thread(desc, action);
+                        break;
+                }
+        }
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
+}
+EXPORT_SYMBOL_GPL(irq_wake_thread);
 static void irq_setup_forced_threading(struct irqaction *new)
 {
        if (!force_irqthreads)
diff --git a/kernel/time/jiffies.c b/kernel/time/jiffies.c
index 7a925ba456fb..a6a5bf53e86d 100644
--- a/kernel/time/jiffies.c
+++ b/kernel/time/jiffies.c
@@ -51,7 +51,13 @@
 * HZ shrinks, so values greater than 8 overflow 32bits when
 * HZ=100.
 */
+#if HZ < 34
+#define JIFFIES_SHIFT   6
+#elif HZ < 67
+#define JIFFIES_SHIFT   7
+#else
 #define JIFFIES_SHIFT   8
+#endif
 static cycle_t jiffies_read(struct clocksource *cs)
 {
diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index 43780ab5e279..98977a57ac72 100644
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -756,6 +756,7 @@ out:
 static void tick_broadcast_clear_oneshot(int cpu)
 {
        cpumask_clear_cpu(cpu, tick_broadcast_oneshot_mask);
+        cpumask_clear_cpu(cpu, tick_broadcast_pending_mask);
 }
 static void tick_broadcast_init_next_event(struct cpumask *mask,
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 294b8a271a04..fc4da2d97f9b 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -2397,6 +2397,13 @@ __rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
        write &= RB_WRITE_MASK;
        tail = write - length;
+        /*
+         * If this is the first commit on the page, then it has the same
+         * timestamp as the page itself.
+         */
+        if (!tail)
+                delta = 0;
        /* See if we shot pass the end of this buffer page */
        if (unlikely(write > BUF_PAGE_SIZE))
                return rb_move_tail(cpu_buffer, length, tail,
author	Thomas Gleixner <tglx@linutronix.de>	2014-02-19 11:23:52 -0500
committer	Thomas Gleixner <tglx@linutronix.de>	2014-02-19 11:23:52 -0500
commit	1bc38a1d33a09949cfb6a12349e3c8dac867a5ab (patch)
tree	e3fa41f522857e3416854368b59e2e08c571f55d /kernel
parent	ddf2965d77558eefee745c9dce22ad7ef5c7b88e (diff)
parent	a92444c6b2225a9115d661c950cb48a22aeace20 (diff)