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