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