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); | |
37cdd991 | 85 | put_cpu_ptr(hv_cpu); |
3e7ee490 | 86 | |
a108393d | 87 | status = hv_do_hypercall(HVCALL_POST_MESSAGE, aligned_msg, NULL); |
3e7ee490 | 88 | |
a108393d | 89 | return status & 0xFFFF; |
3e7ee490 HJ |
90 | } |
91 | ||
4061ed9e S |
92 | static int hv_ce_set_next_event(unsigned long delta, |
93 | struct clock_event_device *evt) | |
94 | { | |
a5a1d1c2 | 95 | u64 current_tick; |
4061ed9e | 96 | |
bc609cb4 | 97 | WARN_ON(!clockevent_state_oneshot(evt)); |
4061ed9e | 98 | |
d5116b40 | 99 | hv_get_current_tick(current_tick); |
4061ed9e | 100 | current_tick += delta; |
d5116b40 | 101 | hv_init_timer(HV_X64_MSR_STIMER0_COUNT, current_tick); |
4061ed9e S |
102 | return 0; |
103 | } | |
104 | ||
bc609cb4 VK |
105 | static int hv_ce_shutdown(struct clock_event_device *evt) |
106 | { | |
d5116b40 S |
107 | hv_init_timer(HV_X64_MSR_STIMER0_COUNT, 0); |
108 | hv_init_timer_config(HV_X64_MSR_STIMER0_CONFIG, 0); | |
bc609cb4 VK |
109 | |
110 | return 0; | |
111 | } | |
112 | ||
113 | static int hv_ce_set_oneshot(struct clock_event_device *evt) | |
4061ed9e S |
114 | { |
115 | union hv_timer_config timer_cfg; | |
116 | ||
bc609cb4 VK |
117 | timer_cfg.enable = 1; |
118 | timer_cfg.auto_enable = 1; | |
119 | timer_cfg.sintx = VMBUS_MESSAGE_SINT; | |
d5116b40 | 120 | hv_init_timer_config(HV_X64_MSR_STIMER0_CONFIG, timer_cfg.as_uint64); |
bc609cb4 VK |
121 | |
122 | return 0; | |
4061ed9e S |
123 | } |
124 | ||
125 | static void hv_init_clockevent_device(struct clock_event_device *dev, int cpu) | |
126 | { | |
127 | dev->name = "Hyper-V clockevent"; | |
128 | dev->features = CLOCK_EVT_FEAT_ONESHOT; | |
129 | dev->cpumask = cpumask_of(cpu); | |
130 | dev->rating = 1000; | |
e086748c VK |
131 | /* |
132 | * Avoid settint dev->owner = THIS_MODULE deliberately as doing so will | |
133 | * result in clockevents_config_and_register() taking additional | |
134 | * references to the hv_vmbus module making it impossible to unload. | |
135 | */ | |
4061ed9e | 136 | |
bc609cb4 VK |
137 | dev->set_state_shutdown = hv_ce_shutdown; |
138 | dev->set_state_oneshot = hv_ce_set_oneshot; | |
4061ed9e S |
139 | dev->set_next_event = hv_ce_set_next_event; |
140 | } | |
141 | ||
2608fb65 JW |
142 | |
143 | int hv_synic_alloc(void) | |
144 | { | |
2608fb65 JW |
145 | int cpu; |
146 | ||
9f01ec53 S |
147 | hv_context.hv_numa_map = kzalloc(sizeof(struct cpumask) * nr_node_ids, |
148 | GFP_ATOMIC); | |
149 | if (hv_context.hv_numa_map == NULL) { | |
150 | pr_err("Unable to allocate NUMA map\n"); | |
151 | goto err; | |
152 | } | |
153 | ||
421b8f20 | 154 | for_each_present_cpu(cpu) { |
37cdd991 SH |
155 | struct hv_per_cpu_context *hv_cpu |
156 | = per_cpu_ptr(hv_context.cpu_context, cpu); | |
157 | ||
158 | memset(hv_cpu, 0, sizeof(*hv_cpu)); | |
37cdd991 SH |
159 | tasklet_init(&hv_cpu->msg_dpc, |
160 | vmbus_on_msg_dpc, (unsigned long) hv_cpu); | |
161 | ||
162 | hv_cpu->clk_evt = kzalloc(sizeof(struct clock_event_device), | |
163 | GFP_KERNEL); | |
164 | if (hv_cpu->clk_evt == NULL) { | |
4061ed9e S |
165 | pr_err("Unable to allocate clock event device\n"); |
166 | goto err; | |
167 | } | |
37cdd991 | 168 | hv_init_clockevent_device(hv_cpu->clk_evt, cpu); |
9f01ec53 | 169 | |
37cdd991 | 170 | hv_cpu->synic_message_page = |
2608fb65 | 171 | (void *)get_zeroed_page(GFP_ATOMIC); |
37cdd991 | 172 | if (hv_cpu->synic_message_page == NULL) { |
2608fb65 JW |
173 | pr_err("Unable to allocate SYNIC message page\n"); |
174 | goto err; | |
175 | } | |
176 | ||
37cdd991 SH |
177 | hv_cpu->synic_event_page = (void *)get_zeroed_page(GFP_ATOMIC); |
178 | if (hv_cpu->synic_event_page == NULL) { | |
2608fb65 JW |
179 | pr_err("Unable to allocate SYNIC event page\n"); |
180 | goto err; | |
181 | } | |
b29ef354 | 182 | |
37cdd991 SH |
183 | hv_cpu->post_msg_page = (void *)get_zeroed_page(GFP_ATOMIC); |
184 | if (hv_cpu->post_msg_page == NULL) { | |
b29ef354 S |
185 | pr_err("Unable to allocate post msg page\n"); |
186 | goto err; | |
187 | } | |
3c7630d3 | 188 | |
37cdd991 | 189 | INIT_LIST_HEAD(&hv_cpu->chan_list); |
2608fb65 JW |
190 | } |
191 | ||
192 | return 0; | |
193 | err: | |
194 | return -ENOMEM; | |
195 | } | |
196 | ||
2608fb65 JW |
197 | |
198 | void hv_synic_free(void) | |
199 | { | |
200 | int cpu; | |
201 | ||
37cdd991 SH |
202 | for_each_present_cpu(cpu) { |
203 | struct hv_per_cpu_context *hv_cpu | |
204 | = per_cpu_ptr(hv_context.cpu_context, cpu); | |
205 | ||
206 | if (hv_cpu->synic_event_page) | |
207 | free_page((unsigned long)hv_cpu->synic_event_page); | |
208 | if (hv_cpu->synic_message_page) | |
209 | free_page((unsigned long)hv_cpu->synic_message_page); | |
210 | if (hv_cpu->post_msg_page) | |
211 | free_page((unsigned long)hv_cpu->post_msg_page); | |
212 | } | |
213 | ||
9f01ec53 | 214 | kfree(hv_context.hv_numa_map); |
2608fb65 JW |
215 | } |
216 | ||
3e189519 | 217 | /* |
d44890c8 | 218 | * hv_synic_init - Initialize the Synthethic Interrupt Controller. |
0831ad04 GKH |
219 | * |
220 | * If it is already initialized by another entity (ie x2v shim), we need to | |
221 | * retrieve the initialized message and event pages. Otherwise, we create and | |
222 | * initialize the message and event pages. | |
223 | */ | |
76d36ab7 | 224 | int hv_synic_init(unsigned int cpu) |
3e7ee490 | 225 | { |
37cdd991 SH |
226 | struct hv_per_cpu_context *hv_cpu |
227 | = per_cpu_ptr(hv_context.cpu_context, cpu); | |
eacb1b4d GKH |
228 | union hv_synic_simp simp; |
229 | union hv_synic_siefp siefp; | |
b8dfb264 | 230 | union hv_synic_sint shared_sint; |
eacb1b4d | 231 | union hv_synic_scontrol sctrl; |
917ea427 | 232 | u64 vp_index; |
a73e6b7c | 233 | |
a73e6b7c | 234 | /* Setup the Synic's message page */ |
155e4a2f | 235 | hv_get_simp(simp.as_uint64); |
f6feebe0 | 236 | simp.simp_enabled = 1; |
37cdd991 | 237 | simp.base_simp_gpa = virt_to_phys(hv_cpu->synic_message_page) |
a73e6b7c | 238 | >> PAGE_SHIFT; |
3e7ee490 | 239 | |
155e4a2f | 240 | hv_set_simp(simp.as_uint64); |
3e7ee490 | 241 | |
a73e6b7c | 242 | /* Setup the Synic's event page */ |
8e307bf8 | 243 | hv_get_siefp(siefp.as_uint64); |
f6feebe0 | 244 | siefp.siefp_enabled = 1; |
37cdd991 | 245 | siefp.base_siefp_gpa = virt_to_phys(hv_cpu->synic_event_page) |
a73e6b7c HJ |
246 | >> PAGE_SHIFT; |
247 | ||
8e307bf8 | 248 | hv_set_siefp(siefp.as_uint64); |
0831ad04 | 249 | |
0831ad04 | 250 | /* Setup the shared SINT. */ |
37e11d5c S |
251 | hv_get_synint_state(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, |
252 | shared_sint.as_uint64); | |
3e7ee490 | 253 | |
b8dfb264 | 254 | shared_sint.as_uint64 = 0; |
302a3c0f | 255 | shared_sint.vector = HYPERVISOR_CALLBACK_VECTOR; |
b8dfb264 | 256 | shared_sint.masked = false; |
6c248aad S |
257 | if (ms_hyperv.hints & HV_X64_DEPRECATING_AEOI_RECOMMENDED) |
258 | shared_sint.auto_eoi = false; | |
259 | else | |
260 | shared_sint.auto_eoi = true; | |
3e7ee490 | 261 | |
37e11d5c S |
262 | hv_set_synint_state(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, |
263 | shared_sint.as_uint64); | |
3e7ee490 | 264 | |
454f18a9 | 265 | /* Enable the global synic bit */ |
06d1d98a | 266 | hv_get_synic_state(sctrl.as_uint64); |
f6feebe0 | 267 | sctrl.enable = 1; |
3e7ee490 | 268 | |
06d1d98a | 269 | hv_set_synic_state(sctrl.as_uint64); |
3e7ee490 | 270 | |
6a0aaa18 | 271 | hv_context.synic_initialized = true; |
917ea427 S |
272 | |
273 | /* | |
274 | * Setup the mapping between Hyper-V's notion | |
275 | * of cpuid and Linux' notion of cpuid. | |
276 | * This array will be indexed using Linux cpuid. | |
277 | */ | |
7297ff0c | 278 | hv_get_vp_index(vp_index); |
917ea427 | 279 | hv_context.vp_index[cpu] = (u32)vp_index; |
3a28fa35 | 280 | |
4061ed9e S |
281 | /* |
282 | * Register the per-cpu clockevent source. | |
283 | */ | |
284 | if (ms_hyperv.features & HV_X64_MSR_SYNTIMER_AVAILABLE) | |
37cdd991 | 285 | clockevents_config_and_register(hv_cpu->clk_evt, |
4061ed9e S |
286 | HV_TIMER_FREQUENCY, |
287 | HV_MIN_DELTA_TICKS, | |
288 | HV_MAX_MAX_DELTA_TICKS); | |
76d36ab7 | 289 | return 0; |
3e7ee490 HJ |
290 | } |
291 | ||
e086748c VK |
292 | /* |
293 | * hv_synic_clockevents_cleanup - Cleanup clockevent devices | |
294 | */ | |
295 | void hv_synic_clockevents_cleanup(void) | |
296 | { | |
297 | int cpu; | |
298 | ||
299 | if (!(ms_hyperv.features & HV_X64_MSR_SYNTIMER_AVAILABLE)) | |
300 | return; | |
301 | ||
37cdd991 SH |
302 | for_each_present_cpu(cpu) { |
303 | struct hv_per_cpu_context *hv_cpu | |
304 | = per_cpu_ptr(hv_context.cpu_context, cpu); | |
305 | ||
306 | clockevents_unbind_device(hv_cpu->clk_evt, cpu); | |
307 | } | |
e086748c VK |
308 | } |
309 | ||
3e189519 | 310 | /* |
d44890c8 | 311 | * hv_synic_cleanup - Cleanup routine for hv_synic_init(). |
0831ad04 | 312 | */ |
76d36ab7 | 313 | int hv_synic_cleanup(unsigned int cpu) |
3e7ee490 | 314 | { |
b8dfb264 | 315 | union hv_synic_sint shared_sint; |
eacb1b4d GKH |
316 | union hv_synic_simp simp; |
317 | union hv_synic_siefp siefp; | |
e72e7ac5 | 318 | union hv_synic_scontrol sctrl; |
523b9408 VK |
319 | struct vmbus_channel *channel, *sc; |
320 | bool channel_found = false; | |
321 | unsigned long flags; | |
3e7ee490 | 322 | |
6a0aaa18 | 323 | if (!hv_context.synic_initialized) |
76d36ab7 | 324 | return -EFAULT; |
3e7ee490 | 325 | |
523b9408 VK |
326 | /* |
327 | * Search for channels which are bound to the CPU we're about to | |
328 | * cleanup. In case we find one and vmbus is still connected we need to | |
329 | * fail, this will effectively prevent CPU offlining. There is no way | |
330 | * we can re-bind channels to different CPUs for now. | |
331 | */ | |
332 | mutex_lock(&vmbus_connection.channel_mutex); | |
333 | list_for_each_entry(channel, &vmbus_connection.chn_list, listentry) { | |
334 | if (channel->target_cpu == cpu) { | |
335 | channel_found = true; | |
336 | break; | |
337 | } | |
338 | spin_lock_irqsave(&channel->lock, flags); | |
339 | list_for_each_entry(sc, &channel->sc_list, sc_list) { | |
340 | if (sc->target_cpu == cpu) { | |
341 | channel_found = true; | |
342 | break; | |
343 | } | |
344 | } | |
345 | spin_unlock_irqrestore(&channel->lock, flags); | |
346 | if (channel_found) | |
347 | break; | |
348 | } | |
349 | mutex_unlock(&vmbus_connection.channel_mutex); | |
350 | ||
351 | if (channel_found && vmbus_connection.conn_state == CONNECTED) | |
352 | return -EBUSY; | |
353 | ||
e086748c | 354 | /* Turn off clockevent device */ |
6ffc4b85 | 355 | if (ms_hyperv.features & HV_X64_MSR_SYNTIMER_AVAILABLE) { |
37cdd991 SH |
356 | struct hv_per_cpu_context *hv_cpu |
357 | = this_cpu_ptr(hv_context.cpu_context); | |
358 | ||
359 | clockevents_unbind_device(hv_cpu->clk_evt, cpu); | |
360 | hv_ce_shutdown(hv_cpu->clk_evt); | |
361 | put_cpu_ptr(hv_cpu); | |
6ffc4b85 | 362 | } |
e086748c | 363 | |
37e11d5c S |
364 | hv_get_synint_state(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, |
365 | shared_sint.as_uint64); | |
3e7ee490 | 366 | |
b8dfb264 | 367 | shared_sint.masked = 1; |
3e7ee490 | 368 | |
7692fd4d | 369 | /* Need to correctly cleanup in the case of SMP!!! */ |
454f18a9 | 370 | /* Disable the interrupt */ |
37e11d5c S |
371 | hv_set_synint_state(HV_X64_MSR_SINT0 + VMBUS_MESSAGE_SINT, |
372 | shared_sint.as_uint64); | |
3e7ee490 | 373 | |
155e4a2f | 374 | hv_get_simp(simp.as_uint64); |
f6feebe0 HZ |
375 | simp.simp_enabled = 0; |
376 | simp.base_simp_gpa = 0; | |
3e7ee490 | 377 | |
155e4a2f | 378 | hv_set_simp(simp.as_uint64); |
3e7ee490 | 379 | |
8e307bf8 | 380 | hv_get_siefp(siefp.as_uint64); |
f6feebe0 HZ |
381 | siefp.siefp_enabled = 0; |
382 | siefp.base_siefp_gpa = 0; | |
3e7ee490 | 383 | |
8e307bf8 | 384 | hv_set_siefp(siefp.as_uint64); |
3e7ee490 | 385 | |
e72e7ac5 | 386 | /* Disable the global synic bit */ |
06d1d98a | 387 | hv_get_synic_state(sctrl.as_uint64); |
e72e7ac5 | 388 | sctrl.enable = 0; |
06d1d98a | 389 | hv_set_synic_state(sctrl.as_uint64); |
76d36ab7 VK |
390 | |
391 | return 0; | |
3e7ee490 | 392 | } |