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