/* * * arch/mips/kernel/smp.c * * Copyright (C) 2000 Sibyte * * Written by Justin Carlson (carlson@sibyte.com) * * 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 program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* * This was written with the BRCM12500 MP SOC in mind, but tries to * be generic. It's modelled on the mips64 smp.c code, which is * derived from Sparc, I'm guessing, which is derived from... * * It's probably horribly designed for very large ccNUMA systems * as it doesn't take any node clustering into account. */ /* Ze Big Kernel Lock! */ spinlock_t kernel_flag __cacheline_aligned_in_smp = SPIN_LOCK_UNLOCKED; int smp_threads_ready; /* Not used */ int smp_num_cpus; int global_irq_holder = NO_PROC_ID; spinlock_t global_irq_lock = SPIN_LOCK_UNLOCKED; struct mips_cpuinfo cpu_data[NR_CPUS]; struct smp_fn_call_struct smp_fn_call = { SPIN_LOCK_UNLOCKED, ATOMIC_INIT(0), NULL, NULL}; static atomic_t cpus_booted = ATOMIC_INIT(0); /* These are defined by the board-specific code. */ /* Cause the function described by smp_fn_call to be executed on the passed cpu. When the function has finished, increment the finished field of smp_fn_call. */ void core_call_function(int cpu); /* * Clear all undefined state in the cpu, set up sp and gp to the passed * values, and kick the cpu into smp_bootstrap(); */ void prom_boot_secondary(int cpu, unsigned long sp, unsigned long gp); /* * After we've done initial boot, this function is called to allow the * board code to clean up state, if needed */ void prom_init_secondary(void); void cpu_idle(void); /* Do whatever setup needs to be done for SMP at the board level. Return the number of cpus in the system, including this one */ int prom_setup_smp(void); int start_secondary(void *unused) { prom_init_secondary(); write_32bit_cp0_register(CP0_CONTEXT, smp_processor_id()<<23); current_pgd[smp_processor_id()] = init_mm.pgd; printk("Slave cpu booted successfully\n"); atomic_inc(&cpus_booted); cpu_idle(); return 0; } void __init smp_boot_cpus(void) { int i; smp_num_cpus = prom_setup_smp(); init_new_context(current, &init_mm); current->processor = 0; atomic_set(&cpus_booted, 1); /* Master CPU is already booted... */ init_idle(); for (i = 1; i < smp_num_cpus; i++) { struct task_struct *p; struct pt_regs regs; printk("Starting CPU %d... ", i); /* Spawn a new process normally. Grab a pointer to its task struct so we can mess with it */ do_fork(CLONE_VM|CLONE_PID, 0, ®s, 0); p = init_task.prev_task; /* Schedule the first task manually */ p->processor = i; p->cpus_runnable = 1 << i; /* we schedule the first task manually */ /* Attach to the address space of init_task. */ atomic_inc(&init_mm.mm_count); p->active_mm = &init_mm; init_tasks[i] = p; del_from_runqueue(p); unhash_process(p); prom_boot_secondary(i, (unsigned long)p + KERNEL_STACK_SIZE - 32, (unsigned long)p); #if 0 /* This is copied from the ip-27 code in the mips64 tree */ struct task_struct *p; /* * The following code is purely to make sure * Linux can schedule processes on this slave. */ kernel_thread(0, NULL, CLONE_PID); p = init_task.prev_task; sprintf(p->comm, "%s%d", "Idle", i); init_tasks[i] = p; p->processor = i; p->cpus_runnable = 1 << i; /* we schedule the first task manually * del_from_runqueue(p); unhash_process(p); /* Attach to the address space of init_task. */ atomic_inc(&init_mm.mm_count); p->active_mm = &init_mm; prom_boot_secondary(i, (unsigned long)p + KERNEL_STACK_SIZE - 32, (unsigned long)p); #endif } /* Wait for everyone to come up */ while (atomic_read(&cpus_booted) != smp_num_cpus); } void __init smp_commence(void) { /* Not sure what to do here yet */ } static void reschedule_this_cpu(void *dummy) { current->need_resched = 1; } void FASTCALL(smp_send_reschedule(int cpu)) { smp_call_function(reschedule_this_cpu, NULL, 0, 0); } /* * The caller of this wants the passed function to run on every cpu. If wait * is set, wait until all cpus have finished the function before returning. * The lock is here to protect the call structure. */ int smp_call_function (void (*func) (void *info), void *info, int retry, int wait) { int cpus = smp_num_cpus - 1; int i; if (smp_num_cpus < 2) { return 0; } spin_lock_bh(&smp_fn_call.lock); atomic_set(&smp_fn_call.finished, 0); smp_fn_call.fn = func; smp_fn_call.data = info; for (i = 0; i < smp_num_cpus; i++) { if (i != smp_processor_id()) { /* Call the board specific routine */ core_call_function(i); } } if (wait) { while(atomic_read(&smp_fn_call.finished) != cpus) {} } spin_unlock_bh(&smp_fn_call.lock); return 0; } void synchronize_irq(void) { panic("synchronize_irq"); } static void stop_this_cpu(void *dummy) { printk("Cpu stopping\n"); for (;;); } void smp_send_stop(void) { smp_call_function(stop_this_cpu, NULL, 1, 0); smp_num_cpus = 1; } /* Not really SMP stuff ... */ int setup_profiling_timer(unsigned int multiplier) { return 0; } /* * Most of this code is take from the mips64 tree (ip27-irq.c). It's virtually * identical to the i386 implentation in arh/i386/irq.c, with translations for * the interrupt enable bit */ #define MAXCOUNT 100000000 #define SYNC_OTHER_CORES(x) udelay(x+1) static inline void wait_on_irq(int cpu) { int count = MAXCOUNT; for (;;) { /* * Wait until all interrupts are gone. Wait * for bottom half handlers unless we're * already executing in one.. */ if (!irqs_running()) if (local_bh_count(cpu) || !spin_is_locked(&global_bh_lock)) break; /* Duh, we have to loop. Release the lock to avoid deadlocks */ spin_unlock(&global_irq_lock); for (;;) { if (!--count) { printk("Count spun out. Huh?\n"); count = ~0; } __sti(); SYNC_OTHER_CORES(cpu); __cli(); if (irqs_running()) continue; if (spin_is_locked(&global_irq_lock)) continue; if (!local_bh_count(cpu) && spin_is_locked(&global_bh_lock)) continue; if (spin_trylock(&global_irq_lock)) break; } } } static inline void get_irqlock(int cpu) { if (!spin_trylock(&global_irq_lock)) { /* do we already hold the lock? */ if ((unsigned char) cpu == global_irq_holder) return; /* Uhhuh.. Somebody else got it. Wait.. */ spin_lock(&global_irq_lock); } /* * We also to make sure that nobody else is running * in an interrupt context. */ wait_on_irq(cpu); /* * Ok, finally.. */ global_irq_holder = cpu; } /* * A global "cli()" while in an interrupt context * turns into just a local cli(). Interrupts * should use spinlocks for the (very unlikely) * case that they ever want to protect against * each other. * * If we already have local interrupts disabled, * this will not turn a local disable into a * global one (problems with spinlocks: this makes * save_flags+cli+sti usable inside a spinlock). */ void __global_cli(void) { unsigned int flags; __save_flags(flags); if (flags & ST0_IE) { int cpu = smp_processor_id(); __cli(); if (!local_irq_count(cpu)) get_irqlock(cpu); } } void __global_sti(void) { int cpu = smp_processor_id(); if (!local_irq_count(cpu)) release_irqlock(cpu); __sti(); } /* * SMP flags value to restore to: * 0 - global cli * 1 - global sti * 2 - local cli * 3 - local sti */ unsigned long __global_save_flags(void) { int retval; int local_enabled; unsigned long flags; int cpu = smp_processor_id(); __save_flags(flags); local_enabled = (flags & ST0_IE); /* default to local */ retval = 2 + local_enabled; /* check for global flags if we're not in an interrupt */ if (!local_irq_count(cpu)) { if (local_enabled) retval = 1; if (global_irq_holder == cpu) retval = 0; } return retval; } void __global_restore_flags(unsigned long flags) { switch (flags) { case 0: __global_cli(); break; case 1: __global_sti(); break; case 2: __cli(); break; case 3: __sti(); break; default: printk("global_restore_flags: %08lx\n", flags); } }