1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) 2017 Arm Ltd.
3 #define pr_fmt(fmt) "sdei: " fmt
6 #include <linux/acpi.h>
7 #include <linux/arm_sdei.h>
8 #include <linux/arm-smccc.h>
9 #include <linux/atomic.h>
10 #include <linux/bitops.h>
11 #include <linux/compiler.h>
12 #include <linux/cpuhotplug.h>
13 #include <linux/cpu.h>
14 #include <linux/cpu_pm.h>
15 #include <linux/errno.h>
16 #include <linux/hardirq.h>
17 #include <linux/kernel.h>
18 #include <linux/kprobes.h>
19 #include <linux/kvm_host.h>
20 #include <linux/list.h>
21 #include <linux/mutex.h>
22 #include <linux/notifier.h>
24 #include <linux/of_platform.h>
25 #include <linux/percpu.h>
26 #include <linux/platform_device.h>
28 #include <linux/ptrace.h>
29 #include <linux/preempt.h>
30 #include <linux/reboot.h>
31 #include <linux/slab.h>
32 #include <linux/smp.h>
33 #include <linux/spinlock.h>
34 #include <linux/uaccess.h>
37 * The call to use to reach the firmware.
39 static asmlinkage void (*sdei_firmware_call)(unsigned long function_id,
40 unsigned long arg0, unsigned long arg1,
41 unsigned long arg2, unsigned long arg3,
42 unsigned long arg4, struct arm_smccc_res *res);
44 /* entry point from firmware to arch asm code */
45 static unsigned long sdei_entry_point;
48 /* These three are protected by the sdei_list_lock */
49 struct list_head list;
57 /* This pointer is handed to firmware as the event argument. */
60 struct sdei_registered_event *registered;
62 /* CPU private events */
63 struct sdei_registered_event __percpu *private_registered;
67 /* Take the mutex for any API call or modification. Take the mutex first. */
68 static DEFINE_MUTEX(sdei_events_lock);
70 /* and then hold this when modifying the list */
71 static DEFINE_SPINLOCK(sdei_list_lock);
72 static LIST_HEAD(sdei_list);
74 /* Private events are registered/enabled via IPI passing one of these */
75 struct sdei_crosscall_args {
76 struct sdei_event *event;
81 #define CROSSCALL_INIT(arg, event) (arg.event = event, \
82 arg.first_error = 0, \
83 atomic_set(&arg.errors, 0))
85 static inline int sdei_do_cross_call(void *fn, struct sdei_event * event)
87 struct sdei_crosscall_args arg;
89 CROSSCALL_INIT(arg, event);
90 on_each_cpu(fn, &arg, true);
92 return arg.first_error;
96 sdei_cross_call_return(struct sdei_crosscall_args *arg, int err)
98 if (err && (atomic_inc_return(&arg->errors) == 1))
99 arg->first_error = err;
102 static int sdei_to_linux_errno(unsigned long sdei_err)
105 case SDEI_NOT_SUPPORTED:
107 case SDEI_INVALID_PARAMETERS:
113 case SDEI_OUT_OF_RESOURCE:
117 /* Not an error value ... */
122 * If x0 is any of these values, then the call failed, use sdei_to_linux_errno()
125 static int sdei_is_err(struct arm_smccc_res *res)
128 case SDEI_NOT_SUPPORTED:
129 case SDEI_INVALID_PARAMETERS:
132 case SDEI_OUT_OF_RESOURCE:
139 static int invoke_sdei_fn(unsigned long function_id, unsigned long arg0,
140 unsigned long arg1, unsigned long arg2,
141 unsigned long arg3, unsigned long arg4,
145 struct arm_smccc_res res;
147 if (sdei_firmware_call) {
148 sdei_firmware_call(function_id, arg0, arg1, arg2, arg3, arg4,
150 if (sdei_is_err(&res))
151 err = sdei_to_linux_errno(res.a0);
154 * !sdei_firmware_call means we failed to probe or called
155 * sdei_mark_interface_broken(). -EIO is not an error returned
156 * by sdei_to_linux_errno() and is used to suppress messages
160 res.a0 = SDEI_NOT_SUPPORTED;
168 NOKPROBE_SYMBOL(invoke_sdei_fn);
170 static struct sdei_event *sdei_event_find(u32 event_num)
172 struct sdei_event *e, *found = NULL;
174 lockdep_assert_held(&sdei_events_lock);
176 spin_lock(&sdei_list_lock);
177 list_for_each_entry(e, &sdei_list, list) {
178 if (e->event_num == event_num) {
183 spin_unlock(&sdei_list_lock);
188 int sdei_api_event_context(u32 query, u64 *result)
190 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_CONTEXT, query, 0, 0, 0, 0,
193 NOKPROBE_SYMBOL(sdei_api_event_context);
195 static int sdei_api_event_get_info(u32 event, u32 info, u64 *result)
197 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_GET_INFO, event, info, 0,
201 static struct sdei_event *sdei_event_create(u32 event_num,
202 sdei_event_callback *cb,
207 struct sdei_event *event;
208 struct sdei_registered_event *reg;
210 lockdep_assert_held(&sdei_events_lock);
212 event = kzalloc(sizeof(*event), GFP_KERNEL);
214 return ERR_PTR(-ENOMEM);
216 INIT_LIST_HEAD(&event->list);
217 event->event_num = event_num;
219 err = sdei_api_event_get_info(event_num, SDEI_EVENT_INFO_EV_PRIORITY,
225 event->priority = result;
227 err = sdei_api_event_get_info(event_num, SDEI_EVENT_INFO_EV_TYPE,
233 event->type = result;
235 if (event->type == SDEI_EVENT_TYPE_SHARED) {
236 reg = kzalloc(sizeof(*reg), GFP_KERNEL);
239 return ERR_PTR(-ENOMEM);
242 reg->event_num = event_num;
243 reg->priority = event->priority;
246 reg->callback_arg = cb_arg;
247 event->registered = reg;
250 struct sdei_registered_event __percpu *regs;
252 regs = alloc_percpu(struct sdei_registered_event);
255 return ERR_PTR(-ENOMEM);
258 for_each_possible_cpu(cpu) {
259 reg = per_cpu_ptr(regs, cpu);
261 reg->event_num = event->event_num;
262 reg->priority = event->priority;
264 reg->callback_arg = cb_arg;
267 event->private_registered = regs;
270 spin_lock(&sdei_list_lock);
271 list_add(&event->list, &sdei_list);
272 spin_unlock(&sdei_list_lock);
277 static void sdei_event_destroy_llocked(struct sdei_event *event)
279 lockdep_assert_held(&sdei_events_lock);
280 lockdep_assert_held(&sdei_list_lock);
282 list_del(&event->list);
284 if (event->type == SDEI_EVENT_TYPE_SHARED)
285 kfree(event->registered);
287 free_percpu(event->private_registered);
292 static void sdei_event_destroy(struct sdei_event *event)
294 spin_lock(&sdei_list_lock);
295 sdei_event_destroy_llocked(event);
296 spin_unlock(&sdei_list_lock);
299 static int sdei_api_get_version(u64 *version)
301 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_VERSION, 0, 0, 0, 0, 0, version);
304 int sdei_mask_local_cpu(void)
308 WARN_ON_ONCE(preemptible());
310 err = invoke_sdei_fn(SDEI_1_0_FN_SDEI_PE_MASK, 0, 0, 0, 0, 0, NULL);
311 if (err && err != -EIO) {
312 pr_warn_once("failed to mask CPU[%u]: %d\n",
313 smp_processor_id(), err);
320 static void _ipi_mask_cpu(void *ignored)
322 sdei_mask_local_cpu();
325 int sdei_unmask_local_cpu(void)
329 WARN_ON_ONCE(preemptible());
331 err = invoke_sdei_fn(SDEI_1_0_FN_SDEI_PE_UNMASK, 0, 0, 0, 0, 0, NULL);
332 if (err && err != -EIO) {
333 pr_warn_once("failed to unmask CPU[%u]: %d\n",
334 smp_processor_id(), err);
341 static void _ipi_unmask_cpu(void *ignored)
343 sdei_unmask_local_cpu();
346 static void _ipi_private_reset(void *ignored)
350 err = invoke_sdei_fn(SDEI_1_0_FN_SDEI_PRIVATE_RESET, 0, 0, 0, 0, 0,
352 if (err && err != -EIO)
353 pr_warn_once("failed to reset CPU[%u]: %d\n",
354 smp_processor_id(), err);
357 static int sdei_api_shared_reset(void)
359 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_SHARED_RESET, 0, 0, 0, 0, 0,
363 static void sdei_mark_interface_broken(void)
365 pr_err("disabling SDEI firmware interface\n");
366 on_each_cpu(&_ipi_mask_cpu, NULL, true);
367 sdei_firmware_call = NULL;
370 static int sdei_platform_reset(void)
374 on_each_cpu(&_ipi_private_reset, NULL, true);
375 err = sdei_api_shared_reset();
377 pr_err("Failed to reset platform: %d\n", err);
378 sdei_mark_interface_broken();
384 static int sdei_api_event_enable(u32 event_num)
386 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_ENABLE, event_num, 0, 0, 0,
390 /* Called directly by the hotplug callbacks */
391 static void _local_event_enable(void *data)
394 struct sdei_crosscall_args *arg = data;
396 WARN_ON_ONCE(preemptible());
398 err = sdei_api_event_enable(arg->event->event_num);
400 sdei_cross_call_return(arg, err);
403 int sdei_event_enable(u32 event_num)
406 struct sdei_event *event;
408 mutex_lock(&sdei_events_lock);
409 event = sdei_event_find(event_num);
411 mutex_unlock(&sdei_events_lock);
417 if (event->type == SDEI_EVENT_TYPE_SHARED)
418 err = sdei_api_event_enable(event->event_num);
420 err = sdei_do_cross_call(_local_event_enable, event);
423 spin_lock(&sdei_list_lock);
424 event->reenable = true;
425 spin_unlock(&sdei_list_lock);
428 mutex_unlock(&sdei_events_lock);
432 EXPORT_SYMBOL(sdei_event_enable);
434 static int sdei_api_event_disable(u32 event_num)
436 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_DISABLE, event_num, 0, 0,
440 static void _ipi_event_disable(void *data)
443 struct sdei_crosscall_args *arg = data;
445 err = sdei_api_event_disable(arg->event->event_num);
447 sdei_cross_call_return(arg, err);
450 int sdei_event_disable(u32 event_num)
453 struct sdei_event *event;
455 mutex_lock(&sdei_events_lock);
456 event = sdei_event_find(event_num);
458 mutex_unlock(&sdei_events_lock);
462 spin_lock(&sdei_list_lock);
463 event->reenable = false;
464 spin_unlock(&sdei_list_lock);
466 if (event->type == SDEI_EVENT_TYPE_SHARED)
467 err = sdei_api_event_disable(event->event_num);
469 err = sdei_do_cross_call(_ipi_event_disable, event);
470 mutex_unlock(&sdei_events_lock);
474 EXPORT_SYMBOL(sdei_event_disable);
476 static int sdei_api_event_unregister(u32 event_num)
478 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_UNREGISTER, event_num, 0,
482 /* Called directly by the hotplug callbacks */
483 static void _local_event_unregister(void *data)
486 struct sdei_crosscall_args *arg = data;
488 WARN_ON_ONCE(preemptible());
490 err = sdei_api_event_unregister(arg->event->event_num);
492 sdei_cross_call_return(arg, err);
495 static int _sdei_event_unregister(struct sdei_event *event)
497 lockdep_assert_held(&sdei_events_lock);
499 if (event->type == SDEI_EVENT_TYPE_SHARED)
500 return sdei_api_event_unregister(event->event_num);
502 return sdei_do_cross_call(_local_event_unregister, event);
505 int sdei_event_unregister(u32 event_num)
508 struct sdei_event *event;
512 mutex_lock(&sdei_events_lock);
513 event = sdei_event_find(event_num);
516 pr_warn("Event %u not registered\n", event_num);
521 spin_lock(&sdei_list_lock);
522 event->reregister = false;
523 event->reenable = false;
524 spin_unlock(&sdei_list_lock);
526 err = _sdei_event_unregister(event);
530 sdei_event_destroy(event);
532 mutex_unlock(&sdei_events_lock);
536 EXPORT_SYMBOL(sdei_event_unregister);
539 * unregister events, but don't destroy them as they are re-registered by
540 * sdei_reregister_shared().
542 static int sdei_unregister_shared(void)
545 struct sdei_event *event;
547 mutex_lock(&sdei_events_lock);
548 spin_lock(&sdei_list_lock);
549 list_for_each_entry(event, &sdei_list, list) {
550 if (event->type != SDEI_EVENT_TYPE_SHARED)
553 err = _sdei_event_unregister(event);
557 spin_unlock(&sdei_list_lock);
558 mutex_unlock(&sdei_events_lock);
563 static int sdei_api_event_register(u32 event_num, unsigned long entry_point,
564 void *arg, u64 flags, u64 affinity)
566 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_REGISTER, event_num,
567 (unsigned long)entry_point, (unsigned long)arg,
568 flags, affinity, NULL);
571 /* Called directly by the hotplug callbacks */
572 static void _local_event_register(void *data)
575 struct sdei_registered_event *reg;
576 struct sdei_crosscall_args *arg = data;
578 WARN_ON(preemptible());
580 reg = per_cpu_ptr(arg->event->private_registered, smp_processor_id());
581 err = sdei_api_event_register(arg->event->event_num, sdei_entry_point,
584 sdei_cross_call_return(arg, err);
587 static int _sdei_event_register(struct sdei_event *event)
591 lockdep_assert_held(&sdei_events_lock);
593 if (event->type == SDEI_EVENT_TYPE_SHARED)
594 return sdei_api_event_register(event->event_num,
597 SDEI_EVENT_REGISTER_RM_ANY, 0);
599 err = sdei_do_cross_call(_local_event_register, event);
601 sdei_do_cross_call(_local_event_unregister, event);
606 int sdei_event_register(u32 event_num, sdei_event_callback *cb, void *arg)
609 struct sdei_event *event;
613 mutex_lock(&sdei_events_lock);
615 if (sdei_event_find(event_num)) {
616 pr_warn("Event %u already registered\n", event_num);
621 event = sdei_event_create(event_num, cb, arg);
623 err = PTR_ERR(event);
624 pr_warn("Failed to create event %u: %d\n", event_num,
630 err = _sdei_event_register(event);
632 sdei_event_destroy(event);
633 pr_warn("Failed to register event %u: %d\n", event_num,
636 spin_lock(&sdei_list_lock);
637 event->reregister = true;
638 spin_unlock(&sdei_list_lock);
642 mutex_unlock(&sdei_events_lock);
646 EXPORT_SYMBOL(sdei_event_register);
648 static int sdei_reregister_event_llocked(struct sdei_event *event)
652 lockdep_assert_held(&sdei_events_lock);
653 lockdep_assert_held(&sdei_list_lock);
655 err = _sdei_event_register(event);
657 pr_err("Failed to re-register event %u\n", event->event_num);
658 sdei_event_destroy_llocked(event);
662 if (event->reenable) {
663 if (event->type == SDEI_EVENT_TYPE_SHARED)
664 err = sdei_api_event_enable(event->event_num);
666 err = sdei_do_cross_call(_local_event_enable, event);
670 pr_err("Failed to re-enable event %u\n", event->event_num);
675 static int sdei_reregister_shared(void)
678 struct sdei_event *event;
680 mutex_lock(&sdei_events_lock);
681 spin_lock(&sdei_list_lock);
682 list_for_each_entry(event, &sdei_list, list) {
683 if (event->type != SDEI_EVENT_TYPE_SHARED)
686 if (event->reregister) {
687 err = sdei_reregister_event_llocked(event);
692 spin_unlock(&sdei_list_lock);
693 mutex_unlock(&sdei_events_lock);
698 static int sdei_cpuhp_down(unsigned int cpu)
700 struct sdei_event *event;
701 struct sdei_crosscall_args arg;
703 /* un-register private events */
704 spin_lock(&sdei_list_lock);
705 list_for_each_entry(event, &sdei_list, list) {
706 if (event->type == SDEI_EVENT_TYPE_SHARED)
709 CROSSCALL_INIT(arg, event);
710 /* call the cross-call function locally... */
711 _local_event_unregister(&arg);
713 pr_err("Failed to unregister event %u: %d\n",
714 event->event_num, arg.first_error);
716 spin_unlock(&sdei_list_lock);
718 return sdei_mask_local_cpu();
721 static int sdei_cpuhp_up(unsigned int cpu)
723 struct sdei_event *event;
724 struct sdei_crosscall_args arg;
726 /* re-register/enable private events */
727 spin_lock(&sdei_list_lock);
728 list_for_each_entry(event, &sdei_list, list) {
729 if (event->type == SDEI_EVENT_TYPE_SHARED)
732 if (event->reregister) {
733 CROSSCALL_INIT(arg, event);
734 /* call the cross-call function locally... */
735 _local_event_register(&arg);
737 pr_err("Failed to re-register event %u: %d\n",
738 event->event_num, arg.first_error);
741 if (event->reenable) {
742 CROSSCALL_INIT(arg, event);
743 _local_event_enable(&arg);
745 pr_err("Failed to re-enable event %u: %d\n",
746 event->event_num, arg.first_error);
749 spin_unlock(&sdei_list_lock);
751 return sdei_unmask_local_cpu();
754 /* When entering idle, mask/unmask events for this cpu */
755 static int sdei_pm_notifier(struct notifier_block *nb, unsigned long action,
762 rv = sdei_mask_local_cpu();
765 case CPU_PM_ENTER_FAILED:
766 rv = sdei_unmask_local_cpu();
773 return notifier_from_errno(rv);
778 static struct notifier_block sdei_pm_nb = {
779 .notifier_call = sdei_pm_notifier,
782 static int sdei_device_suspend(struct device *dev)
784 on_each_cpu(_ipi_mask_cpu, NULL, true);
789 static int sdei_device_resume(struct device *dev)
791 on_each_cpu(_ipi_unmask_cpu, NULL, true);
797 * We need all events to be reregistered when we resume from hibernate.
799 * The sequence is freeze->thaw. Reboot. freeze->restore. We unregister
800 * events during freeze, then re-register and re-enable them during thaw
803 static int sdei_device_freeze(struct device *dev)
807 /* unregister private events */
808 cpuhp_remove_state(CPUHP_AP_ARM_SDEI_STARTING);
810 err = sdei_unregister_shared();
817 static int sdei_device_thaw(struct device *dev)
821 /* re-register shared events */
822 err = sdei_reregister_shared();
824 pr_warn("Failed to re-register shared events...\n");
825 sdei_mark_interface_broken();
829 err = cpuhp_setup_state(CPUHP_AP_ARM_SDEI_STARTING, "SDEI",
830 &sdei_cpuhp_up, &sdei_cpuhp_down);
832 pr_warn("Failed to re-register CPU hotplug notifier...\n");
837 static int sdei_device_restore(struct device *dev)
841 err = sdei_platform_reset();
845 return sdei_device_thaw(dev);
848 static const struct dev_pm_ops sdei_pm_ops = {
849 .suspend = sdei_device_suspend,
850 .resume = sdei_device_resume,
851 .freeze = sdei_device_freeze,
852 .thaw = sdei_device_thaw,
853 .restore = sdei_device_restore,
857 * Mask all CPUs and unregister all events on panic, reboot or kexec.
859 static int sdei_reboot_notifier(struct notifier_block *nb, unsigned long action,
863 * We are going to reset the interface, after this there is no point
864 * doing work when we take CPUs offline.
866 cpuhp_remove_state(CPUHP_AP_ARM_SDEI_STARTING);
868 sdei_platform_reset();
873 static struct notifier_block sdei_reboot_nb = {
874 .notifier_call = sdei_reboot_notifier,
877 static void sdei_smccc_smc(unsigned long function_id,
878 unsigned long arg0, unsigned long arg1,
879 unsigned long arg2, unsigned long arg3,
880 unsigned long arg4, struct arm_smccc_res *res)
882 arm_smccc_smc(function_id, arg0, arg1, arg2, arg3, arg4, 0, 0, res);
884 NOKPROBE_SYMBOL(sdei_smccc_smc);
886 static void sdei_smccc_hvc(unsigned long function_id,
887 unsigned long arg0, unsigned long arg1,
888 unsigned long arg2, unsigned long arg3,
889 unsigned long arg4, struct arm_smccc_res *res)
891 arm_smccc_hvc(function_id, arg0, arg1, arg2, arg3, arg4, 0, 0, res);
893 NOKPROBE_SYMBOL(sdei_smccc_hvc);
895 int sdei_register_ghes(struct ghes *ghes, sdei_event_callback *normal_cb,
896 sdei_event_callback *critical_cb)
901 sdei_event_callback *cb;
903 if (!IS_ENABLED(CONFIG_ACPI_APEI_GHES))
906 event_num = ghes->generic->notify.vector;
907 if (event_num == 0) {
909 * Event 0 is reserved by the specification for
915 err = sdei_api_event_get_info(event_num, SDEI_EVENT_INFO_EV_PRIORITY,
920 if (result == SDEI_EVENT_PRIORITY_CRITICAL)
925 err = sdei_event_register(event_num, cb, ghes);
927 err = sdei_event_enable(event_num);
932 int sdei_unregister_ghes(struct ghes *ghes)
936 u32 event_num = ghes->generic->notify.vector;
940 if (!IS_ENABLED(CONFIG_ACPI_APEI_GHES))
944 * The event may be running on another CPU. Disable it
945 * to stop new events, then try to unregister a few times.
947 err = sdei_event_disable(event_num);
951 for (i = 0; i < 3; i++) {
952 err = sdei_event_unregister(event_num);
953 if (err != -EINPROGRESS)
962 static int sdei_get_conduit(struct platform_device *pdev)
965 struct device_node *np = pdev->dev.of_node;
967 sdei_firmware_call = NULL;
969 if (of_property_read_string(np, "method", &method)) {
970 pr_warn("missing \"method\" property\n");
971 return SMCCC_CONDUIT_NONE;
974 if (!strcmp("hvc", method)) {
975 sdei_firmware_call = &sdei_smccc_hvc;
976 return SMCCC_CONDUIT_HVC;
977 } else if (!strcmp("smc", method)) {
978 sdei_firmware_call = &sdei_smccc_smc;
979 return SMCCC_CONDUIT_SMC;
982 pr_warn("invalid \"method\" property: %s\n", method);
983 } else if (IS_ENABLED(CONFIG_ACPI) && !acpi_disabled) {
984 if (acpi_psci_use_hvc()) {
985 sdei_firmware_call = &sdei_smccc_hvc;
986 return SMCCC_CONDUIT_HVC;
988 sdei_firmware_call = &sdei_smccc_smc;
989 return SMCCC_CONDUIT_SMC;
993 return SMCCC_CONDUIT_NONE;
996 static int sdei_probe(struct platform_device *pdev)
1002 conduit = sdei_get_conduit(pdev);
1003 if (!sdei_firmware_call)
1006 err = sdei_api_get_version(&ver);
1007 if (err == -EOPNOTSUPP)
1008 pr_err("advertised but not implemented in platform firmware\n");
1010 pr_err("Failed to get SDEI version: %d\n", err);
1011 sdei_mark_interface_broken();
1015 pr_info("SDEIv%d.%d (0x%x) detected in firmware.\n",
1016 (int)SDEI_VERSION_MAJOR(ver), (int)SDEI_VERSION_MINOR(ver),
1017 (int)SDEI_VERSION_VENDOR(ver));
1019 if (SDEI_VERSION_MAJOR(ver) != 1) {
1020 pr_warn("Conflicting SDEI version detected.\n");
1021 sdei_mark_interface_broken();
1025 err = sdei_platform_reset();
1029 sdei_entry_point = sdei_arch_get_entry_point(conduit);
1030 if (!sdei_entry_point) {
1031 /* Not supported due to hardware or boot configuration */
1032 sdei_mark_interface_broken();
1036 err = cpu_pm_register_notifier(&sdei_pm_nb);
1038 pr_warn("Failed to register CPU PM notifier...\n");
1042 err = register_reboot_notifier(&sdei_reboot_nb);
1044 pr_warn("Failed to register reboot notifier...\n");
1048 err = cpuhp_setup_state(CPUHP_AP_ARM_SDEI_STARTING, "SDEI",
1049 &sdei_cpuhp_up, &sdei_cpuhp_down);
1051 pr_warn("Failed to register CPU hotplug notifier...\n");
1058 unregister_reboot_notifier(&sdei_reboot_nb);
1061 cpu_pm_unregister_notifier(&sdei_pm_nb);
1064 sdei_mark_interface_broken();
1068 static const struct of_device_id sdei_of_match[] = {
1069 { .compatible = "arm,sdei-1.0" },
1073 static struct platform_driver sdei_driver = {
1077 .of_match_table = sdei_of_match,
1079 .probe = sdei_probe,
1082 static bool __init sdei_present_dt(void)
1084 struct device_node *np, *fw_np;
1086 fw_np = of_find_node_by_name(NULL, "firmware");
1090 np = of_find_matching_node(fw_np, sdei_of_match);
1098 static bool __init sdei_present_acpi(void)
1101 struct platform_device *pdev;
1102 struct acpi_table_header *sdei_table_header;
1107 status = acpi_get_table(ACPI_SIG_SDEI, 0, &sdei_table_header);
1108 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
1109 const char *msg = acpi_format_exception(status);
1111 pr_info("Failed to get ACPI:SDEI table, %s\n", msg);
1113 if (ACPI_FAILURE(status))
1116 pdev = platform_device_register_simple(sdei_driver.driver.name, 0, NULL,
1124 static int __init sdei_init(void)
1126 if (sdei_present_dt() || sdei_present_acpi())
1127 platform_driver_register(&sdei_driver);
1133 * On an ACPI system SDEI needs to be ready before HEST:GHES tries to register
1134 * its events. ACPI is initialised from a subsys_initcall(), GHES is initialised
1135 * by device_initcall(). We want to be called in the middle.
1137 subsys_initcall_sync(sdei_init);
1139 int sdei_event_handler(struct pt_regs *regs,
1140 struct sdei_registered_event *arg)
1143 mm_segment_t orig_addr_limit;
1144 u32 event_num = arg->event_num;
1146 orig_addr_limit = get_fs();
1149 err = arg->callback(event_num, regs, arg->callback_arg);
1151 pr_err_ratelimited("event %u on CPU %u failed with error: %d\n",
1152 event_num, smp_processor_id(), err);
1154 set_fs(orig_addr_limit);
1158 NOKPROBE_SYMBOL(sdei_event_handler);