sh: Bring SMP support back from the dead.

There was a very preliminary bunch of SMP code scattered around for the
SH7604 microcontrollers from way back when, and it has mostly suffered
bitrot since then. With the tree already having been slowly getting
prepped for SMP, this plugs in most of the remaining platform-independent
bits.

Signed-off-by: Magnus Damm <damm@igel.co.jp>
Signed-off-by: Paul Mundt <lethal@linux-sh.org>

1 files changed, 92 insertions, 75 deletions

diff --git a/arch/sh/kernel/smp.c b/arch/sh/kernel/smp.c
index f93d5ffa9417..94075e1a1e61 100644
--- a/arch/sh/kernel/smp.c
+++ b/arch/sh/kernel/smp.c
@@ -3,68 +3,40 @@
  *
  * SMP support for the SuperH processors.
  *
- * Copyright (C) 2002, 2003 Paul Mundt
+ * Copyright (C) 2002 - 2007 Paul Mundt
+ * Copyright (C) 2006 - 2007 Akio Idehara
  *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2 of the License, or (at your
- * option) any later version.
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
  */
-
 #include <linux/err.h>
 #include <linux/cache.h>
 #include <linux/cpumask.h>
 #include <linux/delay.h>
 #include <linux/init.h>
-#include <linux/interrupt.h>
 #include <linux/spinlock.h>
-#include <linux/threads.h>
+#include <linux/mm.h>
 #include <linux/module.h>
-#include <linux/time.h>
-#include <linux/timex.h>
-#include <linux/sched.h>
-#include <linux/module.h>
-
+#include <linux/interrupt.h>
 #include <asm/atomic.h>
 #include <asm/processor.h>
 #include <asm/system.h>
 #include <asm/mmu_context.h>
 #include <asm/smp.h>
+#include <asm/cacheflush.h>
+#include <asm/sections.h>
 
-/*
- * This was written with the Sega Saturn (SMP SH-2 7604) in mind,
- * but is designed to be usable regardless if there's an MMU
- * present or not.
- */
-struct sh_cpuinfo cpu_data[NR_CPUS];
-
-extern void per_cpu_trap_init(void);
+int __cpu_number_map[NR_CPUS];          /* Map physical to logical */
+int __cpu_logical_map[NR_CPUS];         /* Map logical to physical */
 
 cpumask_t cpu_possible_map;
 EXPORT_SYMBOL(cpu_possible_map);
 
 cpumask_t cpu_online_map;
 EXPORT_SYMBOL(cpu_online_map);
-static atomic_t cpus_booted = ATOMIC_INIT(0);
-
-/* These are defined by the board-specific code. */
 
