Drivers: hv: balloon: Fix a memory leak
[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         page_addr = hv_context.synic_event_page[cpu];
464         event = (union hv_synic_event_flags *)page_addr + VMBUS_MESSAGE_SINT;
465
466         /* Since we are a child, we only need to check bit 0 */
467         if (sync_test_and_clear_bit(0, (unsigned long *) &event->flags32[0])) {
468                 handled = true;
469                 tasklet_schedule(&event_dpc);
470         }
471
472         page_addr = hv_context.synic_message_page[cpu];
473         msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
474
475         /* Check if there are actual msgs to be processed */
476         if (msg->header.message_type != HVMSG_NONE) {
477                 handled = true;
478                 tasklet_schedule(&msg_dpc);
479         }
480
481         if (handled)
482                 return IRQ_HANDLED;
483         else
484                 return IRQ_NONE;
485 }
486
487 /*
488  * vmbus_bus_init -Main vmbus driver initialization routine.
489  *
490  * Here, we
491  *      - initialize the vmbus driver context
492  *      - invoke the vmbus hv main init routine
493  *      - get the irq resource
494  *      - retrieve the channel offers
495  */
496 static int vmbus_bus_init(int irq)
497 {
498         int ret;
499         unsigned int vector;
500
501         /* Hypervisor initialization...setup hypercall page..etc */
502         ret = hv_init();
503         if (ret != 0) {
504                 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
505                 return ret;
506         }
507
508         tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0);
509         tasklet_init(&event_dpc, vmbus_on_event, 0);
510
511         ret = bus_register(&hv_bus);
512         if (ret)
513                 goto err_cleanup;
514
515         ret = request_irq(irq, vmbus_isr, 0, driver_name, hv_acpi_dev);
516
517         if (ret != 0) {
518                 pr_err("Unable to request IRQ %d\n",
519                            irq);
520                 goto err_unregister;
521         }
522
523         vector = IRQ0_VECTOR + irq;
524
525         /*
526          * Notify the hypervisor of our irq and
527          * connect to the host.
528          */
529         on_each_cpu(hv_synic_init, (void *)&vector, 1);
530         ret = vmbus_connect();
531         if (ret)
532                 goto err_irq;
533
534         vmbus_request_offers();
535
536         return 0;
537
538 err_irq:
539         free_irq(irq, hv_acpi_dev);
540
541 err_unregister:
542         bus_unregister(&hv_bus);
543
544 err_cleanup:
545         hv_cleanup();
546
547         return ret;
548 }
549
550 /**
551  * __vmbus_child_driver_register - Register a vmbus's driver
552  * @drv: Pointer to driver structure you want to register
553  * @owner: owner module of the drv
554  * @mod_name: module name string
555  *
556  * Registers the given driver with Linux through the 'driver_register()' call
557  * and sets up the hyper-v vmbus handling for this driver.
558  * It will return the state of the 'driver_register()' call.
559  *
560  */
561 int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
562 {
563         int ret;
564
565         pr_info("registering driver %s\n", hv_driver->name);
566
567         ret = vmbus_exists();
568         if (ret < 0)
569                 return ret;
570
571         hv_driver->driver.name = hv_driver->name;
572         hv_driver->driver.owner = owner;
573         hv_driver->driver.mod_name = mod_name;
574         hv_driver->driver.bus = &hv_bus;
575
576         ret = driver_register(&hv_driver->driver);
577
578         vmbus_request_offers();
579
580         return ret;
581 }
582 EXPORT_SYMBOL_GPL(__vmbus_driver_register);
583
584 /**
585  * vmbus_driver_unregister() - Unregister a vmbus's driver
586  * @drv: Pointer to driver structure you want to un-register
587  *
588  * Un-register the given driver that was previous registered with a call to
589  * vmbus_driver_register()
590  */
591 void vmbus_driver_unregister(struct hv_driver *hv_driver)
592 {
593         pr_info("unregistering driver %s\n", hv_driver->name);
594
595         if (!vmbus_exists())
596                 driver_unregister(&hv_driver->driver);
597 }
598 EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
599
600 /*
601  * vmbus_device_create - Creates and registers a new child device
602  * on the vmbus.
603  */
604 struct hv_device *vmbus_device_create(uuid_le *type,
605                                             uuid_le *instance,
606                                             struct vmbus_channel *channel)
607 {
608         struct hv_device *child_device_obj;
609
610         child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
611         if (!child_device_obj) {
612                 pr_err("Unable to allocate device object for child device\n");
613                 return NULL;
614         }
615
616         child_device_obj->channel = channel;
617         memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
618         memcpy(&child_device_obj->dev_instance, instance,
619                sizeof(uuid_le));
620
621
622         return child_device_obj;
623 }
624
625 /*
626  * vmbus_device_register - Register the child device
627  */
628 int vmbus_device_register(struct hv_device *child_device_obj)
629 {
630         int ret = 0;
631
632         static atomic_t device_num = ATOMIC_INIT(0);
633
634         dev_set_name(&child_device_obj->device, "vmbus_0_%d",
635                      atomic_inc_return(&device_num));
636
637         child_device_obj->device.bus = &hv_bus;
638         child_device_obj->device.parent = &hv_acpi_dev->dev;
639         child_device_obj->device.release = vmbus_device_release;
640
641         /*
642          * Register with the LDM. This will kick off the driver/device
643          * binding...which will eventually call vmbus_match() and vmbus_probe()
644          */
645         ret = device_register(&child_device_obj->device);
646
647         if (ret)
648                 pr_err("Unable to register child device\n");
649         else
650                 pr_info("child device %s registered\n",
651                         dev_name(&child_device_obj->device));
652
653         return ret;
654 }
655
656 /*
657  * vmbus_device_unregister - Remove the specified child device
658  * from the vmbus.
659  */
660 void vmbus_device_unregister(struct hv_device *device_obj)
661 {
662         /*
663          * Kick off the process of unregistering the device.
664          * This will call vmbus_remove() and eventually vmbus_device_release()
665          */
666         device_unregister(&device_obj->device);
667
668         pr_info("child device %s unregistered\n",
669                 dev_name(&device_obj->device));
670 }
671
672
673 /*
674  * VMBUS is an acpi enumerated device. Get the the IRQ information
675  * from DSDT.
676  */
677
678 static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *irq)
679 {
680
681         if (res->type == ACPI_RESOURCE_TYPE_IRQ) {
682                 struct acpi_resource_irq *irqp;
683                 irqp = &res->data.irq;
684
685                 *((unsigned int *)irq) = irqp->interrupts[0];
686         }
687
688         return AE_OK;
689 }
690
691 static int vmbus_acpi_add(struct acpi_device *device)
692 {
693         acpi_status result;
694
695         hv_acpi_dev = device;
696
697         result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
698                                         vmbus_walk_resources, &irq);
699
700         if (ACPI_FAILURE(result)) {
701                 complete(&probe_event);
702                 return -ENODEV;
703         }
704         complete(&probe_event);
705         return 0;
706 }
707
708 static const struct acpi_device_id vmbus_acpi_device_ids[] = {
709         {"VMBUS", 0},
710         {"VMBus", 0},
711         {"", 0},
712 };
713 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
714
715 static struct acpi_driver vmbus_acpi_driver = {
716         .name = "vmbus",
717         .ids = vmbus_acpi_device_ids,
718         .ops = {
719                 .add = vmbus_acpi_add,
720         },
721 };
722
723 static int __init hv_acpi_init(void)
724 {
725         int ret, t;
726
727         if (x86_hyper != &x86_hyper_ms_hyperv)
728                 return -ENODEV;
729
730         init_completion(&probe_event);
731
732         /*
733          * Get irq resources first.
734          */
735
736         ret = acpi_bus_register_driver(&vmbus_acpi_driver);
737
738         if (ret)
739                 return ret;
740
741         t = wait_for_completion_timeout(&probe_event, 5*HZ);
742         if (t == 0) {
743                 ret = -ETIMEDOUT;
744                 goto cleanup;
745         }
746
747         if (irq <= 0) {
748                 ret = -ENODEV;
749                 goto cleanup;
750         }
751
752         ret = vmbus_bus_init(irq);
753         if (ret)
754                 goto cleanup;
755
756         return 0;
757
758 cleanup:
759         acpi_bus_unregister_driver(&vmbus_acpi_driver);
760         hv_acpi_dev = NULL;
761         return ret;
762 }
763
764 static void __exit vmbus_exit(void)
765 {
766
767         free_irq(irq, hv_acpi_dev);
768         vmbus_free_channels();
769         bus_unregister(&hv_bus);
770         hv_cleanup();
771         acpi_bus_unregister_driver(&vmbus_acpi_driver);
772 }
773
774
775 MODULE_LICENSE("GPL");
776 MODULE_VERSION(HV_DRV_VERSION);
777
778 subsys_initcall(hv_acpi_init);
779 module_exit(vmbus_exit);