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/irq.h> 29 #include <linux/interrupt.h> 30 #include <linux/sysctl.h> 31 #include <linux/slab.h> 32 #include <linux/acpi.h> 33 #include <acpi/acpi_bus.h> 34 #include <linux/completion.h> 35 #include <linux/hyperv.h> 36 #include <asm/hyperv.h> 37 #include <asm/hypervisor.h> 38 #include "hyperv_vmbus.h" 39 40 41 static struct acpi_device *hv_acpi_dev; 42 43 static struct tasklet_struct msg_dpc; 44 static struct tasklet_struct event_dpc; 45 static struct completion probe_event; 46 static int irq; 47 48 struct hv_device_info { 49 u32 chn_id; 50 u32 chn_state; 51 uuid_le chn_type; 52 uuid_le chn_instance; 53 54 u32 monitor_id; 55 u32 server_monitor_pending; 56 u32 server_monitor_latency; 57 u32 server_monitor_conn_id; 58 u32 client_monitor_pending; 59 u32 client_monitor_latency; 60 u32 client_monitor_conn_id; 61 62 struct hv_dev_port_info inbound; 63 struct hv_dev_port_info outbound; 64 }; 65 66 static int vmbus_exists(void) 67 { 68 if (hv_acpi_dev == NULL) 69 return -ENODEV; 70 71 return 0; 72 } 73 74 75 static void get_channel_info(struct hv_device *device, 76 struct hv_device_info *info) 77 { 78 struct vmbus_channel_debug_info debug_info; 79 80 if (!device->channel) 81 return; 82 83 vmbus_get_debug_info(device->channel, &debug_info); 84 85 info->chn_id = debug_info.relid; 86 info->chn_state = debug_info.state; 87 memcpy(&info->chn_type, &debug_info.interfacetype, 88 sizeof(uuid_le)); 89 memcpy(&info->chn_instance, &debug_info.interface_instance, 90 sizeof(uuid_le)); 91 92 info->monitor_id = debug_info.monitorid; 93 94 info->server_monitor_pending = debug_info.servermonitor_pending; 95 info->server_monitor_latency = debug_info.servermonitor_latency; 96 info->server_monitor_conn_id = debug_info.servermonitor_connectionid; 97 98 info->client_monitor_pending = debug_info.clientmonitor_pending; 99 info->client_monitor_latency = debug_info.clientmonitor_latency; 100 info->client_monitor_conn_id = debug_info.clientmonitor_connectionid; 101 102 info->inbound.int_mask = debug_info.inbound.current_interrupt_mask; 103 info->inbound.read_idx = debug_info.inbound.current_read_index; 104 info->inbound.write_idx = debug_info.inbound.current_write_index; 105 info->inbound.bytes_avail_toread = 106 debug_info.inbound.bytes_avail_toread; 107 info->inbound.bytes_avail_towrite = 108 debug_info.inbound.bytes_avail_towrite; 109 110 info->outbound.int_mask = 111 debug_info.outbound.current_interrupt_mask; 112 info->outbound.read_idx = debug_info.outbound.current_read_index; 113 info->outbound.write_idx = debug_info.outbound.current_write_index; 114 info->outbound.bytes_avail_toread = 115 debug_info.outbound.bytes_avail_toread; 116 info->outbound.bytes_avail_towrite = 117 debug_info.outbound.bytes_avail_towrite; 118 } 119 120 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2) 121 static void print_alias_name(struct hv_device *hv_dev, char *alias_name) 122 { 123 int i; 124 for (i = 0; i < VMBUS_ALIAS_LEN; i += 2) 125 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]); 126 } 127 128 /* 129 * vmbus_show_device_attr - Show the device attribute in sysfs. 130 * 131 * This is invoked when user does a 132 * "cat /sys/bus/vmbus/devices/<busdevice>/<attr name>" 133 */ 134 static ssize_t vmbus_show_device_attr(struct device *dev, 135 struct device_attribute *dev_attr, 136 char *buf) 137 { 138 struct hv_device *hv_dev = device_to_hv_device(dev); 139 struct hv_device_info *device_info; 140 char alias_name[VMBUS_ALIAS_LEN + 1]; 141 int ret = 0; 142 143 device_info = kzalloc(sizeof(struct hv_device_info), GFP_KERNEL); 144 if (!device_info) 145 return ret; 146 147 get_channel_info(hv_dev, device_info); 148 149 if (!strcmp(dev_attr->attr.name, "class_id")) { 150 ret = sprintf(buf, "{%pUl}\n", device_info->chn_type.b); 151 } else if (!strcmp(dev_attr->attr.name, "device_id")) { 152 ret = sprintf(buf, "{%pUl}\n", device_info->chn_instance.b); 153 } else if (!strcmp(dev_attr->attr.name, "modalias")) { 154 print_alias_name(hv_dev, alias_name); 155 ret = sprintf(buf, "vmbus:%s\n", alias_name); 156 } else if (!strcmp(dev_attr->attr.name, "state")) { 157 ret = sprintf(buf, "%d\n", device_info->chn_state); 158 } else if (!strcmp(dev_attr->attr.name, "id")) { 159 ret = sprintf(buf, "%d\n", device_info->chn_id); 160 } else if (!strcmp(dev_attr->attr.name, "out_intr_mask")) { 161 ret = sprintf(buf, "%d\n", device_info->outbound.int_mask); 162 } else if (!strcmp(dev_attr->attr.name, "out_read_index")) { 163 ret = sprintf(buf, "%d\n", device_info->outbound.read_idx); 164 } else if (!strcmp(dev_attr->attr.name, "out_write_index")) { 165 ret = sprintf(buf, "%d\n", device_info->outbound.write_idx); 166 } else if (!strcmp(dev_attr->attr.name, "out_read_bytes_avail")) { 167 ret = sprintf(buf, "%d\n", 168 device_info->outbound.bytes_avail_toread); 169 } else if (!strcmp(dev_attr->attr.name, "out_write_bytes_avail")) { 170 ret = sprintf(buf, "%d\n", 171 device_info->outbound.bytes_avail_towrite); 172 } else if (!strcmp(dev_attr->attr.name, "in_intr_mask")) { 173 ret = sprintf(buf, "%d\n", device_info->inbound.int_mask); 174 } else if (!strcmp(dev_attr->attr.name, "in_read_index")) { 175 ret = sprintf(buf, "%d\n", device_info->inbound.read_idx); 176 } else if (!strcmp(dev_attr->attr.name, "in_write_index")) { 177 ret = sprintf(buf, "%d\n", device_info->inbound.write_idx); 178 } else if (!strcmp(dev_attr->attr.name, "in_read_bytes_avail")) { 179 ret = sprintf(buf, "%d\n", 180 device_info->inbound.bytes_avail_toread); 181 } else if (!strcmp(dev_attr->attr.name, "in_write_bytes_avail")) { 182 ret = sprintf(buf, "%d\n", 183 device_info->inbound.bytes_avail_towrite); 184 } else if (!strcmp(dev_attr->attr.name, "monitor_id")) { 185 ret = sprintf(buf, "%d\n", device_info->monitor_id); 186 } else if (!strcmp(dev_attr->attr.name, "server_monitor_pending")) { 187 ret = sprintf(buf, "%d\n", device_info->server_monitor_pending); 188 } else if (!strcmp(dev_attr->attr.name, "server_monitor_latency")) { 189 ret = sprintf(buf, "%d\n", device_info->server_monitor_latency); 190 } else if (!strcmp(dev_attr->attr.name, "server_monitor_conn_id")) { 191 ret = sprintf(buf, "%d\n", 192 device_info->server_monitor_conn_id); 193 } else if (!strcmp(dev_attr->attr.name, "client_monitor_pending")) { 194 ret = sprintf(buf, "%d\n", device_info->client_monitor_pending); 195 } else if (!strcmp(dev_attr->attr.name, "client_monitor_latency")) { 196 ret = sprintf(buf, "%d\n", device_info->client_monitor_latency); 197 } else if (!strcmp(dev_attr->attr.name, "client_monitor_conn_id")) { 198 ret = sprintf(buf, "%d\n", 199 device_info->client_monitor_conn_id); 200 } 201 202 kfree(device_info); 203 return ret; 204 } 205 206 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */ 207 static struct device_attribute vmbus_device_attrs[] = { 208 __ATTR(id, S_IRUGO, vmbus_show_device_attr, NULL), 209 __ATTR(state, S_IRUGO, vmbus_show_device_attr, NULL), 210 __ATTR(class_id, S_IRUGO, vmbus_show_device_attr, NULL), 211 __ATTR(device_id, S_IRUGO, vmbus_show_device_attr, NULL), 212 __ATTR(monitor_id, S_IRUGO, vmbus_show_device_attr, NULL), 213 __ATTR(modalias, S_IRUGO, vmbus_show_device_attr, NULL), 214 215 __ATTR(server_monitor_pending, S_IRUGO, vmbus_show_device_attr, NULL), 216 __ATTR(server_monitor_latency, S_IRUGO, vmbus_show_device_attr, NULL), 217 __ATTR(server_monitor_conn_id, S_IRUGO, vmbus_show_device_attr, NULL), 218 219 __ATTR(client_monitor_pending, S_IRUGO, vmbus_show_device_attr, NULL), 220 __ATTR(client_monitor_latency, S_IRUGO, vmbus_show_device_attr, NULL), 221 __ATTR(client_monitor_conn_id, S_IRUGO, vmbus_show_device_attr, NULL), 222 223 __ATTR(out_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL), 224 __ATTR(out_read_index, S_IRUGO, vmbus_show_device_attr, NULL), 225 __ATTR(out_write_index, S_IRUGO, vmbus_show_device_attr, NULL), 226 __ATTR(out_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL), 227 __ATTR(out_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL), 228 229 __ATTR(in_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL), 230 __ATTR(in_read_index, S_IRUGO, vmbus_show_device_attr, NULL), 231 __ATTR(in_write_index, S_IRUGO, vmbus_show_device_attr, NULL), 232 __ATTR(in_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL), 233 __ATTR(in_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL), 234 __ATTR_NULL 235 }; 236 237 238 /* 239 * vmbus_uevent - add uevent for our device 240 * 241 * This routine is invoked when a device is added or removed on the vmbus to 242 * generate a uevent to udev in the userspace. The udev will then look at its 243 * rule and the uevent generated here to load the appropriate driver 244 * 245 * The alias string will be of the form vmbus:guid where guid is the string 246 * representation of the device guid (each byte of the guid will be 247 * represented with two hex characters. 248 */ 249 static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env) 250 { 251 struct hv_device *dev = device_to_hv_device(device); 252 int ret; 253 char alias_name[VMBUS_ALIAS_LEN + 1]; 254 255 print_alias_name(dev, alias_name); 256 ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name); 257 return ret; 258 } 259 260 static uuid_le null_guid; 261 262 static inline bool is_null_guid(const __u8 *guid) 263 { 264 if (memcmp(guid, &null_guid, sizeof(uuid_le))) 265 return false; 266 return true; 267 } 268 269 /* 270 * Return a matching hv_vmbus_device_id pointer. 271 * If there is no match, return NULL. 272 */ 273 static const struct hv_vmbus_device_id *hv_vmbus_get_id( 274 const struct hv_vmbus_device_id *id, 275 __u8 *guid) 276 { 277 for (; !is_null_guid(id->guid); id++) 278 if (!memcmp(&id->guid, guid, sizeof(uuid_le))) 279 return id; 280 281 return NULL; 282 } 283 284 285 286 /* 287 * vmbus_match - Attempt to match the specified device to the specified driver 288 */ 289 static int vmbus_match(struct device *device, struct device_driver *driver) 290 { 291 struct hv_driver *drv = drv_to_hv_drv(driver); 292 struct hv_device *hv_dev = device_to_hv_device(device); 293 294 if (hv_vmbus_get_id(drv->id_table, hv_dev->dev_type.b)) 295 return 1; 296 297 return 0; 298 } 299 300 /* 301 * vmbus_probe - Add the new vmbus's child device 302 */ 303 static int vmbus_probe(struct device *child_device) 304 { 305 int ret = 0; 306 struct hv_driver *drv = 307 drv_to_hv_drv(child_device->driver); 308 struct hv_device *dev = device_to_hv_device(child_device); 309 const struct hv_vmbus_device_id *dev_id; 310 311 dev_id = hv_vmbus_get_id(drv->id_table, dev->dev_type.b); 312 if (drv->probe) { 313 ret = drv->probe(dev, dev_id); 314 if (ret != 0) 315 pr_err("probe failed for device %s (%d)\n", 316 dev_name(child_device), ret); 317 318 } else { 319 pr_err("probe not set for driver %s\n", 320 dev_name(child_device)); 321 ret = -ENODEV; 322 } 323 return ret; 324 } 325 326 /* 327 * vmbus_remove - Remove a vmbus device 328 */ 329 static int vmbus_remove(struct device *child_device) 330 { 331 struct hv_driver *drv = drv_to_hv_drv(child_device->driver); 332 struct hv_device *dev = device_to_hv_device(child_device); 333 334 if (drv->remove) 335 drv->remove(dev); 336 else 337 pr_err("remove not set for driver %s\n", 338 dev_name(child_device)); 339 340 return 0; 341 } 342 343 344 /* 345 * vmbus_shutdown - Shutdown a vmbus device 346 */ 347 static void vmbus_shutdown(struct device *child_device) 348 { 349 struct hv_driver *drv; 350 struct hv_device *dev = device_to_hv_device(child_device); 351 352 353 /* The device may not be attached yet */ 354 if (!child_device->driver) 355 return; 356 357 drv = drv_to_hv_drv(child_device->driver); 358 359 if (drv->shutdown) 360 drv->shutdown(dev); 361 362 return; 363 } 364 365 366 /* 367 * vmbus_device_release - Final callback release of the vmbus child device 368 */ 369 static void vmbus_device_release(struct device *device) 370 { 371 struct hv_device *hv_dev = device_to_hv_device(device); 372 373 kfree(hv_dev); 374 375 } 376 377 /* The one and only one */ 378 static struct bus_type hv_bus = { 379 .name = "vmbus", 380 .match = vmbus_match, 381 .shutdown = vmbus_shutdown, 382 .remove = vmbus_remove, 383 .probe = vmbus_probe, 384 .uevent = vmbus_uevent, 385 .dev_attrs = vmbus_device_attrs, 386 }; 387 388 static const char *driver_name = "hyperv"; 389 390 391 struct onmessage_work_context { 392 struct work_struct work; 393 struct hv_message msg; 394 }; 395 396 static void vmbus_onmessage_work(struct work_struct *work) 397 { 398 struct onmessage_work_context *ctx; 399 400 ctx = container_of(work, struct onmessage_work_context, 401 work); 402 vmbus_onmessage(&ctx->msg); 403 kfree(ctx); 404 } 405 406 static void vmbus_on_msg_dpc(unsigned long data) 407 { 408 int cpu = smp_processor_id(); 409 void *page_addr = hv_context.synic_message_page[cpu]; 410 struct hv_message *msg = (struct hv_message *)page_addr + 411 VMBUS_MESSAGE_SINT; 412 struct onmessage_work_context *ctx; 413 414 while (1) { 415 if (msg->header.message_type == HVMSG_NONE) { 416 /* no msg */ 417 break; 418 } else { 419 ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC); 420 if (ctx == NULL) 421 continue; 422 INIT_WORK(&ctx->work, vmbus_onmessage_work); 423 memcpy(&ctx->msg, msg, sizeof(*msg)); 424 queue_work(vmbus_connection.work_queue, &ctx->work); 425 } 426 427 msg->header.message_type = HVMSG_NONE; 428 429 /* 430 * Make sure the write to MessageType (ie set to 431 * HVMSG_NONE) happens before we read the 432 * MessagePending and EOMing. Otherwise, the EOMing 433 * will not deliver any more messages since there is 434 * no empty slot 435 */ 436 smp_mb(); 437 438 if (msg->header.message_flags.msg_pending) { 439 /* 440 * This will cause message queue rescan to 441 * possibly deliver another msg from the 442 * hypervisor 443 */ 444 wrmsrl(HV_X64_MSR_EOM, 0); 445 } 446 } 447 } 448 449 static irqreturn_t vmbus_isr(int irq, void *dev_id) 450 { 451 int cpu = smp_processor_id(); 452 void *page_addr; 453 struct hv_message *msg; 454 union hv_synic_event_flags *event; 455 bool handled = false; 456 457 /* 458 * Check for events before checking for messages. This is the order 459 * in which events and messages are checked in Windows guests on 460 * Hyper-V, and the Windows team suggested we do the same. 461 */ 462 463 page_addr = hv_context.synic_event_page[cpu]; 464 event = (union hv_synic_event_flags *)page_addr + VMBUS_MESSAGE_SINT; 465 466 /* Since we are a child, we only need to check bit 0 */ 467 if (sync_test_and_clear_bit(0, (unsigned long *) &event->flags32[0])) { 468 handled = true; 469 tasklet_schedule(&event_dpc); 470 } 471 472 page_addr = hv_context.synic_message_page[cpu]; 473 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT; 474 475 /* Check if there are actual msgs to be processed */ 476 if (msg->header.message_type != HVMSG_NONE) { 477 handled = true; 478 tasklet_schedule(&msg_dpc); 479 } 480 481 if (handled) 482 return IRQ_HANDLED; 483 else 484 return IRQ_NONE; 485 } 486 487 /* 488 * vmbus_bus_init -Main vmbus driver initialization routine. 489 * 490 * Here, we 491 * - initialize the vmbus driver context 492 * - invoke the vmbus hv main init routine 493 * - get the irq resource 494 * - retrieve the channel offers 495 */ 496 static int vmbus_bus_init(int irq) 497 { 498 int ret; 499 unsigned int vector; 500 501 /* Hypervisor initialization...setup hypercall page..etc */ 502 ret = hv_init(); 503 if (ret != 0) { 504 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret); 505 return ret; 506 } 507 508 tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0); 509 tasklet_init(&event_dpc, vmbus_on_event, 0); 510 511 ret = bus_register(&hv_bus); 512 if (ret) 513 goto err_cleanup; 514 515 ret = request_irq(irq, vmbus_isr, 0, driver_name, hv_acpi_dev); 516 517 if (ret != 0) { 518 pr_err("Unable to request IRQ %d\n", 519 irq); 520 goto err_unregister; 521 } 522 523 vector = IRQ0_VECTOR + irq; 524 525 /* 526 * Notify the hypervisor of our irq and 527 * connect to the host. 528 */ 529 on_each_cpu(hv_synic_init, (void *)&vector, 1); 530 ret = vmbus_connect(); 531 if (ret) 532 goto err_irq; 533 534 vmbus_request_offers(); 535 536 return 0; 537 538 err_irq: 539 free_irq(irq, hv_acpi_dev); 540 541 err_unregister: 542 bus_unregister(&hv_bus); 543 544 err_cleanup: 545 hv_cleanup(); 546 547 return ret; 548 } 549 550 /** 551 * __vmbus_child_driver_register - Register a vmbus's driver 552 * @drv: Pointer to driver structure you want to register 553 * @owner: owner module of the drv 554 * @mod_name: module name string 555 * 556 * Registers the given driver with Linux through the 'driver_register()' call 557 * and sets up the hyper-v vmbus handling for this driver. 558 * It will return the state of the 'driver_register()' call. 559 * 560 */ 561 int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name) 562 { 563 int ret; 564 565 pr_info("registering driver %s\n", hv_driver->name); 566 567 ret = vmbus_exists(); 568 if (ret < 0) 569 return ret; 570 571 hv_driver->driver.name = hv_driver->name; 572 hv_driver->driver.owner = owner; 573 hv_driver->driver.mod_name = mod_name; 574 hv_driver->driver.bus = &hv_bus; 575 576 ret = driver_register(&hv_driver->driver); 577 578 vmbus_request_offers(); 579 580 return ret; 581 } 582 EXPORT_SYMBOL_GPL(__vmbus_driver_register); 583 584 /** 585 * vmbus_driver_unregister() - Unregister a vmbus's driver 586 * @drv: Pointer to driver structure you want to un-register 587 * 588 * Un-register the given driver that was previous registered with a call to 589 * vmbus_driver_register() 590 */ 591 void vmbus_driver_unregister(struct hv_driver *hv_driver) 592 { 593 pr_info("unregistering driver %s\n", hv_driver->name); 594 595 if (!vmbus_exists()) 596 driver_unregister(&hv_driver->driver); 597 } 598 EXPORT_SYMBOL_GPL(vmbus_driver_unregister); 599 600 /* 601 * vmbus_device_create - Creates and registers a new child device 602 * on the vmbus. 603 */ 604 struct hv_device *vmbus_device_create(uuid_le *type, 605 uuid_le *instance, 606 struct vmbus_channel *channel) 607 { 608 struct hv_device *child_device_obj; 609 610 child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL); 611 if (!child_device_obj) { 612 pr_err("Unable to allocate device object for child device\n"); 613 return NULL; 614 } 615 616 child_device_obj->channel = channel; 617 memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le)); 618 memcpy(&child_device_obj->dev_instance, instance, 619 sizeof(uuid_le)); 620 621 622 return child_device_obj; 623 } 624 625 /* 626 * vmbus_device_register - Register the child device 627 */ 628 int vmbus_device_register(struct hv_device *child_device_obj) 629 { 630 int ret = 0; 631 632 static atomic_t device_num = ATOMIC_INIT(0); 633 634 dev_set_name(&child_device_obj->device, "vmbus_0_%d", 635 atomic_inc_return(&device_num)); 636 637 child_device_obj->device.bus = &hv_bus; 638 child_device_obj->device.parent = &hv_acpi_dev->dev; 639 child_device_obj->device.release = vmbus_device_release; 640 641 /* 642 * Register with the LDM. This will kick off the driver/device 643 * binding...which will eventually call vmbus_match() and vmbus_probe() 644 */ 645 ret = device_register(&child_device_obj->device); 646 647 if (ret) 648 pr_err("Unable to register child device\n"); 649 else 650 pr_info("child device %s registered\n", 651 dev_name(&child_device_obj->device)); 652 653 return ret; 654 } 655 656 /* 657 * vmbus_device_unregister - Remove the specified child device 658 * from the vmbus. 659 */ 660 void vmbus_device_unregister(struct hv_device *device_obj) 661 { 662 /* 663 * Kick off the process of unregistering the device. 664 * This will call vmbus_remove() and eventually vmbus_device_release() 665 */ 666 device_unregister(&device_obj->device); 667 668 pr_info("child device %s unregistered\n", 669 dev_name(&device_obj->device)); 670 } 671 672 673 /* 674 * VMBUS is an acpi enumerated device. Get the the IRQ information 675 * from DSDT. 676 */ 677 678 static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *irq) 679 { 680 681 if (res->type == ACPI_RESOURCE_TYPE_IRQ) { 682 struct acpi_resource_irq *irqp; 683 irqp = &res->data.irq; 684 685 *((unsigned int *)irq) = irqp->interrupts[0]; 686 } 687 688 return AE_OK; 689 } 690 691 static int vmbus_acpi_add(struct acpi_device *device) 692 { 693 acpi_status result; 694 695 hv_acpi_dev = device; 696 697 result = acpi_walk_resources(device->handle, METHOD_NAME__CRS, 698 vmbus_walk_resources, &irq); 699 700 if (ACPI_FAILURE(result)) { 701 complete(&probe_event); 702 return -ENODEV; 703 } 704 complete(&probe_event); 705 return 0; 706 } 707 708 static const struct acpi_device_id vmbus_acpi_device_ids[] = { 709 {"VMBUS", 0}, 710 {"VMBus", 0}, 711 {"", 0}, 712 }; 713 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids); 714 715 static struct acpi_driver vmbus_acpi_driver = { 716 .name = "vmbus", 717 .ids = vmbus_acpi_device_ids, 718 .ops = { 719 .add = vmbus_acpi_add, 720 }, 721 }; 722 723 static int __init hv_acpi_init(void) 724 { 725 int ret, t; 726 727 if (x86_hyper != &x86_hyper_ms_hyperv) 728 return -ENODEV; 729 730 init_completion(&probe_event); 731 732 /* 733 * Get irq resources first. 734 */ 735 736 ret = acpi_bus_register_driver(&vmbus_acpi_driver); 737 738 if (ret) 739 return ret; 740 741 t = wait_for_completion_timeout(&probe_event, 5*HZ); 742 if (t == 0) { 743 ret = -ETIMEDOUT; 744 goto cleanup; 745 } 746 747 if (irq <= 0) { 748 ret = -ENODEV; 749 goto cleanup; 750 } 751 752 ret = vmbus_bus_init(irq); 753 if (ret) 754 goto cleanup; 755 756 return 0; 757 758 cleanup: 759 acpi_bus_unregister_driver(&vmbus_acpi_driver); 760 hv_acpi_dev = NULL; 761 return ret; 762 } 763 764 static void __exit vmbus_exit(void) 765 { 766 767 free_irq(irq, hv_acpi_dev); 768 vmbus_free_channels(); 769 bus_unregister(&hv_bus); 770 hv_cleanup(); 771 acpi_bus_unregister_driver(&vmbus_acpi_driver); 772 } 773 774 775 MODULE_LICENSE("GPL"); 776 MODULE_VERSION(HV_DRV_VERSION); 777 778 subsys_initcall(hv_acpi_init); 779 module_exit(vmbus_exit); 780