Drivers: hv: Add code to distribute channel interrupt load
[linux-3.10.git] / drivers / hv / vmbus_drv.c
1 /*
2  * 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>
20  *   K. Y. Srinivasan <kys@microsoft.com>
21  *
22  */
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
24
25 #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>
31 #include <linux/slab.h>
32 #include <linux/acpi.h>
33 #include <acpi/acpi_bus.h>
34 #include <linux/completion.h>
35 #include <linux/hyperv.h>
36 #include <asm/hyperv.h>
37 #include <asm/hypervisor.h>
38 #include "hyperv_vmbus.h"
39
40
41 static struct acpi_device  *hv_acpi_dev;
42
43 static struct tasklet_struct msg_dpc;
44 static struct tasklet_struct event_dpc;
45 static struct completion probe_event;
46 static int irq;
47
48 struct hv_device_info {
49         u32 chn_id;
50         u32 chn_state;
51         uuid_le chn_type;
52         uuid_le chn_instance;
53
54         u32 monitor_id;
55         u32 server_monitor_pending;
56         u32 server_monitor_latency;
57         u32 server_monitor_conn_id;
58         u32 client_monitor_pending;
59         u32 client_monitor_latency;
60         u32 client_monitor_conn_id;
61
62         struct hv_dev_port_info inbound;
63         struct hv_dev_port_info outbound;
64 };
65
66 static int vmbus_exists(void)
67 {
68         if (hv_acpi_dev == NULL)
69                 return -ENODEV;
70
71         return 0;
72 }
73
74
75 static void get_channel_info(struct hv_device *device,
76                              struct hv_device_info *info)
77 {
78         struct vmbus_channel_debug_info debug_info;
79
80         if (!device->channel)
81                 return;
82
83         vmbus_get_debug_info(device->channel, &debug_info);
84
85         info->chn_id = debug_info.relid;
86         info->chn_state = debug_info.state;
87         memcpy(&info->chn_type, &debug_info.interfacetype,
88                sizeof(uuid_le));
89         memcpy(&info->chn_instance, &debug_info.interface_instance,
90                sizeof(uuid_le));
91
92         info->monitor_id = debug_info.monitorid;
93
94         info->server_monitor_pending = debug_info.servermonitor_pending;
95         info->server_monitor_latency = debug_info.servermonitor_latency;
96         info->server_monitor_conn_id = debug_info.servermonitor_connectionid;
97
98         info->client_monitor_pending = debug_info.clientmonitor_pending;
99         info->client_monitor_latency = debug_info.clientmonitor_latency;
100         info->client_monitor_conn_id = debug_info.clientmonitor_connectionid;
101
102         info->inbound.int_mask = debug_info.inbound.current_interrupt_mask;
103         info->inbound.read_idx = debug_info.inbound.current_read_index;
104         info->inbound.write_idx = debug_info.inbound.current_write_index;
105         info->inbound.bytes_avail_toread =
106                 debug_info.inbound.bytes_avail_toread;
107         info->inbound.bytes_avail_towrite =
108                 debug_info.inbound.bytes_avail_towrite;
109
110         info->outbound.int_mask =
111                 debug_info.outbound.current_interrupt_mask;
112         info->outbound.read_idx = debug_info.outbound.current_read_index;
113         info->outbound.write_idx = debug_info.outbound.current_write_index;
114         info->outbound.bytes_avail_toread =
115                 debug_info.outbound.bytes_avail_toread;
116         info->outbound.bytes_avail_towrite =
117                 debug_info.outbound.bytes_avail_towrite;
118 }
119
120 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
121 static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
122 {
123         int i;
124         for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
125                 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
126 }
127
128 /*
129  * vmbus_show_device_attr - Show the device attribute in sysfs.
130  *
131  * This is invoked when user does a
132  * "cat /sys/bus/vmbus/devices/<busdevice>/<attr name>"
133  */
134 static ssize_t vmbus_show_device_attr(struct device *dev,
135                                       struct device_attribute *dev_attr,
136                                       char *buf)
137 {
138         struct hv_device *hv_dev = device_to_hv_device(dev);
139         struct hv_device_info *device_info;
140         char alias_name[VMBUS_ALIAS_LEN + 1];
141         int ret = 0;
142
143         device_info = kzalloc(sizeof(struct hv_device_info), GFP_KERNEL);
144         if (!device_info)
145                 return ret;
146
147         get_channel_info(hv_dev, device_info);
148
149         if (!strcmp(dev_attr->attr.name, "class_id")) {
150                 ret = sprintf(buf, "{%pUl}\n", device_info->chn_type.b);
151         } else if (!strcmp(dev_attr->attr.name, "device_id")) {
152                 ret = sprintf(buf, "{%pUl}\n", device_info->chn_instance.b);
153         } else if (!strcmp(dev_attr->attr.name, "modalias")) {
154                 print_alias_name(hv_dev, alias_name);
155                 ret = sprintf(buf, "vmbus:%s\n", alias_name);
156         } else if (!strcmp(dev_attr->attr.name, "state")) {
157                 ret = sprintf(buf, "%d\n", device_info->chn_state);
158         } else if (!strcmp(dev_attr->attr.name, "id")) {
159                 ret = sprintf(buf, "%d\n", device_info->chn_id);
160         } else if (!strcmp(dev_attr->attr.name, "out_intr_mask")) {
161                 ret = sprintf(buf, "%d\n", device_info->outbound.int_mask);
162         } else if (!strcmp(dev_attr->attr.name, "out_read_index")) {
163                 ret = sprintf(buf, "%d\n", device_info->outbound.read_idx);
164         } else if (!strcmp(dev_attr->attr.name, "out_write_index")) {
165                 ret = sprintf(buf, "%d\n", device_info->outbound.write_idx);
166         } else if (!strcmp(dev_attr->attr.name, "out_read_bytes_avail")) {
167                 ret = sprintf(buf, "%d\n",
168                                device_info->outbound.bytes_avail_toread);
169         } else if (!strcmp(dev_attr->attr.name, "out_write_bytes_avail")) {
170                 ret = sprintf(buf, "%d\n",
171                                device_info->outbound.bytes_avail_towrite);
172         } else if (!strcmp(dev_attr->attr.name, "in_intr_mask")) {
173                 ret = sprintf(buf, "%d\n", device_info->inbound.int_mask);
174         } else if (!strcmp(dev_attr->attr.name, "in_read_index")) {
175                 ret = sprintf(buf, "%d\n", device_info->inbound.read_idx);
176         } else if (!strcmp(dev_attr->attr.name, "in_write_index")) {
177                 ret = sprintf(buf, "%d\n", device_info->inbound.write_idx);
178         } else if (!strcmp(dev_attr->attr.name, "in_read_bytes_avail")) {
179                 ret = sprintf(buf, "%d\n",
180                                device_info->inbound.bytes_avail_toread);
181         } else if (!strcmp(dev_attr->attr.name, "in_write_bytes_avail")) {
182                 ret = sprintf(buf, "%d\n",
183                                device_info->inbound.bytes_avail_towrite);
184         } else if (!strcmp(dev_attr->attr.name, "monitor_id")) {
185                 ret = sprintf(buf, "%d\n", device_info->monitor_id);
186         } else if (!strcmp(dev_attr->attr.name, "server_monitor_pending")) {
187                 ret = sprintf(buf, "%d\n", device_info->server_monitor_pending);
188         } else if (!strcmp(dev_attr->attr.name, "server_monitor_latency")) {
189                 ret = sprintf(buf, "%d\n", device_info->server_monitor_latency);
190         } else if (!strcmp(dev_attr->attr.name, "server_monitor_conn_id")) {
191                 ret = sprintf(buf, "%d\n",
192                                device_info->server_monitor_conn_id);
193         } else if (!strcmp(dev_attr->attr.name, "client_monitor_pending")) {
194                 ret = sprintf(buf, "%d\n", device_info->client_monitor_pending);
195         } else if (!strcmp(dev_attr->attr.name, "client_monitor_latency")) {
196                 ret = sprintf(buf, "%d\n", device_info->client_monitor_latency);
197         } else if (!strcmp(dev_attr->attr.name, "client_monitor_conn_id")) {
198                 ret = sprintf(buf, "%d\n",
199                                device_info->client_monitor_conn_id);
200         }
201
202         kfree(device_info);
203         return ret;
204 }
205
206 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
207 static struct device_attribute vmbus_device_attrs[] = {
208         __ATTR(id, S_IRUGO, vmbus_show_device_attr, NULL),
209         __ATTR(state, S_IRUGO, vmbus_show_device_attr, NULL),
210         __ATTR(class_id, S_IRUGO, vmbus_show_device_attr, NULL),
211         __ATTR(device_id, S_IRUGO, vmbus_show_device_attr, NULL),
212         __ATTR(monitor_id, S_IRUGO, vmbus_show_device_attr, NULL),
213         __ATTR(modalias, S_IRUGO, vmbus_show_device_attr, NULL),
214
215         __ATTR(server_monitor_pending, S_IRUGO, vmbus_show_device_attr, NULL),
216         __ATTR(server_monitor_latency, S_IRUGO, vmbus_show_device_attr, NULL),
217         __ATTR(server_monitor_conn_id, S_IRUGO, vmbus_show_device_attr, NULL),
218
219         __ATTR(client_monitor_pending, S_IRUGO, vmbus_show_device_attr, NULL),
220         __ATTR(client_monitor_latency, S_IRUGO, vmbus_show_device_attr, NULL),
221         __ATTR(client_monitor_conn_id, S_IRUGO, vmbus_show_device_attr, NULL),
222
223         __ATTR(out_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL),
224         __ATTR(out_read_index, S_IRUGO, vmbus_show_device_attr, NULL),
225         __ATTR(out_write_index, S_IRUGO, vmbus_show_device_attr, NULL),
226         __ATTR(out_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
227         __ATTR(out_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
228
229         __ATTR(in_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL),
230         __ATTR(in_read_index, S_IRUGO, vmbus_show_device_attr, NULL),
231         __ATTR(in_write_index, S_IRUGO, vmbus_show_device_attr, NULL),
232         __ATTR(in_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
233         __ATTR(in_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
234         __ATTR_NULL
235 };
236
237
238 /*
239  * vmbus_uevent - add uevent for our device
240  *
241  * This routine is invoked when a device is added or removed on the vmbus to
242  * generate a uevent to udev in the userspace. The udev will then look at its
243  * rule and the uevent generated here to load the appropriate driver
244  *
245  * The alias string will be of the form vmbus:guid where guid is the string
246  * representation of the device guid (each byte of the guid will be
247  * represented with two hex characters.
248  */
249 static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
250 {
251         struct hv_device *dev = device_to_hv_device(device);
252         int ret;
253         char alias_name[VMBUS_ALIAS_LEN + 1];
254
255         print_alias_name(dev, alias_name);
256         ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
257         return ret;
258 }
259
260 static uuid_le null_guid;
261
262 static inline bool is_null_guid(const __u8 *guid)
263 {
264         if (memcmp(guid, &null_guid, sizeof(uuid_le)))
265                 return false;
266         return true;
267 }
268
269 /*
270  * Return a matching hv_vmbus_device_id pointer.
271  * If there is no match, return NULL.
272  */
273 static const struct hv_vmbus_device_id *hv_vmbus_get_id(
274                                         const struct hv_vmbus_device_id *id,
275                                         __u8 *guid)
276 {
277         for (; !is_null_guid(id->guid); id++)
278                 if (!memcmp(&id->guid, guid, sizeof(uuid_le)))
279                         return id;
280
281         return NULL;
282 }
283
284
285
286 /*
287  * vmbus_match - Attempt to match the specified device to the specified driver
288  */
289 static int vmbus_match(struct device *device, struct device_driver *driver)
290 {
291         struct hv_driver *drv = drv_to_hv_drv(driver);
292         struct hv_device *hv_dev = device_to_hv_device(device);
293
294         if (hv_vmbus_get_id(drv->id_table, hv_dev->dev_type.b))
295                 return 1;
296
297         return 0;
298 }
299
300 /*
301  * vmbus_probe - Add the new vmbus's child device
302  */
303 static int vmbus_probe(struct device *child_device)
304 {
305         int ret = 0;
306         struct hv_driver *drv =
307                         drv_to_hv_drv(child_device->driver);
308         struct hv_device *dev = device_to_hv_device(child_device);
309         const struct hv_vmbus_device_id *dev_id;
310
311         dev_id = hv_vmbus_get_id(drv->id_table, dev->dev_type.b);
312         if (drv->probe) {
313                 ret = drv->probe(dev, dev_id);
314                 if (ret != 0)
315                         pr_err("probe failed for device %s (%d)\n",
316                                dev_name(child_device), ret);
317
318         } else {
319                 pr_err("probe not set for driver %s\n",
320                        dev_name(child_device));
321                 ret = -ENODEV;
322         }
323         return ret;
324 }
325
326 /*
327  * vmbus_remove - Remove a vmbus device
328  */
329 static int vmbus_remove(struct device *child_device)
330 {
331         struct hv_driver *drv = drv_to_hv_drv(child_device->driver);
332         struct hv_device *dev = device_to_hv_device(child_device);
333
334         if (drv->remove)
335                 drv->remove(dev);
336         else
337                 pr_err("remove not set for driver %s\n",
338                         dev_name(child_device));
339
340         return 0;
341 }
342
343
344 /*
345  * vmbus_shutdown - Shutdown a vmbus device
346  */
347 static void vmbus_shutdown(struct device *child_device)
348 {
349         struct hv_driver *drv;
350         struct hv_device *dev = device_to_hv_device(child_device);
351
352
353         /* The device may not be attached yet */
354         if (!child_device->driver)
355                 return;
356
357         drv = drv_to_hv_drv(child_device->driver);
358
359         if (drv->shutdown)
360                 drv->shutdown(dev);
361
362         return;
363 }
364
365
366 /*
367  * vmbus_device_release - Final callback release of the vmbus child device
368  */
369 static void vmbus_device_release(struct device *device)
370 {
371         struct hv_device *hv_dev = device_to_hv_device(device);
372
373         kfree(hv_dev);
374
375 }
376
377 /* The one and only one */
378 static struct bus_type  hv_bus = {
379         .name =         "vmbus",
380         .match =                vmbus_match,
381         .shutdown =             vmbus_shutdown,
382         .remove =               vmbus_remove,
383         .probe =                vmbus_probe,
384         .uevent =               vmbus_uevent,
385         .dev_attrs =    vmbus_device_attrs,
386 };
387
388 static const char *driver_name = "hyperv";
389
390
391 struct onmessage_work_context {
392         struct work_struct work;
393         struct hv_message msg;
394 };
395
396 static void vmbus_onmessage_work(struct work_struct *work)
397 {
398         struct onmessage_work_context *ctx;
399
400         ctx = container_of(work, struct onmessage_work_context,
401                            work);
402         vmbus_onmessage(&ctx->msg);
403         kfree(ctx);
404 }
405
406 static void vmbus_on_msg_dpc(unsigned long data)
407 {
408         int cpu = smp_processor_id();
409         void *page_addr = hv_context.synic_message_page[cpu];
410         struct hv_message *msg = (struct hv_message *)page_addr +
411                                   VMBUS_MESSAGE_SINT;
412         struct onmessage_work_context *ctx;
413
414         while (1) {
415                 if (msg->header.message_type == HVMSG_NONE) {
416                         /* no msg */
417                         break;
418                 } else {
419                         ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
420                         if (ctx == NULL)
421                                 continue;
422                         INIT_WORK(&ctx->work, vmbus_onmessage_work);
423                         memcpy(&ctx->msg, msg, sizeof(*msg));
424                         queue_work(vmbus_connection.work_queue, &ctx->work);
425                 }
426
427                 msg->header.message_type = HVMSG_NONE;
428
429                 /*
430                  * Make sure the write to MessageType (ie set to
431                  * HVMSG_NONE) happens before we read the
432                  * MessagePending and EOMing. Otherwise, the EOMing
433                  * will not deliver any more messages since there is
434                  * no empty slot
435                  */
436                 smp_mb();
437
438                 if (msg->header.message_flags.msg_pending) {
439                         /*
440                          * This will cause message queue rescan to
441                          * possibly deliver another msg from the
442                          * hypervisor
443                          */
444                         wrmsrl(HV_X64_MSR_EOM, 0);
445                 }
446         }
447 }
448
449 static irqreturn_t vmbus_isr(int irq, void *dev_id)
450 {
451         int cpu = smp_processor_id();
452         void *page_addr;
453         struct hv_message *msg;
454         union hv_synic_event_flags *event;
455         bool handled = false;
456
457         /*
458          * Check for events before checking for messages. This is the order
459          * in which events and messages are checked in Windows guests on
460          * Hyper-V, and the Windows team suggested we do the same.
461          */
462
463         if ((vmbus_proto_version == VERSION_WS2008) ||
464                 (vmbus_proto_version == VERSION_WIN7)) {
465
466                 page_addr = hv_context.synic_event_page[cpu];
467                 event = (union hv_synic_event_flags *)page_addr +
468                                          VMBUS_MESSAGE_SINT;
469
470                 /* Since we are a child, we only need to check bit 0 */
471                 if (sync_test_and_clear_bit(0,
472                         (unsigned long *) &event->flags32[0])) {
473                         handled = true;
474                 }
475         } else {
476                 /*
477                  * Our host is win8 or above. The signaling mechanism
478                  * has changed and we can directly look at the event page.
479                  * If bit n is set then we have an interrup on the channel
480                  * whose id is n.
481                  */
482                 handled = true;
483         }
484
485         if (handled)
486                 tasklet_schedule(&event_dpc);
487
488
489         page_addr = hv_context.synic_message_page[cpu];
490         msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
491
492         /* Check if there are actual msgs to be processed */
493         if (msg->header.message_type != HVMSG_NONE) {
494                 handled = true;
495                 tasklet_schedule(&msg_dpc);
496         }
497
498         if (handled)
499                 return IRQ_HANDLED;
500         else
501                 return IRQ_NONE;
502 }
503
504 /*
505  * vmbus_bus_init -Main vmbus driver initialization routine.
506  *
507  * Here, we
508  *      - initialize the vmbus driver context
509  *      - invoke the vmbus hv main init routine
510  *      - get the irq resource
511  *      - retrieve the channel offers
512  */
513 static int vmbus_bus_init(int irq)
514 {
515         int ret;
516         unsigned int vector;
517
518         /* Hypervisor initialization...setup hypercall page..etc */
519         ret = hv_init();
520         if (ret != 0) {
521                 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
522                 return ret;
523         }
524
525         tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0);
526         tasklet_init(&event_dpc, vmbus_on_event, 0);
527
528         ret = bus_register(&hv_bus);
529         if (ret)
530                 goto err_cleanup;
531
532         ret = request_irq(irq, vmbus_isr, 0, driver_name, hv_acpi_dev);
533
534         if (ret != 0) {
535                 pr_err("Unable to request IRQ %d\n",
536                            irq);
537                 goto err_unregister;
538         }
539
540         vector = IRQ0_VECTOR + irq;
541
542         /*
543          * Notify the hypervisor of our irq and
544          * connect to the host.
545          */
546         on_each_cpu(hv_synic_init, (void *)&vector, 1);
547         ret = vmbus_connect();
548         if (ret)
549                 goto err_irq;
550
551         vmbus_request_offers();
552
553         return 0;
554
555 err_irq:
556         free_irq(irq, hv_acpi_dev);
557
558 err_unregister:
559         bus_unregister(&hv_bus);
560
561 err_cleanup:
562         hv_cleanup();
563
564         return ret;
565 }
566
567 /**
568  * __vmbus_child_driver_register - Register a vmbus's driver
569  * @drv: Pointer to driver structure you want to register
570  * @owner: owner module of the drv
571  * @mod_name: module name string
572  *
573  * Registers the given driver with Linux through the 'driver_register()' call
574  * and sets up the hyper-v vmbus handling for this driver.
575  * It will return the state of the 'driver_register()' call.
576  *
577  */
578 int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
579 {
580         int ret;
581
582         pr_info("registering driver %s\n", hv_driver->name);
583
584         ret = vmbus_exists();
585         if (ret < 0)
586                 return ret;
587
588         hv_driver->driver.name = hv_driver->name;
589         hv_driver->driver.owner = owner;
590         hv_driver->driver.mod_name = mod_name;
591         hv_driver->driver.bus = &hv_bus;
592
593         ret = driver_register(&hv_driver->driver);
594
595         vmbus_request_offers();
596
597         return ret;
598 }
599 EXPORT_SYMBOL_GPL(__vmbus_driver_register);
600
601 /**
602  * vmbus_driver_unregister() - Unregister a vmbus's driver
603  * @drv: Pointer to driver structure you want to un-register
604  *
605  * Un-register the given driver that was previous registered with a call to
606  * vmbus_driver_register()
607  */
608 void vmbus_driver_unregister(struct hv_driver *hv_driver)
609 {
610         pr_info("unregistering driver %s\n", hv_driver->name);
611
612         if (!vmbus_exists())
613                 driver_unregister(&hv_driver->driver);
614 }
615 EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
616
617 /*
618  * vmbus_device_create - Creates and registers a new child device
619  * on the vmbus.
620  */
621 struct hv_device *vmbus_device_create(uuid_le *type,
622                                             uuid_le *instance,
623                                             struct vmbus_channel *channel)
624 {
625         struct hv_device *child_device_obj;
626
627         child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
628         if (!child_device_obj) {
629                 pr_err("Unable to allocate device object for child device\n");
630                 return NULL;
631         }
632
633         child_device_obj->channel = channel;
634         memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
635         memcpy(&child_device_obj->dev_instance, instance,
636                sizeof(uuid_le));
637
638
639         return child_device_obj;
640 }
641
642 /*
643  * vmbus_device_register - Register the child device
644  */
645 int vmbus_device_register(struct hv_device *child_device_obj)
646 {
647         int ret = 0;
648
649         static atomic_t device_num = ATOMIC_INIT(0);
650
651         dev_set_name(&child_device_obj->device, "vmbus_0_%d",
652                      atomic_inc_return(&device_num));
653
654         child_device_obj->device.bus = &hv_bus;
655         child_device_obj->device.parent = &hv_acpi_dev->dev;
656         child_device_obj->device.release = vmbus_device_release;
657
658         /*
659          * Register with the LDM. This will kick off the driver/device
660          * binding...which will eventually call vmbus_match() and vmbus_probe()
661          */
662         ret = device_register(&child_device_obj->device);
663
664         if (ret)
665                 pr_err("Unable to register child device\n");
666         else
667                 pr_info("child device %s registered\n",
668                         dev_name(&child_device_obj->device));
669
670         return ret;
671 }
672
673 /*
674  * vmbus_device_unregister - Remove the specified child device
675  * from the vmbus.
676  */
677 void vmbus_device_unregister(struct hv_device *device_obj)
678 {
679         /*
680          * Kick off the process of unregistering the device.
681          * This will call vmbus_remove() and eventually vmbus_device_release()
682          */
683         device_unregister(&device_obj->device);
684
685         pr_info("child device %s unregistered\n",
686                 dev_name(&device_obj->device));
687 }
688
689
690 /*
691  * VMBUS is an acpi enumerated device. Get the the IRQ information
692  * from DSDT.
693  */
694
695 static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *irq)
696 {
697
698         if (res->type == ACPI_RESOURCE_TYPE_IRQ) {
699                 struct acpi_resource_irq *irqp;
700                 irqp = &res->data.irq;
701
702                 *((unsigned int *)irq) = irqp->interrupts[0];
703         }
704
705         return AE_OK;
706 }
707
708 static int vmbus_acpi_add(struct acpi_device *device)
709 {
710         acpi_status result;
711
712         hv_acpi_dev = device;
713
714         result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
715                                         vmbus_walk_resources, &irq);
716
717         if (ACPI_FAILURE(result)) {
718                 complete(&probe_event);
719                 return -ENODEV;
720         }
721         complete(&probe_event);
722         return 0;
723 }
724
725 static const struct acpi_device_id vmbus_acpi_device_ids[] = {
726         {"VMBUS", 0},
727         {"VMBus", 0},
728         {"", 0},
729 };
730 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
731
732 static struct acpi_driver vmbus_acpi_driver = {
733         .name = "vmbus",
734         .ids = vmbus_acpi_device_ids,
735         .ops = {
736                 .add = vmbus_acpi_add,
737         },
738 };
739
740 static int __init hv_acpi_init(void)
741 {
742         int ret, t;
743
744         if (x86_hyper != &x86_hyper_ms_hyperv)
745                 return -ENODEV;
746
747         init_completion(&probe_event);
748
749         /*
750          * Get irq resources first.
751          */
752
753         ret = acpi_bus_register_driver(&vmbus_acpi_driver);
754
755         if (ret)
756                 return ret;
757
758         t = wait_for_completion_timeout(&probe_event, 5*HZ);
759         if (t == 0) {
760                 ret = -ETIMEDOUT;
761                 goto cleanup;
762         }
763
764         if (irq <= 0) {
765                 ret = -ENODEV;
766                 goto cleanup;
767         }
768
769         ret = vmbus_bus_init(irq);
770         if (ret)
771                 goto cleanup;
772
773         return 0;
774
775 cleanup:
776         acpi_bus_unregister_driver(&vmbus_acpi_driver);
777         hv_acpi_dev = NULL;
778         return ret;
779 }
780
781 static void __exit vmbus_exit(void)
782 {
783
784         free_irq(irq, hv_acpi_dev);
785         vmbus_free_channels();
786         bus_unregister(&hv_bus);
787         hv_cleanup();
788         acpi_bus_unregister_driver(&vmbus_acpi_driver);
789 }
790
791
792 MODULE_LICENSE("GPL");
793 MODULE_VERSION(HV_DRV_VERSION);
794
795 subsys_initcall(hv_acpi_init);
796 module_exit(vmbus_exit);