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