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