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