]>
Commit | Line | Data |
---|---|---|
3e7ee490 | 1 | /* |
3e7ee490 HJ |
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 | */ | |
0a46618d HJ |
22 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
23 | ||
a0086dc5 GKH |
24 | #include <linux/kernel.h> |
25 | #include <linux/mm.h> | |
5a0e3ad6 | 26 | #include <linux/slab.h> |
b7c947f0 | 27 | #include <linux/vmalloc.h> |
46a97191 | 28 | #include <linux/hyperv.h> |
83ba0c4f | 29 | #include <linux/version.h> |
db11f12a | 30 | #include <linux/interrupt.h> |
4061ed9e | 31 | #include <linux/clockchips.h> |
407dd164 | 32 | #include <asm/hyperv.h> |
4061ed9e | 33 | #include <asm/mshyperv.h> |
0f2a6619 | 34 | #include "hyperv_vmbus.h" |
3e7ee490 | 35 | |
454f18a9 | 36 | /* The one and only */ |
6a0aaa18 HZ |
37 | struct hv_context hv_context = { |
38 | .synic_initialized = false, | |
3e7ee490 HJ |
39 | }; |
40 | ||
4061ed9e S |
41 | #define HV_TIMER_FREQUENCY (10 * 1000 * 1000) /* 100ns period */ |
42 | #define HV_MAX_MAX_DELTA_TICKS 0xffffffff | |
43 | #define HV_MIN_DELTA_TICKS 1 | |
44 | ||
3e189519 | 45 | /* |
d44890c8 | 46 | * hv_init - Main initialization routine. |
0831ad04 GKH |
47 | * |
48 | * This routine must be called before any other routines in here are called | |
49 | */ | |
d44890c8 | 50 | int hv_init(void) |
3e7ee490 | 51 | { |
73638cdd | 52 | if (!hv_is_hypercall_page_setup()) |
8730046c | 53 | return -ENOTSUPP; |
3e7ee490 | 54 | |
37cdd991 SH |
55 | hv_context.cpu_context = alloc_percpu(struct hv_per_cpu_context); |
56 | if (!hv_context.cpu_context) | |
57 | return -ENOMEM; | |
58 | ||
5433e003 | 59 | return 0; |
3e7ee490 HJ |
60 | } |
61 | ||
3e189519 | 62 | /* |
d44890c8 | 63 | * hv_post_message - Post a message using the hypervisor message IPC. |
0831ad04 GKH |
64 | * |
65 | * This involves a hypercall. | |
66 | */ | |
415f0a02 | 67 | int hv_post_message(union hv_connection_id connection_id, |
b8dfb264 HZ |
68 | enum hv_message_type message_type, |
69 | void *payload, size_t payload_size) | |
3e7ee490 | 70 | { |
b8dfb264 | 71 | struct hv_input_post_message *aligned_msg; |
37cdd991 | 72 | struct hv_per_cpu_context *hv_cpu; |
a108393d | 73 | u64 status; |
3e7ee490 | 74 | |
b8dfb264 | 75 | if (payload_size > HV_MESSAGE_PAYLOAD_BYTE_COUNT) |
39594abc | 76 | return -EMSGSIZE; |
3e7ee490 | 77 | |
37cdd991 SH |
78 | hv_cpu = get_cpu_ptr(hv_context.cpu_context); |
79 | aligned_msg = hv_cpu->post_msg_page; | |
b8dfb264 | 80 | aligned_msg->connectionid = connection_id; |
b29ef354 | 81 | aligned_msg->reserved = 0; |
b8dfb264 HZ |
82 | aligned_msg->message_type = message_type; |
83 | aligned_msg->payload_size = payload_size; | |
84 | memcpy((void *)aligned_msg->payload, payload, payload_size); | |
3e7ee490 | 85 | |
a108393d | 86 | status = hv_do_hypercall(HVCALL_POST_MESSAGE, aligned_msg, NULL); |
3e7ee490 | 87 | |
13b9abfc MK |
88 | /* Preemption must remain disabled until after the hypercall |
89 | * so some other thread can't get scheduled onto this cpu and | |
90 | * corrupt the per-cpu post_msg_page | |
91 | */ | |
92 | put_cpu_ptr(hv_cpu); | |
93 | ||
a108393d | 94 | return status & 0xFFFF; |
3e7ee490 HJ |
95 | } |
96 | ||
4061ed9e S |
97 | static int hv_ce_set_next_event(unsigned long delta, |
98 | struct clock_event_device *evt) | |
99 | { | |
a5a1d1c2 | 100 | u64 current_tick; |
4061ed9e | 101 | |
bc609cb4 | 102 | WARN_ON(!clockevent_state_oneshot(evt)); |
4061ed9e | 103 | |
e546d778 | 104 | current_tick = hyperv_cs->read(NULL); |
4061ed9e | 105 | current_tick += delta; |
d5116b40 | 106 | hv_init_timer(HV_X64_MSR_STIMER0_COUNT, current_tick); |
4061ed9e S |
107 | return 0; |
108 | } | |
109 | ||
bc609cb4 VK |
110 | static int hv_ce_shutdown(struct clock_event_device *evt) |
111 | { | |
d5116b40 S |
112 | hv_init_timer(HV_X64_MSR_STIMER0_COUNT, 0); |
113 | hv_init_timer_config(HV_X64_MSR_STIMER0_CONFIG, 0); | |
bc609cb4 VK |
114 | |
115 | return 0; | |
116 | } | |
117 | ||
118 | static int hv_ce_set_oneshot(struct clock_event_device *evt) | |
4061ed9e S |
119 | { |
120 | union hv_timer_config timer_cfg; | |
121 | ||
bc609cb4 VK |
122 | timer_cfg.enable = 1; |
123 | timer_cfg.auto_enable = 1; | |
124 | timer_cfg.sintx = VMBUS_MESSAGE_SINT; | |
d5116b40 | 125 | hv_init_timer_config(HV_X64_MSR_STIMER0_CONFIG, timer_cfg.as_uint64); |
bc609cb4 VK |
126 | |
127 | return 0; | |
4061ed9e S |
128 | } |
129 | ||
130 | static void hv_init_clockevent_device(struct clock_event_device *dev, int cpu) | |
131 | { | |
132 | dev->name = "Hyper-V clockevent"; | |
133 | dev->features = CLOCK_EVT_FEAT_ONESHOT; | |
134 | dev->cpumask = cpumask_of(cpu); | |
135 | dev->rating = 1000; | |
e086748c VK |
136 | /* |
137 | * Avoid settint dev->owner = THIS_MODULE deliberately as doing so will | |
138 | * result in clockevents_config_and_register() taking additional | |
139 | * references to the hv_vmbus module making it impossible to unload. | |
140 | */ | |
4061ed9e | 141 | |
bc609cb4 VK |
142 | dev->set_state_shutdown = hv_ce_shutdown; |
143 | dev->set_state_oneshot = hv_ce_set_oneshot; | |
4061ed9e S |
144 | dev->set_next_event = hv_ce_set_next_event; |
145 | } | |
146 | ||
2608fb65 JW |
147 | |
148 | int hv_synic_alloc(void) | |
149 | { | |
2608fb65 JW |
150 | int cpu; |
151 | ||
9f01ec53 S |
152 | hv_context.hv_numa_map = kzalloc(sizeof(struct cpumask) * nr_node_ids, |
153 | GFP_ATOMIC); | |
154 | if (hv_context.hv_numa_map == NULL) { | |
155 | pr_err("Unable to allocate NUMA map\n"); | |
156 | goto err; | |
157 | } | |
158 | ||
421b8f20 | 159 | for_each_present_cpu(cpu) { |
37cdd991 SH |
160 | struct hv_per_cpu_context *hv_cpu |
161 | = per_cpu_ptr(hv_context.cpu_context, cpu); | |
162 | ||
163 | memset(hv_cpu, 0, sizeof(*hv_cpu)); | |
37cdd991 SH |
164 | tasklet_init(&hv_cpu->msg_dpc, |
165 | vmbus_on_msg_dpc, (unsigned long) hv_cpu); | |
166 | ||
167 | hv_cpu->clk_evt = kzalloc(sizeof(struct clock_event_device), | |
168 | GFP_KERNEL); | |
169 | if (hv_cpu->clk_evt == NULL) { | |
4061ed9e S |
170 | pr_err("Unable to allocate clock event device\n"); |
171 | goto err; | |
172 | } | |
37cdd991 | 173 | hv_init_clockevent_device(hv_cpu->clk_evt, cpu); |
9f01ec53 | 174 | |
37cdd991 | 175 | hv_cpu->synic_message_page = |
2608fb65 | 176 | (void *)get_zeroed_page(GFP_ATOMIC); |
37cdd991 | 177 | if (hv_cpu->synic_message_page == NULL) { |
2608fb65 JW |
178 | pr_err("Unable to allocate SYNIC message page\n"); |
179 | goto err; | |
180 | } | |
181 | ||
37cdd991 SH |
182 | hv_cpu->synic_event_page = (void *)get_zeroed_page(GFP_ATOMIC); |
183 | if (hv_cpu->synic_event_page == NULL) { | |
2608fb65 JW |
184 | pr_err("Unable to allocate SYNIC event page\n"); |
185 | goto err; | |
186 | } | |
b29ef354 | 187 | |
37cdd991 SH |
188 | hv_cpu->post_msg_page = (void *)get_zeroed_page(GFP_ATOMIC); |
189 | if (hv_cpu->post_msg_page == NULL) { | |
b29ef354 S |
190 | pr_err("Unable to allocate post msg page\n"); |
191 | goto err; | |
192 | } | |
3c7630d3 | 193 | |
37cdd991 | 194 | INIT_LIST_HEAD(&hv_cpu->chan_list); |
2608fb65 JW |
195 | } |
196 | ||
197 | return 0; | |
198 | err: | |
199 | return -ENOMEM; | |
200 | } | |
201 | ||
2608fb65 JW |
202 | |
203 | void hv_synic_free(void) | |
204 | { | |
205 | int cpu; | |
206 | ||
37cdd991 SH |
207 | for_each_present_cpu(cpu) { |
208 | struct hv_per_cpu_context *hv_cpu | |
209 | = per_cpu_ptr(hv_context.cpu_context, cpu); | |
210 | ||
211 | if (hv_cpu->synic_event_page) | |
212 | free_page((unsigned long)hv_cpu->synic_event_page); | |
213 | if (hv_cpu->synic_message_page) | |
214 | free_page((unsigned long)hv_cpu->synic_message_page); | |
215 | if (hv_cpu->post_msg_page) | |
216 | free_page((unsigned long)hv_cpu->post_msg_page); | |
217 | } | |
218 | ||
9f01ec53 | 219 | kfree(hv_context.hv_numa_map); |
2608fb65 JW |
220 | } |
221 | ||
3e189519 | 222 | /* |
d44890c8 | 223 | * hv_synic_init - Initialize the Synthethic Interrupt Controller. |
0831ad04 GKH |
224 | * |
225 | * If it is already initialized by another entity (ie x2v shim), we need to | |
226 | * retrieve the initialized message and event pages. Otherwise, we create and | |
227 | * initialize the message and event pages. | |
228 | */ | |
76d36ab7 | 229 | int hv_synic_init(unsigned int cpu) |
3e7ee490 | 230 | { |
37cdd991 SH |
231 | struct hv_per_cpu_context *hv_cpu |
232 | = per_cpu_ptr(hv_context.cpu_context, cpu); | |
eacb1b4d GKH |
233 | union hv_synic_simp simp; |
234 | union hv_synic_siefp siefp; | |
b8dfb264 | 235 | union hv_synic_sint shared_sint; |
eacb1b4d | 236 | union hv_synic_scontrol sctrl; |
917ea427 | 237 | u64 vp_index; |
a73e6b7c | 238 | |
a73e6b7c | 239 | /* Setup the Synic's message page */ |
155e4a2f | 240 | hv_get_simp(simp.as_uint64); |
f6feebe0 | 241 | simp.simp_enabled = 1; |
37cdd991 | 242 | simp.base_simp_gpa = virt_to_phys(hv_cpu->synic_message_page) |
a73e6b7c | 243 | >> PAGE_SHIFT; |
3e7ee490 | 244 | |
155e4a2f | 245 | hv_set_simp(simp.as_uint64); |
3e7ee490 | 246 | |
a73e6b7c | 247 | /* Setup the Synic's event page */ |
8e307bf8 | 248 | hv_get_siefp(siefp.as_uint64); |
f6feebe0 | 249 | siefp.siefp_enabled = 1; |
37cdd991 | 250 | siefp.base_siefp_gpa = virt_to_phys(hv_cpu->synic_event_page) |
a73e6b7c HJ |
251 | >> PAGE_SHIFT; |
252 | ||
8e307bf8 | 253 | hv_set_siefp(siefp.as_uint64); |
0831ad04 | 254 | |
0831ad04 | 255 | /* Setup the shared SINT. */ |
37e11d5c S |
256 | hv_get_synint_state(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, |
257 | shared_sint.as_uint64); | |
3e7ee490 | 258 | |
b8dfb264 | 259 | shared_sint.as_uint64 = 0; |
302a3c0f | 260 | shared_sint.vector = HYPERVISOR_CALLBACK_VECTOR; |
b8dfb264 | 261 | shared_sint.masked = false; |
6c248aad S |
262 | if (ms_hyperv.hints & HV_X64_DEPRECATING_AEOI_RECOMMENDED) |
263 | shared_sint.auto_eoi = false; | |
264 | else | |
265 | shared_sint.auto_eoi = true; | |
3e7ee490 | 266 | |
37e11d5c S |
267 | hv_set_synint_state(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, |
268 | shared_sint.as_uint64); | |
3e7ee490 | 269 | |
454f18a9 | 270 | /* Enable the global synic bit */ |
06d1d98a | 271 | hv_get_synic_state(sctrl.as_uint64); |
f6feebe0 | 272 | sctrl.enable = 1; |
3e7ee490 | 273 | |
06d1d98a | 274 | hv_set_synic_state(sctrl.as_uint64); |
3e7ee490 | 275 | |
6a0aaa18 | 276 | hv_context.synic_initialized = true; |
917ea427 S |
277 | |
278 | /* | |
279 | * Setup the mapping between Hyper-V's notion | |
280 | * of cpuid and Linux' notion of cpuid. | |
281 | * This array will be indexed using Linux cpuid. | |
282 | */ | |
7297ff0c | 283 | hv_get_vp_index(vp_index); |
917ea427 | 284 | hv_context.vp_index[cpu] = (u32)vp_index; |
3a28fa35 | 285 | |
4061ed9e S |
286 | /* |
287 | * Register the per-cpu clockevent source. | |
288 | */ | |
289 | if (ms_hyperv.features & HV_X64_MSR_SYNTIMER_AVAILABLE) | |
37cdd991 | 290 | clockevents_config_and_register(hv_cpu->clk_evt, |
4061ed9e S |
291 | HV_TIMER_FREQUENCY, |
292 | HV_MIN_DELTA_TICKS, | |
293 | HV_MAX_MAX_DELTA_TICKS); | |
76d36ab7 | 294 | return 0; |
3e7ee490 HJ |
295 | } |
296 | ||
e086748c VK |
297 | /* |
298 | * hv_synic_clockevents_cleanup - Cleanup clockevent devices | |
299 | */ | |
300 | void hv_synic_clockevents_cleanup(void) | |
301 | { | |
302 | int cpu; | |
303 | ||
304 | if (!(ms_hyperv.features & HV_X64_MSR_SYNTIMER_AVAILABLE)) | |
305 | return; | |
306 | ||
37cdd991 SH |
307 | for_each_present_cpu(cpu) { |
308 | struct hv_per_cpu_context *hv_cpu | |
309 | = per_cpu_ptr(hv_context.cpu_context, cpu); | |
310 | ||
311 | clockevents_unbind_device(hv_cpu->clk_evt, cpu); | |
312 | } | |
e086748c VK |
313 | } |
314 | ||
3e189519 | 315 | /* |
d44890c8 | 316 | * hv_synic_cleanup - Cleanup routine for hv_synic_init(). |
0831ad04 | 317 | */ |
76d36ab7 | 318 | int hv_synic_cleanup(unsigned int cpu) |
3e7ee490 | 319 | { |
b8dfb264 | 320 | union hv_synic_sint shared_sint; |
eacb1b4d GKH |
321 | union hv_synic_simp simp; |
322 | union hv_synic_siefp siefp; | |
e72e7ac5 | 323 | union hv_synic_scontrol sctrl; |
523b9408 VK |
324 | struct vmbus_channel *channel, *sc; |
325 | bool channel_found = false; | |
326 | unsigned long flags; | |
3e7ee490 | 327 | |
6a0aaa18 | 328 | if (!hv_context.synic_initialized) |
76d36ab7 | 329 | return -EFAULT; |
3e7ee490 | 330 | |
523b9408 VK |
331 | /* |
332 | * Search for channels which are bound to the CPU we're about to | |
333 | * cleanup. In case we find one and vmbus is still connected we need to | |
334 | * fail, this will effectively prevent CPU offlining. There is no way | |
335 | * we can re-bind channels to different CPUs for now. | |
336 | */ | |
337 | mutex_lock(&vmbus_connection.channel_mutex); | |
338 | list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) { | |
339 | if (channel->target_cpu == cpu) { | |
340 | channel_found = true; | |
341 | break; | |
342 | } | |
343 | spin_lock_irqsave(&channel->lock, flags); | |
344 | list_for_each_entry(sc, &channel->sc_list, sc_list) { | |
345 | if (sc->target_cpu == cpu) { | |
346 | channel_found = true; | |
347 | break; | |
348 | } | |
349 | } | |
350 | spin_unlock_irqrestore(&channel->lock, flags); | |
351 | if (channel_found) | |
352 | break; | |
353 | } | |
354 | mutex_unlock(&vmbus_connection.channel_mutex); | |
355 | ||
356 | if (channel_found && vmbus_connection.conn_state == CONNECTED) | |
357 | return -EBUSY; | |
358 | ||
e086748c | 359 | /* Turn off clockevent device */ |
6ffc4b85 | 360 | if (ms_hyperv.features & HV_X64_MSR_SYNTIMER_AVAILABLE) { |
37cdd991 SH |
361 | struct hv_per_cpu_context *hv_cpu |
362 | = this_cpu_ptr(hv_context.cpu_context); | |
363 | ||
364 | clockevents_unbind_device(hv_cpu->clk_evt, cpu); | |
365 | hv_ce_shutdown(hv_cpu->clk_evt); | |
366 | put_cpu_ptr(hv_cpu); | |
6ffc4b85 | 367 | } |
e086748c | 368 | |
37e11d5c S |
369 | hv_get_synint_state(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, |
370 | shared_sint.as_uint64); | |
3e7ee490 | 371 | |
b8dfb264 | 372 | shared_sint.masked = 1; |
3e7ee490 | 373 | |
7692fd4d | 374 | /* Need to correctly cleanup in the case of SMP!!! */ |
454f18a9 | 375 | /* Disable the interrupt */ |
37e11d5c S |
376 | hv_set_synint_state(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, |
377 | shared_sint.as_uint64); | |
3e7ee490 | 378 | |
155e4a2f | 379 | hv_get_simp(simp.as_uint64); |
f6feebe0 HZ |
380 | simp.simp_enabled = 0; |
381 | simp.base_simp_gpa = 0; | |
3e7ee490 | 382 | |
155e4a2f | 383 | hv_set_simp(simp.as_uint64); |
3e7ee490 | 384 | |
8e307bf8 | 385 | hv_get_siefp(siefp.as_uint64); |
f6feebe0 HZ |
386 | siefp.siefp_enabled = 0; |
387 | siefp.base_siefp_gpa = 0; | |
3e7ee490 | 388 | |
8e307bf8 | 389 | hv_set_siefp(siefp.as_uint64); |
3e7ee490 | 390 | |
e72e7ac5 | 391 | /* Disable the global synic bit */ |
06d1d98a | 392 | hv_get_synic_state(sctrl.as_uint64); |
e72e7ac5 | 393 | sctrl.enable = 0; |
06d1d98a | 394 | hv_set_synic_state(sctrl.as_uint64); |
76d36ab7 VK |
395 | |
396 | return 0; | |
3e7ee490 | 397 | } |