sparc32: implement SMP IPIs using the generic functions

The current sparc32 SMP IPI generation is implemented the
cross call function. The cross call function uses IRQ15 the
NMI, this is has the effect that IPIs will interrupt IRQ
critical areas and hang the system. Typically on/after
spin_lock_irqsave calls can be aborted.

The cross call functionality must still exist to flush
cache/TLBS.

This patch provides CPU models a custom way to implement
generation of IPIs on the generic code's request. The
typical approach is to generate an IRQ for each IPI case.

After this patch each sparc32 SMP CPU model needs to
implement IPIs in order to function properly.

Signed-off-by: Daniel Hellstrom <daniel@gaisler.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

2 files changed, 56 insertions, 1 deletions

diff --git a/arch/sparc/kernel/irq_32.c b/arch/sparc/kernel/irq_32.c
index 197e1ba85484..9b89d842913c 100644
--- a/arch/sparc/kernel/irq_32.c
+++ b/arch/sparc/kernel/irq_32.c
@@ -206,6 +206,16 @@ int arch_show_interrupts(struct seq_file *p, int prec)
 {
         int j;
 
+#ifdef CONFIG_SMP
+        seq_printf(p, "RES: ");
+        for_each_online_cpu(j)
+                seq_printf(p, "%10u ", cpu_data(j).irq_resched_count);
+        seq_printf(p, "     IPI rescheduling interrupts\n");
+        seq_printf(p, "CAL: ");
+        for_each_online_cpu(j)
+                seq_printf(p, "%10u ", cpu_data(j).irq_call_count);
+        seq_printf(p, "     IPI function call interrupts\n");
+#endif
         seq_printf(p, "NMI: ");
         for_each_online_cpu(j)
                 seq_printf(p, "%10u ", cpu_data(j).counter);
diff --git a/arch/sparc/kernel/smp_32.c b/arch/sparc/kernel/smp_32.c
index 4a1d5b7f20d3..2710602281de 100644
--- a/arch/sparc/kernel/smp_32.c
+++ b/arch/sparc/kernel/smp_32.c
@@ -123,13 +123,58 @@ struct linux_prom_registers smp_penguin_ctable __cpuinitdata = { 0 };
 
 void smp_send_reschedule(int cpu)
 {
-        /* See sparc64 */
+        /*
+         * CPU model dependent way of implementing IPI generation targeting
+         * a single CPU. The trap handler needs only to do trap entry/return
+         * to call schedule.
+         */
+        BTFIXUP_CALL(smp_ipi_resched)(cpu);
 }
 
 void smp_send_stop(void)
 {
 }
 
+void arch_send_call_function_single_ipi(int cpu)
+{
+        /* trigger one IPI single call on one CPU */
+        BTFIXUP_CALL(smp_ipi_single)(cpu);
+}
+
+void arch_send_call_function_ipi_mask(const struct cpumask *mask)
+{
+        int cpu;
+
+        /* trigger IPI mask call on each CPU */
+        for_each_cpu(cpu, mask)
+                BTFIXUP_CALL(smp_ipi_mask_one)(cpu);
+}
+
+void smp_resched_interrupt(void)
+{
+        local_cpu_data().irq_resched_count++;
+        /*
+         * do nothing, since it all was about calling re-schedule
+         * routine called by interrupt return code.
+         */
+}
+
+void smp_call_function_single_interrupt(void)
+{
+        irq_enter();
+        generic_smp_call_function_single_interrupt();
+        local_cpu_data().irq_call_count++;
+        irq_exit();
+}
+
+void smp_call_function_interrupt(void)
+{
+        irq_enter();
+        generic_smp_call_function_interrupt();
+        local_cpu_data().irq_call_count++;
+        irq_exit();
+}
+
 void smp_flush_cache_all(void)
 {
         xc0((smpfunc_t) BTFIXUP_CALL(local_flush_cache_all));