arch/riscv/kernel/smpboot.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * SMP initialisation and IPI support
   4  * Based on arch/arm64/kernel/smp.c
   5  *
   6  * Copyright (C) 2012 ARM Ltd.
   7  * Copyright (C) 2015 Regents of the University of California
   8  * Copyright (C) 2017 SiFive
   9  */
  10
  11 #include <linux/arch_topology.h>
  12 #include <linux/module.h>
  13 #include <linux/init.h>
  14 #include <linux/kernel.h>
  15 #include <linux/mm.h>
  16 #include <linux/sched.h>
  17 #include <linux/kernel_stat.h>
  18 #include <linux/notifier.h>
  19 #include <linux/cpu.h>
  20 #include <linux/percpu.h>
  21 #include <linux/delay.h>
  22 #include <linux/err.h>
  23 #include <linux/irq.h>
  24 #include <linux/of.h>
  25 #include <linux/sched/task_stack.h>
  26 #include <linux/sched/mm.h>
  27 #include <asm/cpu_ops.h>
  28 #include <asm/irq.h>
  29 #include <asm/mmu_context.h>
  30 #include <asm/numa.h>
  31 #include <asm/tlbflush.h>
  32 #include <asm/sections.h>
  33 #include <asm/sbi.h>
  34 #include <asm/smp.h>
  35 #include <asm/alternative.h>
  36
  37 #include "head.h"
  38
  39 static DECLARE_COMPLETION(cpu_running);
  40
  41 void __init smp_prepare_boot_cpu(void)
  42 {
  43         init_cpu_topology();
  44 #ifdef CONFIG_RISCV_ERRATA_ALTERNATIVE
  45         apply_boot_alternatives();
  46 #endif
  47 }
  48
  49 void __init smp_prepare_cpus(unsigned int max_cpus)
  50 {
  51         int cpuid;
  52         int ret;
  53         unsigned int curr_cpuid;
  54
  55         curr_cpuid = smp_processor_id();
  56         store_cpu_topology(curr_cpuid);
  57         numa_store_cpu_info(curr_cpuid);
  58         numa_add_cpu(curr_cpuid);
  59
  60         /* This covers non-smp usecase mandated by "nosmp" option */
  61         if (max_cpus == 0)
  62                 return;
  63
  64         for_each_possible_cpu(cpuid) {
  65                 if (cpuid == curr_cpuid)
  66                         continue;
  67                 if (cpu_ops[cpuid]->cpu_prepare) {
  68                         ret = cpu_ops[cpuid]->cpu_prepare(cpuid);
  69                         if (ret)
  70                                 continue;
  71                 }
  72                 set_cpu_present(cpuid, true);
  73                 numa_store_cpu_info(cpuid);
  74         }
  75 }
  76
  77 void __init setup_smp(void)
  78 {
  79         struct device_node *dn;
  80         int hart;
  81         bool found_boot_cpu = false;
  82         int cpuid = 1;
  83
  84         cpu_set_ops(0);
  85
  86         for_each_of_cpu_node(dn) {
  87                 hart = riscv_of_processor_hartid(dn);
  88                 if (hart < 0)
  89                         continue;
  90
  91                 if (hart == cpuid_to_hartid_map(0)) {
  92                         BUG_ON(found_boot_cpu);
  93                         found_boot_cpu = 1;
  94                         early_map_cpu_to_node(0, of_node_to_nid(dn));
  95                         continue;
  96                 }
  97                 if (cpuid >= NR_CPUS) {
  98                         pr_warn("Invalid cpuid [%d] for hartid [%d]\n",
  99                                 cpuid, hart);
 100                         break;
 101                 }
 102
 103                 cpuid_to_hartid_map(cpuid) = hart;
 104                 early_map_cpu_to_node(cpuid, of_node_to_nid(dn));
 105                 cpuid++;
 106         }
 107
 108         BUG_ON(!found_boot_cpu);
 109
 110         if (cpuid > nr_cpu_ids)
 111                 pr_warn("Total number of cpus [%d] is greater than nr_cpus option value [%d]\n",
 112                         cpuid, nr_cpu_ids);
 113
 114         for (cpuid = 1; cpuid < nr_cpu_ids; cpuid++) {
 115                 if (cpuid_to_hartid_map(cpuid) != INVALID_HARTID) {
 116                         cpu_set_ops(cpuid);
 117                         set_cpu_possible(cpuid, true);
 118                 }
 119         }
 120 }
 121
 122 static int start_secondary_cpu(int cpu, struct task_struct *tidle)
 123 {
 124         if (cpu_ops[cpu]->cpu_start)
 125                 return cpu_ops[cpu]->cpu_start(cpu, tidle);
 126
 127         return -EOPNOTSUPP;
 128 }
 129
 130 int __cpu_up(unsigned int cpu, struct task_struct *tidle)
 131 {
 132         int ret = 0;
 133         tidle->thread_info.cpu = cpu;
 134
 135         ret = start_secondary_cpu(cpu, tidle);
 136         if (!ret) {
 137                 wait_for_completion_timeout(&cpu_running,
 138                                             msecs_to_jiffies(1000));
 139
 140                 if (!cpu_online(cpu)) {
 141                         pr_crit("CPU%u: failed to come online\n", cpu);
 142                         ret = -EIO;
 143                 }
 144         } else {
 145                 pr_crit("CPU%u: failed to start\n", cpu);
 146         }
 147
 148         return ret;
 149 }
 150
 151 void __init smp_cpus_done(unsigned int max_cpus)
 152 {
 153 }
 154
 155 /*
 156  * C entry point for a secondary processor.
 157  */
 158 asmlinkage __visible void smp_callin(void)
 159 {
 160         struct mm_struct *mm = &init_mm;
 161         unsigned int curr_cpuid = smp_processor_id();
 162
 163         riscv_clear_ipi();
 164
 165         /* All kernel threads share the same mm context.  */
 166         mmgrab(mm);
 167         current->active_mm = mm;
 168
 169         store_cpu_topology(curr_cpuid);
 170         notify_cpu_starting(curr_cpuid);
 171         numa_add_cpu(curr_cpuid);
 172         set_cpu_online(curr_cpuid, 1);
 173
 174         /*
 175          * Remote TLB flushes are ignored while the CPU is offline, so emit
 176          * a local TLB flush right now just in case.
 177          */
 178         local_flush_tlb_all();
 179         complete(&cpu_running);
 180         /*
 181          * Disable preemption before enabling interrupts, so we don't try to
 182          * schedule a CPU that hasn't actually started yet.
 183          */
 184         local_irq_enable();
 185         cpu_startup_entry(CPUHP_AP_ONLINE_IDLE);
 186 }