blob: 8e53a3c2607e00c07e066b28f11c056aef4a6abd [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>
Greg Kroah-Hartman407dd162011-10-11 08:36:44 -060035#include <asm/hyperv.h>
Jason Wang1f94ea82012-08-31 13:32:44 +080036#include <asm/hypervisor.h>
K. Y. Srinivasan302a3c02013-02-17 11:30:44 -080037#include <asm/mshyperv.h>
K. Y. Srinivasan0f2a6612011-05-12 19:34:28 -070038#include "hyperv_vmbus.h"
Hank Janssen3e7ee492009-07-13 16:02:34 -070039
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -070040static struct acpi_device *hv_acpi_dev;
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -070041
K. Y. Srinivasan59c0e4f2011-04-29 13:45:06 -070042static struct tasklet_struct msg_dpc;
K. Y. Srinivasan71a66552011-04-29 13:45:04 -070043static struct completion probe_event;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -070044static int irq;
Hank Janssen3e7ee492009-07-13 16:02:34 -070045
Gerd Hoffmann90eedf02014-02-24 14:17:09 +010046struct resource hyperv_mmio = {
47 .name = "hyperv mmio",
48 .flags = IORESOURCE_MEM,
49};
50EXPORT_SYMBOL_GPL(hyperv_mmio);
Hank Janssen3e7ee492009-07-13 16:02:34 -070051
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -080052static int vmbus_exists(void)
53{
54 if (hv_acpi_dev == NULL)
55 return -ENODEV;
56
57 return 0;
58}
59
Olaf Heringfd776ba2011-09-02 18:25:56 +020060#define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
61static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
62{
63 int i;
64 for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
65 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
66}
67
Greg Kroah-Hartman76c52bb2013-09-13 11:32:56 -070068static u8 channel_monitor_group(struct vmbus_channel *channel)
69{
70 return (u8)channel->offermsg.monitorid / 32;
71}
72
73static u8 channel_monitor_offset(struct vmbus_channel *channel)
74{
75 return (u8)channel->offermsg.monitorid % 32;
76}
77
78static u32 channel_pending(struct vmbus_channel *channel,
79 struct hv_monitor_page *monitor_page)
80{
81 u8 monitor_group = channel_monitor_group(channel);
82 return monitor_page->trigger_group[monitor_group].pending;
83}
84
Greg Kroah-Hartman1cee2722013-09-13 11:32:57 -070085static u32 channel_latency(struct vmbus_channel *channel,
86 struct hv_monitor_page *monitor_page)
87{
88 u8 monitor_group = channel_monitor_group(channel);
89 u8 monitor_offset = channel_monitor_offset(channel);
90 return monitor_page->latency[monitor_group][monitor_offset];
91}
92
Greg Kroah-Hartman4947c742013-09-13 11:32:58 -070093static u32 channel_conn_id(struct vmbus_channel *channel,
94 struct hv_monitor_page *monitor_page)
95{
96 u8 monitor_group = channel_monitor_group(channel);
97 u8 monitor_offset = channel_monitor_offset(channel);
98 return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id;
99}
100
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700101static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr,
102 char *buf)
103{
104 struct hv_device *hv_dev = device_to_hv_device(dev);
105
106 if (!hv_dev->channel)
107 return -ENODEV;
108 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid);
109}
110static DEVICE_ATTR_RO(id);
111
Greg Kroah-Hartmana8fb5f32013-09-13 11:32:50 -0700112static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr,
113 char *buf)
114{
115 struct hv_device *hv_dev = device_to_hv_device(dev);
116
117 if (!hv_dev->channel)
118 return -ENODEV;
119 return sprintf(buf, "%d\n", hv_dev->channel->state);
120}
121static DEVICE_ATTR_RO(state);
122
Greg Kroah-Hartman5ffd00e2013-09-13 11:32:51 -0700123static ssize_t monitor_id_show(struct device *dev,
124 struct device_attribute *dev_attr, char *buf)
125{
126 struct hv_device *hv_dev = device_to_hv_device(dev);
127
128 if (!hv_dev->channel)
129 return -ENODEV;
130 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid);
131}
132static DEVICE_ATTR_RO(monitor_id);
133
Greg Kroah-Hartman68234c02013-09-13 11:32:53 -0700134static ssize_t class_id_show(struct device *dev,
135 struct device_attribute *dev_attr, char *buf)
136{
137 struct hv_device *hv_dev = device_to_hv_device(dev);
138
139 if (!hv_dev->channel)
140 return -ENODEV;
141 return sprintf(buf, "{%pUl}\n",
142 hv_dev->channel->offermsg.offer.if_type.b);
143}
144static DEVICE_ATTR_RO(class_id);
145
Greg Kroah-Hartman7c55e1d2013-09-13 11:32:54 -0700146static ssize_t device_id_show(struct device *dev,
147 struct device_attribute *dev_attr, char *buf)
148{
149 struct hv_device *hv_dev = device_to_hv_device(dev);
150
151 if (!hv_dev->channel)
152 return -ENODEV;
153 return sprintf(buf, "{%pUl}\n",
154 hv_dev->channel->offermsg.offer.if_instance.b);
155}
156static DEVICE_ATTR_RO(device_id);
157
Greg Kroah-Hartman647fa372013-09-13 11:32:52 -0700158static ssize_t modalias_show(struct device *dev,
159 struct device_attribute *dev_attr, char *buf)
160{
161 struct hv_device *hv_dev = device_to_hv_device(dev);
162 char alias_name[VMBUS_ALIAS_LEN + 1];
163
164 print_alias_name(hv_dev, alias_name);
165 return sprintf(buf, "vmbus:%s\n", alias_name);
166}
167static DEVICE_ATTR_RO(modalias);
168
Greg Kroah-Hartman76c52bb2013-09-13 11:32:56 -0700169static ssize_t server_monitor_pending_show(struct device *dev,
170 struct device_attribute *dev_attr,
171 char *buf)
172{
173 struct hv_device *hv_dev = device_to_hv_device(dev);
174
175 if (!hv_dev->channel)
176 return -ENODEV;
177 return sprintf(buf, "%d\n",
178 channel_pending(hv_dev->channel,
179 vmbus_connection.monitor_pages[1]));
180}
181static DEVICE_ATTR_RO(server_monitor_pending);
182
183static ssize_t client_monitor_pending_show(struct device *dev,
184 struct device_attribute *dev_attr,
185 char *buf)
186{
187 struct hv_device *hv_dev = device_to_hv_device(dev);
188
189 if (!hv_dev->channel)
190 return -ENODEV;
191 return sprintf(buf, "%d\n",
192 channel_pending(hv_dev->channel,
193 vmbus_connection.monitor_pages[1]));
194}
195static DEVICE_ATTR_RO(client_monitor_pending);
Greg Kroah-Hartman68234c02013-09-13 11:32:53 -0700196
Greg Kroah-Hartman1cee2722013-09-13 11:32:57 -0700197static ssize_t server_monitor_latency_show(struct device *dev,
198 struct device_attribute *dev_attr,
199 char *buf)
200{
201 struct hv_device *hv_dev = device_to_hv_device(dev);
202
203 if (!hv_dev->channel)
204 return -ENODEV;
205 return sprintf(buf, "%d\n",
206 channel_latency(hv_dev->channel,
207 vmbus_connection.monitor_pages[0]));
208}
209static DEVICE_ATTR_RO(server_monitor_latency);
210
211static ssize_t client_monitor_latency_show(struct device *dev,
212 struct device_attribute *dev_attr,
213 char *buf)
214{
215 struct hv_device *hv_dev = device_to_hv_device(dev);
216
217 if (!hv_dev->channel)
218 return -ENODEV;
219 return sprintf(buf, "%d\n",
220 channel_latency(hv_dev->channel,
221 vmbus_connection.monitor_pages[1]));
222}
223static DEVICE_ATTR_RO(client_monitor_latency);
224
Greg Kroah-Hartman4947c742013-09-13 11:32:58 -0700225static ssize_t server_monitor_conn_id_show(struct device *dev,
226 struct device_attribute *dev_attr,
227 char *buf)
228{
229 struct hv_device *hv_dev = device_to_hv_device(dev);
230
231 if (!hv_dev->channel)
232 return -ENODEV;
233 return sprintf(buf, "%d\n",
234 channel_conn_id(hv_dev->channel,
235 vmbus_connection.monitor_pages[0]));
236}
237static DEVICE_ATTR_RO(server_monitor_conn_id);
238
239static ssize_t client_monitor_conn_id_show(struct device *dev,
240 struct device_attribute *dev_attr,
241 char *buf)
242{
243 struct hv_device *hv_dev = device_to_hv_device(dev);
244
245 if (!hv_dev->channel)
246 return -ENODEV;
247 return sprintf(buf, "%d\n",
248 channel_conn_id(hv_dev->channel,
249 vmbus_connection.monitor_pages[1]));
250}
251static DEVICE_ATTR_RO(client_monitor_conn_id);
252
Greg Kroah-Hartman98f4c6512013-09-13 11:33:01 -0700253static ssize_t out_intr_mask_show(struct device *dev,
254 struct device_attribute *dev_attr, char *buf)
255{
256 struct hv_device *hv_dev = device_to_hv_device(dev);
257 struct hv_ring_buffer_debug_info outbound;
258
259 if (!hv_dev->channel)
260 return -ENODEV;
261 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
262 return sprintf(buf, "%d\n", outbound.current_interrupt_mask);
263}
264static DEVICE_ATTR_RO(out_intr_mask);
265
266static ssize_t out_read_index_show(struct device *dev,
267 struct device_attribute *dev_attr, char *buf)
268{
269 struct hv_device *hv_dev = device_to_hv_device(dev);
270 struct hv_ring_buffer_debug_info outbound;
271
272 if (!hv_dev->channel)
273 return -ENODEV;
274 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
275 return sprintf(buf, "%d\n", outbound.current_read_index);
276}
277static DEVICE_ATTR_RO(out_read_index);
278
279static ssize_t out_write_index_show(struct device *dev,
280 struct device_attribute *dev_attr,
281 char *buf)
282{
283 struct hv_device *hv_dev = device_to_hv_device(dev);
284 struct hv_ring_buffer_debug_info outbound;
285
286 if (!hv_dev->channel)
287 return -ENODEV;
288 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
289 return sprintf(buf, "%d\n", outbound.current_write_index);
290}
291static DEVICE_ATTR_RO(out_write_index);
292
293static ssize_t out_read_bytes_avail_show(struct device *dev,
294 struct device_attribute *dev_attr,
295 char *buf)
296{
297 struct hv_device *hv_dev = device_to_hv_device(dev);
298 struct hv_ring_buffer_debug_info outbound;
299
300 if (!hv_dev->channel)
301 return -ENODEV;
302 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
303 return sprintf(buf, "%d\n", outbound.bytes_avail_toread);
304}
305static DEVICE_ATTR_RO(out_read_bytes_avail);
306
307static ssize_t out_write_bytes_avail_show(struct device *dev,
308 struct device_attribute *dev_attr,
309 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.bytes_avail_towrite);
318}
319static DEVICE_ATTR_RO(out_write_bytes_avail);
320
321static ssize_t in_intr_mask_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 inbound;
326
327 if (!hv_dev->channel)
328 return -ENODEV;
329 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
330 return sprintf(buf, "%d\n", inbound.current_interrupt_mask);
331}
332static DEVICE_ATTR_RO(in_intr_mask);
333
334static ssize_t in_read_index_show(struct device *dev,
335 struct device_attribute *dev_attr, char *buf)
336{
337 struct hv_device *hv_dev = device_to_hv_device(dev);
338 struct hv_ring_buffer_debug_info inbound;
339
340 if (!hv_dev->channel)
341 return -ENODEV;
342 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
343 return sprintf(buf, "%d\n", inbound.current_read_index);
344}
345static DEVICE_ATTR_RO(in_read_index);
346
347static ssize_t in_write_index_show(struct device *dev,
348 struct device_attribute *dev_attr, char *buf)
349{
350 struct hv_device *hv_dev = device_to_hv_device(dev);
351 struct hv_ring_buffer_debug_info inbound;
352
353 if (!hv_dev->channel)
354 return -ENODEV;
355 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
356 return sprintf(buf, "%d\n", inbound.current_write_index);
357}
358static DEVICE_ATTR_RO(in_write_index);
359
360static ssize_t in_read_bytes_avail_show(struct device *dev,
361 struct device_attribute *dev_attr,
362 char *buf)
363{
364 struct hv_device *hv_dev = device_to_hv_device(dev);
365 struct hv_ring_buffer_debug_info inbound;
366
367 if (!hv_dev->channel)
368 return -ENODEV;
369 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
370 return sprintf(buf, "%d\n", inbound.bytes_avail_toread);
371}
372static DEVICE_ATTR_RO(in_read_bytes_avail);
373
374static ssize_t in_write_bytes_avail_show(struct device *dev,
375 struct device_attribute *dev_attr,
376 char *buf)
377{
378 struct hv_device *hv_dev = device_to_hv_device(dev);
379 struct hv_ring_buffer_debug_info inbound;
380
381 if (!hv_dev->channel)
382 return -ENODEV;
383 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
384 return sprintf(buf, "%d\n", inbound.bytes_avail_towrite);
385}
386static DEVICE_ATTR_RO(in_write_bytes_avail);
387
388/* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700389static struct attribute *vmbus_attrs[] = {
390 &dev_attr_id.attr,
Greg Kroah-Hartmana8fb5f32013-09-13 11:32:50 -0700391 &dev_attr_state.attr,
Greg Kroah-Hartman5ffd00e2013-09-13 11:32:51 -0700392 &dev_attr_monitor_id.attr,
Greg Kroah-Hartman68234c02013-09-13 11:32:53 -0700393 &dev_attr_class_id.attr,
Greg Kroah-Hartman7c55e1d2013-09-13 11:32:54 -0700394 &dev_attr_device_id.attr,
Greg Kroah-Hartman647fa372013-09-13 11:32:52 -0700395 &dev_attr_modalias.attr,
Greg Kroah-Hartman76c52bb2013-09-13 11:32:56 -0700396 &dev_attr_server_monitor_pending.attr,
397 &dev_attr_client_monitor_pending.attr,
Greg Kroah-Hartman1cee2722013-09-13 11:32:57 -0700398 &dev_attr_server_monitor_latency.attr,
399 &dev_attr_client_monitor_latency.attr,
Greg Kroah-Hartman4947c742013-09-13 11:32:58 -0700400 &dev_attr_server_monitor_conn_id.attr,
401 &dev_attr_client_monitor_conn_id.attr,
Greg Kroah-Hartman98f4c6512013-09-13 11:33:01 -0700402 &dev_attr_out_intr_mask.attr,
403 &dev_attr_out_read_index.attr,
404 &dev_attr_out_write_index.attr,
405 &dev_attr_out_read_bytes_avail.attr,
406 &dev_attr_out_write_bytes_avail.attr,
407 &dev_attr_in_intr_mask.attr,
408 &dev_attr_in_read_index.attr,
409 &dev_attr_in_write_index.attr,
410 &dev_attr_in_read_bytes_avail.attr,
411 &dev_attr_in_write_bytes_avail.attr,
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700412 NULL,
413};
414ATTRIBUTE_GROUPS(vmbus);
415
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700416/*
417 * vmbus_uevent - add uevent for our device
418 *
419 * This routine is invoked when a device is added or removed on the vmbus to
420 * generate a uevent to udev in the userspace. The udev will then look at its
421 * rule and the uevent generated here to load the appropriate driver
K. Y. Srinivasan0ddda662011-08-25 09:48:38 -0700422 *
423 * The alias string will be of the form vmbus:guid where guid is the string
424 * representation of the device guid (each byte of the guid will be
425 * represented with two hex characters.
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700426 */
427static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
428{
429 struct hv_device *dev = device_to_hv_device(device);
Olaf Heringfd776ba2011-09-02 18:25:56 +0200430 int ret;
431 char alias_name[VMBUS_ALIAS_LEN + 1];
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700432
Olaf Heringfd776ba2011-09-02 18:25:56 +0200433 print_alias_name(dev, alias_name);
K. Y. Srinivasan0ddda662011-08-25 09:48:38 -0700434 ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
435 return ret;
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700436}
437
K. Y. Srinivasan5841a822011-08-25 09:48:39 -0700438static uuid_le null_guid;
439
440static inline bool is_null_guid(const __u8 *guid)
441{
442 if (memcmp(guid, &null_guid, sizeof(uuid_le)))
443 return false;
444 return true;
445}
446
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700447/*
448 * Return a matching hv_vmbus_device_id pointer.
449 * If there is no match, return NULL.
450 */
451static const struct hv_vmbus_device_id *hv_vmbus_get_id(
452 const struct hv_vmbus_device_id *id,
453 __u8 *guid)
454{
455 for (; !is_null_guid(id->guid); id++)
456 if (!memcmp(&id->guid, guid, sizeof(uuid_le)))
457 return id;
458
459 return NULL;
460}
461
462
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700463
464/*
465 * vmbus_match - Attempt to match the specified device to the specified driver
466 */
467static int vmbus_match(struct device *device, struct device_driver *driver)
468{
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700469 struct hv_driver *drv = drv_to_hv_drv(driver);
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700470 struct hv_device *hv_dev = device_to_hv_device(device);
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700471
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700472 if (hv_vmbus_get_id(drv->id_table, hv_dev->dev_type.b))
473 return 1;
K. Y. Srinivasande632a22011-04-26 09:20:24 -0700474
K. Y. Srinivasan5841a822011-08-25 09:48:39 -0700475 return 0;
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700476}
477
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700478/*
479 * vmbus_probe - Add the new vmbus's child device
480 */
481static int vmbus_probe(struct device *child_device)
482{
483 int ret = 0;
484 struct hv_driver *drv =
485 drv_to_hv_drv(child_device->driver);
K. Y. Srinivasan9efd21e2011-04-29 13:45:10 -0700486 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700487 const struct hv_vmbus_device_id *dev_id;
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700488
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700489 dev_id = hv_vmbus_get_id(drv->id_table, dev->dev_type.b);
K. Y. Srinivasan9efd21e2011-04-29 13:45:10 -0700490 if (drv->probe) {
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700491 ret = drv->probe(dev, dev_id);
K. Y. Srinivasanb14a7b32011-04-29 13:45:03 -0700492 if (ret != 0)
Hank Janssen0a466182011-03-29 13:58:47 -0700493 pr_err("probe failed for device %s (%d)\n",
494 dev_name(child_device), ret);
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700495
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700496 } else {
Hank Janssen0a466182011-03-29 13:58:47 -0700497 pr_err("probe not set for driver %s\n",
498 dev_name(child_device));
K. Y. Srinivasan6de925b2011-06-06 15:50:07 -0700499 ret = -ENODEV;
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700500 }
501 return ret;
502}
503
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700504/*
505 * vmbus_remove - Remove a vmbus device
506 */
507static int vmbus_remove(struct device *child_device)
508{
K. Y. Srinivasand4372172011-09-13 10:59:44 -0700509 struct hv_driver *drv = drv_to_hv_drv(child_device->driver);
K. Y. Srinivasan415b0232011-04-29 13:45:12 -0700510 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700511
K. Y. Srinivasand4372172011-09-13 10:59:44 -0700512 if (drv->remove)
513 drv->remove(dev);
514 else
515 pr_err("remove not set for driver %s\n",
516 dev_name(child_device));
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700517
518 return 0;
519}
520
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700521
522/*
523 * vmbus_shutdown - Shutdown a vmbus device
524 */
525static void vmbus_shutdown(struct device *child_device)
526{
527 struct hv_driver *drv;
K. Y. Srinivasanca6887f2011-04-29 13:45:14 -0700528 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700529
530
531 /* The device may not be attached yet */
532 if (!child_device->driver)
533 return;
534
535 drv = drv_to_hv_drv(child_device->driver);
536
K. Y. Srinivasanca6887f2011-04-29 13:45:14 -0700537 if (drv->shutdown)
538 drv->shutdown(dev);
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700539
540 return;
541}
542
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700543
544/*
545 * vmbus_device_release - Final callback release of the vmbus child device
546 */
547static void vmbus_device_release(struct device *device)
548{
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700549 struct hv_device *hv_dev = device_to_hv_device(device);
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700550
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700551 kfree(hv_dev);
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700552
553}
554
Bill Pemberton454f18a2009-07-27 16:47:24 -0400555/* The one and only one */
K. Y. Srinivasan9adcac52011-04-29 13:45:08 -0700556static struct bus_type hv_bus = {
557 .name = "vmbus",
558 .match = vmbus_match,
559 .shutdown = vmbus_shutdown,
560 .remove = vmbus_remove,
561 .probe = vmbus_probe,
562 .uevent = vmbus_uevent,
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700563 .dev_groups = vmbus_groups,
Hank Janssen3e7ee492009-07-13 16:02:34 -0700564};
565
Timo Teräsbf6506f2010-12-15 20:48:08 +0200566struct onmessage_work_context {
567 struct work_struct work;
568 struct hv_message msg;
569};
570
571static void vmbus_onmessage_work(struct work_struct *work)
572{
573 struct onmessage_work_context *ctx;
574
575 ctx = container_of(work, struct onmessage_work_context,
576 work);
577 vmbus_onmessage(&ctx->msg);
578 kfree(ctx);
579}
580
K. Y. Srinivasan62c10592011-03-10 14:04:53 -0800581static void vmbus_on_msg_dpc(unsigned long data)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800582{
583 int cpu = smp_processor_id();
584 void *page_addr = hv_context.synic_message_page[cpu];
585 struct hv_message *msg = (struct hv_message *)page_addr +
586 VMBUS_MESSAGE_SINT;
Timo Teräsbf6506f2010-12-15 20:48:08 +0200587 struct onmessage_work_context *ctx;
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800588
589 while (1) {
590 if (msg->header.message_type == HVMSG_NONE) {
591 /* no msg */
592 break;
593 } else {
Timo Teräsbf6506f2010-12-15 20:48:08 +0200594 ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
595 if (ctx == NULL)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800596 continue;
Timo Teräsbf6506f2010-12-15 20:48:08 +0200597 INIT_WORK(&ctx->work, vmbus_onmessage_work);
598 memcpy(&ctx->msg, msg, sizeof(*msg));
Haiyang Zhangda9fcb72011-01-26 12:12:14 -0800599 queue_work(vmbus_connection.work_queue, &ctx->work);
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800600 }
601
602 msg->header.message_type = HVMSG_NONE;
603
604 /*
605 * Make sure the write to MessageType (ie set to
606 * HVMSG_NONE) happens before we read the
607 * MessagePending and EOMing. Otherwise, the EOMing
608 * will not deliver any more messages since there is
609 * no empty slot
610 */
Jason Wang35848f62013-06-18 13:04:23 +0800611 mb();
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800612
613 if (msg->header.message_flags.msg_pending) {
614 /*
615 * This will cause message queue rescan to
616 * possibly deliver another msg from the
617 * hypervisor
618 */
619 wrmsrl(HV_X64_MSR_EOM, 0);
620 }
621 }
622}
623
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100624static void vmbus_isr(void)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800625{
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800626 int cpu = smp_processor_id();
627 void *page_addr;
628 struct hv_message *msg;
629 union hv_synic_event_flags *event;
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700630 bool handled = false;
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800631
K. Y. Srinivasan5ab05952012-12-01 06:46:55 -0800632 page_addr = hv_context.synic_event_page[cpu];
633 if (page_addr == NULL)
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100634 return;
K. Y. Srinivasan5ab05952012-12-01 06:46:55 -0800635
636 event = (union hv_synic_event_flags *)page_addr +
637 VMBUS_MESSAGE_SINT;
K. Y. Srinivasan7341d902011-08-31 14:35:56 -0700638 /*
639 * Check for events before checking for messages. This is the order
640 * in which events and messages are checked in Windows guests on
641 * Hyper-V, and the Windows team suggested we do the same.
642 */
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800643
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800644 if ((vmbus_proto_version == VERSION_WS2008) ||
645 (vmbus_proto_version == VERSION_WIN7)) {
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800646
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800647 /* Since we are a child, we only need to check bit 0 */
648 if (sync_test_and_clear_bit(0,
649 (unsigned long *) &event->flags32[0])) {
650 handled = true;
651 }
652 } else {
653 /*
654 * Our host is win8 or above. The signaling mechanism
655 * has changed and we can directly look at the event page.
656 * If bit n is set then we have an interrup on the channel
657 * whose id is n.
658 */
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700659 handled = true;
K. Y. Srinivasan793be9c2011-03-15 15:03:43 -0700660 }
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700661
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800662 if (handled)
K. Y. Srinivasandb11f122012-12-01 06:46:53 -0800663 tasklet_schedule(hv_context.event_dpc[cpu]);
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800664
665
K. Y. Srinivasan7341d902011-08-31 14:35:56 -0700666 page_addr = hv_context.synic_message_page[cpu];
667 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
668
669 /* Check if there are actual msgs to be processed */
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100670 if (msg->header.message_type != HVMSG_NONE)
K. Y. Srinivasan7341d902011-08-31 14:35:56 -0700671 tasklet_schedule(&msg_dpc);
K. Y. Srinivasan793be9c2011-03-15 15:03:43 -0700672}
673
Hank Janssen3e189512010-03-04 22:11:00 +0000674/*
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700675 * vmbus_bus_init -Main vmbus driver initialization routine.
676 *
677 * Here, we
Lars Lindley0686e4f2010-03-11 23:51:23 +0100678 * - initialize the vmbus driver context
Lars Lindley0686e4f2010-03-11 23:51:23 +0100679 * - invoke the vmbus hv main init routine
680 * - get the irq resource
Lars Lindley0686e4f2010-03-11 23:51:23 +0100681 * - retrieve the channel offers
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700682 */
K. Y. Srinivasan9aaa9952011-06-06 15:49:37 -0700683static int vmbus_bus_init(int irq)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700684{
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700685 int ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700686
Greg Kroah-Hartman6d26e38fa22010-12-02 12:08:08 -0800687 /* Hypervisor initialization...setup hypercall page..etc */
688 ret = hv_init();
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700689 if (ret != 0) {
Hank Janssen0a466182011-03-29 13:58:47 -0700690 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700691 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700692 }
693
K. Y. Srinivasan59c0e4f2011-04-29 13:45:06 -0700694 tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700695
K. Y. Srinivasan9adcac52011-04-29 13:45:08 -0700696 ret = bus_register(&hv_bus);
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700697 if (ret)
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700698 goto err_cleanup;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700699
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100700 hv_setup_vmbus_irq(vmbus_isr);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700701
Jason Wang2608fb62013-06-19 11:28:10 +0800702 ret = hv_synic_alloc();
703 if (ret)
704 goto err_alloc;
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700705 /*
K. Y. Srinivasan302a3c02013-02-17 11:30:44 -0800706 * Initialize the per-cpu interrupt state and
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700707 * connect to the host.
708 */
K. Y. Srinivasan302a3c02013-02-17 11:30:44 -0800709 on_each_cpu(hv_synic_init, NULL, 1);
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700710 ret = vmbus_connect();
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700711 if (ret)
Jason Wang2608fb62013-06-19 11:28:10 +0800712 goto err_alloc;
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700713
Greg Kroah-Hartman2d6e8822010-12-02 08:50:58 -0800714 vmbus_request_offers();
Haiyang Zhang8b5d6d32010-05-28 23:22:44 +0000715
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700716 return 0;
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700717
Jason Wang2608fb62013-06-19 11:28:10 +0800718err_alloc:
719 hv_synic_free();
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100720 hv_remove_vmbus_irq();
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700721
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700722 bus_unregister(&hv_bus);
723
724err_cleanup:
725 hv_cleanup();
726
727 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700728}
729
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700730/**
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700731 * __vmbus_child_driver_register - Register a vmbus's driver
732 * @drv: Pointer to driver structure you want to register
733 * @owner: owner module of the drv
734 * @mod_name: module name string
Hank Janssen3e189512010-03-04 22:11:00 +0000735 *
736 * Registers the given driver with Linux through the 'driver_register()' call
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700737 * and sets up the hyper-v vmbus handling for this driver.
Hank Janssen3e189512010-03-04 22:11:00 +0000738 * It will return the state of the 'driver_register()' call.
739 *
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700740 */
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700741int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700742{
Bill Pemberton5d48a1c2009-07-27 16:47:36 -0400743 int ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700744
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700745 pr_info("registering driver %s\n", hv_driver->name);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700746
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -0800747 ret = vmbus_exists();
748 if (ret < 0)
749 return ret;
750
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700751 hv_driver->driver.name = hv_driver->name;
752 hv_driver->driver.owner = owner;
753 hv_driver->driver.mod_name = mod_name;
754 hv_driver->driver.bus = &hv_bus;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700755
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700756 ret = driver_register(&hv_driver->driver);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700757
Bill Pemberton5d48a1c2009-07-27 16:47:36 -0400758 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700759}
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700760EXPORT_SYMBOL_GPL(__vmbus_driver_register);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700761
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700762/**
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700763 * vmbus_driver_unregister() - Unregister a vmbus's driver
764 * @drv: Pointer to driver structure you want to un-register
Hank Janssen3e189512010-03-04 22:11:00 +0000765 *
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700766 * Un-register the given driver that was previous registered with a call to
767 * vmbus_driver_register()
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700768 */
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700769void vmbus_driver_unregister(struct hv_driver *hv_driver)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700770{
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700771 pr_info("unregistering driver %s\n", hv_driver->name);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700772
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -0800773 if (!vmbus_exists())
K. Y. Srinivasan8f257a12011-12-27 13:49:37 -0800774 driver_unregister(&hv_driver->driver);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700775}
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700776EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700777
Hank Janssen3e189512010-03-04 22:11:00 +0000778/*
K. Y. Srinivasanf2c73012011-09-08 07:24:12 -0700779 * vmbus_device_create - Creates and registers a new child device
Hank Janssen3e189512010-03-04 22:11:00 +0000780 * on the vmbus.
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700781 */
K. Y. Srinivasanf2c73012011-09-08 07:24:12 -0700782struct hv_device *vmbus_device_create(uuid_le *type,
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -0700783 uuid_le *instance,
Greg Kroah-Hartman89733aa2010-12-02 08:22:41 -0800784 struct vmbus_channel *channel)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700785{
Nicolas Palix3d3b5512009-07-28 17:32:53 +0200786 struct hv_device *child_device_obj;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700787
K. Y. Srinivasan6bad88d2011-03-07 13:35:48 -0800788 child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
789 if (!child_device_obj) {
Hank Janssen0a466182011-03-29 13:58:47 -0700790 pr_err("Unable to allocate device object for child device\n");
Hank Janssen3e7ee492009-07-13 16:02:34 -0700791 return NULL;
792 }
793
Greg Kroah-Hartmancae5b842010-10-21 09:05:27 -0700794 child_device_obj->channel = channel;
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -0700795 memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
Haiyang Zhangca623ad2011-01-26 12:12:11 -0800796 memcpy(&child_device_obj->dev_instance, instance,
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -0700797 sizeof(uuid_le));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700798
Hank Janssen3e7ee492009-07-13 16:02:34 -0700799
Hank Janssen3e7ee492009-07-13 16:02:34 -0700800 return child_device_obj;
801}
802
Hank Janssen3e189512010-03-04 22:11:00 +0000803/*
K. Y. Srinivasan227942812011-09-08 07:24:13 -0700804 * vmbus_device_register - Register the child device
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700805 */
K. Y. Srinivasan227942812011-09-08 07:24:13 -0700806int vmbus_device_register(struct hv_device *child_device_obj)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700807{
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700808 int ret = 0;
K. Y. Srinivasan6bad88d2011-03-07 13:35:48 -0800809
Bill Pembertonf4888412009-07-29 17:00:12 -0400810 static atomic_t device_num = ATOMIC_INIT(0);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700811
K. Y. Srinivasan6bad88d2011-03-07 13:35:48 -0800812 dev_set_name(&child_device_obj->device, "vmbus_0_%d",
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700813 atomic_inc_return(&device_num));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700814
K. Y. Srinivasan0bce28b2011-08-27 11:31:39 -0700815 child_device_obj->device.bus = &hv_bus;
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -0700816 child_device_obj->device.parent = &hv_acpi_dev->dev;
K. Y. Srinivasan6bad88d2011-03-07 13:35:48 -0800817 child_device_obj->device.release = vmbus_device_release;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700818
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700819 /*
820 * Register with the LDM. This will kick off the driver/device
821 * binding...which will eventually call vmbus_match() and vmbus_probe()
822 */
K. Y. Srinivasan6bad88d2011-03-07 13:35:48 -0800823 ret = device_register(&child_device_obj->device);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700824
Hank Janssen3e7ee492009-07-13 16:02:34 -0700825 if (ret)
Hank Janssen0a466182011-03-29 13:58:47 -0700826 pr_err("Unable to register child device\n");
Hank Janssen3e7ee492009-07-13 16:02:34 -0700827 else
Fernando Soto84672362013-06-14 23:13:35 +0000828 pr_debug("child device %s registered\n",
Hank Janssen0a466182011-03-29 13:58:47 -0700829 dev_name(&child_device_obj->device));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700830
Hank Janssen3e7ee492009-07-13 16:02:34 -0700831 return ret;
832}
833
Hank Janssen3e189512010-03-04 22:11:00 +0000834/*
K. Y. Srinivasan696453b2011-09-08 07:24:14 -0700835 * vmbus_device_unregister - Remove the specified child device
Hank Janssen3e189512010-03-04 22:11:00 +0000836 * from the vmbus.
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700837 */
K. Y. Srinivasan696453b2011-09-08 07:24:14 -0700838void vmbus_device_unregister(struct hv_device *device_obj)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700839{
Fernando Soto84672362013-06-14 23:13:35 +0000840 pr_debug("child device %s unregistered\n",
841 dev_name(&device_obj->device));
842
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700843 /*
844 * Kick off the process of unregistering the device.
845 * This will call vmbus_remove() and eventually vmbus_device_release()
846 */
K. Y. Srinivasan6bad88d2011-03-07 13:35:48 -0800847 device_unregister(&device_obj->device);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700848}
849
Hank Janssen3e7ee492009-07-13 16:02:34 -0700850
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700851/*
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800852 * VMBUS is an acpi enumerated device. Get the the information we
853 * need from DSDT.
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700854 */
855
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800856static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *ctx)
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700857{
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800858 switch (res->type) {
859 case ACPI_RESOURCE_TYPE_IRQ:
860 irq = res->data.irq.interrupts[0];
Gerd Hoffmann4eb923f2014-02-24 14:17:08 +0100861 break;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700862
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800863 case ACPI_RESOURCE_TYPE_ADDRESS64:
Gerd Hoffmann90eedf02014-02-24 14:17:09 +0100864 hyperv_mmio.start = res->data.address64.minimum;
865 hyperv_mmio.end = res->data.address64.maximum;
Gerd Hoffmann4eb923f2014-02-24 14:17:08 +0100866 break;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700867 }
868
869 return AE_OK;
870}
871
872static int vmbus_acpi_add(struct acpi_device *device)
873{
874 acpi_status result;
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800875 int ret_val = -ENODEV;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700876
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -0700877 hv_acpi_dev = device;
878
K. Y. Srinivasan0a4425b2011-08-27 11:31:38 -0700879 result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800880 vmbus_walk_resources, NULL);
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700881
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800882 if (ACPI_FAILURE(result))
883 goto acpi_walk_err;
884 /*
885 * The parent of the vmbus acpi device (Gen2 firmware) is the VMOD that
886 * has the mmio ranges. Get that.
887 */
888 if (device->parent) {
889 result = acpi_walk_resources(device->parent->handle,
890 METHOD_NAME__CRS,
891 vmbus_walk_resources, NULL);
892
893 if (ACPI_FAILURE(result))
894 goto acpi_walk_err;
Gerd Hoffmann90eedf02014-02-24 14:17:09 +0100895 if (hyperv_mmio.start && hyperv_mmio.end)
896 request_resource(&iomem_resource, &hyperv_mmio);
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700897 }
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800898 ret_val = 0;
899
900acpi_walk_err:
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700901 complete(&probe_event);
K. Y. Srinivasan90f34532014-01-29 18:14:39 -0800902 return ret_val;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700903}
904
905static const struct acpi_device_id vmbus_acpi_device_ids[] = {
906 {"VMBUS", 0},
K. Y. Srinivasan9d7b18d2011-06-06 15:49:42 -0700907 {"VMBus", 0},
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700908 {"", 0},
909};
910MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
911
912static struct acpi_driver vmbus_acpi_driver = {
913 .name = "vmbus",
914 .ids = vmbus_acpi_device_ids,
915 .ops = {
916 .add = vmbus_acpi_add,
917 },
918};
919
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -0700920static int __init hv_acpi_init(void)
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -0700921{
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -0700922 int ret, t;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700923
Jason Wang1f94ea82012-08-31 13:32:44 +0800924 if (x86_hyper != &x86_hyper_ms_hyperv)
Jason Wang05929692012-08-17 18:52:43 +0800925 return -ENODEV;
926
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700927 init_completion(&probe_event);
928
929 /*
930 * Get irq resources first.
931 */
K. Y. Srinivasan02466042011-06-06 15:49:40 -0700932 ret = acpi_bus_register_driver(&vmbus_acpi_driver);
933
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700934 if (ret)
935 return ret;
936
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -0700937 t = wait_for_completion_timeout(&probe_event, 5*HZ);
938 if (t == 0) {
939 ret = -ETIMEDOUT;
940 goto cleanup;
941 }
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700942
943 if (irq <= 0) {
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -0700944 ret = -ENODEV;
945 goto cleanup;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700946 }
947
K. Y. Srinivasan91fd7992011-06-16 13:16:38 -0700948 ret = vmbus_bus_init(irq);
949 if (ret)
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -0700950 goto cleanup;
951
952 return 0;
953
954cleanup:
955 acpi_bus_unregister_driver(&vmbus_acpi_driver);
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -0800956 hv_acpi_dev = NULL;
K. Y. Srinivasan91fd7992011-06-16 13:16:38 -0700957 return ret;
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -0700958}
959
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -0800960static void __exit vmbus_exit(void)
961{
Thomas Gleixner76d388c2014-03-05 13:42:14 +0100962 hv_remove_vmbus_irq();
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -0800963 vmbus_free_channels();
964 bus_unregister(&hv_bus);
965 hv_cleanup();
966 acpi_bus_unregister_driver(&vmbus_acpi_driver);
967}
968
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -0700969
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700970MODULE_LICENSE("GPL");
Hank Janssen3e7ee492009-07-13 16:02:34 -0700971
K. Y. Srinivasan43d4e112011-10-24 11:28:12 -0700972subsys_initcall(hv_acpi_init);
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -0800973module_exit(vmbus_exit);