1 files changed, 96 insertions, 44 deletions

diff --git a/arch/powerpc/kernel/smp.c b/arch/powerpc/kernel/smp.c
index cbdbb14be4b0..4a6f2ec7e761 100644
--- a/arch/powerpc/kernel/smp.c
+++ b/arch/powerpc/kernel/smp.c
@@ -95,7 +95,7 @@ int smt_enabled_at_boot = 1;
 static void (*crash_ipi_function_ptr)(struct pt_regs *) = NULL;
 
 #ifdef CONFIG_PPC64
-void __devinit smp_generic_kick_cpu(int nr)
+int __devinit smp_generic_kick_cpu(int nr)
 {
         BUG_ON(nr < 0 || nr >= NR_CPUS);
 
@@ -106,37 +106,10 @@ void __devinit smp_generic_kick_cpu(int nr)
          */
         paca[nr].cpu_start = 1;
         smp_mb();
-}
-#endif
 
-void smp_message_recv(int msg)
-{
-        switch(msg) {
-        case PPC_MSG_CALL_FUNCTION:
-                generic_smp_call_function_interrupt();
-                break;
-        case PPC_MSG_RESCHEDULE:
-                /* we notice need_resched on exit */
-                break;
-        case PPC_MSG_CALL_FUNC_SINGLE:
-                generic_smp_call_function_single_interrupt();
-                break;
-        case PPC_MSG_DEBUGGER_BREAK:
-                if (crash_ipi_function_ptr) {
-                        crash_ipi_function_ptr(get_irq_regs());
-                        break;
-                }
-#ifdef CONFIG_DEBUGGER
-                debugger_ipi(get_irq_regs());
-                break;
-#endif /* CONFIG_DEBUGGER */
-                /* FALLTHROUGH */
-        default:
-                printk("SMP %d: smp_message_recv(): unknown msg %d\n",
-                       smp_processor_id(), msg);
-                break;
-        }
+        return 0;
 }
+#endif
 
 static irqreturn_t call_function_action(int irq, void *data)
 {
@@ -146,7 +119,7 @@ static irqreturn_t call_function_action(int irq, void *data)
 
 static irqreturn_t reschedule_action(int irq, void *data)
 {
-        /* we just need the return path side effect of checking need_resched */
+        scheduler_ipi();
         return IRQ_HANDLED;
 }
 
@@ -156,9 +129,17 @@ static irqreturn_t call_function_single_action(int irq, void *data)
         return IRQ_HANDLED;
 }
 
-static irqreturn_t debug_ipi_action(int irq, void *data)
+irqreturn_t debug_ipi_action(int irq, void *data)
 {
-        smp_message_recv(PPC_MSG_DEBUGGER_BREAK);
+        if (crash_ipi_function_ptr) {
+                crash_ipi_function_ptr(get_irq_regs());
+                return IRQ_HANDLED;
+        }
+
+#ifdef CONFIG_DEBUGGER
+        debugger_ipi(get_irq_regs());
+#endif /* CONFIG_DEBUGGER */
+
         return IRQ_HANDLED;
 }
 
@@ -197,6 +178,66 @@ int smp_request_message_ipi(int virq, int msg)
         return err;
 }
 
+#ifdef CONFIG_PPC_SMP_MUXED_IPI
+struct cpu_messages {
+        int messages;                   /* current messages */
+        unsigned long data;             /* data for cause ipi */
+};
+static DEFINE_PER_CPU_SHARED_ALIGNED(struct cpu_messages, ipi_message);
+
+void smp_muxed_ipi_set_data(int cpu, unsigned long data)
+{
+        struct cpu_messages *info = &per_cpu(ipi_message, cpu);
+
+        info->data = data;
+}
+
+void smp_muxed_ipi_message_pass(int cpu, int msg)
+{
+        struct cpu_messages *info = &per_cpu(ipi_message, cpu);
+        char *message = (char *)&info->messages;
+
+        message[msg] = 1;
+        mb();
+        smp_ops->cause_ipi(cpu, info->data);
+}
+
+void smp_muxed_ipi_resend(void)
+{
+        struct cpu_messages *info = &__get_cpu_var(ipi_message);
+
+        if (info->messages)
+                smp_ops->cause_ipi(smp_processor_id(), info->data);
+}
+
+irqreturn_t smp_ipi_demux(void)
+{
+        struct cpu_messages *info = &__get_cpu_var(ipi_message);
+        unsigned int all;
+
+        mb();   /* order any irq clear */
+
+        do {
+                all = xchg_local(&info->messages, 0);
+
+#ifdef __BIG_ENDIAN
+                if (all & (1 << (24 - 8 * PPC_MSG_CALL_FUNCTION)))
+                        generic_smp_call_function_interrupt();
+                if (all & (1 << (24 - 8 * PPC_MSG_RESCHEDULE)))
+                        scheduler_ipi();
+                if (all & (1 << (24 - 8 * PPC_MSG_CALL_FUNC_SINGLE)))
+                        generic_smp_call_function_single_interrupt();
+                if (all & (1 << (24 - 8 * PPC_MSG_DEBUGGER_BREAK)))
+                        debug_ipi_action(0, NULL);
+#else
+#error Unsupported ENDIAN
+#endif
+        } while (info->messages);
+
+        return IRQ_HANDLED;
+}
+#endif /* CONFIG_PPC_SMP_MUXED_IPI */
+
 void smp_send_reschedule(int cpu)
 {
         if (likely(smp_ops))
@@ -216,11 +257,18 @@ void arch_send_call_function_ipi_mask(const struct cpumask *mask)
                 smp_ops->message_pass(cpu, PPC_MSG_CALL_FUNCTION);
 }
 
