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