blob: 3668a95778ec213f4bd73086fd4f8b37eb0e2a7c [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
K. Y. Srinivasan7047f172015-12-25 20:00:30 -0800480static ssize_t vendor_show(struct device *dev,
481 struct device_attribute *dev_attr,
482 char *buf)
483{
484 struct hv_device *hv_dev = device_to_hv_device(dev);
485 return sprintf(buf, "0x%x\n", hv_dev->vendor_id);
486}
487static DEVICE_ATTR_RO(vendor);
488
489static ssize_t device_show(struct device *dev,
490 struct device_attribute *dev_attr,
491 char *buf)
492{
493 struct hv_device *hv_dev = device_to_hv_device(dev);
494 return sprintf(buf, "0x%x\n", hv_dev->device_id);
495}
496static DEVICE_ATTR_RO(device);
497
Greg Kroah-Hartman98f4c652013-09-13 11:33:01 -0700498/* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700499static struct attribute *vmbus_attrs[] = {
500 &dev_attr_id.attr,
Greg Kroah-Hartmana8fb5f32013-09-13 11:32:50 -0700501 &dev_attr_state.attr,
Greg Kroah-Hartman5ffd00e2013-09-13 11:32:51 -0700502 &dev_attr_monitor_id.attr,
Greg Kroah-Hartman68234c02013-09-13 11:32:53 -0700503 &dev_attr_class_id.attr,
Greg Kroah-Hartman7c55e1d2013-09-13 11:32:54 -0700504 &dev_attr_device_id.attr,
Greg Kroah-Hartman647fa372013-09-13 11:32:52 -0700505 &dev_attr_modalias.attr,
Greg Kroah-Hartman76c52bb2013-09-13 11:32:56 -0700506 &dev_attr_server_monitor_pending.attr,
507 &dev_attr_client_monitor_pending.attr,
Greg Kroah-Hartman1cee2722013-09-13 11:32:57 -0700508 &dev_attr_server_monitor_latency.attr,
509 &dev_attr_client_monitor_latency.attr,
Greg Kroah-Hartman4947c742013-09-13 11:32:58 -0700510 &dev_attr_server_monitor_conn_id.attr,
511 &dev_attr_client_monitor_conn_id.attr,
Greg Kroah-Hartman98f4c652013-09-13 11:33:01 -0700512 &dev_attr_out_intr_mask.attr,
513 &dev_attr_out_read_index.attr,
514 &dev_attr_out_write_index.attr,
515 &dev_attr_out_read_bytes_avail.attr,
516 &dev_attr_out_write_bytes_avail.attr,
517 &dev_attr_in_intr_mask.attr,
518 &dev_attr_in_read_index.attr,
519 &dev_attr_in_write_index.attr,
520 &dev_attr_in_read_bytes_avail.attr,
521 &dev_attr_in_write_bytes_avail.attr,
Dexuan Cui042ab032015-08-05 00:52:43 -0700522 &dev_attr_channel_vp_mapping.attr,
K. Y. Srinivasan7047f172015-12-25 20:00:30 -0800523 &dev_attr_vendor.attr,
524 &dev_attr_device.attr,
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700525 NULL,
526};
527ATTRIBUTE_GROUPS(vmbus);
528
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700529/*
530 * vmbus_uevent - add uevent for our device
531 *
532 * This routine is invoked when a device is added or removed on the vmbus to
533 * generate a uevent to udev in the userspace. The udev will then look at its
534 * rule and the uevent generated here to load the appropriate driver
K. Y. Srinivasan0ddda662011-08-25 09:48:38 -0700535 *
536 * The alias string will be of the form vmbus:guid where guid is the string
537 * representation of the device guid (each byte of the guid will be
538 * represented with two hex characters.
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700539 */
540static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
541{
542 struct hv_device *dev = device_to_hv_device(device);
Olaf Heringfd776ba2011-09-02 18:25:56 +0200543 int ret;
544 char alias_name[VMBUS_ALIAS_LEN + 1];
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700545
Olaf Heringfd776ba2011-09-02 18:25:56 +0200546 print_alias_name(dev, alias_name);
K. Y. Srinivasan0ddda662011-08-25 09:48:38 -0700547 ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
548 return ret;
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700549}
550
stephen hemminger1b9d48f2014-06-03 08:38:15 -0700551static const uuid_le null_guid;
K. Y. Srinivasan5841a822011-08-25 09:48:39 -0700552
K. Y. Srinivasanaf3ff642015-12-14 16:01:43 -0800553static inline bool is_null_guid(const uuid_le *guid)
K. Y. Srinivasan5841a822011-08-25 09:48:39 -0700554{
K. Y. Srinivasan4ae92502015-12-14 16:01:44 -0800555 if (uuid_le_cmp(*guid, null_guid))
K. Y. Srinivasan5841a822011-08-25 09:48:39 -0700556 return false;
557 return true;
558}
559
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700560/*
561 * Return a matching hv_vmbus_device_id pointer.
562 * If there is no match, return NULL.
563 */
564static const struct hv_vmbus_device_id *hv_vmbus_get_id(
565 const struct hv_vmbus_device_id *id,
K. Y. Srinivasanaf3ff642015-12-14 16:01:43 -0800566 const uuid_le *guid)
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700567{
K. Y. Srinivasanaf3ff642015-12-14 16:01:43 -0800568 for (; !is_null_guid(&id->guid); id++)
K. Y. Srinivasan4ae92502015-12-14 16:01:44 -0800569 if (!uuid_le_cmp(id->guid, *guid))
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700570 return id;
571
572 return NULL;
573}
574
575
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700576
577/*
578 * vmbus_match - Attempt to match the specified device to the specified driver
579 */
580static int vmbus_match(struct device *device, struct device_driver *driver)
581{
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700582 struct hv_driver *drv = drv_to_hv_drv(driver);
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700583 struct hv_device *hv_dev = device_to_hv_device(device);
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700584
K. Y. Srinivasanaf3ff642015-12-14 16:01:43 -0800585 if (hv_vmbus_get_id(drv->id_table, &hv_dev->dev_type))
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700586 return 1;
K. Y. Srinivasande632a22011-04-26 09:20:24 -0700587
K. Y. Srinivasan5841a822011-08-25 09:48:39 -0700588 return 0;
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700589}
590
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700591/*
592 * vmbus_probe - Add the new vmbus's child device
593 */
594static int vmbus_probe(struct device *child_device)
595{
596 int ret = 0;
597 struct hv_driver *drv =
598 drv_to_hv_drv(child_device->driver);
K. Y. Srinivasan9efd21e2011-04-29 13:45:10 -0700599 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700600 const struct hv_vmbus_device_id *dev_id;
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700601
K. Y. Srinivasanaf3ff642015-12-14 16:01:43 -0800602 dev_id = hv_vmbus_get_id(drv->id_table, &dev->dev_type);
K. Y. Srinivasan9efd21e2011-04-29 13:45:10 -0700603 if (drv->probe) {
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700604 ret = drv->probe(dev, dev_id);
K. Y. Srinivasanb14a7b32011-04-29 13:45:03 -0700605 if (ret != 0)
Hank Janssen0a466182011-03-29 13:58:47 -0700606 pr_err("probe failed for device %s (%d)\n",
607 dev_name(child_device), ret);
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700608
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700609 } else {
Hank Janssen0a466182011-03-29 13:58:47 -0700610 pr_err("probe not set for driver %s\n",
611 dev_name(child_device));
K. Y. Srinivasan6de925b2011-06-06 15:50:07 -0700612 ret = -ENODEV;
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700613 }
614 return ret;
615}
616
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700617/*
618 * vmbus_remove - Remove a vmbus device
619 */
620static int vmbus_remove(struct device *child_device)
621{
K. Y. Srinivasand15a0302015-02-28 11:18:16 -0800622 struct hv_driver *drv;
K. Y. Srinivasan415b0232011-04-29 13:45:12 -0700623 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700624
K. Y. Srinivasand15a0302015-02-28 11:18:16 -0800625 if (child_device->driver) {
626 drv = drv_to_hv_drv(child_device->driver);
627 if (drv->remove)
628 drv->remove(dev);
K. Y. Srinivasand15a0302015-02-28 11:18:16 -0800629 }
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700630
631 return 0;
632}
633
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700634
635/*
636 * vmbus_shutdown - Shutdown a vmbus device
637 */
638static void vmbus_shutdown(struct device *child_device)
639{
640 struct hv_driver *drv;
K. Y. Srinivasanca6887f2011-04-29 13:45:14 -0700641 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700642
643
644 /* The device may not be attached yet */
645 if (!child_device->driver)
646 return;
647
648 drv = drv_to_hv_drv(child_device->driver);
649
K. Y. Srinivasanca6887f2011-04-29 13:45:14 -0700650 if (drv->shutdown)
651 drv->shutdown(dev);
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700652
653 return;
654}
655
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700656
657/*
658 * vmbus_device_release - Final callback release of the vmbus child device
659 */
660static void vmbus_device_release(struct device *device)
661{
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700662 struct hv_device *hv_dev = device_to_hv_device(device);
Dexuan Cui34c68012015-12-14 16:01:49 -0800663 struct vmbus_channel *channel = hv_dev->channel;
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700664
Dexuan Cui34c68012015-12-14 16:01:49 -0800665 hv_process_channel_removal(channel,
666 channel->offermsg.child_relid);
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700667 kfree(hv_dev);
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700668
669}
670
Bill Pemberton454f18a2009-07-27 16:47:24 -0400671/* The one and only one */
K. Y. Srinivasan9adcac52011-04-29 13:45:08 -0700672static struct bus_type hv_bus = {
673 .name = "vmbus",
674 .match = vmbus_match,
675 .shutdown = vmbus_shutdown,
676 .remove = vmbus_remove,
677 .probe = vmbus_probe,
678 .uevent = vmbus_uevent,
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700679 .dev_groups = vmbus_groups,
Hank Janssen3e7ee492009-07-13 16:02:34 -0700680};
681
Timo Teräsbf6506f2010-12-15 20:48:08 +0200682struct onmessage_work_context {
683 struct work_struct work;
684 struct hv_message msg;
685};
686
687static void vmbus_onmessage_work(struct work_struct *work)
688{
689 struct onmessage_work_context *ctx;
690
Vitaly Kuznetsov09a19622015-02-27 11:25:54 -0800691 /* Do not process messages if we're in DISCONNECTED state */
692 if (vmbus_connection.conn_state == DISCONNECTED)
693 return;
694
Timo Teräsbf6506f2010-12-15 20:48:08 +0200695 ctx = container_of(work, struct onmessage_work_context,
696 work);
697 vmbus_onmessage(&ctx->msg);
698 kfree(ctx);
699}
700
kbuild test robotd8a60e02015-01-26 01:17:54 +0800701static void hv_process_timer_expiration(struct hv_message *msg, int cpu)
K. Y. Srinivasan4061ed92015-01-09 23:54:32 -0800702{
703 struct clock_event_device *dev = hv_context.clk_evt[cpu];
704
705 if (dev->event_handler)
706 dev->event_handler(dev);
707
708 msg->header.message_type = HVMSG_NONE;
709
710 /*
711 * Make sure the write to MessageType (ie set to
712 * HVMSG_NONE) happens before we read the
713 * MessagePending and EOMing. Otherwise, the EOMing
714 * will not deliver any more messages since there is
715 * no empty slot
716 */
717 mb();
718
719 if (msg->header.message_flags.msg_pending) {
720 /*
721 * This will cause message queue rescan to
722 * possibly deliver another msg from the
723 * hypervisor
724 */
725 wrmsrl(HV_X64_MSR_EOM, 0);
726 }
727}
728
K. Y. Srinivasan62c10592011-03-10 14:04:53 -0800729static void vmbus_on_msg_dpc(unsigned long data)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800730{
731 int cpu = smp_processor_id();
732 void *page_addr = hv_context.synic_message_page[cpu];
733 struct hv_message *msg = (struct hv_message *)page_addr +
734 VMBUS_MESSAGE_SINT;
Dexuan Cui652594c2015-03-27 09:10:08 -0700735 struct vmbus_channel_message_header *hdr;
736 struct vmbus_channel_message_table_entry *entry;
Timo Teräsbf6506f2010-12-15 20:48:08 +0200737 struct onmessage_work_context *ctx;
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800738
739 while (1) {
Dexuan Cui652594c2015-03-27 09:10:08 -0700740 if (msg->header.message_type == HVMSG_NONE)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800741 /* no msg */
742 break;
Dexuan Cui652594c2015-03-27 09:10:08 -0700743
744 hdr = (struct vmbus_channel_message_header *)msg->u.payload;
745
746 if (hdr->msgtype >= CHANNELMSG_COUNT) {
747 WARN_ONCE(1, "unknown msgtype=%d\n", hdr->msgtype);
748 goto msg_handled;
749 }
750
751 entry = &channel_message_table[hdr->msgtype];
752 if (entry->handler_type == VMHT_BLOCKING) {
Timo Teräsbf6506f2010-12-15 20:48:08 +0200753 ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
754 if (ctx == NULL)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800755 continue;
Dexuan Cui652594c2015-03-27 09:10:08 -0700756
Timo Teräsbf6506f2010-12-15 20:48:08 +0200757 INIT_WORK(&ctx->work, vmbus_onmessage_work);
758 memcpy(&ctx->msg, msg, sizeof(*msg));
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800759
Dexuan Cui652594c2015-03-27 09:10:08 -0700760 queue_work(vmbus_connection.work_queue, &ctx->work);
761 } else
762 entry->message_handler(hdr);
763
764msg_handled:
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800765 msg->header.message_type = HVMSG_NONE;
766
767 /*
768 * Make sure the write to MessageType (ie set to
769 * HVMSG_NONE) happens before we read the
770 * MessagePending and EOMing. Otherwise, the EOMing
771 * will not deliver any more messages since there is
772 * no empty slot
773 */
Jason Wang35848f62013-06-18 13:04:23 +0800774 mb();
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800775
776 if (msg->header.message_flags.msg_pending) {
777 /*
778 * This will cause message queue rescan to
779 * possibly deliver another msg from the
780 * hypervisor
781 */
782 wrmsrl(HV_X64_MSR_EOM, 0);
783 }
784 }
785}
786
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100787static void vmbus_isr(void)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800788{
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800789 int cpu = smp_processor_id();
790 void *page_addr;
791 struct hv_message *msg;
792 union hv_synic_event_flags *event;
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700793 bool handled = false;
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800794
K. Y. Srinivasan5ab05952012-12-01 06:46:55 -0800795 page_addr = hv_context.synic_event_page[cpu];
796 if (page_addr == NULL)
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100797 return;
K. Y. Srinivasan5ab05952012-12-01 06:46:55 -0800798
799 event = (union hv_synic_event_flags *)page_addr +
800 VMBUS_MESSAGE_SINT;
K. Y. Srinivasan7341d902011-08-31 14:35:56 -0700801 /*
802 * Check for events before checking for messages. This is the order
803 * in which events and messages are checked in Windows guests on
804 * Hyper-V, and the Windows team suggested we do the same.
805 */
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800806
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800807 if ((vmbus_proto_version == VERSION_WS2008) ||
808 (vmbus_proto_version == VERSION_WIN7)) {
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800809
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800810 /* Since we are a child, we only need to check bit 0 */
811 if (sync_test_and_clear_bit(0,
812 (unsigned long *) &event->flags32[0])) {
813 handled = true;
814 }
815 } else {
816 /*
817 * Our host is win8 or above. The signaling mechanism
818 * has changed and we can directly look at the event page.
819 * If bit n is set then we have an interrup on the channel
820 * whose id is n.
821 */
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700822 handled = true;
K. Y. Srinivasan793be9c2011-03-15 15:03:43 -0700823 }
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700824
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800825 if (handled)
K. Y. Srinivasandb11f122012-12-01 06:46:53 -0800826 tasklet_schedule(hv_context.event_dpc[cpu]);
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800827
828
K. Y. Srinivasan7341d902011-08-31 14:35:56 -0700829 page_addr = hv_context.synic_message_page[cpu];
830 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
831
832 /* Check if there are actual msgs to be processed */
K. Y. Srinivasan4061ed92015-01-09 23:54:32 -0800833 if (msg->header.message_type != HVMSG_NONE) {
834 if (msg->header.message_type == HVMSG_TIMER_EXPIRED)
835 hv_process_timer_expiration(msg, cpu);
836 else
837 tasklet_schedule(&msg_dpc);
838 }
K. Y. Srinivasan793be9c2011-03-15 15:03:43 -0700839}
840
Vitaly Kuznetsove5132292015-02-27 11:25:51 -0800841
Hank Janssen3e189512010-03-04 22:11:00 +0000842/*
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700843 * vmbus_bus_init -Main vmbus driver initialization routine.
844 *
845 * Here, we
Lars Lindley0686e4f2010-03-11 23:51:23 +0100846 * - initialize the vmbus driver context
Lars Lindley0686e4f2010-03-11 23:51:23 +0100847 * - invoke the vmbus hv main init routine
Lars Lindley0686e4f2010-03-11 23:51:23 +0100848 * - retrieve the channel offers
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700849 */
K. Y. Srinivasanefc26722015-12-14 16:01:46 -0800850static int vmbus_bus_init(void)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700851{
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700852 int ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700853
Greg Kroah-Hartman6d26e38fa22010-12-02 12:08:08 -0800854 /* Hypervisor initialization...setup hypercall page..etc */
855 ret = hv_init();
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700856 if (ret != 0) {
Hank Janssen0a466182011-03-29 13:58:47 -0700857 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700858 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700859 }
860
K. Y. Srinivasan59c0e4f2011-04-29 13:45:06 -0700861 tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700862
K. Y. Srinivasan9adcac52011-04-29 13:45:08 -0700863 ret = bus_register(&hv_bus);
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700864 if (ret)
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700865 goto err_cleanup;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700866
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100867 hv_setup_vmbus_irq(vmbus_isr);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700868
Jason Wang2608fb62013-06-19 11:28:10 +0800869 ret = hv_synic_alloc();
870 if (ret)
871 goto err_alloc;
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700872 /*
K. Y. Srinivasan302a3c02013-02-17 11:30:44 -0800873 * Initialize the per-cpu interrupt state and
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700874 * connect to the host.
875 */
K. Y. Srinivasan302a3c02013-02-17 11:30:44 -0800876 on_each_cpu(hv_synic_init, NULL, 1);
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700877 ret = vmbus_connect();
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700878 if (ret)
Andrey Smetanin17efbee2015-12-14 16:01:38 -0800879 goto err_connect;
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700880
Vitaly Kuznetsovf39c4282015-08-05 00:52:48 -0700881 if (vmbus_proto_version > VERSION_WIN7)
882 cpu_hotplug_disable();
Nick Meier96c1d052015-02-28 11:39:01 -0800883
884 /*
885 * Only register if the crash MSRs are available
886 */
Denis V. Lunevcc2dd402015-08-01 16:08:20 -0700887 if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
Vitaly Kuznetsov510f7ae2015-08-01 16:08:10 -0700888 register_die_notifier(&hyperv_die_block);
Nick Meier96c1d052015-02-28 11:39:01 -0800889 atomic_notifier_chain_register(&panic_notifier_list,
890 &hyperv_panic_block);
891 }
892
Greg Kroah-Hartman2d6e8822010-12-02 08:50:58 -0800893 vmbus_request_offers();
Haiyang Zhang8b5d6d32010-05-28 23:22:44 +0000894
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700895 return 0;
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700896
Andrey Smetanin17efbee2015-12-14 16:01:38 -0800897err_connect:
898 on_each_cpu(hv_synic_cleanup, NULL, 1);
Jason Wang2608fb62013-06-19 11:28:10 +0800899err_alloc:
900 hv_synic_free();
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100901 hv_remove_vmbus_irq();
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700902
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700903 bus_unregister(&hv_bus);
904
905err_cleanup:
906 hv_cleanup();
907
908 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700909}
910
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700911/**
Jake Oshins35464482015-08-05 00:52:37 -0700912 * __vmbus_child_driver_register() - Register a vmbus's driver
913 * @hv_driver: Pointer to driver structure you want to register
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700914 * @owner: owner module of the drv
915 * @mod_name: module name string
Hank Janssen3e189512010-03-04 22:11:00 +0000916 *
917 * Registers the given driver with Linux through the 'driver_register()' call
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700918 * and sets up the hyper-v vmbus handling for this driver.
Hank Janssen3e189512010-03-04 22:11:00 +0000919 * It will return the state of the 'driver_register()' call.
920 *
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700921 */
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700922int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700923{
Bill Pemberton5d48a1c2009-07-27 16:47:36 -0400924 int ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700925
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700926 pr_info("registering driver %s\n", hv_driver->name);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700927
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -0800928 ret = vmbus_exists();
929 if (ret < 0)
930 return ret;
931
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700932 hv_driver->driver.name = hv_driver->name;
933 hv_driver->driver.owner = owner;
934 hv_driver->driver.mod_name = mod_name;
935 hv_driver->driver.bus = &hv_bus;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700936
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700937 ret = driver_register(&hv_driver->driver);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700938
Bill Pemberton5d48a1c2009-07-27 16:47:36 -0400939 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700940}
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700941EXPORT_SYMBOL_GPL(__vmbus_driver_register);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700942
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700943/**
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700944 * vmbus_driver_unregister() - Unregister a vmbus's driver
Jake Oshins35464482015-08-05 00:52:37 -0700945 * @hv_driver: Pointer to driver structure you want to
946 * un-register
Hank Janssen3e189512010-03-04 22:11:00 +0000947 *
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700948 * Un-register the given driver that was previous registered with a call to
949 * vmbus_driver_register()
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700950 */
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700951void vmbus_driver_unregister(struct hv_driver *hv_driver)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700952{
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700953 pr_info("unregistering driver %s\n", hv_driver->name);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700954
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -0800955 if (!vmbus_exists())
K. Y. Srinivasan8f257a12011-12-27 13:49:37 -0800956 driver_unregister(&hv_driver->driver);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700957}
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700958EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700959
Hank Janssen3e189512010-03-04 22:11:00 +0000960/*
K. Y. Srinivasanf2c73012011-09-08 07:24:12 -0700961 * vmbus_device_create - Creates and registers a new child device
Hank Janssen3e189512010-03-04 22:11:00 +0000962 * on the vmbus.
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700963 */
stephen hemminger1b9d48f2014-06-03 08:38:15 -0700964struct hv_device *vmbus_device_create(const uuid_le *type,
965 const uuid_le *instance,
966 struct vmbus_channel *channel)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700967{
Nicolas Palix3d3b5512009-07-28 17:32:53 +0200968 struct hv_device *child_device_obj;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700969
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800970 child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
971 if (!child_device_obj) {
Hank Janssen0a466182011-03-29 13:58:47 -0700972 pr_err("Unable to allocate device object for child device\n");
Hank Janssen3e7ee492009-07-13 16:02:34 -0700973 return NULL;
974 }
975
Greg Kroah-Hartmancae5b842010-10-21 09:05:27 -0700976 child_device_obj->channel = channel;
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -0700977 memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
Haiyang Zhangca623ad2011-01-26 12:12:11 -0800978 memcpy(&child_device_obj->dev_instance, instance,
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -0700979 sizeof(uuid_le));
K. Y. Srinivasan7047f172015-12-25 20:00:30 -0800980 child_device_obj->vendor_id = 0x1414; /* MSFT vendor ID */
Hank Janssen3e7ee492009-07-13 16:02:34 -0700981
Hank Janssen3e7ee492009-07-13 16:02:34 -0700982
Hank Janssen3e7ee492009-07-13 16:02:34 -0700983 return child_device_obj;
984}
985
Hank Janssen3e189512010-03-04 22:11:00 +0000986/*
K. Y. Srinivasan227942812011-09-08 07:24:13 -0700987 * vmbus_device_register - Register the child device
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700988 */
K. Y. Srinivasan227942812011-09-08 07:24:13 -0700989int vmbus_device_register(struct hv_device *child_device_obj)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700990{
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700991 int ret = 0;
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800992
Vitaly Kuznetsovbc63b6f2015-02-27 11:25:52 -0800993 dev_set_name(&child_device_obj->device, "vmbus_%d",
994 child_device_obj->channel->id);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700995
K. Y. Srinivasan0bce28b2011-08-27 11:31:39 -0700996 child_device_obj->device.bus = &hv_bus;
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -0700997 child_device_obj->device.parent = &hv_acpi_dev->dev;
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800998 child_device_obj->device.release = vmbus_device_release;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700999
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -07001000 /*
1001 * Register with the LDM. This will kick off the driver/device
1002 * binding...which will eventually call vmbus_match() and vmbus_probe()
1003 */
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -08001004 ret = device_register(&child_device_obj->device);
Hank Janssen3e7ee492009-07-13 16:02:34 -07001005
Hank Janssen3e7ee492009-07-13 16:02:34 -07001006 if (ret)
Hank Janssen0a466182011-03-29 13:58:47 -07001007 pr_err("Unable to register child device\n");
Hank Janssen3e7ee492009-07-13 16:02:34 -07001008 else
Fernando Soto84672362013-06-14 23:13:35 +00001009 pr_debug("child device %s registered\n",
Hank Janssen0a466182011-03-29 13:58:47 -07001010 dev_name(&child_device_obj->device));
Hank Janssen3e7ee492009-07-13 16:02:34 -07001011
Hank Janssen3e7ee492009-07-13 16:02:34 -07001012 return ret;
1013}
1014
Hank Janssen3e189512010-03-04 22:11:00 +00001015/*
K. Y. Srinivasan696453b2011-09-08 07:24:14 -07001016 * vmbus_device_unregister - Remove the specified child device
Hank Janssen3e189512010-03-04 22:11:00 +00001017 * from the vmbus.
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -07001018 */
K. Y. Srinivasan696453b2011-09-08 07:24:14 -07001019void vmbus_device_unregister(struct hv_device *device_obj)
Hank Janssen3e7ee492009-07-13 16:02:34 -07001020{
Fernando Soto84672362013-06-14 23:13:35 +00001021 pr_debug("child device %s unregistered\n",
1022 dev_name(&device_obj->device));
1023
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -07001024 /*
1025 * Kick off the process of unregistering the device.
1026 * This will call vmbus_remove() and eventually vmbus_device_release()
1027 */
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -08001028 device_unregister(&device_obj->device);
Hank Janssen3e7ee492009-07-13 16:02:34 -07001029}
1030
Hank Janssen3e7ee492009-07-13 16:02:34 -07001031
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001032/*
Jake Oshins7f163a62015-08-05 00:52:36 -07001033 * VMBUS is an acpi enumerated device. Get the information we
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001034 * need from DSDT.
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001035 */
Jake Oshins7f163a62015-08-05 00:52:36 -07001036#define VTPM_BASE_ADDRESS 0xfed40000
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001037static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *ctx)
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001038{
Jake Oshins7f163a62015-08-05 00:52:36 -07001039 resource_size_t start = 0;
1040 resource_size_t end = 0;
1041 struct resource *new_res;
1042 struct resource **old_res = &hyperv_mmio;
1043 struct resource **prev_res = NULL;
1044
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001045 switch (res->type) {
Jake Oshins7f163a62015-08-05 00:52:36 -07001046
1047 /*
1048 * "Address" descriptors are for bus windows. Ignore
1049 * "memory" descriptors, which are for registers on
1050 * devices.
1051 */
1052 case ACPI_RESOURCE_TYPE_ADDRESS32:
1053 start = res->data.address32.address.minimum;
1054 end = res->data.address32.address.maximum;
Gerd Hoffmann4eb923f2014-02-24 14:17:08 +01001055 break;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001056
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001057 case ACPI_RESOURCE_TYPE_ADDRESS64:
Jake Oshins7f163a62015-08-05 00:52:36 -07001058 start = res->data.address64.address.minimum;
1059 end = res->data.address64.address.maximum;
Gerd Hoffmann4eb923f2014-02-24 14:17:08 +01001060 break;
Jake Oshins7f163a62015-08-05 00:52:36 -07001061
1062 default:
1063 /* Unused resource type */
1064 return AE_OK;
1065
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001066 }
Jake Oshins7f163a62015-08-05 00:52:36 -07001067 /*
1068 * Ignore ranges that are below 1MB, as they're not
1069 * necessary or useful here.
1070 */
1071 if (end < 0x100000)
1072 return AE_OK;
1073
1074 new_res = kzalloc(sizeof(*new_res), GFP_ATOMIC);
1075 if (!new_res)
1076 return AE_NO_MEMORY;
1077
1078 /* If this range overlaps the virtual TPM, truncate it. */
1079 if (end > VTPM_BASE_ADDRESS && start < VTPM_BASE_ADDRESS)
1080 end = VTPM_BASE_ADDRESS;
1081
1082 new_res->name = "hyperv mmio";
1083 new_res->flags = IORESOURCE_MEM;
1084 new_res->start = start;
1085 new_res->end = end;
1086
Jake Oshins40f26f32015-12-14 16:01:52 -08001087 /*
1088 * Stick ranges from higher in address space at the front of the list.
1089 * If two ranges are adjacent, merge them.
1090 */
Jake Oshins7f163a62015-08-05 00:52:36 -07001091 do {
1092 if (!*old_res) {
1093 *old_res = new_res;
1094 break;
1095 }
1096
Jake Oshins40f26f32015-12-14 16:01:52 -08001097 if (((*old_res)->end + 1) == new_res->start) {
1098 (*old_res)->end = new_res->end;
1099 kfree(new_res);
1100 break;
1101 }
1102
1103 if ((*old_res)->start == new_res->end + 1) {
1104 (*old_res)->start = new_res->start;
1105 kfree(new_res);
1106 break;
1107 }
1108
Jake Oshins7f163a62015-08-05 00:52:36 -07001109 if ((*old_res)->end < new_res->start) {
1110 new_res->sibling = *old_res;
1111 if (prev_res)
1112 (*prev_res)->sibling = new_res;
1113 *old_res = new_res;
1114 break;
1115 }
1116
1117 prev_res = old_res;
1118 old_res = &(*old_res)->sibling;
1119
1120 } while (1);
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001121
1122 return AE_OK;
1123}
1124
Jake Oshins7f163a62015-08-05 00:52:36 -07001125static int vmbus_acpi_remove(struct acpi_device *device)
1126{
1127 struct resource *cur_res;
1128 struct resource *next_res;
1129
1130 if (hyperv_mmio) {
1131 for (cur_res = hyperv_mmio; cur_res; cur_res = next_res) {
1132 next_res = cur_res->sibling;
1133 kfree(cur_res);
1134 }
1135 }
1136
1137 return 0;
1138}
1139
Jake Oshins35464482015-08-05 00:52:37 -07001140/**
1141 * vmbus_allocate_mmio() - Pick a memory-mapped I/O range.
1142 * @new: If successful, supplied a pointer to the
1143 * allocated MMIO space.
1144 * @device_obj: Identifies the caller
1145 * @min: Minimum guest physical address of the
1146 * allocation
1147 * @max: Maximum guest physical address
1148 * @size: Size of the range to be allocated
1149 * @align: Alignment of the range to be allocated
1150 * @fb_overlap_ok: Whether this allocation can be allowed
1151 * to overlap the video frame buffer.
1152 *
1153 * This function walks the resources granted to VMBus by the
1154 * _CRS object in the ACPI namespace underneath the parent
1155 * "bridge" whether that's a root PCI bus in the Generation 1
1156 * case or a Module Device in the Generation 2 case. It then
1157 * attempts to allocate from the global MMIO pool in a way that
1158 * matches the constraints supplied in these parameters and by
1159 * that _CRS.
1160 *
1161 * Return: 0 on success, -errno on failure
1162 */
1163int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj,
1164 resource_size_t min, resource_size_t max,
1165 resource_size_t size, resource_size_t align,
1166 bool fb_overlap_ok)
1167{
1168 struct resource *iter;
1169 resource_size_t range_min, range_max, start, local_min, local_max;
1170 const char *dev_n = dev_name(&device_obj->device);
1171 u32 fb_end = screen_info.lfb_base + (screen_info.lfb_size << 1);
1172 int i;
1173
1174 for (iter = hyperv_mmio; iter; iter = iter->sibling) {
1175 if ((iter->start >= max) || (iter->end <= min))
1176 continue;
1177
1178 range_min = iter->start;
1179 range_max = iter->end;
1180
1181 /* If this range overlaps the frame buffer, split it into
1182 two tries. */
1183 for (i = 0; i < 2; i++) {
1184 local_min = range_min;
1185 local_max = range_max;
1186 if (fb_overlap_ok || (range_min >= fb_end) ||
1187 (range_max <= screen_info.lfb_base)) {
1188 i++;
1189 } else {
1190 if ((range_min <= screen_info.lfb_base) &&
1191 (range_max >= screen_info.lfb_base)) {
1192 /*
1193 * The frame buffer is in this window,
1194 * so trim this into the part that
1195 * preceeds the frame buffer.
1196 */
1197 local_max = screen_info.lfb_base - 1;
1198 range_min = fb_end;
1199 } else {
1200 range_min = fb_end;
1201 continue;
1202 }
1203 }
1204
1205 start = (local_min + align - 1) & ~(align - 1);
1206 for (; start + size - 1 <= local_max; start += align) {
1207 *new = request_mem_region_exclusive(start, size,
1208 dev_n);
1209 if (*new)
1210 return 0;
1211 }
1212 }
1213 }
1214
1215 return -ENXIO;
1216}
1217EXPORT_SYMBOL_GPL(vmbus_allocate_mmio);
1218
Jake Oshins619848b2015-12-14 16:01:39 -08001219/**
1220 * vmbus_cpu_number_to_vp_number() - Map CPU to VP.
1221 * @cpu_number: CPU number in Linux terms
1222 *
1223 * This function returns the mapping between the Linux processor
1224 * number and the hypervisor's virtual processor number, useful
1225 * in making hypercalls and such that talk about specific
1226 * processors.
1227 *
1228 * Return: Virtual processor number in Hyper-V terms
1229 */
1230int vmbus_cpu_number_to_vp_number(int cpu_number)
1231{
1232 return hv_context.vp_index[cpu_number];
1233}
1234EXPORT_SYMBOL_GPL(vmbus_cpu_number_to_vp_number);
1235
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001236static int vmbus_acpi_add(struct acpi_device *device)
1237{
1238 acpi_status result;
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001239 int ret_val = -ENODEV;
Jake Oshins7f163a62015-08-05 00:52:36 -07001240 struct acpi_device *ancestor;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001241
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -07001242 hv_acpi_dev = device;
1243
K. Y. Srinivasan0a4425b2011-08-27 11:31:38 -07001244 result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001245 vmbus_walk_resources, NULL);
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001246
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001247 if (ACPI_FAILURE(result))
1248 goto acpi_walk_err;
1249 /*
Jake Oshins7f163a62015-08-05 00:52:36 -07001250 * Some ancestor of the vmbus acpi device (Gen1 or Gen2
1251 * firmware) is the VMOD that has the mmio ranges. Get that.
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001252 */
Jake Oshins7f163a62015-08-05 00:52:36 -07001253 for (ancestor = device->parent; ancestor; ancestor = ancestor->parent) {
1254 result = acpi_walk_resources(ancestor->handle, METHOD_NAME__CRS,
1255 vmbus_walk_resources, NULL);
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001256
1257 if (ACPI_FAILURE(result))
Jake Oshins7f163a62015-08-05 00:52:36 -07001258 continue;
1259 if (hyperv_mmio)
1260 break;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001261 }
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001262 ret_val = 0;
1263
1264acpi_walk_err:
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001265 complete(&probe_event);
Jake Oshins7f163a62015-08-05 00:52:36 -07001266 if (ret_val)
1267 vmbus_acpi_remove(device);
K. Y. Srinivasan90f34532014-01-29 18:14:39 -08001268 return ret_val;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001269}
1270
1271static const struct acpi_device_id vmbus_acpi_device_ids[] = {
1272 {"VMBUS", 0},
K. Y. Srinivasan9d7b18d2011-06-06 15:49:42 -07001273 {"VMBus", 0},
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001274 {"", 0},
1275};
1276MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
1277
1278static struct acpi_driver vmbus_acpi_driver = {
1279 .name = "vmbus",
1280 .ids = vmbus_acpi_device_ids,
1281 .ops = {
1282 .add = vmbus_acpi_add,
Vitaly Kuznetsove4ecb412015-04-22 21:31:28 -07001283 .remove = vmbus_acpi_remove,
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001284 },
1285};
1286
Vitaly Kuznetsov25172812015-08-01 16:08:07 -07001287static void hv_kexec_handler(void)
1288{
1289 int cpu;
1290
1291 hv_synic_clockevents_cleanup();
1292 vmbus_initiate_unload();
1293 for_each_online_cpu(cpu)
1294 smp_call_function_single(cpu, hv_synic_cleanup, NULL, 1);
1295 hv_cleanup();
1296};
1297
Vitaly Kuznetsovb4370df2015-08-01 16:08:09 -07001298static void hv_crash_handler(struct pt_regs *regs)
1299{
1300 vmbus_initiate_unload();
1301 /*
1302 * In crash handler we can't schedule synic cleanup for all CPUs,
1303 * doing the cleanup for current CPU only. This should be sufficient
1304 * for kdump.
1305 */
1306 hv_synic_cleanup(NULL);
1307 hv_cleanup();
1308};
1309
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -07001310static int __init hv_acpi_init(void)
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -07001311{
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -07001312 int ret, t;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001313
Jason Wang1f94ea82012-08-31 13:32:44 +08001314 if (x86_hyper != &x86_hyper_ms_hyperv)
Jason Wang05929692012-08-17 18:52:43 +08001315 return -ENODEV;
1316
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001317 init_completion(&probe_event);
1318
1319 /*
K. Y. Srinivasanefc26722015-12-14 16:01:46 -08001320 * Get ACPI resources first.
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001321 */
K. Y. Srinivasan02466042011-06-06 15:49:40 -07001322 ret = acpi_bus_register_driver(&vmbus_acpi_driver);
1323
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001324 if (ret)
1325 return ret;
1326
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -07001327 t = wait_for_completion_timeout(&probe_event, 5*HZ);
1328 if (t == 0) {
1329 ret = -ETIMEDOUT;
1330 goto cleanup;
1331 }
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001332
K. Y. Srinivasanefc26722015-12-14 16:01:46 -08001333 ret = vmbus_bus_init();
K. Y. Srinivasan91fd7992011-06-16 13:16:38 -07001334 if (ret)
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -07001335 goto cleanup;
1336
Vitaly Kuznetsov25172812015-08-01 16:08:07 -07001337 hv_setup_kexec_handler(hv_kexec_handler);
Vitaly Kuznetsovb4370df2015-08-01 16:08:09 -07001338 hv_setup_crash_handler(hv_crash_handler);
Vitaly Kuznetsov25172812015-08-01 16:08:07 -07001339
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -07001340 return 0;
1341
1342cleanup:
1343 acpi_bus_unregister_driver(&vmbus_acpi_driver);
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -08001344 hv_acpi_dev = NULL;
K. Y. Srinivasan91fd7992011-06-16 13:16:38 -07001345 return ret;
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -07001346}
1347
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001348static void __exit vmbus_exit(void)
1349{
Vitaly Kuznetsove72e7ac2015-02-27 11:25:55 -08001350 int cpu;
1351
Vitaly Kuznetsov25172812015-08-01 16:08:07 -07001352 hv_remove_kexec_handler();
Vitaly Kuznetsovb4370df2015-08-01 16:08:09 -07001353 hv_remove_crash_handler();
Vitaly Kuznetsov09a19622015-02-27 11:25:54 -08001354 vmbus_connection.conn_state = DISCONNECTED;
Vitaly Kuznetsove0867482015-02-27 11:25:57 -08001355 hv_synic_clockevents_cleanup();
K. Y. Srinivasan2db84ef2015-04-22 21:31:32 -07001356 vmbus_disconnect();
Thomas Gleixner76d388c2014-03-05 13:42:14 +01001357 hv_remove_vmbus_irq();
Vitaly Kuznetsov1959a282015-05-06 17:47:41 -07001358 tasklet_kill(&msg_dpc);
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001359 vmbus_free_channels();
Denis V. Lunevcc2dd402015-08-01 16:08:20 -07001360 if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
Vitaly Kuznetsov510f7ae2015-08-01 16:08:10 -07001361 unregister_die_notifier(&hyperv_die_block);
Vitaly Kuznetsov096c6052015-04-22 21:31:29 -07001362 atomic_notifier_chain_unregister(&panic_notifier_list,
1363 &hyperv_panic_block);
1364 }
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001365 bus_unregister(&hv_bus);
1366 hv_cleanup();
Vitaly Kuznetsov1959a282015-05-06 17:47:41 -07001367 for_each_online_cpu(cpu) {
1368 tasklet_kill(hv_context.event_dpc[cpu]);
Vitaly Kuznetsove72e7ac2015-02-27 11:25:55 -08001369 smp_call_function_single(cpu, hv_synic_cleanup, NULL, 1);
Vitaly Kuznetsov1959a282015-05-06 17:47:41 -07001370 }
Vitaly Kuznetsov06210b42f2015-08-01 16:08:05 -07001371 hv_synic_free();
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001372 acpi_bus_unregister_driver(&vmbus_acpi_driver);
Vitaly Kuznetsovf39c4282015-08-05 00:52:48 -07001373 if (vmbus_proto_version > VERSION_WIN7)
1374 cpu_hotplug_enable();
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001375}
1376
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -07001377
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -07001378MODULE_LICENSE("GPL");
Hank Janssen3e7ee492009-07-13 16:02:34 -07001379
K. Y. Srinivasan43d4e112011-10-24 11:28:12 -07001380subsys_initcall(hv_acpi_init);
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001381module_exit(vmbus_exit);