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 | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 15 | #include <asm/xen/hypervisor.h> |
| 16 | #include <asm/xen/hypercall.h> |
Stefano Stabellini | 6abb749 | 2013-04-25 10:23:07 +0000 | [diff] [blame] | 17 | #include <asm/system_misc.h> |
Stefano Stabellini | 0ec53ec | 2012-09-14 13:37:32 +0000 | [diff] [blame] | 18 | #include <linux/interrupt.h> |
| 19 | #include <linux/irqreturn.h> |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 20 | #include <linux/module.h> |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 21 | #include <linux/of.h> |
| 22 | #include <linux/of_irq.h> |
| 23 | #include <linux/of_address.h> |
Julien Grall | e1a9c16 | 2013-09-09 11:35:26 +0000 | [diff] [blame] | 24 | #include <linux/cpuidle.h> |
| 25 | #include <linux/cpufreq.h> |
Julien Grall | 8b271d5 | 2014-01-30 12:52:59 +0000 | [diff] [blame] | 26 | #include <linux/cpu.h> |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 27 | |
Ian Campbell | f832da0 | 2012-10-03 16:37:09 +0100 | [diff] [blame] | 28 | #include <linux/mm.h> |
| 29 | |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 30 | struct start_info _xen_start_info; |
| 31 | struct start_info *xen_start_info = &_xen_start_info; |
Chuck Tuffli | 35c8ab4 | 2014-12-21 12:30:58 -0800 | [diff] [blame] | 32 | EXPORT_SYMBOL(xen_start_info); |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 33 | |
| 34 | enum xen_domain_type xen_domain_type = XEN_NATIVE; |
Chuck Tuffli | 35c8ab4 | 2014-12-21 12:30:58 -0800 | [diff] [blame] | 35 | EXPORT_SYMBOL(xen_domain_type); |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 36 | |
| 37 | struct shared_info xen_dummy_shared_info; |
| 38 | struct shared_info *HYPERVISOR_shared_info = (void *)&xen_dummy_shared_info; |
| 39 | |
| 40 | DEFINE_PER_CPU(struct vcpu_info *, xen_vcpu); |
Stefano Stabellini | 9a9ab3c | 2013-04-25 16:17:04 +0000 | [diff] [blame] | 41 | static struct vcpu_info __percpu *xen_vcpu_info; |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 42 | |
Ian Campbell | c61ba72 | 2012-10-03 12:28:26 +0100 | [diff] [blame] | 43 | /* These are unused until we support booting "pre-ballooned" */ |
| 44 | unsigned long xen_released_pages; |
| 45 | struct xen_memory_region xen_extra_mem[XEN_EXTRA_MEM_MAX_REGIONS] __initdata; |
| 46 | |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 47 | /* TODO: to be removed */ |
| 48 | __read_mostly int xen_have_vector_callback; |
| 49 | EXPORT_SYMBOL_GPL(xen_have_vector_callback); |
| 50 | |
| 51 | int xen_platform_pci_unplug = XEN_UNPLUG_ALL; |
| 52 | EXPORT_SYMBOL_GPL(xen_platform_pci_unplug); |
| 53 | |
Stefano Stabellini | 0ec53ec | 2012-09-14 13:37:32 +0000 | [diff] [blame] | 54 | static __read_mostly int xen_events_irq = -1; |
| 55 | |
David Vrabel | 4e8c0c8 | 2015-03-11 14:49:57 +0000 | [diff] [blame] | 56 | int xen_remap_domain_mfn_array(struct vm_area_struct *vma, |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 57 | unsigned long addr, |
David Vrabel | 4e8c0c8 | 2015-03-11 14:49:57 +0000 | [diff] [blame] | 58 | xen_pfn_t *mfn, int nr, |
| 59 | int *err_ptr, pgprot_t prot, |
| 60 | unsigned domid, |
Ian Campbell | f832da0 | 2012-10-03 16:37:09 +0100 | [diff] [blame] | 61 | struct page **pages) |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 62 | { |
David Vrabel | 4e8c0c8 | 2015-03-11 14:49:57 +0000 | [diff] [blame] | 63 | return xen_xlate_remap_gfn_array(vma, addr, mfn, nr, err_ptr, |
David Vrabel | 628c28e | 2015-03-11 14:49:56 +0000 | [diff] [blame] | 64 | prot, domid, pages); |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 65 | } |
David Vrabel | 4e8c0c8 | 2015-03-11 14:49:57 +0000 | [diff] [blame] | 66 | EXPORT_SYMBOL_GPL(xen_remap_domain_mfn_array); |
| 67 | |
| 68 | /* Not used by XENFEAT_auto_translated guests. */ |
| 69 | int xen_remap_domain_mfn_range(struct vm_area_struct *vma, |
| 70 | unsigned long addr, |
| 71 | xen_pfn_t mfn, int nr, |
| 72 | pgprot_t prot, unsigned domid, |
| 73 | struct page **pages) |
| 74 | { |
| 75 | return -ENOSYS; |
| 76 | } |
Stefano Stabellini | 4c071ee | 2012-09-14 13:53:39 +0000 | [diff] [blame] | 77 | EXPORT_SYMBOL_GPL(xen_remap_domain_mfn_range); |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 78 | |
Ian Campbell | f832da0 | 2012-10-03 16:37:09 +0100 | [diff] [blame] | 79 | int xen_unmap_domain_mfn_range(struct vm_area_struct *vma, |
| 80 | int nr, struct page **pages) |
| 81 | { |
David Vrabel | 628c28e | 2015-03-11 14:49:56 +0000 | [diff] [blame] | 82 | return xen_xlate_unmap_gfn_range(vma, nr, pages); |
Ian Campbell | f832da0 | 2012-10-03 16:37:09 +0100 | [diff] [blame] | 83 | } |
| 84 | EXPORT_SYMBOL_GPL(xen_unmap_domain_mfn_range); |
| 85 | |
Julien Grall | 8b271d5 | 2014-01-30 12:52:59 +0000 | [diff] [blame] | 86 | static void xen_percpu_init(void) |
Stefano Stabellini | 9a9ab3c | 2013-04-25 16:17:04 +0000 | [diff] [blame] | 87 | { |
| 88 | struct vcpu_register_vcpu_info info; |
| 89 | struct vcpu_info *vcpup; |
| 90 | int err; |
Stefano Stabellini | 3cc8e40 | 2013-05-08 11:59:01 +0000 | [diff] [blame] | 91 | int cpu = get_cpu(); |
Stefano Stabellini | 9a9ab3c | 2013-04-25 16:17:04 +0000 | [diff] [blame] | 92 | |
| 93 | pr_info("Xen: initializing cpu%d\n", cpu); |
| 94 | vcpup = per_cpu_ptr(xen_vcpu_info, cpu); |
| 95 | |
| 96 | info.mfn = __pa(vcpup) >> PAGE_SHIFT; |
| 97 | info.offset = offset_in_page(vcpup); |
| 98 | |
| 99 | err = HYPERVISOR_vcpu_op(VCPUOP_register_vcpu_info, cpu, &info); |
Stefano Stabellini | d7266d7 | 2013-05-08 13:02:38 +0000 | [diff] [blame] | 100 | BUG_ON(err); |
| 101 | per_cpu(xen_vcpu, cpu) = vcpup; |
| 102 | |
Stefano Stabellini | 3cc8e40 | 2013-05-08 11:59:01 +0000 | [diff] [blame] | 103 | enable_percpu_irq(xen_events_irq, 0); |
Julien Grall | 0d7febe | 2013-07-29 17:06:05 +0100 | [diff] [blame] | 104 | put_cpu(); |
Stefano Stabellini | 9a9ab3c | 2013-04-25 16:17:04 +0000 | [diff] [blame] | 105 | } |
| 106 | |
Stefano Stabellini | 2451ade | 2013-07-21 15:17:54 +0000 | [diff] [blame] | 107 | static void xen_restart(enum reboot_mode reboot_mode, const char *cmd) |
Stefano Stabellini | 6abb749 | 2013-04-25 10:23:07 +0000 | [diff] [blame] | 108 | { |
| 109 | struct sched_shutdown r = { .reason = SHUTDOWN_reboot }; |
| 110 | int rc; |
| 111 | rc = HYPERVISOR_sched_op(SCHEDOP_shutdown, &r); |
Himangi Saraogi | a91c777 | 2014-07-25 12:05:39 -0400 | [diff] [blame] | 112 | BUG_ON(rc); |
Stefano Stabellini | 6abb749 | 2013-04-25 10:23:07 +0000 | [diff] [blame] | 113 | } |
| 114 | |
| 115 | static void xen_power_off(void) |
| 116 | { |
| 117 | struct sched_shutdown r = { .reason = SHUTDOWN_poweroff }; |
| 118 | int rc; |
| 119 | rc = HYPERVISOR_sched_op(SCHEDOP_shutdown, &r); |
Himangi Saraogi | a91c777 | 2014-07-25 12:05:39 -0400 | [diff] [blame] | 120 | BUG_ON(rc); |
Stefano Stabellini | 6abb749 | 2013-04-25 10:23:07 +0000 | [diff] [blame] | 121 | } |
| 122 | |
Julien Grall | 8b271d5 | 2014-01-30 12:52:59 +0000 | [diff] [blame] | 123 | static int xen_cpu_notification(struct notifier_block *self, |
| 124 | unsigned long action, |
| 125 | void *hcpu) |
| 126 | { |
| 127 | switch (action) { |
| 128 | case CPU_STARTING: |
| 129 | xen_percpu_init(); |
| 130 | break; |
| 131 | default: |
| 132 | break; |
| 133 | } |
| 134 | |
| 135 | return NOTIFY_OK; |
| 136 | } |
| 137 | |
| 138 | static struct notifier_block xen_cpu_notifier = { |
| 139 | .notifier_call = xen_cpu_notification, |
| 140 | }; |
| 141 | |
| 142 | static irqreturn_t xen_arm_callback(int irq, void *arg) |
| 143 | { |
| 144 | xen_hvm_evtchn_do_upcall(); |
| 145 | return IRQ_HANDLED; |
| 146 | } |
| 147 | |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 148 | /* |
| 149 | * see Documentation/devicetree/bindings/arm/xen.txt for the |
| 150 | * documentation of the Xen Device Tree format. |
| 151 | */ |
Stefano Stabellini | b3b52fd | 2012-09-13 12:06:52 +0000 | [diff] [blame] | 152 | #define GRANT_TABLE_PHYSADDR 0 |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 153 | static int __init xen_guest_init(void) |
| 154 | { |
| 155 | struct xen_add_to_physmap xatp; |
| 156 | static struct shared_info *shared_info_page = 0; |
| 157 | struct device_node *node; |
| 158 | int len; |
| 159 | const char *s = NULL; |
| 160 | const char *version = NULL; |
| 161 | const char *xen_prefix = "xen,xen-"; |
Stefano Stabellini | b3b52fd | 2012-09-13 12:06:52 +0000 | [diff] [blame] | 162 | struct resource res; |
Julien Grall | 47c5420 | 2014-01-30 12:56:34 +0000 | [diff] [blame] | 163 | phys_addr_t grant_frames; |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 164 | |
| 165 | node = of_find_compatible_node(NULL, NULL, "xen,xen"); |
| 166 | if (!node) { |
| 167 | pr_debug("No Xen support\n"); |
| 168 | return 0; |
| 169 | } |
| 170 | s = of_get_property(node, "compatible", &len); |
| 171 | if (strlen(xen_prefix) + 3 < len && |
| 172 | !strncmp(xen_prefix, s, strlen(xen_prefix))) |
| 173 | version = s + strlen(xen_prefix); |
| 174 | if (version == NULL) { |
| 175 | pr_debug("Xen version not found\n"); |
| 176 | return 0; |
| 177 | } |
Stefano Stabellini | b3b52fd | 2012-09-13 12:06:52 +0000 | [diff] [blame] | 178 | if (of_address_to_resource(node, GRANT_TABLE_PHYSADDR, &res)) |
| 179 | return 0; |
Konrad Rzeszutek Wilk | efaf30a | 2014-01-06 10:40:36 -0500 | [diff] [blame] | 180 | grant_frames = res.start; |
Stefano Stabellini | 0ec53ec | 2012-09-14 13:37:32 +0000 | [diff] [blame] | 181 | xen_events_irq = irq_of_parse_and_map(node, 0); |
Julien Grall | 47c5420 | 2014-01-30 12:56:34 +0000 | [diff] [blame] | 182 | pr_info("Xen %s support found, events_irq=%d gnttab_frame=%pa\n", |
| 183 | version, xen_events_irq, &grant_frames); |
Julien Grall | 8b271d5 | 2014-01-30 12:52:59 +0000 | [diff] [blame] | 184 | |
| 185 | if (xen_events_irq < 0) |
| 186 | return -ENODEV; |
| 187 | |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 188 | xen_domain_type = XEN_HVM_DOMAIN; |
| 189 | |
Stefano Stabellini | ef61ee0d | 2012-08-08 17:20:18 +0000 | [diff] [blame] | 190 | xen_setup_features(); |
Stefano Stabellini | 5ebc77d | 2014-09-10 22:49:30 +0000 | [diff] [blame] | 191 | |
Stefano Stabellini | ef61ee0d | 2012-08-08 17:20:18 +0000 | [diff] [blame] | 192 | if (xen_feature(XENFEAT_dom0)) |
| 193 | xen_start_info->flags |= SIF_INITDOMAIN|SIF_PRIVILEGED; |
| 194 | else |
| 195 | xen_start_info->flags &= ~(SIF_INITDOMAIN|SIF_PRIVILEGED); |
| 196 | |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 197 | if (!shared_info_page) |
| 198 | shared_info_page = (struct shared_info *) |
| 199 | get_zeroed_page(GFP_KERNEL); |
| 200 | if (!shared_info_page) { |
| 201 | pr_err("not enough memory\n"); |
| 202 | return -ENOMEM; |
| 203 | } |
| 204 | xatp.domid = DOMID_SELF; |
| 205 | xatp.idx = 0; |
| 206 | xatp.space = XENMAPSPACE_shared_info; |
| 207 | xatp.gpfn = __pa(shared_info_page) >> PAGE_SHIFT; |
| 208 | if (HYPERVISOR_memory_op(XENMEM_add_to_physmap, &xatp)) |
| 209 | BUG(); |
| 210 | |
| 211 | HYPERVISOR_shared_info = (struct shared_info *)shared_info_page; |
| 212 | |
| 213 | /* xen_vcpu is a pointer to the vcpu_info struct in the shared_info |
| 214 | * 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] | 215 | * related functions. |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 216 | * The shared info contains exactly 1 CPU (the boot CPU). The guest |
| 217 | * is required to use VCPUOP_register_vcpu_info to place vcpu info |
Stefano Stabellini | 9a9ab3c | 2013-04-25 16:17:04 +0000 | [diff] [blame] | 218 | * for secondary CPUs as they are brought up. |
| 219 | * For uniformity we use VCPUOP_register_vcpu_info even on cpu0. |
| 220 | */ |
| 221 | xen_vcpu_info = __alloc_percpu(sizeof(struct vcpu_info), |
| 222 | sizeof(struct vcpu_info)); |
| 223 | if (xen_vcpu_info == NULL) |
| 224 | return -ENOMEM; |
Stefano Stabellini | b3b52fd | 2012-09-13 12:06:52 +0000 | [diff] [blame] | 225 | |
Konrad Rzeszutek Wilk | efaf30a | 2014-01-06 10:40:36 -0500 | [diff] [blame] | 226 | if (gnttab_setup_auto_xlat_frames(grant_frames)) { |
| 227 | free_percpu(xen_vcpu_info); |
| 228 | return -ENOMEM; |
| 229 | } |
Stefano Stabellini | b3b52fd | 2012-09-13 12:06:52 +0000 | [diff] [blame] | 230 | gnttab_init(); |
| 231 | if (!xen_initial_domain()) |
| 232 | xenbus_probe(NULL); |
| 233 | |
Julien Grall | e1a9c16 | 2013-09-09 11:35:26 +0000 | [diff] [blame] | 234 | /* |
| 235 | * Making sure board specific code will not set up ops for |
| 236 | * cpu idle and cpu freq. |
| 237 | */ |
| 238 | disable_cpuidle(); |
| 239 | disable_cpufreq(); |
| 240 | |
Julien Grall | 8b271d5 | 2014-01-30 12:52:59 +0000 | [diff] [blame] | 241 | xen_init_IRQ(); |
| 242 | |
| 243 | if (request_percpu_irq(xen_events_irq, xen_arm_callback, |
| 244 | "events", &xen_vcpu)) { |
| 245 | pr_err("Error request IRQ %d\n", xen_events_irq); |
| 246 | return -EINVAL; |
| 247 | } |
| 248 | |
| 249 | xen_percpu_init(); |
| 250 | |
| 251 | register_cpu_notifier(&xen_cpu_notifier); |
| 252 | |
Stefano Stabellini | 1aa3d8d | 2013-05-08 11:59:01 +0000 | [diff] [blame] | 253 | return 0; |
| 254 | } |
Julien Grall | 8b271d5 | 2014-01-30 12:52:59 +0000 | [diff] [blame] | 255 | early_initcall(xen_guest_init); |
Stefano Stabellini | 1aa3d8d | 2013-05-08 11:59:01 +0000 | [diff] [blame] | 256 | |
| 257 | static int __init xen_pm_init(void) |
| 258 | { |
Rob Herring | 9dd4b29 | 2013-08-29 07:43:52 -0500 | [diff] [blame] | 259 | if (!xen_domain()) |
| 260 | return -ENODEV; |
| 261 | |
Stefano Stabellini | 6abb749 | 2013-04-25 10:23:07 +0000 | [diff] [blame] | 262 | pm_power_off = xen_power_off; |
| 263 | arm_pm_restart = xen_restart; |
| 264 | |
Stefano Stabellini | 2e01f16 | 2012-09-14 10:47:52 +0000 | [diff] [blame] | 265 | return 0; |
| 266 | } |
Rob Herring | 9dd4b29 | 2013-08-29 07:43:52 -0500 | [diff] [blame] | 267 | late_initcall(xen_pm_init); |
Stefano Stabellini | 0ec53ec | 2012-09-14 13:37:32 +0000 | [diff] [blame] | 268 | |
Stefano Stabellini | 7939028 | 2014-05-08 16:54:02 +0100 | [diff] [blame] | 269 | |
| 270 | /* empty stubs */ |
| 271 | void xen_arch_pre_suspend(void) { } |
| 272 | void xen_arch_post_suspend(int suspend_cancelled) { } |
| 273 | void xen_timer_resume(void) { } |
| 274 | void xen_arch_resume(void) { } |
Boris Ostrovsky | ffb7dbe | 2015-05-07 12:55:23 -0400 | [diff] [blame] | 275 | void xen_arch_suspend(void) { } |
Stefano Stabellini | 7939028 | 2014-05-08 16:54:02 +0100 | [diff] [blame] | 276 | |
| 277 | |
Konrad Rzeszutek Wilk | 911dec0 | 2012-11-06 17:06:52 -0500 | [diff] [blame] | 278 | /* In the hypervisor.S file. */ |
| 279 | EXPORT_SYMBOL_GPL(HYPERVISOR_event_channel_op); |
| 280 | EXPORT_SYMBOL_GPL(HYPERVISOR_grant_table_op); |
Stefano Stabellini | ab277bb | 2012-11-08 15:58:55 +0000 | [diff] [blame] | 281 | EXPORT_SYMBOL_GPL(HYPERVISOR_xen_version); |
| 282 | EXPORT_SYMBOL_GPL(HYPERVISOR_console_io); |
| 283 | EXPORT_SYMBOL_GPL(HYPERVISOR_sched_op); |
| 284 | EXPORT_SYMBOL_GPL(HYPERVISOR_hvm_op); |
| 285 | EXPORT_SYMBOL_GPL(HYPERVISOR_memory_op); |
| 286 | EXPORT_SYMBOL_GPL(HYPERVISOR_physdev_op); |
Stefano Stabellini | ea0af61 | 2013-04-25 13:53:05 +0000 | [diff] [blame] | 287 | EXPORT_SYMBOL_GPL(HYPERVISOR_vcpu_op); |
Stefano Stabellini | 176455e | 2013-07-02 10:42:40 +0000 | [diff] [blame] | 288 | EXPORT_SYMBOL_GPL(HYPERVISOR_tmem_op); |
Ian Campbell | 9f1d3414 | 2014-05-09 16:10:49 +0000 | [diff] [blame] | 289 | EXPORT_SYMBOL_GPL(HYPERVISOR_multicall); |
Konrad Rzeszutek Wilk | 911dec0 | 2012-11-06 17:06:52 -0500 | [diff] [blame] | 290 | EXPORT_SYMBOL_GPL(privcmd_call); |