blob: 328e4c3808e06d146add9ade074efd2d1728e1dd [file] [log] [blame]
Hank Janssen3e7ee492009-07-13 16:02:34 -07001/*
Hank Janssen3e7ee492009-07-13 16:02:34 -07002 * 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>
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -070020 * K. Y. Srinivasan <kys@microsoft.com>
K. Y. Srinivasan52e5c1c2011-03-15 15:03:34 -070021 *
Hank Janssen3e7ee492009-07-13 16:02:34 -070022 */
Hank Janssen0a466182011-03-29 13:58:47 -070023#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24
Hank Janssen3e7ee492009-07-13 16:02:34 -070025#include <linux/init.h>
26#include <linux/module.h>
27#include <linux/device.h>
Hank Janssen3e7ee492009-07-13 16:02:34 -070028#include <linux/interrupt.h>
29#include <linux/sysctl.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090030#include <linux/slab.h>
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -070031#include <linux/acpi.h>
Haiyang Zhang8b5d6d32010-05-28 23:22:44 +000032#include <linux/completion.h>
Greg Kroah-Hartman46a97192011-10-04 12:29:52 -070033#include <linux/hyperv.h>
K. Y. Srinivasanb0209502012-12-01 06:46:54 -080034#include <linux/kernel_stat.h>
K. Y. Srinivasan4061ed92015-01-09 23:54:32 -080035#include <linux/clockchips.h>
Vitaly Kuznetsove5132292015-02-27 11:25:51 -080036#include <linux/cpu.h>
Greg Kroah-Hartman407dd162011-10-11 08:36:44 -060037#include <asm/hyperv.h>
Jason Wang1f94ea82012-08-31 13:32:44 +080038#include <asm/hypervisor.h>
K. Y. Srinivasan302a3c02013-02-17 11:30:44 -080039#include <asm/mshyperv.h>
Nick Meier96c1d052015-02-28 11:39:01 -080040#include <linux/notifier.h>
41#include <linux/ptrace.h>
Jake Oshins35464482015-08-05 00:52:37 -070042#include <linux/screen_info.h>
Vitaly Kuznetsov510f7ae2015-08-01 16:08:10 -070043#include <linux/kdebug.h>
K. Y. Srinivasan0f2a6612011-05-12 19:34:28 -070044#include "hyperv_vmbus.h"
Hank Janssen3e7ee492009-07-13 16:02:34 -070045
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -070046static struct acpi_device *hv_acpi_dev;
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -070047
K. Y. Srinivasan59c0e4f2011-04-29 13:45:06 -070048static struct tasklet_struct msg_dpc;
K. Y. Srinivasan71a66552011-04-29 13:45:04 -070049static struct completion probe_event;
Hank Janssen3e7ee492009-07-13 16:02:34 -070050
Nick Meier96c1d052015-02-28 11:39:01 -080051
Vitaly Kuznetsov510f7ae2015-08-01 16:08:10 -070052static void hyperv_report_panic(struct pt_regs *regs)
Nick Meier96c1d052015-02-28 11:39:01 -080053{
Vitaly Kuznetsov510f7ae2015-08-01 16:08:10 -070054 static bool panic_reported;
Nick Meier96c1d052015-02-28 11:39:01 -080055
Vitaly Kuznetsov510f7ae2015-08-01 16:08:10 -070056 /*
57 * We prefer to report panic on 'die' chain as we have proper
58 * registers to report, but if we miss it (e.g. on BUG()) we need
59 * to report it on 'panic'.
60 */
61 if (panic_reported)
62 return;
63 panic_reported = true;
Nick Meier96c1d052015-02-28 11:39:01 -080064
65 wrmsrl(HV_X64_MSR_CRASH_P0, regs->ip);
66 wrmsrl(HV_X64_MSR_CRASH_P1, regs->ax);
67 wrmsrl(HV_X64_MSR_CRASH_P2, regs->bx);
68 wrmsrl(HV_X64_MSR_CRASH_P3, regs->cx);
69 wrmsrl(HV_X64_MSR_CRASH_P4, regs->dx);
70
71 /*
72 * Let Hyper-V know there is crash data available
73 */
74 wrmsrl(HV_X64_MSR_CRASH_CTL, HV_CRASH_CTL_CRASH_NOTIFY);
Vitaly Kuznetsov510f7ae2015-08-01 16:08:10 -070075}
76
77static int hyperv_panic_event(struct notifier_block *nb, unsigned long val,
78 void *args)
79{
80 struct pt_regs *regs;
81
82 regs = current_pt_regs();
83
84 hyperv_report_panic(regs);
Nick Meier96c1d052015-02-28 11:39:01 -080085 return NOTIFY_DONE;
86}
87
Vitaly Kuznetsov510f7ae2015-08-01 16:08:10 -070088static int hyperv_die_event(struct notifier_block *nb, unsigned long val,
89 void *args)
90{
91 struct die_args *die = (struct die_args *)args;
92 struct pt_regs *regs = die->regs;
93
94 hyperv_report_panic(regs);
95 return NOTIFY_DONE;
96}
97
98static struct notifier_block hyperv_die_block = {
99 .notifier_call = hyperv_die_event,
100};
Nick Meier96c1d052015-02-28 11:39:01 -0800101static struct notifier_block hyperv_panic_block = {
102 .notifier_call = hyperv_panic_event,
103};
104
Jake Oshins7f163a62015-08-05 00:52:36 -0700105struct resource *hyperv_mmio;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700106
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -0800107static int vmbus_exists(void)
108{
109 if (hv_acpi_dev == NULL)
110 return -ENODEV;
111
112 return 0;
113}
114
Olaf Heringfd776ba2011-09-02 18:25:56 +0200115#define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
116static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
117{
118 int i;
119 for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
120 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
121}
122
Greg Kroah-Hartman76c52bb2013-09-13 11:32:56 -0700123static u8 channel_monitor_group(struct vmbus_channel *channel)
124{
125 return (u8)channel->offermsg.monitorid / 32;
126}
127
128static u8 channel_monitor_offset(struct vmbus_channel *channel)
129{
130 return (u8)channel->offermsg.monitorid % 32;
131}
132
133static u32 channel_pending(struct vmbus_channel *channel,
134 struct hv_monitor_page *monitor_page)
135{
136 u8 monitor_group = channel_monitor_group(channel);
137 return monitor_page->trigger_group[monitor_group].pending;
138}
139
Greg Kroah-Hartman1cee2722013-09-13 11:32:57 -0700140static u32 channel_latency(struct vmbus_channel *channel,
141 struct hv_monitor_page *monitor_page)
142{
143 u8 monitor_group = channel_monitor_group(channel);
144 u8 monitor_offset = channel_monitor_offset(channel);
145 return monitor_page->latency[monitor_group][monitor_offset];
146}
147
Greg Kroah-Hartman4947c742013-09-13 11:32:58 -0700148static u32 channel_conn_id(struct vmbus_channel *channel,
149 struct hv_monitor_page *monitor_page)
150{
151 u8 monitor_group = channel_monitor_group(channel);
152 u8 monitor_offset = channel_monitor_offset(channel);
153 return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id;
154}
155
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700156static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr,
157 char *buf)
158{
159 struct hv_device *hv_dev = device_to_hv_device(dev);
160
161 if (!hv_dev->channel)
162 return -ENODEV;
163 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid);
164}
165static DEVICE_ATTR_RO(id);
166
Greg Kroah-Hartmana8fb5f32013-09-13 11:32:50 -0700167static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr,
168 char *buf)
169{
170 struct hv_device *hv_dev = device_to_hv_device(dev);
171
172 if (!hv_dev->channel)
173 return -ENODEV;
174 return sprintf(buf, "%d\n", hv_dev->channel->state);
175}
176static DEVICE_ATTR_RO(state);
177
Greg Kroah-Hartman5ffd00e2013-09-13 11:32:51 -0700178static ssize_t monitor_id_show(struct device *dev,
179 struct device_attribute *dev_attr, char *buf)
180{
181 struct hv_device *hv_dev = device_to_hv_device(dev);
182
183 if (!hv_dev->channel)
184 return -ENODEV;
185 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid);
186}
187static DEVICE_ATTR_RO(monitor_id);
188
Greg Kroah-Hartman68234c02013-09-13 11:32:53 -0700189static ssize_t class_id_show(struct device *dev,
190 struct device_attribute *dev_attr, char *buf)
191{
192 struct hv_device *hv_dev = device_to_hv_device(dev);
193
194 if (!hv_dev->channel)
195 return -ENODEV;
196 return sprintf(buf, "{%pUl}\n",
197 hv_dev->channel->offermsg.offer.if_type.b);
198}
199static DEVICE_ATTR_RO(class_id);
200
Greg Kroah-Hartman7c55e1d2013-09-13 11:32:54 -0700201static ssize_t device_id_show(struct device *dev,
202 struct device_attribute *dev_attr, char *buf)
203{
204 struct hv_device *hv_dev = device_to_hv_device(dev);
205
206 if (!hv_dev->channel)
207 return -ENODEV;
208 return sprintf(buf, "{%pUl}\n",
209 hv_dev->channel->offermsg.offer.if_instance.b);
210}
211static DEVICE_ATTR_RO(device_id);
212
Greg Kroah-Hartman647fa372013-09-13 11:32:52 -0700213static ssize_t modalias_show(struct device *dev,
214 struct device_attribute *dev_attr, char *buf)
215{
216 struct hv_device *hv_dev = device_to_hv_device(dev);
217 char alias_name[VMBUS_ALIAS_LEN + 1];
218
219 print_alias_name(hv_dev, alias_name);
220 return sprintf(buf, "vmbus:%s\n", alias_name);
221}
222static DEVICE_ATTR_RO(modalias);
223
Greg Kroah-Hartman76c52bb2013-09-13 11:32:56 -0700224static ssize_t server_monitor_pending_show(struct device *dev,
225 struct device_attribute *dev_attr,
226 char *buf)
227{
228 struct hv_device *hv_dev = device_to_hv_device(dev);
229
230 if (!hv_dev->channel)
231 return -ENODEV;
232 return sprintf(buf, "%d\n",
233 channel_pending(hv_dev->channel,
234 vmbus_connection.monitor_pages[1]));
235}
236static DEVICE_ATTR_RO(server_monitor_pending);
237
238static ssize_t client_monitor_pending_show(struct device *dev,
239 struct device_attribute *dev_attr,
240 char *buf)
241{
242 struct hv_device *hv_dev = device_to_hv_device(dev);
243
244 if (!hv_dev->channel)
245 return -ENODEV;
246 return sprintf(buf, "%d\n",
247 channel_pending(hv_dev->channel,
248 vmbus_connection.monitor_pages[1]));
249}
250static DEVICE_ATTR_RO(client_monitor_pending);
Greg Kroah-Hartman68234c02013-09-13 11:32:53 -0700251
Greg Kroah-Hartman1cee2722013-09-13 11:32:57 -0700252static ssize_t server_monitor_latency_show(struct device *dev,
253 struct device_attribute *dev_attr,
254 char *buf)
255{
256 struct hv_device *hv_dev = device_to_hv_device(dev);
257
258 if (!hv_dev->channel)
259 return -ENODEV;
260 return sprintf(buf, "%d\n",
261 channel_latency(hv_dev->channel,
262 vmbus_connection.monitor_pages[0]));
263}
264static DEVICE_ATTR_RO(server_monitor_latency);
265
266static ssize_t client_monitor_latency_show(struct device *dev,
267 struct device_attribute *dev_attr,
268 char *buf)
269{
270 struct hv_device *hv_dev = device_to_hv_device(dev);
271
272 if (!hv_dev->channel)
273 return -ENODEV;
274 return sprintf(buf, "%d\n",
275 channel_latency(hv_dev->channel,
276 vmbus_connection.monitor_pages[1]));
277}
278static DEVICE_ATTR_RO(client_monitor_latency);
279
Greg Kroah-Hartman4947c742013-09-13 11:32:58 -0700280static ssize_t server_monitor_conn_id_show(struct device *dev,
281 struct device_attribute *dev_attr,
282 char *buf)
283{
284 struct hv_device *hv_dev = device_to_hv_device(dev);
285
286 if (!hv_dev->channel)
287 return -ENODEV;
288 return sprintf(buf, "%d\n",
289 channel_conn_id(hv_dev->channel,
290 vmbus_connection.monitor_pages[0]));
291}
292static DEVICE_ATTR_RO(server_monitor_conn_id);
293
294static ssize_t client_monitor_conn_id_show(struct device *dev,
295 struct device_attribute *dev_attr,
296 char *buf)
297{
298 struct hv_device *hv_dev = device_to_hv_device(dev);
299
300 if (!hv_dev->channel)
301 return -ENODEV;
302 return sprintf(buf, "%d\n",
303 channel_conn_id(hv_dev->channel,
304 vmbus_connection.monitor_pages[1]));
305}
306static DEVICE_ATTR_RO(client_monitor_conn_id);
307
Greg Kroah-Hartman98f4c652013-09-13 11:33:01 -0700308static ssize_t out_intr_mask_show(struct device *dev,
309 struct device_attribute *dev_attr, char *buf)
310{
311 struct hv_device *hv_dev = device_to_hv_device(dev);
312 struct hv_ring_buffer_debug_info outbound;
313
314 if (!hv_dev->channel)
315 return -ENODEV;
316 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
317 return sprintf(buf, "%d\n", outbound.current_interrupt_mask);
318}
319static DEVICE_ATTR_RO(out_intr_mask);
320
321static ssize_t out_read_index_show(struct device *dev,
322 struct device_attribute *dev_attr, char *buf)
323{
324 struct hv_device *hv_dev = device_to_hv_device(dev);
325 struct hv_ring_buffer_debug_info outbound;
326
327 if (!hv_dev->channel)
328 return -ENODEV;
329 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
330 return sprintf(buf, "%d\n", outbound.current_read_index);
331}
332static DEVICE_ATTR_RO(out_read_index);
333
334static ssize_t out_write_index_show(struct device *dev,
335 struct device_attribute *dev_attr,
336 char *buf)
337{
338 struct hv_device *hv_dev = device_to_hv_device(dev);
339 struct hv_ring_buffer_debug_info outbound;
340
341 if (!hv_dev->channel)
342 return -ENODEV;
343 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
344 return sprintf(buf, "%d\n", outbound.current_write_index);
345}
346static DEVICE_ATTR_RO(out_write_index);
347
348static ssize_t out_read_bytes_avail_show(struct device *dev,
349 struct device_attribute *dev_attr,
350 char *buf)
351{
352 struct hv_device *hv_dev = device_to_hv_device(dev);
353 struct hv_ring_buffer_debug_info outbound;
354
355 if (!hv_dev->channel)
356 return -ENODEV;
357 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
358 return sprintf(buf, "%d\n", outbound.bytes_avail_toread);
359}
360static DEVICE_ATTR_RO(out_read_bytes_avail);
361
362static ssize_t out_write_bytes_avail_show(struct device *dev,
363 struct device_attribute *dev_attr,
364 char *buf)
365{
366 struct hv_device *hv_dev = device_to_hv_device(dev);
367 struct hv_ring_buffer_debug_info outbound;
368
369 if (!hv_dev->channel)
370 return -ENODEV;
371 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
372 return sprintf(buf, "%d\n", outbound.bytes_avail_towrite);
373}
374static DEVICE_ATTR_RO(out_write_bytes_avail);
375
376static ssize_t in_intr_mask_show(struct device *dev,
377 struct device_attribute *dev_attr, char *buf)
378{
379 struct hv_device *hv_dev = device_to_hv_device(dev);
380 struct hv_ring_buffer_debug_info inbound;
381
382 if (!hv_dev->channel)
383 return -ENODEV;
384 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
385 return sprintf(buf, "%d\n", inbound.current_interrupt_mask);
386}
387static DEVICE_ATTR_RO(in_intr_mask);
388
389static ssize_t in_read_index_show(struct device *dev,
390 struct device_attribute *dev_attr, char *buf)
391{
392 struct hv_device *hv_dev = device_to_hv_device(dev);
393 struct hv_ring_buffer_debug_info inbound;
394
395 if (!hv_dev->channel)
396 return -ENODEV;
397 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
398 return sprintf(buf, "%d\n", inbound.current_read_index);
399}
400static DEVICE_ATTR_RO(in_read_index);
401
402static ssize_t in_write_index_show(struct device *dev,
403 struct device_attribute *dev_attr, char *buf)
404{
405 struct hv_device *hv_dev = device_to_hv_device(dev);
406 struct hv_ring_buffer_debug_info inbound;
407
408 if (!hv_dev->channel)
409 return -ENODEV;
410 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
411 return sprintf(buf, "%d\n", inbound.current_write_index);
412}
413static DEVICE_ATTR_RO(in_write_index);
414
415static ssize_t in_read_bytes_avail_show(struct device *dev,
416 struct device_attribute *dev_attr,
417 char *buf)
418{
419 struct hv_device *hv_dev = device_to_hv_device(dev);
420 struct hv_ring_buffer_debug_info inbound;
421
422 if (!hv_dev->channel)
423 return -ENODEV;
424 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
425 return sprintf(buf, "%d\n", inbound.bytes_avail_toread);
426}
427static DEVICE_ATTR_RO(in_read_bytes_avail);
428
429static ssize_t in_write_bytes_avail_show(struct device *dev,
430 struct device_attribute *dev_attr,
431 char *buf)
432{
433 struct hv_device *hv_dev = device_to_hv_device(dev);
434 struct hv_ring_buffer_debug_info inbound;
435
436 if (!hv_dev->channel)
437 return -ENODEV;
438 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
439 return sprintf(buf, "%d\n", inbound.bytes_avail_towrite);
440}
441static DEVICE_ATTR_RO(in_write_bytes_avail);
442
Dexuan Cui042ab032015-08-05 00:52:43 -0700443static ssize_t channel_vp_mapping_show(struct device *dev,
444 struct device_attribute *dev_attr,
445 char *buf)
446{
447 struct hv_device *hv_dev = device_to_hv_device(dev);
448 struct vmbus_channel *channel = hv_dev->channel, *cur_sc;
449 unsigned long flags;
450 int buf_size = PAGE_SIZE, n_written, tot_written;
451 struct list_head *cur;
452
453 if (!channel)
454 return -ENODEV;
455
456 tot_written = snprintf(buf, buf_size, "%u:%u\n",
457 channel->offermsg.child_relid, channel->target_cpu);
458
459 spin_lock_irqsave(&channel->lock, flags);
460
461 list_for_each(cur, &channel->sc_list) {
462 if (tot_written >= buf_size - 1)
463 break;
464
465 cur_sc = list_entry(cur, struct vmbus_channel, sc_list);
466 n_written = scnprintf(buf + tot_written,
467 buf_size - tot_written,
468 "%u:%u\n",
469 cur_sc->offermsg.child_relid,
470 cur_sc->target_cpu);
471 tot_written += n_written;
472 }
473
474 spin_unlock_irqrestore(&channel->lock, flags);
475
476 return tot_written;
477}
478static DEVICE_ATTR_RO(channel_vp_mapping);
479
Greg Kroah-Hartman98f4c652013-09-13 11:33:01 -0700480/* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700481static struct attribute *vmbus_attrs[] = {
482 &dev_attr_id.attr,
Greg Kroah-Hartmana8fb5f32013-09-13 11:32:50 -0700483 &dev_attr_state.attr,
Greg Kroah-Hartman5ffd00e2013-09-13 11:32:51 -0700484 &dev_attr_monitor_id.attr,
Greg Kroah-Hartman68234c02013-09-13 11:32:53 -0700485 &dev_attr_class_id.attr,
Greg Kroah-Hartman7c55e1d2013-09-13 11:32:54 -0700486 &dev_attr_device_id.attr,
Greg Kroah-Hartman647fa372013-09-13 11:32:52 -0700487 &dev_attr_modalias.attr,
Greg Kroah-Hartman76c52bb2013-09-13 11:32:56 -0700488 &dev_attr_server_monitor_pending.attr,
489 &dev_attr_client_monitor_pending.attr,
Greg Kroah-Hartman1cee2722013-09-13 11:32:57 -0700490 &dev_attr_server_monitor_latency.attr,
491 &dev_attr_client_monitor_latency.attr,
Greg Kroah-Hartman4947c742013-09-13 11:32:58 -0700492 &dev_attr_server_monitor_conn_id.attr,
493 &dev_attr_client_monitor_conn_id.attr,
Greg Kroah-Hartman98f4c652013-09-13 11:33:01 -0700494 &dev_attr_out_intr_mask.attr,
495 &dev_attr_out_read_index.attr,
496 &dev_attr_out_write_index.attr,
497 &dev_attr_out_read_bytes_avail.attr,
498 &dev_attr_out_write_bytes_avail.attr,
499 &dev_attr_in_intr_mask.attr,
500 &dev_attr_in_read_index.attr,
501 &dev_attr_in_write_index.attr,
502 &dev_attr_in_read_bytes_avail.attr,
503 &dev_attr_in_write_bytes_avail.attr,
Dexuan Cui042ab032015-08-05 00:52:43 -0700504 &dev_attr_channel_vp_mapping.attr,
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700505 NULL,
506};
507ATTRIBUTE_GROUPS(vmbus);
508
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700509/*
510 * vmbus_uevent - add uevent for our device
511 *
512 * This routine is invoked when a device is added or removed on the vmbus to
513 * generate a uevent to udev in the userspace. The udev will then look at its
514 * rule and the uevent generated here to load the appropriate driver
K. Y. Srinivasan0ddda662011-08-25 09:48:38 -0700515 *
516 * The alias string will be of the form vmbus:guid where guid is the string
517 * representation of the device guid (each byte of the guid will be
518 * represented with two hex characters.
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700519 */
520static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
521{
522 struct hv_device *dev = device_to_hv_device(device);
Olaf Heringfd776ba2011-09-02 18:25:56 +0200523 int ret;
524 char alias_name[VMBUS_ALIAS_LEN + 1];
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700525
Olaf Heringfd776ba2011-09-02 18:25:56 +0200526 print_alias_name(dev, alias_name);
K. Y. Srinivasan0ddda662011-08-25 09:48:38 -0700527 ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
528 return ret;
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700529}
530
stephen hemminger1b9d48f2014-06-03 08:38:15 -0700531static const uuid_le null_guid;
K. Y. Srinivasan5841a822011-08-25 09:48:39 -0700532
K. Y. Srinivasanaf3ff642015-12-14 16:01:43 -0800533static inline bool is_null_guid(const uuid_le *guid)
K. Y. Srinivasan5841a822011-08-25 09:48:39 -0700534{
K. Y. Srinivasan4ae92502015-12-14 16:01:44 -0800535 if (uuid_le_cmp(*guid, null_guid))
K. Y. Srinivasan5841a822011-08-25 09:48:39 -0700536 return false;
537 return true;
538}
539
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700540/*
541 * Return a matching hv_vmbus_device_id pointer.
542 * If there is no match, return NULL.
543 */
544static const struct hv_vmbus_device_id *hv_vmbus_get_id(
545 const struct hv_vmbus_device_id *id,
K. Y. Srinivasanaf3ff642015-12-14 16:01:43 -0800546 const uuid_le *guid)
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700547{
K. Y. Srinivasanaf3ff642015-12-14 16:01:43 -0800548 for (; !is_null_guid(&id->guid); id++)
K. Y. Srinivasan4ae92502015-12-14 16:01:44 -0800549 if (!uuid_le_cmp(id->guid, *guid))
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700550 return id;
551
552 return NULL;
553}
554
555
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700556
557/*
558 * vmbus_match - Attempt to match the specified device to the specified driver
559 */
560static int vmbus_match(struct device *device, struct device_driver *driver)
561{
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700562 struct hv_driver *drv = drv_to_hv_drv(driver);
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700563 struct hv_device *hv_dev = device_to_hv_device(device);
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700564
K. Y. Srinivasanaf3ff642015-12-14 16:01:43 -0800565 if (hv_vmbus_get_id(drv->id_table, &hv_dev->dev_type))
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700566 return 1;
K. Y. Srinivasande632a22011-04-26 09:20:24 -0700567
K. Y. Srinivasan5841a822011-08-25 09:48:39 -0700568 return 0;
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700569}
570
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700571/*
572 * vmbus_probe - Add the new vmbus's child device
573 */
574static int vmbus_probe(struct device *child_device)
575{
576 int ret = 0;
577 struct hv_driver *drv =
578 drv_to_hv_drv(child_device->driver);
K. Y. Srinivasan9efd21e2011-04-29 13:45:10 -0700579 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700580 const struct hv_vmbus_device_id *dev_id;
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700581
K. Y. Srinivasanaf3ff642015-12-14 16:01:43 -0800582 dev_id = hv_vmbus_get_id(drv->id_table, &dev->dev_type);
K. Y. Srinivasan9efd21e2011-04-29 13:45:10 -0700583 if (drv->probe) {
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700584 ret = drv->probe(dev, dev_id);
K. Y. Srinivasanb14a7b32011-04-29 13:45:03 -0700585 if (ret != 0)
Hank Janssen0a466182011-03-29 13:58:47 -0700586 pr_err("probe failed for device %s (%d)\n",
587 dev_name(child_device), ret);
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700588
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700589 } else {
Hank Janssen0a466182011-03-29 13:58:47 -0700590 pr_err("probe not set for driver %s\n",
591 dev_name(child_device));
K. Y. Srinivasan6de925b2011-06-06 15:50:07 -0700592 ret = -ENODEV;
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700593 }
594 return ret;
595}
596
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700597/*
598 * vmbus_remove - Remove a vmbus device
599 */
600static int vmbus_remove(struct device *child_device)
601{
K. Y. Srinivasand15a0302015-02-28 11:18:16 -0800602 struct hv_driver *drv;
K. Y. Srinivasan415b0232011-04-29 13:45:12 -0700603 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700604
K. Y. Srinivasand15a0302015-02-28 11:18:16 -0800605 if (child_device->driver) {
606 drv = drv_to_hv_drv(child_device->driver);
607 if (drv->remove)
608 drv->remove(dev);
K. Y. Srinivasand15a0302015-02-28 11:18:16 -0800609 }
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700610
611 return 0;
612}
613
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700614
615/*
616 * vmbus_shutdown - Shutdown a vmbus device
617 */
618static void vmbus_shutdown(struct device *child_device)
619{
620 struct hv_driver *drv;
K. Y. Srinivasanca6887f2011-04-29 13:45:14 -0700621 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700622
623
624 /* The device may not be attached yet */
625 if (!child_device->driver)
626 return;
627
628 drv = drv_to_hv_drv(child_device->driver);
629
K. Y. Srinivasanca6887f2011-04-29 13:45:14 -0700630 if (drv->shutdown)
631 drv->shutdown(dev);
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700632
633 return;
634}
635
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700636
637/*
638 * vmbus_device_release - Final callback release of the vmbus child device
639 */
640static void vmbus_device_release(struct device *device)
641{
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700642 struct hv_device *hv_dev = device_to_hv_device(device);
Dexuan Cui34c68012015-12-14 16:01:49 -0800643 struct vmbus_channel *channel = hv_dev->channel;
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700644
Dexuan Cui34c68012015-12-14 16:01:49 -0800645 hv_process_channel_removal(channel,
646 channel->offermsg.child_relid);
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700647 kfree(hv_dev);
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700648
649}
650
Bill Pemberton454f18a2009-07-27 16:47:24 -0400651/* The one and only one */
K. Y. Srinivasan9adcac52011-04-29 13:45:08 -0700652static struct bus_type hv_bus = {
653 .name = "vmbus",
654 .match = vmbus_match,
655 .shutdown = vmbus_shutdown,
656 .remove = vmbus_remove,
657 .probe = vmbus_probe,
658 .uevent = vmbus_uevent,
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700659 .dev_groups = vmbus_groups,
Hank Janssen3e7ee492009-07-13 16:02:34 -0700660};
661
Timo Teräsbf6506f2010-12-15 20:48:08 +0200662struct onmessage_work_context {
663 struct work_struct work;
664 struct hv_message msg;
665};
666
667static void vmbus_onmessage_work(struct work_struct *work)
668{
669 struct onmessage_work_context *ctx;
670
Vitaly Kuznetsov09a19622015-02-27 11:25:54 -0800671 /* Do not process messages if we're in DISCONNECTED state */
672 if (vmbus_connection.conn_state == DISCONNECTED)
673 return;
674
Timo Teräsbf6506f2010-12-15 20:48:08 +0200675 ctx = container_of(work, struct onmessage_work_context,
676 work);
677 vmbus_onmessage(&ctx->msg);
678 kfree(ctx);
679}
680
kbuild test robotd8a60e02015-01-26 01:17:54 +0800681static void hv_process_timer_expiration(struct hv_message *msg, int cpu)
K. Y. Srinivasan4061ed92015-01-09 23:54:32 -0800682{
683 struct clock_event_device *dev = hv_context.clk_evt[cpu];
684
685 if (dev->event_handler)
686 dev->event_handler(dev);
687
688 msg->header.message_type = HVMSG_NONE;
689
690 /*
691 * Make sure the write to MessageType (ie set to
692 * HVMSG_NONE) happens before we read the
693 * MessagePending and EOMing. Otherwise, the EOMing
694 * will not deliver any more messages since there is
695 * no empty slot
696 */
697 mb();
698
699 if (msg->header.message_flags.msg_pending) {
700 /*
701 * This will cause message queue rescan to
702 * possibly deliver another msg from the
703 * hypervisor
704 */
705 wrmsrl(HV_X64_MSR_EOM, 0);
706 }
707}
708
K. Y. Srinivasan62c10592011-03-10 14:04:53 -0800709static void vmbus_on_msg_dpc(unsigned long data)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800710{
711 int cpu = smp_processor_id();
712 void *page_addr = hv_context.synic_message_page[cpu];
713 struct hv_message *msg = (struct hv_message *)page_addr +
714 VMBUS_MESSAGE_SINT;
Dexuan Cui652594c2015-03-27 09:10:08 -0700715 struct vmbus_channel_message_header *hdr;
716 struct vmbus_channel_message_table_entry *entry;
Timo Teräsbf6506f2010-12-15 20:48:08 +0200717 struct onmessage_work_context *ctx;
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800718
719 while (1) {
Dexuan Cui652594c2015-03-27 09:10:08 -0700720 if (msg->header.message_type == HVMSG_NONE)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800721 /* no msg */
722 break;
Dexuan Cui652594c2015-03-27 09:10:08 -0700723
724 hdr = (struct vmbus_channel_message_header *)msg->u.payload;
725
726 if (hdr->msgtype >= CHANNELMSG_COUNT) {
727 WARN_ONCE(1, "unknown msgtype=%d\n", hdr->msgtype);
728 goto msg_handled;
729 }
730
731 entry = &channel_message_table[hdr->msgtype];
732 if (entry->handler_type == VMHT_BLOCKING) {
Timo Teräsbf6506f2010-12-15 20:48:08 +0200733 ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
734 if (ctx == NULL)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800735 continue;
Dexuan Cui652594c2015-03-27 09:10:08 -0700736
Timo Teräsbf6506f2010-12-15 20:48:08 +0200737 INIT_WORK(&ctx->work, vmbus_onmessage_work);
738 memcpy(&ctx->msg, msg, sizeof(*msg));
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800739
Dexuan Cui652594c2015-03-27 09:10:08 -0700740 queue_work(vmbus_connection.work_queue, &ctx->work);
741 } else
742 entry->message_handler(hdr);
743
744msg_handled:
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800745 msg->header.message_type = HVMSG_NONE;
746
747 /*
748 * Make sure the write to MessageType (ie set to
749 * HVMSG_NONE) happens before we read the
750 * MessagePending and EOMing. Otherwise, the EOMing
751 * will not deliver any more messages since there is
752 * no empty slot
753 */
Jason Wang35848f62013-06-18 13:04:23 +0800754 mb();
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800755
756 if (msg->header.message_flags.msg_pending) {
757 /*
758 * This will cause message queue rescan to
759 * possibly deliver another msg from the
760 * hypervisor
761 */
762 wrmsrl(HV_X64_MSR_EOM, 0);
763 }
764 }
765}
766
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100767static void vmbus_isr(void)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800768{
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800769 int cpu = smp_processor_id();
770 void *page_addr;
771 struct hv_message *msg;
772 union hv_synic_event_flags *event;
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700773 bool handled = false;
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800774
K. Y. Srinivasan5ab05952012-12-01 06:46:55 -0800775 page_addr = hv_context.synic_event_page[cpu];
776 if (page_addr == NULL)
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100777 return;
K. Y. Srinivasan5ab05952012-12-01 06:46:55 -0800778
779 event = (union hv_synic_event_flags *)page_addr +
780 VMBUS_MESSAGE_SINT;
K. Y. Srinivasan7341d902011-08-31 14:35:56 -0700781 /*
782 * Check for events before checking for messages. This is the order
783 * in which events and messages are checked in Windows guests on
784 * Hyper-V, and the Windows team suggested we do the same.
785 */
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800786
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800787 if ((vmbus_proto_version == VERSION_WS2008) ||
788 (vmbus_proto_version == VERSION_WIN7)) {
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800789
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800790 /* Since we are a child, we only need to check bit 0 */
791 if (sync_test_and_clear_bit(0,
792 (unsigned long *) &event->flags32[0])) {
793 handled = true;
794 }
795 } else {
796 /*
797 * Our host is win8 or above. The signaling mechanism
798 * has changed and we can directly look at the event page.
799 * If bit n is set then we have an interrup on the channel
800 * whose id is n.
801 */
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700802 handled = true;
K. Y. Srinivasan793be9c2011-03-15 15:03:43 -0700803 }
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700804
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800805 if (handled)
K. Y. Srinivasandb11f122012-12-01 06:46:53 -0800806 tasklet_schedule(hv_context.event_dpc[cpu]);
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800807
808
K. Y. Srinivasan7341d902011-08-31 14:35:56 -0700809 page_addr = hv_context.synic_message_page[cpu];
810 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
811
812 /* Check if there are actual msgs to be processed */
K. Y. Srinivasan4061ed92015-01-09 23:54:32 -0800813 if (msg->header.message_type != HVMSG_NONE) {
814 if (msg->header.message_type == HVMSG_TIMER_EXPIRED)
815 hv_process_timer_expiration(msg, cpu);
816 else
817 tasklet_schedule(&msg_dpc);
818 }
K. Y. Srinivasan793be9c2011-03-15 15:03:43 -0700819}
820
Vitaly Kuznetsove5132292015-02-27 11:25:51 -0800821
Hank Janssen3e189512010-03-04 22:11:00 +0000822/*
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700823 * vmbus_bus_init -Main vmbus driver initialization routine.
824 *
825 * Here, we
Lars Lindley0686e4f2010-03-11 23:51:23 +0100826 * - initialize the vmbus driver context
Lars Lindley0686e4f2010-03-11 23:51:23 +0100827 * - invoke the vmbus hv main init routine
Lars Lindley0686e4f2010-03-11 23:51:23 +0100828 * - retrieve the channel offers
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700829 */
K. Y. Srinivasanefc26722015-12-14 16:01:46 -0800830static int vmbus_bus_init(void)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700831{
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700832 int ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700833
Greg Kroah-Hartman6d26e38fa22010-12-02 12:08:08 -0800834 /* Hypervisor initialization...setup hypercall page..etc */
835 ret = hv_init();
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700836 if (ret != 0) {
Hank Janssen0a466182011-03-29 13:58:47 -0700837 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700838 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700839 }
840
K. Y. Srinivasan59c0e4f2011-04-29 13:45:06 -0700841 tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700842
K. Y. Srinivasan9adcac52011-04-29 13:45:08 -0700843 ret = bus_register(&hv_bus);
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700844 if (ret)
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700845 goto err_cleanup;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700846
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100847 hv_setup_vmbus_irq(vmbus_isr);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700848
Jason Wang2608fb62013-06-19 11:28:10 +0800849 ret = hv_synic_alloc();
850 if (ret)
851 goto err_alloc;
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700852 /*
K. Y. Srinivasan302a3c02013-02-17 11:30:44 -0800853 * Initialize the per-cpu interrupt state and
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700854 * connect to the host.
855 */
K. Y. Srinivasan302a3c02013-02-17 11:30:44 -0800856 on_each_cpu(hv_synic_init, NULL, 1);
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700857 ret = vmbus_connect();
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700858 if (ret)
Andrey Smetanin17efbee2015-12-14 16:01:38 -0800859 goto err_connect;
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700860
Vitaly Kuznetsovf39c4282015-08-05 00:52:48 -0700861 if (vmbus_proto_version > VERSION_WIN7)
862 cpu_hotplug_disable();
Nick Meier96c1d052015-02-28 11:39:01 -0800863
864 /*
865 * Only register if the crash MSRs are available
866 */
Denis V. Lunevcc2dd402015-08-01 16:08:20 -0700867 if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
Vitaly Kuznetsov510f7ae2015-08-01 16:08:10 -0700868 register_die_notifier(&hyperv_die_block);
Nick Meier96c1d052015-02-28 11:39:01 -0800869 atomic_notifier_chain_register(&panic_notifier_list,
870 &hyperv_panic_block);
871 }
872
Greg Kroah-Hartman2d6e8822010-12-02 08:50:58 -0800873 vmbus_request_offers();
Haiyang Zhang8b5d6d32010-05-28 23:22:44 +0000874
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700875 return 0;
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700876
Andrey Smetanin17efbee2015-12-14 16:01:38 -0800877err_connect:
878 on_each_cpu(hv_synic_cleanup, NULL, 1);
Jason Wang2608fb62013-06-19 11:28:10 +0800879err_alloc:
880 hv_synic_free();
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100881 hv_remove_vmbus_irq();
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700882
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700883 bus_unregister(&hv_bus);
884
885err_cleanup:
886 hv_cleanup();
887
888 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700889}
890
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700891/**
Jake Oshins35464482015-08-05 00:52:37 -0700892 * __vmbus_child_driver_register() - Register a vmbus's driver
893 * @hv_driver: Pointer to driver structure you want to register
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700894 * @owner: owner module of the drv
895 * @mod_name: module name string
Hank Janssen3e189512010-03-04 22:11:00 +0000896 *
897 * Registers the given driver with Linux through the 'driver_register()' call
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700898 * and sets up the hyper-v vmbus handling for this driver.
Hank Janssen3e189512010-03-04 22:11:00 +0000899 * It will return the state of the 'driver_register()' call.
900 *
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700901 */
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700902int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700903{
Bill Pemberton5d48a1c2009-07-27 16:47:36 -0400904 int ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700905
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700906 pr_info("registering driver %s\n", hv_driver->name);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700907
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -0800908 ret = vmbus_exists();
909 if (ret < 0)
910 return ret;
911
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700912 hv_driver->driver.name = hv_driver->name;
913 hv_driver->driver.owner = owner;
914 hv_driver->driver.mod_name = mod_name;
915 hv_driver->driver.bus = &hv_bus;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700916
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700917 ret = driver_register(&hv_driver->driver);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700918
Bill Pemberton5d48a1c2009-07-27 16:47:36 -0400919 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700920}
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700921EXPORT_SYMBOL_GPL(__vmbus_driver_register);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700922
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700923/**
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700924 * vmbus_driver_unregister() - Unregister a vmbus's driver
Jake Oshins35464482015-08-05 00:52:37 -0700925 * @hv_driver: Pointer to driver structure you want to
926 * un-register
Hank Janssen3e189512010-03-04 22:11:00 +0000927 *
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700928 * Un-register the given driver that was previous registered with a call to
929 * vmbus_driver_register()
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700930 */
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700931void vmbus_driver_unregister(struct hv_driver *hv_driver)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700932{
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700933 pr_info("unregistering driver %s\n", hv_driver->name);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700934
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -0800935 if (!vmbus_exists())
K. Y. Srinivasan8f257a12011-12-27 13:49:37 -0800936 driver_unregister(&hv_driver->driver);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700937}
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700938EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700939
Hank Janssen3e189512010-03-04 22:11:00 +0000940/*
K. Y. Srinivasanf2c73012011-09-08 07:24:12 -0700941 * vmbus_device_create - Creates and registers a new child device
Hank Janssen3e189512010-03-04 22:11:00 +0000942 * on the vmbus.
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700943 */
stephen hemminger1b9d48f2014-06-03 08:38:15 -0700944struct hv_device *vmbus_device_create(const uuid_le *type,
945 const uuid_le *instance,
946 struct vmbus_channel *channel)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700947{
Nicolas Palix3d3b5512009-07-28 17:32:53 +0200948 struct hv_device *child_device_obj;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700949
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800950 child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
951 if (!child_device_obj) {
Hank Janssen0a466182011-03-29 13:58:47 -0700952 pr_err("Unable to allocate device object for child device\n");
Hank Janssen3e7ee492009-07-13 16:02:34 -0700953 return NULL;
954 }
955
Greg Kroah-Hartmancae5b842010-10-21 09:05:27 -0700956 child_device_obj->channel = channel;
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -0700957 memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
Haiyang Zhangca623ad2011-01-26 12:12:11 -0800958 memcpy(&child_device_obj->dev_instance, instance,
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -0700959 sizeof(uuid_le));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700960
Hank Janssen3e7ee492009-07-13 16:02:34 -0700961
Hank Janssen3e7ee492009-07-13 16:02:34 -0700962 return child_device_obj;
963}
964
Hank Janssen3e189512010-03-04 22:11:00 +0000965/*
K. Y. Srinivasan227942812011-09-08 07:24:13 -0700966 * vmbus_device_register - Register the child device
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700967 */
K. Y. Srinivasan227942812011-09-08 07:24:13 -0700968int vmbus_device_register(struct hv_device *child_device_obj)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700969{
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700970 int ret = 0;
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800971
Vitaly Kuznetsovbc63b6f2015-02-27 11:25:52 -0800972 dev_set_name(&child_device_obj->device, "vmbus_%d",
973 child_device_obj->channel->id);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700974
K. Y. Srinivasan0bce28b2011-08-27 11:31:39 -0700975 child_device_obj->device.bus = &hv_bus;
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -0700976 child_device_obj->device.parent = &hv_acpi_dev->dev;
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800977 child_device_obj->device.release = vmbus_device_release;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700978
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700979 /*
980 * Register with the LDM. This will kick off the driver/device
981 * binding...which will eventually call vmbus_match() and vmbus_probe()
982 */
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800983 ret = device_register(&child_device_obj->device);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700984
Hank Janssen3e7ee492009-07-13 16:02:34 -0700985 if (ret)
Hank Janssen0a466182011-03-29 13:58:47 -0700986 pr_err("Unable to register child device\n");
Hank Janssen3e7ee492009-07-13 16:02:34 -0700987 else
Fernando Soto84672362013-06-14 23:13:35 +0000988 pr_debug("child device %s registered\n",
Hank Janssen0a466182011-03-29 13:58:47 -0700989 dev_name(&child_device_obj->device));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700990
Hank Janssen3e7ee492009-07-13 16:02:34 -0700991 return ret;
992}
993
Hank Janssen3e189512010-03-04 22:11:00 +0000994/*
K. Y. Srinivasan696453b2011-09-08 07:24:14 -0700995 * vmbus_device_unregister - Remove the specified child device
Hank Janssen3e189512010-03-04 22:11:00 +0000996 * from the vmbus.
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700997 */
K. Y. Srinivasan696453b2011-09-08 07:24:14 -0700998void vmbus_device_unregister(struct hv_device *device_obj)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700999{
Fernando Soto84672362013-06-14 23:13:35 +00001000 pr_debug("child device %s unregistered\n",
1001 dev_name(&device_obj->device));
1002
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -07001003 /*
1004 * Kick off the process of unregistering the device.
1005 * This will call vmbus_remove() and eventually vmbus_device_release()
1006 */
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -08001007 device_unregister(&device_obj->device);
Hank Janssen3e7ee492009-07-13 16:02:34 -07001008}
1009
Hank Janssen3e7ee492009-07-13 16:02:34 -07001010
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001011/*
Jake Oshins7f163a62015-08-05 00:52:36 -07001012 * VMBUS is an acpi enumerated device. Get the information we
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001013 * need from DSDT.
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001014 */
Jake Oshins7f163a62015-08-05 00:52:36 -07001015#define VTPM_BASE_ADDRESS 0xfed40000
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001016static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *ctx)
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001017{
Jake Oshins7f163a62015-08-05 00:52:36 -07001018 resource_size_t start = 0;
1019 resource_size_t end = 0;
1020 struct resource *new_res;
1021 struct resource **old_res = &hyperv_mmio;
1022 struct resource **prev_res = NULL;
1023
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001024 switch (res->type) {
Jake Oshins7f163a62015-08-05 00:52:36 -07001025
1026 /*
1027 * "Address" descriptors are for bus windows. Ignore
1028 * "memory" descriptors, which are for registers on
1029 * devices.
1030 */
1031 case ACPI_RESOURCE_TYPE_ADDRESS32:
1032 start = res->data.address32.address.minimum;
1033 end = res->data.address32.address.maximum;
Gerd Hoffmann4eb923f2014-02-24 14:17:08 +01001034 break;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001035
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001036 case ACPI_RESOURCE_TYPE_ADDRESS64:
Jake Oshins7f163a62015-08-05 00:52:36 -07001037 start = res->data.address64.address.minimum;
1038 end = res->data.address64.address.maximum;
Gerd Hoffmann4eb923f2014-02-24 14:17:08 +01001039 break;
Jake Oshins7f163a62015-08-05 00:52:36 -07001040
1041 default:
1042 /* Unused resource type */
1043 return AE_OK;
1044
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001045 }
Jake Oshins7f163a62015-08-05 00:52:36 -07001046 /*
1047 * Ignore ranges that are below 1MB, as they're not
1048 * necessary or useful here.
1049 */
1050 if (end < 0x100000)
1051 return AE_OK;
1052
1053 new_res = kzalloc(sizeof(*new_res), GFP_ATOMIC);
1054 if (!new_res)
1055 return AE_NO_MEMORY;
1056
1057 /* If this range overlaps the virtual TPM, truncate it. */
1058 if (end > VTPM_BASE_ADDRESS && start < VTPM_BASE_ADDRESS)
1059 end = VTPM_BASE_ADDRESS;
1060
1061 new_res->name = "hyperv mmio";
1062 new_res->flags = IORESOURCE_MEM;
1063 new_res->start = start;
1064 new_res->end = end;
1065
Jake Oshins40f26f32015-12-14 16:01:52 -08001066 /*
1067 * Stick ranges from higher in address space at the front of the list.
1068 * If two ranges are adjacent, merge them.
1069 */
Jake Oshins7f163a62015-08-05 00:52:36 -07001070 do {
1071 if (!*old_res) {
1072 *old_res = new_res;
1073 break;
1074 }
1075
Jake Oshins40f26f32015-12-14 16:01:52 -08001076 if (((*old_res)->end + 1) == new_res->start) {
1077 (*old_res)->end = new_res->end;
1078 kfree(new_res);
1079 break;
1080 }
1081
1082 if ((*old_res)->start == new_res->end + 1) {
1083 (*old_res)->start = new_res->start;
1084 kfree(new_res);
1085 break;
1086 }
1087
Jake Oshins7f163a62015-08-05 00:52:36 -07001088 if ((*old_res)->end < new_res->start) {
1089 new_res->sibling = *old_res;
1090 if (prev_res)
1091 (*prev_res)->sibling = new_res;
1092 *old_res = new_res;
1093 break;
1094 }
1095
1096 prev_res = old_res;
1097 old_res = &(*old_res)->sibling;
1098
1099 } while (1);
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001100
1101 return AE_OK;
1102}
1103
Jake Oshins7f163a62015-08-05 00:52:36 -07001104static int vmbus_acpi_remove(struct acpi_device *device)
1105{
1106 struct resource *cur_res;
1107 struct resource *next_res;
1108
1109 if (hyperv_mmio) {
1110 for (cur_res = hyperv_mmio; cur_res; cur_res = next_res) {
1111 next_res = cur_res->sibling;
1112 kfree(cur_res);
1113 }
1114 }
1115
1116 return 0;
1117}
1118
Jake Oshins35464482015-08-05 00:52:37 -07001119/**
1120 * vmbus_allocate_mmio() - Pick a memory-mapped I/O range.
1121 * @new: If successful, supplied a pointer to the
1122 * allocated MMIO space.
1123 * @device_obj: Identifies the caller
1124 * @min: Minimum guest physical address of the
1125 * allocation
1126 * @max: Maximum guest physical address
1127 * @size: Size of the range to be allocated
1128 * @align: Alignment of the range to be allocated
1129 * @fb_overlap_ok: Whether this allocation can be allowed
1130 * to overlap the video frame buffer.
1131 *
1132 * This function walks the resources granted to VMBus by the
1133 * _CRS object in the ACPI namespace underneath the parent
1134 * "bridge" whether that's a root PCI bus in the Generation 1
1135 * case or a Module Device in the Generation 2 case. It then
1136 * attempts to allocate from the global MMIO pool in a way that
1137 * matches the constraints supplied in these parameters and by
1138 * that _CRS.
1139 *
1140 * Return: 0 on success, -errno on failure
1141 */
1142int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj,
1143 resource_size_t min, resource_size_t max,
1144 resource_size_t size, resource_size_t align,
1145 bool fb_overlap_ok)
1146{
1147 struct resource *iter;
1148 resource_size_t range_min, range_max, start, local_min, local_max;
1149 const char *dev_n = dev_name(&device_obj->device);
1150 u32 fb_end = screen_info.lfb_base + (screen_info.lfb_size << 1);
1151 int i;
1152
1153 for (iter = hyperv_mmio; iter; iter = iter->sibling) {
1154 if ((iter->start >= max) || (iter->end <= min))
1155 continue;
1156
1157 range_min = iter->start;
1158 range_max = iter->end;
1159
1160 /* If this range overlaps the frame buffer, split it into
1161 two tries. */
1162 for (i = 0; i < 2; i++) {
1163 local_min = range_min;
1164 local_max = range_max;
1165 if (fb_overlap_ok || (range_min >= fb_end) ||
1166 (range_max <= screen_info.lfb_base)) {
1167 i++;
1168 } else {
1169 if ((range_min <= screen_info.lfb_base) &&
1170 (range_max >= screen_info.lfb_base)) {
1171 /*
1172 * The frame buffer is in this window,
1173 * so trim this into the part that
1174 * preceeds the frame buffer.
1175 */
1176 local_max = screen_info.lfb_base - 1;
1177 range_min = fb_end;
1178 } else {
1179 range_min = fb_end;
1180 continue;
1181 }
1182 }
1183
1184 start = (local_min + align - 1) & ~(align - 1);
1185 for (; start + size - 1 <= local_max; start += align) {
1186 *new = request_mem_region_exclusive(start, size,
1187 dev_n);
1188 if (*new)
1189 return 0;
1190 }
1191 }
1192 }
1193
1194 return -ENXIO;
1195}
1196EXPORT_SYMBOL_GPL(vmbus_allocate_mmio);
1197
Jake Oshins619848b2015-12-14 16:01:39 -08001198/**
1199 * vmbus_cpu_number_to_vp_number() - Map CPU to VP.
1200 * @cpu_number: CPU number in Linux terms
1201 *
1202 * This function returns the mapping between the Linux processor
1203 * number and the hypervisor's virtual processor number, useful
1204 * in making hypercalls and such that talk about specific
1205 * processors.
1206 *
1207 * Return: Virtual processor number in Hyper-V terms
1208 */
1209int vmbus_cpu_number_to_vp_number(int cpu_number)
1210{
1211 return hv_context.vp_index[cpu_number];
1212}
1213EXPORT_SYMBOL_GPL(vmbus_cpu_number_to_vp_number);
1214
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001215static int vmbus_acpi_add(struct acpi_device *device)
1216{
1217 acpi_status result;
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001218 int ret_val = -ENODEV;
Jake Oshins7f163a62015-08-05 00:52:36 -07001219 struct acpi_device *ancestor;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001220
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -07001221 hv_acpi_dev = device;
1222
K. Y. Srinivasan0a4425b2011-08-27 11:31:38 -07001223 result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001224 vmbus_walk_resources, NULL);
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001225
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001226 if (ACPI_FAILURE(result))
1227 goto acpi_walk_err;
1228 /*
Jake Oshins7f163a62015-08-05 00:52:36 -07001229 * Some ancestor of the vmbus acpi device (Gen1 or Gen2
1230 * firmware) is the VMOD that has the mmio ranges. Get that.
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001231 */
Jake Oshins7f163a62015-08-05 00:52:36 -07001232 for (ancestor = device->parent; ancestor; ancestor = ancestor->parent) {
1233 result = acpi_walk_resources(ancestor->handle, METHOD_NAME__CRS,
1234 vmbus_walk_resources, NULL);
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001235
1236 if (ACPI_FAILURE(result))
Jake Oshins7f163a62015-08-05 00:52:36 -07001237 continue;
1238 if (hyperv_mmio)
1239 break;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001240 }
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001241 ret_val = 0;
1242
1243acpi_walk_err:
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001244 complete(&probe_event);
Jake Oshins7f163a62015-08-05 00:52:36 -07001245 if (ret_val)
1246 vmbus_acpi_remove(device);
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001247 return ret_val;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001248}
1249
1250static const struct acpi_device_id vmbus_acpi_device_ids[] = {
1251 {"VMBUS", 0},
K. Y. Srinivasan9d7b18d2011-06-06 15:49:42 -07001252 {"VMBus", 0},
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001253 {"", 0},
1254};
1255MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
1256
1257static struct acpi_driver vmbus_acpi_driver = {
1258 .name = "vmbus",
1259 .ids = vmbus_acpi_device_ids,
1260 .ops = {
1261 .add = vmbus_acpi_add,
Vitaly Kuznetsove4ecb412015-04-22 21:31:28 -07001262 .remove = vmbus_acpi_remove,
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001263 },
1264};
1265
Vitaly Kuznetsov25172812015-08-01 16:08:07 -07001266static void hv_kexec_handler(void)
1267{
1268 int cpu;
1269
1270 hv_synic_clockevents_cleanup();
1271 vmbus_initiate_unload();
1272 for_each_online_cpu(cpu)
1273 smp_call_function_single(cpu, hv_synic_cleanup, NULL, 1);
1274 hv_cleanup();
1275};
1276
Vitaly Kuznetsovb4370df2015-08-01 16:08:09 -07001277static void hv_crash_handler(struct pt_regs *regs)
1278{
1279 vmbus_initiate_unload();
1280 /*
1281 * In crash handler we can't schedule synic cleanup for all CPUs,
1282 * doing the cleanup for current CPU only. This should be sufficient
1283 * for kdump.
1284 */
1285 hv_synic_cleanup(NULL);
1286 hv_cleanup();
1287};
1288
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -07001289static int __init hv_acpi_init(void)
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -07001290{
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -07001291 int ret, t;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001292
Jason Wang1f94ea82012-08-31 13:32:44 +08001293 if (x86_hyper != &x86_hyper_ms_hyperv)
Jason Wang05929692012-08-17 18:52:43 +08001294 return -ENODEV;
1295
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001296 init_completion(&probe_event);
1297
1298 /*
K. Y. Srinivasanefc26722015-12-14 16:01:46 -08001299 * Get ACPI resources first.
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001300 */
K. Y. Srinivasan02466042011-06-06 15:49:40 -07001301 ret = acpi_bus_register_driver(&vmbus_acpi_driver);
1302
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001303 if (ret)
1304 return ret;
1305
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -07001306 t = wait_for_completion_timeout(&probe_event, 5*HZ);
1307 if (t == 0) {
1308 ret = -ETIMEDOUT;
1309 goto cleanup;
1310 }
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001311
K. Y. Srinivasanefc26722015-12-14 16:01:46 -08001312 ret = vmbus_bus_init();
K. Y. Srinivasan91fd7992011-06-16 13:16:38 -07001313 if (ret)
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -07001314 goto cleanup;
1315
Vitaly Kuznetsov25172812015-08-01 16:08:07 -07001316 hv_setup_kexec_handler(hv_kexec_handler);
Vitaly Kuznetsovb4370df2015-08-01 16:08:09 -07001317 hv_setup_crash_handler(hv_crash_handler);
Vitaly Kuznetsov25172812015-08-01 16:08:07 -07001318
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -07001319 return 0;
1320
1321cleanup:
1322 acpi_bus_unregister_driver(&vmbus_acpi_driver);
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -08001323 hv_acpi_dev = NULL;
K. Y. Srinivasan91fd7992011-06-16 13:16:38 -07001324 return ret;
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -07001325}
1326
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001327static void __exit vmbus_exit(void)
1328{
Vitaly Kuznetsove72e7ac2015-02-27 11:25:55 -08001329 int cpu;
1330
Vitaly Kuznetsov25172812015-08-01 16:08:07 -07001331 hv_remove_kexec_handler();
Vitaly Kuznetsovb4370df2015-08-01 16:08:09 -07001332 hv_remove_crash_handler();
Vitaly Kuznetsov09a19622015-02-27 11:25:54 -08001333 vmbus_connection.conn_state = DISCONNECTED;
Vitaly Kuznetsove0867482015-02-27 11:25:57 -08001334 hv_synic_clockevents_cleanup();
K. Y. Srinivasan2db84ef2015-04-22 21:31:32 -07001335 vmbus_disconnect();
Thomas Gleixner76d388c2014-03-05 13:42:14 +01001336 hv_remove_vmbus_irq();
Vitaly Kuznetsov1959a282015-05-06 17:47:41 -07001337 tasklet_kill(&msg_dpc);
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001338 vmbus_free_channels();
Denis V. Lunevcc2dd402015-08-01 16:08:20 -07001339 if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
Vitaly Kuznetsov510f7ae2015-08-01 16:08:10 -07001340 unregister_die_notifier(&hyperv_die_block);
Vitaly Kuznetsov096c6052015-04-22 21:31:29 -07001341 atomic_notifier_chain_unregister(&panic_notifier_list,
1342 &hyperv_panic_block);
1343 }
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001344 bus_unregister(&hv_bus);
1345 hv_cleanup();
Vitaly Kuznetsov1959a282015-05-06 17:47:41 -07001346 for_each_online_cpu(cpu) {
1347 tasklet_kill(hv_context.event_dpc[cpu]);
Vitaly Kuznetsove72e7ac2015-02-27 11:25:55 -08001348 smp_call_function_single(cpu, hv_synic_cleanup, NULL, 1);
Vitaly Kuznetsov1959a282015-05-06 17:47:41 -07001349 }
Vitaly Kuznetsov06210b42f2015-08-01 16:08:05 -07001350 hv_synic_free();
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001351 acpi_bus_unregister_driver(&vmbus_acpi_driver);
Vitaly Kuznetsovf39c4282015-08-05 00:52:48 -07001352 if (vmbus_proto_version > VERSION_WIN7)
1353 cpu_hotplug_enable();
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001354}
1355
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -07001356
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -07001357MODULE_LICENSE("GPL");
Hank Janssen3e7ee492009-07-13 16:02:34 -07001358
K. Y. Srinivasan43d4e112011-10-24 11:28:12 -07001359subsys_initcall(hv_acpi_init);
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001360module_exit(vmbus_exit);