forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
254 lines
5.0 KiB
254 lines
5.0 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* SMP support for Hexagon |
|
* |
|
* Copyright (c) 2010-2012, The Linux Foundation. All rights reserved. |
|
*/ |
|
|
|
#include <linux/err.h> |
|
#include <linux/errno.h> |
|
#include <linux/kernel.h> |
|
#include <linux/init.h> |
|
#include <linux/interrupt.h> |
|
#include <linux/module.h> |
|
#include <linux/percpu.h> |
|
#include <linux/sched/mm.h> |
|
#include <linux/smp.h> |
|
#include <linux/spinlock.h> |
|
#include <linux/cpu.h> |
|
#include <linux/mm_types.h> |
|
|
|
#include <asm/time.h> /* timer_interrupt */ |
|
#include <asm/hexagon_vm.h> |
|
|
|
#define BASE_IPI_IRQ 26 |
|
|
|
/* |
|
* cpu_possible_mask needs to be filled out prior to setup_per_cpu_areas |
|
* (which is prior to any of our smp_prepare_cpu crap), in order to set |
|
* up the... per_cpu areas. |
|
*/ |
|
|
|
struct ipi_data { |
|
unsigned long bits; |
|
}; |
|
|
|
static DEFINE_PER_CPU(struct ipi_data, ipi_data); |
|
|
|
static inline void __handle_ipi(unsigned long *ops, struct ipi_data *ipi, |
|
int cpu) |
|
{ |
|
unsigned long msg = 0; |
|
do { |
|
msg = find_next_bit(ops, BITS_PER_LONG, msg+1); |
|
|
|
switch (msg) { |
|
|
|
case IPI_TIMER: |
|
ipi_timer(); |
|
break; |
|
|
|
case IPI_CALL_FUNC: |
|
generic_smp_call_function_interrupt(); |
|
break; |
|
|
|
case IPI_CPU_STOP: |
|
/* |
|
* call vmstop() |
|
*/ |
|
__vmstop(); |
|
break; |
|
|
|
case IPI_RESCHEDULE: |
|
scheduler_ipi(); |
|
break; |
|
} |
|
} while (msg < BITS_PER_LONG); |
|
} |
|
|
|
/* Used for IPI call from other CPU's to unmask int */ |
|
void smp_vm_unmask_irq(void *info) |
|
{ |
|
__vmintop_locen((long) info); |
|
} |
|
|
|
|
|
/* |
|
* This is based on Alpha's IPI stuff. |
|
* Supposed to take (int, void*) as args now. |
|
* Specifically, first arg is irq, second is the irq_desc. |
|
*/ |
|
|
|
irqreturn_t handle_ipi(int irq, void *desc) |
|
{ |
|
int cpu = smp_processor_id(); |
|
struct ipi_data *ipi = &per_cpu(ipi_data, cpu); |
|
unsigned long ops; |
|
|
|
while ((ops = xchg(&ipi->bits, 0)) != 0) |
|
__handle_ipi(&ops, ipi, cpu); |
|
return IRQ_HANDLED; |
|
} |
|
|
|
void send_ipi(const struct cpumask *cpumask, enum ipi_message_type msg) |
|
{ |
|
unsigned long flags; |
|
unsigned long cpu; |
|
unsigned long retval; |
|
|
|
local_irq_save(flags); |
|
|
|
for_each_cpu(cpu, cpumask) { |
|
struct ipi_data *ipi = &per_cpu(ipi_data, cpu); |
|
|
|
set_bit(msg, &ipi->bits); |
|
/* Possible barrier here */ |
|
retval = __vmintop_post(BASE_IPI_IRQ+cpu); |
|
|
|
if (retval != 0) { |
|
printk(KERN_ERR "interrupt %ld not configured?\n", |
|
BASE_IPI_IRQ+cpu); |
|
} |
|
} |
|
|
|
local_irq_restore(flags); |
|
} |
|
|
|
void __init smp_prepare_boot_cpu(void) |
|
{ |
|
} |
|
|
|
/* |
|
* interrupts should already be disabled from the VM |
|
* SP should already be correct; need to set THREADINFO_REG |
|
* to point to current thread info |
|
*/ |
|
|
|
void start_secondary(void) |
|
{ |
|
unsigned long thread_ptr; |
|
unsigned int cpu, irq; |
|
|
|
/* Calculate thread_info pointer from stack pointer */ |
|
__asm__ __volatile__( |
|
"%0 = SP;\n" |
|
: "=r" (thread_ptr) |
|
); |
|
|
|
thread_ptr = thread_ptr & ~(THREAD_SIZE-1); |
|
|
|
__asm__ __volatile__( |
|
QUOTED_THREADINFO_REG " = %0;\n" |
|
: |
|
: "r" (thread_ptr) |
|
); |
|
|
|
/* Set the memory struct */ |
|
mmgrab(&init_mm); |
|
current->active_mm = &init_mm; |
|
|
|
cpu = smp_processor_id(); |
|
|
|
irq = BASE_IPI_IRQ + cpu; |
|
if (request_irq(irq, handle_ipi, IRQF_TRIGGER_RISING, "ipi_handler", |
|
NULL)) |
|
pr_err("Failed to request irq %u (ipi_handler)\n", irq); |
|
|
|
/* Register the clock_event dummy */ |
|
setup_percpu_clockdev(); |
|
|
|
printk(KERN_INFO "%s cpu %d\n", __func__, current_thread_info()->cpu); |
|
|
|
notify_cpu_starting(cpu); |
|
|
|
set_cpu_online(cpu, true); |
|
|
|
local_irq_enable(); |
|
|
|
cpu_startup_entry(CPUHP_AP_ONLINE_IDLE); |
|
} |
|
|
|
|
|
/* |
|
* called once for each present cpu |
|
* apparently starts up the CPU and then |
|
* maintains control until "cpu_online(cpu)" is set. |
|
*/ |
|
|
|
int __cpu_up(unsigned int cpu, struct task_struct *idle) |
|
{ |
|
struct thread_info *thread = (struct thread_info *)idle->stack; |
|
void *stack_start; |
|
|
|
thread->cpu = cpu; |
|
|
|
/* Boot to the head. */ |
|
stack_start = ((void *) thread) + THREAD_SIZE; |
|
__vmstart(start_secondary, stack_start); |
|
|
|
while (!cpu_online(cpu)) |
|
barrier(); |
|
|
|
return 0; |
|
} |
|
|
|
void __init smp_cpus_done(unsigned int max_cpus) |
|
{ |
|
} |
|
|
|
void __init smp_prepare_cpus(unsigned int max_cpus) |
|
{ |
|
int i, irq = BASE_IPI_IRQ; |
|
|
|
/* |
|
* should eventually have some sort of machine |
|
* descriptor that has this stuff |
|
*/ |
|
|
|
/* Right now, let's just fake it. */ |
|
for (i = 0; i < max_cpus; i++) |
|
set_cpu_present(i, true); |
|
|
|
/* Also need to register the interrupts for IPI */ |
|
if (max_cpus > 1) { |
|
if (request_irq(irq, handle_ipi, IRQF_TRIGGER_RISING, |
|
"ipi_handler", NULL)) |
|
pr_err("Failed to request irq %d (ipi_handler)\n", irq); |
|
} |
|
} |
|
|
|
void smp_send_reschedule(int cpu) |
|
{ |
|
send_ipi(cpumask_of(cpu), IPI_RESCHEDULE); |
|
} |
|
|
|
void smp_send_stop(void) |
|
{ |
|
struct cpumask targets; |
|
cpumask_copy(&targets, cpu_online_mask); |
|
cpumask_clear_cpu(smp_processor_id(), &targets); |
|
send_ipi(&targets, IPI_CPU_STOP); |
|
} |
|
|
|
void arch_send_call_function_single_ipi(int cpu) |
|
{ |
|
send_ipi(cpumask_of(cpu), IPI_CALL_FUNC); |
|
} |
|
|
|
void arch_send_call_function_ipi_mask(const struct cpumask *mask) |
|
{ |
|
send_ipi(mask, IPI_CALL_FUNC); |
|
} |
|
|
|
int setup_profiling_timer(unsigned int multiplier) |
|
{ |
|
return -EINVAL; |
|
} |
|
|
|
void smp_start_cpus(void) |
|
{ |
|
int i; |
|
|
|
for (i = 0; i < NR_CPUS; i++) |
|
set_cpu_possible(i, true); |
|
}
|
|
|