| /* |
| * Copyright 2010 Tilera Corporation. All Rights Reserved. |
| * |
| * 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, version 2. |
| * |
| * 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, GOOD TITLE or |
| * NON INFRINGEMENT. See the GNU General Public License for |
| * more details. |
| */ |
| |
| #include <linux/module.h> |
| #include <linux/init.h> |
| #include <linux/kernel.h> |
| #include <linux/mm.h> |
| #include <linux/sched.h> |
| #include <linux/kernel_stat.h> |
| #include <linux/bootmem.h> |
| #include <linux/notifier.h> |
| #include <linux/cpu.h> |
| #include <linux/percpu.h> |
| #include <linux/delay.h> |
| #include <linux/err.h> |
| #include <linux/irq.h> |
| #include <asm/mmu_context.h> |
| #include <asm/tlbflush.h> |
| #include <asm/sections.h> |
| |
| /* State of each CPU. */ |
| static DEFINE_PER_CPU(int, cpu_state) = { 0 }; |
| |
| /* The messaging code jumps to this pointer during boot-up */ |
| unsigned long start_cpu_function_addr; |
| |
| /* Called very early during startup to mark boot cpu as online */ |
| void __init smp_prepare_boot_cpu(void) |
| { |
| int cpu = smp_processor_id(); |
| set_cpu_online(cpu, 1); |
| set_cpu_present(cpu, 1); |
| __get_cpu_var(cpu_state) = CPU_ONLINE; |
| |
| init_messaging(); |
| } |
| |
| static void start_secondary(void); |
| |
| /* |
| * Called at the top of init() to launch all the other CPUs. |
| * They run free to complete their initialization and then wait |
| * until they get an IPI from the boot cpu to come online. |
| */ |
| void __init smp_prepare_cpus(unsigned int max_cpus) |
| { |
| long rc; |
| int cpu, cpu_count; |
| int boot_cpu = smp_processor_id(); |
| |
| current_thread_info()->cpu = boot_cpu; |
| |
| /* |
| * Pin this task to the boot CPU while we bring up the others, |
| * just to make sure we don't uselessly migrate as they come up. |
| */ |
| rc = sched_setaffinity(current->pid, cpumask_of(boot_cpu)); |
| if (rc != 0) |
| pr_err("Couldn't set init affinity to boot cpu (%ld)\n", rc); |
| |
| /* Print information about disabled and dataplane cpus. */ |
| print_disabled_cpus(); |
| |
| /* |
| * Tell the messaging subsystem how to respond to the |
| * startup message. We use a level of indirection to avoid |
| * confusing the linker with the fact that the messaging |
| * subsystem is calling __init code. |
| */ |
| start_cpu_function_addr = (unsigned long) &online_secondary; |
| |
| /* Set up thread context for all new processors. */ |
| cpu_count = 1; |
| for (cpu = 0; cpu < NR_CPUS; ++cpu) { |
| struct task_struct *idle; |
| |
| if (cpu == boot_cpu) |
| continue; |
| |
| if (!cpu_possible(cpu)) { |
| /* |
| * Make this processor do nothing on boot. |
| * Note that we don't give the boot_pc function |
| * a stack, so it has to be assembly code. |
| */ |
| per_cpu(boot_sp, cpu) = 0; |
| per_cpu(boot_pc, cpu) = (unsigned long) smp_nap; |
| continue; |
| } |
| |
| /* Create a new idle thread to run start_secondary() */ |
| idle = fork_idle(cpu); |
| if (IS_ERR(idle)) |
| panic("failed fork for CPU %d", cpu); |
| idle->thread.pc = (unsigned long) start_secondary; |
| |
| /* Make this thread the boot thread for this processor */ |
| per_cpu(boot_sp, cpu) = task_ksp0(idle); |
| per_cpu(boot_pc, cpu) = idle->thread.pc; |
| |
| ++cpu_count; |
| } |
| BUG_ON(cpu_count > (max_cpus ? max_cpus : 1)); |
| |
| /* Fire up the other tiles, if any */ |
| init_cpu_present(cpu_possible_mask); |
| if (cpumask_weight(cpu_present_mask) > 1) { |
| mb(); /* make sure all data is visible to new processors */ |
| hv_start_all_tiles(); |
| } |
| } |
| |
| static __initdata struct cpumask init_affinity; |
| |
| static __init int reset_init_affinity(void) |
| { |
| long rc = sched_setaffinity(current->pid, &init_affinity); |
| if (rc != 0) |
| pr_warning("couldn't reset init affinity (%ld)\n", |
| rc); |
| return 0; |
| } |
| late_initcall(reset_init_affinity); |
| |
| static struct cpumask cpu_started; |
| |
| /* |
| * Activate a secondary processor. Very minimal; don't add anything |
| * to this path without knowing what you're doing, since SMP booting |
| * is pretty fragile. |
| */ |
| static void start_secondary(void) |
| { |
| int cpuid = smp_processor_id(); |
| |
| /* Set our thread pointer appropriately. */ |
| set_my_cpu_offset(__per_cpu_offset[cpuid]); |
| |
| preempt_disable(); |
| |
| /* |
| * In large machines even this will slow us down, since we |
| * will be contending for for the printk spinlock. |
| */ |
| /* printk(KERN_DEBUG "Initializing CPU#%d\n", cpuid); */ |
| |
| /* Initialize the current asid for our first page table. */ |
| __get_cpu_var(current_asid) = min_asid; |
| |
| /* Set up this thread as another owner of the init_mm */ |
| atomic_inc(&init_mm.mm_count); |
| current->active_mm = &init_mm; |
| if (current->mm) |
| BUG(); |
| enter_lazy_tlb(&init_mm, current); |
| |
| /* Allow hypervisor messages to be received */ |
| init_messaging(); |
| local_irq_enable(); |
| |
| /* Indicate that we're ready to come up. */ |
| /* Must not do this before we're ready to receive messages */ |
| if (cpumask_test_and_set_cpu(cpuid, &cpu_started)) { |
| pr_warning("CPU#%d already started!\n", cpuid); |
| for (;;) |
| local_irq_enable(); |
| } |
| |
| smp_nap(); |
| } |
| |
| /* |
| * Bring a secondary processor online. |
| */ |
| void online_secondary(void) |
| { |
| /* |
| * low-memory mappings have been cleared, flush them from |
| * the local TLBs too. |
| */ |
| local_flush_tlb(); |
| |
| BUG_ON(in_interrupt()); |
| |
| /* This must be done before setting cpu_online_mask */ |
| wmb(); |
| |
| notify_cpu_starting(smp_processor_id()); |
| |
| set_cpu_online(smp_processor_id(), 1); |
| __get_cpu_var(cpu_state) = CPU_ONLINE; |
| |
| /* Set up tile-specific state for this cpu. */ |
| setup_cpu(0); |
| |
| /* Set up tile-timer clock-event device on this cpu */ |
| setup_tile_timer(); |
| |
| cpu_startup_entry(CPUHP_ONLINE); |
| } |
| |
| int __cpu_up(unsigned int cpu, struct task_struct *tidle) |
| { |
| /* Wait 5s total for all CPUs for them to come online */ |
| static int timeout; |
| for (; !cpumask_test_cpu(cpu, &cpu_started); timeout++) { |
| if (timeout >= 50000) { |
| pr_info("skipping unresponsive cpu%d\n", cpu); |
| local_irq_enable(); |
| return -EIO; |
| } |
| udelay(100); |
| } |
| |
| local_irq_enable(); |
| per_cpu(cpu_state, cpu) = CPU_UP_PREPARE; |
| |
| /* Unleash the CPU! */ |
| send_IPI_single(cpu, MSG_TAG_START_CPU); |
| while (!cpumask_test_cpu(cpu, cpu_online_mask)) |
| cpu_relax(); |
| return 0; |
| } |
| |
| static void panic_start_cpu(void) |
| { |
| panic("Received a MSG_START_CPU IPI after boot finished."); |
| } |
| |
| void __init smp_cpus_done(unsigned int max_cpus) |
| { |
| int cpu, next, rc; |
| |
| /* Reset the response to a (now illegal) MSG_START_CPU IPI. */ |
| start_cpu_function_addr = (unsigned long) &panic_start_cpu; |
| |
| cpumask_copy(&init_affinity, cpu_online_mask); |
| |
| /* |
| * Pin ourselves to a single cpu in the initial affinity set |
| * so that kernel mappings for the rootfs are not in the dataplane, |
| * if set, and to avoid unnecessary migrating during bringup. |
| * Use the last cpu just in case the whole chip has been |
| * isolated from the scheduler, to keep init away from likely |
| * more useful user code. This also ensures that work scheduled |
| * via schedule_delayed_work() in the init routines will land |
| * on this cpu. |
| */ |
| for (cpu = cpumask_first(&init_affinity); |
| (next = cpumask_next(cpu, &init_affinity)) < nr_cpu_ids; |
| cpu = next) |
| ; |
| rc = sched_setaffinity(current->pid, cpumask_of(cpu)); |
| if (rc != 0) |
| pr_err("Couldn't set init affinity to cpu %d (%d)\n", cpu, rc); |
| } |