1// SPDX-License-Identifier: GPL-2.0
 2#include <linux/types.h>
 3#include <linux/tick.h>
 4#include <linux/percpu-defs.h>
 5
 6#include <xen/xen.h>
 7#include <xen/interface/xen.h>
 8#include <xen/grant_table.h>
 9#include <xen/events.h>
10
11#include <asm/cpufeatures.h>
12#include <asm/msr-index.h>
13#include <asm/xen/hypercall.h>
14#include <asm/xen/page.h>
15#include <asm/fixmap.h>
16
17#include "xen-ops.h"
18#include "mmu.h"
19#include "pmu.h"
20
21static DEFINE_PER_CPU(u64, spec_ctrl);
22
23void xen_arch_pre_suspend(void)
24{
25	xen_save_time_memory_area();
26
27	if (xen_pv_domain())
28		xen_pv_pre_suspend();
29}
30
31void xen_arch_post_suspend(int cancelled)
32{
33	if (xen_pv_domain())
34		xen_pv_post_suspend(cancelled);
35	else
36		xen_hvm_post_suspend(cancelled);
37
38	xen_restore_time_memory_area();
39}
40
41static void xen_vcpu_notify_restore(void *data)
42{
43	if (xen_pv_domain() && boot_cpu_has(X86_FEATURE_SPEC_CTRL))
44		wrmsrl(MSR_IA32_SPEC_CTRL, this_cpu_read(spec_ctrl));
45
46	/* Boot processor notified via generic timekeeping_resume() */
47	if (smp_processor_id() == 0)
48		return;
49
50	tick_resume_local();
 
 
 
51}
52
53static void xen_vcpu_notify_suspend(void *data)
54{
55	u64 tmp;
56
57	tick_suspend_local();
58
59	if (xen_pv_domain() && boot_cpu_has(X86_FEATURE_SPEC_CTRL)) {
60		rdmsrl(MSR_IA32_SPEC_CTRL, tmp);
61		this_cpu_write(spec_ctrl, tmp);
62		wrmsrl(MSR_IA32_SPEC_CTRL, 0);
 
 
 
 
 
 
 
63	}
 
64}
65
66void xen_arch_resume(void)
67{
68	int cpu;
69
70	on_each_cpu(xen_vcpu_notify_restore, NULL, 1);
 
 
71
72	for_each_online_cpu(cpu)
73		xen_pmu_init(cpu);
74}
75
76void xen_arch_suspend(void)
77{
78	int cpu;
79
80	for_each_online_cpu(cpu)
81		xen_pmu_finish(cpu);
82
83	on_each_cpu(xen_vcpu_notify_suspend, NULL, 1);
84}

 
 1#include <linux/types.h>
 2#include <linux/clockchips.h>
 
 3
 
 4#include <xen/interface/xen.h>
 5#include <xen/grant_table.h>
 6#include <xen/events.h>
 7
 
 
 8#include <asm/xen/hypercall.h>
 9#include <asm/xen/page.h>
10#include <asm/fixmap.h>
11
12#include "xen-ops.h"
13#include "mmu.h"
 
 
 
14
15void xen_arch_pre_suspend(void)
16{
17	xen_start_info->store_mfn = mfn_to_pfn(xen_start_info->store_mfn);
18	xen_start_info->console.domU.mfn =
19		mfn_to_pfn(xen_start_info->console.domU.mfn);
20
21	BUG_ON(!irqs_disabled());
22
23	HYPERVISOR_shared_info = &xen_dummy_shared_info;
24	if (HYPERVISOR_update_va_mapping(fix_to_virt(FIX_PARAVIRT_BOOTMAP),
25					 __pte_ma(0), 0))
26		BUG();
 
 
 
 
27}
28
29void xen_arch_hvm_post_suspend(int suspend_cancelled)
30{
31#ifdef CONFIG_XEN_PVHVM
32	int cpu;
33	xen_hvm_init_shared_info();
34	xen_callback_vector();
35	xen_unplug_emulated_devices();
36	if (xen_feature(XENFEAT_hvm_safe_pvclock)) {
37		for_each_online_cpu(cpu) {
38			xen_setup_runstate_info(cpu);
39		}
40	}
41#endif
42}
43
44void xen_arch_post_suspend(int suspend_cancelled)
45{
46	xen_build_mfn_list_list();
47
48	xen_setup_shared_info();
49
50	if (suspend_cancelled) {
51		xen_start_info->store_mfn =
52			pfn_to_mfn(xen_start_info->store_mfn);
53		xen_start_info->console.domU.mfn =
54			pfn_to_mfn(xen_start_info->console.domU.mfn);
55	} else {
56#ifdef CONFIG_SMP
57		BUG_ON(xen_cpu_initialized_map == NULL);
58		cpumask_copy(xen_cpu_initialized_map, cpu_online_mask);
59#endif
60		xen_vcpu_restore();
61	}
62
63}
64
65static void xen_vcpu_notify_restore(void *data)
66{
67	unsigned long reason = (unsigned long)data;
68
69	/* Boot processor notified via generic timekeeping_resume() */
70	if ( smp_processor_id() == 0)
71		return;
72
73	clockevents_notify(reason, NULL);
 
74}
75
76void xen_arch_resume(void)
77{
78	on_each_cpu(xen_vcpu_notify_restore,
79		    (void *)CLOCK_EVT_NOTIFY_RESUME, 1);
 
 
 
 
80}