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 <linux/notifier.h>
  41 #include <linux/ptrace.h>
  42 #include <linux/screen_info.h>
  43 #include <linux/kdebug.h>
  44 #include <linux/efi.h>
  45 #include <linux/random.h>
  46 #include "hyperv_vmbus.h"
  47
  48 static struct acpi_device  *hv_acpi_dev;
  49
  50 static struct completion probe_event;
  51
  52
  53 static void hyperv_report_panic(struct pt_regs *regs)
  54 {
  55         static bool panic_reported;
  56
  57         /*
  58          * We prefer to report panic on 'die' chain as we have proper
  59          * registers to report, but if we miss it (e.g. on BUG()) we need
  60          * to report it on 'panic'.
  61          */
  62         if (panic_reported)
  63                 return;
  64         panic_reported = true;
  65
  66         wrmsrl(HV_X64_MSR_CRASH_P0, regs->ip);
  67         wrmsrl(HV_X64_MSR_CRASH_P1, regs->ax);
  68         wrmsrl(HV_X64_MSR_CRASH_P2, regs->bx);
  69         wrmsrl(HV_X64_MSR_CRASH_P3, regs->cx);
  70         wrmsrl(HV_X64_MSR_CRASH_P4, regs->dx);
  71
  72         /*
  73          * Let Hyper-V know there is crash data available
  74          */
  75         wrmsrl(HV_X64_MSR_CRASH_CTL, HV_CRASH_CTL_CRASH_NOTIFY);
  76 }
  77
  78 static int hyperv_panic_event(struct notifier_block *nb, unsigned long val,
  79                               void *args)
  80 {
  81         struct pt_regs *regs;
  82
  83         regs = current_pt_regs();
  84
  85         hyperv_report_panic(regs);
  86         return NOTIFY_DONE;
  87 }
  88
  89 static int hyperv_die_event(struct notifier_block *nb, unsigned long val,
  90                             void *args)
  91 {
  92         struct die_args *die = (struct die_args *)args;
  93         struct pt_regs *regs = die->regs;
  94
  95         hyperv_report_panic(regs);
  96         return NOTIFY_DONE;
  97 }
  98
  99 static struct notifier_block hyperv_die_block = {
 100         .notifier_call = hyperv_die_event,
 101 };
 102 static struct notifier_block hyperv_panic_block = {
 103         .notifier_call = hyperv_panic_event,
 104 };
 105
 106 static const char *fb_mmio_name = "fb_range";
 107 static struct resource *fb_mmio;
 108 struct resource *hyperv_mmio;
 109 DEFINE_SEMAPHORE(hyperv_mmio_lock);
 110
 111 static int vmbus_exists(void)
 112 {
 113         if (hv_acpi_dev == NULL)
 114                 return -ENODEV;
 115
 116         return 0;
 117 }
 118
 119 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
 120 static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
 121 {
 122         int i;
 123         for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
 124                 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
 125 }
 126
 127 static u8 channel_monitor_group(struct vmbus_channel *channel)
 128 {
 129         return (u8)channel->offermsg.monitorid / 32;
 130 }
 131
 132 static u8 channel_monitor_offset(struct vmbus_channel *channel)
 133 {
 134         return (u8)channel->offermsg.monitorid % 32;
 135 }
 136
 137 static u32 channel_pending(struct vmbus_channel *channel,
 138                            struct hv_monitor_page *monitor_page)
 139 {
 140         u8 monitor_group = channel_monitor_group(channel);
 141         return monitor_page->trigger_group[monitor_group].pending;
 142 }
 143
 144 static u32 channel_latency(struct vmbus_channel *channel,
 145                            struct hv_monitor_page *monitor_page)
 146 {
 147         u8 monitor_group = channel_monitor_group(channel);
 148         u8 monitor_offset = channel_monitor_offset(channel);
 149         return monitor_page->latency[monitor_group][monitor_offset];
 150 }
 151
 152 static u32 channel_conn_id(struct vmbus_channel *channel,
 153                            struct hv_monitor_page *monitor_page)
 154 {
 155         u8 monitor_group = channel_monitor_group(channel);
 156         u8 monitor_offset = channel_monitor_offset(channel);
 157         return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id;
 158 }
 159
 160 static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr,
 161                        char *buf)
 162 {
 163         struct hv_device *hv_dev = device_to_hv_device(dev);
 164
 165         if (!hv_dev->channel)
 166                 return -ENODEV;
 167         return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid);
 168 }
 169 static DEVICE_ATTR_RO(id);
 170
 171 static ssize_t state_show(struct device *dev, 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", hv_dev->channel->state);
 179 }
 180 static DEVICE_ATTR_RO(state);
 181
 182 static ssize_t monitor_id_show(struct device *dev,
 183                                struct device_attribute *dev_attr, char *buf)
 184 {
 185         struct hv_device *hv_dev = device_to_hv_device(dev);
 186
 187         if (!hv_dev->channel)
 188                 return -ENODEV;
 189         return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid);
 190 }
 191 static DEVICE_ATTR_RO(monitor_id);
 192
 193 static ssize_t class_id_show(struct device *dev,
 194                                struct device_attribute *dev_attr, char *buf)
 195 {
 196         struct hv_device *hv_dev = device_to_hv_device(dev);
 197
 198         if (!hv_dev->channel)
 199                 return -ENODEV;
 200         return sprintf(buf, "{%pUl}\n",
 201                        hv_dev->channel->offermsg.offer.if_type.b);
 202 }
 203 static DEVICE_ATTR_RO(class_id);
 204
 205 static ssize_t device_id_show(struct device *dev,
 206                               struct device_attribute *dev_attr, char *buf)
 207 {
 208         struct hv_device *hv_dev = device_to_hv_device(dev);
 209
 210         if (!hv_dev->channel)
 211                 return -ENODEV;
 212         return sprintf(buf, "{%pUl}\n",
 213                        hv_dev->channel->offermsg.offer.if_instance.b);
 214 }
 215 static DEVICE_ATTR_RO(device_id);
 216
 217 static ssize_t modalias_show(struct device *dev,
 218                              struct device_attribute *dev_attr, char *buf)
 219 {
 220         struct hv_device *hv_dev = device_to_hv_device(dev);
 221         char alias_name[VMBUS_ALIAS_LEN + 1];
 222
 223         print_alias_name(hv_dev, alias_name);
 224         return sprintf(buf, "vmbus:%s\n", alias_name);
 225 }
 226 static DEVICE_ATTR_RO(modalias);
 227
 228 static ssize_t server_monitor_pending_show(struct device *dev,
 229                                            struct device_attribute *dev_attr,
 230                                            char *buf)
 231 {
 232         struct hv_device *hv_dev = device_to_hv_device(dev);
 233
 234         if (!hv_dev->channel)
 235                 return -ENODEV;
 236         return sprintf(buf, "%d\n",
 237                        channel_pending(hv_dev->channel,
 238                                        vmbus_connection.monitor_pages[1]));
 239 }
 240 static DEVICE_ATTR_RO(server_monitor_pending);
 241
 242 static ssize_t client_monitor_pending_show(struct device *dev,
 243                                            struct device_attribute *dev_attr,
 244                                            char *buf)
 245 {
 246         struct hv_device *hv_dev = device_to_hv_device(dev);
 247
 248         if (!hv_dev->channel)
 249                 return -ENODEV;
 250         return sprintf(buf, "%d\n",
 251                        channel_pending(hv_dev->channel,
 252                                        vmbus_connection.monitor_pages[1]));
 253 }
 254 static DEVICE_ATTR_RO(client_monitor_pending);
 255
 256 static ssize_t server_monitor_latency_show(struct device *dev,
 257                                            struct device_attribute *dev_attr,
 258                                            char *buf)
 259 {
 260         struct hv_device *hv_dev = device_to_hv_device(dev);
 261
 262         if (!hv_dev->channel)
 263                 return -ENODEV;
 264         return sprintf(buf, "%d\n",
 265                        channel_latency(hv_dev->channel,
 266                                        vmbus_connection.monitor_pages[0]));
 267 }
 268 static DEVICE_ATTR_RO(server_monitor_latency);
 269
 270 static ssize_t client_monitor_latency_show(struct device *dev,
 271                                            struct device_attribute *dev_attr,
 272                                            char *buf)
 273 {
 274         struct hv_device *hv_dev = device_to_hv_device(dev);
 275
 276         if (!hv_dev->channel)
 277                 return -ENODEV;
 278         return sprintf(buf, "%d\n",
 279                        channel_latency(hv_dev->channel,
 280                                        vmbus_connection.monitor_pages[1]));
 281 }
 282 static DEVICE_ATTR_RO(client_monitor_latency);
 283
 284 static ssize_t server_monitor_conn_id_show(struct device *dev,
 285                                            struct device_attribute *dev_attr,
 286                                            char *buf)
 287 {
 288         struct hv_device *hv_dev = device_to_hv_device(dev);
 289
 290         if (!hv_dev->channel)
 291                 return -ENODEV;
 292         return sprintf(buf, "%d\n",
 293                        channel_conn_id(hv_dev->channel,
 294                                        vmbus_connection.monitor_pages[0]));
 295 }
 296 static DEVICE_ATTR_RO(server_monitor_conn_id);
 297
 298 static ssize_t client_monitor_conn_id_show(struct device *dev,
 299                                            struct device_attribute *dev_attr,
 300                                            char *buf)
 301 {
 302         struct hv_device *hv_dev = device_to_hv_device(dev);
 303
 304         if (!hv_dev->channel)
 305                 return -ENODEV;
 306         return sprintf(buf, "%d\n",
 307                        channel_conn_id(hv_dev->channel,
 308                                        vmbus_connection.monitor_pages[1]));
 309 }
 310 static DEVICE_ATTR_RO(client_monitor_conn_id);
 311
 312 static ssize_t out_intr_mask_show(struct device *dev,
 313                                   struct device_attribute *dev_attr, char *buf)
 314 {
 315         struct hv_device *hv_dev = device_to_hv_device(dev);
 316         struct hv_ring_buffer_debug_info outbound;
 317
 318         if (!hv_dev->channel)
 319                 return -ENODEV;
 320         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
 321         return sprintf(buf, "%d\n", outbound.current_interrupt_mask);
 322 }
 323 static DEVICE_ATTR_RO(out_intr_mask);
 324
 325 static ssize_t out_read_index_show(struct device *dev,
 326                                    struct device_attribute *dev_attr, char *buf)
 327 {
 328         struct hv_device *hv_dev = device_to_hv_device(dev);
 329         struct hv_ring_buffer_debug_info outbound;
 330
 331         if (!hv_dev->channel)
 332                 return -ENODEV;
 333         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
 334         return sprintf(buf, "%d\n", outbound.current_read_index);
 335 }
 336 static DEVICE_ATTR_RO(out_read_index);
 337
 338 static ssize_t out_write_index_show(struct device *dev,
 339                                     struct device_attribute *dev_attr,
 340                                     char *buf)
 341 {
 342         struct hv_device *hv_dev = device_to_hv_device(dev);
 343         struct hv_ring_buffer_debug_info outbound;
 344
 345         if (!hv_dev->channel)
 346                 return -ENODEV;
 347         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
 348         return sprintf(buf, "%d\n", outbound.current_write_index);
 349 }
 350 static DEVICE_ATTR_RO(out_write_index);
 351
 352 static ssize_t out_read_bytes_avail_show(struct device *dev,
 353                                          struct device_attribute *dev_attr,
 354                                          char *buf)
 355 {
 356         struct hv_device *hv_dev = device_to_hv_device(dev);
 357         struct hv_ring_buffer_debug_info outbound;
 358
 359         if (!hv_dev->channel)
 360                 return -ENODEV;
 361         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
 362         return sprintf(buf, "%d\n", outbound.bytes_avail_toread);
 363 }
 364 static DEVICE_ATTR_RO(out_read_bytes_avail);
 365
 366 static ssize_t out_write_bytes_avail_show(struct device *dev,
 367                                           struct device_attribute *dev_attr,
 368                                           char *buf)
 369 {
 370         struct hv_device *hv_dev = device_to_hv_device(dev);
 371         struct hv_ring_buffer_debug_info outbound;
 372
 373         if (!hv_dev->channel)
 374                 return -ENODEV;
 375         hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
 376         return sprintf(buf, "%d\n", outbound.bytes_avail_towrite);
 377 }
 378 static DEVICE_ATTR_RO(out_write_bytes_avail);
 379
 380 static ssize_t in_intr_mask_show(struct device *dev,
 381                                  struct device_attribute *dev_attr, char *buf)
 382 {
 383         struct hv_device *hv_dev = device_to_hv_device(dev);
 384         struct hv_ring_buffer_debug_info inbound;
 385
 386         if (!hv_dev->channel)
 387                 return -ENODEV;
 388         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
 389         return sprintf(buf, "%d\n", inbound.current_interrupt_mask);
 390 }
 391 static DEVICE_ATTR_RO(in_intr_mask);
 392
 393 static ssize_t in_read_index_show(struct device *dev,
 394                                   struct device_attribute *dev_attr, char *buf)
 395 {
 396         struct hv_device *hv_dev = device_to_hv_device(dev);
 397         struct hv_ring_buffer_debug_info inbound;
 398
 399         if (!hv_dev->channel)
 400                 return -ENODEV;
 401         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
 402         return sprintf(buf, "%d\n", inbound.current_read_index);
 403 }
 404 static DEVICE_ATTR_RO(in_read_index);
 405
 406 static ssize_t in_write_index_show(struct device *dev,
 407                                    struct device_attribute *dev_attr, char *buf)
 408 {
 409         struct hv_device *hv_dev = device_to_hv_device(dev);
 410         struct hv_ring_buffer_debug_info inbound;
 411
 412         if (!hv_dev->channel)
 413                 return -ENODEV;
 414         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
 415         return sprintf(buf, "%d\n", inbound.current_write_index);
 416 }
 417 static DEVICE_ATTR_RO(in_write_index);
 418
 419 static ssize_t in_read_bytes_avail_show(struct device *dev,
 420                                         struct device_attribute *dev_attr,
 421                                         char *buf)
 422 {
 423         struct hv_device *hv_dev = device_to_hv_device(dev);
 424         struct hv_ring_buffer_debug_info inbound;
 425
 426         if (!hv_dev->channel)
 427                 return -ENODEV;
 428         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
 429         return sprintf(buf, "%d\n", inbound.bytes_avail_toread);
 430 }
 431 static DEVICE_ATTR_RO(in_read_bytes_avail);
 432
 433 static ssize_t in_write_bytes_avail_show(struct device *dev,
 434                                          struct device_attribute *dev_attr,
 435                                          char *buf)
 436 {
 437         struct hv_device *hv_dev = device_to_hv_device(dev);
 438         struct hv_ring_buffer_debug_info inbound;
 439
 440         if (!hv_dev->channel)
 441                 return -ENODEV;
 442         hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
 443         return sprintf(buf, "%d\n", inbound.bytes_avail_towrite);
 444 }
 445 static DEVICE_ATTR_RO(in_write_bytes_avail);
 446
 447 static ssize_t channel_vp_mapping_show(struct device *dev,
 448                                        struct device_attribute *dev_attr,
 449                                        char *buf)
 450 {
 451         struct hv_device *hv_dev = device_to_hv_device(dev);
 452         struct vmbus_channel *channel = hv_dev->channel, *cur_sc;
 453         unsigned long flags;
 454         int buf_size = PAGE_SIZE, n_written, tot_written;
 455         struct list_head *cur;
 456
 457         if (!channel)
 458                 return -ENODEV;
 459
 460         tot_written = snprintf(buf, buf_size, "%u:%u\n",
 461                 channel->offermsg.child_relid, channel->target_cpu);
 462
 463         spin_lock_irqsave(&channel->lock, flags);
 464
 465         list_for_each(cur, &channel->sc_list) {
 466                 if (tot_written >= buf_size - 1)
 467                         break;
 468
 469                 cur_sc = list_entry(cur, struct vmbus_channel, sc_list);
 470                 n_written = scnprintf(buf + tot_written,
 471                                      buf_size - tot_written,
 472                                      "%u:%u\n",
 473                                      cur_sc->offermsg.child_relid,
 474                                      cur_sc->target_cpu);
 475                 tot_written += n_written;
 476         }
 477
 478         spin_unlock_irqrestore(&channel->lock, flags);
 479
 480         return tot_written;
 481 }
 482 static DEVICE_ATTR_RO(channel_vp_mapping);
 483
 484 static ssize_t vendor_show(struct device *dev,
 485                            struct device_attribute *dev_attr,
 486                            char *buf)
 487 {
 488         struct hv_device *hv_dev = device_to_hv_device(dev);
 489         return sprintf(buf, "0x%x\n", hv_dev->vendor_id);
 490 }
 491 static DEVICE_ATTR_RO(vendor);
 492
 493 static ssize_t device_show(struct device *dev,
 494                            struct device_attribute *dev_attr,
 495                            char *buf)
 496 {
 497         struct hv_device *hv_dev = device_to_hv_device(dev);
 498         return sprintf(buf, "0x%x\n", hv_dev->device_id);
 499 }
 500 static DEVICE_ATTR_RO(device);
 501
 502 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
 503 static struct attribute *vmbus_attrs[] = {
 504         &dev_attr_id.attr,
 505         &dev_attr_state.attr,
 506         &dev_attr_monitor_id.attr,
 507         &dev_attr_class_id.attr,
 508         &dev_attr_device_id.attr,
 509         &dev_attr_modalias.attr,
 510         &dev_attr_server_monitor_pending.attr,
 511         &dev_attr_client_monitor_pending.attr,
 512         &dev_attr_server_monitor_latency.attr,
 513         &dev_attr_client_monitor_latency.attr,
 514         &dev_attr_server_monitor_conn_id.attr,
 515         &dev_attr_client_monitor_conn_id.attr,
 516         &dev_attr_out_intr_mask.attr,
 517         &dev_attr_out_read_index.attr,
 518         &dev_attr_out_write_index.attr,
 519         &dev_attr_out_read_bytes_avail.attr,
 520         &dev_attr_out_write_bytes_avail.attr,
 521         &dev_attr_in_intr_mask.attr,
 522         &dev_attr_in_read_index.attr,
 523         &dev_attr_in_write_index.attr,
 524         &dev_attr_in_read_bytes_avail.attr,
 525         &dev_attr_in_write_bytes_avail.attr,
 526         &dev_attr_channel_vp_mapping.attr,
 527         &dev_attr_vendor.attr,
 528         &dev_attr_device.attr,
 529         NULL,
 530 };
 531 ATTRIBUTE_GROUPS(vmbus);
 532
 533 /*
 534  * vmbus_uevent - add uevent for our device
 535  *
 536  * This routine is invoked when a device is added or removed on the vmbus to
 537  * generate a uevent to udev in the userspace. The udev will then look at its
 538  * rule and the uevent generated here to load the appropriate driver
 539  *
 540  * The alias string will be of the form vmbus:guid where guid is the string
 541  * representation of the device guid (each byte of the guid will be
 542  * represented with two hex characters.
 543  */
 544 static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
 545 {
 546         struct hv_device *dev = device_to_hv_device(device);
 547         int ret;
 548         char alias_name[VMBUS_ALIAS_LEN + 1];
 549
 550         print_alias_name(dev, alias_name);
 551         ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
 552         return ret;
 553 }
 554
 555 static const uuid_le null_guid;
 556
 557 static inline bool is_null_guid(const uuid_le *guid)
 558 {
 559         if (uuid_le_cmp(*guid, null_guid))
 560                 return false;
 561         return true;
 562 }
 563
 564 /*
 565  * Return a matching hv_vmbus_device_id pointer.
 566  * If there is no match, return NULL.
 567  */
 568 static const struct hv_vmbus_device_id *hv_vmbus_get_id(
 569                                         const struct hv_vmbus_device_id *id,
 570                                         const uuid_le *guid)
 571 {
 572         for (; !is_null_guid(&id->guid); id++)
 573                 if (!uuid_le_cmp(id->guid, *guid))
 574                         return id;
 575
 576         return NULL;
 577 }
 578
 579
 580
 581 /*
 582  * vmbus_match - Attempt to match the specified device to the specified driver
 583  */
 584 static int vmbus_match(struct device *device, struct device_driver *driver)
 585 {
 586         struct hv_driver *drv = drv_to_hv_drv(driver);
 587         struct hv_device *hv_dev = device_to_hv_device(device);
 588
 589         /* The hv_sock driver handles all hv_sock offers. */
 590         if (is_hvsock_channel(hv_dev->channel))
 591                 return drv->hvsock;
 592
 593         if (hv_vmbus_get_id(drv->id_table, &hv_dev->dev_type))
 594                 return 1;
 595
 596         return 0;
 597 }
 598
 599 /*
 600  * vmbus_probe - Add the new vmbus's child device
 601  */
 602 static int vmbus_probe(struct device *child_device)
 603 {
 604         int ret = 0;
 605         struct hv_driver *drv =
 606                         drv_to_hv_drv(child_device->driver);
 607         struct hv_device *dev = device_to_hv_device(child_device);
 608         const struct hv_vmbus_device_id *dev_id;
 609
 610         dev_id = hv_vmbus_get_id(drv->id_table, &dev->dev_type);
 611         if (drv->probe) {
 612                 ret = drv->probe(dev, dev_id);
 613                 if (ret != 0)
 614                         pr_err("probe failed for device %s (%d)\n",
 615                                dev_name(child_device), ret);
 616
 617         } else {
 618                 pr_err("probe not set for driver %s\n",
 619                        dev_name(child_device));
 620                 ret = -ENODEV;
 621         }
 622         return ret;
 623 }
 624
 625 /*
 626  * vmbus_remove - Remove a vmbus device
 627  */
 628 static int vmbus_remove(struct device *child_device)
 629 {
 630         struct hv_driver *drv;
 631         struct hv_device *dev = device_to_hv_device(child_device);
 632
 633         if (child_device->driver) {
 634                 drv = drv_to_hv_drv(child_device->driver);
 635                 if (drv->remove)
 636                         drv->remove(dev);
 637         }
 638
 639         return 0;
 640 }
 641
 642
 643 /*
 644  * vmbus_shutdown - Shutdown a vmbus device
 645  */
 646 static void vmbus_shutdown(struct device *child_device)
 647 {
 648         struct hv_driver *drv;
 649         struct hv_device *dev = device_to_hv_device(child_device);
 650
 651
 652         /* The device may not be attached yet */
 653         if (!child_device->driver)
 654                 return;
 655
 656         drv = drv_to_hv_drv(child_device->driver);
 657
 658         if (drv->shutdown)
 659                 drv->shutdown(dev);
 660
 661         return;
 662 }
 663
 664
 665 /*
 666  * vmbus_device_release - Final callback release of the vmbus child device
 667  */
 668 static void vmbus_device_release(struct device *device)
 669 {
 670         struct hv_device *hv_dev = device_to_hv_device(device);
 671         struct vmbus_channel *channel = hv_dev->channel;
 672
 673         hv_process_channel_removal(channel,
 674                                    channel->offermsg.child_relid);
 675         kfree(hv_dev);
 676
 677 }
 678
 679 /* The one and only one */
 680 static struct bus_type  hv_bus = {
 681         .name =         "vmbus",
 682         .match =                vmbus_match,
 683         .shutdown =             vmbus_shutdown,
 684         .remove =               vmbus_remove,
 685         .probe =                vmbus_probe,
 686         .uevent =               vmbus_uevent,
 687         .dev_groups =           vmbus_groups,
 688 };
 689
 690 struct onmessage_work_context {
 691         struct work_struct work;
 692         struct hv_message msg;
 693 };
 694
 695 static void vmbus_onmessage_work(struct work_struct *work)
 696 {
 697         struct onmessage_work_context *ctx;
 698
 699         /* Do not process messages if we're in DISCONNECTED state */
 700         if (vmbus_connection.conn_state == DISCONNECTED)
 701                 return;
 702
 703         ctx = container_of(work, struct onmessage_work_context,
 704                            work);
 705         vmbus_onmessage(&ctx->msg);
 706         kfree(ctx);
 707 }
 708
 709 static void hv_process_timer_expiration(struct hv_message *msg, int cpu)
 710 {
 711         struct clock_event_device *dev = hv_context.clk_evt[cpu];
 712
 713         if (dev->event_handler)
 714                 dev->event_handler(dev);
 715
 716         vmbus_signal_eom(msg, HVMSG_TIMER_EXPIRED);
 717 }
 718
 719 void vmbus_on_msg_dpc(unsigned long data)
 720 {
 721         int cpu = smp_processor_id();
 722         void *page_addr = hv_context.synic_message_page[cpu];
 723         struct hv_message *msg = (struct hv_message *)page_addr +
 724                                   VMBUS_MESSAGE_SINT;
 725         struct vmbus_channel_message_header *hdr;
 726         struct vmbus_channel_message_table_entry *entry;
 727         struct onmessage_work_context *ctx;
 728         u32 message_type = msg->header.message_type;
 729
 730         if (message_type == HVMSG_NONE)
 731                 /* no msg */
 732                 return;
 733
 734         hdr = (struct vmbus_channel_message_header *)msg->u.payload;
 735
 736         if (hdr->msgtype >= CHANNELMSG_COUNT) {
 737                 WARN_ONCE(1, "unknown msgtype=%d\n", hdr->msgtype);
 738                 goto msg_handled;
 739         }
 740
 741         entry = &channel_message_table[hdr->msgtype];
 742         if (entry->handler_type == VMHT_BLOCKING) {
 743                 ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
 744                 if (ctx == NULL)
 745                         return;
 746
 747                 INIT_WORK(&ctx->work, vmbus_onmessage_work);
 748                 memcpy(&ctx->msg, msg, sizeof(*msg));
 749
 750                 queue_work(vmbus_connection.work_queue, &ctx->work);
 751         } else
 752                 entry->message_handler(hdr);
 753
 754 msg_handled:
 755         vmbus_signal_eom(msg, message_type);
 756 }
 757
 758 static void vmbus_isr(void)
 759 {
 760         int cpu = smp_processor_id();
 761         void *page_addr;
 762         struct hv_message *msg;
 763         union hv_synic_event_flags *event;
 764         bool handled = false;
 765
 766         page_addr = hv_context.synic_event_page[cpu];
 767         if (page_addr == NULL)
 768                 return;
 769
 770         event = (union hv_synic_event_flags *)page_addr +
 771                                          VMBUS_MESSAGE_SINT;
 772         /*
 773          * Check for events before checking for messages. This is the order
 774          * in which events and messages are checked in Windows guests on
 775          * Hyper-V, and the Windows team suggested we do the same.
 776          */
 777
 778         if ((vmbus_proto_version == VERSION_WS2008) ||
 779                 (vmbus_proto_version == VERSION_WIN7)) {
 780
 781                 /* Since we are a child, we only need to check bit 0 */
 782                 if (sync_test_and_clear_bit(0,
 783                         (unsigned long *) &event->flags32[0])) {
 784                         handled = true;
 785                 }
 786         } else {
 787                 /*
 788                  * Our host is win8 or above. The signaling mechanism
 789                  * has changed and we can directly look at the event page.
 790                  * If bit n is set then we have an interrup on the channel
 791                  * whose id is n.
 792                  */
 793                 handled = true;
 794         }
 795
 796         if (handled)
 797                 tasklet_schedule(hv_context.event_dpc[cpu]);
 798
 799
 800         page_addr = hv_context.synic_message_page[cpu];
 801         msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
 802
 803         /* Check if there are actual msgs to be processed */
 804         if (msg->header.message_type != HVMSG_NONE) {
 805                 if (msg->header.message_type == HVMSG_TIMER_EXPIRED)
 806                         hv_process_timer_expiration(msg, cpu);
 807                 else
 808                         tasklet_schedule(hv_context.msg_dpc[cpu]);
 809         }
 810
 811         add_interrupt_randomness(HYPERVISOR_CALLBACK_VECTOR, 0);
 812 }
 813
 814
 815 /*
 816  * vmbus_bus_init -Main vmbus driver initialization routine.
 817  *
 818  * Here, we
 819  *      - initialize the vmbus driver context
 820  *      - invoke the vmbus hv main init routine
 821  *      - retrieve the channel offers
 822  */
 823 static int vmbus_bus_init(void)
 824 {
 825         int ret;
 826
 827         /* Hypervisor initialization...setup hypercall page..etc */
 828         ret = hv_init();
 829         if (ret != 0) {
 830                 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
 831                 return ret;
 832         }
 833
 834         ret = bus_register(&hv_bus);
 835         if (ret)
 836                 goto err_cleanup;
 837
 838         hv_setup_vmbus_irq(vmbus_isr);
 839
 840         ret = hv_synic_alloc();
 841         if (ret)
 842                 goto err_alloc;
 843         /*
 844          * Initialize the per-cpu interrupt state and
 845          * connect to the host.
 846          */
 847         on_each_cpu(hv_synic_init, NULL, 1);
 848         ret = vmbus_connect();
 849         if (ret)
 850                 goto err_connect;
 851
 852         if (vmbus_proto_version > VERSION_WIN7)
 853                 cpu_hotplug_disable();
 854
 855         /*
 856          * Only register if the crash MSRs are available
 857          */
 858         if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
 859                 register_die_notifier(&hyperv_die_block);
 860                 atomic_notifier_chain_register(&panic_notifier_list,
 861                                                &hyperv_panic_block);
 862         }
 863
 864         vmbus_request_offers();
 865
 866         return 0;
 867
 868 err_connect:
 869         on_each_cpu(hv_synic_cleanup, NULL, 1);
 870 err_alloc:
 871         hv_synic_free();
 872         hv_remove_vmbus_irq();
 873
 874         bus_unregister(&hv_bus);
 875
 876 err_cleanup:
 877         hv_cleanup();
 878
 879         return ret;
 880 }
 881
 882 /**
 883  * __vmbus_child_driver_register() - Register a vmbus's driver
 884  * @hv_driver: Pointer to driver structure you want to register
 885  * @owner: owner module of the drv
 886  * @mod_name: module name string
 887  *
 888  * Registers the given driver with Linux through the 'driver_register()' call
 889  * and sets up the hyper-v vmbus handling for this driver.
 890  * It will return the state of the 'driver_register()' call.
 891  *
 892  */
 893 int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
 894 {
 895         int ret;
 896
 897         pr_info("registering driver %s\n", hv_driver->name);
 898
 899         ret = vmbus_exists();
 900         if (ret < 0)
 901                 return ret;
 902
 903         hv_driver->driver.name = hv_driver->name;
 904         hv_driver->driver.owner = owner;
 905         hv_driver->driver.mod_name = mod_name;
 906         hv_driver->driver.bus = &hv_bus;
 907
 908         ret = driver_register(&hv_driver->driver);
 909
 910         return ret;
 911 }
 912 EXPORT_SYMBOL_GPL(__vmbus_driver_register);
 913
 914 /**
 915  * vmbus_driver_unregister() - Unregister a vmbus's driver
 916  * @hv_driver: Pointer to driver structure you want to
 917  *             un-register
 918  *
 919  * Un-register the given driver that was previous registered with a call to
 920  * vmbus_driver_register()
 921  */
 922 void vmbus_driver_unregister(struct hv_driver *hv_driver)
 923 {
 924         pr_info("unregistering driver %s\n", hv_driver->name);
 925
 926         if (!vmbus_exists())
 927                 driver_unregister(&hv_driver->driver);
 928 }
 929 EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
 930
 931 /*
 932  * vmbus_device_create - Creates and registers a new child device
 933  * on the vmbus.
 934  */
 935 struct hv_device *vmbus_device_create(const uuid_le *type,
 936                                       const uuid_le *instance,
 937                                       struct vmbus_channel *channel)
 938 {
 939         struct hv_device *child_device_obj;
 940
 941         child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
 942         if (!child_device_obj) {
 943                 pr_err("Unable to allocate device object for child device\n");
 944                 return NULL;
 945         }
 946
 947         child_device_obj->channel = channel;
 948         memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
 949         memcpy(&child_device_obj->dev_instance, instance,
 950                sizeof(uuid_le));
 951         child_device_obj->vendor_id = 0x1414; /* MSFT vendor ID */
 952
 953
 954         return child_device_obj;
 955 }
 956
 957 /*
 958  * vmbus_device_register - Register the child device
 959  */
 960 int vmbus_device_register(struct hv_device *child_device_obj)
 961 {
 962         int ret = 0;
 963
 964         dev_set_name(&child_device_obj->device, "vmbus_%d",
 965                      child_device_obj->channel->id);
 966
 967         child_device_obj->device.bus = &hv_bus;
 968         child_device_obj->device.parent = &hv_acpi_dev->dev;
 969         child_device_obj->device.release = vmbus_device_release;
 970
 971         /*
 972          * Register with the LDM. This will kick off the driver/device
 973          * binding...which will eventually call vmbus_match() and vmbus_probe()
 974          */
 975         ret = device_register(&child_device_obj->device);
 976
 977         if (ret)
 978                 pr_err("Unable to register child device\n");
 979         else
 980                 pr_debug("child device %s registered\n",
 981                         dev_name(&child_device_obj->device));
 982
 983         return ret;
 984 }
 985
 986 /*
 987  * vmbus_device_unregister - Remove the specified child device
 988  * from the vmbus.
 989  */
 990 void vmbus_device_unregister(struct hv_device *device_obj)
 991 {
 992         pr_debug("child device %s unregistered\n",
 993                 dev_name(&device_obj->device));
 994
 995         /*
 996          * Kick off the process of unregistering the device.
 997          * This will call vmbus_remove() and eventually vmbus_device_release()
 998          */
 999         device_unregister(&device_obj->device);
1000 }
1001
1002
1003 /*
1004  * VMBUS is an acpi enumerated device. Get the information we
1005  * need from DSDT.
1006  */
1007 #define VTPM_BASE_ADDRESS 0xfed40000
1008 static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *ctx)
1009 {
1010         resource_size_t start = 0;
1011         resource_size_t end = 0;
1012         struct resource *new_res;
1013         struct resource **old_res = &hyperv_mmio;
1014         struct resource **prev_res = NULL;
1015
1016         switch (res->type) {
1017
1018         /*
1019          * "Address" descriptors are for bus windows. Ignore
1020          * "memory" descriptors, which are for registers on
1021          * devices.
1022          */
1023         case ACPI_RESOURCE_TYPE_ADDRESS32:
1024                 start = res->data.address32.address.minimum;
1025                 end = res->data.address32.address.maximum;
1026                 break;
1027
1028         case ACPI_RESOURCE_TYPE_ADDRESS64:
1029                 start = res->data.address64.address.minimum;
1030                 end = res->data.address64.address.maximum;
1031                 break;
1032
1033         default:
1034                 /* Unused resource type */
1035                 return AE_OK;
1036
1037         }
1038         /*
1039          * Ignore ranges that are below 1MB, as they're not
1040          * necessary or useful here.
1041          */
1042         if (end < 0x100000)
1043                 return AE_OK;
1044
1045         new_res = kzalloc(sizeof(*new_res), GFP_ATOMIC);
1046         if (!new_res)
1047                 return AE_NO_MEMORY;
1048
1049         /* If this range overlaps the virtual TPM, truncate it. */
1050         if (end > VTPM_BASE_ADDRESS && start < VTPM_BASE_ADDRESS)
1051                 end = VTPM_BASE_ADDRESS;
1052
1053         new_res->name = "hyperv mmio";
1054         new_res->flags = IORESOURCE_MEM;
1055         new_res->start = start;
1056         new_res->end = end;
1057
1058         /*
1059          * If two ranges are adjacent, merge them.
1060          */
1061         do {
1062                 if (!*old_res) {
1063                         *old_res = new_res;
1064                         break;
1065                 }
1066
1067                 if (((*old_res)->end + 1) == new_res->start) {
1068                         (*old_res)->end = new_res->end;
1069                         kfree(new_res);
1070                         break;
1071                 }
1072
1073                 if ((*old_res)->start == new_res->end + 1) {
1074                         (*old_res)->start = new_res->start;
1075                         kfree(new_res);
1076                         break;
1077                 }
1078
1079                 if ((*old_res)->start > new_res->end) {
1080                         new_res->sibling = *old_res;
1081                         if (prev_res)
1082                                 (*prev_res)->sibling = new_res;
1083                         *old_res = new_res;
1084                         break;
1085                 }
1086
1087                 prev_res = old_res;
1088                 old_res = &(*old_res)->sibling;
1089
1090         } while (1);
1091
1092         return AE_OK;
1093 }
1094
1095 static int vmbus_acpi_remove(struct acpi_device *device)
1096 {
1097         struct resource *cur_res;
1098         struct resource *next_res;
1099
1100         if (hyperv_mmio) {
1101                 if (fb_mmio) {
1102                         __release_region(hyperv_mmio, fb_mmio->start,
1103                                          resource_size(fb_mmio));
1104                         fb_mmio = NULL;
1105                 }
1106
1107                 for (cur_res = hyperv_mmio; cur_res; cur_res = next_res) {
1108                         next_res = cur_res->sibling;
1109                         kfree(cur_res);
1110                 }
1111         }
1112
1113         return 0;
1114 }
1115
1116 static void vmbus_reserve_fb(void)
1117 {
1118         int size;
1119         /*
1120          * Make a claim for the frame buffer in the resource tree under the
1121          * first node, which will be the one below 4GB.  The length seems to
1122          * be underreported, particularly in a Generation 1 VM.  So start out
1123          * reserving a larger area and make it smaller until it succeeds.
1124          */
1125
1126         if (screen_info.lfb_base) {
1127                 if (efi_enabled(EFI_BOOT))
1128                         size = max_t(__u32, screen_info.lfb_size, 0x800000);
1129                 else
1130                         size = max_t(__u32, screen_info.lfb_size, 0x4000000);
1131
1132                 for (; !fb_mmio && (size >= 0x100000); size >>= 1) {
1133                         fb_mmio = __request_region(hyperv_mmio,
1134                                                    screen_info.lfb_base, size,
1135                                                    fb_mmio_name, 0);
1136                 }
1137         }
1138 }
1139
1140 /**
1141  * vmbus_allocate_mmio() - Pick a memory-mapped I/O range.
1142  * @new:                If successful, supplied a pointer to the
1143  *                      allocated MMIO space.
1144  * @device_obj:         Identifies the caller
1145  * @min:                Minimum guest physical address of the
1146  *                      allocation
1147  * @max:                Maximum guest physical address
1148  * @size:               Size of the range to be allocated
1149  * @align:              Alignment of the range to be allocated
1150  * @fb_overlap_ok:      Whether this allocation can be allowed
1151  *                      to overlap the video frame buffer.
1152  *
1153  * This function walks the resources granted to VMBus by the
1154  * _CRS object in the ACPI namespace underneath the parent
1155  * "bridge" whether that's a root PCI bus in the Generation 1
1156  * case or a Module Device in the Generation 2 case.  It then
1157  * attempts to allocate from the global MMIO pool in a way that
1158  * matches the constraints supplied in these parameters and by
1159  * that _CRS.
1160  *
1161  * Return: 0 on success, -errno on failure
1162  */
1163 int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj,
1164                         resource_size_t min, resource_size_t max,
1165                         resource_size_t size, resource_size_t align,
1166                         bool fb_overlap_ok)
1167 {
1168         struct resource *iter, *shadow;
1169         resource_size_t range_min, range_max, start;
1170         const char *dev_n = dev_name(&device_obj->device);
1171         int retval;
1172
1173         retval = -ENXIO;
1174         down(&hyperv_mmio_lock);
1175
1176         /*
1177          * If overlaps with frame buffers are allowed, then first attempt to
1178          * make the allocation from within the reserved region.  Because it
1179          * is already reserved, no shadow allocation is necessary.
1180          */
1181         if (fb_overlap_ok && fb_mmio && !(min > fb_mmio->end) &&
1182             !(max < fb_mmio->start)) {
1183
1184                 range_min = fb_mmio->start;
1185                 range_max = fb_mmio->end;
1186                 start = (range_min + align - 1) & ~(align - 1);
1187                 for (; start + size - 1 <= range_max; start += align) {
1188                         *new = request_mem_region_exclusive(start, size, dev_n);
1189                         if (*new) {
1190                                 retval = 0;
1191                                 goto exit;
1192                         }
1193                 }
1194         }
1195
1196         for (iter = hyperv_mmio; iter; iter = iter->sibling) {
1197                 if ((iter->start >= max) || (iter->end <= min))
1198                         continue;
1199
1200                 range_min = iter->start;
1201                 range_max = iter->end;
1202                 start = (range_min + align - 1) & ~(align - 1);
1203                 for (; start + size - 1 <= range_max; start += align) {
1204                         shadow = __request_region(iter, start, size, NULL,
1205                                                   IORESOURCE_BUSY);
1206                         if (!shadow)
1207                                 continue;
1208
1209                         *new = request_mem_region_exclusive(start, size, dev_n);
1210                         if (*new) {
1211                                 shadow->name = (char *)*new;
1212                                 retval = 0;
1213                                 goto exit;
1214                         }
1215
1216                         __release_region(iter, start, size);
1217                 }
1218         }
1219
1220 exit:
1221         up(&hyperv_mmio_lock);
1222         return retval;
1223 }
1224 EXPORT_SYMBOL_GPL(vmbus_allocate_mmio);
1225
1226 /**
1227  * vmbus_free_mmio() - Free a memory-mapped I/O range.
1228  * @start:              Base address of region to release.
1229  * @size:               Size of the range to be allocated
1230  *
1231  * This function releases anything requested by
1232  * vmbus_mmio_allocate().
1233  */
1234 void vmbus_free_mmio(resource_size_t start, resource_size_t size)
1235 {
1236         struct resource *iter;
1237
1238         down(&hyperv_mmio_lock);
1239         for (iter = hyperv_mmio; iter; iter = iter->sibling) {
1240                 if ((iter->start >= start + size) || (iter->end <= start))
1241                         continue;
1242
1243                 __release_region(iter, start, size);
1244         }
1245         release_mem_region(start, size);
1246         up(&hyperv_mmio_lock);
1247
1248 }
1249 EXPORT_SYMBOL_GPL(vmbus_free_mmio);
1250
1251 /**
1252  * vmbus_cpu_number_to_vp_number() - Map CPU to VP.
1253  * @cpu_number: CPU number in Linux terms
1254  *
1255  * This function returns the mapping between the Linux processor
1256  * number and the hypervisor's virtual processor number, useful
1257  * in making hypercalls and such that talk about specific
1258  * processors.
1259  *
1260  * Return: Virtual processor number in Hyper-V terms
1261  */
1262 int vmbus_cpu_number_to_vp_number(int cpu_number)
1263 {
1264         return hv_context.vp_index[cpu_number];
1265 }
1266 EXPORT_SYMBOL_GPL(vmbus_cpu_number_to_vp_number);
1267
1268 static int vmbus_acpi_add(struct acpi_device *device)
1269 {
1270         acpi_status result;
1271         int ret_val = -ENODEV;
1272         struct acpi_device *ancestor;
1273
1274         hv_acpi_dev = device;
1275
1276         result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
1277                                         vmbus_walk_resources, NULL);
1278
1279         if (ACPI_FAILURE(result))
1280                 goto acpi_walk_err;
1281         /*
1282          * Some ancestor of the vmbus acpi device (Gen1 or Gen2
1283          * firmware) is the VMOD that has the mmio ranges. Get that.
1284          */
1285         for (ancestor = device->parent; ancestor; ancestor = ancestor->parent) {
1286                 result = acpi_walk_resources(ancestor->handle, METHOD_NAME__CRS,
1287                                              vmbus_walk_resources, NULL);
1288
1289                 if (ACPI_FAILURE(result))
1290                         continue;
1291                 if (hyperv_mmio) {
1292                         vmbus_reserve_fb();
1293                         break;
1294                 }
1295         }
1296         ret_val = 0;
1297
1298 acpi_walk_err:
1299         complete(&probe_event);
1300         if (ret_val)
1301                 vmbus_acpi_remove(device);
1302         return ret_val;
1303 }
1304
1305 static const struct acpi_device_id vmbus_acpi_device_ids[] = {
1306         {"VMBUS", 0},
1307         {"VMBus", 0},
1308         {"", 0},
1309 };
1310 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);
1311
1312 static struct acpi_driver vmbus_acpi_driver = {
1313         .name = "vmbus",
1314         .ids = vmbus_acpi_device_ids,
1315         .ops = {
1316                 .add = vmbus_acpi_add,
1317                 .remove = vmbus_acpi_remove,
1318         },
1319 };
1320
1321 static void hv_kexec_handler(void)
1322 {
1323         int cpu;
1324
1325         hv_synic_clockevents_cleanup();
1326         vmbus_initiate_unload(false);
1327         for_each_online_cpu(cpu)
1328                 smp_call_function_single(cpu, hv_synic_cleanup, NULL, 1);
1329         hv_cleanup();
1330 };
1331
1332 static void hv_crash_handler(struct pt_regs *regs)
1333 {
1334         vmbus_initiate_unload(true);
1335         /*
1336          * In crash handler we can't schedule synic cleanup for all CPUs,
1337          * doing the cleanup for current CPU only. This should be sufficient
1338          * for kdump.
1339          */
1340         hv_synic_cleanup(NULL);
1341         hv_cleanup();
1342 };
1343
1344 static int __init hv_acpi_init(void)
1345 {
1346         int ret, t;
1347
1348         if (x86_hyper != &x86_hyper_ms_hyperv)
1349                 return -ENODEV;
1350
1351         init_completion(&probe_event);
1352
1353         /*
1354          * Get ACPI resources first.
1355          */
1356         ret = acpi_bus_register_driver(&vmbus_acpi_driver);
1357
1358         if (ret)
1359                 return ret;
1360
1361         t = wait_for_completion_timeout(&probe_event, 5*HZ);
1362         if (t == 0) {
1363                 ret = -ETIMEDOUT;
1364                 goto cleanup;
1365         }
1366
1367         ret = vmbus_bus_init();
1368         if (ret)
1369                 goto cleanup;
1370
1371         hv_setup_kexec_handler(hv_kexec_handler);
1372         hv_setup_crash_handler(hv_crash_handler);
1373
1374         return 0;
1375
1376 cleanup:
1377         acpi_bus_unregister_driver(&vmbus_acpi_driver);
1378         hv_acpi_dev = NULL;
1379         return ret;
1380 }
1381
1382 static void __exit vmbus_exit(void)
1383 {
1384         int cpu;
1385
1386         hv_remove_kexec_handler();
1387         hv_remove_crash_handler();
1388         vmbus_connection.conn_state = DISCONNECTED;
1389         hv_synic_clockevents_cleanup();
1390         vmbus_disconnect();
1391         hv_remove_vmbus_irq();
1392         for_each_online_cpu(cpu)
1393                 tasklet_kill(hv_context.msg_dpc[cpu]);
1394         vmbus_free_channels();
1395         if (ms_hyperv.misc_features & HV_FEATURE_GUEST_CRASH_MSR_AVAILABLE) {
1396                 unregister_die_notifier(&hyperv_die_block);
1397                 atomic_notifier_chain_unregister(&panic_notifier_list,
1398                                                  &hyperv_panic_block);
1399         }
1400         bus_unregister(&hv_bus);
1401         hv_cleanup();
1402         for_each_online_cpu(cpu) {
1403                 tasklet_kill(hv_context.event_dpc[cpu]);
1404                 smp_call_function_single(cpu, hv_synic_cleanup, NULL, 1);
1405         }
1406         hv_synic_free();
1407         acpi_bus_unregister_driver(&vmbus_acpi_driver);
1408         if (vmbus_proto_version > VERSION_WIN7)
1409                 cpu_hotplug_enable();
1410 }
1411
1412
1413 MODULE_LICENSE("GPL");
1414
1415 subsys_initcall(hv_acpi_init);
1416 module_exit(vmbus_exit);