blob: a220e5746d67df8922f7421b2ee0b174d6ae949b [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>
Greg Kroah-Hartman407dd162011-10-11 08:36:44 -060036#include <asm/hyperv.h>
K. Y. Srinivasan0f2a6612011-05-12 19:34:28 -070037#include "hyperv_vmbus.h"
Hank Janssen3e7ee492009-07-13 16:02:34 -070038
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. Srinivasan66d92292011-04-29 13:45:07 -070043static struct tasklet_struct event_dpc;
K. Y. Srinivasan71a66552011-04-29 13:45:04 -070044static struct completion probe_event;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -070045static int irq;
Hank Janssen3e7ee492009-07-13 16:02:34 -070046
Greg Kroah-Hartman15b80d62011-10-11 09:43:14 -060047struct hv_device_info {
48 u32 chn_id;
49 u32 chn_state;
50 uuid_le chn_type;
51 uuid_le chn_instance;
52
53 u32 monitor_id;
54 u32 server_monitor_pending;
55 u32 server_monitor_latency;
56 u32 server_monitor_conn_id;
57 u32 client_monitor_pending;
58 u32 client_monitor_latency;
59 u32 client_monitor_conn_id;
60
61 struct hv_dev_port_info inbound;
62 struct hv_dev_port_info outbound;
63};
64
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -080065static int vmbus_exists(void)
66{
67 if (hv_acpi_dev == NULL)
68 return -ENODEV;
69
70 return 0;
71}
72
Greg Kroah-Hartman15b80d62011-10-11 09:43:14 -060073
K. Y. Srinivasan98db4332011-03-15 15:03:44 -070074static void get_channel_info(struct hv_device *device,
75 struct hv_device_info *info)
76{
77 struct vmbus_channel_debug_info debug_info;
78
79 if (!device->channel)
80 return;
81
82 vmbus_get_debug_info(device->channel, &debug_info);
83
84 info->chn_id = debug_info.relid;
85 info->chn_state = debug_info.state;
86 memcpy(&info->chn_type, &debug_info.interfacetype,
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -070087 sizeof(uuid_le));
K. Y. Srinivasan98db4332011-03-15 15:03:44 -070088 memcpy(&info->chn_instance, &debug_info.interface_instance,
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -070089 sizeof(uuid_le));
K. Y. Srinivasan98db4332011-03-15 15:03:44 -070090
91 info->monitor_id = debug_info.monitorid;
92
93 info->server_monitor_pending = debug_info.servermonitor_pending;
94 info->server_monitor_latency = debug_info.servermonitor_latency;
95 info->server_monitor_conn_id = debug_info.servermonitor_connectionid;
96
97 info->client_monitor_pending = debug_info.clientmonitor_pending;
98 info->client_monitor_latency = debug_info.clientmonitor_latency;
99 info->client_monitor_conn_id = debug_info.clientmonitor_connectionid;
100
101 info->inbound.int_mask = debug_info.inbound.current_interrupt_mask;
102 info->inbound.read_idx = debug_info.inbound.current_read_index;
103 info->inbound.write_idx = debug_info.inbound.current_write_index;
104 info->inbound.bytes_avail_toread =
105 debug_info.inbound.bytes_avail_toread;
106 info->inbound.bytes_avail_towrite =
107 debug_info.inbound.bytes_avail_towrite;
108
109 info->outbound.int_mask =
110 debug_info.outbound.current_interrupt_mask;
111 info->outbound.read_idx = debug_info.outbound.current_read_index;
112 info->outbound.write_idx = debug_info.outbound.current_write_index;
113 info->outbound.bytes_avail_toread =
114 debug_info.outbound.bytes_avail_toread;
115 info->outbound.bytes_avail_towrite =
116 debug_info.outbound.bytes_avail_towrite;
117}
118
Olaf Heringfd776ba2011-09-02 18:25:56 +0200119#define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
120static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
121{
122 int i;
123 for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
124 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
125}
126
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700127/*
128 * vmbus_show_device_attr - Show the device attribute in sysfs.
129 *
130 * This is invoked when user does a
131 * "cat /sys/bus/vmbus/devices/<busdevice>/<attr name>"
132 */
133static ssize_t vmbus_show_device_attr(struct device *dev,
134 struct device_attribute *dev_attr,
135 char *buf)
136{
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700137 struct hv_device *hv_dev = device_to_hv_device(dev);
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700138 struct hv_device_info *device_info;
Olaf Heringfd776ba2011-09-02 18:25:56 +0200139 char alias_name[VMBUS_ALIAS_LEN + 1];
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700140 int ret = 0;
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700141
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700142 device_info = kzalloc(sizeof(struct hv_device_info), GFP_KERNEL);
143 if (!device_info)
144 return ret;
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700145
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700146 get_channel_info(hv_dev, device_info);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700147
148 if (!strcmp(dev_attr->attr.name, "class_id")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700149 ret = sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-"
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700150 "%02x%02x%02x%02x%02x%02x%02x%02x}\n",
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700151 device_info->chn_type.b[3],
152 device_info->chn_type.b[2],
153 device_info->chn_type.b[1],
154 device_info->chn_type.b[0],
155 device_info->chn_type.b[5],
156 device_info->chn_type.b[4],
157 device_info->chn_type.b[7],
158 device_info->chn_type.b[6],
159 device_info->chn_type.b[8],
160 device_info->chn_type.b[9],
161 device_info->chn_type.b[10],
162 device_info->chn_type.b[11],
163 device_info->chn_type.b[12],
164 device_info->chn_type.b[13],
165 device_info->chn_type.b[14],
166 device_info->chn_type.b[15]);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700167 } else if (!strcmp(dev_attr->attr.name, "device_id")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700168 ret = sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-"
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700169 "%02x%02x%02x%02x%02x%02x%02x%02x}\n",
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700170 device_info->chn_instance.b[3],
171 device_info->chn_instance.b[2],
172 device_info->chn_instance.b[1],
173 device_info->chn_instance.b[0],
174 device_info->chn_instance.b[5],
175 device_info->chn_instance.b[4],
176 device_info->chn_instance.b[7],
177 device_info->chn_instance.b[6],
178 device_info->chn_instance.b[8],
179 device_info->chn_instance.b[9],
180 device_info->chn_instance.b[10],
181 device_info->chn_instance.b[11],
182 device_info->chn_instance.b[12],
183 device_info->chn_instance.b[13],
184 device_info->chn_instance.b[14],
185 device_info->chn_instance.b[15]);
Olaf Heringfd776ba2011-09-02 18:25:56 +0200186 } else if (!strcmp(dev_attr->attr.name, "modalias")) {
187 print_alias_name(hv_dev, alias_name);
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700188 ret = sprintf(buf, "vmbus:%s\n", alias_name);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700189 } else if (!strcmp(dev_attr->attr.name, "state")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700190 ret = sprintf(buf, "%d\n", device_info->chn_state);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700191 } else if (!strcmp(dev_attr->attr.name, "id")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700192 ret = sprintf(buf, "%d\n", device_info->chn_id);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700193 } else if (!strcmp(dev_attr->attr.name, "out_intr_mask")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700194 ret = sprintf(buf, "%d\n", device_info->outbound.int_mask);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700195 } else if (!strcmp(dev_attr->attr.name, "out_read_index")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700196 ret = sprintf(buf, "%d\n", device_info->outbound.read_idx);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700197 } else if (!strcmp(dev_attr->attr.name, "out_write_index")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700198 ret = sprintf(buf, "%d\n", device_info->outbound.write_idx);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700199 } else if (!strcmp(dev_attr->attr.name, "out_read_bytes_avail")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700200 ret = sprintf(buf, "%d\n",
201 device_info->outbound.bytes_avail_toread);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700202 } else if (!strcmp(dev_attr->attr.name, "out_write_bytes_avail")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700203 ret = sprintf(buf, "%d\n",
204 device_info->outbound.bytes_avail_towrite);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700205 } else if (!strcmp(dev_attr->attr.name, "in_intr_mask")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700206 ret = sprintf(buf, "%d\n", device_info->inbound.int_mask);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700207 } else if (!strcmp(dev_attr->attr.name, "in_read_index")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700208 ret = sprintf(buf, "%d\n", device_info->inbound.read_idx);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700209 } else if (!strcmp(dev_attr->attr.name, "in_write_index")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700210 ret = sprintf(buf, "%d\n", device_info->inbound.write_idx);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700211 } else if (!strcmp(dev_attr->attr.name, "in_read_bytes_avail")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700212 ret = sprintf(buf, "%d\n",
213 device_info->inbound.bytes_avail_toread);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700214 } else if (!strcmp(dev_attr->attr.name, "in_write_bytes_avail")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700215 ret = sprintf(buf, "%d\n",
216 device_info->inbound.bytes_avail_towrite);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700217 } else if (!strcmp(dev_attr->attr.name, "monitor_id")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700218 ret = sprintf(buf, "%d\n", device_info->monitor_id);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700219 } else if (!strcmp(dev_attr->attr.name, "server_monitor_pending")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700220 ret = sprintf(buf, "%d\n", device_info->server_monitor_pending);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700221 } else if (!strcmp(dev_attr->attr.name, "server_monitor_latency")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700222 ret = sprintf(buf, "%d\n", device_info->server_monitor_latency);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700223 } else if (!strcmp(dev_attr->attr.name, "server_monitor_conn_id")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700224 ret = sprintf(buf, "%d\n",
225 device_info->server_monitor_conn_id);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700226 } else if (!strcmp(dev_attr->attr.name, "client_monitor_pending")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700227 ret = sprintf(buf, "%d\n", device_info->client_monitor_pending);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700228 } else if (!strcmp(dev_attr->attr.name, "client_monitor_latency")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700229 ret = sprintf(buf, "%d\n", device_info->client_monitor_latency);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700230 } else if (!strcmp(dev_attr->attr.name, "client_monitor_conn_id")) {
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700231 ret = sprintf(buf, "%d\n",
232 device_info->client_monitor_conn_id);
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700233 }
K. Y. Srinivasan7bb52382011-09-13 10:59:52 -0700234
235 kfree(device_info);
236 return ret;
K. Y. Srinivasan98db4332011-03-15 15:03:44 -0700237}
238
Bill Pemberton454f18a2009-07-27 16:47:24 -0400239/* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
Hank Janssen3e7ee492009-07-13 16:02:34 -0700240static struct device_attribute vmbus_device_attrs[] = {
241 __ATTR(id, S_IRUGO, vmbus_show_device_attr, NULL),
242 __ATTR(state, S_IRUGO, vmbus_show_device_attr, NULL),
243 __ATTR(class_id, S_IRUGO, vmbus_show_device_attr, NULL),
244 __ATTR(device_id, S_IRUGO, vmbus_show_device_attr, NULL),
245 __ATTR(monitor_id, S_IRUGO, vmbus_show_device_attr, NULL),
Olaf Heringfd776ba2011-09-02 18:25:56 +0200246 __ATTR(modalias, S_IRUGO, vmbus_show_device_attr, NULL),
Hank Janssen3e7ee492009-07-13 16:02:34 -0700247
248 __ATTR(server_monitor_pending, S_IRUGO, vmbus_show_device_attr, NULL),
249 __ATTR(server_monitor_latency, S_IRUGO, vmbus_show_device_attr, NULL),
250 __ATTR(server_monitor_conn_id, S_IRUGO, vmbus_show_device_attr, NULL),
251
252 __ATTR(client_monitor_pending, S_IRUGO, vmbus_show_device_attr, NULL),
253 __ATTR(client_monitor_latency, S_IRUGO, vmbus_show_device_attr, NULL),
254 __ATTR(client_monitor_conn_id, S_IRUGO, vmbus_show_device_attr, NULL),
255
256 __ATTR(out_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL),
257 __ATTR(out_read_index, S_IRUGO, vmbus_show_device_attr, NULL),
258 __ATTR(out_write_index, S_IRUGO, vmbus_show_device_attr, NULL),
259 __ATTR(out_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
260 __ATTR(out_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
261
262 __ATTR(in_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL),
263 __ATTR(in_read_index, S_IRUGO, vmbus_show_device_attr, NULL),
264 __ATTR(in_write_index, S_IRUGO, vmbus_show_device_attr, NULL),
265 __ATTR(in_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
266 __ATTR(in_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
267 __ATTR_NULL
268};
Hank Janssen3e7ee492009-07-13 16:02:34 -0700269
K. Y. Srinivasan793be9c2011-03-15 15:03:43 -0700270
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700271/*
272 * vmbus_uevent - add uevent for our device
273 *
274 * This routine is invoked when a device is added or removed on the vmbus to
275 * generate a uevent to udev in the userspace. The udev will then look at its
276 * rule and the uevent generated here to load the appropriate driver
K. Y. Srinivasan0ddda662011-08-25 09:48:38 -0700277 *
278 * The alias string will be of the form vmbus:guid where guid is the string
279 * representation of the device guid (each byte of the guid will be
280 * represented with two hex characters.
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700281 */
282static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
283{
284 struct hv_device *dev = device_to_hv_device(device);
Olaf Heringfd776ba2011-09-02 18:25:56 +0200285 int ret;
286 char alias_name[VMBUS_ALIAS_LEN + 1];
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700287
Olaf Heringfd776ba2011-09-02 18:25:56 +0200288 print_alias_name(dev, alias_name);
K. Y. Srinivasan0ddda662011-08-25 09:48:38 -0700289 ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
290 return ret;
K. Y. Srinivasanadde2482011-03-15 15:03:37 -0700291}
292
K. Y. Srinivasan5841a822011-08-25 09:48:39 -0700293static uuid_le null_guid;
294
295static inline bool is_null_guid(const __u8 *guid)
296{
297 if (memcmp(guid, &null_guid, sizeof(uuid_le)))
298 return false;
299 return true;
300}
301
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700302/*
303 * Return a matching hv_vmbus_device_id pointer.
304 * If there is no match, return NULL.
305 */
306static const struct hv_vmbus_device_id *hv_vmbus_get_id(
307 const struct hv_vmbus_device_id *id,
308 __u8 *guid)
309{
310 for (; !is_null_guid(id->guid); id++)
311 if (!memcmp(&id->guid, guid, sizeof(uuid_le)))
312 return id;
313
314 return NULL;
315}
316
317
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700318
319/*
320 * vmbus_match - Attempt to match the specified device to the specified driver
321 */
322static int vmbus_match(struct device *device, struct device_driver *driver)
323{
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700324 struct hv_driver *drv = drv_to_hv_drv(driver);
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700325 struct hv_device *hv_dev = device_to_hv_device(device);
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700326
K. Y. Srinivasan3037a7b2011-09-13 10:59:37 -0700327 if (hv_vmbus_get_id(drv->id_table, hv_dev->dev_type.b))
328 return 1;
K. Y. Srinivasande632a22011-04-26 09:20:24 -0700329
K. Y. Srinivasan5841a822011-08-25 09:48:39 -0700330 return 0;
K. Y. Srinivasanb7fc1472011-03-15 15:03:38 -0700331}
332
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700333/*
334 * vmbus_probe - Add the new vmbus's child device
335 */
336static int vmbus_probe(struct device *child_device)
337{
338 int ret = 0;
339 struct hv_driver *drv =
340 drv_to_hv_drv(child_device->driver);
K. Y. Srinivasan9efd21e2011-04-29 13:45:10 -0700341 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700342 const struct hv_vmbus_device_id *dev_id;
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700343
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700344 dev_id = hv_vmbus_get_id(drv->id_table, dev->dev_type.b);
K. Y. Srinivasan9efd21e2011-04-29 13:45:10 -0700345 if (drv->probe) {
K. Y. Srinivasan84946892011-09-13 10:59:38 -0700346 ret = drv->probe(dev, dev_id);
K. Y. Srinivasanb14a7b32011-04-29 13:45:03 -0700347 if (ret != 0)
Hank Janssen0a466182011-03-29 13:58:47 -0700348 pr_err("probe failed for device %s (%d)\n",
349 dev_name(child_device), ret);
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700350
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700351 } else {
Hank Janssen0a466182011-03-29 13:58:47 -0700352 pr_err("probe not set for driver %s\n",
353 dev_name(child_device));
K. Y. Srinivasan6de925b2011-06-06 15:50:07 -0700354 ret = -ENODEV;
K. Y. Srinivasanf1f0d672011-03-15 15:03:39 -0700355 }
356 return ret;
357}
358
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700359/*
360 * vmbus_remove - Remove a vmbus device
361 */
362static int vmbus_remove(struct device *child_device)
363{
K. Y. Srinivasand4372172011-09-13 10:59:44 -0700364 struct hv_driver *drv = drv_to_hv_drv(child_device->driver);
K. Y. Srinivasan415b0232011-04-29 13:45:12 -0700365 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700366
K. Y. Srinivasand4372172011-09-13 10:59:44 -0700367 if (drv->remove)
368 drv->remove(dev);
369 else
370 pr_err("remove not set for driver %s\n",
371 dev_name(child_device));
K. Y. Srinivasanc5dce3d2011-03-15 15:03:40 -0700372
373 return 0;
374}
375
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700376
377/*
378 * vmbus_shutdown - Shutdown a vmbus device
379 */
380static void vmbus_shutdown(struct device *child_device)
381{
382 struct hv_driver *drv;
K. Y. Srinivasanca6887f2011-04-29 13:45:14 -0700383 struct hv_device *dev = device_to_hv_device(child_device);
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700384
385
386 /* The device may not be attached yet */
387 if (!child_device->driver)
388 return;
389
390 drv = drv_to_hv_drv(child_device->driver);
391
K. Y. Srinivasanca6887f2011-04-29 13:45:14 -0700392 if (drv->shutdown)
393 drv->shutdown(dev);
K. Y. Srinivasaneb1bb252011-03-15 15:03:41 -0700394
395 return;
396}
397
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700398
399/*
400 * vmbus_device_release - Final callback release of the vmbus child device
401 */
402static void vmbus_device_release(struct device *device)
403{
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700404 struct hv_device *hv_dev = device_to_hv_device(device);
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700405
K. Y. Srinivasane8e27042011-06-06 15:50:04 -0700406 kfree(hv_dev);
K. Y. Srinivasan086e7a52011-03-15 15:03:42 -0700407
408}
409
Bill Pemberton454f18a2009-07-27 16:47:24 -0400410/* The one and only one */
K. Y. Srinivasan9adcac52011-04-29 13:45:08 -0700411static struct bus_type hv_bus = {
412 .name = "vmbus",
413 .match = vmbus_match,
414 .shutdown = vmbus_shutdown,
415 .remove = vmbus_remove,
416 .probe = vmbus_probe,
417 .uevent = vmbus_uevent,
418 .dev_attrs = vmbus_device_attrs,
Hank Janssen3e7ee492009-07-13 16:02:34 -0700419};
420
Haiyang Zhangadf874c2011-01-26 12:12:09 -0800421static const char *driver_name = "hyperv";
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800422
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800423
Timo Teräsbf6506f2010-12-15 20:48:08 +0200424struct onmessage_work_context {
425 struct work_struct work;
426 struct hv_message msg;
427};
428
429static void vmbus_onmessage_work(struct work_struct *work)
430{
431 struct onmessage_work_context *ctx;
432
433 ctx = container_of(work, struct onmessage_work_context,
434 work);
435 vmbus_onmessage(&ctx->msg);
436 kfree(ctx);
437}
438
K. Y. Srinivasan62c10592011-03-10 14:04:53 -0800439static void vmbus_on_msg_dpc(unsigned long data)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800440{
441 int cpu = smp_processor_id();
442 void *page_addr = hv_context.synic_message_page[cpu];
443 struct hv_message *msg = (struct hv_message *)page_addr +
444 VMBUS_MESSAGE_SINT;
Timo Teräsbf6506f2010-12-15 20:48:08 +0200445 struct onmessage_work_context *ctx;
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800446
447 while (1) {
448 if (msg->header.message_type == HVMSG_NONE) {
449 /* no msg */
450 break;
451 } else {
Timo Teräsbf6506f2010-12-15 20:48:08 +0200452 ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
453 if (ctx == NULL)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800454 continue;
Timo Teräsbf6506f2010-12-15 20:48:08 +0200455 INIT_WORK(&ctx->work, vmbus_onmessage_work);
456 memcpy(&ctx->msg, msg, sizeof(*msg));
Haiyang Zhangda9fcb72011-01-26 12:12:14 -0800457 queue_work(vmbus_connection.work_queue, &ctx->work);
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800458 }
459
460 msg->header.message_type = HVMSG_NONE;
461
462 /*
463 * Make sure the write to MessageType (ie set to
464 * HVMSG_NONE) happens before we read the
465 * MessagePending and EOMing. Otherwise, the EOMing
466 * will not deliver any more messages since there is
467 * no empty slot
468 */
K. Y. Srinivasane826f1d2011-06-06 15:50:03 -0700469 smp_mb();
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800470
471 if (msg->header.message_flags.msg_pending) {
472 /*
473 * This will cause message queue rescan to
474 * possibly deliver another msg from the
475 * hypervisor
476 */
477 wrmsrl(HV_X64_MSR_EOM, 0);
478 }
479 }
480}
481
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700482static irqreturn_t vmbus_isr(int irq, void *dev_id)
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800483{
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800484 int cpu = smp_processor_id();
485 void *page_addr;
486 struct hv_message *msg;
487 union hv_synic_event_flags *event;
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700488 bool handled = false;
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800489
K. Y. Srinivasan7341d902011-08-31 14:35:56 -0700490 /*
491 * Check for events before checking for messages. This is the order
492 * in which events and messages are checked in Windows guests on
493 * Hyper-V, and the Windows team suggested we do the same.
494 */
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800495
Greg Kroah-Hartman36199a92010-12-02 11:59:22 -0800496 page_addr = hv_context.synic_event_page[cpu];
497 event = (union hv_synic_event_flags *)page_addr + VMBUS_MESSAGE_SINT;
498
499 /* Since we are a child, we only need to check bit 0 */
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700500 if (sync_test_and_clear_bit(0, (unsigned long *) &event->flags32[0])) {
501 handled = true;
502 tasklet_schedule(&event_dpc);
K. Y. Srinivasan793be9c2011-03-15 15:03:43 -0700503 }
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700504
K. Y. Srinivasan7341d902011-08-31 14:35:56 -0700505 page_addr = hv_context.synic_message_page[cpu];
506 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
507
508 /* Check if there are actual msgs to be processed */
509 if (msg->header.message_type != HVMSG_NONE) {
510 handled = true;
511 tasklet_schedule(&msg_dpc);
512 }
513
K. Y. Srinivasanae4636e2011-08-27 11:31:35 -0700514 if (handled)
515 return IRQ_HANDLED;
516 else
517 return IRQ_NONE;
K. Y. Srinivasan793be9c2011-03-15 15:03:43 -0700518}
519
Hank Janssen3e189512010-03-04 22:11:00 +0000520/*
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700521 * vmbus_bus_init -Main vmbus driver initialization routine.
522 *
523 * Here, we
Lars Lindley0686e4f2010-03-11 23:51:23 +0100524 * - initialize the vmbus driver context
Lars Lindley0686e4f2010-03-11 23:51:23 +0100525 * - invoke the vmbus hv main init routine
526 * - get the irq resource
Lars Lindley0686e4f2010-03-11 23:51:23 +0100527 * - retrieve the channel offers
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700528 */
K. Y. Srinivasan9aaa9952011-06-06 15:49:37 -0700529static int vmbus_bus_init(int irq)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700530{
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700531 int ret;
532 unsigned int vector;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700533
Greg Kroah-Hartman6d26e382010-12-02 12:08:08 -0800534 /* Hypervisor initialization...setup hypercall page..etc */
535 ret = hv_init();
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700536 if (ret != 0) {
Hank Janssen0a466182011-03-29 13:58:47 -0700537 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700538 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700539 }
540
K. Y. Srinivasan59c0e4f2011-04-29 13:45:06 -0700541 tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0);
K. Y. Srinivasan66d92292011-04-29 13:45:07 -0700542 tasklet_init(&event_dpc, vmbus_on_event, 0);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700543
K. Y. Srinivasan9adcac52011-04-29 13:45:08 -0700544 ret = bus_register(&hv_bus);
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700545 if (ret)
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700546 goto err_cleanup;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700547
K. Y. Srinivasan3d2de262011-06-06 15:49:38 -0700548 ret = request_irq(irq, vmbus_isr, IRQF_SAMPLE_RANDOM,
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -0700549 driver_name, hv_acpi_dev);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700550
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700551 if (ret != 0) {
Hank Janssen0a466182011-03-29 13:58:47 -0700552 pr_err("Unable to request IRQ %d\n",
K. Y. Srinivasan9aaa9952011-06-06 15:49:37 -0700553 irq);
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700554 goto err_unregister;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700555 }
Hank Janssen3e7ee492009-07-13 16:02:34 -0700556
K. Y. Srinivasan9aaa9952011-06-06 15:49:37 -0700557 vector = IRQ0_VECTOR + irq;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700558
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700559 /*
560 * Notify the hypervisor of our irq and
561 * connect to the host.
562 */
563 on_each_cpu(hv_synic_init, (void *)&vector, 1);
564 ret = vmbus_connect();
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700565 if (ret)
566 goto err_irq;
K. Y. Srinivasan800b6902011-03-15 15:03:33 -0700567
Greg Kroah-Hartman2d6e8822010-12-02 08:50:58 -0800568 vmbus_request_offers();
Haiyang Zhang8b5d6d32010-05-28 23:22:44 +0000569
K. Y. Srinivasand6c1c5d2011-06-06 15:50:08 -0700570 return 0;
K. Y. Srinivasan8b9987e2011-08-31 14:35:55 -0700571
572err_irq:
573 free_irq(irq, hv_acpi_dev);
574
575err_unregister:
576 bus_unregister(&hv_bus);
577
578err_cleanup:
579 hv_cleanup();
580
581 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700582}
583
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700584/**
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700585 * __vmbus_child_driver_register - Register a vmbus's driver
586 * @drv: Pointer to driver structure you want to register
587 * @owner: owner module of the drv
588 * @mod_name: module name string
Hank Janssen3e189512010-03-04 22:11:00 +0000589 *
590 * Registers the given driver with Linux through the 'driver_register()' call
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700591 * and sets up the hyper-v vmbus handling for this driver.
Hank Janssen3e189512010-03-04 22:11:00 +0000592 * It will return the state of the 'driver_register()' call.
593 *
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700594 */
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700595int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700596{
Bill Pemberton5d48a1c2009-07-27 16:47:36 -0400597 int ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700598
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700599 pr_info("registering driver %s\n", hv_driver->name);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700600
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -0800601 ret = vmbus_exists();
602 if (ret < 0)
603 return ret;
604
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700605 hv_driver->driver.name = hv_driver->name;
606 hv_driver->driver.owner = owner;
607 hv_driver->driver.mod_name = mod_name;
608 hv_driver->driver.bus = &hv_bus;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700609
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700610 ret = driver_register(&hv_driver->driver);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700611
Greg Kroah-Hartman2d6e8822010-12-02 08:50:58 -0800612 vmbus_request_offers();
Hank Janssen3e7ee492009-07-13 16:02:34 -0700613
Bill Pemberton5d48a1c2009-07-27 16:47:36 -0400614 return ret;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700615}
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700616EXPORT_SYMBOL_GPL(__vmbus_driver_register);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700617
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700618/**
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700619 * vmbus_driver_unregister() - Unregister a vmbus's driver
620 * @drv: Pointer to driver structure you want to un-register
Hank Janssen3e189512010-03-04 22:11:00 +0000621 *
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700622 * Un-register the given driver that was previous registered with a call to
623 * vmbus_driver_register()
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700624 */
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700625void vmbus_driver_unregister(struct hv_driver *hv_driver)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700626{
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700627 pr_info("unregistering driver %s\n", hv_driver->name);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700628
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -0800629 if (!vmbus_exists())
K. Y. Srinivasan8f257a12011-12-27 13:49:37 -0800630 driver_unregister(&hv_driver->driver);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700631}
Greg Kroah-Hartman768fa212011-08-25 15:07:32 -0700632EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700633
Hank Janssen3e189512010-03-04 22:11:00 +0000634/*
K. Y. Srinivasanf2c73012011-09-08 07:24:12 -0700635 * vmbus_device_create - Creates and registers a new child device
Hank Janssen3e189512010-03-04 22:11:00 +0000636 * on the vmbus.
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700637 */
K. Y. Srinivasanf2c73012011-09-08 07:24:12 -0700638struct hv_device *vmbus_device_create(uuid_le *type,
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -0700639 uuid_le *instance,
Greg Kroah-Hartman89733aa2010-12-02 08:22:41 -0800640 struct vmbus_channel *channel)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700641{
Nicolas Palix3d3b5512009-07-28 17:32:53 +0200642 struct hv_device *child_device_obj;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700643
K. Y. Srinivasan6bad88d2011-03-07 13:35:48 -0800644 child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
645 if (!child_device_obj) {
Hank Janssen0a466182011-03-29 13:58:47 -0700646 pr_err("Unable to allocate device object for child device\n");
Hank Janssen3e7ee492009-07-13 16:02:34 -0700647 return NULL;
648 }
649
Greg Kroah-Hartmancae5b842010-10-21 09:05:27 -0700650 child_device_obj->channel = channel;
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -0700651 memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
Haiyang Zhangca623ad2011-01-26 12:12:11 -0800652 memcpy(&child_device_obj->dev_instance, instance,
K. Y. Srinivasan358d2ee2011-08-25 09:48:28 -0700653 sizeof(uuid_le));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700654
Hank Janssen3e7ee492009-07-13 16:02:34 -0700655
Hank Janssen3e7ee492009-07-13 16:02:34 -0700656 return child_device_obj;
657}
658
Hank Janssen3e189512010-03-04 22:11:00 +0000659/*
K. Y. Srinivasan22794282011-09-08 07:24:13 -0700660 * vmbus_device_register - Register the child device
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700661 */
K. Y. Srinivasan22794282011-09-08 07:24:13 -0700662int vmbus_device_register(struct hv_device *child_device_obj)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700663{
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700664 int ret = 0;
K. Y. Srinivasan6bad88d2011-03-07 13:35:48 -0800665
Bill Pembertonf4888412009-07-29 17:00:12 -0400666 static atomic_t device_num = ATOMIC_INIT(0);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700667
K. Y. Srinivasan6bad88d2011-03-07 13:35:48 -0800668 dev_set_name(&child_device_obj->device, "vmbus_0_%d",
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700669 atomic_inc_return(&device_num));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700670
K. Y. Srinivasan0bce28b2011-08-27 11:31:39 -0700671 child_device_obj->device.bus = &hv_bus;
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -0700672 child_device_obj->device.parent = &hv_acpi_dev->dev;
K. Y. Srinivasan6bad88d2011-03-07 13:35:48 -0800673 child_device_obj->device.release = vmbus_device_release;
Hank Janssen3e7ee492009-07-13 16:02:34 -0700674
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700675 /*
676 * Register with the LDM. This will kick off the driver/device
677 * binding...which will eventually call vmbus_match() and vmbus_probe()
678 */
K. Y. Srinivasan6bad88d2011-03-07 13:35:48 -0800679 ret = device_register(&child_device_obj->device);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700680
Hank Janssen3e7ee492009-07-13 16:02:34 -0700681 if (ret)
Hank Janssen0a466182011-03-29 13:58:47 -0700682 pr_err("Unable to register child device\n");
Hank Janssen3e7ee492009-07-13 16:02:34 -0700683 else
Hank Janssen0a466182011-03-29 13:58:47 -0700684 pr_info("child device %s registered\n",
685 dev_name(&child_device_obj->device));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700686
Hank Janssen3e7ee492009-07-13 16:02:34 -0700687 return ret;
688}
689
Hank Janssen3e189512010-03-04 22:11:00 +0000690/*
K. Y. Srinivasan696453b2011-09-08 07:24:14 -0700691 * vmbus_device_unregister - Remove the specified child device
Hank Janssen3e189512010-03-04 22:11:00 +0000692 * from the vmbus.
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700693 */
K. Y. Srinivasan696453b2011-09-08 07:24:14 -0700694void vmbus_device_unregister(struct hv_device *device_obj)
Hank Janssen3e7ee492009-07-13 16:02:34 -0700695{
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700696 /*
697 * Kick off the process of unregistering the device.
698 * This will call vmbus_remove() and eventually vmbus_device_release()
699 */
K. Y. Srinivasan6bad88d2011-03-07 13:35:48 -0800700 device_unregister(&device_obj->device);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700701
Hank Janssen0a466182011-03-29 13:58:47 -0700702 pr_info("child device %s unregistered\n",
703 dev_name(&device_obj->device));
Hank Janssen3e7ee492009-07-13 16:02:34 -0700704}
705
Hank Janssen3e7ee492009-07-13 16:02:34 -0700706
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700707/*
708 * VMBUS is an acpi enumerated device. Get the the IRQ information
709 * from DSDT.
710 */
711
712static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *irq)
713{
714
715 if (res->type == ACPI_RESOURCE_TYPE_IRQ) {
716 struct acpi_resource_irq *irqp;
717 irqp = &res->data.irq;
718
719 *((unsigned int *)irq) = irqp->interrupts[0];
720 }
721
722 return AE_OK;
723}
724
725static int vmbus_acpi_add(struct acpi_device *device)
726{
727 acpi_status result;
728
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -0700729 hv_acpi_dev = device;
730
K. Y. Srinivasan0a4425b2011-08-27 11:31:38 -0700731 result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
732 vmbus_walk_resources, &irq);
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700733
734 if (ACPI_FAILURE(result)) {
735 complete(&probe_event);
736 return -ENODEV;
737 }
738 complete(&probe_event);
739 return 0;
740}
741
742static const struct acpi_device_id vmbus_acpi_device_ids[] = {
743 {"VMBUS", 0},
K. Y. Srinivasan9d7b18d2011-06-06 15:49:42 -0700744 {"VMBus", 0},
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700745 {"", 0},
746};
747MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
748
749static struct acpi_driver vmbus_acpi_driver = {
750 .name = "vmbus",
751 .ids = vmbus_acpi_device_ids,
752 .ops = {
753 .add = vmbus_acpi_add,
754 },
755};
756
K. Y. Srinivasan607c1a12011-06-06 15:49:39 -0700757static int __init hv_acpi_init(void)
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -0700758{
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -0700759 int ret, t;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700760
761 init_completion(&probe_event);
762
763 /*
764 * Get irq resources first.
765 */
766
K. Y. Srinivasan02466042011-06-06 15:49:40 -0700767 ret = acpi_bus_register_driver(&vmbus_acpi_driver);
768
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700769 if (ret)
770 return ret;
771
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -0700772 t = wait_for_completion_timeout(&probe_event, 5*HZ);
773 if (t == 0) {
774 ret = -ETIMEDOUT;
775 goto cleanup;
776 }
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700777
778 if (irq <= 0) {
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -0700779 ret = -ENODEV;
780 goto cleanup;
K. Y. Srinivasanb0069f42011-04-29 13:45:15 -0700781 }
782
K. Y. Srinivasan91fd7992011-06-16 13:16:38 -0700783 ret = vmbus_bus_init(irq);
784 if (ret)
K. Y. Srinivasan2dda95f2011-07-15 13:38:56 -0700785 goto cleanup;
786
787 return 0;
788
789cleanup:
790 acpi_bus_unregister_driver(&vmbus_acpi_driver);
K. Y. Srinivasancf6a2ea2011-12-01 09:59:34 -0800791 hv_acpi_dev = NULL;
K. Y. Srinivasan91fd7992011-06-16 13:16:38 -0700792 return ret;
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -0700793}
794
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -0800795static void __exit vmbus_exit(void)
796{
797
798 free_irq(irq, hv_acpi_dev);
799 vmbus_free_channels();
800 bus_unregister(&hv_bus);
801 hv_cleanup();
802 acpi_bus_unregister_driver(&vmbus_acpi_driver);
803}
804
K. Y. Srinivasan1168ac22011-03-15 15:03:32 -0700805
Greg Kroah-Hartman90c99602009-09-02 07:11:14 -0700806MODULE_LICENSE("GPL");
Hank Janssen26c14cc2010-02-11 23:02:42 +0000807MODULE_VERSION(HV_DRV_VERSION);
Hank Janssen3e7ee492009-07-13 16:02:34 -0700808
K. Y. Srinivasan43d4e112011-10-24 11:28:12 -0700809subsys_initcall(hv_acpi_init);
K. Y. Srinivasan93e5bd02011-12-12 09:29:17 -0800810module_exit(vmbus_exit);