blob: 73cb456e256be3908ce15b4c9dbedf20521ca2c1 [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>
28#include <linux/irq.h>
29#include <linux/interrupt.h>
30#include <linux/sysctl.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090031#include <linux/slab.h>
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -070032#include <linux/acpi.h>
33#include <acpi/acpi_bus.h>
Haiyang Zhang8b5d6d32010-05-28 23:22:44 +000034#include <linux/completion.h>
Greg Kroah-Hartman46a97192011-10-04 12:29:52 -070035#include <linux/hyperv.h>
K. Y. Srinivasanb0209502012-12-01 06:46:54 -080036#include <linux/kernel_stat.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
Hank Janssen3e7ee492009-07-13 16:02:34 -070042
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -070043static struct acpi_device *hv_acpi_dev;
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -070044
K. Y. Srinivasan59c0e4f2011-04-29 13:45:06 -070045static struct tasklet_struct msg_dpc;
K. Y. Srinivasan71a66552011-04-29 13:45:04 -070046static struct completion probe_event;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -070047static int irq;
Hank Janssen3e7ee492009-07-13 16:02:34 -070048
Greg Kroah-Hartman15b80d62011-10-11 09:43:14 -060049struct hv_device_info {
Greg Kroah-Hartman15b80d62011-10-11 09:43:14 -060050 struct hv_dev_port_info inbound;
51 struct hv_dev_port_info outbound;
52};
53
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
Greg Kroah-Hartman15b80d62011-10-11 09:43:14 -060062
K. Y. Srinivasan98db4332011-03-15 15:03:44 -070063static void get_channel_info(struct hv_device *device,
64 struct hv_device_info *info)
65{
66 struct vmbus_channel_debug_info debug_info;
67
68 if (!device->channel)
69 return;
70
71 vmbus_get_debug_info(device->channel, &debug_info);
72
K. Y. Srinivasan98db4332011-03-15 15:03:44 -070073 info->inbound.int_mask = debug_info.inbound.current_interrupt_mask;
74 info->inbound.read_idx = debug_info.inbound.current_read_index;
75 info->inbound.write_idx = debug_info.inbound.current_write_index;
76 info->inbound.bytes_avail_toread =
77 debug_info.inbound.bytes_avail_toread;
78 info->inbound.bytes_avail_towrite =
79 debug_info.inbound.bytes_avail_towrite;
80
81 info->outbound.int_mask =
82 debug_info.outbound.current_interrupt_mask;
83 info->outbound.read_idx = debug_info.outbound.current_read_index;
84 info->outbound.write_idx = debug_info.outbound.current_write_index;
85 info->outbound.bytes_avail_toread =
86 debug_info.outbound.bytes_avail_toread;
87 info->outbound.bytes_avail_towrite =
88 debug_info.outbound.bytes_avail_towrite;
89}
90
Olaf Heringfd776ba2011-09-02 18:25:56 +020091#define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
92static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
93{
94 int i;
95 for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
96 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
97}
98
K. Y. Srinivasan98db4332011-03-15 15:03:44 -070099/*
100 * vmbus_show_device_attr - Show the device attribute in sysfs.
101 *
102 * This is invoked when user does a
103 * "cat /sys/bus/vmbus/devices/<busdevice>/<attr name>"
104 */
105static ssize_t vmbus_show_device_attr(struct device *dev,
106 struct device_attribute *dev_attr,
107 char *buf)
108{
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700109 struct hv_device *hv_dev = device_to_hv_device(dev);
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700110 struct hv_device_info *device_info;
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700111 int ret = 0;
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700112
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700113 device_info = kzalloc(sizeof(struct hv_device_info), GFP_KERNEL);
114 if (!device_info)
115 return ret;
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700116
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700117 get_channel_info(hv_dev, device_info);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700118
Greg Kroah-Hartman7c55e1d2013-09-13 11:32:54 -0700119 if (!strcmp(dev_attr->attr.name, "out_intr_mask")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700120 ret = sprintf(buf, "%d\n", device_info->outbound.int_mask);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700121 } else if (!strcmp(dev_attr->attr.name, "out_read_index")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700122 ret = sprintf(buf, "%d\n", device_info->outbound.read_idx);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700123 } else if (!strcmp(dev_attr->attr.name, "out_write_index")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700124 ret = sprintf(buf, "%d\n", device_info->outbound.write_idx);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700125 } else if (!strcmp(dev_attr->attr.name, "out_read_bytes_avail")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700126 ret = sprintf(buf, "%d\n",
127 device_info->outbound.bytes_avail_toread);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700128 } else if (!strcmp(dev_attr->attr.name, "out_write_bytes_avail")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700129 ret = sprintf(buf, "%d\n",
130 device_info->outbound.bytes_avail_towrite);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700131 } else if (!strcmp(dev_attr->attr.name, "in_intr_mask")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700132 ret = sprintf(buf, "%d\n", device_info->inbound.int_mask);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700133 } else if (!strcmp(dev_attr->attr.name, "in_read_index")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700134 ret = sprintf(buf, "%d\n", device_info->inbound.read_idx);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700135 } else if (!strcmp(dev_attr->attr.name, "in_write_index")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700136 ret = sprintf(buf, "%d\n", device_info->inbound.write_idx);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700137 } else if (!strcmp(dev_attr->attr.name, "in_read_bytes_avail")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700138 ret = sprintf(buf, "%d\n",
139 device_info->inbound.bytes_avail_toread);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700140 } else if (!strcmp(dev_attr->attr.name, "in_write_bytes_avail")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700141 ret = sprintf(buf, "%d\n",
142 device_info->inbound.bytes_avail_towrite);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700143 }
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700144
145 kfree(device_info);
146 return ret;
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700147}
148
Greg Kroah-Hartman76c52bb2013-09-13 11:32:56 -0700149static u8 channel_monitor_group(struct vmbus_channel *channel)
150{
151 return (u8)channel->offermsg.monitorid / 32;
152}
153
154static u8 channel_monitor_offset(struct vmbus_channel *channel)
155{
156 return (u8)channel->offermsg.monitorid % 32;
157}
158
159static u32 channel_pending(struct vmbus_channel *channel,
160 struct hv_monitor_page *monitor_page)
161{
162 u8 monitor_group = channel_monitor_group(channel);
163 return monitor_page->trigger_group[monitor_group].pending;
164}
165
Greg Kroah-Hartman1cee2722013-09-13 11:32:57 -0700166static u32 channel_latency(struct vmbus_channel *channel,
167 struct hv_monitor_page *monitor_page)
168{
169 u8 monitor_group = channel_monitor_group(channel);
170 u8 monitor_offset = channel_monitor_offset(channel);
171 return monitor_page->latency[monitor_group][monitor_offset];
172}
173
Greg Kroah-Hartman4947c742013-09-13 11:32:58 -0700174static u32 channel_conn_id(struct vmbus_channel *channel,
175 struct hv_monitor_page *monitor_page)
176{
177 u8 monitor_group = channel_monitor_group(channel);
178 u8 monitor_offset = channel_monitor_offset(channel);
179 return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id;
180}
181
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700182static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr,
183 char *buf)
184{
185 struct hv_device *hv_dev = device_to_hv_device(dev);
186
187 if (!hv_dev->channel)
188 return -ENODEV;
189 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid);
190}
191static DEVICE_ATTR_RO(id);
192
Greg Kroah-Hartmana8fb5f32013-09-13 11:32:50 -0700193static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr,
194 char *buf)
195{
196 struct hv_device *hv_dev = device_to_hv_device(dev);
197
198 if (!hv_dev->channel)
199 return -ENODEV;
200 return sprintf(buf, "%d\n", hv_dev->channel->state);
201}
202static DEVICE_ATTR_RO(state);
203
Greg Kroah-Hartman5ffd00e2013-09-13 11:32:51 -0700204static ssize_t monitor_id_show(struct device *dev,
205 struct device_attribute *dev_attr, char *buf)
206{
207 struct hv_device *hv_dev = device_to_hv_device(dev);
208
209 if (!hv_dev->channel)
210 return -ENODEV;
211 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid);
212}
213static DEVICE_ATTR_RO(monitor_id);
214
Greg Kroah-Hartman68234c02013-09-13 11:32:53 -0700215static ssize_t class_id_show(struct device *dev,
216 struct device_attribute *dev_attr, char *buf)
217{
218 struct hv_device *hv_dev = device_to_hv_device(dev);
219
220 if (!hv_dev->channel)
221 return -ENODEV;
222 return sprintf(buf, "{%pUl}\n",
223 hv_dev->channel->offermsg.offer.if_type.b);
224}
225static DEVICE_ATTR_RO(class_id);
226
Greg Kroah-Hartman7c55e1d2013-09-13 11:32:54 -0700227static ssize_t device_id_show(struct device *dev,
228 struct device_attribute *dev_attr, char *buf)
229{
230 struct hv_device *hv_dev = device_to_hv_device(dev);
231
232 if (!hv_dev->channel)
233 return -ENODEV;
234 return sprintf(buf, "{%pUl}\n",
235 hv_dev->channel->offermsg.offer.if_instance.b);
236}
237static DEVICE_ATTR_RO(device_id);
238
Greg Kroah-Hartman647fa372013-09-13 11:32:52 -0700239static ssize_t modalias_show(struct device *dev,
240 struct device_attribute *dev_attr, char *buf)
241{
242 struct hv_device *hv_dev = device_to_hv_device(dev);
243 char alias_name[VMBUS_ALIAS_LEN + 1];
244
245 print_alias_name(hv_dev, alias_name);
246 return sprintf(buf, "vmbus:%s\n", alias_name);
247}
248static DEVICE_ATTR_RO(modalias);
249
Greg Kroah-Hartman76c52bb2013-09-13 11:32:56 -0700250static ssize_t server_monitor_pending_show(struct device *dev,
251 struct device_attribute *dev_attr,
252 char *buf)
253{
254 struct hv_device *hv_dev = device_to_hv_device(dev);
255
256 if (!hv_dev->channel)
257 return -ENODEV;
258 return sprintf(buf, "%d\n",
259 channel_pending(hv_dev->channel,
260 vmbus_connection.monitor_pages[1]));
261}
262static DEVICE_ATTR_RO(server_monitor_pending);
263
264static ssize_t client_monitor_pending_show(struct device *dev,
265 struct device_attribute *dev_attr,
266 char *buf)
267{
268 struct hv_device *hv_dev = device_to_hv_device(dev);
269
270 if (!hv_dev->channel)
271 return -ENODEV;
272 return sprintf(buf, "%d\n",
273 channel_pending(hv_dev->channel,
274 vmbus_connection.monitor_pages[1]));
275}
276static DEVICE_ATTR_RO(client_monitor_pending);
Greg Kroah-Hartman68234c02013-09-13 11:32:53 -0700277
Greg Kroah-Hartman1cee2722013-09-13 11:32:57 -0700278static ssize_t server_monitor_latency_show(struct device *dev,
279 struct device_attribute *dev_attr,
280 char *buf)
281{
282 struct hv_device *hv_dev = device_to_hv_device(dev);
283
284 if (!hv_dev->channel)
285 return -ENODEV;
286 return sprintf(buf, "%d\n",
287 channel_latency(hv_dev->channel,
288 vmbus_connection.monitor_pages[0]));
289}
290static DEVICE_ATTR_RO(server_monitor_latency);
291
292static ssize_t client_monitor_latency_show(struct device *dev,
293 struct device_attribute *dev_attr,
294 char *buf)
295{
296 struct hv_device *hv_dev = device_to_hv_device(dev);
297
298 if (!hv_dev->channel)
299 return -ENODEV;
300 return sprintf(buf, "%d\n",
301 channel_latency(hv_dev->channel,
302 vmbus_connection.monitor_pages[1]));
303}
304static DEVICE_ATTR_RO(client_monitor_latency);
305
Greg Kroah-Hartman4947c742013-09-13 11:32:58 -0700306static ssize_t server_monitor_conn_id_show(struct device *dev,
307 struct device_attribute *dev_attr,
308 char *buf)
309{
310 struct hv_device *hv_dev = device_to_hv_device(dev);
311
312 if (!hv_dev->channel)
313 return -ENODEV;
314 return sprintf(buf, "%d\n",
315 channel_conn_id(hv_dev->channel,
316 vmbus_connection.monitor_pages[0]));
317}
318static DEVICE_ATTR_RO(server_monitor_conn_id);
319
320static ssize_t client_monitor_conn_id_show(struct device *dev,
321 struct device_attribute *dev_attr,
322 char *buf)
323{
324 struct hv_device *hv_dev = device_to_hv_device(dev);
325
326 if (!hv_dev->channel)
327 return -ENODEV;
328 return sprintf(buf, "%d\n",
329 channel_conn_id(hv_dev->channel,
330 vmbus_connection.monitor_pages[1]));
331}
332static DEVICE_ATTR_RO(client_monitor_conn_id);
333
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700334static struct attribute *vmbus_attrs[] = {
335 &dev_attr_id.attr,
Greg Kroah-Hartmana8fb5f32013-09-13 11:32:50 -0700336 &dev_attr_state.attr,
Greg Kroah-Hartman5ffd00e2013-09-13 11:32:51 -0700337 &dev_attr_monitor_id.attr,
Greg Kroah-Hartman68234c02013-09-13 11:32:53 -0700338 &dev_attr_class_id.attr,
Greg Kroah-Hartman7c55e1d2013-09-13 11:32:54 -0700339 &dev_attr_device_id.attr,
Greg Kroah-Hartman647fa372013-09-13 11:32:52 -0700340 &dev_attr_modalias.attr,
Greg Kroah-Hartman76c52bb2013-09-13 11:32:56 -0700341 &dev_attr_server_monitor_pending.attr,
342 &dev_attr_client_monitor_pending.attr,
Greg Kroah-Hartman1cee2722013-09-13 11:32:57 -0700343 &dev_attr_server_monitor_latency.attr,
344 &dev_attr_client_monitor_latency.attr,
Greg Kroah-Hartman4947c742013-09-13 11:32:58 -0700345 &dev_attr_server_monitor_conn_id.attr,
346 &dev_attr_client_monitor_conn_id.attr,
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700347 NULL,
348};
349ATTRIBUTE_GROUPS(vmbus);
350
Bill Pemberton454f18a2009-07-27 16:47:24 -0400351/* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
Hank Janssen3e7ee492009-07-13 16:02:34 -0700352static struct device_attribute vmbus_device_attrs[] = {
Hank Janssen3e7ee492009-07-13 16:02:34 -0700353 __ATTR(out_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL),
354 __ATTR(out_read_index, S_IRUGO, vmbus_show_device_attr, NULL),
355 __ATTR(out_write_index, S_IRUGO, vmbus_show_device_attr, NULL),
356 __ATTR(out_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
357 __ATTR(out_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
358
359 __ATTR(in_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL),
360 __ATTR(in_read_index, S_IRUGO, vmbus_show_device_attr, NULL),
361 __ATTR(in_write_index, S_IRUGO, vmbus_show_device_attr, NULL),
362 __ATTR(in_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
363 __ATTR(in_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
364 __ATTR_NULL
365};
Hank Janssen3e7ee492009-07-13 16:02:34 -0700366
K. Y. Srinivasan793be9c2011-03-15 15:03:43 -0700367
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700368/*
369 * vmbus_uevent - add uevent for our device
370 *
371 * This routine is invoked when a device is added or removed on the vmbus to
372 * generate a uevent to udev in the userspace. The udev will then look at its
373 * rule and the uevent generated here to load the appropriate driver
K. Y. Srinivasan0ddda662011-08-25 09:48:38 -0700374 *
375 * The alias string will be of the form vmbus:guid where guid is the string
376 * representation of the device guid (each byte of the guid will be
377 * represented with two hex characters.
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700378 */
379static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
380{
381 struct hv_device *dev = device_to_hv_device(device);
Olaf Heringfd776ba2011-09-02 18:25:56 +0200382 int ret;
383 char alias_name[VMBUS_ALIAS_LEN + 1];
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700384
Olaf Heringfd776ba2011-09-02 18:25:56 +0200385 print_alias_name(dev, alias_name);
K. Y. Srinivasan0ddda662011-08-25 09:48:38 -0700386 ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
387 return ret;
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700388}
389
K. Y. Srinivasan5841a822011-08-25 09:48:39 -0700390static uuid_le null_guid;
391
392static inline bool is_null_guid(const __u8 *guid)
393{
394 if (memcmp(guid, &null_guid, sizeof(uuid_le)))
395 return false;
396 return true;
397}
398
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700399/*
400 * Return a matching hv_vmbus_device_id pointer.
401 * If there is no match, return NULL.
402 */
403static const struct hv_vmbus_device_id *hv_vmbus_get_id(
404 const struct hv_vmbus_device_id *id,
405 __u8 *guid)
406{
407 for (; !is_null_guid(id->guid); id++)
408 if (!memcmp(&id->guid, guid, sizeof(uuid_le)))
409 return id;
410
411 return NULL;
412}
413
414
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700415
416/*
417 * vmbus_match - Attempt to match the specified device to the specified driver
418 */
419static int vmbus_match(struct device *device, struct device_driver *driver)
420{
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700421 struct hv_driver *drv = drv_to_hv_drv(driver);
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700422 struct hv_device *hv_dev = device_to_hv_device(device);
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700423
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700424 if (hv_vmbus_get_id(drv->id_table, hv_dev->dev_type.b))
425 return 1;
K. Y. Srinivasande632a22011-04-26 09:20:24 -0700426
K. Y. Srinivasan5841a822011-08-25 09:48:39 -0700427 return 0;
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700428}
429
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700430/*
431 * vmbus_probe - Add the new vmbus's child device
432 */
433static int vmbus_probe(struct device *child_device)
434{
435 int ret = 0;
436 struct hv_driver *drv =
437 drv_to_hv_drv(child_device->driver);
K. Y. Srinivasan9efd21e2011-04-29 13:45:10 -0700438 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700439 const struct hv_vmbus_device_id *dev_id;
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700440
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700441 dev_id = hv_vmbus_get_id(drv->id_table, dev->dev_type.b);
K. Y. Srinivasan9efd21e2011-04-29 13:45:10 -0700442 if (drv->probe) {
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700443 ret = drv->probe(dev, dev_id);
K. Y. Srinivasanb14a7b32011-04-29 13:45:03 -0700444 if (ret != 0)
Hank Janssen0a466182011-03-29 13:58:47 -0700445 pr_err("probe failed for device %s (%d)\n",
446 dev_name(child_device), ret);
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700447
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700448 } else {
Hank Janssen0a466182011-03-29 13:58:47 -0700449 pr_err("probe not set for driver %s\n",
450 dev_name(child_device));
K. Y. Srinivasan6de925b2011-06-06 15:50:07 -0700451 ret = -ENODEV;
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700452 }
453 return ret;
454}
455
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700456/*
457 * vmbus_remove - Remove a vmbus device
458 */
459static int vmbus_remove(struct device *child_device)
460{
K. Y. Srinivasand4372172011-09-13 10:59:44 -0700461 struct hv_driver *drv = drv_to_hv_drv(child_device->driver);
K. Y. Srinivasan415b0232011-04-29 13:45:12 -0700462 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700463
K. Y. Srinivasand4372172011-09-13 10:59:44 -0700464 if (drv->remove)
465 drv->remove(dev);
466 else
467 pr_err("remove not set for driver %s\n",
468 dev_name(child_device));
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700469
470 return 0;
471}
472
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700473
474/*
475 * vmbus_shutdown - Shutdown a vmbus device
476 */
477static void vmbus_shutdown(struct device *child_device)
478{
479 struct hv_driver *drv;
K. Y. Srinivasanca6887f2011-04-29 13:45:14 -0700480 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700481
482
483 /* The device may not be attached yet */
484 if (!child_device->driver)
485 return;
486
487 drv = drv_to_hv_drv(child_device->driver);
488
K. Y. Srinivasanca6887f2011-04-29 13:45:14 -0700489 if (drv->shutdown)
490 drv->shutdown(dev);
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700491
492 return;
493}
494
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700495
496/*
497 * vmbus_device_release - Final callback release of the vmbus child device
498 */
499static void vmbus_device_release(struct device *device)
500{
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700501 struct hv_device *hv_dev = device_to_hv_device(device);
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700502
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700503 kfree(hv_dev);
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700504
505}
506
Bill Pemberton454f18a2009-07-27 16:47:24 -0400507/* The one and only one */
K. Y. Srinivasan9adcac52011-04-29 13:45:08 -0700508static struct bus_type hv_bus = {
509 .name = "vmbus",
510 .match = vmbus_match,
511 .shutdown = vmbus_shutdown,
512 .remove = vmbus_remove,
513 .probe = vmbus_probe,
514 .uevent = vmbus_uevent,
515 .dev_attrs = vmbus_device_attrs,
Greg Kroah-Hartman03f3a912013-09-13 11:32:49 -0700516 .dev_groups = vmbus_groups,
Hank Janssen3e7ee492009-07-13 16:02:34 -0700517};
518
Haiyang Zhangadf874c2011-01-26 12:12:09 -0800519static const char *driver_name = "hyperv";
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800520
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800521
Timo Teräsbf6506f2010-12-15 20:48:08 +0200522struct onmessage_work_context {
523 struct work_struct work;
524 struct hv_message msg;
525};
526
527static void vmbus_onmessage_work(struct work_struct *work)
528{
529 struct onmessage_work_context *ctx;
530
531 ctx = container_of(work, struct onmessage_work_context,
532 work);
533 vmbus_onmessage(&ctx->msg);
534 kfree(ctx);
535}
536
K. Y. Srinivasan62c10592011-03-10 14:04:53 -0800537static void vmbus_on_msg_dpc(unsigned long data)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800538{
539 int cpu = smp_processor_id();
540 void *page_addr = hv_context.synic_message_page[cpu];
541 struct hv_message *msg = (struct hv_message *)page_addr +
542 VMBUS_MESSAGE_SINT;
Timo Teräsbf6506f2010-12-15 20:48:08 +0200543 struct onmessage_work_context *ctx;
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800544
545 while (1) {
546 if (msg->header.message_type == HVMSG_NONE) {
547 /* no msg */
548 break;
549 } else {
Timo Teräsbf6506f2010-12-15 20:48:08 +0200550 ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
551 if (ctx == NULL)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800552 continue;
Timo Teräsbf6506f2010-12-15 20:48:08 +0200553 INIT_WORK(&ctx->work, vmbus_onmessage_work);
554 memcpy(&ctx->msg, msg, sizeof(*msg));
Haiyang Zhangda9fcb72011-01-26 12:12:14 -0800555 queue_work(vmbus_connection.work_queue, &ctx->work);
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800556 }
557
558 msg->header.message_type = HVMSG_NONE;
559
560 /*
561 * Make sure the write to MessageType (ie set to
562 * HVMSG_NONE) happens before we read the
563 * MessagePending and EOMing. Otherwise, the EOMing
564 * will not deliver any more messages since there is
565 * no empty slot
566 */
Jason Wang35848f62013-06-18 13:04:23 +0800567 mb();
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800568
569 if (msg->header.message_flags.msg_pending) {
570 /*
571 * This will cause message queue rescan to
572 * possibly deliver another msg from the
573 * hypervisor
574 */
575 wrmsrl(HV_X64_MSR_EOM, 0);
576 }
577 }
578}
579
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700580static irqreturn_t vmbus_isr(int irq, void *dev_id)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800581{
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800582 int cpu = smp_processor_id();
583 void *page_addr;
584 struct hv_message *msg;
585 union hv_synic_event_flags *event;
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700586 bool handled = false;
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800587
K. Y. Srinivasan5ab05952012-12-01 06:46:55 -0800588 page_addr = hv_context.synic_event_page[cpu];
589 if (page_addr == NULL)
590 return IRQ_NONE;
591
592 event = (union hv_synic_event_flags *)page_addr +
593 VMBUS_MESSAGE_SINT;
K. Y. Srinivasan7341d902011-08-31 14:35:56 -0700594 /*
595 * Check for events before checking for messages. This is the order
596 * in which events and messages are checked in Windows guests on
597 * Hyper-V, and the Windows team suggested we do the same.
598 */
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800599
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800600 if ((vmbus_proto_version == VERSION_WS2008) ||
601 (vmbus_proto_version == VERSION_WIN7)) {
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800602
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800603 /* Since we are a child, we only need to check bit 0 */
604 if (sync_test_and_clear_bit(0,
605 (unsigned long *) &event->flags32[0])) {
606 handled = true;
607 }
608 } else {
609 /*
610 * Our host is win8 or above. The signaling mechanism
611 * has changed and we can directly look at the event page.
612 * If bit n is set then we have an interrup on the channel
613 * whose id is n.
614 */
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700615 handled = true;
K. Y. Srinivasan793be9c2011-03-15 15:03:43 -0700616 }
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700617
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800618 if (handled)
K. Y. Srinivasandb11f122012-12-01 06:46:53 -0800619 tasklet_schedule(hv_context.event_dpc[cpu]);
K. Y. Srinivasan6552ecd2012-12-01 06:46:49 -0800620
621
K. Y. Srinivasan7341d902011-08-31 14:35:56 -0700622 page_addr = hv_context.synic_message_page[cpu];
623 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
624
625 /* Check if there are actual msgs to be processed */
626 if (msg->header.message_type != HVMSG_NONE) {
627 handled = true;
628 tasklet_schedule(&msg_dpc);
629 }
630
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700631 if (handled)
632 return IRQ_HANDLED;
633 else
634 return IRQ_NONE;
K. Y. Srinivasan793be9c2011-03-15 15:03:43 -0700635}
636
Hank Janssen3e189512010-03-04 22:11:00 +0000637/*
K. Y. Srinivasanb0209502012-12-01 06:46:54 -0800638 * vmbus interrupt flow handler:
639 * vmbus interrupts can concurrently occur on multiple CPUs and
640 * can be handled concurrently.
641 */
642
Fengguang Wu83ebf6e2013-01-18 09:09:32 +0800643static void vmbus_flow_handler(unsigned int irq, struct irq_desc *desc)
K. Y. Srinivasanb0209502012-12-01 06:46:54 -0800644{
645 kstat_incr_irqs_this_cpu(irq, desc);
646
647 desc->action->handler(irq, desc->action->dev_id);
648}
649
650/*
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700651 * vmbus_bus_init -Main vmbus driver initialization routine.
652 *
653 * Here, we
Lars Lindley0686e4f2010-03-11 23:51:23 +0100654 * - initialize the vmbus driver context
Lars Lindley0686e4f2010-03-11 23:51:23 +0100655 * - invoke the vmbus hv main init routine
656 * - get the irq resource
Lars Lindley0686e4f2010-03-11 23:51:23 +0100657 * - retrieve the channel offers
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700658 */
K. Y. Srinivasan9aaa9952011-06-06 15:49:37 -0700659static int vmbus_bus_init(int irq)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700660{
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700661 int ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700662
Greg Kroah-Hartman6d26e38fa22010-12-02 12:08:08 -0800663 /* Hypervisor initialization...setup hypercall page..etc */
664 ret = hv_init();
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700665 if (ret != 0) {
Hank Janssen0a466182011-03-29 13:58:47 -0700666 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700667 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700668 }
669
K. Y. Srinivasan59c0e4f2011-04-29 13:45:06 -0700670 tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700671
K. Y. Srinivasan9adcac52011-04-29 13:45:08 -0700672 ret = bus_register(&hv_bus);
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700673 if (ret)
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700674 goto err_cleanup;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700675
Theodore Ts'o20ed3ef2012-07-17 13:50:30 -0400676 ret = request_irq(irq, vmbus_isr, 0, driver_name, hv_acpi_dev);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700677
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700678 if (ret != 0) {
Hank Janssen0a466182011-03-29 13:58:47 -0700679 pr_err("Unable to request IRQ %d\n",
K. Y. Srinivasan9aaa9952011-06-06 15:49:37 -0700680 irq);
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700681 goto err_unregister;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700682 }
Hank Janssen3e7ee492009-07-13 16:02:34 -0700683
K. Y. Srinivasanb0209502012-12-01 06:46:54 -0800684 /*
685 * Vmbus interrupts can be handled concurrently on
686 * different CPUs. Establish an appropriate interrupt flow
687 * handler that can support this model.
688 */
689 irq_set_handler(irq, vmbus_flow_handler);
690
K. Y. Srinivasan302a3c02013-02-17 11:30:44 -0800691 /*
692 * Register our interrupt handler.
693 */
694 hv_register_vmbus_handler(irq, vmbus_isr);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700695
Jason Wang2608fb62013-06-19 11:28:10 +0800696 ret = hv_synic_alloc();
697 if (ret)
698 goto err_alloc;
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700699 /*
K. Y. Srinivasan302a3c02013-02-17 11:30:44 -0800700 * Initialize the per-cpu interrupt state and
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700701 * connect to the host.
702 */
K. Y. Srinivasan302a3c02013-02-17 11:30:44 -0800703 on_each_cpu(hv_synic_init, NULL, 1);
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700704 ret = vmbus_connect();
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700705 if (ret)
Jason Wang2608fb62013-06-19 11:28:10 +0800706 goto err_alloc;
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700707
Greg Kroah-Hartman2d6e8822010-12-02 08:50:58 -0800708 vmbus_request_offers();
Haiyang Zhang8b5d6d32010-05-28 23:22:44 +0000709
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700710 return 0;
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700711
Jason Wang2608fb62013-06-19 11:28:10 +0800712err_alloc:
713 hv_synic_free();
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700714 free_irq(irq, hv_acpi_dev);
715
716err_unregister:
717 bus_unregister(&hv_bus);
718
719err_cleanup:
720 hv_cleanup();
721
722 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700723}
724
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700725/**
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700726 * __vmbus_child_driver_register - Register a vmbus's driver
727 * @drv: Pointer to driver structure you want to register
728 * @owner: owner module of the drv
729 * @mod_name: module name string
Hank Janssen3e189512010-03-04 22:11:00 +0000730 *
731 * Registers the given driver with Linux through the 'driver_register()' call
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700732 * and sets up the hyper-v vmbus handling for this driver.
Hank Janssen3e189512010-03-04 22:11:00 +0000733 * It will return the state of the 'driver_register()' call.
734 *
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700735 */
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700736int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700737{
Bill Pemberton5d48a1c2009-07-27 16:47:36 -0400738 int ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700739
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700740 pr_info("registering driver %s\n", hv_driver->name);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700741
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -0800742 ret = vmbus_exists();
743 if (ret < 0)
744 return ret;
745
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700746 hv_driver->driver.name = hv_driver->name;
747 hv_driver->driver.owner = owner;
748 hv_driver->driver.mod_name = mod_name;
749 hv_driver->driver.bus = &hv_bus;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700750
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700751 ret = driver_register(&hv_driver->driver);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700752
Bill Pemberton5d48a1c2009-07-27 16:47:36 -0400753 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700754}
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700755EXPORT_SYMBOL_GPL(__vmbus_driver_register);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700756
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700757/**
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700758 * vmbus_driver_unregister() - Unregister a vmbus's driver
759 * @drv: Pointer to driver structure you want to un-register
Hank Janssen3e189512010-03-04 22:11:00 +0000760 *
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700761 * Un-register the given driver that was previous registered with a call to
762 * vmbus_driver_register()
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700763 */
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700764void vmbus_driver_unregister(struct hv_driver *hv_driver)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700765{
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700766 pr_info("unregistering driver %s\n", hv_driver->name);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700767
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -0800768 if (!vmbus_exists())
K. Y. Srinivasan8f257a12011-12-27 13:49:37 -0800769 driver_unregister(&hv_driver->driver);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700770}
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700771EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700772
Hank Janssen3e189512010-03-04 22:11:00 +0000773/*
K. Y. Srinivasanf2c73012011-09-08 07:24:12 -0700774 * vmbus_device_create - Creates and registers a new child device
Hank Janssen3e189512010-03-04 22:11:00 +0000775 * on the vmbus.
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700776 */
K. Y. Srinivasanf2c73012011-09-08 07:24:12 -0700777struct hv_device *vmbus_device_create(uuid_le *type,
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -0700778 uuid_le *instance,
Greg Kroah-Hartman89733aa2010-12-02 08:22:41 -0800779 struct vmbus_channel *channel)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700780{
Nicolas Palix3d3b5512009-07-28 17:32:53 +0200781 struct hv_device *child_device_obj;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700782
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800783 child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
784 if (!child_device_obj) {
Hank Janssen0a466182011-03-29 13:58:47 -0700785 pr_err("Unable to allocate device object for child device\n");
Hank Janssen3e7ee492009-07-13 16:02:34 -0700786 return NULL;
787 }
788
Greg Kroah-Hartmancae5b842010-10-21 09:05:27 -0700789 child_device_obj->channel = channel;
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -0700790 memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
Haiyang Zhangca623ad2011-01-26 12:12:11 -0800791 memcpy(&child_device_obj->dev_instance, instance,
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -0700792 sizeof(uuid_le));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700793
Hank Janssen3e7ee492009-07-13 16:02:34 -0700794
Hank Janssen3e7ee492009-07-13 16:02:34 -0700795 return child_device_obj;
796}
797
Hank Janssen3e189512010-03-04 22:11:00 +0000798/*
K. Y. Srinivasan227942812011-09-08 07:24:13 -0700799 * vmbus_device_register - Register the child device
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700800 */
K. Y. Srinivasan227942812011-09-08 07:24:13 -0700801int vmbus_device_register(struct hv_device *child_device_obj)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700802{
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700803 int ret = 0;
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800804
Bill Pembertonf4888412009-07-29 17:00:12 -0400805 static atomic_t device_num = ATOMIC_INIT(0);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700806
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800807 dev_set_name(&child_device_obj->device, "vmbus_0_%d",
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700808 atomic_inc_return(&device_num));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700809
K. Y. Srinivasan0bce28b2011-08-27 11:31:39 -0700810 child_device_obj->device.bus = &hv_bus;
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -0700811 child_device_obj->device.parent = &hv_acpi_dev->dev;
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800812 child_device_obj->device.release = vmbus_device_release;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700813
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700814 /*
815 * Register with the LDM. This will kick off the driver/device
816 * binding...which will eventually call vmbus_match() and vmbus_probe()
817 */
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800818 ret = device_register(&child_device_obj->device);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700819
Hank Janssen3e7ee492009-07-13 16:02:34 -0700820 if (ret)
Hank Janssen0a466182011-03-29 13:58:47 -0700821 pr_err("Unable to register child device\n");
Hank Janssen3e7ee492009-07-13 16:02:34 -0700822 else
Fernando Soto84672362013-06-14 23:13:35 +0000823 pr_debug("child device %s registered\n",
Hank Janssen0a466182011-03-29 13:58:47 -0700824 dev_name(&child_device_obj->device));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700825
Hank Janssen3e7ee492009-07-13 16:02:34 -0700826 return ret;
827}
828
Hank Janssen3e189512010-03-04 22:11:00 +0000829/*
K. Y. Srinivasan696453b2011-09-08 07:24:14 -0700830 * vmbus_device_unregister - Remove the specified child device
Hank Janssen3e189512010-03-04 22:11:00 +0000831 * from the vmbus.
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700832 */
K. Y. Srinivasan696453b2011-09-08 07:24:14 -0700833void vmbus_device_unregister(struct hv_device *device_obj)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700834{
Fernando Soto84672362013-06-14 23:13:35 +0000835 pr_debug("child device %s unregistered\n",
836 dev_name(&device_obj->device));
837
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700838 /*
839 * Kick off the process of unregistering the device.
840 * This will call vmbus_remove() and eventually vmbus_device_release()
841 */
K. Y. Srinivasan6bad88da2011-03-07 13:35:48 -0800842 device_unregister(&device_obj->device);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700843}
844
Hank Janssen3e7ee492009-07-13 16:02:34 -0700845
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700846/*
847 * VMBUS is an acpi enumerated device. Get the the IRQ information
848 * from DSDT.
849 */
850
851static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *irq)
852{
853
854 if (res->type == ACPI_RESOURCE_TYPE_IRQ) {
855 struct acpi_resource_irq *irqp;
856 irqp = &res->data.irq;
857
858 *((unsigned int *)irq) = irqp->interrupts[0];
859 }
860
861 return AE_OK;
862}
863
864static int vmbus_acpi_add(struct acpi_device *device)
865{
866 acpi_status result;
867
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -0700868 hv_acpi_dev = device;
869
K. Y. Srinivasan0a4425b2011-08-27 11:31:38 -0700870 result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
871 vmbus_walk_resources, &irq);
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700872
873 if (ACPI_FAILURE(result)) {
874 complete(&probe_event);
875 return -ENODEV;
876 }
877 complete(&probe_event);
878 return 0;
879}
880
881static const struct acpi_device_id vmbus_acpi_device_ids[] = {
882 {"VMBUS", 0},
K. Y. Srinivasan9d7b18d2011-06-06 15:49:42 -0700883 {"VMBus", 0},
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700884 {"", 0},
885};
886MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
887
888static struct acpi_driver vmbus_acpi_driver = {
889 .name = "vmbus",
890 .ids = vmbus_acpi_device_ids,
891 .ops = {
892 .add = vmbus_acpi_add,
893 },
894};
895
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -0700896static int __init hv_acpi_init(void)
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -0700897{
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -0700898 int ret, t;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700899
Jason Wang1f94ea82012-08-31 13:32:44 +0800900 if (x86_hyper != &x86_hyper_ms_hyperv)
Jason Wang05929692012-08-17 18:52:43 +0800901 return -ENODEV;
902
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700903 init_completion(&probe_event);
904
905 /*
906 * Get irq resources first.
907 */
908
K. Y. Srinivasan02466042011-06-06 15:49:40 -0700909 ret = acpi_bus_register_driver(&vmbus_acpi_driver);
910
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700911 if (ret)
912 return ret;
913
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -0700914 t = wait_for_completion_timeout(&probe_event, 5*HZ);
915 if (t == 0) {
916 ret = -ETIMEDOUT;
917 goto cleanup;
918 }
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700919
920 if (irq <= 0) {
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -0700921 ret = -ENODEV;
922 goto cleanup;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700923 }
924
K. Y. Srinivasan91fd7992011-06-16 13:16:38 -0700925 ret = vmbus_bus_init(irq);
926 if (ret)
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -0700927 goto cleanup;
928
929 return 0;
930
931cleanup:
932 acpi_bus_unregister_driver(&vmbus_acpi_driver);
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -0800933 hv_acpi_dev = NULL;
K. Y. Srinivasan91fd7992011-06-16 13:16:38 -0700934 return ret;
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -0700935}
936
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -0800937static void __exit vmbus_exit(void)
938{
939
940 free_irq(irq, hv_acpi_dev);
941 vmbus_free_channels();
942 bus_unregister(&hv_bus);
943 hv_cleanup();
944 acpi_bus_unregister_driver(&vmbus_acpi_driver);
945}
946
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -0700947
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700948MODULE_LICENSE("GPL");
Hank Janssen3e7ee492009-07-13 16:02:34 -0700949
K. Y. Srinivasan43d4e112011-10-24 11:28:12 -0700950subsys_initcall(hv_acpi_init);
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -0800951module_exit(vmbus_exit);