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