Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 1 | #include <xen/xen.h> |
Stefano Stabellini | 0ec53ec | 2012-09-14 13:37:32 +0000 | [diff] [blame] | 2 | #include <xen/events.h> |
Stefano Stabellini | b3b52fd | 2012-09-13 12:06:52 +0000 | [diff] [blame] | 3 | #include <xen/grant_table.h> |
| 4 | #include <xen/hvm.h> |
Stefano Stabellini | 9a9ab3c | 2013-04-25 16:17:04 +0000 | [diff] [blame] | 5 | #include <xen/interface/vcpu.h> |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 6 | #include <xen/interface/xen.h> |
| 7 | #include <xen/interface/memory.h> |
Stefano Stabellini | b3b52fd | 2012-09-13 12:06:52 +0000 | [diff] [blame] | 8 | #include <xen/interface/hvm/params.h> |
Stefano Stabellini | ef61ee0d | 2012-08-08 17:20:18 +0000 | [diff] [blame] | 9 | #include <xen/features.h> |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 10 | #include <xen/platform_pci.h> |
Stefano Stabellini | b3b52fd | 2012-09-13 12:06:52 +0000 | [diff] [blame] | 11 | #include <xen/xenbus.h> |
Ian Campbell | c61ba72 | 2012-10-03 12:28:26 +0100 | [diff] [blame] | 12 | #include <xen/page.h> |
Stefano Stabellini | 6abb749 | 2013-04-25 10:23:07 +0000 | [diff] [blame] | 13 | #include <xen/interface/sched.h> |
Ian Campbell | f832da0 | 2012-10-03 16:37:09 +0100 | [diff] [blame] | 14 | #include <xen/xen-ops.h> |
Stefano Stabellini | 34e3852 | 2015-11-23 10:35:12 +0000 | [diff] [blame] | 15 | #include <asm/paravirt.h> |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 16 | #include <asm/xen/hypervisor.h> |
| 17 | #include <asm/xen/hypercall.h> |
Stefano Stabellini | 6abb749 | 2013-04-25 10:23:07 +0000 | [diff] [blame] | 18 | #include <asm/system_misc.h> |
Stefano Stabellini | 0ec53ec | 2012-09-14 13:37:32 +0000 | [diff] [blame] | 19 | #include <linux/interrupt.h> |
| 20 | #include <linux/irqreturn.h> |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 21 | #include <linux/module.h> |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 22 | #include <linux/of.h> |
| 23 | #include <linux/of_irq.h> |
| 24 | #include <linux/of_address.h> |
Julien Grall | e1a9c16 | 2013-09-09 11:35:26 +0000 | [diff] [blame] | 25 | #include <linux/cpuidle.h> |
| 26 | #include <linux/cpufreq.h> |
Julien Grall | 8b271d5 | 2014-01-30 12:52:59 +0000 | [diff] [blame] | 27 | #include <linux/cpu.h> |
Ard Biesheuvel | f1dddd1 | 2015-05-06 14:14:22 +0000 | [diff] [blame] | 28 | #include <linux/console.h> |
Stefano Stabellini | 7d5f6f8 | 2015-11-23 10:41:12 +0000 | [diff] [blame] | 29 | #include <linux/pvclock_gtod.h> |
| 30 | #include <linux/time64.h> |
Stefano Stabellini | e709fba | 2015-11-23 10:40:12 +0000 | [diff] [blame] | 31 | #include <linux/timekeeping.h> |
Stefano Stabellini | 7d5f6f8 | 2015-11-23 10:41:12 +0000 | [diff] [blame] | 32 | #include <linux/timekeeper_internal.h> |
Shannon Zhao | d22cbe6 | 2016-04-07 20:03:27 +0800 | [diff] [blame^] | 33 | #include <linux/acpi.h> |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 34 | |
Ian Campbell | f832da0 | 2012-10-03 16:37:09 +0100 | [diff] [blame] | 35 | #include <linux/mm.h> |
| 36 | |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 37 | struct start_info _xen_start_info; |
| 38 | struct start_info *xen_start_info = &_xen_start_info; |
Chuck Tuffli | 35c8ab4 | 2014-12-21 12:30:58 -0800 | [diff] [blame] | 39 | EXPORT_SYMBOL(xen_start_info); |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 40 | |
| 41 | enum xen_domain_type xen_domain_type = XEN_NATIVE; |
Chuck Tuffli | 35c8ab4 | 2014-12-21 12:30:58 -0800 | [diff] [blame] | 42 | EXPORT_SYMBOL(xen_domain_type); |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 43 | |
| 44 | struct shared_info xen_dummy_shared_info; |
| 45 | struct shared_info *HYPERVISOR_shared_info = (void *)&xen_dummy_shared_info; |
| 46 | |
| 47 | DEFINE_PER_CPU(struct vcpu_info *, xen_vcpu); |
Stefano Stabellini | 9a9ab3c | 2013-04-25 16:17:04 +0000 | [diff] [blame] | 48 | static struct vcpu_info __percpu *xen_vcpu_info; |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 49 | |
Ian Campbell | c61ba72 | 2012-10-03 12:28:26 +0100 | [diff] [blame] | 50 | /* These are unused until we support booting "pre-ballooned" */ |
| 51 | unsigned long xen_released_pages; |
| 52 | struct xen_memory_region xen_extra_mem[XEN_EXTRA_MEM_MAX_REGIONS] __initdata; |
| 53 | |
Julien Grall | 81e863c | 2015-05-06 14:09:06 +0000 | [diff] [blame] | 54 | static __read_mostly unsigned int xen_events_irq; |
Stefano Stabellini | 0ec53ec | 2012-09-14 13:37:32 +0000 | [diff] [blame] | 55 | |
Stefano Stabellini | 5882bfe | 2015-05-06 14:13:31 +0000 | [diff] [blame] | 56 | static __initdata struct device_node *xen_node; |
| 57 | |
Julien Grall | a13d720 | 2015-08-07 17:34:41 +0100 | [diff] [blame] | 58 | int xen_remap_domain_gfn_array(struct vm_area_struct *vma, |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 59 | unsigned long addr, |
Julien Grall | a13d720 | 2015-08-07 17:34:41 +0100 | [diff] [blame] | 60 | xen_pfn_t *gfn, int nr, |
David Vrabel | 4e8c0c8 | 2015-03-11 14:49:57 +0000 | [diff] [blame] | 61 | int *err_ptr, pgprot_t prot, |
| 62 | unsigned domid, |
Ian Campbell | f832da0 | 2012-10-03 16:37:09 +0100 | [diff] [blame] | 63 | struct page **pages) |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 64 | { |
Julien Grall | a13d720 | 2015-08-07 17:34:41 +0100 | [diff] [blame] | 65 | return xen_xlate_remap_gfn_array(vma, addr, gfn, nr, err_ptr, |
David Vrabel | 628c28e | 2015-03-11 14:49:56 +0000 | [diff] [blame] | 66 | prot, domid, pages); |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 67 | } |
Julien Grall | a13d720 | 2015-08-07 17:34:41 +0100 | [diff] [blame] | 68 | EXPORT_SYMBOL_GPL(xen_remap_domain_gfn_array); |
David Vrabel | 4e8c0c8 | 2015-03-11 14:49:57 +0000 | [diff] [blame] | 69 | |
| 70 | /* Not used by XENFEAT_auto_translated guests. */ |
Julien Grall | a13d720 | 2015-08-07 17:34:41 +0100 | [diff] [blame] | 71 | int xen_remap_domain_gfn_range(struct vm_area_struct *vma, |
David Vrabel | 4e8c0c8 | 2015-03-11 14:49:57 +0000 | [diff] [blame] | 72 | unsigned long addr, |
Julien Grall | a13d720 | 2015-08-07 17:34:41 +0100 | [diff] [blame] | 73 | xen_pfn_t gfn, int nr, |
David Vrabel | 4e8c0c8 | 2015-03-11 14:49:57 +0000 | [diff] [blame] | 74 | pgprot_t prot, unsigned domid, |
| 75 | struct page **pages) |
| 76 | { |
| 77 | return -ENOSYS; |
| 78 | } |
Julien Grall | a13d720 | 2015-08-07 17:34:41 +0100 | [diff] [blame] | 79 | EXPORT_SYMBOL_GPL(xen_remap_domain_gfn_range); |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 80 | |
Julien Grall | a13d720 | 2015-08-07 17:34:41 +0100 | [diff] [blame] | 81 | int xen_unmap_domain_gfn_range(struct vm_area_struct *vma, |
Ian Campbell | f832da0 | 2012-10-03 16:37:09 +0100 | [diff] [blame] | 82 | int nr, struct page **pages) |
| 83 | { |
David Vrabel | 628c28e | 2015-03-11 14:49:56 +0000 | [diff] [blame] | 84 | return xen_xlate_unmap_gfn_range(vma, nr, pages); |
Ian Campbell | f832da0 | 2012-10-03 16:37:09 +0100 | [diff] [blame] | 85 | } |
Julien Grall | a13d720 | 2015-08-07 17:34:41 +0100 | [diff] [blame] | 86 | EXPORT_SYMBOL_GPL(xen_unmap_domain_gfn_range); |
Ian Campbell | f832da0 | 2012-10-03 16:37:09 +0100 | [diff] [blame] | 87 | |
Stefano Stabellini | 34e3852 | 2015-11-23 10:35:12 +0000 | [diff] [blame] | 88 | static unsigned long long xen_stolen_accounting(int cpu) |
| 89 | { |
| 90 | struct vcpu_runstate_info state; |
| 91 | |
| 92 | BUG_ON(cpu != smp_processor_id()); |
| 93 | |
| 94 | xen_get_runstate_snapshot(&state); |
| 95 | |
| 96 | WARN_ON(state.state != RUNSTATE_running); |
| 97 | |
| 98 | return state.time[RUNSTATE_runnable] + state.time[RUNSTATE_offline]; |
| 99 | } |
| 100 | |
Stefano Stabellini | e709fba | 2015-11-23 10:40:12 +0000 | [diff] [blame] | 101 | static void xen_read_wallclock(struct timespec64 *ts) |
| 102 | { |
| 103 | u32 version; |
| 104 | struct timespec64 now, ts_monotonic; |
| 105 | struct shared_info *s = HYPERVISOR_shared_info; |
| 106 | struct pvclock_wall_clock *wall_clock = &(s->wc); |
| 107 | |
| 108 | /* get wallclock at system boot */ |
| 109 | do { |
| 110 | version = wall_clock->version; |
| 111 | rmb(); /* fetch version before time */ |
| 112 | now.tv_sec = ((uint64_t)wall_clock->sec_hi << 32) | wall_clock->sec; |
| 113 | now.tv_nsec = wall_clock->nsec; |
| 114 | rmb(); /* fetch time before checking version */ |
| 115 | } while ((wall_clock->version & 1) || (version != wall_clock->version)); |
| 116 | |
| 117 | /* time since system boot */ |
| 118 | ktime_get_ts64(&ts_monotonic); |
| 119 | *ts = timespec64_add(now, ts_monotonic); |
| 120 | } |
| 121 | |
Stefano Stabellini | 7d5f6f8 | 2015-11-23 10:41:12 +0000 | [diff] [blame] | 122 | static int xen_pvclock_gtod_notify(struct notifier_block *nb, |
| 123 | unsigned long was_set, void *priv) |
| 124 | { |
| 125 | /* Protected by the calling core code serialization */ |
| 126 | static struct timespec64 next_sync; |
| 127 | |
| 128 | struct xen_platform_op op; |
| 129 | struct timespec64 now, system_time; |
| 130 | struct timekeeper *tk = priv; |
| 131 | |
| 132 | now.tv_sec = tk->xtime_sec; |
| 133 | now.tv_nsec = (long)(tk->tkr_mono.xtime_nsec >> tk->tkr_mono.shift); |
| 134 | system_time = timespec64_add(now, tk->wall_to_monotonic); |
| 135 | |
| 136 | /* |
| 137 | * We only take the expensive HV call when the clock was set |
| 138 | * or when the 11 minutes RTC synchronization time elapsed. |
| 139 | */ |
| 140 | if (!was_set && timespec64_compare(&now, &next_sync) < 0) |
| 141 | return NOTIFY_OK; |
| 142 | |
| 143 | op.cmd = XENPF_settime64; |
| 144 | op.u.settime64.mbz = 0; |
| 145 | op.u.settime64.secs = now.tv_sec; |
| 146 | op.u.settime64.nsecs = now.tv_nsec; |
| 147 | op.u.settime64.system_time = timespec64_to_ns(&system_time); |
| 148 | (void)HYPERVISOR_platform_op(&op); |
| 149 | |
| 150 | /* |
| 151 | * Move the next drift compensation time 11 minutes |
| 152 | * ahead. That's emulating the sync_cmos_clock() update for |
| 153 | * the hardware RTC. |
| 154 | */ |
| 155 | next_sync = now; |
| 156 | next_sync.tv_sec += 11 * 60; |
| 157 | |
| 158 | return NOTIFY_OK; |
| 159 | } |
| 160 | |
| 161 | static struct notifier_block xen_pvclock_gtod_notifier = { |
| 162 | .notifier_call = xen_pvclock_gtod_notify, |
| 163 | }; |
| 164 | |
Julien Grall | 8b271d5 | 2014-01-30 12:52:59 +0000 | [diff] [blame] | 165 | static void xen_percpu_init(void) |
Stefano Stabellini | 9a9ab3c | 2013-04-25 16:17:04 +0000 | [diff] [blame] | 166 | { |
| 167 | struct vcpu_register_vcpu_info info; |
| 168 | struct vcpu_info *vcpup; |
| 169 | int err; |
Stefano Stabellini | 3cc8e40 | 2013-05-08 11:59:01 +0000 | [diff] [blame] | 170 | int cpu = get_cpu(); |
Stefano Stabellini | 9a9ab3c | 2013-04-25 16:17:04 +0000 | [diff] [blame] | 171 | |
Stefano Stabellini | cb9644b | 2015-10-22 16:22:46 +0000 | [diff] [blame] | 172 | /* |
| 173 | * VCPUOP_register_vcpu_info cannot be called twice for the same |
| 174 | * vcpu, so if vcpu_info is already registered, just get out. This |
| 175 | * can happen with cpu-hotplug. |
| 176 | */ |
| 177 | if (per_cpu(xen_vcpu, cpu) != NULL) |
| 178 | goto after_register_vcpu_info; |
| 179 | |
Stefano Stabellini | 9a9ab3c | 2013-04-25 16:17:04 +0000 | [diff] [blame] | 180 | pr_info("Xen: initializing cpu%d\n", cpu); |
| 181 | vcpup = per_cpu_ptr(xen_vcpu_info, cpu); |
| 182 | |
Julien Grall | 250c9af | 2015-05-05 16:36:56 +0100 | [diff] [blame] | 183 | info.mfn = virt_to_gfn(vcpup); |
| 184 | info.offset = xen_offset_in_page(vcpup); |
Stefano Stabellini | 9a9ab3c | 2013-04-25 16:17:04 +0000 | [diff] [blame] | 185 | |
| 186 | err = HYPERVISOR_vcpu_op(VCPUOP_register_vcpu_info, cpu, &info); |
Stefano Stabellini | d7266d7 | 2013-05-08 13:02:38 +0000 | [diff] [blame] | 187 | BUG_ON(err); |
| 188 | per_cpu(xen_vcpu, cpu) = vcpup; |
| 189 | |
Stefano Stabellini | 34e3852 | 2015-11-23 10:35:12 +0000 | [diff] [blame] | 190 | xen_setup_runstate_info(cpu); |
| 191 | |
Stefano Stabellini | cb9644b | 2015-10-22 16:22:46 +0000 | [diff] [blame] | 192 | after_register_vcpu_info: |
Stefano Stabellini | 3cc8e40 | 2013-05-08 11:59:01 +0000 | [diff] [blame] | 193 | enable_percpu_irq(xen_events_irq, 0); |
Julien Grall | 0d7febe | 2013-07-29 17:06:05 +0100 | [diff] [blame] | 194 | put_cpu(); |
Stefano Stabellini | 9a9ab3c | 2013-04-25 16:17:04 +0000 | [diff] [blame] | 195 | } |
| 196 | |
Stefano Stabellini | 2451ade | 2013-07-21 15:17:54 +0000 | [diff] [blame] | 197 | static void xen_restart(enum reboot_mode reboot_mode, const char *cmd) |
Stefano Stabellini | 6abb749 | 2013-04-25 10:23:07 +0000 | [diff] [blame] | 198 | { |
| 199 | struct sched_shutdown r = { .reason = SHUTDOWN_reboot }; |
| 200 | int rc; |
| 201 | rc = HYPERVISOR_sched_op(SCHEDOP_shutdown, &r); |
Himangi Saraogi | a91c777 | 2014-07-25 12:05:39 -0400 | [diff] [blame] | 202 | BUG_ON(rc); |
Stefano Stabellini | 6abb749 | 2013-04-25 10:23:07 +0000 | [diff] [blame] | 203 | } |
| 204 | |
| 205 | static void xen_power_off(void) |
| 206 | { |
| 207 | struct sched_shutdown r = { .reason = SHUTDOWN_poweroff }; |
| 208 | int rc; |
| 209 | rc = HYPERVISOR_sched_op(SCHEDOP_shutdown, &r); |
Himangi Saraogi | a91c777 | 2014-07-25 12:05:39 -0400 | [diff] [blame] | 210 | BUG_ON(rc); |
Stefano Stabellini | 6abb749 | 2013-04-25 10:23:07 +0000 | [diff] [blame] | 211 | } |
| 212 | |
Julien Grall | 8b271d5 | 2014-01-30 12:52:59 +0000 | [diff] [blame] | 213 | static int xen_cpu_notification(struct notifier_block *self, |
| 214 | unsigned long action, |
| 215 | void *hcpu) |
| 216 | { |
| 217 | switch (action) { |
| 218 | case CPU_STARTING: |
| 219 | xen_percpu_init(); |
| 220 | break; |
Stefano Stabellini | cb9644b | 2015-10-22 16:22:46 +0000 | [diff] [blame] | 221 | case CPU_DYING: |
| 222 | disable_percpu_irq(xen_events_irq); |
| 223 | break; |
Julien Grall | 8b271d5 | 2014-01-30 12:52:59 +0000 | [diff] [blame] | 224 | default: |
| 225 | break; |
| 226 | } |
| 227 | |
| 228 | return NOTIFY_OK; |
| 229 | } |
| 230 | |
| 231 | static struct notifier_block xen_cpu_notifier = { |
| 232 | .notifier_call = xen_cpu_notification, |
| 233 | }; |
| 234 | |
| 235 | static irqreturn_t xen_arm_callback(int irq, void *arg) |
| 236 | { |
| 237 | xen_hvm_evtchn_do_upcall(); |
| 238 | return IRQ_HANDLED; |
| 239 | } |
| 240 | |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 241 | /* |
| 242 | * see Documentation/devicetree/bindings/arm/xen.txt for the |
| 243 | * documentation of the Xen Device Tree format. |
| 244 | */ |
Stefano Stabellini | b3b52fd | 2012-09-13 12:06:52 +0000 | [diff] [blame] | 245 | #define GRANT_TABLE_PHYSADDR 0 |
Stefano Stabellini | 5882bfe | 2015-05-06 14:13:31 +0000 | [diff] [blame] | 246 | void __init xen_early_init(void) |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 247 | { |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 248 | int len; |
| 249 | const char *s = NULL; |
| 250 | const char *version = NULL; |
| 251 | const char *xen_prefix = "xen,xen-"; |
| 252 | |
Stefano Stabellini | 5882bfe | 2015-05-06 14:13:31 +0000 | [diff] [blame] | 253 | xen_node = of_find_compatible_node(NULL, NULL, "xen,xen"); |
| 254 | if (!xen_node) { |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 255 | pr_debug("No Xen support\n"); |
Stefano Stabellini | 5882bfe | 2015-05-06 14:13:31 +0000 | [diff] [blame] | 256 | return; |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 257 | } |
Stefano Stabellini | 5882bfe | 2015-05-06 14:13:31 +0000 | [diff] [blame] | 258 | s = of_get_property(xen_node, "compatible", &len); |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 259 | if (strlen(xen_prefix) + 3 < len && |
| 260 | !strncmp(xen_prefix, s, strlen(xen_prefix))) |
| 261 | version = s + strlen(xen_prefix); |
| 262 | if (version == NULL) { |
| 263 | pr_debug("Xen version not found\n"); |
Stefano Stabellini | 5882bfe | 2015-05-06 14:13:31 +0000 | [diff] [blame] | 264 | return; |
Julien Grall | 81e863c | 2015-05-06 14:09:06 +0000 | [diff] [blame] | 265 | } |
| 266 | |
Stefano Stabellini | 5882bfe | 2015-05-06 14:13:31 +0000 | [diff] [blame] | 267 | pr_info("Xen %s support found\n", version); |
Julien Grall | 8b271d5 | 2014-01-30 12:52:59 +0000 | [diff] [blame] | 268 | |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 269 | xen_domain_type = XEN_HVM_DOMAIN; |
| 270 | |
Stefano Stabellini | ef61ee0d | 2012-08-08 17:20:18 +0000 | [diff] [blame] | 271 | xen_setup_features(); |
Stefano Stabellini | 5ebc77d | 2014-09-10 22:49:30 +0000 | [diff] [blame] | 272 | |
Stefano Stabellini | ef61ee0d | 2012-08-08 17:20:18 +0000 | [diff] [blame] | 273 | if (xen_feature(XENFEAT_dom0)) |
| 274 | xen_start_info->flags |= SIF_INITDOMAIN|SIF_PRIVILEGED; |
| 275 | else |
| 276 | xen_start_info->flags &= ~(SIF_INITDOMAIN|SIF_PRIVILEGED); |
Ard Biesheuvel | f1dddd1 | 2015-05-06 14:14:22 +0000 | [diff] [blame] | 277 | |
| 278 | if (!console_set_on_cmdline && !xen_initial_domain()) |
| 279 | add_preferred_console("hvc", 0, NULL); |
Stefano Stabellini | 5882bfe | 2015-05-06 14:13:31 +0000 | [diff] [blame] | 280 | } |
Stefano Stabellini | ef61ee0d | 2012-08-08 17:20:18 +0000 | [diff] [blame] | 281 | |
Shannon Zhao | d22cbe6 | 2016-04-07 20:03:27 +0800 | [diff] [blame^] | 282 | static void __init xen_acpi_guest_init(void) |
| 283 | { |
| 284 | #ifdef CONFIG_ACPI |
| 285 | struct xen_hvm_param a; |
| 286 | int interrupt, trigger, polarity; |
| 287 | |
| 288 | a.domid = DOMID_SELF; |
| 289 | a.index = HVM_PARAM_CALLBACK_IRQ; |
| 290 | |
| 291 | if (HYPERVISOR_hvm_op(HVMOP_get_param, &a) |
| 292 | || (a.value >> 56) != HVM_PARAM_CALLBACK_TYPE_PPI) { |
| 293 | xen_events_irq = 0; |
| 294 | return; |
| 295 | } |
| 296 | |
| 297 | interrupt = a.value & 0xff; |
| 298 | trigger = ((a.value >> 8) & 0x1) ? ACPI_EDGE_SENSITIVE |
| 299 | : ACPI_LEVEL_SENSITIVE; |
| 300 | polarity = ((a.value >> 8) & 0x2) ? ACPI_ACTIVE_LOW |
| 301 | : ACPI_ACTIVE_HIGH; |
| 302 | xen_events_irq = acpi_register_gsi(NULL, interrupt, trigger, polarity); |
| 303 | #endif |
| 304 | } |
| 305 | |
| 306 | static void __init xen_dt_guest_init(void) |
| 307 | { |
| 308 | xen_events_irq = irq_of_parse_and_map(xen_node, 0); |
| 309 | } |
| 310 | |
Stefano Stabellini | 5882bfe | 2015-05-06 14:13:31 +0000 | [diff] [blame] | 311 | static int __init xen_guest_init(void) |
| 312 | { |
| 313 | struct xen_add_to_physmap xatp; |
| 314 | struct shared_info *shared_info_page = NULL; |
Stefano Stabellini | 5882bfe | 2015-05-06 14:13:31 +0000 | [diff] [blame] | 315 | |
| 316 | if (!xen_domain()) |
| 317 | return 0; |
| 318 | |
Shannon Zhao | d22cbe6 | 2016-04-07 20:03:27 +0800 | [diff] [blame^] | 319 | if (!acpi_disabled) |
| 320 | xen_acpi_guest_init(); |
| 321 | else |
| 322 | xen_dt_guest_init(); |
| 323 | |
Stefano Stabellini | 5882bfe | 2015-05-06 14:13:31 +0000 | [diff] [blame] | 324 | if (!xen_events_irq) { |
| 325 | pr_err("Xen event channel interrupt not found\n"); |
| 326 | return -ENODEV; |
| 327 | } |
| 328 | |
| 329 | shared_info_page = (struct shared_info *)get_zeroed_page(GFP_KERNEL); |
| 330 | |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 331 | if (!shared_info_page) { |
| 332 | pr_err("not enough memory\n"); |
| 333 | return -ENOMEM; |
| 334 | } |
| 335 | xatp.domid = DOMID_SELF; |
| 336 | xatp.idx = 0; |
| 337 | xatp.space = XENMAPSPACE_shared_info; |
Julien Grall | 250c9af | 2015-05-05 16:36:56 +0100 | [diff] [blame] | 338 | xatp.gpfn = virt_to_gfn(shared_info_page); |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 339 | if (HYPERVISOR_memory_op(XENMEM_add_to_physmap, &xatp)) |
| 340 | BUG(); |
| 341 | |
| 342 | HYPERVISOR_shared_info = (struct shared_info *)shared_info_page; |
| 343 | |
| 344 | /* xen_vcpu is a pointer to the vcpu_info struct in the shared_info |
| 345 | * page, we use it in the event channel upcall and in some pvclock |
Stefano Stabellini | 9a9ab3c | 2013-04-25 16:17:04 +0000 | [diff] [blame] | 346 | * related functions. |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 347 | * The shared info contains exactly 1 CPU (the boot CPU). The guest |
| 348 | * is required to use VCPUOP_register_vcpu_info to place vcpu info |
Stefano Stabellini | 9a9ab3c | 2013-04-25 16:17:04 +0000 | [diff] [blame] | 349 | * for secondary CPUs as they are brought up. |
| 350 | * For uniformity we use VCPUOP_register_vcpu_info even on cpu0. |
| 351 | */ |
| 352 | xen_vcpu_info = __alloc_percpu(sizeof(struct vcpu_info), |
| 353 | sizeof(struct vcpu_info)); |
| 354 | if (xen_vcpu_info == NULL) |
| 355 | return -ENOMEM; |
Stefano Stabellini | b3b52fd | 2012-09-13 12:06:52 +0000 | [diff] [blame] | 356 | |
Shannon Zhao | 3cf4095 | 2016-04-07 20:03:21 +0800 | [diff] [blame] | 357 | xen_auto_xlat_grant_frames.count = gnttab_max_grant_frames(); |
| 358 | if (xen_xlate_map_ballooned_pages(&xen_auto_xlat_grant_frames.pfn, |
| 359 | &xen_auto_xlat_grant_frames.vaddr, |
| 360 | xen_auto_xlat_grant_frames.count)) { |
Konrad Rzeszutek Wilk | efaf30a | 2014-01-06 10:40:36 -0500 | [diff] [blame] | 361 | free_percpu(xen_vcpu_info); |
| 362 | return -ENOMEM; |
| 363 | } |
Stefano Stabellini | b3b52fd | 2012-09-13 12:06:52 +0000 | [diff] [blame] | 364 | gnttab_init(); |
| 365 | if (!xen_initial_domain()) |
| 366 | xenbus_probe(NULL); |
| 367 | |
Julien Grall | e1a9c16 | 2013-09-09 11:35:26 +0000 | [diff] [blame] | 368 | /* |
| 369 | * Making sure board specific code will not set up ops for |
| 370 | * cpu idle and cpu freq. |
| 371 | */ |
| 372 | disable_cpuidle(); |
| 373 | disable_cpufreq(); |
| 374 | |
Julien Grall | 8b271d5 | 2014-01-30 12:52:59 +0000 | [diff] [blame] | 375 | xen_init_IRQ(); |
| 376 | |
| 377 | if (request_percpu_irq(xen_events_irq, xen_arm_callback, |
| 378 | "events", &xen_vcpu)) { |
| 379 | pr_err("Error request IRQ %d\n", xen_events_irq); |
| 380 | return -EINVAL; |
| 381 | } |
| 382 | |
| 383 | xen_percpu_init(); |
| 384 | |
| 385 | register_cpu_notifier(&xen_cpu_notifier); |
| 386 | |
Stefano Stabellini | 34e3852 | 2015-11-23 10:35:12 +0000 | [diff] [blame] | 387 | pv_time_ops.steal_clock = xen_stolen_accounting; |
| 388 | static_key_slow_inc(¶virt_steal_enabled); |
Stefano Stabellini | 7d5f6f8 | 2015-11-23 10:41:12 +0000 | [diff] [blame] | 389 | if (xen_initial_domain()) |
| 390 | pvclock_gtod_register_notifier(&xen_pvclock_gtod_notifier); |
Stefano Stabellini | 34e3852 | 2015-11-23 10:35:12 +0000 | [diff] [blame] | 391 | |
Stefano Stabellini | 1aa3d8d | 2013-05-08 11:59:01 +0000 | [diff] [blame] | 392 | return 0; |
| 393 | } |
Julien Grall | 8b271d5 | 2014-01-30 12:52:59 +0000 | [diff] [blame] | 394 | early_initcall(xen_guest_init); |
Stefano Stabellini | 1aa3d8d | 2013-05-08 11:59:01 +0000 | [diff] [blame] | 395 | |
| 396 | static int __init xen_pm_init(void) |
| 397 | { |
Rob Herring | 9dd4b29 | 2013-08-29 07:43:52 -0500 | [diff] [blame] | 398 | if (!xen_domain()) |
| 399 | return -ENODEV; |
| 400 | |
Stefano Stabellini | 6abb749 | 2013-04-25 10:23:07 +0000 | [diff] [blame] | 401 | pm_power_off = xen_power_off; |
| 402 | arm_pm_restart = xen_restart; |
Stefano Stabellini | e709fba | 2015-11-23 10:40:12 +0000 | [diff] [blame] | 403 | if (!xen_initial_domain()) { |
| 404 | struct timespec64 ts; |
| 405 | xen_read_wallclock(&ts); |
| 406 | do_settimeofday64(&ts); |
| 407 | } |
Stefano Stabellini | 6abb749 | 2013-04-25 10:23:07 +0000 | [diff] [blame] | 408 | |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 409 | return 0; |
| 410 | } |
Rob Herring | 9dd4b29 | 2013-08-29 07:43:52 -0500 | [diff] [blame] | 411 | late_initcall(xen_pm_init); |
Stefano Stabellini | 0ec53ec | 2012-09-14 13:37:32 +0000 | [diff] [blame] | 412 | |
Stefano Stabellini | 7939028 | 2014-05-08 16:54:02 +0100 | [diff] [blame] | 413 | |
| 414 | /* empty stubs */ |
| 415 | void xen_arch_pre_suspend(void) { } |
| 416 | void xen_arch_post_suspend(int suspend_cancelled) { } |
| 417 | void xen_timer_resume(void) { } |
| 418 | void xen_arch_resume(void) { } |
Boris Ostrovsky | ffb7dbe | 2015-05-07 12:55:23 -0400 | [diff] [blame] | 419 | void xen_arch_suspend(void) { } |
Stefano Stabellini | 7939028 | 2014-05-08 16:54:02 +0100 | [diff] [blame] | 420 | |
| 421 | |
Juergen Gross | d5f985c | 2015-09-14 15:20:52 +0200 | [diff] [blame] | 422 | /* In the hypercall.S file. */ |
Konrad Rzeszutek Wilk | 911dec0 | 2012-11-06 17:06:52 -0500 | [diff] [blame] | 423 | EXPORT_SYMBOL_GPL(HYPERVISOR_event_channel_op); |
| 424 | EXPORT_SYMBOL_GPL(HYPERVISOR_grant_table_op); |
Stefano Stabellini | ab277bb | 2012-11-08 15:58:55 +0000 | [diff] [blame] | 425 | EXPORT_SYMBOL_GPL(HYPERVISOR_xen_version); |
| 426 | EXPORT_SYMBOL_GPL(HYPERVISOR_console_io); |
| 427 | EXPORT_SYMBOL_GPL(HYPERVISOR_sched_op); |
| 428 | EXPORT_SYMBOL_GPL(HYPERVISOR_hvm_op); |
| 429 | EXPORT_SYMBOL_GPL(HYPERVISOR_memory_op); |
| 430 | EXPORT_SYMBOL_GPL(HYPERVISOR_physdev_op); |
Stefano Stabellini | ea0af61 | 2013-04-25 13:53:05 +0000 | [diff] [blame] | 431 | EXPORT_SYMBOL_GPL(HYPERVISOR_vcpu_op); |
Stefano Stabellini | 176455e | 2013-07-02 10:42:40 +0000 | [diff] [blame] | 432 | EXPORT_SYMBOL_GPL(HYPERVISOR_tmem_op); |
Stefano Stabellini | 72d39c6 | 2015-11-23 10:37:12 +0000 | [diff] [blame] | 433 | EXPORT_SYMBOL_GPL(HYPERVISOR_platform_op); |
Ian Campbell | 9f1d3414 | 2014-05-09 16:10:49 +0000 | [diff] [blame] | 434 | EXPORT_SYMBOL_GPL(HYPERVISOR_multicall); |
Konrad Rzeszutek Wilk | 911dec0 | 2012-11-06 17:06:52 -0500 | [diff] [blame] | 435 | EXPORT_SYMBOL_GPL(privcmd_call); |