drivers/staging/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  */
  21 #include <linux/init.h>
  22 #include <linux/module.h>
  23 #include <linux/device.h>
  24 #include <linux/irq.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/sysctl.h>
  27 #include <linux/pci.h>
  28 #include <linux/dmi.h>
  29 #include <linux/slab.h>
  30 #include <linux/completion.h>
  31 #include "version_info.h"
  32 #include "hv_api.h"
  33 #include "logging.h"
  34 #include "vmbus.h"
  35 #include "channel.h"
  36 #include "vmbus_private.h"
  37
  38
  39 /* FIXME! We need to do this dynamically for PIC and APIC system */
  40 #define VMBUS_IRQ               0x5
  41 #define VMBUS_IRQ_VECTOR        IRQ5_VECTOR
  42
  43 /* Main vmbus driver data structure */
  44 struct vmbus_driver_context {
  45
  46         struct bus_type bus;
  47         struct tasklet_struct msg_dpc;
  48         struct tasklet_struct event_dpc;
  49
  50         /* The bus root device */
  51         struct hv_device device_ctx;
  52 };
  53
  54 static int vmbus_match(struct device *device, struct device_driver *driver);
  55 static int vmbus_probe(struct device *device);
  56 static int vmbus_remove(struct device *device);
  57 static void vmbus_shutdown(struct device *device);
  58 static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env);
  59 static void vmbus_msg_dpc(unsigned long data);
  60 static void vmbus_event_dpc(unsigned long data);
  61
  62 static irqreturn_t vmbus_isr(int irq, void *dev_id);
  63
  64 static void vmbus_device_release(struct device *device);
  65 static void vmbus_bus_release(struct device *device);
  66
  67 static ssize_t vmbus_show_device_attr(struct device *dev,
  68                                       struct device_attribute *dev_attr,
  69                                       char *buf);
  70
  71
  72 unsigned int vmbus_loglevel = (ALL_MODULES << 16 | INFO_LVL);
  73 EXPORT_SYMBOL(vmbus_loglevel);
  74         /* (ALL_MODULES << 16 | DEBUG_LVL_ENTEREXIT); */
  75         /* (((VMBUS | VMBUS_DRV)<<16) | DEBUG_LVL_ENTEREXIT); */
  76
  77 static int vmbus_irq = VMBUS_IRQ;
  78
  79 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
  80 static struct device_attribute vmbus_device_attrs[] = {
  81         __ATTR(id, S_IRUGO, vmbus_show_device_attr, NULL),
  82         __ATTR(state, S_IRUGO, vmbus_show_device_attr, NULL),
  83         __ATTR(class_id, S_IRUGO, vmbus_show_device_attr, NULL),
  84         __ATTR(device_id, S_IRUGO, vmbus_show_device_attr, NULL),
  85         __ATTR(monitor_id, S_IRUGO, vmbus_show_device_attr, NULL),
  86
  87         __ATTR(server_monitor_pending, S_IRUGO, vmbus_show_device_attr, NULL),
  88         __ATTR(server_monitor_latency, S_IRUGO, vmbus_show_device_attr, NULL),
  89         __ATTR(server_monitor_conn_id, S_IRUGO, vmbus_show_device_attr, NULL),
  90
  91         __ATTR(client_monitor_pending, S_IRUGO, vmbus_show_device_attr, NULL),
  92         __ATTR(client_monitor_latency, S_IRUGO, vmbus_show_device_attr, NULL),
  93         __ATTR(client_monitor_conn_id, S_IRUGO, vmbus_show_device_attr, NULL),
  94
  95         __ATTR(out_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL),
  96         __ATTR(out_read_index, S_IRUGO, vmbus_show_device_attr, NULL),
  97         __ATTR(out_write_index, S_IRUGO, vmbus_show_device_attr, NULL),
  98         __ATTR(out_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
  99         __ATTR(out_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
 100
 101         __ATTR(in_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL),
 102         __ATTR(in_read_index, S_IRUGO, vmbus_show_device_attr, NULL),
 103         __ATTR(in_write_index, S_IRUGO, vmbus_show_device_attr, NULL),
 104         __ATTR(in_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
 105         __ATTR(in_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
 106         __ATTR_NULL
 107 };
 108
 109 /* The one and only one */
 110 static struct vmbus_driver_context vmbus_drv = {
 111         .bus.name =             "vmbus",
 112         .bus.match =            vmbus_match,
 113         .bus.shutdown =         vmbus_shutdown,
 114         .bus.remove =           vmbus_remove,
 115         .bus.probe =            vmbus_probe,
 116         .bus.uevent =           vmbus_uevent,
 117         .bus.dev_attrs =        vmbus_device_attrs,
 118 };
 119
 120 static const char *driver_name = "hyperv";
 121
 122 /*
 123  * Windows vmbus does not defined this.
 124  * We defined this to be consistent with other devices
 125  */
 126 /* {c5295816-f63a-4d5f-8d1a-4daf999ca185} */
 127 static const struct hv_guid device_type = {
 128         .data = {
 129                 0x16, 0x58, 0x29, 0xc5, 0x3a, 0xf6, 0x5f, 0x4d,
 130                 0x8d, 0x1a, 0x4d, 0xaf, 0x99, 0x9c, 0xa1, 0x85
 131         }
 132 };
 133
 134 /* {ac3760fc-9adf-40aa-9427-a70ed6de95c5} */
 135 static const struct hv_guid device_id = {
 136         .data = {
 137                 0xfc, 0x60, 0x37, 0xac, 0xdf, 0x9a, 0xaa, 0x40,
 138                 0x94, 0x27, 0xa7, 0x0e, 0xd6, 0xde, 0x95, 0xc5
 139         }
 140 };
 141
 142 static struct hv_device *vmbus_device; /* vmbus root device */
 143
 144 /*
 145  * vmbus_child_dev_add - Registers the child device with the vmbus
 146  */
 147 int vmbus_child_dev_add(struct hv_device *child_dev)
 148 {
 149         return vmbus_child_device_register(vmbus_device, child_dev);
 150 }
 151
 152 /*
 153  * vmbus_dev_add - Callback when the root bus device is added
 154  */
 155 static int vmbus_dev_add(struct hv_device *dev, void *info)
 156 {
 157         u32 *irqvector = info;
 158         int ret;
 159
 160         vmbus_device = dev;
 161
 162         memcpy(&vmbus_device->dev_type, &device_type, sizeof(struct hv_guid));
 163         memcpy(&vmbus_device->dev_instance, &device_id,
 164                sizeof(struct hv_guid));
 165
 166         /* strcpy(dev->name, "vmbus"); */
 167         /* SynIC setup... */
 168         on_each_cpu(hv_synic_init, (void *)irqvector, 1);
 169
 170         /* Connect to VMBus in the root partition */
 171         ret = vmbus_connect();
 172
 173         /* VmbusSendEvent(device->localPortId+1); */
 174         return ret;
 175 }
 176
 177 /*
 178  * vmbus_dev_rm - Callback when the root bus device is removed
 179  */
 180 static int vmbus_dev_rm(struct hv_device *dev)
 181 {
 182         int ret = 0;
 183
 184         vmbus_release_unattached_channels();
 185         vmbus_disconnect();
 186         on_each_cpu(hv_synic_cleanup, NULL, 1);
 187         return ret;
 188 }
 189
 190 /*
 191  * vmbus_cleanup - Perform any cleanup when the driver is removed
 192  */
 193 static void vmbus_cleanup(void)
 194 {
 195
 196         hv_cleanup();
 197 }
 198
 199 struct onmessage_work_context {
 200         struct work_struct work;
 201         struct hv_message msg;
 202 };
 203
 204 static void vmbus_onmessage_work(struct work_struct *work)
 205 {
 206         struct onmessage_work_context *ctx;
 207
 208         ctx = container_of(work, struct onmessage_work_context,
 209                            work);
 210         vmbus_onmessage(&ctx->msg);
 211         kfree(ctx);
 212 }
 213
 214 /*
 215  * vmbus_on_msg_dpc - DPC routine to handle messages from the hypervisior
 216  */
 217 static void vmbus_on_msg_dpc(struct hv_driver *drv)
 218 {
 219         int cpu = smp_processor_id();
 220         void *page_addr = hv_context.synic_message_page[cpu];
 221         struct hv_message *msg = (struct hv_message *)page_addr +
 222                                   VMBUS_MESSAGE_SINT;
 223         struct onmessage_work_context *ctx;
 224
 225         while (1) {
 226                 if (msg->header.message_type == HVMSG_NONE) {
 227                         /* no msg */
 228                         break;
 229                 } else {
 230                         ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
 231                         if (ctx == NULL)
 232                                 continue;
 233                         INIT_WORK(&ctx->work, vmbus_onmessage_work);
 234                         memcpy(&ctx->msg, msg, sizeof(*msg));
 235                         queue_work(vmbus_connection.work_queue, &ctx->work);
 236                 }
 237
 238                 msg->header.message_type = HVMSG_NONE;
 239
 240                 /*
 241                  * Make sure the write to MessageType (ie set to
 242                  * HVMSG_NONE) happens before we read the
 243                  * MessagePending and EOMing. Otherwise, the EOMing
 244                  * will not deliver any more messages since there is
 245                  * no empty slot
 246                  */
 247                 mb();
 248
 249                 if (msg->header.message_flags.msg_pending) {
 250                         /*
 251                          * This will cause message queue rescan to
 252                          * possibly deliver another msg from the
 253                          * hypervisor
 254                          */
 255                         wrmsrl(HV_X64_MSR_EOM, 0);
 256                 }
 257         }
 258 }
 259
 260 /*
 261  * vmbus_on_isr - ISR routine
 262  */
 263 static int vmbus_on_isr(struct hv_driver *drv)
 264 {
 265         int ret = 0;
 266         int cpu = smp_processor_id();
 267         void *page_addr;
 268         struct hv_message *msg;
 269         union hv_synic_event_flags *event;
 270
 271         page_addr = hv_context.synic_message_page[cpu];
 272         msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
 273
 274         /* Check if there are actual msgs to be process */
 275         if (msg->header.message_type != HVMSG_NONE) {
 276                 DPRINT_DBG(VMBUS, "received msg type %d size %d",
 277                                 msg->header.message_type,
 278                                 msg->header.payload_size);
 279                 ret |= 0x1;
 280         }
 281
 282         /* TODO: Check if there are events to be process */
 283         page_addr = hv_context.synic_event_page[cpu];
 284         event = (union hv_synic_event_flags *)page_addr + VMBUS_MESSAGE_SINT;
 285
 286         /* Since we are a child, we only need to check bit 0 */
 287         if (test_and_clear_bit(0, (unsigned long *) &event->flags32[0])) {
 288                 DPRINT_DBG(VMBUS, "received event %d", event->flags32[0]);
 289                 ret |= 0x2;
 290         }
 291
 292         return ret;
 293 }
 294
 295 static void get_channel_info(struct hv_device *device,
 296                              struct hv_device_info *info)
 297 {
 298         struct vmbus_channel_debug_info debug_info;
 299
 300         if (!device->channel)
 301                 return;
 302
 303         vmbus_get_debug_info(device->channel, &debug_info);
 304
 305         info->chn_id = debug_info.relid;
 306         info->chn_state = debug_info.state;
 307         memcpy(&info->chn_type, &debug_info.interfacetype,
 308                sizeof(struct hv_guid));
 309         memcpy(&info->chn_instance, &debug_info.interface_instance,
 310                sizeof(struct hv_guid));
 311
 312         info->monitor_id = debug_info.monitorid;
 313
 314         info->server_monitor_pending = debug_info.servermonitor_pending;
 315         info->server_monitor_latency = debug_info.servermonitor_latency;
 316         info->server_monitor_conn_id = debug_info.servermonitor_connectionid;
 317
 318         info->client_monitor_pending = debug_info.clientmonitor_pending;
 319         info->client_monitor_latency = debug_info.clientmonitor_latency;
 320         info->client_monitor_conn_id = debug_info.clientmonitor_connectionid;
 321
 322         info->inbound.int_mask = debug_info.inbound.current_interrupt_mask;
 323         info->inbound.read_idx = debug_info.inbound.current_read_index;
 324         info->inbound.write_idx = debug_info.inbound.current_write_index;
 325         info->inbound.bytes_avail_toread =
 326                 debug_info.inbound.bytes_avail_toread;
 327         info->inbound.bytes_avail_towrite =
 328                 debug_info.inbound.bytes_avail_towrite;
 329
 330         info->outbound.int_mask =
 331                 debug_info.outbound.current_interrupt_mask;
 332         info->outbound.read_idx = debug_info.outbound.current_read_index;
 333         info->outbound.write_idx = debug_info.outbound.current_write_index;
 334         info->outbound.bytes_avail_toread =
 335                 debug_info.outbound.bytes_avail_toread;
 336         info->outbound.bytes_avail_towrite =
 337                 debug_info.outbound.bytes_avail_towrite;
 338 }
 339
 340 /*
 341  * vmbus_show_device_attr - Show the device attribute in sysfs.
 342  *
 343  * This is invoked when user does a
 344  * "cat /sys/bus/vmbus/devices/<busdevice>/<attr name>"
 345  */
 346 static ssize_t vmbus_show_device_attr(struct device *dev,
 347                                       struct device_attribute *dev_attr,
 348                                       char *buf)
 349 {
 350         struct hv_device *device_ctx = device_to_hv_device(dev);
 351         struct hv_device_info device_info;
 352
 353         memset(&device_info, 0, sizeof(struct hv_device_info));
 354
 355         get_channel_info(device_ctx, &device_info);
 356
 357         if (!strcmp(dev_attr->attr.name, "class_id")) {
 358                 return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-"
 359                                "%02x%02x%02x%02x%02x%02x%02x%02x}\n",
 360                                device_info.chn_type.data[3],
 361                                device_info.chn_type.data[2],
 362                                device_info.chn_type.data[1],
 363                                device_info.chn_type.data[0],
 364                                device_info.chn_type.data[5],
 365                                device_info.chn_type.data[4],
 366                                device_info.chn_type.data[7],
 367                                device_info.chn_type.data[6],
 368                                device_info.chn_type.data[8],
 369                                device_info.chn_type.data[9],
 370                                device_info.chn_type.data[10],
 371                                device_info.chn_type.data[11],
 372                                device_info.chn_type.data[12],
 373                                device_info.chn_type.data[13],
 374                                device_info.chn_type.data[14],
 375                                device_info.chn_type.data[15]);
 376         } else if (!strcmp(dev_attr->attr.name, "device_id")) {
 377                 return sprintf(buf, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-"
 378                                "%02x%02x%02x%02x%02x%02x%02x%02x}\n",
 379                                device_info.chn_instance.data[3],
 380                                device_info.chn_instance.data[2],
 381                                device_info.chn_instance.data[1],
 382                                device_info.chn_instance.data[0],
 383                                device_info.chn_instance.data[5],
 384                                device_info.chn_instance.data[4],
 385                                device_info.chn_instance.data[7],
 386                                device_info.chn_instance.data[6],
 387                                device_info.chn_instance.data[8],
 388                                device_info.chn_instance.data[9],
 389                                device_info.chn_instance.data[10],
 390                                device_info.chn_instance.data[11],
 391                                device_info.chn_instance.data[12],
 392                                device_info.chn_instance.data[13],
 393                                device_info.chn_instance.data[14],
 394                                device_info.chn_instance.data[15]);
 395         } else if (!strcmp(dev_attr->attr.name, "state")) {
 396                 return sprintf(buf, "%d\n", device_info.chn_state);
 397         } else if (!strcmp(dev_attr->attr.name, "id")) {
 398                 return sprintf(buf, "%d\n", device_info.chn_id);
 399         } else if (!strcmp(dev_attr->attr.name, "out_intr_mask")) {
 400                 return sprintf(buf, "%d\n", device_info.outbound.int_mask);
 401         } else if (!strcmp(dev_attr->attr.name, "out_read_index")) {
 402                 return sprintf(buf, "%d\n", device_info.outbound.read_idx);
 403         } else if (!strcmp(dev_attr->attr.name, "out_write_index")) {
 404                 return sprintf(buf, "%d\n", device_info.outbound.write_idx);
 405         } else if (!strcmp(dev_attr->attr.name, "out_read_bytes_avail")) {
 406                 return sprintf(buf, "%d\n",
 407                                device_info.outbound.bytes_avail_toread);
 408         } else if (!strcmp(dev_attr->attr.name, "out_write_bytes_avail")) {
 409                 return sprintf(buf, "%d\n",
 410                                device_info.outbound.bytes_avail_towrite);
 411         } else if (!strcmp(dev_attr->attr.name, "in_intr_mask")) {
 412                 return sprintf(buf, "%d\n", device_info.inbound.int_mask);
 413         } else if (!strcmp(dev_attr->attr.name, "in_read_index")) {
 414                 return sprintf(buf, "%d\n", device_info.inbound.read_idx);
 415         } else if (!strcmp(dev_attr->attr.name, "in_write_index")) {
 416                 return sprintf(buf, "%d\n", device_info.inbound.write_idx);
 417         } else if (!strcmp(dev_attr->attr.name, "in_read_bytes_avail")) {
 418                 return sprintf(buf, "%d\n",
 419                                device_info.inbound.bytes_avail_toread);
 420         } else if (!strcmp(dev_attr->attr.name, "in_write_bytes_avail")) {
 421                 return sprintf(buf, "%d\n",
 422                                device_info.inbound.bytes_avail_towrite);
 423         } else if (!strcmp(dev_attr->attr.name, "monitor_id")) {
 424                 return sprintf(buf, "%d\n", device_info.monitor_id);
 425         } else if (!strcmp(dev_attr->attr.name, "server_monitor_pending")) {
 426                 return sprintf(buf, "%d\n", device_info.server_monitor_pending);
 427         } else if (!strcmp(dev_attr->attr.name, "server_monitor_latency")) {
 428                 return sprintf(buf, "%d\n", device_info.server_monitor_latency);
 429         } else if (!strcmp(dev_attr->attr.name, "server_monitor_conn_id")) {
 430                 return sprintf(buf, "%d\n",
 431                                device_info.server_monitor_conn_id);
 432         } else if (!strcmp(dev_attr->attr.name, "client_monitor_pending")) {
 433                 return sprintf(buf, "%d\n", device_info.client_monitor_pending);
 434         } else if (!strcmp(dev_attr->attr.name, "client_monitor_latency")) {
 435                 return sprintf(buf, "%d\n", device_info.client_monitor_latency);
 436         } else if (!strcmp(dev_attr->attr.name, "client_monitor_conn_id")) {
 437                 return sprintf(buf, "%d\n",
 438                                device_info.client_monitor_conn_id);
 439         } else {
 440                 return 0;
 441         }
 442 }
 443
 444 /*
 445  * vmbus_bus_init -Main vmbus driver initialization routine.
 446  *
 447  * Here, we
 448  *      - initialize the vmbus driver context
 449  *      - setup various driver entry points
 450  *      - invoke the vmbus hv main init routine
 451  *      - get the irq resource
 452  *      - invoke the vmbus to add the vmbus root device
 453  *      - setup the vmbus root device
 454  *      - retrieve the channel offers
 455  */
 456 static int vmbus_bus_init(void)
 457 {
 458         struct vmbus_driver_context *vmbus_drv_ctx = &vmbus_drv;
 459         struct hv_device *dev_ctx = &vmbus_drv.device_ctx;
 460         int ret;
 461         unsigned int vector;
 462
 463         DPRINT_INFO(VMBUS, "+++++++ HV Driver version = %s +++++++",
 464                     HV_DRV_VERSION);
 465         DPRINT_INFO(VMBUS, "+++++++ Vmbus supported version = %d +++++++",
 466                         VMBUS_REVISION_NUMBER);
 467         DPRINT_INFO(VMBUS, "+++++++ Vmbus using SINT %d +++++++",
 468                         VMBUS_MESSAGE_SINT);
 469         DPRINT_DBG(VMBUS, "sizeof(vmbus_channel_packet_page_buffer)=%zd, "
 470                         "sizeof(VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER)=%zd",
 471                         sizeof(struct vmbus_channel_packet_page_buffer),
 472                         sizeof(struct vmbus_channel_packet_multipage_buffer));
 473
 474
 475         /* Hypervisor initialization...setup hypercall page..etc */
 476         ret = hv_init();
 477         if (ret != 0) {
 478                 DPRINT_ERR(VMBUS, "Unable to initialize the hypervisor - 0x%x",
 479                                 ret);
 480                 goto cleanup;
 481         }
 482
 483
 484         vmbus_drv_ctx->bus.name = driver_name;
 485
 486         /* Initialize the bus context */
 487         tasklet_init(&vmbus_drv_ctx->msg_dpc, vmbus_msg_dpc,
 488                      (unsigned long)NULL);
 489         tasklet_init(&vmbus_drv_ctx->event_dpc, vmbus_event_dpc,
 490                      (unsigned long)NULL);
 491
 492         /* Now, register the bus  with LDM */
 493         ret = bus_register(&vmbus_drv_ctx->bus);
 494         if (ret) {
 495                 ret = -1;
 496                 goto cleanup;
 497         }
 498
 499         /* Get the interrupt resource */
 500         ret = request_irq(vmbus_irq, vmbus_isr, IRQF_SAMPLE_RANDOM,
 501                           driver_name, NULL);
 502
 503         if (ret != 0) {
 504                 DPRINT_ERR(VMBUS_DRV, "ERROR - Unable to request IRQ %d",
 505                            vmbus_irq);
 506
 507                 bus_unregister(&vmbus_drv_ctx->bus);
 508
 509                 ret = -1;
 510                 goto cleanup;
 511         }
 512         vector = VMBUS_IRQ_VECTOR;
 513
 514         DPRINT_INFO(VMBUS_DRV, "irq 0x%x vector 0x%x", vmbus_irq, vector);
 515
 516         /* Add the root device */
 517         memset(dev_ctx, 0, sizeof(struct hv_device));
 518
 519         ret = vmbus_dev_add(dev_ctx, &vector);
 520         if (ret != 0) {
 521                 DPRINT_ERR(VMBUS_DRV,
 522                            "ERROR - Unable to add vmbus root device");
 523
 524                 free_irq(vmbus_irq, NULL);
 525
 526                 bus_unregister(&vmbus_drv_ctx->bus);
 527
 528                 ret = -1;
 529                 goto cleanup;
 530         }
 531         /* strcpy(dev_ctx->device.bus_id, dev_ctx->device_obj.name); */
 532         dev_set_name(&dev_ctx->device, "vmbus_0_0");
 533
 534         /* No need to bind a driver to the root device. */
 535         dev_ctx->device.parent = NULL;
 536         /* NULL; vmbus_remove() does not get invoked */
 537         dev_ctx->device.bus = &vmbus_drv_ctx->bus;
 538
 539         /* Setup the device dispatch table */
 540         dev_ctx->device.release = vmbus_bus_release;
 541
 542         /* register the  root device */
 543         ret = device_register(&dev_ctx->device);
 544         if (ret) {
 545                 DPRINT_ERR(VMBUS_DRV,
 546                            "ERROR - Unable to register vmbus root device");
 547
 548                 free_irq(vmbus_irq, NULL);
 549                 bus_unregister(&vmbus_drv_ctx->bus);
 550
 551                 ret = -1;
 552                 goto cleanup;
 553         }
 554
 555         vmbus_request_offers();
 556         wait_for_completion(&hv_channel_ready);
 557
 558 cleanup:
 559         return ret;
 560 }
 561
 562 /*
 563  * vmbus_bus_exit - Terminate the vmbus driver.
 564  *
 565  * This routine is opposite of vmbus_bus_init()
 566  */
 567 static void vmbus_bus_exit(void)
 568 {
 569         struct vmbus_driver_context *vmbus_drv_ctx = &vmbus_drv;
 570
 571         struct hv_device *dev_ctx = &vmbus_drv.device_ctx;
 572
 573         /* Remove the root device */
 574         vmbus_dev_rm(dev_ctx);
 575
 576         vmbus_cleanup();
 577
 578         /* Unregister the root bus device */
 579         device_unregister(&dev_ctx->device);
 580
 581         bus_unregister(&vmbus_drv_ctx->bus);
 582
 583         free_irq(vmbus_irq, NULL);
 584
 585         tasklet_kill(&vmbus_drv_ctx->msg_dpc);
 586         tasklet_kill(&vmbus_drv_ctx->event_dpc);
 587 }
 588
 589
 590 /**
 591  * vmbus_child_driver_register() - Register a vmbus's child driver
 592  * @drv:        Pointer to driver structure you want to register
 593  *
 594  *
 595  * Registers the given driver with Linux through the 'driver_register()' call
 596  * And sets up the hyper-v vmbus handling for this driver.
 597  * It will return the state of the 'driver_register()' call.
 598  *
 599  * Mainly used by Hyper-V drivers.
 600  */
 601 int vmbus_child_driver_register(struct device_driver *drv)
 602 {
 603         int ret;
 604
 605         DPRINT_INFO(VMBUS_DRV, "child driver (%p) registering - name %s",
 606                     drv, drv->name);
 607
 608         /* The child driver on this vmbus */
 609         drv->bus = &vmbus_drv.bus;
 610
 611         ret = driver_register(drv);
 612
 613         vmbus_request_offers();
 614
 615         return ret;
 616 }
 617 EXPORT_SYMBOL(vmbus_child_driver_register);
 618
 619 /**
 620  * vmbus_child_driver_unregister() - Unregister a vmbus's child driver
 621  * @drv:        Pointer to driver structure you want to un-register
 622  *
 623  *
 624  * Un-register the given driver with Linux through the 'driver_unregister()'
 625  * call. And ungegisters the driver from the Hyper-V vmbus handler.
 626  *
 627  * Mainly used by Hyper-V drivers.
 628  */
 629 void vmbus_child_driver_unregister(struct device_driver *drv)
 630 {
 631         DPRINT_INFO(VMBUS_DRV, "child driver (%p) unregistering - name %s",
 632                     drv, drv->name);
 633
 634         driver_unregister(drv);
 635
 636         drv->bus = NULL;
 637 }
 638 EXPORT_SYMBOL(vmbus_child_driver_unregister);
 639
 640 /*
 641  * vmbus_child_device_create - Creates and registers a new child device
 642  * on the vmbus.
 643  */
 644 struct hv_device *vmbus_child_device_create(struct hv_guid *type,
 645                                             struct hv_guid *instance,
 646                                             struct vmbus_channel *channel)
 647 {
 648         struct hv_device *child_device_obj;
 649
 650         /* Allocate the new child device */
 651         child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
 652         if (!child_device_obj) {
 653                 DPRINT_ERR(VMBUS_DRV,
 654                         "unable to allocate device_context for child device");
 655                 return NULL;
 656         }
 657
 658         DPRINT_DBG(VMBUS_DRV, "child device (%p) allocated - "
 659                 "type {%02x%02x%02x%02x-%02x%02x-%02x%02x-"
 660                 "%02x%02x%02x%02x%02x%02x%02x%02x},"
 661                 "id {%02x%02x%02x%02x-%02x%02x-%02x%02x-"
 662                 "%02x%02x%02x%02x%02x%02x%02x%02x}",
 663                 &child_device_obj->device,
 664                 type->data[3], type->data[2], type->data[1], type->data[0],
 665                 type->data[5], type->data[4], type->data[7], type->data[6],
 666                 type->data[8], type->data[9], type->data[10], type->data[11],
 667                 type->data[12], type->data[13], type->data[14], type->data[15],
 668                 instance->data[3], instance->data[2],
 669                 instance->data[1], instance->data[0],
 670                 instance->data[5], instance->data[4],
 671                 instance->data[7], instance->data[6],
 672                 instance->data[8], instance->data[9],
 673                 instance->data[10], instance->data[11],
 674                 instance->data[12], instance->data[13],
 675                 instance->data[14], instance->data[15]);
 676
 677         child_device_obj->channel = channel;
 678         memcpy(&child_device_obj->dev_type, type, sizeof(struct hv_guid));
 679         memcpy(&child_device_obj->dev_instance, instance,
 680                sizeof(struct hv_guid));
 681
 682
 683         return child_device_obj;
 684 }
 685
 686 /*
 687  * vmbus_child_device_register - Register the child device on the specified bus
 688  */
 689 int vmbus_child_device_register(struct hv_device *root_device_obj,
 690                                 struct hv_device *child_device_obj)
 691 {
 692         int ret = 0;
 693
 694         static atomic_t device_num = ATOMIC_INIT(0);
 695
 696         DPRINT_DBG(VMBUS_DRV, "child device (%p) registering",
 697                    child_device_obj);
 698
 699         /* Set the device name. Otherwise, device_register() will fail. */
 700         dev_set_name(&child_device_obj->device, "vmbus_0_%d",
 701                      atomic_inc_return(&device_num));
 702
 703         /* The new device belongs to this bus */
 704         child_device_obj->device.bus = &vmbus_drv.bus; /* device->dev.bus; */
 705         child_device_obj->device.parent = &root_device_obj->device;
 706         child_device_obj->device.release = vmbus_device_release;
 707
 708         /*
 709          * Register with the LDM. This will kick off the driver/device
 710          * binding...which will eventually call vmbus_match() and vmbus_probe()
 711          */
 712         ret = device_register(&child_device_obj->device);
 713
 714         /* vmbus_probe() error does not get propergate to device_register(). */
 715         ret = child_device_obj->probe_error;
 716
 717         if (ret)
 718                 DPRINT_ERR(VMBUS_DRV, "unable to register child device (%p)",
 719                            &child_device_obj->device);
 720         else
 721                 DPRINT_INFO(VMBUS_DRV, "child device (%p) registered",
 722                             &child_device_obj->device);
 723
 724         return ret;
 725 }
 726
 727 /*
 728  * vmbus_child_device_unregister - Remove the specified child device
 729  * from the vmbus.
 730  */
 731 void vmbus_child_device_unregister(struct hv_device *device_obj)
 732 {
 733
 734         DPRINT_INFO(VMBUS_DRV, "unregistering child device (%p)",
 735                     &device_obj->device);
 736
 737         /*
 738          * Kick off the process of unregistering the device.
 739          * This will call vmbus_remove() and eventually vmbus_device_release()
 740          */
 741         device_unregister(&device_obj->device);
 742
 743         DPRINT_INFO(VMBUS_DRV, "child device (%p) unregistered",
 744                     &device_obj->device);
 745 }
 746
 747 /*
 748  * vmbus_uevent - add uevent for our device
 749  *
 750  * This routine is invoked when a device is added or removed on the vmbus to
 751  * generate a uevent to udev in the userspace. The udev will then look at its
 752  * rule and the uevent generated here to load the appropriate driver
 753  */
 754 static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
 755 {
 756         struct hv_device *dev = device_to_hv_device(device);
 757         int ret;
 758
 759         DPRINT_INFO(VMBUS_DRV, "generating uevent - VMBUS_DEVICE_CLASS_GUID={"
 760                     "%02x%02x%02x%02x-%02x%02x-%02x%02x-"
 761                     "%02x%02x%02x%02x%02x%02x%02x%02x}",
 762                     dev->dev_type.data[3], dev->dev_type.data[2],
 763                     dev->dev_type.data[1], dev->dev_type.data[0],
 764                     dev->dev_type.data[5], dev->dev_type.data[4],
 765                     dev->dev_type.data[7], dev->dev_type.data[6],
 766                     dev->dev_type.data[8], dev->dev_type.data[9],
 767                     dev->dev_type.data[10],
 768                     dev->dev_type.data[11],
 769                     dev->dev_type.data[12],
 770                     dev->dev_type.data[13],
 771                     dev->dev_type.data[14],
 772                     dev->dev_type.data[15]);
 773
 774         ret = add_uevent_var(env, "VMBUS_DEVICE_CLASS_GUID={"
 775                              "%02x%02x%02x%02x-%02x%02x-%02x%02x-"
 776                              "%02x%02x%02x%02x%02x%02x%02x%02x}",
 777                              dev->dev_type.data[3],
 778                              dev->dev_type.data[2],
 779                              dev->dev_type.data[1],
 780                              dev->dev_type.data[0],
 781                              dev->dev_type.data[5],
 782                              dev->dev_type.data[4],
 783                              dev->dev_type.data[7],
 784                              dev->dev_type.data[6],
 785                              dev->dev_type.data[8],
 786                              dev->dev_type.data[9],
 787                              dev->dev_type.data[10],
 788                              dev->dev_type.data[11],
 789                              dev->dev_type.data[12],
 790                              dev->dev_type.data[13],
 791                              dev->dev_type.data[14],
 792                              dev->dev_type.data[15]);
 793
 794         if (ret)
 795                 return ret;
 796
 797         ret = add_uevent_var(env, "VMBUS_DEVICE_DEVICE_GUID={"
 798                              "%02x%02x%02x%02x-%02x%02x-%02x%02x-"
 799                              "%02x%02x%02x%02x%02x%02x%02x%02x}",
 800                              dev->dev_instance.data[3],
 801                              dev->dev_instance.data[2],
 802                              dev->dev_instance.data[1],
 803                              dev->dev_instance.data[0],
 804                              dev->dev_instance.data[5],
 805                              dev->dev_instance.data[4],
 806                              dev->dev_instance.data[7],
 807                              dev->dev_instance.data[6],
 808                              dev->dev_instance.data[8],
 809                              dev->dev_instance.data[9],
 810                              dev->dev_instance.data[10],
 811                              dev->dev_instance.data[11],
 812                              dev->dev_instance.data[12],
 813                              dev->dev_instance.data[13],
 814                              dev->dev_instance.data[14],
 815                              dev->dev_instance.data[15]);
 816         if (ret)
 817                 return ret;
 818
 819         return 0;
 820 }
 821
 822 /*
 823  * vmbus_match - Attempt to match the specified device to the specified driver
 824  */
 825 static int vmbus_match(struct device *device, struct device_driver *driver)
 826 {
 827         int match = 0;
 828         struct hv_driver *drv = drv_to_hv_drv(driver);
 829         struct hv_device *device_ctx = device_to_hv_device(device);
 830
 831         /* We found our driver ? */
 832         if (memcmp(&device_ctx->dev_type, &drv->dev_type,
 833                    sizeof(struct hv_guid)) == 0) {
 834
 835                 device_ctx->drv = drv->priv;
 836                 DPRINT_INFO(VMBUS_DRV,
 837                             "device object (%p) set to driver object (%p)",
 838                             &device_ctx,
 839                             device_ctx->drv);
 840
 841                 match = 1;
 842         }
 843         return match;
 844 }
 845
 846 /*
 847  * vmbus_probe_failed_cb - Callback when a driver probe failed in vmbus_probe()
 848  *
 849  * We need a callback because we cannot invoked device_unregister() inside
 850  * vmbus_probe() since vmbus_probe() may be invoked inside device_register()
 851  * i.e. we cannot call device_unregister() inside device_register()
 852  */
 853 static void vmbus_probe_failed_cb(struct work_struct *context)
 854 {
 855         struct hv_device *device_ctx = (struct hv_device *)context;
 856
 857         /*
 858          * Kick off the process of unregistering the device.
 859          * This will call vmbus_remove() and eventually vmbus_device_release()
 860          */
 861         device_unregister(&device_ctx->device);
 862
 863         /* put_device(&device_ctx->device); */
 864 }
 865
 866 /*
 867  * vmbus_probe - Add the new vmbus's child device
 868  */
 869 static int vmbus_probe(struct device *child_device)
 870 {
 871         int ret = 0;
 872         struct hv_driver *drv =
 873                         drv_to_hv_drv(child_device->driver);
 874         struct hv_device *dev = device_to_hv_device(child_device);
 875
 876         /* Let the specific open-source driver handles the probe if it can */
 877         if (drv->driver.probe) {
 878                 ret = dev->probe_error =
 879                 drv->driver.probe(child_device);
 880                 if (ret != 0) {
 881                         DPRINT_ERR(VMBUS_DRV, "probe() failed for device %s "
 882                                    "(%p) on driver %s (%d)...",
 883                                    dev_name(child_device), child_device,
 884                                    child_device->driver->name, ret);
 885
 886                         INIT_WORK(&dev->probe_failed_work_item,
 887                                   vmbus_probe_failed_cb);
 888                         schedule_work(&dev->probe_failed_work_item);
 889                 }
 890         } else {
 891                 DPRINT_ERR(VMBUS_DRV, "probe() method not set for driver - %s",
 892                            child_device->driver->name);
 893                 ret = -1;
 894         }
 895         return ret;
 896 }
 897
 898 /*
 899  * vmbus_remove - Remove a vmbus device
 900  */
 901 static int vmbus_remove(struct device *child_device)
 902 {
 903         int ret;
 904         struct hv_driver *drv;
 905
 906         /* Special case root bus device */
 907         if (child_device->parent == NULL) {
 908                 /*
 909                  * No-op since it is statically defined and handle in
 910                  * vmbus_bus_exit()
 911                  */
 912                 return 0;
 913         }
 914
 915         if (child_device->driver) {
 916                 drv = drv_to_hv_drv(child_device->driver);
 917
 918                 /*
 919                  * Let the specific open-source driver handles the removal if
 920                  * it can
 921                  */
 922                 if (drv->driver.remove) {
 923                         ret = drv->driver.remove(child_device);
 924                 } else {
 925                         DPRINT_ERR(VMBUS_DRV,
 926                                    "remove() method not set for driver - %s",
 927                                    child_device->driver->name);
 928                         ret = -1;
 929                 }
 930         }
 931
 932         return 0;
 933 }
 934
 935 /*
 936  * vmbus_shutdown - Shutdown a vmbus device
 937  */
 938 static void vmbus_shutdown(struct device *child_device)
 939 {
 940         struct hv_driver *drv;
 941
 942         /* Special case root bus device */
 943         if (child_device->parent == NULL) {
 944                 /*
 945                  * No-op since it is statically defined and handle in
 946                  * vmbus_bus_exit()
 947                  */
 948                 return;
 949         }
 950
 951         /* The device may not be attached yet */
 952         if (!child_device->driver)
 953                 return;
 954
 955         drv = drv_to_hv_drv(child_device->driver);
 956
 957         /* Let the specific open-source driver handles the removal if it can */
 958         if (drv->driver.shutdown)
 959                 drv->driver.shutdown(child_device);
 960
 961         return;
 962 }
 963
 964 /*
 965  * vmbus_bus_release - Final callback release of the vmbus root device
 966  */
 967 static void vmbus_bus_release(struct device *device)
 968 {
 969         /* FIXME */
 970         /* Empty release functions are a bug, or a major sign
 971          * of a problem design, this MUST BE FIXED! */
 972         dev_err(device, "%s needs to be fixed!\n", __func__);
 973         WARN_ON(1);
 974 }
 975
 976 /*
 977  * vmbus_device_release - Final callback release of the vmbus child device
 978  */
 979 static void vmbus_device_release(struct device *device)
 980 {
 981         struct hv_device *device_ctx = device_to_hv_device(device);
 982
 983         kfree(device_ctx);
 984
 985         /* !!DO NOT REFERENCE device_ctx anymore at this point!! */
 986 }
 987
 988 /*
 989  * vmbus_msg_dpc - Tasklet routine to handle hypervisor messages
 990  */
 991 static void vmbus_msg_dpc(unsigned long data)
 992 {
 993         struct hv_driver *driver = (struct hv_driver *)data;
 994
 995         /* Call to bus driver to handle interrupt */
 996         vmbus_on_msg_dpc(driver);
 997 }
 998
 999 /*
1000  * vmbus_event_dpc - Tasklet routine to handle hypervisor events
1001  */
1002 static void vmbus_event_dpc(unsigned long data)
1003 {
1004         /* Call to bus driver to handle interrupt */
1005         vmbus_on_event();
1006 }
1007
1008 static irqreturn_t vmbus_isr(int irq, void *dev_id)
1009 {
1010         int ret;
1011
1012         /* Call to bus driver to handle interrupt */
1013         ret = vmbus_on_isr(NULL);
1014
1015         /* Schedules a dpc if necessary */
1016         if (ret > 0) {
1017                 if (test_bit(0, (unsigned long *)&ret))
1018                         tasklet_schedule(&vmbus_drv.msg_dpc);
1019
1020                 if (test_bit(1, (unsigned long *)&ret))
1021                         tasklet_schedule(&vmbus_drv.event_dpc);
1022
1023                 return IRQ_HANDLED;
1024         } else {
1025                 return IRQ_NONE;
1026         }
1027 }
1028
1029 static struct dmi_system_id __initdata microsoft_hv_dmi_table[] = {
1030         {
1031                 .ident = "Hyper-V",
1032                 .matches = {
1033                         DMI_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"),
1034                         DMI_MATCH(DMI_PRODUCT_NAME, "Virtual Machine"),
1035                         DMI_MATCH(DMI_BOARD_NAME, "Virtual Machine"),
1036                 },
1037         },
1038         { },
1039 };
1040 MODULE_DEVICE_TABLE(dmi, microsoft_hv_dmi_table);
1041
1042 static int __init vmbus_init(void)
1043 {
1044         DPRINT_INFO(VMBUS_DRV,
1045                 "Vmbus initializing.... current log level 0x%x (%x,%x)",
1046                 vmbus_loglevel, HIWORD(vmbus_loglevel), LOWORD(vmbus_loglevel));
1047         /* Todo: it is used for loglevel, to be ported to new kernel. */
1048
1049         if (!dmi_check_system(microsoft_hv_dmi_table))
1050                 return -ENODEV;
1051
1052         return vmbus_bus_init();
1053 }
1054
1055 static void __exit vmbus_exit(void)
1056 {
1057         vmbus_bus_exit();
1058         /* Todo: it is used for loglevel, to be ported to new kernel. */
1059 }
1060
1061 /*
1062  * We use a PCI table to determine if we should autoload this driver  This is
1063  * needed by distro tools to determine if the hyperv drivers should be
1064  * installed and/or configured.  We don't do anything else with the table, but
1065  * it needs to be present.
1066  */
1067 static const struct pci_device_id microsoft_hv_pci_table[] = {
1068         { PCI_DEVICE(0x1414, 0x5353) }, /* VGA compatible controller */
1069         { 0 }
1070 };
1071 MODULE_DEVICE_TABLE(pci, microsoft_hv_pci_table);
1072
1073 MODULE_LICENSE("GPL");
1074 MODULE_VERSION(HV_DRV_VERSION);
1075 module_param(vmbus_irq, int, S_IRUGO);
1076 module_param(vmbus_loglevel, int, S_IRUGO);
1077
1078 module_init(vmbus_init);
1079 module_exit(vmbus_exit);