2 * Copyright (c) 2009, Microsoft Corporation.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15 * Place - Suite 330, Boston, MA 02111-1307 USA.
18 * Haiyang Zhang <haiyangz@microsoft.com>
19 * Hank Janssen <hjanssen@microsoft.com>
22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24 #include <linux/kernel.h>
26 #include <linux/slab.h>
27 #include <linux/vmalloc.h>
28 #include <linux/hyperv.h>
29 #include <asm/hyperv.h>
30 #include "hyperv_vmbus.h"
32 /* The one and only */
33 struct hv_context hv_context = {
34 .synic_initialized = false,
35 .hypercall_page = NULL,
36 .signal_event_param = NULL,
37 .signal_event_buffer = NULL,
41 * query_hypervisor_presence
42 * - Query the cpuid for presence of windows hypervisor
44 static int query_hypervisor_presence(void)
56 op = HVCPUID_VERSION_FEATURES;
57 cpuid(op, &eax, &ebx, &ecx, &edx);
59 return ecx & HV_PRESENT_BIT;
63 * query_hypervisor_info - Get version info of the windows hypervisor
65 static int query_hypervisor_info(void)
71 unsigned int max_leaf;
75 * Its assumed that this is called after confirming that Viridian
76 * is present. Query id and revision.
82 op = HVCPUID_VENDOR_MAXFUNCTION;
83 cpuid(op, &eax, &ebx, &ecx, &edx);
87 if (max_leaf >= HVCPUID_VERSION) {
93 cpuid(op, &eax, &ebx, &ecx, &edx);
94 pr_info("Hyper-V Host OS Build:%d-%d.%d-%d-%d.%d\n",
106 * do_hypercall- Invoke the specified hypercall
108 static u64 do_hypercall(u64 control, void *input, void *output)
112 u64 input_address = (input) ? virt_to_phys(input) : 0;
113 u64 output_address = (output) ? virt_to_phys(output) : 0;
114 void *hypercall_page = hv_context.hypercall_page;
116 __asm__ __volatile__("mov %0, %%r8" : : "r" (output_address) : "r8");
117 __asm__ __volatile__("call *%3" : "=a" (hv_status) :
118 "c" (control), "d" (input_address),
119 "m" (hypercall_page));
125 u32 control_hi = control >> 32;
126 u32 control_lo = control & 0xFFFFFFFF;
127 u32 hv_status_hi = 1;
128 u32 hv_status_lo = 1;
129 u64 input_address = (input) ? virt_to_phys(input) : 0;
130 u32 input_address_hi = input_address >> 32;
131 u32 input_address_lo = input_address & 0xFFFFFFFF;
132 u64 output_address = (output) ? virt_to_phys(output) : 0;
133 u32 output_address_hi = output_address >> 32;
134 u32 output_address_lo = output_address & 0xFFFFFFFF;
135 void *hypercall_page = hv_context.hypercall_page;
137 __asm__ __volatile__ ("call *%8" : "=d"(hv_status_hi),
138 "=a"(hv_status_lo) : "d" (control_hi),
139 "a" (control_lo), "b" (input_address_hi),
140 "c" (input_address_lo), "D"(output_address_hi),
141 "S"(output_address_lo), "m" (hypercall_page));
143 return hv_status_lo | ((u64)hv_status_hi << 32);
148 * hv_init - Main initialization routine.
150 * This routine must be called before any other routines in here are called
155 union hv_x64_msr_hypercall_contents hypercall_msr;
156 void *virtaddr = NULL;
158 memset(hv_context.synic_event_page, 0, sizeof(void *) * MAX_NUM_CPUS);
159 memset(hv_context.synic_message_page, 0,
160 sizeof(void *) * MAX_NUM_CPUS);
161 memset(hv_context.post_msg_page, 0,
162 sizeof(void *) * MAX_NUM_CPUS);
164 if (!query_hypervisor_presence())
167 max_leaf = query_hypervisor_info();
169 rdmsrl(HV_X64_MSR_GUEST_OS_ID, hv_context.guestid);
171 if (hv_context.guestid != 0)
174 /* Write our OS info */
175 wrmsrl(HV_X64_MSR_GUEST_OS_ID, HV_LINUX_GUEST_ID);
176 hv_context.guestid = HV_LINUX_GUEST_ID;
178 /* See if the hypercall page is already set */
179 rdmsrl(HV_X64_MSR_HYPERCALL, hypercall_msr.as_uint64);
181 virtaddr = __vmalloc(PAGE_SIZE, GFP_KERNEL, PAGE_KERNEL_EXEC);
186 hypercall_msr.enable = 1;
188 hypercall_msr.guest_physical_address = vmalloc_to_pfn(virtaddr);
189 wrmsrl(HV_X64_MSR_HYPERCALL, hypercall_msr.as_uint64);
191 /* Confirm that hypercall page did get setup. */
192 hypercall_msr.as_uint64 = 0;
193 rdmsrl(HV_X64_MSR_HYPERCALL, hypercall_msr.as_uint64);
195 if (!hypercall_msr.enable)
198 hv_context.hypercall_page = virtaddr;
200 /* Setup the global signal event param for the signal event hypercall */
201 hv_context.signal_event_buffer =
202 kmalloc(sizeof(struct hv_input_signal_event_buffer),
204 if (!hv_context.signal_event_buffer)
207 hv_context.signal_event_param =
208 (struct hv_input_signal_event *)
209 (ALIGN((unsigned long)
210 hv_context.signal_event_buffer,
211 HV_HYPERCALL_PARAM_ALIGN));
212 hv_context.signal_event_param->connectionid.asu32 = 0;
213 hv_context.signal_event_param->connectionid.u.id =
214 VMBUS_EVENT_CONNECTION_ID;
215 hv_context.signal_event_param->flag_number = 0;
216 hv_context.signal_event_param->rsvdz = 0;
222 if (hypercall_msr.enable) {
223 hypercall_msr.as_uint64 = 0;
224 wrmsrl(HV_X64_MSR_HYPERCALL, hypercall_msr.as_uint64);
234 * hv_cleanup - Cleanup routine.
236 * This routine is called normally during driver unloading or exiting.
238 void hv_cleanup(void)
240 union hv_x64_msr_hypercall_contents hypercall_msr;
242 kfree(hv_context.signal_event_buffer);
243 hv_context.signal_event_buffer = NULL;
244 hv_context.signal_event_param = NULL;
246 if (hv_context.hypercall_page) {
247 hypercall_msr.as_uint64 = 0;
248 wrmsrl(HV_X64_MSR_HYPERCALL, hypercall_msr.as_uint64);
249 vfree(hv_context.hypercall_page);
250 hv_context.hypercall_page = NULL;
255 * hv_post_message - Post a message using the hypervisor message IPC.
257 * This involves a hypercall.
259 u16 hv_post_message(union hv_connection_id connection_id,
260 enum hv_message_type message_type,
261 void *payload, size_t payload_size)
264 struct hv_input_post_message *aligned_msg;
267 if (payload_size > HV_MESSAGE_PAYLOAD_BYTE_COUNT)
270 aligned_msg = (struct hv_input_post_message *)
271 hv_context.post_msg_page[get_cpu()];
273 aligned_msg->connectionid = connection_id;
274 aligned_msg->reserved = 0;
275 aligned_msg->message_type = message_type;
276 aligned_msg->payload_size = payload_size;
277 memcpy((void *)aligned_msg->payload, payload, payload_size);
279 status = do_hypercall(HVCALL_POST_MESSAGE, aligned_msg, NULL)
289 * Signal an event on the specified connection using the hypervisor event IPC.
291 * This involves a hypercall.
293 u16 hv_signal_event(void)
297 status = do_hypercall(HVCALL_SIGNAL_EVENT,
298 hv_context.signal_event_param,
304 * hv_synic_init - Initialize the Synthethic Interrupt Controller.
306 * If it is already initialized by another entity (ie x2v shim), we need to
307 * retrieve the initialized message and event pages. Otherwise, we create and
308 * initialize the message and event pages.
310 void hv_synic_init(void *irqarg)
313 union hv_synic_simp simp;
314 union hv_synic_siefp siefp;
315 union hv_synic_sint shared_sint;
316 union hv_synic_scontrol sctrl;
318 u32 irq_vector = *((u32 *)(irqarg));
319 int cpu = smp_processor_id();
321 if (!hv_context.hypercall_page)
324 /* Check the version */
325 rdmsrl(HV_X64_MSR_SVERSION, version);
327 hv_context.synic_message_page[cpu] =
328 (void *)get_zeroed_page(GFP_ATOMIC);
330 if (hv_context.synic_message_page[cpu] == NULL) {
331 pr_err("Unable to allocate SYNIC message page\n");
335 hv_context.synic_event_page[cpu] =
336 (void *)get_zeroed_page(GFP_ATOMIC);
338 if (hv_context.synic_event_page[cpu] == NULL) {
339 pr_err("Unable to allocate SYNIC event page\n");
343 hv_context.post_msg_page[cpu] =
344 (void *)get_zeroed_page(GFP_ATOMIC);
346 if (hv_context.post_msg_page[cpu] == NULL) {
347 pr_err("Unable to allocate post msg page\n");
351 /* Setup the Synic's message page */
352 rdmsrl(HV_X64_MSR_SIMP, simp.as_uint64);
353 simp.simp_enabled = 1;
354 simp.base_simp_gpa = virt_to_phys(hv_context.synic_message_page[cpu])
357 wrmsrl(HV_X64_MSR_SIMP, simp.as_uint64);
359 /* Setup the Synic's event page */
360 rdmsrl(HV_X64_MSR_SIEFP, siefp.as_uint64);
361 siefp.siefp_enabled = 1;
362 siefp.base_siefp_gpa = virt_to_phys(hv_context.synic_event_page[cpu])
365 wrmsrl(HV_X64_MSR_SIEFP, siefp.as_uint64);
367 /* Setup the shared SINT. */
368 rdmsrl(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, shared_sint.as_uint64);
370 shared_sint.as_uint64 = 0;
371 shared_sint.vector = irq_vector; /* HV_SHARED_SINT_IDT_VECTOR + 0x20; */
372 shared_sint.masked = false;
373 shared_sint.auto_eoi = false;
375 wrmsrl(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, shared_sint.as_uint64);
377 /* Enable the global synic bit */
378 rdmsrl(HV_X64_MSR_SCONTROL, sctrl.as_uint64);
381 wrmsrl(HV_X64_MSR_SCONTROL, sctrl.as_uint64);
383 hv_context.synic_initialized = true;
387 if (hv_context.synic_event_page[cpu])
388 free_page((unsigned long)hv_context.synic_event_page[cpu]);
390 if (hv_context.synic_message_page[cpu])
391 free_page((unsigned long)hv_context.synic_message_page[cpu]);
392 if (hv_context.post_msg_page[cpu])
393 free_page((unsigned long)hv_context.post_msg_page[cpu]);
398 * hv_synic_cleanup - Cleanup routine for hv_synic_init().
400 void hv_synic_cleanup(void *arg)
402 union hv_synic_sint shared_sint;
403 union hv_synic_simp simp;
404 union hv_synic_siefp siefp;
405 int cpu = smp_processor_id();
407 if (!hv_context.synic_initialized)
410 rdmsrl(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, shared_sint.as_uint64);
412 shared_sint.masked = 1;
414 /* Need to correctly cleanup in the case of SMP!!! */
415 /* Disable the interrupt */
416 wrmsrl(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, shared_sint.as_uint64);
418 rdmsrl(HV_X64_MSR_SIMP, simp.as_uint64);
419 simp.simp_enabled = 0;
420 simp.base_simp_gpa = 0;
422 wrmsrl(HV_X64_MSR_SIMP, simp.as_uint64);
424 rdmsrl(HV_X64_MSR_SIEFP, siefp.as_uint64);
425 siefp.siefp_enabled = 0;
426 siefp.base_siefp_gpa = 0;
428 wrmsrl(HV_X64_MSR_SIEFP, siefp.as_uint64);
430 free_page((unsigned long)hv_context.synic_message_page[cpu]);
431 free_page((unsigned long)hv_context.synic_event_page[cpu]);
432 free_page((unsigned long)hv_context.post_msg_page[cpu]);