blob: 2b7b51d264f1b8269f33cee9c427195d23e46ba2 [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>
K. Y. Srinivasan0f2a6612011-05-12 19:34:28 -070040#include "hyperv_vmbus.h"
Hank Janssen3e7ee492009-07-13 16:02:34 -070041
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -070042static struct acpi_device *hv_acpi_dev;
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -070043
K. Y. Srinivasan59c0e4f2011-04-29 13:45:06 -070044static struct tasklet_struct msg_dpc;
K. Y. Srinivasan71a66552011-04-29 13:45:04 -070045static struct completion probe_event;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -070046static int irq;
Hank Janssen3e7ee492009-07-13 16:02:34 -070047
Gerd Hoffmann90eedf02014-02-24 14:17:09 +010048struct resource hyperv_mmio = {
49 .name = "hyperv mmio",
50 .flags = IORESOURCE_MEM,
51};
52EXPORT_SYMBOL_GPL(hyperv_mmio);
Hank Janssen3e7ee492009-07-13 16:02:34 -070053
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -080054static int vmbus_exists(void)
55{
56 if (hv_acpi_dev == NULL)
57 return -ENODEV;
58
59 return 0;
60}
61
Olaf Heringfd776ba2011-09-02 18:25:56 +020062#define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
63static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
64{
65 int i;
66 for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
67 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
68}
69
Greg Kroah-Hartman76c52bb2013-09-13 11:32:56 -070070static u8 channel_monitor_group(struct vmbus_channel *channel)
71{
72 return (u8)channel->offermsg.monitorid / 32;
73}
74
75static u8 channel_monitor_offset(struct vmbus_channel *channel)
76{
77 return (u8)channel->offermsg.monitorid % 32;
78}
79
80static u32 channel_pending(struct vmbus_channel *channel,
81 struct hv_monitor_page *monitor_page)
82{
83 u8 monitor_group = channel_monitor_group(channel);
84 return monitor_page->trigger_group[monitor_group].pending;
85}
86
Greg Kroah-Hartman1cee2722013-09-13 11:32:57 -070087static u32 channel_latency(struct vmbus_channel *channel,
88 struct hv_monitor_page *monitor_page)
89{
90 u8 monitor_group = channel_monitor_group(channel);
91 u8 monitor_offset = channel_monitor_offset(channel);
92 return monitor_page->latency[monitor_group][monitor_offset];
93}
94
Greg Kroah-Hartman4947c742013-09-13 11:32:58 -070095static u32 channel_conn_id(struct vmbus_channel *channel,
96 struct hv_monitor_page *monitor_page)
97{
98 u8 monitor_group = channel_monitor_group(channel);
99 u8 monitor_offset = channel_monitor_offset(channel);
100 return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id;
101}
102
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700103static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr,
104 char *buf)
105{
106 struct hv_device *hv_dev = device_to_hv_device(dev);
107
108 if (!hv_dev->channel)
109 return -ENODEV;
110 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid);
111}
112static DEVICE_ATTR_RO(id);
113
Greg Kroah-Hartmana8fb5f32013-09-13 11:32:50 -0700114static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr,
115 char *buf)
116{
117 struct hv_device *hv_dev = device_to_hv_device(dev);
118
119 if (!hv_dev->channel)
120 return -ENODEV;
121 return sprintf(buf, "%d\n", hv_dev->channel->state);
122}
123static DEVICE_ATTR_RO(state);
124
Greg Kroah-Hartman5ffd00e2013-09-13 11:32:51 -0700125static ssize_t monitor_id_show(struct device *dev,
126 struct device_attribute *dev_attr, char *buf)
127{
128 struct hv_device *hv_dev = device_to_hv_device(dev);
129
130 if (!hv_dev->channel)
131 return -ENODEV;
132 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid);
133}
134static DEVICE_ATTR_RO(monitor_id);
135
Greg Kroah-Hartman68234c02013-09-13 11:32:53 -0700136static ssize_t class_id_show(struct device *dev,
137 struct device_attribute *dev_attr, char *buf)
138{
139 struct hv_device *hv_dev = device_to_hv_device(dev);
140
141 if (!hv_dev->channel)
142 return -ENODEV;
143 return sprintf(buf, "{%pUl}\n",
144 hv_dev->channel->offermsg.offer.if_type.b);
145}
146static DEVICE_ATTR_RO(class_id);
147
Greg Kroah-Hartman7c55e1d2013-09-13 11:32:54 -0700148static ssize_t device_id_show(struct device *dev,
149 struct device_attribute *dev_attr, char *buf)
150{
151 struct hv_device *hv_dev = device_to_hv_device(dev);
152
153 if (!hv_dev->channel)
154 return -ENODEV;
155 return sprintf(buf, "{%pUl}\n",
156 hv_dev->channel->offermsg.offer.if_instance.b);
157}
158static DEVICE_ATTR_RO(device_id);
159
Greg Kroah-Hartman647fa372013-09-13 11:32:52 -0700160static ssize_t modalias_show(struct device *dev,
161 struct device_attribute *dev_attr, char *buf)
162{
163 struct hv_device *hv_dev = device_to_hv_device(dev);
164 char alias_name[VMBUS_ALIAS_LEN + 1];
165
166 print_alias_name(hv_dev, alias_name);
167 return sprintf(buf, "vmbus:%s\n", alias_name);
168}
169static DEVICE_ATTR_RO(modalias);
170
Greg Kroah-Hartman76c52bb2013-09-13 11:32:56 -0700171static ssize_t server_monitor_pending_show(struct device *dev,
172 struct device_attribute *dev_attr,
173 char *buf)
174{
175 struct hv_device *hv_dev = device_to_hv_device(dev);
176
177 if (!hv_dev->channel)
178 return -ENODEV;
179 return sprintf(buf, "%d\n",
180 channel_pending(hv_dev->channel,
181 vmbus_connection.monitor_pages[1]));
182}
183static DEVICE_ATTR_RO(server_monitor_pending);
184
185static ssize_t client_monitor_pending_show(struct device *dev,
186 struct device_attribute *dev_attr,
187 char *buf)
188{
189 struct hv_device *hv_dev = device_to_hv_device(dev);
190
191 if (!hv_dev->channel)
192 return -ENODEV;
193 return sprintf(buf, "%d\n",
194 channel_pending(hv_dev->channel,
195 vmbus_connection.monitor_pages[1]));
196}
197static DEVICE_ATTR_RO(client_monitor_pending);
Greg Kroah-Hartman68234c02013-09-13 11:32:53 -0700198
Greg Kroah-Hartman1cee2722013-09-13 11:32:57 -0700199static ssize_t server_monitor_latency_show(struct device *dev,
200 struct device_attribute *dev_attr,
201 char *buf)
202{
203 struct hv_device *hv_dev = device_to_hv_device(dev);
204
205 if (!hv_dev->channel)
206 return -ENODEV;
207 return sprintf(buf, "%d\n",
208 channel_latency(hv_dev->channel,
209 vmbus_connection.monitor_pages[0]));
210}
211static DEVICE_ATTR_RO(server_monitor_latency);
212
213static ssize_t client_monitor_latency_show(struct device *dev,
214 struct device_attribute *dev_attr,
215 char *buf)
216{
217 struct hv_device *hv_dev = device_to_hv_device(dev);
218
219 if (!hv_dev->channel)
220 return -ENODEV;
221 return sprintf(buf, "%d\n",
222 channel_latency(hv_dev->channel,
223 vmbus_connection.monitor_pages[1]));
224}
225static DEVICE_ATTR_RO(client_monitor_latency);
226
Greg Kroah-Hartman4947c742013-09-13 11:32:58 -0700227static ssize_t server_monitor_conn_id_show(struct device *dev,
228 struct device_attribute *dev_attr,
229 char *buf)
230{
231 struct hv_device *hv_dev = device_to_hv_device(dev);
232
233 if (!hv_dev->channel)
234 return -ENODEV;
235 return sprintf(buf, "%d\n",
236 channel_conn_id(hv_dev->channel,
237 vmbus_connection.monitor_pages[0]));
238}
239static DEVICE_ATTR_RO(server_monitor_conn_id);
240
241static ssize_t client_monitor_conn_id_show(struct device *dev,
242 struct device_attribute *dev_attr,
243 char *buf)
244{
245 struct hv_device *hv_dev = device_to_hv_device(dev);
246
247 if (!hv_dev->channel)
248 return -ENODEV;
249 return sprintf(buf, "%d\n",
250 channel_conn_id(hv_dev->channel,
251 vmbus_connection.monitor_pages[1]));
252}
253static DEVICE_ATTR_RO(client_monitor_conn_id);
254
Greg Kroah-Hartman98f4c652013-09-13 11:33:01 -0700255static ssize_t out_intr_mask_show(struct device *dev,
256 struct device_attribute *dev_attr, char *buf)
257{
258 struct hv_device *hv_dev = device_to_hv_device(dev);
259 struct hv_ring_buffer_debug_info outbound;
260
261 if (!hv_dev->channel)
262 return -ENODEV;
263 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
264 return sprintf(buf, "%d\n", outbound.current_interrupt_mask);
265}
266static DEVICE_ATTR_RO(out_intr_mask);
267
268static ssize_t out_read_index_show(struct device *dev,
269 struct device_attribute *dev_attr, char *buf)
270{
271 struct hv_device *hv_dev = device_to_hv_device(dev);
272 struct hv_ring_buffer_debug_info outbound;
273
274 if (!hv_dev->channel)
275 return -ENODEV;
276 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
277 return sprintf(buf, "%d\n", outbound.current_read_index);
278}
279static DEVICE_ATTR_RO(out_read_index);
280
281static ssize_t out_write_index_show(struct device *dev,
282 struct device_attribute *dev_attr,
283 char *buf)
284{
285 struct hv_device *hv_dev = device_to_hv_device(dev);
286 struct hv_ring_buffer_debug_info outbound;
287
288 if (!hv_dev->channel)
289 return -ENODEV;
290 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
291 return sprintf(buf, "%d\n", outbound.current_write_index);
292}
293static DEVICE_ATTR_RO(out_write_index);
294
295static ssize_t out_read_bytes_avail_show(struct device *dev,
296 struct device_attribute *dev_attr,
297 char *buf)
298{
299 struct hv_device *hv_dev = device_to_hv_device(dev);
300 struct hv_ring_buffer_debug_info outbound;
301
302 if (!hv_dev->channel)
303 return -ENODEV;
304 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
305 return sprintf(buf, "%d\n", outbound.bytes_avail_toread);
306}
307static DEVICE_ATTR_RO(out_read_bytes_avail);
308
309static ssize_t out_write_bytes_avail_show(struct device *dev,
310 struct device_attribute *dev_attr,
311 char *buf)
312{
313 struct hv_device *hv_dev = device_to_hv_device(dev);
314 struct hv_ring_buffer_debug_info outbound;
315
316 if (!hv_dev->channel)
317 return -ENODEV;
318 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
319 return sprintf(buf, "%d\n", outbound.bytes_avail_towrite);
320}
321static DEVICE_ATTR_RO(out_write_bytes_avail);
322
323static ssize_t in_intr_mask_show(struct device *dev,
324 struct device_attribute *dev_attr, char *buf)
325{
326 struct hv_device *hv_dev = device_to_hv_device(dev);
327 struct hv_ring_buffer_debug_info inbound;
328
329 if (!hv_dev->channel)
330 return -ENODEV;
331 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
332 return sprintf(buf, "%d\n", inbound.current_interrupt_mask);
333}
334static DEVICE_ATTR_RO(in_intr_mask);
335
336static ssize_t in_read_index_show(struct device *dev,
337 struct device_attribute *dev_attr, char *buf)
338{
339 struct hv_device *hv_dev = device_to_hv_device(dev);
340 struct hv_ring_buffer_debug_info inbound;
341
342 if (!hv_dev->channel)
343 return -ENODEV;
344 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
345 return sprintf(buf, "%d\n", inbound.current_read_index);
346}
347static DEVICE_ATTR_RO(in_read_index);
348
349static ssize_t in_write_index_show(struct device *dev,
350 struct device_attribute *dev_attr, char *buf)
351{
352 struct hv_device *hv_dev = device_to_hv_device(dev);
353 struct hv_ring_buffer_debug_info inbound;
354
355 if (!hv_dev->channel)
356 return -ENODEV;
357 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
358 return sprintf(buf, "%d\n", inbound.current_write_index);
359}
360static DEVICE_ATTR_RO(in_write_index);
361
362static ssize_t in_read_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 inbound;
368
369 if (!hv_dev->channel)
370 return -ENODEV;
371 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
372 return sprintf(buf, "%d\n", inbound.bytes_avail_toread);
373}
374static DEVICE_ATTR_RO(in_read_bytes_avail);
375
376static ssize_t in_write_bytes_avail_show(struct device *dev,
377 struct device_attribute *dev_attr,
378 char *buf)
379{
380 struct hv_device *hv_dev = device_to_hv_device(dev);
381 struct hv_ring_buffer_debug_info inbound;
382
383 if (!hv_dev->channel)
384 return -ENODEV;
385 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
386 return sprintf(buf, "%d\n", inbound.bytes_avail_towrite);
387}
388static DEVICE_ATTR_RO(in_write_bytes_avail);
389
390/* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700391static struct attribute *vmbus_attrs[] = {
392 &dev_attr_id.attr,
Greg Kroah-Hartmana8fb5f32013-09-13 11:32:50 -0700393 &dev_attr_state.attr,
Greg Kroah-Hartman5ffd00e2013-09-13 11:32:51 -0700394 &dev_attr_monitor_id.attr,
Greg Kroah-Hartman68234c02013-09-13 11:32:53 -0700395 &dev_attr_class_id.attr,
Greg Kroah-Hartman7c55e1d2013-09-13 11:32:54 -0700396 &dev_attr_device_id.attr,
Greg Kroah-Hartman647fa372013-09-13 11:32:52 -0700397 &dev_attr_modalias.attr,
Greg Kroah-Hartman76c52bb2013-09-13 11:32:56 -0700398 &dev_attr_server_monitor_pending.attr,
399 &dev_attr_client_monitor_pending.attr,
Greg Kroah-Hartman1cee2722013-09-13 11:32:57 -0700400 &dev_attr_server_monitor_latency.attr,
401 &dev_attr_client_monitor_latency.attr,
Greg Kroah-Hartman4947c742013-09-13 11:32:58 -0700402 &dev_attr_server_monitor_conn_id.attr,
403 &dev_attr_client_monitor_conn_id.attr,
Greg Kroah-Hartman98f4c652013-09-13 11:33:01 -0700404 &dev_attr_out_intr_mask.attr,
405 &dev_attr_out_read_index.attr,
406 &dev_attr_out_write_index.attr,
407 &dev_attr_out_read_bytes_avail.attr,
408 &dev_attr_out_write_bytes_avail.attr,
409 &dev_attr_in_intr_mask.attr,
410 &dev_attr_in_read_index.attr,
411 &dev_attr_in_write_index.attr,
412 &dev_attr_in_read_bytes_avail.attr,
413 &dev_attr_in_write_bytes_avail.attr,
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700414 NULL,
415};
416ATTRIBUTE_GROUPS(vmbus);
417
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700418/*
419 * vmbus_uevent - add uevent for our device
420 *
421 * This routine is invoked when a device is added or removed on the vmbus to
422 * generate a uevent to udev in the userspace. The udev will then look at its
423 * rule and the uevent generated here to load the appropriate driver
K. Y. Srinivasan0ddda662011-08-25 09:48:38 -0700424 *
425 * The alias string will be of the form vmbus:guid where guid is the string
426 * representation of the device guid (each byte of the guid will be
427 * represented with two hex characters.
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700428 */
429static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
430{
431 struct hv_device *dev = device_to_hv_device(device);
Olaf Heringfd776ba2011-09-02 18:25:56 +0200432 int ret;
433 char alias_name[VMBUS_ALIAS_LEN + 1];
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700434
Olaf Heringfd776ba2011-09-02 18:25:56 +0200435 print_alias_name(dev, alias_name);
K. Y. Srinivasan0ddda662011-08-25 09:48:38 -0700436 ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
437 return ret;
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700438}
439
stephen hemminger1b9d48f2014-06-03 08:38:15 -0700440static const uuid_le null_guid;
K. Y. Srinivasan5841a822011-08-25 09:48:39 -0700441
442static inline bool is_null_guid(const __u8 *guid)
443{
444 if (memcmp(guid, &null_guid, sizeof(uuid_le)))
445 return false;
446 return true;
447}
448
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700449/*
450 * Return a matching hv_vmbus_device_id pointer.
451 * If there is no match, return NULL.
452 */
453static const struct hv_vmbus_device_id *hv_vmbus_get_id(
454 const struct hv_vmbus_device_id *id,
stephen hemminger1b9d48f2014-06-03 08:38:15 -0700455 const __u8 *guid)
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700456{
457 for (; !is_null_guid(id->guid); id++)
458 if (!memcmp(&id->guid, guid, sizeof(uuid_le)))
459 return id;
460
461 return NULL;
462}
463
464
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700465
466/*
467 * vmbus_match - Attempt to match the specified device to the specified driver
468 */
469static int vmbus_match(struct device *device, struct device_driver *driver)
470{
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700471 struct hv_driver *drv = drv_to_hv_drv(driver);
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700472 struct hv_device *hv_dev = device_to_hv_device(device);
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700473
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700474 if (hv_vmbus_get_id(drv->id_table, hv_dev->dev_type.b))
475 return 1;
K. Y. Srinivasande632a22011-04-26 09:20:24 -0700476
K. Y. Srinivasan5841a822011-08-25 09:48:39 -0700477 return 0;
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700478}
479
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700480/*
481 * vmbus_probe - Add the new vmbus's child device
482 */
483static int vmbus_probe(struct device *child_device)
484{
485 int ret = 0;
486 struct hv_driver *drv =
487 drv_to_hv_drv(child_device->driver);
K. Y. Srinivasan9efd21e2011-04-29 13:45:10 -0700488 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700489 const struct hv_vmbus_device_id *dev_id;
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700490
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700491 dev_id = hv_vmbus_get_id(drv->id_table, dev->dev_type.b);
K. Y. Srinivasan9efd21e2011-04-29 13:45:10 -0700492 if (drv->probe) {
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700493 ret = drv->probe(dev, dev_id);
K. Y. Srinivasanb14a7b32011-04-29 13:45:03 -0700494 if (ret != 0)
Hank Janssen0a466182011-03-29 13:58:47 -0700495 pr_err("probe failed for device %s (%d)\n",
496 dev_name(child_device), ret);
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700497
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700498 } else {
Hank Janssen0a466182011-03-29 13:58:47 -0700499 pr_err("probe not set for driver %s\n",
500 dev_name(child_device));
K. Y. Srinivasan6de925b2011-06-06 15:50:07 -0700501 ret = -ENODEV;
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700502 }
503 return ret;
504}
505
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700506/*
507 * vmbus_remove - Remove a vmbus device
508 */
509static int vmbus_remove(struct device *child_device)
510{
K. Y. Srinivasand15a0302015-02-28 11:18:16 -0800511 struct hv_driver *drv;
K. Y. Srinivasan415b0232011-04-29 13:45:12 -0700512 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasaned6cfcc2015-02-28 11:18:17 -0800513 u32 relid = dev->channel->offermsg.child_relid;
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700514
K. Y. Srinivasand15a0302015-02-28 11:18:16 -0800515 if (child_device->driver) {
516 drv = drv_to_hv_drv(child_device->driver);
517 if (drv->remove)
518 drv->remove(dev);
K. Y. Srinivasaned6cfcc2015-02-28 11:18:17 -0800519 else {
520 hv_process_channel_removal(dev->channel, relid);
K. Y. Srinivasand15a0302015-02-28 11:18:16 -0800521 pr_err("remove not set for driver %s\n",
522 dev_name(child_device));
K. Y. Srinivasaned6cfcc2015-02-28 11:18:17 -0800523 }
524 } else {
525 /*
526 * We don't have a driver for this device; deal with the
527 * rescind message by removing the channel.
528 */
529 hv_process_channel_removal(dev->channel, relid);
K. Y. Srinivasand15a0302015-02-28 11:18:16 -0800530 }
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700531
532 return 0;
533}
534
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700535
536/*
537 * vmbus_shutdown - Shutdown a vmbus device
538 */
539static void vmbus_shutdown(struct device *child_device)
540{
541 struct hv_driver *drv;
K. Y. Srinivasanca6887f2011-04-29 13:45:14 -0700542 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700543
544
545 /* The device may not be attached yet */
546 if (!child_device->driver)
547 return;
548
549 drv = drv_to_hv_drv(child_device->driver);
550
K. Y. Srinivasanca6887f2011-04-29 13:45:14 -0700551 if (drv->shutdown)
552 drv->shutdown(dev);
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700553
554 return;
555}
556
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700557
558/*
559 * vmbus_device_release - Final callback release of the vmbus child device
560 */
561static void vmbus_device_release(struct device *device)
562{
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700563 struct hv_device *hv_dev = device_to_hv_device(device);
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700564
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700565 kfree(hv_dev);
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700566
567}
568
Bill Pemberton454f18a2009-07-27 16:47:24 -0400569/* The one and only one */
K. Y. Srinivasan9adcac52011-04-29 13:45:08 -0700570static struct bus_type hv_bus = {
571 .name = "vmbus",
572 .match = vmbus_match,
573 .shutdown = vmbus_shutdown,
574 .remove = vmbus_remove,
575 .probe = vmbus_probe,
576 .uevent = vmbus_uevent,
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700577 .dev_groups = vmbus_groups,
Hank Janssen3e7ee492009-07-13 16:02:34 -0700578};
579
Timo Teräsbf6506f2010-12-15 20:48:08 +0200580struct onmessage_work_context {
581 struct work_struct work;
582 struct hv_message msg;
583};
584
585static void vmbus_onmessage_work(struct work_struct *work)
586{
587 struct onmessage_work_context *ctx;
588
Vitaly Kuznetsov09a19622015-02-27 11:25:54 -0800589 /* Do not process messages if we're in DISCONNECTED state */
590 if (vmbus_connection.conn_state == DISCONNECTED)
591 return;
592
Timo Teräsbf6506f2010-12-15 20:48:08 +0200593 ctx = container_of(work, struct onmessage_work_context,
594 work);
595 vmbus_onmessage(&ctx->msg);
596 kfree(ctx);
597}
598
kbuild test robotd8a60e02015-01-26 01:17:54 +0800599static void hv_process_timer_expiration(struct hv_message *msg, int cpu)
K. Y. Srinivasan4061ed92015-01-09 23:54:32 -0800600{
601 struct clock_event_device *dev = hv_context.clk_evt[cpu];
602
603 if (dev->event_handler)
604 dev->event_handler(dev);
605
606 msg->header.message_type = HVMSG_NONE;
607
608 /*
609 * Make sure the write to MessageType (ie set to
610 * HVMSG_NONE) happens before we read the
611 * MessagePending and EOMing. Otherwise, the EOMing
612 * will not deliver any more messages since there is
613 * no empty slot
614 */
615 mb();
616
617 if (msg->header.message_flags.msg_pending) {
618 /*
619 * This will cause message queue rescan to
620 * possibly deliver another msg from the
621 * hypervisor
622 */
623 wrmsrl(HV_X64_MSR_EOM, 0);
624 }
625}
626
K. Y. Srinivasan62c10592011-03-10 14:04:53 -0800627static void vmbus_on_msg_dpc(unsigned long data)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800628{
629 int cpu = smp_processor_id();
630 void *page_addr = hv_context.synic_message_page[cpu];
631 struct hv_message *msg = (struct hv_message *)page_addr +
632 VMBUS_MESSAGE_SINT;
Timo Teräsbf6506f2010-12-15 20:48:08 +0200633 struct onmessage_work_context *ctx;
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800634
635 while (1) {
636 if (msg->header.message_type == HVMSG_NONE) {
637 /* no msg */
638 break;
639 } else {
Timo Teräsbf6506f2010-12-15 20:48:08 +0200640 ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
641 if (ctx == NULL)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800642 continue;
Timo Teräsbf6506f2010-12-15 20:48:08 +0200643 INIT_WORK(&ctx->work, vmbus_onmessage_work);
644 memcpy(&ctx->msg, msg, sizeof(*msg));
Haiyang Zhangda9fcb72011-01-26 12:12:14 -0800645 queue_work(vmbus_connection.work_queue, &ctx->work);
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800646 }
647
648 msg->header.message_type = HVMSG_NONE;
649
650 /*
651 * Make sure the write to MessageType (ie set to
652 * HVMSG_NONE) happens before we read the
653 * MessagePending and EOMing. Otherwise, the EOMing
654 * will not deliver any more messages since there is
655 * no empty slot
656 */
Jason Wang35848f62013-06-18 13:04:23 +0800657 mb();
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800658
659 if (msg->header.message_flags.msg_pending) {
660 /*
661 * This will cause message queue rescan to
662 * possibly deliver another msg from the
663 * hypervisor
664 */
665 wrmsrl(HV_X64_MSR_EOM, 0);
666 }
667 }
668}
669
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100670static void vmbus_isr(void)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800671{
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800672 int cpu = smp_processor_id();
673 void *page_addr;
674 struct hv_message *msg;
675 union hv_synic_event_flags *event;
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700676 bool handled = false;
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800677
K. Y. Srinivasan5ab05952012-12-01 06:46:55 -0800678 page_addr = hv_context.synic_event_page[cpu];
679 if (page_addr == NULL)
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100680 return;
K. Y. Srinivasan5ab05952012-12-01 06:46:55 -0800681
682 event = (union hv_synic_event_flags *)page_addr +
683 VMBUS_MESSAGE_SINT;
K. Y. Srinivasan7341d902011-08-31 14:35:56 -0700684 /*
685 * Check for events before checking for messages. This is the order
686 * in which events and messages are checked in Windows guests on
687 * Hyper-V, and the Windows team suggested we do the same.
688 */
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800689
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800690 if ((vmbus_proto_version == VERSION_WS2008) ||
691 (vmbus_proto_version == VERSION_WIN7)) {
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800692
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800693 /* Since we are a child, we only need to check bit 0 */
694 if (sync_test_and_clear_bit(0,
695 (unsigned long *) &event->flags32[0])) {
696 handled = true;
697 }
698 } else {
699 /*
700 * Our host is win8 or above. The signaling mechanism
701 * has changed and we can directly look at the event page.
702 * If bit n is set then we have an interrup on the channel
703 * whose id is n.
704 */
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700705 handled = true;
K. Y. Srinivasan793be9c2011-03-15 15:03:43 -0700706 }
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700707
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800708 if (handled)
K. Y. Srinivasandb11f122012-12-01 06:46:53 -0800709 tasklet_schedule(hv_context.event_dpc[cpu]);
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800710
711
K. Y. Srinivasan7341d902011-08-31 14:35:56 -0700712 page_addr = hv_context.synic_message_page[cpu];
713 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
714
715 /* Check if there are actual msgs to be processed */
K. Y. Srinivasan4061ed92015-01-09 23:54:32 -0800716 if (msg->header.message_type != HVMSG_NONE) {
717 if (msg->header.message_type == HVMSG_TIMER_EXPIRED)
718 hv_process_timer_expiration(msg, cpu);
719 else
720 tasklet_schedule(&msg_dpc);
721 }
K. Y. Srinivasan793be9c2011-03-15 15:03:43 -0700722}
723
Vitaly Kuznetsove5132292015-02-27 11:25:51 -0800724#ifdef CONFIG_HOTPLUG_CPU
725static int hyperv_cpu_disable(void)
726{
727 return -ENOSYS;
728}
729
730static void hv_cpu_hotplug_quirk(bool vmbus_loaded)
731{
732 static void *previous_cpu_disable;
733
734 /*
735 * Offlining a CPU when running on newer hypervisors (WS2012R2, Win8,
736 * ...) is not supported at this moment as channel interrupts are
737 * distributed across all of them.
738 */
739
740 if ((vmbus_proto_version == VERSION_WS2008) ||
741 (vmbus_proto_version == VERSION_WIN7))
742 return;
743
744 if (vmbus_loaded) {
745 previous_cpu_disable = smp_ops.cpu_disable;
746 smp_ops.cpu_disable = hyperv_cpu_disable;
747 pr_notice("CPU offlining is not supported by hypervisor\n");
748 } else if (previous_cpu_disable)
749 smp_ops.cpu_disable = previous_cpu_disable;
750}
751#else
752static void hv_cpu_hotplug_quirk(bool vmbus_loaded)
753{
754}
755#endif
756
Hank Janssen3e189512010-03-04 22:11:00 +0000757/*
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700758 * vmbus_bus_init -Main vmbus driver initialization routine.
759 *
760 * Here, we
Lars Lindley0686e4f2010-03-11 23:51:23 +0100761 * - initialize the vmbus driver context
Lars Lindley0686e4f2010-03-11 23:51:23 +0100762 * - invoke the vmbus hv main init routine
763 * - get the irq resource
Lars Lindley0686e4f2010-03-11 23:51:23 +0100764 * - retrieve the channel offers
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700765 */
K. Y. Srinivasan9aaa9952011-06-06 15:49:37 -0700766static int vmbus_bus_init(int irq)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700767{
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700768 int ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700769
Greg Kroah-Hartman6d26e38fa22010-12-02 12:08:08 -0800770 /* Hypervisor initialization...setup hypercall page..etc */
771 ret = hv_init();
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700772 if (ret != 0) {
Hank Janssen0a466182011-03-29 13:58:47 -0700773 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700774 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700775 }
776
K. Y. Srinivasan59c0e4f2011-04-29 13:45:06 -0700777 tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700778
K. Y. Srinivasan9adcac52011-04-29 13:45:08 -0700779 ret = bus_register(&hv_bus);
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700780 if (ret)
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700781 goto err_cleanup;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700782
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100783 hv_setup_vmbus_irq(vmbus_isr);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700784
Jason Wang2608fb62013-06-19 11:28:10 +0800785 ret = hv_synic_alloc();
786 if (ret)
787 goto err_alloc;
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700788 /*
K. Y. Srinivasan302a3c02013-02-17 11:30:44 -0800789 * Initialize the per-cpu interrupt state and
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700790 * connect to the host.
791 */
K. Y. Srinivasan302a3c02013-02-17 11:30:44 -0800792 on_each_cpu(hv_synic_init, NULL, 1);
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700793 ret = vmbus_connect();
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700794 if (ret)
Jason Wang2608fb62013-06-19 11:28:10 +0800795 goto err_alloc;
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700796
Vitaly Kuznetsove5132292015-02-27 11:25:51 -0800797 hv_cpu_hotplug_quirk(true);
Greg Kroah-Hartman2d6e8822010-12-02 08:50:58 -0800798 vmbus_request_offers();
Haiyang Zhang8b5d6d32010-05-28 23:22:44 +0000799
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700800 return 0;
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700801
Jason Wang2608fb62013-06-19 11:28:10 +0800802err_alloc:
803 hv_synic_free();
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100804 hv_remove_vmbus_irq();
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700805
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700806 bus_unregister(&hv_bus);
807
808err_cleanup:
809 hv_cleanup();
810
811 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700812}
813
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700814/**
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700815 * __vmbus_child_driver_register - Register a vmbus's driver
816 * @drv: Pointer to driver structure you want to register
817 * @owner: owner module of the drv
818 * @mod_name: module name string
Hank Janssen3e189512010-03-04 22:11:00 +0000819 *
820 * Registers the given driver with Linux through the 'driver_register()' call
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700821 * and sets up the hyper-v vmbus handling for this driver.
Hank Janssen3e189512010-03-04 22:11:00 +0000822 * It will return the state of the 'driver_register()' call.
823 *
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700824 */
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700825int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700826{
Bill Pemberton5d48a1c2009-07-27 16:47:36 -0400827 int ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700828
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700829 pr_info("registering driver %s\n", hv_driver->name);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700830
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -0800831 ret = vmbus_exists();
832 if (ret < 0)
833 return ret;
834
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700835 hv_driver->driver.name = hv_driver->name;
836 hv_driver->driver.owner = owner;
837 hv_driver->driver.mod_name = mod_name;
838 hv_driver->driver.bus = &hv_bus;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700839
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700840 ret = driver_register(&hv_driver->driver);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700841
Bill Pemberton5d48a1c2009-07-27 16:47:36 -0400842 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700843}
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700844EXPORT_SYMBOL_GPL(__vmbus_driver_register);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700845
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700846/**
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700847 * vmbus_driver_unregister() - Unregister a vmbus's driver
848 * @drv: Pointer to driver structure you want to un-register
Hank Janssen3e189512010-03-04 22:11:00 +0000849 *
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700850 * Un-register the given driver that was previous registered with a call to
851 * vmbus_driver_register()
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700852 */
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700853void vmbus_driver_unregister(struct hv_driver *hv_driver)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700854{
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700855 pr_info("unregistering driver %s\n", hv_driver->name);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700856
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -0800857 if (!vmbus_exists())
K. Y. Srinivasan8f257a12011-12-27 13:49:37 -0800858 driver_unregister(&hv_driver->driver);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700859}
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700860EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700861
Hank Janssen3e189512010-03-04 22:11:00 +0000862/*
K. Y. Srinivasanf2c73012011-09-08 07:24:12 -0700863 * vmbus_device_create - Creates and registers a new child device
Hank Janssen3e189512010-03-04 22:11:00 +0000864 * on the vmbus.
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700865 */
stephen hemminger1b9d48f2014-06-03 08:38:15 -0700866struct hv_device *vmbus_device_create(const uuid_le *type,
867 const uuid_le *instance,
868 struct vmbus_channel *channel)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700869{
Nicolas Palix3d3b5512009-07-28 17:32:53 +0200870 struct hv_device *child_device_obj;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700871
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800872 child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
873 if (!child_device_obj) {
Hank Janssen0a466182011-03-29 13:58:47 -0700874 pr_err("Unable to allocate device object for child device\n");
Hank Janssen3e7ee492009-07-13 16:02:34 -0700875 return NULL;
876 }
877
Greg Kroah-Hartmancae5b842010-10-21 09:05:27 -0700878 child_device_obj->channel = channel;
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -0700879 memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
Haiyang Zhangca623ad2011-01-26 12:12:11 -0800880 memcpy(&child_device_obj->dev_instance, instance,
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -0700881 sizeof(uuid_le));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700882
Hank Janssen3e7ee492009-07-13 16:02:34 -0700883
Hank Janssen3e7ee492009-07-13 16:02:34 -0700884 return child_device_obj;
885}
886
Hank Janssen3e189512010-03-04 22:11:00 +0000887/*
K. Y. Srinivasan227942812011-09-08 07:24:13 -0700888 * vmbus_device_register - Register the child device
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700889 */
K. Y. Srinivasan227942812011-09-08 07:24:13 -0700890int vmbus_device_register(struct hv_device *child_device_obj)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700891{
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700892 int ret = 0;
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800893
Vitaly Kuznetsovbc63b6f2015-02-27 11:25:52 -0800894 dev_set_name(&child_device_obj->device, "vmbus_%d",
895 child_device_obj->channel->id);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700896
K. Y. Srinivasan0bce28b2011-08-27 11:31:39 -0700897 child_device_obj->device.bus = &hv_bus;
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -0700898 child_device_obj->device.parent = &hv_acpi_dev->dev;
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800899 child_device_obj->device.release = vmbus_device_release;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700900
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700901 /*
902 * Register with the LDM. This will kick off the driver/device
903 * binding...which will eventually call vmbus_match() and vmbus_probe()
904 */
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800905 ret = device_register(&child_device_obj->device);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700906
Hank Janssen3e7ee492009-07-13 16:02:34 -0700907 if (ret)
Hank Janssen0a466182011-03-29 13:58:47 -0700908 pr_err("Unable to register child device\n");
Hank Janssen3e7ee492009-07-13 16:02:34 -0700909 else
Fernando Soto84672362013-06-14 23:13:35 +0000910 pr_debug("child device %s registered\n",
Hank Janssen0a466182011-03-29 13:58:47 -0700911 dev_name(&child_device_obj->device));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700912
Hank Janssen3e7ee492009-07-13 16:02:34 -0700913 return ret;
914}
915
Hank Janssen3e189512010-03-04 22:11:00 +0000916/*
K. Y. Srinivasan696453b2011-09-08 07:24:14 -0700917 * vmbus_device_unregister - Remove the specified child device
Hank Janssen3e189512010-03-04 22:11:00 +0000918 * from the vmbus.
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700919 */
K. Y. Srinivasan696453b2011-09-08 07:24:14 -0700920void vmbus_device_unregister(struct hv_device *device_obj)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700921{
Fernando Soto84672362013-06-14 23:13:35 +0000922 pr_debug("child device %s unregistered\n",
923 dev_name(&device_obj->device));
924
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700925 /*
926 * Kick off the process of unregistering the device.
927 * This will call vmbus_remove() and eventually vmbus_device_release()
928 */
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800929 device_unregister(&device_obj->device);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700930}
931
Hank Janssen3e7ee492009-07-13 16:02:34 -0700932
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700933/*
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800934 * VMBUS is an acpi enumerated device. Get the the information we
935 * need from DSDT.
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700936 */
937
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800938static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *ctx)
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700939{
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800940 switch (res->type) {
941 case ACPI_RESOURCE_TYPE_IRQ:
942 irq = res->data.irq.interrupts[0];
Gerd Hoffmann4eb923f2014-02-24 14:17:08 +0100943 break;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700944
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800945 case ACPI_RESOURCE_TYPE_ADDRESS64:
Lv Zhenga45de932015-01-26 16:58:56 +0800946 hyperv_mmio.start = res->data.address64.address.minimum;
947 hyperv_mmio.end = res->data.address64.address.maximum;
Gerd Hoffmann4eb923f2014-02-24 14:17:08 +0100948 break;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700949 }
950
951 return AE_OK;
952}
953
954static int vmbus_acpi_add(struct acpi_device *device)
955{
956 acpi_status result;
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800957 int ret_val = -ENODEV;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700958
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -0700959 hv_acpi_dev = device;
960
K. Y. Srinivasan0a4425b2011-08-27 11:31:38 -0700961 result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800962 vmbus_walk_resources, NULL);
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700963
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800964 if (ACPI_FAILURE(result))
965 goto acpi_walk_err;
966 /*
967 * The parent of the vmbus acpi device (Gen2 firmware) is the VMOD that
968 * has the mmio ranges. Get that.
969 */
970 if (device->parent) {
971 result = acpi_walk_resources(device->parent->handle,
972 METHOD_NAME__CRS,
973 vmbus_walk_resources, NULL);
974
975 if (ACPI_FAILURE(result))
976 goto acpi_walk_err;
Gerd Hoffmann90eedf02014-02-24 14:17:09 +0100977 if (hyperv_mmio.start && hyperv_mmio.end)
978 request_resource(&iomem_resource, &hyperv_mmio);
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700979 }
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800980 ret_val = 0;
981
982acpi_walk_err:
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700983 complete(&probe_event);
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800984 return ret_val;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700985}
986
987static const struct acpi_device_id vmbus_acpi_device_ids[] = {
988 {"VMBUS", 0},
K. Y. Srinivasan9d7b18d2011-06-06 15:49:42 -0700989 {"VMBus", 0},
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700990 {"", 0},
991};
992MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
993
994static struct acpi_driver vmbus_acpi_driver = {
995 .name = "vmbus",
996 .ids = vmbus_acpi_device_ids,
997 .ops = {
998 .add = vmbus_acpi_add,
999 },
1000};
1001
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -07001002static int __init hv_acpi_init(void)
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -07001003{
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -07001004 int ret, t;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001005
Jason Wang1f94ea82012-08-31 13:32:44 +08001006 if (x86_hyper != &x86_hyper_ms_hyperv)
Jason Wang05929692012-08-17 18:52:43 +08001007 return -ENODEV;
1008
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001009 init_completion(&probe_event);
1010
1011 /*
1012 * Get irq resources first.
1013 */
K. Y. Srinivasan02466042011-06-06 15:49:40 -07001014 ret = acpi_bus_register_driver(&vmbus_acpi_driver);
1015
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001016 if (ret)
1017 return ret;
1018
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -07001019 t = wait_for_completion_timeout(&probe_event, 5*HZ);
1020 if (t == 0) {
1021 ret = -ETIMEDOUT;
1022 goto cleanup;
1023 }
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001024
1025 if (irq <= 0) {
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -07001026 ret = -ENODEV;
1027 goto cleanup;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -07001028 }
1029
K. Y. Srinivasan91fd7992011-06-16 13:16:38 -07001030 ret = vmbus_bus_init(irq);
1031 if (ret)
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -07001032 goto cleanup;
1033
1034 return 0;
1035
1036cleanup:
1037 acpi_bus_unregister_driver(&vmbus_acpi_driver);
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -08001038 hv_acpi_dev = NULL;
K. Y. Srinivasan91fd7992011-06-16 13:16:38 -07001039 return ret;
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -07001040}
1041
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001042static void __exit vmbus_exit(void)
1043{
Vitaly Kuznetsove72e7ac2015-02-27 11:25:55 -08001044 int cpu;
1045
Vitaly Kuznetsov09a19622015-02-27 11:25:54 -08001046 vmbus_connection.conn_state = DISCONNECTED;
Vitaly Kuznetsove0867482015-02-27 11:25:57 -08001047 hv_synic_clockevents_cleanup();
Thomas Gleixner76d388c2014-03-05 13:42:14 +01001048 hv_remove_vmbus_irq();
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001049 vmbus_free_channels();
1050 bus_unregister(&hv_bus);
1051 hv_cleanup();
Vitaly Kuznetsove72e7ac2015-02-27 11:25:55 -08001052 for_each_online_cpu(cpu)
1053 smp_call_function_single(cpu, hv_synic_cleanup, NULL, 1);
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001054 acpi_bus_unregister_driver(&vmbus_acpi_driver);
Vitaly Kuznetsove5132292015-02-27 11:25:51 -08001055 hv_cpu_hotplug_quirk(false);
Vitaly Kuznetsov09a19622015-02-27 11:25:54 -08001056 vmbus_disconnect();
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001057}
1058
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -07001059
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -07001060MODULE_LICENSE("GPL");
Hank Janssen3e7ee492009-07-13 16:02:34 -07001061
K. Y. Srinivasan43d4e112011-10-24 11:28:12 -07001062subsys_initcall(hv_acpi_init);
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -08001063module_exit(vmbus_exit);