Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 1 | /* |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 2 | * Copyright (c) 2009, Microsoft Corporation. |
| 3 | * |
| 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. |
| 7 | * |
| 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 |
| 11 | * more details. |
| 12 | * |
| 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. |
| 16 | * |
| 17 | * Authors: |
| 18 | * Haiyang Zhang <haiyangz@microsoft.com> |
| 19 | * Hank Janssen <hjanssen@microsoft.com> |
| 20 | * |
| 21 | */ |
Greg Kroah-Hartman | a0086dc | 2009-08-17 17:22:08 -0700 | [diff] [blame] | 22 | #include <linux/kernel.h> |
| 23 | #include <linux/mm.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 24 | #include <linux/slab.h> |
Bill Pemberton | b7c947f | 2009-07-29 17:00:13 -0400 | [diff] [blame] | 25 | #include <linux/vmalloc.h> |
Greg Kroah-Hartman | 4983b39 | 2009-08-19 16:14:47 -0700 | [diff] [blame] | 26 | #include "osd.h" |
Greg Kroah-Hartman | 645954c | 2009-08-28 16:22:59 -0700 | [diff] [blame] | 27 | #include "logging.h" |
Greg Kroah-Hartman | 72daf32 | 2010-05-05 22:45:25 -0700 | [diff] [blame] | 28 | #include "vmbus_private.h" |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 29 | |
Bill Pemberton | 454f18a | 2009-07-27 16:47:24 -0400 | [diff] [blame] | 30 | /* The one and only */ |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 31 | struct hv_context hv_context = { |
| 32 | .synic_initialized = false, |
| 33 | .hypercall_page = NULL, |
| 34 | .signal_event_param = NULL, |
| 35 | .signal_event_buffer = NULL, |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 36 | }; |
| 37 | |
Hank Janssen | 3e18951 | 2010-03-04 22:11:00 +0000 | [diff] [blame] | 38 | /* |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 39 | * query_hypervisor_presence |
| 40 | * - Query the cpuid for presense of windows hypervisor |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 41 | */ |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 42 | static int query_hypervisor_presence(void) |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 43 | { |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 44 | unsigned int eax; |
| 45 | unsigned int ebx; |
| 46 | unsigned int ecx; |
| 47 | unsigned int edx; |
| 48 | unsigned int op; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 49 | |
Bill Pemberton | 454f18a | 2009-07-27 16:47:24 -0400 | [diff] [blame] | 50 | eax = 0; |
| 51 | ebx = 0; |
| 52 | ecx = 0; |
| 53 | edx = 0; |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 54 | op = HVCPUID_VERSION_FEATURES; |
Greg Kroah-Hartman | f931a70 | 2009-07-29 15:37:12 -0700 | [diff] [blame] | 55 | cpuid(op, &eax, &ebx, &ecx, &edx); |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 56 | |
| 57 | return ecx & HV_PRESENT_BIT; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 58 | } |
| 59 | |
Hank Janssen | 3e18951 | 2010-03-04 22:11:00 +0000 | [diff] [blame] | 60 | /* |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 61 | * query_hypervisor_info - Get version info of the windows hypervisor |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 62 | */ |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 63 | static int query_hypervisor_info(void) |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 64 | { |
| 65 | unsigned int eax; |
| 66 | unsigned int ebx; |
| 67 | unsigned int ecx; |
| 68 | unsigned int edx; |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 69 | unsigned int max_leaf; |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 70 | unsigned int op; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 71 | |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 72 | /* |
| 73 | * Its assumed that this is called after confirming that Viridian |
| 74 | * is present. Query id and revision. |
| 75 | */ |
| 76 | eax = 0; |
| 77 | ebx = 0; |
| 78 | ecx = 0; |
| 79 | edx = 0; |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 80 | op = HVCPUID_VENDOR_MAXFUNCTION; |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 81 | cpuid(op, &eax, &ebx, &ecx, &edx); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 82 | |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 83 | DPRINT_INFO(VMBUS, "Vendor ID: %c%c%c%c%c%c%c%c%c%c%c%c", |
| 84 | (ebx & 0xFF), |
| 85 | ((ebx >> 8) & 0xFF), |
| 86 | ((ebx >> 16) & 0xFF), |
| 87 | ((ebx >> 24) & 0xFF), |
| 88 | (ecx & 0xFF), |
| 89 | ((ecx >> 8) & 0xFF), |
| 90 | ((ecx >> 16) & 0xFF), |
| 91 | ((ecx >> 24) & 0xFF), |
| 92 | (edx & 0xFF), |
| 93 | ((edx >> 8) & 0xFF), |
| 94 | ((edx >> 16) & 0xFF), |
| 95 | ((edx >> 24) & 0xFF)); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 96 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 97 | max_leaf = eax; |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 98 | eax = 0; |
| 99 | ebx = 0; |
| 100 | ecx = 0; |
| 101 | edx = 0; |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 102 | op = HVCPUID_INTERFACE; |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 103 | cpuid(op, &eax, &ebx, &ecx, &edx); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 104 | |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 105 | DPRINT_INFO(VMBUS, "Interface ID: %c%c%c%c", |
| 106 | (eax & 0xFF), |
| 107 | ((eax >> 8) & 0xFF), |
| 108 | ((eax >> 16) & 0xFF), |
| 109 | ((eax >> 24) & 0xFF)); |
| 110 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 111 | if (max_leaf >= HVCPUID_VERSION) { |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 112 | eax = 0; |
| 113 | ebx = 0; |
| 114 | ecx = 0; |
| 115 | edx = 0; |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 116 | op = HVCPUID_VERSION; |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 117 | cpuid(op, &eax, &ebx, &ecx, &edx); |
| 118 | DPRINT_INFO(VMBUS, "OS Build:%d-%d.%d-%d-%d.%d",\ |
| 119 | eax, |
| 120 | ebx >> 16, |
| 121 | ebx & 0xFFFF, |
| 122 | ecx, |
| 123 | edx >> 24, |
| 124 | edx & 0xFFFFFF); |
| 125 | } |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 126 | return max_leaf; |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 127 | } |
| 128 | |
Hank Janssen | 3e18951 | 2010-03-04 22:11:00 +0000 | [diff] [blame] | 129 | /* |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 130 | * do_hypercall- Invoke the specified hypercall |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 131 | */ |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 132 | static u64 do_hypercall(u64 control, void *input, void *output) |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 133 | { |
Greg Kroah-Hartman | 530cf20 | 2009-07-16 22:31:15 -0700 | [diff] [blame] | 134 | #ifdef CONFIG_X86_64 |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 135 | u64 hv_status = 0; |
| 136 | u64 input_address = (input) ? virt_to_phys(input) : 0; |
| 137 | u64 output_address = (output) ? virt_to_phys(output) : 0; |
| 138 | volatile void *hypercall_page = hv_context.hypercall_page; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 139 | |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 140 | DPRINT_DBG(VMBUS, "Hypercall <control %llx input phys %llx virt %p " |
| 141 | "output phys %llx virt %p hypercall %p>", |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 142 | control, input_address, input, |
| 143 | output_address, output, hypercall_page); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 144 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 145 | __asm__ __volatile__("mov %0, %%r8" : : "r" (output_address) : "r8"); |
| 146 | __asm__ __volatile__("call *%3" : "=a" (hv_status) : |
| 147 | "c" (control), "d" (input_address), |
| 148 | "m" (hypercall_page)); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 149 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 150 | DPRINT_DBG(VMBUS, "Hypercall <return %llx>", hv_status); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 151 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 152 | return hv_status; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 153 | |
| 154 | #else |
| 155 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 156 | u32 control_hi = control >> 32; |
| 157 | u32 control_lo = control & 0xFFFFFFFF; |
| 158 | u32 hv_status_hi = 1; |
| 159 | u32 hv_status_lo = 1; |
| 160 | u64 input_address = (input) ? virt_to_phys(input) : 0; |
| 161 | u32 input_address_hi = input_address >> 32; |
| 162 | u32 input_address_lo = input_address & 0xFFFFFFFF; |
| 163 | u64 output_address = (output) ? virt_to_phys(output) : 0; |
| 164 | u32 output_address_hi = output_address >> 32; |
| 165 | u32 output_address_lo = output_address & 0xFFFFFFFF; |
| 166 | volatile void *hypercall_page = hv_context.hypercall_page; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 167 | |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 168 | DPRINT_DBG(VMBUS, "Hypercall <control %llx input %p output %p>", |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 169 | control, input, output); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 170 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 171 | __asm__ __volatile__ ("call *%8" : "=d"(hv_status_hi), |
| 172 | "=a"(hv_status_lo) : "d" (control_hi), |
| 173 | "a" (control_lo), "b" (input_address_hi), |
| 174 | "c" (input_address_lo), "D"(output_address_hi), |
| 175 | "S"(output_address_lo), "m" (hypercall_page)); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 176 | |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 177 | DPRINT_DBG(VMBUS, "Hypercall <return %llx>", |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 178 | hv_status_lo | ((u64)hv_status_hi << 32)); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 179 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 180 | return hv_status_lo | ((u64)hv_status_hi << 32); |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 181 | #endif /* !x86_64 */ |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 182 | } |
| 183 | |
Hank Janssen | 3e18951 | 2010-03-04 22:11:00 +0000 | [diff] [blame] | 184 | /* |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 185 | * hv_init - Main initialization routine. |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 186 | * |
| 187 | * This routine must be called before any other routines in here are called |
| 188 | */ |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 189 | int hv_init(void) |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 190 | { |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 191 | int ret = 0; |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 192 | int max_leaf; |
| 193 | union hv_x64_msr_hypercall_contents hypercall_msr; |
| 194 | void *virtaddr = NULL; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 195 | |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 196 | memset(hv_context.synic_event_page, 0, sizeof(void *) * MAX_NUM_CPUS); |
| 197 | memset(hv_context.synic_message_page, 0, |
| 198 | sizeof(void *) * MAX_NUM_CPUS); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 199 | |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 200 | if (!query_hypervisor_presence()) { |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 201 | DPRINT_ERR(VMBUS, "No Windows hypervisor detected!!"); |
| 202 | goto Cleanup; |
| 203 | } |
| 204 | |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 205 | DPRINT_INFO(VMBUS, |
| 206 | "Windows hypervisor detected! Retrieving more info..."); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 207 | |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 208 | max_leaf = query_hypervisor_info(); |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 209 | /* HvQueryHypervisorFeatures(maxLeaf); */ |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 210 | |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 211 | /* |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 212 | * We only support running on top of Hyper-V |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 213 | */ |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 214 | rdmsrl(HV_X64_MSR_GUEST_OS_ID, hv_context.guestid); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 215 | |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 216 | if (hv_context.guestid != 0) { |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 217 | DPRINT_ERR(VMBUS, "Unknown guest id (0x%llx)!!", |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 218 | hv_context.guestid); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 219 | goto Cleanup; |
| 220 | } |
| 221 | |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 222 | /* Write our OS info */ |
| 223 | wrmsrl(HV_X64_MSR_GUEST_OS_ID, HV_LINUX_GUEST_ID); |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 224 | hv_context.guestid = HV_LINUX_GUEST_ID; |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 225 | |
| 226 | /* See if the hypercall page is already set */ |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 227 | rdmsrl(HV_X64_MSR_HYPERCALL, hypercall_msr.as_uint64); |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 228 | |
| 229 | /* |
| 230 | * Allocate the hypercall page memory |
Haiyang Zhang | 203df82 | 2010-11-08 14:04:44 -0800 | [diff] [blame^] | 231 | * virtaddr = osd_page_alloc(1); |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 232 | */ |
Haiyang Zhang | 203df82 | 2010-11-08 14:04:44 -0800 | [diff] [blame^] | 233 | virtaddr = osd_virtual_alloc_exec(PAGE_SIZE); |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 234 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 235 | if (!virtaddr) { |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 236 | DPRINT_ERR(VMBUS, |
| 237 | "unable to allocate hypercall page!!"); |
| 238 | goto Cleanup; |
| 239 | } |
| 240 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 241 | hypercall_msr.enable = 1; |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 242 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 243 | hypercall_msr.guest_physical_address = vmalloc_to_pfn(virtaddr); |
| 244 | wrmsrl(HV_X64_MSR_HYPERCALL, hypercall_msr.as_uint64); |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 245 | |
| 246 | /* Confirm that hypercall page did get setup. */ |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 247 | hypercall_msr.as_uint64 = 0; |
| 248 | rdmsrl(HV_X64_MSR_HYPERCALL, hypercall_msr.as_uint64); |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 249 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 250 | if (!hypercall_msr.enable) { |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 251 | DPRINT_ERR(VMBUS, "unable to set hypercall page!!"); |
| 252 | goto Cleanup; |
| 253 | } |
| 254 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 255 | hv_context.hypercall_page = virtaddr; |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 256 | |
Greg Kroah-Hartman | 2701f68 | 2009-07-16 12:36:37 -0700 | [diff] [blame] | 257 | DPRINT_INFO(VMBUS, "Hypercall page VA=%p, PA=0x%0llx", |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 258 | hv_context.hypercall_page, |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 259 | (u64)hypercall_msr.guest_physical_address << PAGE_SHIFT); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 260 | |
Bill Pemberton | 454f18a | 2009-07-27 16:47:24 -0400 | [diff] [blame] | 261 | /* Setup the global signal event param for the signal event hypercall */ |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 262 | hv_context.signal_event_buffer = |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 263 | kmalloc(sizeof(struct hv_input_signal_event_buffer), |
| 264 | GFP_KERNEL); |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 265 | if (!hv_context.signal_event_buffer) |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 266 | goto Cleanup; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 267 | |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 268 | hv_context.signal_event_param = |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 269 | (struct hv_input_signal_event *) |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 270 | (ALIGN_UP((unsigned long) |
| 271 | hv_context.signal_event_buffer, |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 272 | HV_HYPERCALL_PARAM_ALIGN)); |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 273 | hv_context.signal_event_param->connectionid.asu32 = 0; |
| 274 | hv_context.signal_event_param->connectionid.u.id = |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 275 | VMBUS_EVENT_CONNECTION_ID; |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 276 | hv_context.signal_event_param->flag_number = 0; |
| 277 | hv_context.signal_event_param->rsvdz = 0; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 278 | |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 279 | return ret; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 280 | |
| 281 | Cleanup: |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 282 | if (virtaddr) { |
| 283 | if (hypercall_msr.enable) { |
| 284 | hypercall_msr.as_uint64 = 0; |
| 285 | wrmsrl(HV_X64_MSR_HYPERCALL, hypercall_msr.as_uint64); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 286 | } |
| 287 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 288 | vfree(virtaddr); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 289 | } |
| 290 | ret = -1; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 291 | return ret; |
| 292 | } |
| 293 | |
Hank Janssen | 3e18951 | 2010-03-04 22:11:00 +0000 | [diff] [blame] | 294 | /* |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 295 | * hv_cleanup - Cleanup routine. |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 296 | * |
| 297 | * This routine is called normally during driver unloading or exiting. |
| 298 | */ |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 299 | void hv_cleanup(void) |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 300 | { |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 301 | union hv_x64_msr_hypercall_contents hypercall_msr; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 302 | |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 303 | kfree(hv_context.signal_event_buffer); |
| 304 | hv_context.signal_event_buffer = NULL; |
| 305 | hv_context.signal_event_param = NULL; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 306 | |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 307 | if (hv_context.hypercall_page) { |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 308 | hypercall_msr.as_uint64 = 0; |
| 309 | wrmsrl(HV_X64_MSR_HYPERCALL, hypercall_msr.as_uint64); |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 310 | vfree(hv_context.hypercall_page); |
| 311 | hv_context.hypercall_page = NULL; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 312 | } |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 313 | } |
| 314 | |
Hank Janssen | 3e18951 | 2010-03-04 22:11:00 +0000 | [diff] [blame] | 315 | /* |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 316 | * hv_post_message - Post a message using the hypervisor message IPC. |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 317 | * |
| 318 | * This involves a hypercall. |
| 319 | */ |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 320 | u16 hv_post_message(union hv_connection_id connection_id, |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 321 | enum hv_message_type message_type, |
| 322 | void *payload, size_t payload_size) |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 323 | { |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 324 | struct aligned_input { |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 325 | u64 alignment8; |
Greg Kroah-Hartman | cba4dec | 2009-08-19 16:21:28 -0700 | [diff] [blame] | 326 | struct hv_input_post_message msg; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 327 | }; |
| 328 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 329 | struct hv_input_post_message *aligned_msg; |
Greg Kroah-Hartman | 034469e | 2009-08-20 12:14:11 -0700 | [diff] [blame] | 330 | u16 status; |
Greg Kroah-Hartman | c4b0bc9 | 2009-07-14 15:12:46 -0700 | [diff] [blame] | 331 | unsigned long addr; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 332 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 333 | if (payload_size > HV_MESSAGE_PAYLOAD_BYTE_COUNT) |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 334 | return -1; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 335 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 336 | addr = (unsigned long)kmalloc(sizeof(struct aligned_input), GFP_ATOMIC); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 337 | if (!addr) |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 338 | return -1; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 339 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 340 | aligned_msg = (struct hv_input_post_message *) |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 341 | (ALIGN_UP(addr, HV_HYPERCALL_PARAM_ALIGN)); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 342 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 343 | aligned_msg->connectionid = connection_id; |
| 344 | aligned_msg->message_type = message_type; |
| 345 | aligned_msg->payload_size = payload_size; |
| 346 | memcpy((void *)aligned_msg->payload, payload, payload_size); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 347 | |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 348 | status = do_hypercall(HVCALL_POST_MESSAGE, aligned_msg, NULL) |
| 349 | & 0xFFFF; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 350 | |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 351 | kfree((void *)addr); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 352 | |
| 353 | return status; |
| 354 | } |
| 355 | |
| 356 | |
Hank Janssen | 3e18951 | 2010-03-04 22:11:00 +0000 | [diff] [blame] | 357 | /* |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 358 | * hv_signal_event - |
| 359 | * Signal an event on the specified connection using the hypervisor event IPC. |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 360 | * |
| 361 | * This involves a hypercall. |
| 362 | */ |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 363 | u16 hv_signal_event(void) |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 364 | { |
Greg Kroah-Hartman | 034469e | 2009-08-20 12:14:11 -0700 | [diff] [blame] | 365 | u16 status; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 366 | |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 367 | status = do_hypercall(HVCALL_SIGNAL_EVENT, |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 368 | hv_context.signal_event_param, |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 369 | NULL) & 0xFFFF; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 370 | return status; |
| 371 | } |
| 372 | |
Hank Janssen | 3e18951 | 2010-03-04 22:11:00 +0000 | [diff] [blame] | 373 | /* |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 374 | * hv_synic_init - Initialize the Synthethic Interrupt Controller. |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 375 | * |
| 376 | * If it is already initialized by another entity (ie x2v shim), we need to |
| 377 | * retrieve the initialized message and event pages. Otherwise, we create and |
| 378 | * initialize the message and event pages. |
| 379 | */ |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 380 | void hv_synic_init(void *irqarg) |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 381 | { |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 382 | u64 version; |
Greg Kroah-Hartman | eacb1b4 | 2009-08-20 12:11:26 -0700 | [diff] [blame] | 383 | union hv_synic_simp simp; |
| 384 | union hv_synic_siefp siefp; |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 385 | union hv_synic_sint shared_sint; |
Greg Kroah-Hartman | eacb1b4 | 2009-08-20 12:11:26 -0700 | [diff] [blame] | 386 | union hv_synic_scontrol sctrl; |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 387 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 388 | u32 irq_vector = *((u32 *)(irqarg)); |
Greg Kroah-Hartman | 7692fd4 | 2010-01-08 09:06:40 -0800 | [diff] [blame] | 389 | int cpu = smp_processor_id(); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 390 | |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 391 | if (!hv_context.hypercall_page) |
Greg Kroah-Hartman | 7692fd4 | 2010-01-08 09:06:40 -0800 | [diff] [blame] | 392 | return; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 393 | |
Bill Pemberton | 454f18a | 2009-07-27 16:47:24 -0400 | [diff] [blame] | 394 | /* Check the version */ |
Greg Kroah-Hartman | a51ed7d | 2009-08-17 17:20:02 -0700 | [diff] [blame] | 395 | rdmsrl(HV_X64_MSR_SVERSION, version); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 396 | |
| 397 | DPRINT_INFO(VMBUS, "SynIC version: %llx", version); |
| 398 | |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 399 | hv_context.synic_message_page[cpu] = |
| 400 | (void *)get_zeroed_page(GFP_ATOMIC); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 401 | |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 402 | if (hv_context.synic_message_page[cpu] == NULL) { |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 403 | DPRINT_ERR(VMBUS, |
| 404 | "unable to allocate SYNIC message page!!"); |
| 405 | goto Cleanup; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 406 | } |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 407 | |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 408 | hv_context.synic_event_page[cpu] = |
| 409 | (void *)get_zeroed_page(GFP_ATOMIC); |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 410 | |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 411 | if (hv_context.synic_event_page[cpu] == NULL) { |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 412 | DPRINT_ERR(VMBUS, |
| 413 | "unable to allocate SYNIC event page!!"); |
| 414 | goto Cleanup; |
| 415 | } |
| 416 | |
| 417 | /* Setup the Synic's message page */ |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 418 | rdmsrl(HV_X64_MSR_SIMP, simp.as_uint64); |
| 419 | simp.simp_enabled = 1; |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 420 | simp.base_simp_gpa = virt_to_phys(hv_context.synic_message_page[cpu]) |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 421 | >> PAGE_SHIFT; |
| 422 | |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 423 | DPRINT_DBG(VMBUS, "HV_X64_MSR_SIMP msr set to: %llx", simp.as_uint64); |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 424 | |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 425 | wrmsrl(HV_X64_MSR_SIMP, simp.as_uint64); |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 426 | |
| 427 | /* Setup the Synic's event page */ |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 428 | rdmsrl(HV_X64_MSR_SIEFP, siefp.as_uint64); |
| 429 | siefp.siefp_enabled = 1; |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 430 | siefp.base_siefp_gpa = virt_to_phys(hv_context.synic_event_page[cpu]) |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 431 | >> PAGE_SHIFT; |
| 432 | |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 433 | DPRINT_DBG(VMBUS, "HV_X64_MSR_SIEFP msr set to: %llx", siefp.as_uint64); |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 434 | |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 435 | wrmsrl(HV_X64_MSR_SIEFP, siefp.as_uint64); |
Hank Janssen | a73e6b7 | 2010-01-22 19:17:50 +0000 | [diff] [blame] | 436 | |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 437 | /* Setup the interception SINT. */ |
| 438 | /* wrmsrl((HV_X64_MSR_SINT0 + HV_SYNIC_INTERCEPTION_SINT_INDEX), */ |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 439 | /* interceptionSint.as_uint64); */ |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 440 | |
| 441 | /* Setup the shared SINT. */ |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 442 | rdmsrl(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, shared_sint.as_uint64); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 443 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 444 | shared_sint.as_uint64 = 0; |
| 445 | shared_sint.vector = irq_vector; /* HV_SHARED_SINT_IDT_VECTOR + 0x20; */ |
| 446 | shared_sint.masked = false; |
| 447 | shared_sint.auto_eoi = true; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 448 | |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 449 | DPRINT_DBG(VMBUS, "HV_X64_MSR_SINT1 msr set to: %llx", |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 450 | shared_sint.as_uint64); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 451 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 452 | wrmsrl(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, shared_sint.as_uint64); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 453 | |
Bill Pemberton | 454f18a | 2009-07-27 16:47:24 -0400 | [diff] [blame] | 454 | /* Enable the global synic bit */ |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 455 | rdmsrl(HV_X64_MSR_SCONTROL, sctrl.as_uint64); |
| 456 | sctrl.enable = 1; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 457 | |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 458 | wrmsrl(HV_X64_MSR_SCONTROL, sctrl.as_uint64); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 459 | |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 460 | hv_context.synic_initialized = true; |
Greg Kroah-Hartman | 7692fd4 | 2010-01-08 09:06:40 -0800 | [diff] [blame] | 461 | return; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 462 | |
| 463 | Cleanup: |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 464 | if (hv_context.synic_event_page[cpu]) |
Haiyang Zhang | 203df82 | 2010-11-08 14:04:44 -0800 | [diff] [blame^] | 465 | osd_page_free(hv_context.synic_event_page[cpu], 1); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 466 | |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 467 | if (hv_context.synic_message_page[cpu]) |
Haiyang Zhang | 203df82 | 2010-11-08 14:04:44 -0800 | [diff] [blame^] | 468 | osd_page_free(hv_context.synic_message_page[cpu], 1); |
Greg Kroah-Hartman | 7692fd4 | 2010-01-08 09:06:40 -0800 | [diff] [blame] | 469 | return; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 470 | } |
| 471 | |
Hank Janssen | 3e18951 | 2010-03-04 22:11:00 +0000 | [diff] [blame] | 472 | /* |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 473 | * hv_synic_cleanup - Cleanup routine for hv_synic_init(). |
Greg Kroah-Hartman | 0831ad0 | 2009-08-31 20:23:33 -0700 | [diff] [blame] | 474 | */ |
Haiyang Zhang | d44890c | 2010-11-08 14:04:42 -0800 | [diff] [blame] | 475 | void hv_synic_cleanup(void *arg) |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 476 | { |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 477 | union hv_synic_sint shared_sint; |
Greg Kroah-Hartman | eacb1b4 | 2009-08-20 12:11:26 -0700 | [diff] [blame] | 478 | union hv_synic_simp simp; |
| 479 | union hv_synic_siefp siefp; |
Greg Kroah-Hartman | 7692fd4 | 2010-01-08 09:06:40 -0800 | [diff] [blame] | 480 | int cpu = smp_processor_id(); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 481 | |
Haiyang Zhang | 6a0aaa1 | 2010-11-08 14:04:40 -0800 | [diff] [blame] | 482 | if (!hv_context.synic_initialized) |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 483 | return; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 484 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 485 | rdmsrl(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, shared_sint.as_uint64); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 486 | |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 487 | shared_sint.masked = 1; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 488 | |
Greg Kroah-Hartman | 7692fd4 | 2010-01-08 09:06:40 -0800 | [diff] [blame] | 489 | /* Need to correctly cleanup in the case of SMP!!! */ |
Bill Pemberton | 454f18a | 2009-07-27 16:47:24 -0400 | [diff] [blame] | 490 | /* Disable the interrupt */ |
Haiyang Zhang | b8dfb26 | 2010-11-08 14:04:41 -0800 | [diff] [blame] | 491 | wrmsrl(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, shared_sint.as_uint64); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 492 | |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 493 | rdmsrl(HV_X64_MSR_SIMP, simp.as_uint64); |
| 494 | simp.simp_enabled = 0; |
| 495 | simp.base_simp_gpa = 0; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 496 | |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 497 | wrmsrl(HV_X64_MSR_SIMP, simp.as_uint64); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 498 | |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 499 | rdmsrl(HV_X64_MSR_SIEFP, siefp.as_uint64); |
| 500 | siefp.siefp_enabled = 0; |
| 501 | siefp.base_siefp_gpa = 0; |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 502 | |
Haiyang Zhang | f6feebe | 2010-11-08 14:04:39 -0800 | [diff] [blame] | 503 | wrmsrl(HV_X64_MSR_SIEFP, siefp.as_uint64); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 504 | |
Haiyang Zhang | 203df82 | 2010-11-08 14:04:44 -0800 | [diff] [blame^] | 505 | osd_page_free(hv_context.synic_message_page[cpu], 1); |
| 506 | osd_page_free(hv_context.synic_event_page[cpu], 1); |
Hank Janssen | 3e7ee49 | 2009-07-13 16:02:34 -0700 | [diff] [blame] | 507 | } |