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 <linux/clockchips.h>
32 #include <asm/hyperv.h>
33 #include <asm/mshyperv.h>
34 #include "hyperv_vmbus.h"
36 /* The one and only */
37 struct hv_context hv_context
= {
38 .synic_initialized
= false,
39 .hypercall_page
= NULL
,
42 #define HV_TIMER_FREQUENCY (10 * 1000 * 1000) /* 100ns period */
43 #define HV_MAX_MAX_DELTA_TICKS 0xffffffff
44 #define HV_MIN_DELTA_TICKS 1
47 * query_hypervisor_info - Get version info of the windows hypervisor
49 unsigned int host_info_eax
;
50 unsigned int host_info_ebx
;
51 unsigned int host_info_ecx
;
52 unsigned int host_info_edx
;
54 static int query_hypervisor_info(void)
60 unsigned int max_leaf
;
64 * Its assumed that this is called after confirming that Viridian
65 * is present. Query id and revision.
71 op
= HVCPUID_VENDOR_MAXFUNCTION
;
72 cpuid(op
, &eax
, &ebx
, &ecx
, &edx
);
76 if (max_leaf
>= HVCPUID_VERSION
) {
82 cpuid(op
, &eax
, &ebx
, &ecx
, &edx
);
92 * do_hypercall- Invoke the specified hypercall
94 static u64
do_hypercall(u64 control
, void *input
, void *output
)
96 u64 input_address
= (input
) ? virt_to_phys(input
) : 0;
97 u64 output_address
= (output
) ? virt_to_phys(output
) : 0;
98 void *hypercall_page
= hv_context
.hypercall_page
;
103 return (u64
)ULLONG_MAX
;
105 __asm__
__volatile__("mov %0, %%r8" : : "r" (output_address
) : "r8");
106 __asm__
__volatile__("call *%3" : "=a" (hv_status
) :
107 "c" (control
), "d" (input_address
),
108 "m" (hypercall_page
));
114 u32 control_hi
= control
>> 32;
115 u32 control_lo
= control
& 0xFFFFFFFF;
116 u32 hv_status_hi
= 1;
117 u32 hv_status_lo
= 1;
118 u32 input_address_hi
= input_address
>> 32;
119 u32 input_address_lo
= input_address
& 0xFFFFFFFF;
120 u32 output_address_hi
= output_address
>> 32;
121 u32 output_address_lo
= output_address
& 0xFFFFFFFF;
124 return (u64
)ULLONG_MAX
;
126 __asm__
__volatile__ ("call *%8" : "=d"(hv_status_hi
),
127 "=a"(hv_status_lo
) : "d" (control_hi
),
128 "a" (control_lo
), "b" (input_address_hi
),
129 "c" (input_address_lo
), "D"(output_address_hi
),
130 "S"(output_address_lo
), "m" (hypercall_page
));
132 return hv_status_lo
| ((u64
)hv_status_hi
<< 32);
137 * hv_init - Main initialization routine.
139 * This routine must be called before any other routines in here are called
144 union hv_x64_msr_hypercall_contents hypercall_msr
;
145 void *virtaddr
= NULL
;
147 memset(hv_context
.synic_event_page
, 0, sizeof(void *) * NR_CPUS
);
148 memset(hv_context
.synic_message_page
, 0,
149 sizeof(void *) * NR_CPUS
);
150 memset(hv_context
.post_msg_page
, 0,
151 sizeof(void *) * NR_CPUS
);
152 memset(hv_context
.vp_index
, 0,
153 sizeof(int) * NR_CPUS
);
154 memset(hv_context
.event_dpc
, 0,
155 sizeof(void *) * NR_CPUS
);
156 memset(hv_context
.clk_evt
, 0,
157 sizeof(void *) * NR_CPUS
);
159 max_leaf
= query_hypervisor_info();
164 hv_context
.guestid
= generate_guest_id(0, LINUX_VERSION_CODE
, 0);
165 wrmsrl(HV_X64_MSR_GUEST_OS_ID
, hv_context
.guestid
);
167 /* See if the hypercall page is already set */
168 rdmsrl(HV_X64_MSR_HYPERCALL
, hypercall_msr
.as_uint64
);
170 virtaddr
= __vmalloc(PAGE_SIZE
, GFP_KERNEL
, PAGE_KERNEL_EXEC
);
175 hypercall_msr
.enable
= 1;
177 hypercall_msr
.guest_physical_address
= vmalloc_to_pfn(virtaddr
);
178 wrmsrl(HV_X64_MSR_HYPERCALL
, hypercall_msr
.as_uint64
);
180 /* Confirm that hypercall page did get setup. */
181 hypercall_msr
.as_uint64
= 0;
182 rdmsrl(HV_X64_MSR_HYPERCALL
, hypercall_msr
.as_uint64
);
184 if (!hypercall_msr
.enable
)
187 hv_context
.hypercall_page
= virtaddr
;
193 if (hypercall_msr
.enable
) {
194 hypercall_msr
.as_uint64
= 0;
195 wrmsrl(HV_X64_MSR_HYPERCALL
, hypercall_msr
.as_uint64
);
205 * hv_cleanup - Cleanup routine.
207 * This routine is called normally during driver unloading or exiting.
209 void hv_cleanup(void)
211 union hv_x64_msr_hypercall_contents hypercall_msr
;
213 /* Reset our OS id */
214 wrmsrl(HV_X64_MSR_GUEST_OS_ID
, 0);
216 if (hv_context
.hypercall_page
) {
217 hypercall_msr
.as_uint64
= 0;
218 wrmsrl(HV_X64_MSR_HYPERCALL
, hypercall_msr
.as_uint64
);
219 vfree(hv_context
.hypercall_page
);
220 hv_context
.hypercall_page
= NULL
;
225 * hv_post_message - Post a message using the hypervisor message IPC.
227 * This involves a hypercall.
229 int hv_post_message(union hv_connection_id connection_id
,
230 enum hv_message_type message_type
,
231 void *payload
, size_t payload_size
)
234 struct hv_input_post_message
*aligned_msg
;
237 if (payload_size
> HV_MESSAGE_PAYLOAD_BYTE_COUNT
)
240 aligned_msg
= (struct hv_input_post_message
*)
241 hv_context
.post_msg_page
[get_cpu()];
243 aligned_msg
->connectionid
= connection_id
;
244 aligned_msg
->reserved
= 0;
245 aligned_msg
->message_type
= message_type
;
246 aligned_msg
->payload_size
= payload_size
;
247 memcpy((void *)aligned_msg
->payload
, payload
, payload_size
);
249 status
= do_hypercall(HVCALL_POST_MESSAGE
, aligned_msg
, NULL
)
259 * Signal an event on the specified connection using the hypervisor event IPC.
261 * This involves a hypercall.
263 u16
hv_signal_event(void *con_id
)
267 status
= (do_hypercall(HVCALL_SIGNAL_EVENT
, con_id
, NULL
) & 0xFFFF);
272 static int hv_ce_set_next_event(unsigned long delta
,
273 struct clock_event_device
*evt
)
275 cycle_t current_tick
;
277 WARN_ON(evt
->mode
!= CLOCK_EVT_MODE_ONESHOT
);
279 rdmsrl(HV_X64_MSR_TIME_REF_COUNT
, current_tick
);
280 current_tick
+= delta
;
281 wrmsrl(HV_X64_MSR_STIMER0_COUNT
, current_tick
);
285 static void hv_ce_setmode(enum clock_event_mode mode
,
286 struct clock_event_device
*evt
)
288 union hv_timer_config timer_cfg
;
291 case CLOCK_EVT_MODE_PERIODIC
:
295 case CLOCK_EVT_MODE_ONESHOT
:
296 timer_cfg
.enable
= 1;
297 timer_cfg
.auto_enable
= 1;
298 timer_cfg
.sintx
= VMBUS_MESSAGE_SINT
;
299 wrmsrl(HV_X64_MSR_STIMER0_CONFIG
, timer_cfg
.as_uint64
);
302 case CLOCK_EVT_MODE_UNUSED
:
303 case CLOCK_EVT_MODE_SHUTDOWN
:
304 wrmsrl(HV_X64_MSR_STIMER0_COUNT
, 0);
305 wrmsrl(HV_X64_MSR_STIMER0_CONFIG
, 0);
307 case CLOCK_EVT_MODE_RESUME
:
312 static void hv_init_clockevent_device(struct clock_event_device
*dev
, int cpu
)
314 dev
->name
= "Hyper-V clockevent";
315 dev
->features
= CLOCK_EVT_FEAT_ONESHOT
;
316 dev
->cpumask
= cpumask_of(cpu
);
319 * Avoid settint dev->owner = THIS_MODULE deliberately as doing so will
320 * result in clockevents_config_and_register() taking additional
321 * references to the hv_vmbus module making it impossible to unload.
324 dev
->set_mode
= hv_ce_setmode
;
325 dev
->set_next_event
= hv_ce_set_next_event
;
329 int hv_synic_alloc(void)
331 size_t size
= sizeof(struct tasklet_struct
);
332 size_t ced_size
= sizeof(struct clock_event_device
);
335 hv_context
.hv_numa_map
= kzalloc(sizeof(struct cpumask
) * nr_node_ids
,
337 if (hv_context
.hv_numa_map
== NULL
) {
338 pr_err("Unable to allocate NUMA map\n");
342 for_each_online_cpu(cpu
) {
343 hv_context
.event_dpc
[cpu
] = kmalloc(size
, GFP_ATOMIC
);
344 if (hv_context
.event_dpc
[cpu
] == NULL
) {
345 pr_err("Unable to allocate event dpc\n");
348 tasklet_init(hv_context
.event_dpc
[cpu
], vmbus_on_event
, cpu
);
350 hv_context
.clk_evt
[cpu
] = kzalloc(ced_size
, GFP_ATOMIC
);
351 if (hv_context
.clk_evt
[cpu
] == NULL
) {
352 pr_err("Unable to allocate clock event device\n");
356 hv_init_clockevent_device(hv_context
.clk_evt
[cpu
], cpu
);
358 hv_context
.synic_message_page
[cpu
] =
359 (void *)get_zeroed_page(GFP_ATOMIC
);
361 if (hv_context
.synic_message_page
[cpu
] == NULL
) {
362 pr_err("Unable to allocate SYNIC message page\n");
366 hv_context
.synic_event_page
[cpu
] =
367 (void *)get_zeroed_page(GFP_ATOMIC
);
369 if (hv_context
.synic_event_page
[cpu
] == NULL
) {
370 pr_err("Unable to allocate SYNIC event page\n");
374 hv_context
.post_msg_page
[cpu
] =
375 (void *)get_zeroed_page(GFP_ATOMIC
);
377 if (hv_context
.post_msg_page
[cpu
] == NULL
) {
378 pr_err("Unable to allocate post msg page\n");
388 static void hv_synic_free_cpu(int cpu
)
390 kfree(hv_context
.event_dpc
[cpu
]);
391 kfree(hv_context
.clk_evt
[cpu
]);
392 if (hv_context
.synic_event_page
[cpu
])
393 free_page((unsigned long)hv_context
.synic_event_page
[cpu
]);
394 if (hv_context
.synic_message_page
[cpu
])
395 free_page((unsigned long)hv_context
.synic_message_page
[cpu
]);
396 if (hv_context
.post_msg_page
[cpu
])
397 free_page((unsigned long)hv_context
.post_msg_page
[cpu
]);
400 void hv_synic_free(void)
404 kfree(hv_context
.hv_numa_map
);
405 for_each_online_cpu(cpu
)
406 hv_synic_free_cpu(cpu
);
410 * hv_synic_init - Initialize the Synthethic Interrupt Controller.
412 * If it is already initialized by another entity (ie x2v shim), we need to
413 * retrieve the initialized message and event pages. Otherwise, we create and
414 * initialize the message and event pages.
416 void hv_synic_init(void *arg
)
419 union hv_synic_simp simp
;
420 union hv_synic_siefp siefp
;
421 union hv_synic_sint shared_sint
;
422 union hv_synic_scontrol sctrl
;
425 int cpu
= smp_processor_id();
427 if (!hv_context
.hypercall_page
)
430 /* Check the version */
431 rdmsrl(HV_X64_MSR_SVERSION
, version
);
433 /* Setup the Synic's message page */
434 rdmsrl(HV_X64_MSR_SIMP
, simp
.as_uint64
);
435 simp
.simp_enabled
= 1;
436 simp
.base_simp_gpa
= virt_to_phys(hv_context
.synic_message_page
[cpu
])
439 wrmsrl(HV_X64_MSR_SIMP
, simp
.as_uint64
);
441 /* Setup the Synic's event page */
442 rdmsrl(HV_X64_MSR_SIEFP
, siefp
.as_uint64
);
443 siefp
.siefp_enabled
= 1;
444 siefp
.base_siefp_gpa
= virt_to_phys(hv_context
.synic_event_page
[cpu
])
447 wrmsrl(HV_X64_MSR_SIEFP
, siefp
.as_uint64
);
449 /* Setup the shared SINT. */
450 rdmsrl(HV_X64_MSR_SINT0
+ VMBUS_MESSAGE_SINT
, shared_sint
.as_uint64
);
452 shared_sint
.as_uint64
= 0;
453 shared_sint
.vector
= HYPERVISOR_CALLBACK_VECTOR
;
454 shared_sint
.masked
= false;
455 shared_sint
.auto_eoi
= true;
457 wrmsrl(HV_X64_MSR_SINT0
+ VMBUS_MESSAGE_SINT
, shared_sint
.as_uint64
);
459 /* Enable the global synic bit */
460 rdmsrl(HV_X64_MSR_SCONTROL
, sctrl
.as_uint64
);
463 wrmsrl(HV_X64_MSR_SCONTROL
, sctrl
.as_uint64
);
465 hv_context
.synic_initialized
= true;
468 * Setup the mapping between Hyper-V's notion
469 * of cpuid and Linux' notion of cpuid.
470 * This array will be indexed using Linux cpuid.
472 rdmsrl(HV_X64_MSR_VP_INDEX
, vp_index
);
473 hv_context
.vp_index
[cpu
] = (u32
)vp_index
;
475 INIT_LIST_HEAD(&hv_context
.percpu_list
[cpu
]);
478 * Register the per-cpu clockevent source.
480 if (ms_hyperv
.features
& HV_X64_MSR_SYNTIMER_AVAILABLE
)
481 clockevents_config_and_register(hv_context
.clk_evt
[cpu
],
484 HV_MAX_MAX_DELTA_TICKS
);
489 * hv_synic_clockevents_cleanup - Cleanup clockevent devices
491 void hv_synic_clockevents_cleanup(void)
495 if (!(ms_hyperv
.features
& HV_X64_MSR_SYNTIMER_AVAILABLE
))
498 for_each_online_cpu(cpu
)
499 clockevents_unbind_device(hv_context
.clk_evt
[cpu
], cpu
);
503 * hv_synic_cleanup - Cleanup routine for hv_synic_init().
505 void hv_synic_cleanup(void *arg
)
507 union hv_synic_sint shared_sint
;
508 union hv_synic_simp simp
;
509 union hv_synic_siefp siefp
;
510 union hv_synic_scontrol sctrl
;
511 int cpu
= smp_processor_id();
513 if (!hv_context
.synic_initialized
)
516 /* Turn off clockevent device */
517 if (ms_hyperv
.features
& HV_X64_MSR_SYNTIMER_AVAILABLE
)
518 hv_ce_setmode(CLOCK_EVT_MODE_SHUTDOWN
,
519 hv_context
.clk_evt
[cpu
]);
521 rdmsrl(HV_X64_MSR_SINT0
+ VMBUS_MESSAGE_SINT
, shared_sint
.as_uint64
);
523 shared_sint
.masked
= 1;
525 /* Need to correctly cleanup in the case of SMP!!! */
526 /* Disable the interrupt */
527 wrmsrl(HV_X64_MSR_SINT0
+ VMBUS_MESSAGE_SINT
, shared_sint
.as_uint64
);
529 rdmsrl(HV_X64_MSR_SIMP
, simp
.as_uint64
);
530 simp
.simp_enabled
= 0;
531 simp
.base_simp_gpa
= 0;
533 wrmsrl(HV_X64_MSR_SIMP
, simp
.as_uint64
);
535 rdmsrl(HV_X64_MSR_SIEFP
, siefp
.as_uint64
);
536 siefp
.siefp_enabled
= 0;
537 siefp
.base_siefp_gpa
= 0;
539 wrmsrl(HV_X64_MSR_SIEFP
, siefp
.as_uint64
);
541 /* Disable the global synic bit */
542 rdmsrl(HV_X64_MSR_SCONTROL
, sctrl
.as_uint64
);
544 wrmsrl(HV_X64_MSR_SCONTROL
, sctrl
.as_uint64
);