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 <linux/interrupt.h>
31 #include <asm/hyperv.h>
32 #include "hyperv_vmbus.h"
34 /* The one and only */
35 struct hv_context hv_context
= {
36 .synic_initialized
= false,
37 .hypercall_page
= NULL
,
41 * query_hypervisor_info - Get version info of the windows hypervisor
43 unsigned int host_info_eax
;
44 unsigned int host_info_ebx
;
45 unsigned int host_info_ecx
;
46 unsigned int host_info_edx
;
48 static int query_hypervisor_info(void)
54 unsigned int max_leaf
;
58 * Its assumed that this is called after confirming that Viridian
59 * is present. Query id and revision.
65 op
= HVCPUID_VENDOR_MAXFUNCTION
;
66 cpuid(op
, &eax
, &ebx
, &ecx
, &edx
);
70 if (max_leaf
>= HVCPUID_VERSION
) {
76 cpuid(op
, &eax
, &ebx
, &ecx
, &edx
);
86 * do_hypercall- Invoke the specified hypercall
88 static u64
do_hypercall(u64 control
, void *input
, void *output
)
92 u64 input_address
= (input
) ? virt_to_phys(input
) : 0;
93 u64 output_address
= (output
) ? virt_to_phys(output
) : 0;
94 void *hypercall_page
= hv_context
.hypercall_page
;
96 __asm__
__volatile__("mov %0, %%r8" : : "r" (output_address
) : "r8");
97 __asm__
__volatile__("call *%3" : "=a" (hv_status
) :
98 "c" (control
), "d" (input_address
),
99 "m" (hypercall_page
));
105 u32 control_hi
= control
>> 32;
106 u32 control_lo
= control
& 0xFFFFFFFF;
107 u32 hv_status_hi
= 1;
108 u32 hv_status_lo
= 1;
109 u64 input_address
= (input
) ? virt_to_phys(input
) : 0;
110 u32 input_address_hi
= input_address
>> 32;
111 u32 input_address_lo
= input_address
& 0xFFFFFFFF;
112 u64 output_address
= (output
) ? virt_to_phys(output
) : 0;
113 u32 output_address_hi
= output_address
>> 32;
114 u32 output_address_lo
= output_address
& 0xFFFFFFFF;
115 void *hypercall_page
= hv_context
.hypercall_page
;
117 __asm__
__volatile__ ("call *%8" : "=d"(hv_status_hi
),
118 "=a"(hv_status_lo
) : "d" (control_hi
),
119 "a" (control_lo
), "b" (input_address_hi
),
120 "c" (input_address_lo
), "D"(output_address_hi
),
121 "S"(output_address_lo
), "m" (hypercall_page
));
123 return hv_status_lo
| ((u64
)hv_status_hi
<< 32);
128 * hv_init - Main initialization routine.
130 * This routine must be called before any other routines in here are called
135 union hv_x64_msr_hypercall_contents hypercall_msr
;
136 void *virtaddr
= NULL
;
138 memset(hv_context
.synic_event_page
, 0, sizeof(void *) * NR_CPUS
);
139 memset(hv_context
.synic_message_page
, 0,
140 sizeof(void *) * NR_CPUS
);
141 memset(hv_context
.vp_index
, 0,
142 sizeof(int) * NR_CPUS
);
143 memset(hv_context
.event_dpc
, 0,
144 sizeof(void *) * NR_CPUS
);
146 max_leaf
= query_hypervisor_info();
151 hv_context
.guestid
= generate_guest_id(0, LINUX_VERSION_CODE
, 0);
152 wrmsrl(HV_X64_MSR_GUEST_OS_ID
, hv_context
.guestid
);
154 /* See if the hypercall page is already set */
155 rdmsrl(HV_X64_MSR_HYPERCALL
, hypercall_msr
.as_uint64
);
157 virtaddr
= __vmalloc(PAGE_SIZE
, GFP_KERNEL
, PAGE_KERNEL_EXEC
);
162 hypercall_msr
.enable
= 1;
164 hypercall_msr
.guest_physical_address
= vmalloc_to_pfn(virtaddr
);
165 wrmsrl(HV_X64_MSR_HYPERCALL
, hypercall_msr
.as_uint64
);
167 /* Confirm that hypercall page did get setup. */
168 hypercall_msr
.as_uint64
= 0;
169 rdmsrl(HV_X64_MSR_HYPERCALL
, hypercall_msr
.as_uint64
);
171 if (!hypercall_msr
.enable
)
174 hv_context
.hypercall_page
= virtaddr
;
180 if (hypercall_msr
.enable
) {
181 hypercall_msr
.as_uint64
= 0;
182 wrmsrl(HV_X64_MSR_HYPERCALL
, hypercall_msr
.as_uint64
);
192 * hv_cleanup - Cleanup routine.
194 * This routine is called normally during driver unloading or exiting.
196 void hv_cleanup(void)
198 union hv_x64_msr_hypercall_contents hypercall_msr
;
200 /* Reset our OS id */
201 wrmsrl(HV_X64_MSR_GUEST_OS_ID
, 0);
203 if (hv_context
.hypercall_page
) {
204 hypercall_msr
.as_uint64
= 0;
205 wrmsrl(HV_X64_MSR_HYPERCALL
, hypercall_msr
.as_uint64
);
206 vfree(hv_context
.hypercall_page
);
207 hv_context
.hypercall_page
= NULL
;
212 * hv_post_message - Post a message using the hypervisor message IPC.
214 * This involves a hypercall.
216 int hv_post_message(union hv_connection_id connection_id
,
217 enum hv_message_type message_type
,
218 void *payload
, size_t payload_size
)
220 struct aligned_input
{
222 struct hv_input_post_message msg
;
225 struct hv_input_post_message
*aligned_msg
;
229 if (payload_size
> HV_MESSAGE_PAYLOAD_BYTE_COUNT
)
232 addr
= (unsigned long)kmalloc(sizeof(struct aligned_input
), GFP_ATOMIC
);
236 aligned_msg
= (struct hv_input_post_message
*)
237 (ALIGN(addr
, HV_HYPERCALL_PARAM_ALIGN
));
239 aligned_msg
->connectionid
= connection_id
;
240 aligned_msg
->message_type
= message_type
;
241 aligned_msg
->payload_size
= payload_size
;
242 memcpy((void *)aligned_msg
->payload
, payload
, payload_size
);
244 status
= do_hypercall(HVCALL_POST_MESSAGE
, aligned_msg
, NULL
)
255 * Signal an event on the specified connection using the hypervisor event IPC.
257 * This involves a hypercall.
259 u16
hv_signal_event(void *con_id
)
263 status
= (do_hypercall(HVCALL_SIGNAL_EVENT
, con_id
, NULL
) & 0xFFFF);
269 * hv_synic_init - Initialize the Synthethic Interrupt Controller.
271 * If it is already initialized by another entity (ie x2v shim), we need to
272 * retrieve the initialized message and event pages. Otherwise, we create and
273 * initialize the message and event pages.
275 void hv_synic_init(void *arg
)
278 union hv_synic_simp simp
;
279 union hv_synic_siefp siefp
;
280 union hv_synic_sint shared_sint
;
281 union hv_synic_scontrol sctrl
;
284 int cpu
= smp_processor_id();
286 if (!hv_context
.hypercall_page
)
289 /* Check the version */
290 rdmsrl(HV_X64_MSR_SVERSION
, version
);
292 hv_context
.event_dpc
[cpu
] = (struct tasklet_struct
*)
293 kmalloc(sizeof(struct tasklet_struct
),
295 if (hv_context
.event_dpc
[cpu
] == NULL
) {
296 pr_err("Unable to allocate event dpc\n");
299 tasklet_init(hv_context
.event_dpc
[cpu
], vmbus_on_event
, cpu
);
301 hv_context
.synic_message_page
[cpu
] =
302 (void *)get_zeroed_page(GFP_ATOMIC
);
304 if (hv_context
.synic_message_page
[cpu
] == NULL
) {
305 pr_err("Unable to allocate SYNIC message page\n");
309 hv_context
.synic_event_page
[cpu
] =
310 (void *)get_zeroed_page(GFP_ATOMIC
);
312 if (hv_context
.synic_event_page
[cpu
] == NULL
) {
313 pr_err("Unable to allocate SYNIC event page\n");
317 /* Setup the Synic's message page */
318 rdmsrl(HV_X64_MSR_SIMP
, simp
.as_uint64
);
319 simp
.simp_enabled
= 1;
320 simp
.base_simp_gpa
= virt_to_phys(hv_context
.synic_message_page
[cpu
])
323 wrmsrl(HV_X64_MSR_SIMP
, simp
.as_uint64
);
325 /* Setup the Synic's event page */
326 rdmsrl(HV_X64_MSR_SIEFP
, siefp
.as_uint64
);
327 siefp
.siefp_enabled
= 1;
328 siefp
.base_siefp_gpa
= virt_to_phys(hv_context
.synic_event_page
[cpu
])
331 wrmsrl(HV_X64_MSR_SIEFP
, siefp
.as_uint64
);
333 /* Setup the shared SINT. */
334 rdmsrl(HV_X64_MSR_SINT0
+ VMBUS_MESSAGE_SINT
, shared_sint
.as_uint64
);
336 shared_sint
.as_uint64
= 0;
337 shared_sint
.vector
= HYPERVISOR_CALLBACK_VECTOR
;
338 shared_sint
.masked
= false;
339 shared_sint
.auto_eoi
= true;
341 wrmsrl(HV_X64_MSR_SINT0
+ VMBUS_MESSAGE_SINT
, shared_sint
.as_uint64
);
343 /* Enable the global synic bit */
344 rdmsrl(HV_X64_MSR_SCONTROL
, sctrl
.as_uint64
);
347 wrmsrl(HV_X64_MSR_SCONTROL
, sctrl
.as_uint64
);
349 hv_context
.synic_initialized
= true;
352 * Setup the mapping between Hyper-V's notion
353 * of cpuid and Linux' notion of cpuid.
354 * This array will be indexed using Linux cpuid.
356 rdmsrl(HV_X64_MSR_VP_INDEX
, vp_index
);
357 hv_context
.vp_index
[cpu
] = (u32
)vp_index
;
361 if (hv_context
.synic_event_page
[cpu
])
362 free_page((unsigned long)hv_context
.synic_event_page
[cpu
]);
364 if (hv_context
.synic_message_page
[cpu
])
365 free_page((unsigned long)hv_context
.synic_message_page
[cpu
]);
370 * hv_synic_cleanup - Cleanup routine for hv_synic_init().
372 void hv_synic_cleanup(void *arg
)
374 union hv_synic_sint shared_sint
;
375 union hv_synic_simp simp
;
376 union hv_synic_siefp siefp
;
377 int cpu
= smp_processor_id();
379 if (!hv_context
.synic_initialized
)
382 rdmsrl(HV_X64_MSR_SINT0
+ VMBUS_MESSAGE_SINT
, shared_sint
.as_uint64
);
384 shared_sint
.masked
= 1;
386 /* Need to correctly cleanup in the case of SMP!!! */
387 /* Disable the interrupt */
388 wrmsrl(HV_X64_MSR_SINT0
+ VMBUS_MESSAGE_SINT
, shared_sint
.as_uint64
);
390 rdmsrl(HV_X64_MSR_SIMP
, simp
.as_uint64
);
391 simp
.simp_enabled
= 0;
392 simp
.base_simp_gpa
= 0;
394 wrmsrl(HV_X64_MSR_SIMP
, simp
.as_uint64
);
396 rdmsrl(HV_X64_MSR_SIEFP
, siefp
.as_uint64
);
397 siefp
.siefp_enabled
= 0;
398 siefp
.base_siefp_gpa
= 0;
400 wrmsrl(HV_X64_MSR_SIEFP
, siefp
.as_uint64
);
402 free_page((unsigned long)hv_context
.synic_message_page
[cpu
]);
403 free_page((unsigned long)hv_context
.synic_event_page
[cpu
]);