1 #include <xen/xen.h>
2 #include <xen/events.h>
3 #include <xen/grant_table.h>
4 #include <xen/hvm.h>
5 #include <xen/interface/vcpu.h>
6 #include <xen/interface/xen.h>
7 #include <xen/interface/memory.h>
8 #include <xen/interface/hvm/params.h>
9 #include <xen/features.h>
10 #include <xen/platform_pci.h>
11 #include <xen/xenbus.h>
12 #include <xen/page.h>
13 #include <xen/interface/sched.h>
14 #include <xen/xen-ops.h>
15 #include <asm/xen/hypervisor.h>
16 #include <asm/xen/hypercall.h>
17 #include <asm/system_misc.h>
18 #include <linux/interrupt.h>
19 #include <linux/irqreturn.h>
20 #include <linux/module.h>
21 #include <linux/of.h>
22 #include <linux/of_irq.h>
23 #include <linux/of_address.h>
24 #include <linux/cpuidle.h>
25 #include <linux/cpufreq.h>
26 #include <linux/cpu.h>
27 #include <linux/console.h>
28
29 #include <linux/mm.h>
30
31 struct start_info _xen_start_info;
32 struct start_info *xen_start_info = &_xen_start_info;
33 EXPORT_SYMBOL(xen_start_info);
34
35 enum xen_domain_type xen_domain_type = XEN_NATIVE;
36 EXPORT_SYMBOL(xen_domain_type);
37
38 struct shared_info xen_dummy_shared_info;
39 struct shared_info *HYPERVISOR_shared_info = (void *)&xen_dummy_shared_info;
40
41 DEFINE_PER_CPU(struct vcpu_info *, xen_vcpu);
42 static struct vcpu_info __percpu *xen_vcpu_info;
43
44 /* These are unused until we support booting "pre-ballooned" */
45 unsigned long xen_released_pages;
46 struct xen_memory_region xen_extra_mem[XEN_EXTRA_MEM_MAX_REGIONS] __initdata;
47
48 static __read_mostly unsigned int xen_events_irq;
49
50 static __initdata struct device_node *xen_node;
51
xen_remap_domain_gfn_array(struct vm_area_struct * vma,unsigned long addr,xen_pfn_t * gfn,int nr,int * err_ptr,pgprot_t prot,unsigned domid,struct page ** pages)52 int xen_remap_domain_gfn_array(struct vm_area_struct *vma,
53 unsigned long addr,
54 xen_pfn_t *gfn, int nr,
55 int *err_ptr, pgprot_t prot,
56 unsigned domid,
57 struct page **pages)
58 {
59 return xen_xlate_remap_gfn_array(vma, addr, gfn, nr, err_ptr,
60 prot, domid, pages);
61 }
62 EXPORT_SYMBOL_GPL(xen_remap_domain_gfn_array);
63
64 /* Not used by XENFEAT_auto_translated guests. */
xen_remap_domain_gfn_range(struct vm_area_struct * vma,unsigned long addr,xen_pfn_t gfn,int nr,pgprot_t prot,unsigned domid,struct page ** pages)65 int xen_remap_domain_gfn_range(struct vm_area_struct *vma,
66 unsigned long addr,
67 xen_pfn_t gfn, int nr,
68 pgprot_t prot, unsigned domid,
69 struct page **pages)
70 {
71 return -ENOSYS;
72 }
73 EXPORT_SYMBOL_GPL(xen_remap_domain_gfn_range);
74
xen_unmap_domain_gfn_range(struct vm_area_struct * vma,int nr,struct page ** pages)75 int xen_unmap_domain_gfn_range(struct vm_area_struct *vma,
76 int nr, struct page **pages)
77 {
78 return xen_xlate_unmap_gfn_range(vma, nr, pages);
79 }
80 EXPORT_SYMBOL_GPL(xen_unmap_domain_gfn_range);
81
xen_percpu_init(void)82 static void xen_percpu_init(void)
83 {
84 struct vcpu_register_vcpu_info info;
85 struct vcpu_info *vcpup;
86 int err;
87 int cpu = get_cpu();
88
89 /*
90 * VCPUOP_register_vcpu_info cannot be called twice for the same
91 * vcpu, so if vcpu_info is already registered, just get out. This
92 * can happen with cpu-hotplug.
93 */
94 if (per_cpu(xen_vcpu, cpu) != NULL)
95 goto after_register_vcpu_info;
96
97 pr_info("Xen: initializing cpu%d\n", cpu);
98 vcpup = per_cpu_ptr(xen_vcpu_info, cpu);
99
100 info.mfn = virt_to_gfn(vcpup);
101 info.offset = xen_offset_in_page(vcpup);
102
103 err = HYPERVISOR_vcpu_op(VCPUOP_register_vcpu_info, cpu, &info);
104 BUG_ON(err);
105 per_cpu(xen_vcpu, cpu) = vcpup;
106
107 after_register_vcpu_info:
108 enable_percpu_irq(xen_events_irq, 0);
109 put_cpu();
110 }
111
xen_restart(enum reboot_mode reboot_mode,const char * cmd)112 static void xen_restart(enum reboot_mode reboot_mode, const char *cmd)
113 {
114 struct sched_shutdown r = { .reason = SHUTDOWN_reboot };
115 int rc;
116 rc = HYPERVISOR_sched_op(SCHEDOP_shutdown, &r);
117 BUG_ON(rc);
118 }
119
xen_power_off(void)120 static void xen_power_off(void)
121 {
122 struct sched_shutdown r = { .reason = SHUTDOWN_poweroff };
123 int rc;
124 rc = HYPERVISOR_sched_op(SCHEDOP_shutdown, &r);
125 BUG_ON(rc);
126 }
127
xen_cpu_notification(struct notifier_block * self,unsigned long action,void * hcpu)128 static int xen_cpu_notification(struct notifier_block *self,
129 unsigned long action,
130 void *hcpu)
131 {
132 switch (action) {
133 case CPU_STARTING:
134 xen_percpu_init();
135 break;
136 case CPU_DYING:
137 disable_percpu_irq(xen_events_irq);
138 break;
139 default:
140 break;
141 }
142
143 return NOTIFY_OK;
144 }
145
146 static struct notifier_block xen_cpu_notifier = {
147 .notifier_call = xen_cpu_notification,
148 };
149
xen_arm_callback(int irq,void * arg)150 static irqreturn_t xen_arm_callback(int irq, void *arg)
151 {
152 xen_hvm_evtchn_do_upcall();
153 return IRQ_HANDLED;
154 }
155
156 /*
157 * see Documentation/devicetree/bindings/arm/xen.txt for the
158 * documentation of the Xen Device Tree format.
159 */
160 #define GRANT_TABLE_PHYSADDR 0
xen_early_init(void)161 void __init xen_early_init(void)
162 {
163 int len;
164 const char *s = NULL;
165 const char *version = NULL;
166 const char *xen_prefix = "xen,xen-";
167
168 xen_node = of_find_compatible_node(NULL, NULL, "xen,xen");
169 if (!xen_node) {
170 pr_debug("No Xen support\n");
171 return;
172 }
173 s = of_get_property(xen_node, "compatible", &len);
174 if (strlen(xen_prefix) + 3 < len &&
175 !strncmp(xen_prefix, s, strlen(xen_prefix)))
176 version = s + strlen(xen_prefix);
177 if (version == NULL) {
178 pr_debug("Xen version not found\n");
179 return;
180 }
181
182 pr_info("Xen %s support found\n", version);
183
184 xen_domain_type = XEN_HVM_DOMAIN;
185
186 xen_setup_features();
187
188 if (xen_feature(XENFEAT_dom0))
189 xen_start_info->flags |= SIF_INITDOMAIN|SIF_PRIVILEGED;
190 else
191 xen_start_info->flags &= ~(SIF_INITDOMAIN|SIF_PRIVILEGED);
192
193 if (!console_set_on_cmdline && !xen_initial_domain())
194 add_preferred_console("hvc", 0, NULL);
195 }
196
xen_guest_init(void)197 static int __init xen_guest_init(void)
198 {
199 struct xen_add_to_physmap xatp;
200 struct shared_info *shared_info_page = NULL;
201 struct resource res;
202 phys_addr_t grant_frames;
203
204 if (!xen_domain())
205 return 0;
206
207 if (of_address_to_resource(xen_node, GRANT_TABLE_PHYSADDR, &res)) {
208 pr_err("Xen grant table base address not found\n");
209 return -ENODEV;
210 }
211 grant_frames = res.start;
212
213 xen_events_irq = irq_of_parse_and_map(xen_node, 0);
214 if (!xen_events_irq) {
215 pr_err("Xen event channel interrupt not found\n");
216 return -ENODEV;
217 }
218
219 shared_info_page = (struct shared_info *)get_zeroed_page(GFP_KERNEL);
220
221 if (!shared_info_page) {
222 pr_err("not enough memory\n");
223 return -ENOMEM;
224 }
225 xatp.domid = DOMID_SELF;
226 xatp.idx = 0;
227 xatp.space = XENMAPSPACE_shared_info;
228 xatp.gpfn = virt_to_gfn(shared_info_page);
229 if (HYPERVISOR_memory_op(XENMEM_add_to_physmap, &xatp))
230 BUG();
231
232 HYPERVISOR_shared_info = (struct shared_info *)shared_info_page;
233
234 /* xen_vcpu is a pointer to the vcpu_info struct in the shared_info
235 * page, we use it in the event channel upcall and in some pvclock
236 * related functions.
237 * The shared info contains exactly 1 CPU (the boot CPU). The guest
238 * is required to use VCPUOP_register_vcpu_info to place vcpu info
239 * for secondary CPUs as they are brought up.
240 * For uniformity we use VCPUOP_register_vcpu_info even on cpu0.
241 */
242 xen_vcpu_info = __alloc_percpu(sizeof(struct vcpu_info),
243 sizeof(struct vcpu_info));
244 if (xen_vcpu_info == NULL)
245 return -ENOMEM;
246
247 if (gnttab_setup_auto_xlat_frames(grant_frames)) {
248 free_percpu(xen_vcpu_info);
249 return -ENOMEM;
250 }
251 gnttab_init();
252 if (!xen_initial_domain())
253 xenbus_probe(NULL);
254
255 /*
256 * Making sure board specific code will not set up ops for
257 * cpu idle and cpu freq.
258 */
259 disable_cpuidle();
260 disable_cpufreq();
261
262 xen_init_IRQ();
263
264 if (request_percpu_irq(xen_events_irq, xen_arm_callback,
265 "events", &xen_vcpu)) {
266 pr_err("Error request IRQ %d\n", xen_events_irq);
267 return -EINVAL;
268 }
269
270 xen_percpu_init();
271
272 register_cpu_notifier(&xen_cpu_notifier);
273
274 return 0;
275 }
276 early_initcall(xen_guest_init);
277
xen_pm_init(void)278 static int __init xen_pm_init(void)
279 {
280 if (!xen_domain())
281 return -ENODEV;
282
283 pm_power_off = xen_power_off;
284 arm_pm_restart = xen_restart;
285
286 return 0;
287 }
288 late_initcall(xen_pm_init);
289
290
291 /* empty stubs */
xen_arch_pre_suspend(void)292 void xen_arch_pre_suspend(void) { }
xen_arch_post_suspend(int suspend_cancelled)293 void xen_arch_post_suspend(int suspend_cancelled) { }
xen_timer_resume(void)294 void xen_timer_resume(void) { }
xen_arch_resume(void)295 void xen_arch_resume(void) { }
xen_arch_suspend(void)296 void xen_arch_suspend(void) { }
297
298
299 /* In the hypercall.S file. */
300 EXPORT_SYMBOL_GPL(HYPERVISOR_event_channel_op);
301 EXPORT_SYMBOL_GPL(HYPERVISOR_grant_table_op);
302 EXPORT_SYMBOL_GPL(HYPERVISOR_xen_version);
303 EXPORT_SYMBOL_GPL(HYPERVISOR_console_io);
304 EXPORT_SYMBOL_GPL(HYPERVISOR_sched_op);
305 EXPORT_SYMBOL_GPL(HYPERVISOR_hvm_op);
306 EXPORT_SYMBOL_GPL(HYPERVISOR_memory_op);
307 EXPORT_SYMBOL_GPL(HYPERVISOR_physdev_op);
308 EXPORT_SYMBOL_GPL(HYPERVISOR_vcpu_op);
309 EXPORT_SYMBOL_GPL(HYPERVISOR_tmem_op);
310 EXPORT_SYMBOL_GPL(HYPERVISOR_multicall);
311 EXPORT_SYMBOL_GPL(privcmd_call);
312