-/*
- * Cause the function described by call_data to be executed on the passed
- * cpu.  When the function has finished, increment the finished field of
- * call_data.
- */
-void __smp_send_ipi(unsigned int cpu, unsigned int action);
-
-/*
- * Find the number of available processors
- */
-unsigned int __smp_probe_cpus(void);
-
-/*
- * Start a particular processor
- */
-void __smp_slave_init(unsigned int cpu);
+static atomic_t cpus_booted = ATOMIC_INIT(0);
 
 /*
  * Run specified function on a particular processor.
@@ -73,74 +45,123 @@ void __smp_call_function(unsigned int cpu);
 
 static inline void __init smp_store_cpu_info(unsigned int cpu)
 {
-        cpu_data[cpu].loops_per_jiffy = loops_per_jiffy;
+        struct sh_cpuinfo *c = cpu_data + cpu;
+
+        c->loops_per_jiffy = loops_per_jiffy;
 }
 
 void __init smp_prepare_cpus(unsigned int max_cpus)
 {
         unsigned int cpu = smp_processor_id();
-        int i;
 
-        atomic_set(&cpus_booted, 1);
-        smp_store_cpu_info(cpu);
-        
-        for (i = 0; i < __smp_probe_cpus(); i++)
-                cpu_set(i, cpu_possible_map);
+        init_new_context(current, &init_mm);
+        current_thread_info()->cpu = cpu;
+        plat_prepare_cpus(max_cpus);
+
+#ifndef CONFIG_HOTPLUG_CPU
+        cpu_present_map = cpu_possible_map;
+#endif
 }
 
 void __devinit smp_prepare_boot_cpu(void)
 {
         unsigned int cpu = smp_processor_id();
 
+        __cpu_number_map[0] = cpu;
+        __cpu_logical_map[0] = cpu;
+
         cpu_set(cpu, cpu_online_map);
         cpu_set(cpu, cpu_possible_map);
 }
 
-int __cpu_up(unsigned int cpu)
+asmlinkage void __cpuinit start_secondary(void)
 {
-        struct task_struct *tsk;
+        unsigned int cpu;
+        struct mm_struct *mm = &init_mm;
 
-        tsk = fork_idle(cpu);
+        atomic_inc(&mm->mm_count);
+        atomic_inc(&mm->mm_users);
+        current->active_mm = mm;
+        BUG_ON(current->mm);
+        enter_lazy_tlb(mm, current);
+
+        per_cpu_trap_init();
 
-        if (IS_ERR(tsk))
-                panic("Failed forking idle task for cpu %d\n", cpu);
-        
-        task_thread_info(tsk)->cpu = cpu;
+        preempt_disable();
+
+        local_irq_enable();
+
+        calibrate_delay();
+
+        cpu = smp_processor_id();
+        smp_store_cpu_info(cpu);
 
         cpu_set(cpu, cpu_online_map);
 
-        return 0;
+        cpu_idle();
 }
 
-int start_secondary(void *unused)
+extern struct {
+        unsigned long sp;
+        unsigned long bss_start;
+        unsigned long bss_end;
+        void *start_kernel_fn;
+        void *cpu_init_fn;
+        void *thread_info;
+} stack_start;
+
+int __cpuinit __cpu_up(unsigned int cpu)
 {
-        unsigned int cpu;
+        struct task_struct *tsk;
+        unsigned long timeout;
 
-        cpu = smp_processor_id();
+        tsk = fork_idle(cpu);
+        if (IS_ERR(tsk)) {
+                printk(KERN_ERR "Failed forking idle task for cpu %d\n", cpu);
+                return PTR_ERR(tsk);
+        }
 
-        atomic_inc(&init_mm.mm_count);
-        current->active_mm = &init_mm;
+        /* Fill in data in head.S for secondary cpus */
+        stack_start.sp = tsk->thread.sp;
+        stack_start.thread_info = tsk->stack;
+        stack_start.bss_start = 0; /* don't clear bss for secondary cpus */
+        stack_start.start_kernel_fn = start_secondary;
 
-        smp_store_cpu_info(cpu);
+        flush_cache_all();
 
-        __smp_slave_init(cpu);
-        preempt_disable();
-        per_cpu_trap_init();
-        
-        atomic_inc(&cpus_booted);
+        plat_start_cpu(cpu, (unsigned long)_stext);
 
-        cpu_idle();
-        return 0;
+        timeout = jiffies + HZ;
+        while (time_before(jiffies, timeout)) {
+                if (cpu_online(cpu))
+                        break;
+
+                udelay(10);
+        }
+
+        if (cpu_online(cpu))
+                return 0;
+
+        return -ENOENT;
 }
 
 void __init smp_cpus_done(unsigned int max_cpus)
 {
-        smp_mb();
+        unsigned long bogosum = 0;
+        int cpu;
+
+        for_each_online_cpu(cpu)
+                bogosum += cpu_data[cpu].loops_per_jiffy;
+
+        printk(KERN_INFO "SMP: Total of %d processors activated "
+               "(%lu.%02lu BogoMIPS).\n", num_online_cpus(),
+               bogosum / (500000/HZ),
+               (bogosum / (5000/HZ)) % 100);
 }
 
 void smp_send_reschedule(int cpu)
 {
-        __smp_send_ipi(cpu, SMP_MSG_RESCHEDULE);
+        plat_send_ipi(cpu, SMP_MSG_RESCHEDULE);
 }
 
 static void stop_this_cpu(void *unused)
@@ -157,7 +178,6 @@ void smp_send_stop(void)
         smp_call_function(stop_this_cpu, 0, 1, 0);
 }
 
-
 struct smp_fn_call_struct smp_fn_call = {
         .lock           = SPIN_LOCK_UNLOCKED,
         .finished       = ATOMIC_INIT(0),
@@ -175,9 +195,6 @@ int smp_call_function(void (*func)(void *info), void *info, int retry, int wait)
         unsigned int nr_cpus = atomic_read(&cpus_booted);
         int i;
 
-        if (nr_cpus < 2)
-                return 0;
-
         /* Can deadlock when called with interrupts disabled */
         WARN_ON(irqs_disabled());
 
@@ -189,7 +206,7 @@ int smp_call_function(void (*func)(void *info), void *info, int retry, int wait)
 
         for (i = 0; i < nr_cpus; i++)
                 if (i != smp_processor_id())
-                        __smp_call_function(i);
+                        plat_send_ipi(i, SMP_MSG_FUNCTION);
 
         if (wait)
                 while (atomic_read(&smp_fn_call.finished) != (nr_cpus - 1));