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
);
433 static int sdei_api_event_disable(u32 event_num
)
435 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_DISABLE
, event_num
, 0, 0,
439 static void _ipi_event_disable(void *data
)
442 struct sdei_crosscall_args
*arg
= data
;
444 err
= sdei_api_event_disable(arg
->event
->event_num
);
446 sdei_cross_call_return(arg
, err
);
449 int sdei_event_disable(u32 event_num
)
452 struct sdei_event
*event
;
454 mutex_lock(&sdei_events_lock
);
455 event
= sdei_event_find(event_num
);
457 mutex_unlock(&sdei_events_lock
);
461 spin_lock(&sdei_list_lock
);
462 event
->reenable
= false;
463 spin_unlock(&sdei_list_lock
);
465 if (event
->type
== SDEI_EVENT_TYPE_SHARED
)
466 err
= sdei_api_event_disable(event
->event_num
);
468 err
= sdei_do_cross_call(_ipi_event_disable
, event
);
469 mutex_unlock(&sdei_events_lock
);
474 static int sdei_api_event_unregister(u32 event_num
)
476 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_UNREGISTER
, event_num
, 0,
480 /* Called directly by the hotplug callbacks */
481 static void _local_event_unregister(void *data
)
484 struct sdei_crosscall_args
*arg
= data
;
486 WARN_ON_ONCE(preemptible());
488 err
= sdei_api_event_unregister(arg
->event
->event_num
);
490 sdei_cross_call_return(arg
, err
);
493 static int _sdei_event_unregister(struct sdei_event
*event
)
495 lockdep_assert_held(&sdei_events_lock
);
497 if (event
->type
== SDEI_EVENT_TYPE_SHARED
)
498 return sdei_api_event_unregister(event
->event_num
);
500 return sdei_do_cross_call(_local_event_unregister
, event
);
503 int sdei_event_unregister(u32 event_num
)
506 struct sdei_event
*event
;
510 mutex_lock(&sdei_events_lock
);
511 event
= sdei_event_find(event_num
);
514 pr_warn("Event %u not registered\n", event_num
);
519 spin_lock(&sdei_list_lock
);
520 event
->reregister
= false;
521 event
->reenable
= false;
522 spin_unlock(&sdei_list_lock
);
524 err
= _sdei_event_unregister(event
);
528 sdei_event_destroy(event
);
530 mutex_unlock(&sdei_events_lock
);
536 * unregister events, but don't destroy them as they are re-registered by
537 * sdei_reregister_shared().
539 static int sdei_unregister_shared(void)
542 struct sdei_event
*event
;
544 mutex_lock(&sdei_events_lock
);
545 spin_lock(&sdei_list_lock
);
546 list_for_each_entry(event
, &sdei_list
, list
) {
547 if (event
->type
!= SDEI_EVENT_TYPE_SHARED
)
550 err
= _sdei_event_unregister(event
);
554 spin_unlock(&sdei_list_lock
);
555 mutex_unlock(&sdei_events_lock
);
560 static int sdei_api_event_register(u32 event_num
, unsigned long entry_point
,
561 void *arg
, u64 flags
, u64 affinity
)
563 return invoke_sdei_fn(SDEI_1_0_FN_SDEI_EVENT_REGISTER
, event_num
,
564 (unsigned long)entry_point
, (unsigned long)arg
,
565 flags
, affinity
, NULL
);
568 /* Called directly by the hotplug callbacks */
569 static void _local_event_register(void *data
)
572 struct sdei_registered_event
*reg
;
573 struct sdei_crosscall_args
*arg
= data
;
575 WARN_ON(preemptible());
577 reg
= per_cpu_ptr(arg
->event
->private_registered
, smp_processor_id());
578 err
= sdei_api_event_register(arg
->event
->event_num
, sdei_entry_point
,
581 sdei_cross_call_return(arg
, err
);
584 static int _sdei_event_register(struct sdei_event
*event
)
588 lockdep_assert_held(&sdei_events_lock
);
590 if (event
->type
== SDEI_EVENT_TYPE_SHARED
)
591 return sdei_api_event_register(event
->event_num
,
594 SDEI_EVENT_REGISTER_RM_ANY
, 0);
596 err
= sdei_do_cross_call(_local_event_register
, event
);
598 sdei_do_cross_call(_local_event_unregister
, event
);
603 int sdei_event_register(u32 event_num
, sdei_event_callback
*cb
, void *arg
)
606 struct sdei_event
*event
;
610 mutex_lock(&sdei_events_lock
);
612 if (sdei_event_find(event_num
)) {
613 pr_warn("Event %u already registered\n", event_num
);
618 event
= sdei_event_create(event_num
, cb
, arg
);
620 err
= PTR_ERR(event
);
621 pr_warn("Failed to create event %u: %d\n", event_num
,
627 err
= _sdei_event_register(event
);
629 sdei_event_destroy(event
);
630 pr_warn("Failed to register event %u: %d\n", event_num
,
633 spin_lock(&sdei_list_lock
);
634 event
->reregister
= true;
635 spin_unlock(&sdei_list_lock
);
639 mutex_unlock(&sdei_events_lock
);
644 static int sdei_reregister_event_llocked(struct sdei_event
*event
)
648 lockdep_assert_held(&sdei_events_lock
);
649 lockdep_assert_held(&sdei_list_lock
);
651 err
= _sdei_event_register(event
);
653 pr_err("Failed to re-register event %u\n", event
->event_num
);
654 sdei_event_destroy_llocked(event
);
658 if (event
->reenable
) {
659 if (event
->type
== SDEI_EVENT_TYPE_SHARED
)
660 err
= sdei_api_event_enable(event
->event_num
);
662 err
= sdei_do_cross_call(_local_event_enable
, event
);
666 pr_err("Failed to re-enable event %u\n", event
->event_num
);
671 static int sdei_reregister_shared(void)
674 struct sdei_event
*event
;
676 mutex_lock(&sdei_events_lock
);
677 spin_lock(&sdei_list_lock
);
678 list_for_each_entry(event
, &sdei_list
, list
) {
679 if (event
->type
!= SDEI_EVENT_TYPE_SHARED
)
682 if (event
->reregister
) {
683 err
= sdei_reregister_event_llocked(event
);
688 spin_unlock(&sdei_list_lock
);
689 mutex_unlock(&sdei_events_lock
);
694 static int sdei_cpuhp_down(unsigned int cpu
)
696 struct sdei_event
*event
;
697 struct sdei_crosscall_args arg
;
699 /* un-register private events */
700 spin_lock(&sdei_list_lock
);
701 list_for_each_entry(event
, &sdei_list
, list
) {
702 if (event
->type
== SDEI_EVENT_TYPE_SHARED
)
705 CROSSCALL_INIT(arg
, event
);
706 /* call the cross-call function locally... */
707 _local_event_unregister(&arg
);
709 pr_err("Failed to unregister event %u: %d\n",
710 event
->event_num
, arg
.first_error
);
712 spin_unlock(&sdei_list_lock
);
714 return sdei_mask_local_cpu();
717 static int sdei_cpuhp_up(unsigned int cpu
)
719 struct sdei_event
*event
;
720 struct sdei_crosscall_args arg
;
722 /* re-register/enable private events */
723 spin_lock(&sdei_list_lock
);
724 list_for_each_entry(event
, &sdei_list
, list
) {
725 if (event
->type
== SDEI_EVENT_TYPE_SHARED
)
728 if (event
->reregister
) {
729 CROSSCALL_INIT(arg
, event
);
730 /* call the cross-call function locally... */
731 _local_event_register(&arg
);
733 pr_err("Failed to re-register event %u: %d\n",
734 event
->event_num
, arg
.first_error
);
737 if (event
->reenable
) {
738 CROSSCALL_INIT(arg
, event
);
739 _local_event_enable(&arg
);
741 pr_err("Failed to re-enable event %u: %d\n",
742 event
->event_num
, arg
.first_error
);
745 spin_unlock(&sdei_list_lock
);
747 return sdei_unmask_local_cpu();
750 /* When entering idle, mask/unmask events for this cpu */
751 static int sdei_pm_notifier(struct notifier_block
*nb
, unsigned long action
,
758 rv
= sdei_mask_local_cpu();
761 case CPU_PM_ENTER_FAILED
:
762 rv
= sdei_unmask_local_cpu();
769 return notifier_from_errno(rv
);
774 static struct notifier_block sdei_pm_nb
= {
775 .notifier_call
= sdei_pm_notifier
,
778 static int sdei_device_suspend(struct device
*dev
)
780 on_each_cpu(_ipi_mask_cpu
, NULL
, true);
785 static int sdei_device_resume(struct device
*dev
)
787 on_each_cpu(_ipi_unmask_cpu
, NULL
, true);
793 * We need all events to be reregistered when we resume from hibernate.
795 * The sequence is freeze->thaw. Reboot. freeze->restore. We unregister
796 * events during freeze, then re-register and re-enable them during thaw
799 static int sdei_device_freeze(struct device
*dev
)
803 /* unregister private events */
804 cpuhp_remove_state(CPUHP_AP_ARM_SDEI_STARTING
);
806 err
= sdei_unregister_shared();
813 static int sdei_device_thaw(struct device
*dev
)
817 /* re-register shared events */
818 err
= sdei_reregister_shared();
820 pr_warn("Failed to re-register shared events...\n");
821 sdei_mark_interface_broken();
825 err
= cpuhp_setup_state(CPUHP_AP_ARM_SDEI_STARTING
, "SDEI",
826 &sdei_cpuhp_up
, &sdei_cpuhp_down
);
828 pr_warn("Failed to re-register CPU hotplug notifier...\n");
833 static int sdei_device_restore(struct device
*dev
)
837 err
= sdei_platform_reset();
841 return sdei_device_thaw(dev
);
844 static const struct dev_pm_ops sdei_pm_ops
= {
845 .suspend
= sdei_device_suspend
,
846 .resume
= sdei_device_resume
,
847 .freeze
= sdei_device_freeze
,
848 .thaw
= sdei_device_thaw
,
849 .restore
= sdei_device_restore
,
853 * Mask all CPUs and unregister all events on panic, reboot or kexec.
855 static int sdei_reboot_notifier(struct notifier_block
*nb
, unsigned long action
,
859 * We are going to reset the interface, after this there is no point
860 * doing work when we take CPUs offline.
862 cpuhp_remove_state(CPUHP_AP_ARM_SDEI_STARTING
);
864 sdei_platform_reset();
869 static struct notifier_block sdei_reboot_nb
= {
870 .notifier_call
= sdei_reboot_notifier
,
873 static void sdei_smccc_smc(unsigned long function_id
,
874 unsigned long arg0
, unsigned long arg1
,
875 unsigned long arg2
, unsigned long arg3
,
876 unsigned long arg4
, struct arm_smccc_res
*res
)
878 arm_smccc_smc(function_id
, arg0
, arg1
, arg2
, arg3
, arg4
, 0, 0, res
);
880 NOKPROBE_SYMBOL(sdei_smccc_smc
);
882 static void sdei_smccc_hvc(unsigned long function_id
,
883 unsigned long arg0
, unsigned long arg1
,
884 unsigned long arg2
, unsigned long arg3
,
885 unsigned long arg4
, struct arm_smccc_res
*res
)
887 arm_smccc_hvc(function_id
, arg0
, arg1
, arg2
, arg3
, arg4
, 0, 0, res
);
889 NOKPROBE_SYMBOL(sdei_smccc_hvc
);
891 int sdei_register_ghes(struct ghes
*ghes
, sdei_event_callback
*normal_cb
,
892 sdei_event_callback
*critical_cb
)
897 sdei_event_callback
*cb
;
899 if (!IS_ENABLED(CONFIG_ACPI_APEI_GHES
))
902 event_num
= ghes
->generic
->notify
.vector
;
903 if (event_num
== 0) {
905 * Event 0 is reserved by the specification for
911 err
= sdei_api_event_get_info(event_num
, SDEI_EVENT_INFO_EV_PRIORITY
,
916 if (result
== SDEI_EVENT_PRIORITY_CRITICAL
)
921 err
= sdei_event_register(event_num
, cb
, ghes
);
923 err
= sdei_event_enable(event_num
);
928 int sdei_unregister_ghes(struct ghes
*ghes
)
932 u32 event_num
= ghes
->generic
->notify
.vector
;
936 if (!IS_ENABLED(CONFIG_ACPI_APEI_GHES
))
940 * The event may be running on another CPU. Disable it
941 * to stop new events, then try to unregister a few times.
943 err
= sdei_event_disable(event_num
);
947 for (i
= 0; i
< 3; i
++) {
948 err
= sdei_event_unregister(event_num
);
949 if (err
!= -EINPROGRESS
)
958 static int sdei_get_conduit(struct platform_device
*pdev
)
961 struct device_node
*np
= pdev
->dev
.of_node
;
963 sdei_firmware_call
= NULL
;
965 if (of_property_read_string(np
, "method", &method
)) {
966 pr_warn("missing \"method\" property\n");
967 return SMCCC_CONDUIT_NONE
;
970 if (!strcmp("hvc", method
)) {
971 sdei_firmware_call
= &sdei_smccc_hvc
;
972 return SMCCC_CONDUIT_HVC
;
973 } else if (!strcmp("smc", method
)) {
974 sdei_firmware_call
= &sdei_smccc_smc
;
975 return SMCCC_CONDUIT_SMC
;
978 pr_warn("invalid \"method\" property: %s\n", method
);
979 } else if (IS_ENABLED(CONFIG_ACPI
) && !acpi_disabled
) {
980 if (acpi_psci_use_hvc()) {
981 sdei_firmware_call
= &sdei_smccc_hvc
;
982 return SMCCC_CONDUIT_HVC
;
984 sdei_firmware_call
= &sdei_smccc_smc
;
985 return SMCCC_CONDUIT_SMC
;
989 return SMCCC_CONDUIT_NONE
;
992 static int sdei_probe(struct platform_device
*pdev
)
998 conduit
= sdei_get_conduit(pdev
);
999 if (!sdei_firmware_call
)
1002 err
= sdei_api_get_version(&ver
);
1003 if (err
== -EOPNOTSUPP
)
1004 pr_err("advertised but not implemented in platform firmware\n");
1006 pr_err("Failed to get SDEI version: %d\n", err
);
1007 sdei_mark_interface_broken();
1011 pr_info("SDEIv%d.%d (0x%x) detected in firmware.\n",
1012 (int)SDEI_VERSION_MAJOR(ver
), (int)SDEI_VERSION_MINOR(ver
),
1013 (int)SDEI_VERSION_VENDOR(ver
));
1015 if (SDEI_VERSION_MAJOR(ver
) != 1) {
1016 pr_warn("Conflicting SDEI version detected.\n");
1017 sdei_mark_interface_broken();
1021 err
= sdei_platform_reset();
1025 sdei_entry_point
= sdei_arch_get_entry_point(conduit
);
1026 if (!sdei_entry_point
) {
1027 /* Not supported due to hardware or boot configuration */
1028 sdei_mark_interface_broken();
1032 err
= cpu_pm_register_notifier(&sdei_pm_nb
);
1034 pr_warn("Failed to register CPU PM notifier...\n");
1038 err
= register_reboot_notifier(&sdei_reboot_nb
);
1040 pr_warn("Failed to register reboot notifier...\n");
1044 err
= cpuhp_setup_state(CPUHP_AP_ARM_SDEI_STARTING
, "SDEI",
1045 &sdei_cpuhp_up
, &sdei_cpuhp_down
);
1047 pr_warn("Failed to register CPU hotplug notifier...\n");
1054 unregister_reboot_notifier(&sdei_reboot_nb
);
1057 cpu_pm_unregister_notifier(&sdei_pm_nb
);
1060 sdei_mark_interface_broken();
1064 static const struct of_device_id sdei_of_match
[] = {
1065 { .compatible
= "arm,sdei-1.0" },
1069 static struct platform_driver sdei_driver
= {
1073 .of_match_table
= sdei_of_match
,
1075 .probe
= sdei_probe
,
1078 static bool __init
sdei_present_acpi(void)
1081 struct acpi_table_header
*sdei_table_header
;
1086 status
= acpi_get_table(ACPI_SIG_SDEI
, 0, &sdei_table_header
);
1087 if (ACPI_FAILURE(status
) && status
!= AE_NOT_FOUND
) {
1088 const char *msg
= acpi_format_exception(status
);
1090 pr_info("Failed to get ACPI:SDEI table, %s\n", msg
);
1092 if (ACPI_FAILURE(status
))
1095 acpi_put_table(sdei_table_header
);
1100 static int __init
sdei_init(void)
1102 int ret
= platform_driver_register(&sdei_driver
);
1104 if (!ret
&& sdei_present_acpi()) {
1105 struct platform_device
*pdev
;
1107 pdev
= platform_device_register_simple(sdei_driver
.driver
.name
,
1110 pr_info("Failed to register ACPI:SDEI platform device %ld\n",
1118 * On an ACPI system SDEI needs to be ready before HEST:GHES tries to register
1119 * its events. ACPI is initialised from a subsys_initcall(), GHES is initialised
1120 * by device_initcall(). We want to be called in the middle.
1122 subsys_initcall_sync(sdei_init
);
1124 int sdei_event_handler(struct pt_regs
*regs
,
1125 struct sdei_registered_event
*arg
)
1128 mm_segment_t orig_addr_limit
;
1129 u32 event_num
= arg
->event_num
;
1132 * Save restore 'fs'.
1133 * The architecture's entry code save/restores 'fs' when taking an
1134 * exception from the kernel. This ensures addr_limit isn't inherited
1135 * if you interrupted something that allowed the uaccess routines to
1136 * access kernel memory.
1137 * Do the same here because this doesn't come via the same entry code.
1139 orig_addr_limit
= force_uaccess_begin();
1141 err
= arg
->callback(event_num
, regs
, arg
->callback_arg
);
1143 pr_err_ratelimited("event %u on CPU %u failed with error: %d\n",
1144 event_num
, smp_processor_id(), err
);
1146 force_uaccess_end(orig_addr_limit
);
1150 NOKPROBE_SYMBOL(sdei_event_handler
);