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