-#ifdef CONFIG_DEBUGGER
-void smp_send_debugger_break(int cpu)
+#if defined(CONFIG_DEBUGGER) || defined(CONFIG_KEXEC)
+void smp_send_debugger_break(void)
 {
-        if (likely(smp_ops))
-                smp_ops->message_pass(cpu, PPC_MSG_DEBUGGER_BREAK);
+        int cpu;
+        int me = raw_smp_processor_id();
+
+        if (unlikely(!smp_ops))
+                return;
+
+        for_each_online_cpu(cpu)
+                if (cpu != me)
+                        smp_ops->message_pass(cpu, PPC_MSG_DEBUGGER_BREAK);
 }
 #endif
 
@@ -228,9 +276,9 @@ void smp_send_debugger_break(int cpu)
 void crash_send_ipi(void (*crash_ipi_callback)(struct pt_regs *))
 {
         crash_ipi_function_ptr = crash_ipi_callback;
-        if (crash_ipi_callback && smp_ops) {
+        if (crash_ipi_callback) {
                 mb();
-                smp_ops->message_pass(MSG_ALL_BUT_SELF, PPC_MSG_DEBUGGER_BREAK);
+                smp_send_debugger_break();
         }
 }
 #endif
@@ -410,8 +458,6 @@ int __cpuinit __cpu_up(unsigned int cpu)
 {
         int rc, c;
 
-        secondary_ti = current_set[cpu];
-
         if (smp_ops == NULL ||
             (smp_ops->cpu_bootable && !smp_ops->cpu_bootable(cpu)))
                 return -EINVAL;
@@ -421,6 +467,8 @@ int __cpuinit __cpu_up(unsigned int cpu)
         if (rc)
                 return rc;
 
+        secondary_ti = current_set[cpu];
+
         /* Make sure callin-map entry is 0 (can be leftover a CPU
          * hotplug
          */
@@ -434,7 +482,11 @@ int __cpuinit __cpu_up(unsigned int cpu)
 
         /* wake up cpus */
         DBG("smp: kicking cpu %d\n", cpu);
-        smp_ops->kick_cpu(cpu);
+        rc = smp_ops->kick_cpu(cpu);
+        if (rc) {
+                pr_err("smp: failed starting cpu %d (rc %d)\n", cpu, rc);
+                return rc;
+        }
 
         /*
          * wait to see if the cpu made a callin (is actually up).
@@ -507,7 +559,7 @@ int cpu_first_thread_of_core(int core)
 }
 EXPORT_SYMBOL_GPL(cpu_first_thread_of_core);
 
-/* Must be called when no change can occur to cpu_present_map,
+/* Must be called when no change can occur to cpu_present_mask,
  * i.e. during cpu online or offline.
  */
 static struct device_node *cpu_to_l2cache(int cpu)
@@ -608,7 +660,7 @@ void __init smp_cpus_done(unsigned int max_cpus)
          * se we pin us down to CPU 0 for a short while
          */
         alloc_cpumask_var(&old_mask, GFP_NOWAIT);
-        cpumask_copy(old_mask, &current->cpus_allowed);
+        cpumask_copy(old_mask, tsk_cpus_allowed(current));
         set_cpus_allowed_ptr(current, cpumask_of(boot_cpuid));
         
         if (smp_ops && smp_ops->setup_cpu)