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 <linux/completion.h>
  34 #include <linux/hyperv.h>
  35 #include <linux/kernel_stat.h>
  36 #include <asm/hyperv.h>
  37 #include <asm/hypervisor.h>
  38 #include <asm/mshyperv.h>
  39 #include "hyperv_vmbus.h"
  40
  41 static struct acpi_device  *hv_acpi_dev;
  42
  43 static struct tasklet_struct msg_dpc;
  44 static struct completion probe_event;
  45 static int irq;
  46
  47 struct resource hyperv_mmio = {
  48         .name  = "hyperv mmio",
  49         .flags = IORESOURCE_MEM,
  50 };
  51 EXPORT_SYMBOL_GPL(hyperv_mmio);
  52
  53 static int vmbus_exists(void)
  54 {
  55         if (hv_acpi_dev == NULL)
  56                 return -ENODEV;
  57
  58         return 0;
  59 }
  60
  61 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
  62 static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
  63 {
  64         int i;
  65         for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
  66                 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
  67 }
  68
  69 static u8 channel_monitor_group(struct vmbus_channel *channel)
  70 {
  71         return (u8)channel->offermsg.monitorid / 32;
  72 }
  73
  74 static u8 channel_monitor_offset(struct vmbus_channel *channel)
  75 {
  76         return (u8)channel->offermsg.monitorid % 32;
  77 }
  78
  79 static u32 channel_pending(struct vmbus_channel *channel,
  80                            struct hv_monitor_page *monitor_page)
  81 {
  82         u8 monitor_group = channel_monitor_group(channel);
  83         return monitor_page->trigger_group[monitor_group].pending;
  84 }
  85
  86 static u32 channel_latency(struct vmbus_channel *channel,
  87                            struct hv_monitor_page *monitor_page)
  88 {
  89         u8 monitor_group = channel_monitor_group(channel);
  90         u8 monitor_offset = channel_monitor_offset(channel);
  91         return monitor_page->latency[monitor_group][monitor_offset];
  92 }
  93
  94 static u32 channel_conn_id(struct vmbus_channel *channel,
  95                            struct hv_monitor_page *monitor_page)
  96 {
  97         u8 monitor_group = channel_monitor_group(channel);
  98         u8 monitor_offset = channel_monitor_offset(channel);
  99         return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id;
 100 }
 101
 102 static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr,
 103                        char *buf)
 104 {
 105         struct hv_device *hv_dev = device_to_hv_device(dev);
 106
 107         if (!hv_dev->channel)
 108                 return -ENODEV;
 109         return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid);
 110 }
 111 static DEVICE_ATTR_RO(id);
 112
 113 static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr,
 114                           char *buf)
 115 {
 116         struct hv_device *hv_dev = device_to_hv_device(dev);
 117
 118         if (!hv_dev->channel)
 119                 return -ENODEV;
 120         return sprintf(buf, "%d\n", hv_dev->channel->state);
 121 }
 122 static DEVICE_ATTR_RO(state);
 123
 124 static ssize_t monitor_id_show(struct device *dev,
 125                                struct device_attribute *dev_attr, char *buf)
 126 {
 127         struct hv_device *hv_dev = device_to_hv_device(dev);
 128
 129         if (!hv_dev->channel)
 130                 return -ENODEV;
 131         return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid);
 132 }
 133 static DEVICE_ATTR_RO(monitor_id);
 134
 135 static ssize_t class_id_show(struct device *dev,
 136                                struct device_attribute *dev_attr, char *buf)
 137 {
 138         struct hv_device *hv_dev = device_to_hv_device(dev);
 139
 140         if (!hv_dev->channel)
 141                 return -ENODEV;
 142         return sprintf(buf, "{%pUl}\n",
 143                        hv_dev->channel->offermsg.offer.if_type.b);
 144 }
 145 static DEVICE_ATTR_RO(class_id);
 146
 147 static ssize_t device_id_show(struct device *dev,
 148                               struct device_attribute *dev_attr, char *buf)
 149 {
 150         struct hv_device *hv_dev = device_to_hv_device(dev);
 151
 152         if (!hv_dev->channel)
 153                 return -ENODEV;
 154         return sprintf(buf, "{%pUl}\n",
 155                        hv_dev->channel->offermsg.offer.if_instance.b);
 156 }
 157 static DEVICE_ATTR_RO(device_id);
 158
 159 static ssize_t modalias_show(struct device *dev,
 160                              struct device_attribute *dev_attr, char *buf)
 161 {
 162         struct hv_device *hv_dev = device_to_hv_device(dev);
 163         char alias_name[VMBUS_ALIAS_LEN + 1];
 164
 165         print_alias_name(hv_dev, alias_name);
 166         return sprintf(buf, "vmbus:%s\n", alias_name);
 167 }
 168 static DEVICE_ATTR_RO(modalias);
 169
 170 static ssize_t server_monitor_pending_show(struct device *dev,
 171                                            struct device_attribute *dev_attr,
 172                                            char *buf)
 173 {
 174         struct hv_device *hv_dev = device_to_hv_device(dev);
 175
 176         if (!hv_dev->channel)
 177                 return -ENODEV;
 178         return sprintf(buf, "%d\n",
 179                        channel_pending(hv_dev->channel,
 180                                        vmbus_connection.monitor_pages[1]));
 181 }
 182 static DEVICE_ATTR_RO(server_monitor_pending);
 183
 184 static ssize_t client_monitor_pending_show(struct device *dev,
 185                                            struct device_attribute *dev_attr,
 186                                            char *buf)
 187 {
 188         struct hv_device *hv_dev = device_to_hv_device(dev);
 189
 190         if (!hv_dev->channel)
 191                 return -ENODEV;
 192         return sprintf(buf, "%d\n",
 193                        channel_pending(hv_dev->channel,
 194                                        vmbus_connection.monitor_pages[1]));
 195 }
 196 static DEVICE_ATTR_RO(client_monitor_pending);
 197
 198 static ssize_t server_monitor_latency_show(struct device *dev,
 199                                            struct device_attribute *dev_attr,
 200                                            char *buf)
 201 {
 202         struct hv_device *hv_dev = device_to_hv_device(dev);
 203
 204         if (!hv_dev->channel)
 205                 return -ENODEV;
 206         return sprintf(buf, "%d\n",
 207                        channel_latency(hv_dev->channel,
 208                                        vmbus_connection.monitor_pages[0]));
 209 }
 210 static DEVICE_ATTR_RO(server_monitor_latency);
 211
 212 static ssize_t client_monitor_latency_show(struct device *dev,
 213                                            struct device_attribute *dev_attr,
 214                                            char *buf)
 215 {
 216         struct hv_device *hv_dev = device_to_hv_device(dev);
 217
 218         if (!hv_dev->channel)
 219                 return -ENODEV;
 220         return sprintf(buf, "%d\n",
 221                        channel_latency(hv_dev->channel,
 222                                        vmbus_connection.monitor_pages[1]));
 223 }
 224 static DEVICE_ATTR_RO(client_monitor_latency);
 225
 226 static ssize_t server_monitor_conn_id_show(struct device *dev,
 227                                            struct device_attribute *dev_attr,
 228                                            char *buf)
 229 {
 230         struct hv_device *hv_dev = device_to_hv_device(dev);
 231
 232         if (!hv_dev->channel)
 233                 return -ENODEV;
 234         return sprintf(buf, "%d\n",
 235                        channel_conn_id(hv_dev->channel,
 236                                        vmbus_connection.monitor_pages[0]));
 237 }
 238 static DEVICE_ATTR_RO(server_monitor_conn_id);
 239
 240 static ssize_t client_monitor_conn_id_show(struct device *dev,
 241                                            struct device_attribute *dev_attr,
 242                                            char *buf)
 243 {
 244         struct hv_device *hv_dev = device_to_hv_device(dev);
 245
 246         if (!hv_dev->channel)
 247                 return -ENODEV;
 248         return sprintf(buf, "%d\n",
 249                        channel_conn_id(hv_dev->channel,
 250                                        vmbus_connection.monitor_pages[1]));
 251 }
 252 static DEVICE_ATTR_RO(client_monitor_conn_id);
 253
 254 static ssize_t out_intr_mask_show(struct device *dev,
 255                                   struct device_attribute *dev_attr, char *buf)
 256 {
 257         struct hv_device *hv_dev = device_to_hv_device(dev);
 258         struct hv_ring_buffer_debug_info outbound;
 259
 260         if (!hv_dev->channel)
 261                 return -ENODEV;
 262         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
 263         return sprintf(buf, "%d\n", outbound.current_interrupt_mask);
 264 }
 265 static DEVICE_ATTR_RO(out_intr_mask);
 266
 267 static ssize_t out_read_index_show(struct device *dev,
 268                                    struct device_attribute *dev_attr, char *buf)
 269 {
 270         struct hv_device *hv_dev = device_to_hv_device(dev);
 271         struct hv_ring_buffer_debug_info outbound;
 272
 273         if (!hv_dev->channel)
 274                 return -ENODEV;
 275         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
 276         return sprintf(buf, "%d\n", outbound.current_read_index);
 277 }
 278 static DEVICE_ATTR_RO(out_read_index);
 279
 280 static ssize_t out_write_index_show(struct device *dev,
 281                                     struct device_attribute *dev_attr,
 282                                     char *buf)
 283 {
 284         struct hv_device *hv_dev = device_to_hv_device(dev);
 285         struct hv_ring_buffer_debug_info outbound;
 286
 287         if (!hv_dev->channel)
 288                 return -ENODEV;
 289         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
 290         return sprintf(buf, "%d\n", outbound.current_write_index);
 291 }
 292 static DEVICE_ATTR_RO(out_write_index);
 293
 294 static ssize_t out_read_bytes_avail_show(struct device *dev,
 295                                          struct device_attribute *dev_attr,
 296                                          char *buf)
 297 {
 298         struct hv_device *hv_dev = device_to_hv_device(dev);
 299         struct hv_ring_buffer_debug_info outbound;
 300
 301         if (!hv_dev->channel)
 302                 return -ENODEV;
 303         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
 304         return sprintf(buf, "%d\n", outbound.bytes_avail_toread);
 305 }
 306 static DEVICE_ATTR_RO(out_read_bytes_avail);
 307
 308 static ssize_t out_write_bytes_avail_show(struct device *dev,
 309                                           struct device_attribute *dev_attr,
 310                                           char *buf)
 311 {
 312         struct hv_device *hv_dev = device_to_hv_device(dev);
 313         struct hv_ring_buffer_debug_info outbound;
 314
 315         if (!hv_dev->channel)
 316                 return -ENODEV;
 317         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
 318         return sprintf(buf, "%d\n", outbound.bytes_avail_towrite);
 319 }
 320 static DEVICE_ATTR_RO(out_write_bytes_avail);
 321
 322 static ssize_t in_intr_mask_show(struct device *dev,
 323                                  struct device_attribute *dev_attr, char *buf)
 324 {
 325         struct hv_device *hv_dev = device_to_hv_device(dev);
 326         struct hv_ring_buffer_debug_info inbound;
 327
 328         if (!hv_dev->channel)
 329                 return -ENODEV;
 330         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
 331         return sprintf(buf, "%d\n", inbound.current_interrupt_mask);
 332 }
 333 static DEVICE_ATTR_RO(in_intr_mask);
 334
 335 static ssize_t in_read_index_show(struct device *dev,
 336                                   struct device_attribute *dev_attr, char *buf)
 337 {
 338         struct hv_device *hv_dev = device_to_hv_device(dev);
 339         struct hv_ring_buffer_debug_info inbound;
 340
 341         if (!hv_dev->channel)
 342                 return -ENODEV;
 343         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
 344         return sprintf(buf, "%d\n", inbound.current_read_index);
 345 }
 346 static DEVICE_ATTR_RO(in_read_index);
 347
 348 static ssize_t in_write_index_show(struct device *dev,
 349                                    struct device_attribute *dev_attr, char *buf)
 350 {
 351         struct hv_device *hv_dev = device_to_hv_device(dev);
 352         struct hv_ring_buffer_debug_info inbound;
 353
 354         if (!hv_dev->channel)
 355                 return -ENODEV;
 356         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
 357         return sprintf(buf, "%d\n", inbound.current_write_index);
 358 }
 359 static DEVICE_ATTR_RO(in_write_index);
 360
 361 static ssize_t in_read_bytes_avail_show(struct device *dev,
 362                                         struct device_attribute *dev_attr,
 363                                         char *buf)
 364 {
 365         struct hv_device *hv_dev = device_to_hv_device(dev);
 366         struct hv_ring_buffer_debug_info inbound;
 367
 368         if (!hv_dev->channel)
 369                 return -ENODEV;
 370         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
 371         return sprintf(buf, "%d\n", inbound.bytes_avail_toread);
 372 }
 373 static DEVICE_ATTR_RO(in_read_bytes_avail);
 374
 375 static ssize_t in_write_bytes_avail_show(struct device *dev,
 376                                          struct device_attribute *dev_attr,
 377                                          char *buf)
 378 {
 379         struct hv_device *hv_dev = device_to_hv_device(dev);
 380         struct hv_ring_buffer_debug_info inbound;
 381
 382         if (!hv_dev->channel)
 383                 return -ENODEV;
 384         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
 385         return sprintf(buf, "%d\n", inbound.bytes_avail_towrite);
 386 }
 387 static DEVICE_ATTR_RO(in_write_bytes_avail);
 388
 389 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
 390 static struct attribute *vmbus_attrs[] = {
 391         &dev_attr_id.attr,
 392         &dev_attr_state.attr,
 393         &dev_attr_monitor_id.attr,
 394         &dev_attr_class_id.attr,
 395         &dev_attr_device_id.attr,
 396         &dev_attr_modalias.attr,
 397         &dev_attr_server_monitor_pending.attr,
 398         &dev_attr_client_monitor_pending.attr,
 399         &dev_attr_server_monitor_latency.attr,
 400         &dev_attr_client_monitor_latency.attr,
 401         &dev_attr_server_monitor_conn_id.attr,
 402         &dev_attr_client_monitor_conn_id.attr,
 403         &dev_attr_out_intr_mask.attr,
 404         &dev_attr_out_read_index.attr,
 405         &dev_attr_out_write_index.attr,
 406         &dev_attr_out_read_bytes_avail.attr,
 407         &dev_attr_out_write_bytes_avail.attr,
 408         &dev_attr_in_intr_mask.attr,
 409         &dev_attr_in_read_index.attr,
 410         &dev_attr_in_write_index.attr,
 411         &dev_attr_in_read_bytes_avail.attr,
 412         &dev_attr_in_write_bytes_avail.attr,
 413         NULL,
 414 };
 415 ATTRIBUTE_GROUPS(vmbus);
 416
 417 /*
 418  * vmbus_uevent - add uevent for our device
 419  *
 420  * This routine is invoked when a device is added or removed on the vmbus to
 421  * generate a uevent to udev in the userspace. The udev will then look at its
 422  * rule and the uevent generated here to load the appropriate driver
 423  *
 424  * The alias string will be of the form vmbus:guid where guid is the string
 425  * representation of the device guid (each byte of the guid will be
 426  * represented with two hex characters.
 427  */
 428 static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
 429 {
 430         struct hv_device *dev = device_to_hv_device(device);
 431         int ret;
 432         char alias_name[VMBUS_ALIAS_LEN + 1];
 433
 434         print_alias_name(dev, alias_name);
 435         ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
 436         return ret;
 437 }
 438
 439 static uuid_le null_guid;
 440
 441 static inline bool is_null_guid(const __u8 *guid)
 442 {
 443         if (memcmp(guid, &null_guid, sizeof(uuid_le)))
 444                 return false;
 445         return true;
 446 }
 447
 448 /*
 449  * Return a matching hv_vmbus_device_id pointer.
 450  * If there is no match, return NULL.
 451  */
 452 static const struct hv_vmbus_device_id *hv_vmbus_get_id(
 453                                         const struct hv_vmbus_device_id *id,
 454                                         __u8 *guid)
 455 {
 456         for (; !is_null_guid(id->guid); id++)
 457                 if (!memcmp(&id->guid, guid, sizeof(uuid_le)))
 458                         return id;
 459
 460         return NULL;
 461 }
 462
 463
 464
 465 /*
 466  * vmbus_match - Attempt to match the specified device to the specified driver
 467  */
 468 static int vmbus_match(struct device *device, struct device_driver *driver)
 469 {
 470         struct hv_driver *drv = drv_to_hv_drv(driver);
 471         struct hv_device *hv_dev = device_to_hv_device(device);
 472
 473         if (hv_vmbus_get_id(drv->id_table, hv_dev->dev_type.b))
 474                 return 1;
 475
 476         return 0;
 477 }
 478
 479 /*
 480  * vmbus_probe - Add the new vmbus's child device
 481  */
 482 static int vmbus_probe(struct device *child_device)
 483 {
 484         int ret = 0;
 485         struct hv_driver *drv =
 486                         drv_to_hv_drv(child_device->driver);
 487         struct hv_device *dev = device_to_hv_device(child_device);
 488         const struct hv_vmbus_device_id *dev_id;
 489
 490         dev_id = hv_vmbus_get_id(drv->id_table, dev->dev_type.b);
 491         if (drv->probe) {
 492                 ret = drv->probe(dev, dev_id);
 493                 if (ret != 0)
 494                         pr_err("probe failed for device %s (%d)\n",
 495                                dev_name(child_device), ret);
 496
 497         } else {
 498                 pr_err("probe not set for driver %s\n",
 499                        dev_name(child_device));
 500                 ret = -ENODEV;
 501         }
 502         return ret;
 503 }
 504
 505 /*
 506  * vmbus_remove - Remove a vmbus device
 507  */
 508 static int vmbus_remove(struct device *child_device)
 509 {
 510         struct hv_driver *drv = drv_to_hv_drv(child_device->driver);
 511         struct hv_device *dev = device_to_hv_device(child_device);
 512
 513         if (drv->remove)
 514                 drv->remove(dev);
 515         else
 516                 pr_err("remove not set for driver %s\n",
 517                         dev_name(child_device));
 518
 519         return 0;
 520 }
 521
 522
 523 /*
 524  * vmbus_shutdown - Shutdown a vmbus device
 525  */
 526 static void vmbus_shutdown(struct device *child_device)
 527 {
 528         struct hv_driver *drv;
 529         struct hv_device *dev = device_to_hv_device(child_device);
 530
 531
 532         /* The device may not be attached yet */
 533         if (!child_device->driver)
 534                 return;
 535
 536         drv = drv_to_hv_drv(child_device->driver);
 537
 538         if (drv->shutdown)
 539                 drv->shutdown(dev);
 540
 541         return;
 542 }
 543
 544
 545 /*
 546  * vmbus_device_release - Final callback release of the vmbus child device
 547  */
 548 static void vmbus_device_release(struct device *device)
 549 {
 550         struct hv_device *hv_dev = device_to_hv_device(device);
 551
 552         kfree(hv_dev);
 553
 554 }
 555
 556 /* The one and only one */
 557 static struct bus_type  hv_bus = {
 558         .name =         "vmbus",
 559         .match =                vmbus_match,
 560         .shutdown =             vmbus_shutdown,
 561         .remove =               vmbus_remove,
 562         .probe =                vmbus_probe,
 563         .uevent =               vmbus_uevent,
 564         .dev_groups =           vmbus_groups,
 565 };
 566
 567 static const char *driver_name = "hyperv";
 568
 569
 570 struct onmessage_work_context {
 571         struct work_struct work;
 572         struct hv_message msg;
 573 };
 574
 575 static void vmbus_onmessage_work(struct work_struct *work)
 576 {
 577         struct onmessage_work_context *ctx;
 578
 579         ctx = container_of(work, struct onmessage_work_context,
 580                            work);
 581         vmbus_onmessage(&ctx->msg);
 582         kfree(ctx);
 583 }
 584
 585 static void vmbus_on_msg_dpc(unsigned long data)
 586 {
 587         int cpu = smp_processor_id();
 588         void *page_addr = hv_context.synic_message_page[cpu];
 589         struct hv_message *msg = (struct hv_message *)page_addr +
 590                                   VMBUS_MESSAGE_SINT;
 591         struct onmessage_work_context *ctx;
 592
 593         while (1) {
 594                 if (msg->header.message_type == HVMSG_NONE) {
 595                         /* no msg */
 596                         break;
 597                 } else {
 598                         ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
 599                         if (ctx == NULL)
 600                                 continue;
 601                         INIT_WORK(&ctx->work, vmbus_onmessage_work);
 602                         memcpy(&ctx->msg, msg, sizeof(*msg));
 603                         queue_work(vmbus_connection.work_queue, &ctx->work);
 604                 }
 605
 606                 msg->header.message_type = HVMSG_NONE;
 607
 608                 /*
 609                  * Make sure the write to MessageType (ie set to
 610                  * HVMSG_NONE) happens before we read the
 611                  * MessagePending and EOMing. Otherwise, the EOMing
 612                  * will not deliver any more messages since there is
 613                  * no empty slot
 614                  */
 615                 mb();
 616
 617                 if (msg->header.message_flags.msg_pending) {
 618                         /*
 619                          * This will cause message queue rescan to
 620                          * possibly deliver another msg from the
 621                          * hypervisor
 622                          */
 623                         wrmsrl(HV_X64_MSR_EOM, 0);
 624                 }
 625         }
 626 }
 627
 628 static irqreturn_t vmbus_isr(int irq, void *dev_id)
 629 {
 630         int cpu = smp_processor_id();
 631         void *page_addr;
 632         struct hv_message *msg;
 633         union hv_synic_event_flags *event;
 634         bool handled = false;
 635
 636         page_addr = hv_context.synic_event_page[cpu];
 637         if (page_addr == NULL)
 638                 return IRQ_NONE;
 639
 640         event = (union hv_synic_event_flags *)page_addr +
 641                                          VMBUS_MESSAGE_SINT;
 642         /*
 643          * Check for events before checking for messages. This is the order
 644          * in which events and messages are checked in Windows guests on
 645          * Hyper-V, and the Windows team suggested we do the same.
 646          */
 647
 648         if ((vmbus_proto_version == VERSION_WS2008) ||
 649                 (vmbus_proto_version == VERSION_WIN7)) {
 650
 651                 /* Since we are a child, we only need to check bit 0 */
 652                 if (sync_test_and_clear_bit(0,
 653                         (unsigned long *) &event->flags32[0])) {
 654                         handled = true;
 655                 }
 656         } else {
 657                 /*
 658                  * Our host is win8 or above. The signaling mechanism
 659                  * has changed and we can directly look at the event page.
 660                  * If bit n is set then we have an interrup on the channel
 661                  * whose id is n.
 662                  */
 663                 handled = true;
 664         }
 665
 666         if (handled)
 667                 tasklet_schedule(hv_context.event_dpc[cpu]);
 668
 669
 670         page_addr = hv_context.synic_message_page[cpu];
 671         msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
 672
 673         /* Check if there are actual msgs to be processed */
 674         if (msg->header.message_type != HVMSG_NONE) {
 675                 handled = true;
 676                 tasklet_schedule(&msg_dpc);
 677         }
 678
 679         if (handled)
 680                 return IRQ_HANDLED;
 681         else
 682                 return IRQ_NONE;
 683 }
 684
 685 /*
 686  * vmbus interrupt flow handler:
 687  * vmbus interrupts can concurrently occur on multiple CPUs and
 688  * can be handled concurrently.
 689  */
 690
 691 static void vmbus_flow_handler(unsigned int irq, struct irq_desc *desc)
 692 {
 693         kstat_incr_irqs_this_cpu(irq, desc);
 694
 695         desc->action->handler(irq, desc->action->dev_id);
 696 }
 697
 698 /*
 699  * vmbus_bus_init -Main vmbus driver initialization routine.
 700  *
 701  * Here, we
 702  *      - initialize the vmbus driver context
 703  *      - invoke the vmbus hv main init routine
 704  *      - get the irq resource
 705  *      - retrieve the channel offers
 706  */
 707 static int vmbus_bus_init(int irq)
 708 {
 709         int ret;
 710
 711         /* Hypervisor initialization...setup hypercall page..etc */
 712         ret = hv_init();
 713         if (ret != 0) {
 714                 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
 715                 return ret;
 716         }
 717
 718         tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0);
 719
 720         ret = bus_register(&hv_bus);
 721         if (ret)
 722                 goto err_cleanup;
 723
 724         ret = request_irq(irq, vmbus_isr, 0, driver_name, hv_acpi_dev);
 725
 726         if (ret != 0) {
 727                 pr_err("Unable to request IRQ %d\n",
 728                            irq);
 729                 goto err_unregister;
 730         }
 731
 732         /*
 733          * Vmbus interrupts can be handled concurrently on
 734          * different CPUs. Establish an appropriate interrupt flow
 735          * handler that can support this model.
 736          */
 737         irq_set_handler(irq, vmbus_flow_handler);
 738
 739         /*
 740          * Register our interrupt handler.
 741          */
 742         hv_register_vmbus_handler(irq, vmbus_isr);
 743
 744         ret = hv_synic_alloc();
 745         if (ret)
 746                 goto err_alloc;
 747         /*
 748          * Initialize the per-cpu interrupt state and
 749          * connect to the host.
 750          */
 751         on_each_cpu(hv_synic_init, NULL, 1);
 752         ret = vmbus_connect();
 753         if (ret)
 754                 goto err_alloc;
 755
 756         vmbus_request_offers();
 757
 758         return 0;
 759
 760 err_alloc:
 761         hv_synic_free();
 762         free_irq(irq, hv_acpi_dev);
 763
 764 err_unregister:
 765         bus_unregister(&hv_bus);
 766
 767 err_cleanup:
 768         hv_cleanup();
 769
 770         return ret;
 771 }
 772
 773 /**
 774  * __vmbus_child_driver_register - Register a vmbus's driver
 775  * @drv: Pointer to driver structure you want to register
 776  * @owner: owner module of the drv
 777  * @mod_name: module name string
 778  *
 779  * Registers the given driver with Linux through the 'driver_register()' call
 780  * and sets up the hyper-v vmbus handling for this driver.
 781  * It will return the state of the 'driver_register()' call.
 782  *
 783  */
 784 int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
 785 {
 786         int ret;
 787
 788         pr_info("registering driver %s\n", hv_driver->name);
 789
 790         ret = vmbus_exists();
 791         if (ret < 0)
 792                 return ret;
 793
 794         hv_driver->driver.name = hv_driver->name;
 795         hv_driver->driver.owner = owner;
 796         hv_driver->driver.mod_name = mod_name;
 797         hv_driver->driver.bus = &hv_bus;
 798
 799         ret = driver_register(&hv_driver->driver);
 800
 801         return ret;
 802 }
 803 EXPORT_SYMBOL_GPL(__vmbus_driver_register);
 804
 805 /**
 806  * vmbus_driver_unregister() - Unregister a vmbus's driver
 807  * @drv: Pointer to driver structure you want to un-register
 808  *
 809  * Un-register the given driver that was previous registered with a call to
 810  * vmbus_driver_register()
 811  */
 812 void vmbus_driver_unregister(struct hv_driver *hv_driver)
 813 {
 814         pr_info("unregistering driver %s\n", hv_driver->name);
 815
 816         if (!vmbus_exists())
 817                 driver_unregister(&hv_driver->driver);
 818 }
 819 EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
 820
 821 /*
 822  * vmbus_device_create - Creates and registers a new child device
 823  * on the vmbus.
 824  */
 825 struct hv_device *vmbus_device_create(uuid_le *type,
 826                                             uuid_le *instance,
 827                                             struct vmbus_channel *channel)
 828 {
 829         struct hv_device *child_device_obj;
 830
 831         child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
 832         if (!child_device_obj) {
 833                 pr_err("Unable to allocate device object for child device\n");
 834                 return NULL;
 835         }
 836
 837         child_device_obj->channel = channel;
 838         memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
 839         memcpy(&child_device_obj->dev_instance, instance,
 840                sizeof(uuid_le));
 841
 842
 843         return child_device_obj;
 844 }
 845
 846 /*
 847  * vmbus_device_register - Register the child device
 848  */
 849 int vmbus_device_register(struct hv_device *child_device_obj)
 850 {
 851         int ret = 0;
 852
 853         static atomic_t device_num = ATOMIC_INIT(0);
 854
 855         dev_set_name(&child_device_obj->device, "vmbus_0_%d",
 856                      atomic_inc_return(&device_num));
 857
 858         child_device_obj->device.bus = &hv_bus;
 859         child_device_obj->device.parent = &hv_acpi_dev->dev;
 860         child_device_obj->device.release = vmbus_device_release;
 861
 862         /*
 863          * Register with the LDM. This will kick off the driver/device
 864          * binding...which will eventually call vmbus_match() and vmbus_probe()
 865          */
 866         ret = device_register(&child_device_obj->device);
 867
 868         if (ret)
 869                 pr_err("Unable to register child device\n");
 870         else
 871                 pr_debug("child device %s registered\n",
 872                         dev_name(&child_device_obj->device));
 873
 874         return ret;
 875 }
 876
 877 /*
 878  * vmbus_device_unregister - Remove the specified child device
 879  * from the vmbus.
 880  */
 881 void vmbus_device_unregister(struct hv_device *device_obj)
 882 {
 883         pr_debug("child device %s unregistered\n",
 884                 dev_name(&device_obj->device));
 885
 886         /*
 887          * Kick off the process of unregistering the device.
 888          * This will call vmbus_remove() and eventually vmbus_device_release()
 889          */
 890         device_unregister(&device_obj->device);
 891 }
 892
 893
 894 /*
 895  * VMBUS is an acpi enumerated device. Get the the information we
 896  * need from DSDT.
 897  */
 898
 899 static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *ctx)
 900 {
 901         switch (res->type) {
 902         case ACPI_RESOURCE_TYPE_IRQ:
 903                 irq = res->data.irq.interrupts[0];
 904                 break;
 905
 906         case ACPI_RESOURCE_TYPE_ADDRESS64:
 907                 hyperv_mmio.start = res->data.address64.minimum;
 908                 hyperv_mmio.end = res->data.address64.maximum;
 909                 break;
 910         }
 911
 912         return AE_OK;
 913 }
 914
 915 static int vmbus_acpi_add(struct acpi_device *device)
 916 {
 917         acpi_status result;
 918         int ret_val = -ENODEV;
 919
 920         hv_acpi_dev = device;
 921
 922         result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
 923                                         vmbus_walk_resources, NULL);
 924
 925         if (ACPI_FAILURE(result))
 926                 goto acpi_walk_err;
 927         /*
 928          * The parent of the vmbus acpi device (Gen2 firmware) is the VMOD that
 929          * has the mmio ranges. Get that.
 930          */
 931         if (device->parent) {
 932                 result = acpi_walk_resources(device->parent->handle,
 933                                         METHOD_NAME__CRS,
 934                                         vmbus_walk_resources, NULL);
 935
 936                 if (ACPI_FAILURE(result))
 937                         goto acpi_walk_err;
 938                 if (hyperv_mmio.start && hyperv_mmio.end)
 939                         request_resource(&iomem_resource, &hyperv_mmio);
 940         }
 941         ret_val = 0;
 942
 943 acpi_walk_err:
 944         complete(&probe_event);
 945         return ret_val;
 946 }
 947
 948 static const struct acpi_device_id vmbus_acpi_device_ids[] = {
 949         {"VMBUS", 0},
 950         {"VMBus", 0},
 951         {"", 0},
 952 };
 953 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
 954
 955 static struct acpi_driver vmbus_acpi_driver = {
 956         .name = "vmbus",
 957         .ids = vmbus_acpi_device_ids,
 958         .ops = {
 959                 .add = vmbus_acpi_add,
 960         },
 961 };
 962
 963 static int __init hv_acpi_init(void)
 964 {
 965         int ret, t;
 966
 967         if (x86_hyper != &x86_hyper_ms_hyperv)
 968                 return -ENODEV;
 969
 970         init_completion(&probe_event);
 971
 972         /*
 973          * Get irq resources first.
 974          */
 975
 976         ret = acpi_bus_register_driver(&vmbus_acpi_driver);
 977
 978         if (ret)
 979                 return ret;
 980
 981         t = wait_for_completion_timeout(&probe_event, 5*HZ);
 982         if (t == 0) {
 983                 ret = -ETIMEDOUT;
 984                 goto cleanup;
 985         }
 986
 987         if (irq <= 0) {
 988                 ret = -ENODEV;
 989                 goto cleanup;
 990         }
 991
 992         ret = vmbus_bus_init(irq);
 993         if (ret)
 994                 goto cleanup;
 995
 996         return 0;
 997
 998 cleanup:
 999         acpi_bus_unregister_driver(&vmbus_acpi_driver);
1000         hv_acpi_dev = NULL;
1001         return ret;
1002 }
1003
1004 static void __exit vmbus_exit(void)
1005 {
1006
1007         free_irq(irq, hv_acpi_dev);
1008         vmbus_free_channels();
1009         bus_unregister(&hv_bus);
1010         hv_cleanup();
1011         acpi_bus_unregister_driver(&vmbus_acpi_driver);
1012 }
1013
1014
1015 MODULE_LICENSE("GPL");
1016
1017 subsys_initcall(hv_acpi_init);
1018 module_exit(vmbus_exit);