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 <linux/version.h>
30 #include <asm/hyperv.h>
31 #include "hyperv_vmbus.h"
33 /* The one and only */
34 struct hv_context hv_context
= {
35 .synic_initialized
= false,
36 .hypercall_page
= NULL
,
37 .signal_event_param
= NULL
,
38 .signal_event_buffer
= NULL
,
42 * query_hypervisor_presence
43 * - Query the cpuid for presence of windows hypervisor
45 static int query_hypervisor_presence(void)
57 op
= HVCPUID_VERSION_FEATURES
;
58 cpuid(op
, &eax
, &ebx
, &ecx
, &edx
);
60 return ecx
& HV_PRESENT_BIT
;
64 * query_hypervisor_info - Get version info of the windows hypervisor
66 static int query_hypervisor_info(void)
72 unsigned int max_leaf
;
76 * Its assumed that this is called after confirming that Viridian
77 * is present. Query id and revision.
83 op
= HVCPUID_VENDOR_MAXFUNCTION
;
84 cpuid(op
, &eax
, &ebx
, &ecx
, &edx
);
88 if (max_leaf
>= HVCPUID_VERSION
) {
94 cpuid(op
, &eax
, &ebx
, &ecx
, &edx
);
95 pr_info("Hyper-V Host OS Build:%d-%d.%d-%d-%d.%d\n",
107 * do_hypercall- Invoke the specified hypercall
109 static u64
do_hypercall(u64 control
, void *input
, void *output
)
113 u64 input_address
= (input
) ? virt_to_phys(input
) : 0;
114 u64 output_address
= (output
) ? virt_to_phys(output
) : 0;
115 void *hypercall_page
= hv_context
.hypercall_page
;
117 __asm__
__volatile__("mov %0, %%r8" : : "r" (output_address
) : "r8");
118 __asm__
__volatile__("call *%3" : "=a" (hv_status
) :
119 "c" (control
), "d" (input_address
),
120 "m" (hypercall_page
));
126 u32 control_hi
= control
>> 32;
127 u32 control_lo
= control
& 0xFFFFFFFF;
128 u32 hv_status_hi
= 1;
129 u32 hv_status_lo
= 1;
130 u64 input_address
= (input
) ? virt_to_phys(input
) : 0;
131 u32 input_address_hi
= input_address
>> 32;
132 u32 input_address_lo
= input_address
& 0xFFFFFFFF;
133 u64 output_address
= (output
) ? virt_to_phys(output
) : 0;
134 u32 output_address_hi
= output_address
>> 32;
135 u32 output_address_lo
= output_address
& 0xFFFFFFFF;
136 void *hypercall_page
= hv_context
.hypercall_page
;
138 __asm__
__volatile__ ("call *%8" : "=d"(hv_status_hi
),
139 "=a"(hv_status_lo
) : "d" (control_hi
),
140 "a" (control_lo
), "b" (input_address_hi
),
141 "c" (input_address_lo
), "D"(output_address_hi
),
142 "S"(output_address_lo
), "m" (hypercall_page
));
144 return hv_status_lo
| ((u64
)hv_status_hi
<< 32);
149 * hv_init - Main initialization routine.
151 * This routine must be called before any other routines in here are called
156 union hv_x64_msr_hypercall_contents hypercall_msr
;
157 void *virtaddr
= NULL
;
159 memset(hv_context
.synic_event_page
, 0, sizeof(void *) * NR_CPUS
);
160 memset(hv_context
.synic_message_page
, 0,
161 sizeof(void *) * NR_CPUS
);
163 if (!query_hypervisor_presence())
166 max_leaf
= query_hypervisor_info();
171 hv_context
.guestid
= generate_guest_id(0, LINUX_VERSION_CODE
, 0);
172 wrmsrl(HV_X64_MSR_GUEST_OS_ID
, hv_context
.guestid
);
174 /* See if the hypercall page is already set */
175 rdmsrl(HV_X64_MSR_HYPERCALL
, hypercall_msr
.as_uint64
);
177 virtaddr
= __vmalloc(PAGE_SIZE
, GFP_KERNEL
, PAGE_KERNEL_EXEC
);
182 hypercall_msr
.enable
= 1;
184 hypercall_msr
.guest_physical_address
= vmalloc_to_pfn(virtaddr
);
185 wrmsrl(HV_X64_MSR_HYPERCALL
, hypercall_msr
.as_uint64
);
187 /* Confirm that hypercall page did get setup. */
188 hypercall_msr
.as_uint64
= 0;
189 rdmsrl(HV_X64_MSR_HYPERCALL
, hypercall_msr
.as_uint64
);
191 if (!hypercall_msr
.enable
)
194 hv_context
.hypercall_page
= virtaddr
;
196 /* Setup the global signal event param for the signal event hypercall */
197 hv_context
.signal_event_buffer
=
198 kmalloc(sizeof(struct hv_input_signal_event_buffer
),
200 if (!hv_context
.signal_event_buffer
)
203 hv_context
.signal_event_param
=
204 (struct hv_input_signal_event
*)
205 (ALIGN((unsigned long)
206 hv_context
.signal_event_buffer
,
207 HV_HYPERCALL_PARAM_ALIGN
));
208 hv_context
.signal_event_param
->connectionid
.asu32
= 0;
209 hv_context
.signal_event_param
->connectionid
.u
.id
=
210 VMBUS_EVENT_CONNECTION_ID
;
211 hv_context
.signal_event_param
->flag_number
= 0;
212 hv_context
.signal_event_param
->rsvdz
= 0;
218 if (hypercall_msr
.enable
) {
219 hypercall_msr
.as_uint64
= 0;
220 wrmsrl(HV_X64_MSR_HYPERCALL
, hypercall_msr
.as_uint64
);
230 * hv_cleanup - Cleanup routine.
232 * This routine is called normally during driver unloading or exiting.
234 void hv_cleanup(void)
236 union hv_x64_msr_hypercall_contents hypercall_msr
;
238 /* Reset our OS id */
239 wrmsrl(HV_X64_MSR_GUEST_OS_ID
, 0);
241 kfree(hv_context
.signal_event_buffer
);
242 hv_context
.signal_event_buffer
= NULL
;
243 hv_context
.signal_event_param
= NULL
;
245 if (hv_context
.hypercall_page
) {
246 hypercall_msr
.as_uint64
= 0;
247 wrmsrl(HV_X64_MSR_HYPERCALL
, hypercall_msr
.as_uint64
);
248 vfree(hv_context
.hypercall_page
);
249 hv_context
.hypercall_page
= NULL
;
254 * hv_post_message - Post a message using the hypervisor message IPC.
256 * This involves a hypercall.
258 int hv_post_message(union hv_connection_id connection_id
,
259 enum hv_message_type message_type
,
260 void *payload
, size_t payload_size
)
262 struct aligned_input
{
264 struct hv_input_post_message msg
;
267 struct hv_input_post_message
*aligned_msg
;
271 if (payload_size
> HV_MESSAGE_PAYLOAD_BYTE_COUNT
)
274 addr
= (unsigned long)kmalloc(sizeof(struct aligned_input
), GFP_ATOMIC
);
278 aligned_msg
= (struct hv_input_post_message
*)
279 (ALIGN(addr
, HV_HYPERCALL_PARAM_ALIGN
));
281 aligned_msg
->connectionid
= connection_id
;
282 aligned_msg
->message_type
= message_type
;
283 aligned_msg
->payload_size
= payload_size
;
284 memcpy((void *)aligned_msg
->payload
, payload
, payload_size
);
286 status
= do_hypercall(HVCALL_POST_MESSAGE
, aligned_msg
, NULL
)
297 * Signal an event on the specified connection using the hypervisor event IPC.
299 * This involves a hypercall.
301 u16
hv_signal_event(void)
305 status
= do_hypercall(HVCALL_SIGNAL_EVENT
,
306 hv_context
.signal_event_param
,
312 * hv_synic_init - Initialize the Synthethic Interrupt Controller.
314 * If it is already initialized by another entity (ie x2v shim), we need to
315 * retrieve the initialized message and event pages. Otherwise, we create and
316 * initialize the message and event pages.
318 void hv_synic_init(void *irqarg
)
321 union hv_synic_simp simp
;
322 union hv_synic_siefp siefp
;
323 union hv_synic_sint shared_sint
;
324 union hv_synic_scontrol sctrl
;
326 u32 irq_vector
= *((u32
*)(irqarg
));
327 int cpu
= smp_processor_id();
329 if (!hv_context
.hypercall_page
)
332 /* Check the version */
333 rdmsrl(HV_X64_MSR_SVERSION
, version
);
335 hv_context
.synic_message_page
[cpu
] =
336 (void *)get_zeroed_page(GFP_ATOMIC
);
338 if (hv_context
.synic_message_page
[cpu
] == NULL
) {
339 pr_err("Unable to allocate SYNIC message page\n");
343 hv_context
.synic_event_page
[cpu
] =
344 (void *)get_zeroed_page(GFP_ATOMIC
);
346 if (hv_context
.synic_event_page
[cpu
] == NULL
) {
347 pr_err("Unable to allocate SYNIC event 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
]);
396 * hv_synic_cleanup - Cleanup routine for hv_synic_init().
398 void hv_synic_cleanup(void *arg
)
400 union hv_synic_sint shared_sint
;
401 union hv_synic_simp simp
;
402 union hv_synic_siefp siefp
;
403 int cpu
= smp_processor_id();
405 if (!hv_context
.synic_initialized
)
408 rdmsrl(HV_X64_MSR_SINT0
+ VMBUS_MESSAGE_SINT
, shared_sint
.as_uint64
);
410 shared_sint
.masked
= 1;
412 /* Need to correctly cleanup in the case of SMP!!! */
413 /* Disable the interrupt */
414 wrmsrl(HV_X64_MSR_SINT0
+ VMBUS_MESSAGE_SINT
, shared_sint
.as_uint64
);
416 rdmsrl(HV_X64_MSR_SIMP
, simp
.as_uint64
);
417 simp
.simp_enabled
= 0;
418 simp
.base_simp_gpa
= 0;
420 wrmsrl(HV_X64_MSR_SIMP
, simp
.as_uint64
);
422 rdmsrl(HV_X64_MSR_SIEFP
, siefp
.as_uint64
);
423 siefp
.siefp_enabled
= 0;
424 siefp
.base_siefp_gpa
= 0;
426 wrmsrl(HV_X64_MSR_SIEFP
, siefp
.as_uint64
);
428 free_page((unsigned long)hv_context
.synic_message_page
[cpu
]);
429 free_page((unsigned long)hv_context
.synic_event_page
[cpu
]);