mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 19:29:37 +00:00
![James Morse](/assets/img/avatar_default.png)
[ Upstream commit 54f529a680
]
SDEI has private events that need registering and enabling on each CPU.
CPUs can come and go while we are trying to do this. SDEI tries to avoid
these problems by setting the reregister flag before the register call,
so any CPUs that come online register the event too. Sticking plaster
like this doesn't work, as if the register call fails, a CPU that
subsequently comes online will register the event before reregister
is cleared.
Take cpus_read_lock() around the register and enable calls. We don't
want surprise CPUs to do the wrong thing if they race with these calls
failing.
Signed-off-by: James Morse <james.morse@arm.com>
Signed-off-by: Catalin Marinas <catalin.marinas@arm.com>
Signed-off-by: Sasha Levin <sashal@kernel.org>
1157 lines
25 KiB
C
1157 lines
25 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
// Copyright (C) 2017 Arm Ltd.
|
|
#define pr_fmt(fmt) "sdei: " fmt
|
|
|
|
#include <acpi/ghes.h>
|
|
#include <linux/acpi.h>
|
|
#include <linux/arm_sdei.h>
|
|
#include <linux/arm-smccc.h>
|
|
#include <linux/atomic.h>
|
|
#include <linux/bitops.h>
|
|
#include <linux/compiler.h>
|
|
#include <linux/cpuhotplug.h>
|
|
#include <linux/cpu.h>
|
|
#include <linux/cpu_pm.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/hardirq.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/kprobes.h>
|
|
#include <linux/kvm_host.h>
|
|
#include <linux/list.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/notifier.h>
|
|
#include <linux/of.h>
|
|
#include <linux/of_platform.h>
|
|
#include <linux/percpu.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/pm.h>
|
|
#include <linux/ptrace.h>
|
|
#include <linux/preempt.h>
|
|
#include <linux/reboot.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/smp.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/uaccess.h>
|
|
|
|
/*
|
|
* The call to use to reach the firmware.
|
|
*/
|
|
static asmlinkage void (*sdei_firmware_call)(unsigned long function_id,
|
|
unsigned long arg0, unsigned long arg1,
|
|
unsigned long arg2, unsigned long arg3,
|
|
unsigned long arg4, struct arm_smccc_res *res);
|
|
|
|
/* entry point from firmware to arch asm code */
|
|
static unsigned long sdei_entry_point;
|
|
|
|
struct sdei_event {
|
|
/* These three are protected by the sdei_list_lock */
|
|
struct list_head list;
|
|
bool reregister;
|
|
bool reenable;
|
|
|
|
u32 event_num;
|
|
u8 type;
|
|
u8 priority;
|
|
|
|
/* This pointer is handed to firmware as the event argument. */
|
|
union {
|
|
/* Shared events */
|
|
struct sdei_registered_event *registered;
|
|
|
|
/* CPU private events */
|
|
struct sdei_registered_event __percpu *private_registered;
|
|
};
|
|
};
|
|
|
|
/* Take the mutex for any API call or modification. Take the mutex first. */
|
|
static DEFINE_MUTEX(sdei_events_lock);
|
|
|
|
/* and then hold this when modifying the list */
|
|
static DEFINE_SPINLOCK(sdei_list_lock);
|
|
static LIST_HEAD(sdei_list);
|
|
|
|
/* Private events are registered/enabled via IPI passing one of these */
|
|
struct sdei_crosscall_args {
|
|
struct sdei_event *event;
|
|
atomic_t errors;
|
|
int first_error;
|
|
};
|
|
|
|
#define CROSSCALL_INIT(arg, event) (arg.event = event, \
|
|
arg.first_error = 0, \
|
|
atomic_set(&arg.errors, 0))
|
|
|
|
static inline int sdei_do_cross_call(void *fn, struct sdei_event * event)
|
|
{
|
|
struct sdei_crosscall_args arg;
|
|
|
|
CROSSCALL_INIT(arg, event);
|
|
on_each_cpu(fn, &arg, true);
|
|
|
|
return arg.first_error;
|
|
}
|
|
|
|
static inline void
|
|
sdei_cross_call_return(struct sdei_crosscall_args *arg, int err)
|
|
{
|
|
if (err && (atomic_inc_return(&arg->errors) == 1))
|
|
arg->first_error = err;
|
|
}
|
|
|
|
static int sdei_to_linux_errno(unsigned long sdei_err)
|
|
{
|
|
switch (sdei_err) {
|
|
case SDEI_NOT_SUPPORTED:
|
|
return -EOPNOTSUPP;
|
|
case SDEI_INVALID_PARAMETERS:
|
|
return -EINVAL;
|
|
case SDEI_DENIED:
|
|
return -EPERM;
|
|
case SDEI_PENDING:
|
|
return -EINPROGRESS;
|
|
case SDEI_OUT_OF_RESOURCE:
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/* Not an error value ... */
|
|
return sdei_err;
|
|
}
|
|
|
|
/*
|
|
* If x0 is any of these values, then the call failed, use sdei_to_linux_errno()
|
|
* to translate.
|
|
*/
|
|
static int sdei_is_err(struct arm_smccc_res *res)
|
|
{
|
|
switch (res->a0) {
|
|
case SDEI_NOT_SUPPORTED:
|
|
case SDEI_INVALID_PARAMETERS:
|
|
case SDEI_DENIED:
|
|
case SDEI_PENDING:
|
|
case SDEI_OUT_OF_RESOURCE:
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static int invoke_sdei_fn(unsigned long function_id, unsigned long arg0,
|
|
unsigned long arg1, unsigned long arg2,
|
|
unsigned long arg3, unsigned long arg4,
|
|
u64 *result)
|
|
{
|
|
int err = 0;
|
|
struct arm_smccc_res res;
|
|
|
|
if (sdei_firmware_call) {
|
|
sdei_firmware_call(function_id, arg0, arg1, arg2, arg3, arg4,
|
|
&res);
|
|
if (sdei_is_err(&res))
|
|
err = sdei_to_linux_errno(res.a0);
|
|
} else {
|
|
/*
|
|
* !sdei_firmware_call means we failed to probe or called
|
|
* sdei_mark_interface_broken(). -EIO is not an error returned
|
|
* by sdei_to_linux_errno() and is used to suppress messages
|
|
* from this driver.
|
|
*/
|
|
err = -EIO;
|
|
res.a0 = SDEI_NOT_SUPPORTED;
|
|
}
|
|
|
|
if (result)
|
|
*result = res.a0;
|
|
|
|
return err;
|
|
}
|
|
NOKPROBE_SYMBOL(invoke_sdei_fn);
|
|
|
|
static struct sdei_event *sdei_event_find(u32 event_num)
|
|
{
|
|
struct sdei_event *e, *found = NULL;
|
|
|
|
lockdep_assert_held(&sdei_events_lock);
|
|
|
|
spin_lock(&sdei_list_lock);
|
|
list_for_each_entry(e, &sdei_list, list) {
|
|
if (e->event_num == event_num) {
|
|
found = e;
|
|
break;
|
|
}
|
|
}
|
|
spin_unlock(&sdei_list_lock);
|
|
|
|
return found;
|
|
}
|
|
|
|
int sdei_api_event_context(u32 query, u64 *result)
|
|
{
|
|
return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_CONTEXT, query, 0, 0, 0, 0,
|
|
result);
|
|
}
|
|
NOKPROBE_SYMBOL(sdei_api_event_context);
|
|
|
|
static int sdei_api_event_get_info(u32 event, u32 info, u64 *result)
|
|
{
|
|
return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_GET_INFO, event, info, 0,
|
|
0, 0, result);
|
|
}
|
|
|
|
static struct sdei_event *sdei_event_create(u32 event_num,
|
|
sdei_event_callback *cb,
|
|
void *cb_arg)
|
|
{
|
|
int err;
|
|
u64 result;
|
|
struct sdei_event *event;
|
|
struct sdei_registered_event *reg;
|
|
|
|
lockdep_assert_held(&sdei_events_lock);
|
|
|
|
event = kzalloc(sizeof(*event), GFP_KERNEL);
|
|
if (!event)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
INIT_LIST_HEAD(&event->list);
|
|
event->event_num = event_num;
|
|
|
|
err = sdei_api_event_get_info(event_num, SDEI_EVENT_INFO_EV_PRIORITY,
|
|
&result);
|
|
if (err) {
|
|
kfree(event);
|
|
return ERR_PTR(err);
|
|
}
|
|
event->priority = result;
|
|
|
|
err = sdei_api_event_get_info(event_num, SDEI_EVENT_INFO_EV_TYPE,
|
|
&result);
|
|
if (err) {
|
|
kfree(event);
|
|
return ERR_PTR(err);
|
|
}
|
|
event->type = result;
|
|
|
|
if (event->type == SDEI_EVENT_TYPE_SHARED) {
|
|
reg = kzalloc(sizeof(*reg), GFP_KERNEL);
|
|
if (!reg) {
|
|
kfree(event);
|
|
return ERR_PTR(-ENOMEM);
|
|
}
|
|
|
|
reg->event_num = event_num;
|
|
reg->priority = event->priority;
|
|
|
|
reg->callback = cb;
|
|
reg->callback_arg = cb_arg;
|
|
event->registered = reg;
|
|
} else {
|
|
int cpu;
|
|
struct sdei_registered_event __percpu *regs;
|
|
|
|
regs = alloc_percpu(struct sdei_registered_event);
|
|
if (!regs) {
|
|
kfree(event);
|
|
return ERR_PTR(-ENOMEM);
|
|
}
|
|
|
|
for_each_possible_cpu(cpu) {
|
|
reg = per_cpu_ptr(regs, cpu);
|
|
|
|
reg->event_num = event->event_num;
|
|
reg->priority = event->priority;
|
|
reg->callback = cb;
|
|
reg->callback_arg = cb_arg;
|
|
}
|
|
|
|
event->private_registered = regs;
|
|
}
|
|
|
|
if (sdei_event_find(event_num)) {
|
|
kfree(event->registered);
|
|
kfree(event);
|
|
event = ERR_PTR(-EBUSY);
|
|
} else {
|
|
spin_lock(&sdei_list_lock);
|
|
list_add(&event->list, &sdei_list);
|
|
spin_unlock(&sdei_list_lock);
|
|
}
|
|
|
|
return event;
|
|
}
|
|
|
|
static void sdei_event_destroy(struct sdei_event *event)
|
|
{
|
|
lockdep_assert_held(&sdei_events_lock);
|
|
|
|
spin_lock(&sdei_list_lock);
|
|
list_del(&event->list);
|
|
spin_unlock(&sdei_list_lock);
|
|
|
|
if (event->type == SDEI_EVENT_TYPE_SHARED)
|
|
kfree(event->registered);
|
|
else
|
|
free_percpu(event->private_registered);
|
|
|
|
kfree(event);
|
|
}
|
|
|
|
static int sdei_api_get_version(u64 *version)
|
|
{
|
|
return invoke_sdei_fn(SDEI_1_0_FN_SDEI_VERSION, 0, 0, 0, 0, 0, version);
|
|
}
|
|
|
|
int sdei_mask_local_cpu(void)
|
|
{
|
|
int err;
|
|
|
|
WARN_ON_ONCE(preemptible());
|
|
|
|
err = invoke_sdei_fn(SDEI_1_0_FN_SDEI_PE_MASK, 0, 0, 0, 0, 0, NULL);
|
|
if (err && err != -EIO) {
|
|
pr_warn_once("failed to mask CPU[%u]: %d\n",
|
|
smp_processor_id(), err);
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void _ipi_mask_cpu(void *ignored)
|
|
{
|
|
sdei_mask_local_cpu();
|
|
}
|
|
|
|
int sdei_unmask_local_cpu(void)
|
|
{
|
|
int err;
|
|
|
|
WARN_ON_ONCE(preemptible());
|
|
|
|
err = invoke_sdei_fn(SDEI_1_0_FN_SDEI_PE_UNMASK, 0, 0, 0, 0, 0, NULL);
|
|
if (err && err != -EIO) {
|
|
pr_warn_once("failed to unmask CPU[%u]: %d\n",
|
|
smp_processor_id(), err);
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void _ipi_unmask_cpu(void *ignored)
|
|
{
|
|
sdei_unmask_local_cpu();
|
|
}
|
|
|
|
static void _ipi_private_reset(void *ignored)
|
|
{
|
|
int err;
|
|
|
|
err = invoke_sdei_fn(SDEI_1_0_FN_SDEI_PRIVATE_RESET, 0, 0, 0, 0, 0,
|
|
NULL);
|
|
if (err && err != -EIO)
|
|
pr_warn_once("failed to reset CPU[%u]: %d\n",
|
|
smp_processor_id(), err);
|
|
}
|
|
|
|
static int sdei_api_shared_reset(void)
|
|
{
|
|
return invoke_sdei_fn(SDEI_1_0_FN_SDEI_SHARED_RESET, 0, 0, 0, 0, 0,
|
|
NULL);
|
|
}
|
|
|
|
static void sdei_mark_interface_broken(void)
|
|
{
|
|
pr_err("disabling SDEI firmware interface\n");
|
|
on_each_cpu(&_ipi_mask_cpu, NULL, true);
|
|
sdei_firmware_call = NULL;
|
|
}
|
|
|
|
static int sdei_platform_reset(void)
|
|
{
|
|
int err;
|
|
|
|
on_each_cpu(&_ipi_private_reset, NULL, true);
|
|
err = sdei_api_shared_reset();
|
|
if (err) {
|
|
pr_err("Failed to reset platform: %d\n", err);
|
|
sdei_mark_interface_broken();
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static int sdei_api_event_enable(u32 event_num)
|
|
{
|
|
return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_ENABLE, event_num, 0, 0, 0,
|
|
0, NULL);
|
|
}
|
|
|
|
/* Called directly by the hotplug callbacks */
|
|
static void _local_event_enable(void *data)
|
|
{
|
|
int err;
|
|
struct sdei_crosscall_args *arg = data;
|
|
|
|
WARN_ON_ONCE(preemptible());
|
|
|
|
err = sdei_api_event_enable(arg->event->event_num);
|
|
|
|
sdei_cross_call_return(arg, err);
|
|
}
|
|
|
|
int sdei_event_enable(u32 event_num)
|
|
{
|
|
int err = -EINVAL;
|
|
struct sdei_event *event;
|
|
|
|
mutex_lock(&sdei_events_lock);
|
|
event = sdei_event_find(event_num);
|
|
if (!event) {
|
|
mutex_unlock(&sdei_events_lock);
|
|
return -ENOENT;
|
|
}
|
|
|
|
|
|
cpus_read_lock();
|
|
if (event->type == SDEI_EVENT_TYPE_SHARED)
|
|
err = sdei_api_event_enable(event->event_num);
|
|
else
|
|
err = sdei_do_cross_call(_local_event_enable, event);
|
|
|
|
if (!err) {
|
|
spin_lock(&sdei_list_lock);
|
|
event->reenable = true;
|
|
spin_unlock(&sdei_list_lock);
|
|
}
|
|
cpus_read_unlock();
|
|
mutex_unlock(&sdei_events_lock);
|
|
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(sdei_event_enable);
|
|
|
|
static int sdei_api_event_disable(u32 event_num)
|
|
{
|
|
return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_DISABLE, event_num, 0, 0,
|
|
0, 0, NULL);
|
|
}
|
|
|
|
static void _ipi_event_disable(void *data)
|
|
{
|
|
int err;
|
|
struct sdei_crosscall_args *arg = data;
|
|
|
|
err = sdei_api_event_disable(arg->event->event_num);
|
|
|
|
sdei_cross_call_return(arg, err);
|
|
}
|
|
|
|
int sdei_event_disable(u32 event_num)
|
|
{
|
|
int err = -EINVAL;
|
|
struct sdei_event *event;
|
|
|
|
mutex_lock(&sdei_events_lock);
|
|
event = sdei_event_find(event_num);
|
|
if (!event) {
|
|
mutex_unlock(&sdei_events_lock);
|
|
return -ENOENT;
|
|
}
|
|
|
|
spin_lock(&sdei_list_lock);
|
|
event->reenable = false;
|
|
spin_unlock(&sdei_list_lock);
|
|
|
|
if (event->type == SDEI_EVENT_TYPE_SHARED)
|
|
err = sdei_api_event_disable(event->event_num);
|
|
else
|
|
err = sdei_do_cross_call(_ipi_event_disable, event);
|
|
mutex_unlock(&sdei_events_lock);
|
|
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(sdei_event_disable);
|
|
|
|
static int sdei_api_event_unregister(u32 event_num)
|
|
{
|
|
return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_UNREGISTER, event_num, 0,
|
|
0, 0, 0, NULL);
|
|
}
|
|
|
|
/* Called directly by the hotplug callbacks */
|
|
static void _local_event_unregister(void *data)
|
|
{
|
|
int err;
|
|
struct sdei_crosscall_args *arg = data;
|
|
|
|
WARN_ON_ONCE(preemptible());
|
|
|
|
err = sdei_api_event_unregister(arg->event->event_num);
|
|
|
|
sdei_cross_call_return(arg, err);
|
|
}
|
|
|
|
static int _sdei_event_unregister(struct sdei_event *event)
|
|
{
|
|
lockdep_assert_held(&sdei_events_lock);
|
|
|
|
if (event->type == SDEI_EVENT_TYPE_SHARED)
|
|
return sdei_api_event_unregister(event->event_num);
|
|
|
|
return sdei_do_cross_call(_local_event_unregister, event);
|
|
}
|
|
|
|
int sdei_event_unregister(u32 event_num)
|
|
{
|
|
int err;
|
|
struct sdei_event *event;
|
|
|
|
WARN_ON(in_nmi());
|
|
|
|
mutex_lock(&sdei_events_lock);
|
|
event = sdei_event_find(event_num);
|
|
do {
|
|
if (!event) {
|
|
pr_warn("Event %u not registered\n", event_num);
|
|
err = -ENOENT;
|
|
break;
|
|
}
|
|
|
|
spin_lock(&sdei_list_lock);
|
|
event->reregister = false;
|
|
event->reenable = false;
|
|
spin_unlock(&sdei_list_lock);
|
|
|
|
err = _sdei_event_unregister(event);
|
|
if (err)
|
|
break;
|
|
|
|
sdei_event_destroy(event);
|
|
} while (0);
|
|
mutex_unlock(&sdei_events_lock);
|
|
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(sdei_event_unregister);
|
|
|
|
/*
|
|
* unregister events, but don't destroy them as they are re-registered by
|
|
* sdei_reregister_shared().
|
|
*/
|
|
static int sdei_unregister_shared(void)
|
|
{
|
|
int err = 0;
|
|
struct sdei_event *event;
|
|
|
|
mutex_lock(&sdei_events_lock);
|
|
spin_lock(&sdei_list_lock);
|
|
list_for_each_entry(event, &sdei_list, list) {
|
|
if (event->type != SDEI_EVENT_TYPE_SHARED)
|
|
continue;
|
|
|
|
err = _sdei_event_unregister(event);
|
|
if (err)
|
|
break;
|
|
}
|
|
spin_unlock(&sdei_list_lock);
|
|
mutex_unlock(&sdei_events_lock);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int sdei_api_event_register(u32 event_num, unsigned long entry_point,
|
|
void *arg, u64 flags, u64 affinity)
|
|
{
|
|
return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_REGISTER, event_num,
|
|
(unsigned long)entry_point, (unsigned long)arg,
|
|
flags, affinity, NULL);
|
|
}
|
|
|
|
/* Called directly by the hotplug callbacks */
|
|
static void _local_event_register(void *data)
|
|
{
|
|
int err;
|
|
struct sdei_registered_event *reg;
|
|
struct sdei_crosscall_args *arg = data;
|
|
|
|
WARN_ON(preemptible());
|
|
|
|
reg = per_cpu_ptr(arg->event->private_registered, smp_processor_id());
|
|
err = sdei_api_event_register(arg->event->event_num, sdei_entry_point,
|
|
reg, 0, 0);
|
|
|
|
sdei_cross_call_return(arg, err);
|
|
}
|
|
|
|
static int _sdei_event_register(struct sdei_event *event)
|
|
{
|
|
int err;
|
|
|
|
lockdep_assert_held(&sdei_events_lock);
|
|
|
|
if (event->type == SDEI_EVENT_TYPE_SHARED)
|
|
return sdei_api_event_register(event->event_num,
|
|
sdei_entry_point,
|
|
event->registered,
|
|
SDEI_EVENT_REGISTER_RM_ANY, 0);
|
|
|
|
err = sdei_do_cross_call(_local_event_register, event);
|
|
if (err)
|
|
sdei_do_cross_call(_local_event_unregister, event);
|
|
|
|
return err;
|
|
}
|
|
|
|
int sdei_event_register(u32 event_num, sdei_event_callback *cb, void *arg)
|
|
{
|
|
int err;
|
|
struct sdei_event *event;
|
|
|
|
WARN_ON(in_nmi());
|
|
|
|
mutex_lock(&sdei_events_lock);
|
|
do {
|
|
if (sdei_event_find(event_num)) {
|
|
pr_warn("Event %u already registered\n", event_num);
|
|
err = -EBUSY;
|
|
break;
|
|
}
|
|
|
|
event = sdei_event_create(event_num, cb, arg);
|
|
if (IS_ERR(event)) {
|
|
err = PTR_ERR(event);
|
|
pr_warn("Failed to create event %u: %d\n", event_num,
|
|
err);
|
|
break;
|
|
}
|
|
|
|
cpus_read_lock();
|
|
err = _sdei_event_register(event);
|
|
if (err) {
|
|
sdei_event_destroy(event);
|
|
pr_warn("Failed to register event %u: %d\n", event_num,
|
|
err);
|
|
} else {
|
|
spin_lock(&sdei_list_lock);
|
|
event->reregister = true;
|
|
spin_unlock(&sdei_list_lock);
|
|
}
|
|
cpus_read_unlock();
|
|
} while (0);
|
|
mutex_unlock(&sdei_events_lock);
|
|
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(sdei_event_register);
|
|
|
|
static int sdei_reregister_event(struct sdei_event *event)
|
|
{
|
|
int err;
|
|
|
|
lockdep_assert_held(&sdei_events_lock);
|
|
|
|
err = _sdei_event_register(event);
|
|
if (err) {
|
|
pr_err("Failed to re-register event %u\n", event->event_num);
|
|
sdei_event_destroy(event);
|
|
return err;
|
|
}
|
|
|
|
if (event->reenable) {
|
|
if (event->type == SDEI_EVENT_TYPE_SHARED)
|
|
err = sdei_api_event_enable(event->event_num);
|
|
else
|
|
err = sdei_do_cross_call(_local_event_enable, event);
|
|
}
|
|
|
|
if (err)
|
|
pr_err("Failed to re-enable event %u\n", event->event_num);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int sdei_reregister_shared(void)
|
|
{
|
|
int err = 0;
|
|
struct sdei_event *event;
|
|
|
|
mutex_lock(&sdei_events_lock);
|
|
spin_lock(&sdei_list_lock);
|
|
list_for_each_entry(event, &sdei_list, list) {
|
|
if (event->type != SDEI_EVENT_TYPE_SHARED)
|
|
continue;
|
|
|
|
if (event->reregister) {
|
|
err = sdei_reregister_event(event);
|
|
if (err)
|
|
break;
|
|
}
|
|
}
|
|
spin_unlock(&sdei_list_lock);
|
|
mutex_unlock(&sdei_events_lock);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int sdei_cpuhp_down(unsigned int cpu)
|
|
{
|
|
struct sdei_event *event;
|
|
struct sdei_crosscall_args arg;
|
|
|
|
/* un-register private events */
|
|
spin_lock(&sdei_list_lock);
|
|
list_for_each_entry(event, &sdei_list, list) {
|
|
if (event->type == SDEI_EVENT_TYPE_SHARED)
|
|
continue;
|
|
|
|
CROSSCALL_INIT(arg, event);
|
|
/* call the cross-call function locally... */
|
|
_local_event_unregister(&arg);
|
|
if (arg.first_error)
|
|
pr_err("Failed to unregister event %u: %d\n",
|
|
event->event_num, arg.first_error);
|
|
}
|
|
spin_unlock(&sdei_list_lock);
|
|
|
|
return sdei_mask_local_cpu();
|
|
}
|
|
|
|
static int sdei_cpuhp_up(unsigned int cpu)
|
|
{
|
|
struct sdei_event *event;
|
|
struct sdei_crosscall_args arg;
|
|
|
|
/* re-register/enable private events */
|
|
spin_lock(&sdei_list_lock);
|
|
list_for_each_entry(event, &sdei_list, list) {
|
|
if (event->type == SDEI_EVENT_TYPE_SHARED)
|
|
continue;
|
|
|
|
if (event->reregister) {
|
|
CROSSCALL_INIT(arg, event);
|
|
/* call the cross-call function locally... */
|
|
_local_event_register(&arg);
|
|
if (arg.first_error)
|
|
pr_err("Failed to re-register event %u: %d\n",
|
|
event->event_num, arg.first_error);
|
|
}
|
|
|
|
if (event->reenable) {
|
|
CROSSCALL_INIT(arg, event);
|
|
_local_event_enable(&arg);
|
|
if (arg.first_error)
|
|
pr_err("Failed to re-enable event %u: %d\n",
|
|
event->event_num, arg.first_error);
|
|
}
|
|
}
|
|
spin_unlock(&sdei_list_lock);
|
|
|
|
return sdei_unmask_local_cpu();
|
|
}
|
|
|
|
/* When entering idle, mask/unmask events for this cpu */
|
|
static int sdei_pm_notifier(struct notifier_block *nb, unsigned long action,
|
|
void *data)
|
|
{
|
|
int rv;
|
|
|
|
switch (action) {
|
|
case CPU_PM_ENTER:
|
|
rv = sdei_mask_local_cpu();
|
|
break;
|
|
case CPU_PM_EXIT:
|
|
case CPU_PM_ENTER_FAILED:
|
|
rv = sdei_unmask_local_cpu();
|
|
break;
|
|
default:
|
|
return NOTIFY_DONE;
|
|
}
|
|
|
|
if (rv)
|
|
return notifier_from_errno(rv);
|
|
|
|
return NOTIFY_OK;
|
|
}
|
|
|
|
static struct notifier_block sdei_pm_nb = {
|
|
.notifier_call = sdei_pm_notifier,
|
|
};
|
|
|
|
static int sdei_device_suspend(struct device *dev)
|
|
{
|
|
on_each_cpu(_ipi_mask_cpu, NULL, true);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int sdei_device_resume(struct device *dev)
|
|
{
|
|
on_each_cpu(_ipi_unmask_cpu, NULL, true);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* We need all events to be reregistered when we resume from hibernate.
|
|
*
|
|
* The sequence is freeze->thaw. Reboot. freeze->restore. We unregister
|
|
* events during freeze, then re-register and re-enable them during thaw
|
|
* and restore.
|
|
*/
|
|
static int sdei_device_freeze(struct device *dev)
|
|
{
|
|
int err;
|
|
|
|
/* unregister private events */
|
|
cpuhp_remove_state(CPUHP_AP_ARM_SDEI_STARTING);
|
|
|
|
err = sdei_unregister_shared();
|
|
if (err)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int sdei_device_thaw(struct device *dev)
|
|
{
|
|
int err;
|
|
|
|
/* re-register shared events */
|
|
err = sdei_reregister_shared();
|
|
if (err) {
|
|
pr_warn("Failed to re-register shared events...\n");
|
|
sdei_mark_interface_broken();
|
|
return err;
|
|
}
|
|
|
|
err = cpuhp_setup_state(CPUHP_AP_ARM_SDEI_STARTING, "SDEI",
|
|
&sdei_cpuhp_up, &sdei_cpuhp_down);
|
|
if (err)
|
|
pr_warn("Failed to re-register CPU hotplug notifier...\n");
|
|
|
|
return err;
|
|
}
|
|
|
|
static int sdei_device_restore(struct device *dev)
|
|
{
|
|
int err;
|
|
|
|
err = sdei_platform_reset();
|
|
if (err)
|
|
return err;
|
|
|
|
return sdei_device_thaw(dev);
|
|
}
|
|
|
|
static const struct dev_pm_ops sdei_pm_ops = {
|
|
.suspend = sdei_device_suspend,
|
|
.resume = sdei_device_resume,
|
|
.freeze = sdei_device_freeze,
|
|
.thaw = sdei_device_thaw,
|
|
.restore = sdei_device_restore,
|
|
};
|
|
|
|
/*
|
|
* Mask all CPUs and unregister all events on panic, reboot or kexec.
|
|
*/
|
|
static int sdei_reboot_notifier(struct notifier_block *nb, unsigned long action,
|
|
void *data)
|
|
{
|
|
/*
|
|
* We are going to reset the interface, after this there is no point
|
|
* doing work when we take CPUs offline.
|
|
*/
|
|
cpuhp_remove_state(CPUHP_AP_ARM_SDEI_STARTING);
|
|
|
|
sdei_platform_reset();
|
|
|
|
return NOTIFY_OK;
|
|
}
|
|
|
|
static struct notifier_block sdei_reboot_nb = {
|
|
.notifier_call = sdei_reboot_notifier,
|
|
};
|
|
|
|
static void sdei_smccc_smc(unsigned long function_id,
|
|
unsigned long arg0, unsigned long arg1,
|
|
unsigned long arg2, unsigned long arg3,
|
|
unsigned long arg4, struct arm_smccc_res *res)
|
|
{
|
|
arm_smccc_smc(function_id, arg0, arg1, arg2, arg3, arg4, 0, 0, res);
|
|
}
|
|
NOKPROBE_SYMBOL(sdei_smccc_smc);
|
|
|
|
static void sdei_smccc_hvc(unsigned long function_id,
|
|
unsigned long arg0, unsigned long arg1,
|
|
unsigned long arg2, unsigned long arg3,
|
|
unsigned long arg4, struct arm_smccc_res *res)
|
|
{
|
|
arm_smccc_hvc(function_id, arg0, arg1, arg2, arg3, arg4, 0, 0, res);
|
|
}
|
|
NOKPROBE_SYMBOL(sdei_smccc_hvc);
|
|
|
|
int sdei_register_ghes(struct ghes *ghes, sdei_event_callback *normal_cb,
|
|
sdei_event_callback *critical_cb)
|
|
{
|
|
int err;
|
|
u64 result;
|
|
u32 event_num;
|
|
sdei_event_callback *cb;
|
|
|
|
if (!IS_ENABLED(CONFIG_ACPI_APEI_GHES))
|
|
return -EOPNOTSUPP;
|
|
|
|
event_num = ghes->generic->notify.vector;
|
|
if (event_num == 0) {
|
|
/*
|
|
* Event 0 is reserved by the specification for
|
|
* SDEI_EVENT_SIGNAL.
|
|
*/
|
|
return -EINVAL;
|
|
}
|
|
|
|
err = sdei_api_event_get_info(event_num, SDEI_EVENT_INFO_EV_PRIORITY,
|
|
&result);
|
|
if (err)
|
|
return err;
|
|
|
|
if (result == SDEI_EVENT_PRIORITY_CRITICAL)
|
|
cb = critical_cb;
|
|
else
|
|
cb = normal_cb;
|
|
|
|
err = sdei_event_register(event_num, cb, ghes);
|
|
if (!err)
|
|
err = sdei_event_enable(event_num);
|
|
|
|
return err;
|
|
}
|
|
|
|
int sdei_unregister_ghes(struct ghes *ghes)
|
|
{
|
|
int i;
|
|
int err;
|
|
u32 event_num = ghes->generic->notify.vector;
|
|
|
|
might_sleep();
|
|
|
|
if (!IS_ENABLED(CONFIG_ACPI_APEI_GHES))
|
|
return -EOPNOTSUPP;
|
|
|
|
/*
|
|
* The event may be running on another CPU. Disable it
|
|
* to stop new events, then try to unregister a few times.
|
|
*/
|
|
err = sdei_event_disable(event_num);
|
|
if (err)
|
|
return err;
|
|
|
|
for (i = 0; i < 3; i++) {
|
|
err = sdei_event_unregister(event_num);
|
|
if (err != -EINPROGRESS)
|
|
break;
|
|
|
|
schedule();
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static int sdei_get_conduit(struct platform_device *pdev)
|
|
{
|
|
const char *method;
|
|
struct device_node *np = pdev->dev.of_node;
|
|
|
|
sdei_firmware_call = NULL;
|
|
if (np) {
|
|
if (of_property_read_string(np, "method", &method)) {
|
|
pr_warn("missing \"method\" property\n");
|
|
return CONDUIT_INVALID;
|
|
}
|
|
|
|
if (!strcmp("hvc", method)) {
|
|
sdei_firmware_call = &sdei_smccc_hvc;
|
|
return CONDUIT_HVC;
|
|
} else if (!strcmp("smc", method)) {
|
|
sdei_firmware_call = &sdei_smccc_smc;
|
|
return CONDUIT_SMC;
|
|
}
|
|
|
|
pr_warn("invalid \"method\" property: %s\n", method);
|
|
} else if (IS_ENABLED(CONFIG_ACPI) && !acpi_disabled) {
|
|
if (acpi_psci_use_hvc()) {
|
|
sdei_firmware_call = &sdei_smccc_hvc;
|
|
return CONDUIT_HVC;
|
|
} else {
|
|
sdei_firmware_call = &sdei_smccc_smc;
|
|
return CONDUIT_SMC;
|
|
}
|
|
}
|
|
|
|
return CONDUIT_INVALID;
|
|
}
|
|
|
|
static int sdei_probe(struct platform_device *pdev)
|
|
{
|
|
int err;
|
|
u64 ver = 0;
|
|
int conduit;
|
|
|
|
conduit = sdei_get_conduit(pdev);
|
|
if (!sdei_firmware_call)
|
|
return 0;
|
|
|
|
err = sdei_api_get_version(&ver);
|
|
if (err == -EOPNOTSUPP)
|
|
pr_err("advertised but not implemented in platform firmware\n");
|
|
if (err) {
|
|
pr_err("Failed to get SDEI version: %d\n", err);
|
|
sdei_mark_interface_broken();
|
|
return err;
|
|
}
|
|
|
|
pr_info("SDEIv%d.%d (0x%x) detected in firmware.\n",
|
|
(int)SDEI_VERSION_MAJOR(ver), (int)SDEI_VERSION_MINOR(ver),
|
|
(int)SDEI_VERSION_VENDOR(ver));
|
|
|
|
if (SDEI_VERSION_MAJOR(ver) != 1) {
|
|
pr_warn("Conflicting SDEI version detected.\n");
|
|
sdei_mark_interface_broken();
|
|
return -EINVAL;
|
|
}
|
|
|
|
err = sdei_platform_reset();
|
|
if (err)
|
|
return err;
|
|
|
|
sdei_entry_point = sdei_arch_get_entry_point(conduit);
|
|
if (!sdei_entry_point) {
|
|
/* Not supported due to hardware or boot configuration */
|
|
sdei_mark_interface_broken();
|
|
return 0;
|
|
}
|
|
|
|
err = cpu_pm_register_notifier(&sdei_pm_nb);
|
|
if (err) {
|
|
pr_warn("Failed to register CPU PM notifier...\n");
|
|
goto error;
|
|
}
|
|
|
|
err = register_reboot_notifier(&sdei_reboot_nb);
|
|
if (err) {
|
|
pr_warn("Failed to register reboot notifier...\n");
|
|
goto remove_cpupm;
|
|
}
|
|
|
|
err = cpuhp_setup_state(CPUHP_AP_ARM_SDEI_STARTING, "SDEI",
|
|
&sdei_cpuhp_up, &sdei_cpuhp_down);
|
|
if (err) {
|
|
pr_warn("Failed to register CPU hotplug notifier...\n");
|
|
goto remove_reboot;
|
|
}
|
|
|
|
return 0;
|
|
|
|
remove_reboot:
|
|
unregister_reboot_notifier(&sdei_reboot_nb);
|
|
|
|
remove_cpupm:
|
|
cpu_pm_unregister_notifier(&sdei_pm_nb);
|
|
|
|
error:
|
|
sdei_mark_interface_broken();
|
|
return err;
|
|
}
|
|
|
|
static const struct of_device_id sdei_of_match[] = {
|
|
{ .compatible = "arm,sdei-1.0" },
|
|
{}
|
|
};
|
|
|
|
static struct platform_driver sdei_driver = {
|
|
.driver = {
|
|
.name = "sdei",
|
|
.pm = &sdei_pm_ops,
|
|
.of_match_table = sdei_of_match,
|
|
},
|
|
.probe = sdei_probe,
|
|
};
|
|
|
|
static bool __init sdei_present_dt(void)
|
|
{
|
|
struct device_node *np, *fw_np;
|
|
|
|
fw_np = of_find_node_by_name(NULL, "firmware");
|
|
if (!fw_np)
|
|
return false;
|
|
|
|
np = of_find_matching_node(fw_np, sdei_of_match);
|
|
if (!np)
|
|
return false;
|
|
of_node_put(np);
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool __init sdei_present_acpi(void)
|
|
{
|
|
acpi_status status;
|
|
struct platform_device *pdev;
|
|
struct acpi_table_header *sdei_table_header;
|
|
|
|
if (acpi_disabled)
|
|
return false;
|
|
|
|
status = acpi_get_table(ACPI_SIG_SDEI, 0, &sdei_table_header);
|
|
if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
|
|
const char *msg = acpi_format_exception(status);
|
|
|
|
pr_info("Failed to get ACPI:SDEI table, %s\n", msg);
|
|
}
|
|
if (ACPI_FAILURE(status))
|
|
return false;
|
|
|
|
pdev = platform_device_register_simple(sdei_driver.driver.name, 0, NULL,
|
|
0);
|
|
if (IS_ERR(pdev))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
static int __init sdei_init(void)
|
|
{
|
|
if (sdei_present_dt() || sdei_present_acpi())
|
|
platform_driver_register(&sdei_driver);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* On an ACPI system SDEI needs to be ready before HEST:GHES tries to register
|
|
* its events. ACPI is initialised from a subsys_initcall(), GHES is initialised
|
|
* by device_initcall(). We want to be called in the middle.
|
|
*/
|
|
subsys_initcall_sync(sdei_init);
|
|
|
|
int sdei_event_handler(struct pt_regs *regs,
|
|
struct sdei_registered_event *arg)
|
|
{
|
|
int err;
|
|
mm_segment_t orig_addr_limit;
|
|
u32 event_num = arg->event_num;
|
|
|
|
orig_addr_limit = get_fs();
|
|
set_fs(USER_DS);
|
|
|
|
err = arg->callback(event_num, regs, arg->callback_arg);
|
|
if (err)
|
|
pr_err_ratelimited("event %u on CPU %u failed with error: %d\n",
|
|
event_num, smp_processor_id(), err);
|
|
|
|
set_fs(orig_addr_limit);
|
|
|
|
return err;
|
|
}
|
|
NOKPROBE_SYMBOL(sdei_event_handler);
|