2 * Copyright (c) 2009, Microsoft Corporation.
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.
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
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.
18 * Haiyang Zhang <haiyangz@microsoft.com>
19 * Hank Janssen <hjanssen@microsoft.com>
20 * K. Y. Srinivasan <kys@microsoft.com>
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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 <linux/kernel_stat.h>
37 #include <asm/hyperv.h>
38 #include <asm/hypervisor.h>
39 #include <asm/mshyperv.h>
40 #include "hyperv_vmbus.h"
43 static struct acpi_device *hv_acpi_dev;
45 static struct tasklet_struct msg_dpc;
46 static struct completion probe_event;
49 struct hv_device_info {
50 struct hv_dev_port_info inbound;
51 struct hv_dev_port_info outbound;
54 static int vmbus_exists(void)
56 if (hv_acpi_dev == NULL)
63 static void get_channel_info(struct hv_device *device,
64 struct hv_device_info *info)
66 struct vmbus_channel_debug_info debug_info;
71 vmbus_get_debug_info(device->channel, &debug_info);
73 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;
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;
91 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
92 static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
95 for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
96 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
100 * vmbus_show_device_attr - Show the device attribute in sysfs.
102 * This is invoked when user does a
103 * "cat /sys/bus/vmbus/devices/<busdevice>/<attr name>"
105 static ssize_t vmbus_show_device_attr(struct device *dev,
106 struct device_attribute *dev_attr,
109 struct hv_device *hv_dev = device_to_hv_device(dev);
110 struct hv_device_info *device_info;
113 device_info = kzalloc(sizeof(struct hv_device_info), GFP_KERNEL);
117 get_channel_info(hv_dev, device_info);
119 if (!strcmp(dev_attr->attr.name, "out_intr_mask")) {
120 ret = sprintf(buf, "%d\n", device_info->outbound.int_mask);
121 } else if (!strcmp(dev_attr->attr.name, "out_read_index")) {
122 ret = sprintf(buf, "%d\n", device_info->outbound.read_idx);
123 } else if (!strcmp(dev_attr->attr.name, "out_write_index")) {
124 ret = sprintf(buf, "%d\n", device_info->outbound.write_idx);
125 } else if (!strcmp(dev_attr->attr.name, "out_read_bytes_avail")) {
126 ret = sprintf(buf, "%d\n",
127 device_info->outbound.bytes_avail_toread);
128 } else if (!strcmp(dev_attr->attr.name, "out_write_bytes_avail")) {
129 ret = sprintf(buf, "%d\n",
130 device_info->outbound.bytes_avail_towrite);
131 } else if (!strcmp(dev_attr->attr.name, "in_intr_mask")) {
132 ret = sprintf(buf, "%d\n", device_info->inbound.int_mask);
133 } else if (!strcmp(dev_attr->attr.name, "in_read_index")) {
134 ret = sprintf(buf, "%d\n", device_info->inbound.read_idx);
135 } else if (!strcmp(dev_attr->attr.name, "in_write_index")) {
136 ret = sprintf(buf, "%d\n", device_info->inbound.write_idx);
137 } else if (!strcmp(dev_attr->attr.name, "in_read_bytes_avail")) {
138 ret = sprintf(buf, "%d\n",
139 device_info->inbound.bytes_avail_toread);
140 } else if (!strcmp(dev_attr->attr.name, "in_write_bytes_avail")) {
141 ret = sprintf(buf, "%d\n",
142 device_info->inbound.bytes_avail_towrite);
149 static u8 channel_monitor_group(struct vmbus_channel *channel)
151 return (u8)channel->offermsg.monitorid / 32;
154 static u8 channel_monitor_offset(struct vmbus_channel *channel)
156 return (u8)channel->offermsg.monitorid % 32;
159 static u32 channel_pending(struct vmbus_channel *channel,
160 struct hv_monitor_page *monitor_page)
162 u8 monitor_group = channel_monitor_group(channel);
163 return monitor_page->trigger_group[monitor_group].pending;
166 static u32 channel_latency(struct vmbus_channel *channel,
167 struct hv_monitor_page *monitor_page)
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];
174 static u32 channel_conn_id(struct vmbus_channel *channel,
175 struct hv_monitor_page *monitor_page)
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;
182 static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr,
185 struct hv_device *hv_dev = device_to_hv_device(dev);
187 if (!hv_dev->channel)
189 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid);
191 static DEVICE_ATTR_RO(id);
193 static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr,
196 struct hv_device *hv_dev = device_to_hv_device(dev);
198 if (!hv_dev->channel)
200 return sprintf(buf, "%d\n", hv_dev->channel->state);
202 static DEVICE_ATTR_RO(state);
204 static ssize_t monitor_id_show(struct device *dev,
205 struct device_attribute *dev_attr, char *buf)
207 struct hv_device *hv_dev = device_to_hv_device(dev);
209 if (!hv_dev->channel)
211 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid);
213 static DEVICE_ATTR_RO(monitor_id);
215 static ssize_t class_id_show(struct device *dev,
216 struct device_attribute *dev_attr, char *buf)
218 struct hv_device *hv_dev = device_to_hv_device(dev);
220 if (!hv_dev->channel)
222 return sprintf(buf, "{%pUl}\n",
223 hv_dev->channel->offermsg.offer.if_type.b);
225 static DEVICE_ATTR_RO(class_id);
227 static ssize_t device_id_show(struct device *dev,
228 struct device_attribute *dev_attr, char *buf)
230 struct hv_device *hv_dev = device_to_hv_device(dev);
232 if (!hv_dev->channel)
234 return sprintf(buf, "{%pUl}\n",
235 hv_dev->channel->offermsg.offer.if_instance.b);
237 static DEVICE_ATTR_RO(device_id);
239 static ssize_t modalias_show(struct device *dev,
240 struct device_attribute *dev_attr, char *buf)
242 struct hv_device *hv_dev = device_to_hv_device(dev);
243 char alias_name[VMBUS_ALIAS_LEN + 1];
245 print_alias_name(hv_dev, alias_name);
246 return sprintf(buf, "vmbus:%s\n", alias_name);
248 static DEVICE_ATTR_RO(modalias);
250 static ssize_t server_monitor_pending_show(struct device *dev,
251 struct device_attribute *dev_attr,
254 struct hv_device *hv_dev = device_to_hv_device(dev);
256 if (!hv_dev->channel)
258 return sprintf(buf, "%d\n",
259 channel_pending(hv_dev->channel,
260 vmbus_connection.monitor_pages[1]));
262 static DEVICE_ATTR_RO(server_monitor_pending);
264 static ssize_t client_monitor_pending_show(struct device *dev,
265 struct device_attribute *dev_attr,
268 struct hv_device *hv_dev = device_to_hv_device(dev);
270 if (!hv_dev->channel)
272 return sprintf(buf, "%d\n",
273 channel_pending(hv_dev->channel,
274 vmbus_connection.monitor_pages[1]));
276 static DEVICE_ATTR_RO(client_monitor_pending);
278 static ssize_t server_monitor_latency_show(struct device *dev,
279 struct device_attribute *dev_attr,
282 struct hv_device *hv_dev = device_to_hv_device(dev);
284 if (!hv_dev->channel)
286 return sprintf(buf, "%d\n",
287 channel_latency(hv_dev->channel,
288 vmbus_connection.monitor_pages[0]));
290 static DEVICE_ATTR_RO(server_monitor_latency);
292 static ssize_t client_monitor_latency_show(struct device *dev,
293 struct device_attribute *dev_attr,
296 struct hv_device *hv_dev = device_to_hv_device(dev);
298 if (!hv_dev->channel)
300 return sprintf(buf, "%d\n",
301 channel_latency(hv_dev->channel,
302 vmbus_connection.monitor_pages[1]));
304 static DEVICE_ATTR_RO(client_monitor_latency);
306 static ssize_t server_monitor_conn_id_show(struct device *dev,
307 struct device_attribute *dev_attr,
310 struct hv_device *hv_dev = device_to_hv_device(dev);
312 if (!hv_dev->channel)
314 return sprintf(buf, "%d\n",
315 channel_conn_id(hv_dev->channel,
316 vmbus_connection.monitor_pages[0]));
318 static DEVICE_ATTR_RO(server_monitor_conn_id);
320 static ssize_t client_monitor_conn_id_show(struct device *dev,
321 struct device_attribute *dev_attr,
324 struct hv_device *hv_dev = device_to_hv_device(dev);
326 if (!hv_dev->channel)
328 return sprintf(buf, "%d\n",
329 channel_conn_id(hv_dev->channel,
330 vmbus_connection.monitor_pages[1]));
332 static DEVICE_ATTR_RO(client_monitor_conn_id);
334 static struct attribute *vmbus_attrs[] = {
336 &dev_attr_state.attr,
337 &dev_attr_monitor_id.attr,
338 &dev_attr_class_id.attr,
339 &dev_attr_device_id.attr,
340 &dev_attr_modalias.attr,
341 &dev_attr_server_monitor_pending.attr,
342 &dev_attr_client_monitor_pending.attr,
343 &dev_attr_server_monitor_latency.attr,
344 &dev_attr_client_monitor_latency.attr,
345 &dev_attr_server_monitor_conn_id.attr,
346 &dev_attr_client_monitor_conn_id.attr,
349 ATTRIBUTE_GROUPS(vmbus);
351 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
352 static struct device_attribute vmbus_device_attrs[] = {
353 __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),
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),
369 * vmbus_uevent - add uevent for our device
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
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.
379 static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
381 struct hv_device *dev = device_to_hv_device(device);
383 char alias_name[VMBUS_ALIAS_LEN + 1];
385 print_alias_name(dev, alias_name);
386 ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
390 static uuid_le null_guid;
392 static inline bool is_null_guid(const __u8 *guid)
394 if (memcmp(guid, &null_guid, sizeof(uuid_le)))
400 * Return a matching hv_vmbus_device_id pointer.
401 * If there is no match, return NULL.
403 static const struct hv_vmbus_device_id *hv_vmbus_get_id(
404 const struct hv_vmbus_device_id *id,
407 for (; !is_null_guid(id->guid); id++)
408 if (!memcmp(&id->guid, guid, sizeof(uuid_le)))
417 * vmbus_match - Attempt to match the specified device to the specified driver
419 static int vmbus_match(struct device *device, struct device_driver *driver)
421 struct hv_driver *drv = drv_to_hv_drv(driver);
422 struct hv_device *hv_dev = device_to_hv_device(device);
424 if (hv_vmbus_get_id(drv->id_table, hv_dev->dev_type.b))
431 * vmbus_probe - Add the new vmbus's child device
433 static int vmbus_probe(struct device *child_device)
436 struct hv_driver *drv =
437 drv_to_hv_drv(child_device->driver);
438 struct hv_device *dev = device_to_hv_device(child_device);
439 const struct hv_vmbus_device_id *dev_id;
441 dev_id = hv_vmbus_get_id(drv->id_table, dev->dev_type.b);
443 ret = drv->probe(dev, dev_id);
445 pr_err("probe failed for device %s (%d)\n",
446 dev_name(child_device), ret);
449 pr_err("probe not set for driver %s\n",
450 dev_name(child_device));
457 * vmbus_remove - Remove a vmbus device
459 static int vmbus_remove(struct device *child_device)
461 struct hv_driver *drv = drv_to_hv_drv(child_device->driver);
462 struct hv_device *dev = device_to_hv_device(child_device);
467 pr_err("remove not set for driver %s\n",
468 dev_name(child_device));
475 * vmbus_shutdown - Shutdown a vmbus device
477 static void vmbus_shutdown(struct device *child_device)
479 struct hv_driver *drv;
480 struct hv_device *dev = device_to_hv_device(child_device);
483 /* The device may not be attached yet */
484 if (!child_device->driver)
487 drv = drv_to_hv_drv(child_device->driver);
497 * vmbus_device_release - Final callback release of the vmbus child device
499 static void vmbus_device_release(struct device *device)
501 struct hv_device *hv_dev = device_to_hv_device(device);
507 /* The one and only one */
508 static struct bus_type hv_bus = {
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,
516 .dev_groups = vmbus_groups,
519 static const char *driver_name = "hyperv";
522 struct onmessage_work_context {
523 struct work_struct work;
524 struct hv_message msg;
527 static void vmbus_onmessage_work(struct work_struct *work)
529 struct onmessage_work_context *ctx;
531 ctx = container_of(work, struct onmessage_work_context,
533 vmbus_onmessage(&ctx->msg);
537 static void vmbus_on_msg_dpc(unsigned long data)
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 +
543 struct onmessage_work_context *ctx;
546 if (msg->header.message_type == HVMSG_NONE) {
550 ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
553 INIT_WORK(&ctx->work, vmbus_onmessage_work);
554 memcpy(&ctx->msg, msg, sizeof(*msg));
555 queue_work(vmbus_connection.work_queue, &ctx->work);
558 msg->header.message_type = HVMSG_NONE;
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
569 if (msg->header.message_flags.msg_pending) {
571 * This will cause message queue rescan to
572 * possibly deliver another msg from the
575 wrmsrl(HV_X64_MSR_EOM, 0);
580 static irqreturn_t vmbus_isr(int irq, void *dev_id)
582 int cpu = smp_processor_id();
584 struct hv_message *msg;
585 union hv_synic_event_flags *event;
586 bool handled = false;
588 page_addr = hv_context.synic_event_page[cpu];
589 if (page_addr == NULL)
592 event = (union hv_synic_event_flags *)page_addr +
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.
600 if ((vmbus_proto_version == VERSION_WS2008) ||
601 (vmbus_proto_version == VERSION_WIN7)) {
603 /* 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])) {
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
619 tasklet_schedule(hv_context.event_dpc[cpu]);
622 page_addr = hv_context.synic_message_page[cpu];
623 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
625 /* Check if there are actual msgs to be processed */
626 if (msg->header.message_type != HVMSG_NONE) {
628 tasklet_schedule(&msg_dpc);
638 * vmbus interrupt flow handler:
639 * vmbus interrupts can concurrently occur on multiple CPUs and
640 * can be handled concurrently.
643 static void vmbus_flow_handler(unsigned int irq, struct irq_desc *desc)
645 kstat_incr_irqs_this_cpu(irq, desc);
647 desc->action->handler(irq, desc->action->dev_id);
651 * vmbus_bus_init -Main vmbus driver initialization routine.
654 * - initialize the vmbus driver context
655 * - invoke the vmbus hv main init routine
656 * - get the irq resource
657 * - retrieve the channel offers
659 static int vmbus_bus_init(int irq)
663 /* Hypervisor initialization...setup hypercall page..etc */
666 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
670 tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0);
672 ret = bus_register(&hv_bus);
676 ret = request_irq(irq, vmbus_isr, 0, driver_name, hv_acpi_dev);
679 pr_err("Unable to request IRQ %d\n",
685 * Vmbus interrupts can be handled concurrently on
686 * different CPUs. Establish an appropriate interrupt flow
687 * handler that can support this model.
689 irq_set_handler(irq, vmbus_flow_handler);
692 * Register our interrupt handler.
694 hv_register_vmbus_handler(irq, vmbus_isr);
696 ret = hv_synic_alloc();
700 * Initialize the per-cpu interrupt state and
701 * connect to the host.
703 on_each_cpu(hv_synic_init, NULL, 1);
704 ret = vmbus_connect();
708 vmbus_request_offers();
714 free_irq(irq, hv_acpi_dev);
717 bus_unregister(&hv_bus);
726 * __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
731 * Registers the given driver with Linux through the 'driver_register()' call
732 * and sets up the hyper-v vmbus handling for this driver.
733 * It will return the state of the 'driver_register()' call.
736 int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
740 pr_info("registering driver %s\n", hv_driver->name);
742 ret = vmbus_exists();
746 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;
751 ret = driver_register(&hv_driver->driver);
755 EXPORT_SYMBOL_GPL(__vmbus_driver_register);
758 * vmbus_driver_unregister() - Unregister a vmbus's driver
759 * @drv: Pointer to driver structure you want to un-register
761 * Un-register the given driver that was previous registered with a call to
762 * vmbus_driver_register()
764 void vmbus_driver_unregister(struct hv_driver *hv_driver)
766 pr_info("unregistering driver %s\n", hv_driver->name);
769 driver_unregister(&hv_driver->driver);
771 EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
774 * vmbus_device_create - Creates and registers a new child device
777 struct hv_device *vmbus_device_create(uuid_le *type,
779 struct vmbus_channel *channel)
781 struct hv_device *child_device_obj;
783 child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
784 if (!child_device_obj) {
785 pr_err("Unable to allocate device object for child device\n");
789 child_device_obj->channel = channel;
790 memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
791 memcpy(&child_device_obj->dev_instance, instance,
795 return child_device_obj;
799 * vmbus_device_register - Register the child device
801 int vmbus_device_register(struct hv_device *child_device_obj)
805 static atomic_t device_num = ATOMIC_INIT(0);
807 dev_set_name(&child_device_obj->device, "vmbus_0_%d",
808 atomic_inc_return(&device_num));
810 child_device_obj->device.bus = &hv_bus;
811 child_device_obj->device.parent = &hv_acpi_dev->dev;
812 child_device_obj->device.release = vmbus_device_release;
815 * Register with the LDM. This will kick off the driver/device
816 * binding...which will eventually call vmbus_match() and vmbus_probe()
818 ret = device_register(&child_device_obj->device);
821 pr_err("Unable to register child device\n");
823 pr_debug("child device %s registered\n",
824 dev_name(&child_device_obj->device));
830 * vmbus_device_unregister - Remove the specified child device
833 void vmbus_device_unregister(struct hv_device *device_obj)
835 pr_debug("child device %s unregistered\n",
836 dev_name(&device_obj->device));
839 * Kick off the process of unregistering the device.
840 * This will call vmbus_remove() and eventually vmbus_device_release()
842 device_unregister(&device_obj->device);
847 * VMBUS is an acpi enumerated device. Get the the IRQ information
851 static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *irq)
854 if (res->type == ACPI_RESOURCE_TYPE_IRQ) {
855 struct acpi_resource_irq *irqp;
856 irqp = &res->data.irq;
858 *((unsigned int *)irq) = irqp->interrupts[0];
864 static int vmbus_acpi_add(struct acpi_device *device)
868 hv_acpi_dev = device;
870 result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
871 vmbus_walk_resources, &irq);
873 if (ACPI_FAILURE(result)) {
874 complete(&probe_event);
877 complete(&probe_event);
881 static const struct acpi_device_id vmbus_acpi_device_ids[] = {
886 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
888 static struct acpi_driver vmbus_acpi_driver = {
890 .ids = vmbus_acpi_device_ids,
892 .add = vmbus_acpi_add,
896 static int __init hv_acpi_init(void)
900 if (x86_hyper != &x86_hyper_ms_hyperv)
903 init_completion(&probe_event);
906 * Get irq resources first.
909 ret = acpi_bus_register_driver(&vmbus_acpi_driver);
914 t = wait_for_completion_timeout(&probe_event, 5*HZ);
925 ret = vmbus_bus_init(irq);
932 acpi_bus_unregister_driver(&vmbus_acpi_driver);
937 static void __exit vmbus_exit(void)
940 free_irq(irq, hv_acpi_dev);
941 vmbus_free_channels();
942 bus_unregister(&hv_bus);
944 acpi_bus_unregister_driver(&vmbus_acpi_driver);
948 MODULE_LICENSE("GPL");
950 subsys_initcall(hv_acpi_init);
951 module_exit(vmbus_exit);