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 <linux/kernel_stat.h> 37 #include <asm/hyperv.h> 38 #include <asm/hypervisor.h> 39 #include <asm/mshyperv.h> 40 #include "hyperv_vmbus.h" 41 42 43 static struct acpi_device *hv_acpi_dev; 44 45 static struct tasklet_struct msg_dpc; 46 static struct completion probe_event; 47 static int irq; 48 49 static int vmbus_exists(void) 50 { 51 if (hv_acpi_dev == NULL) 52 return -ENODEV; 53 54 return 0; 55 } 56 57 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2) 58 static void print_alias_name(struct hv_device *hv_dev, char *alias_name) 59 { 60 int i; 61 for (i = 0; i < VMBUS_ALIAS_LEN; i += 2) 62 sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]); 63 } 64 65 static u8 channel_monitor_group(struct vmbus_channel *channel) 66 { 67 return (u8)channel->offermsg.monitorid / 32; 68 } 69 70 static u8 channel_monitor_offset(struct vmbus_channel *channel) 71 { 72 return (u8)channel->offermsg.monitorid % 32; 73 } 74 75 static u32 channel_pending(struct vmbus_channel *channel, 76 struct hv_monitor_page *monitor_page) 77 { 78 u8 monitor_group = channel_monitor_group(channel); 79 return monitor_page->trigger_group[monitor_group].pending; 80 } 81 82 static u32 channel_latency(struct vmbus_channel *channel, 83 struct hv_monitor_page *monitor_page) 84 { 85 u8 monitor_group = channel_monitor_group(channel); 86 u8 monitor_offset = channel_monitor_offset(channel); 87 return monitor_page->latency[monitor_group][monitor_offset]; 88 } 89 90 static u32 channel_conn_id(struct vmbus_channel *channel, 91 struct hv_monitor_page *monitor_page) 92 { 93 u8 monitor_group = channel_monitor_group(channel); 94 u8 monitor_offset = channel_monitor_offset(channel); 95 return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id; 96 } 97 98 static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr, 99 char *buf) 100 { 101 struct hv_device *hv_dev = device_to_hv_device(dev); 102 103 if (!hv_dev->channel) 104 return -ENODEV; 105 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid); 106 } 107 static DEVICE_ATTR_RO(id); 108 109 static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr, 110 char *buf) 111 { 112 struct hv_device *hv_dev = device_to_hv_device(dev); 113 114 if (!hv_dev->channel) 115 return -ENODEV; 116 return sprintf(buf, "%d\n", hv_dev->channel->state); 117 } 118 static DEVICE_ATTR_RO(state); 119 120 static ssize_t monitor_id_show(struct device *dev, 121 struct device_attribute *dev_attr, char *buf) 122 { 123 struct hv_device *hv_dev = device_to_hv_device(dev); 124 125 if (!hv_dev->channel) 126 return -ENODEV; 127 return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid); 128 } 129 static DEVICE_ATTR_RO(monitor_id); 130 131 static ssize_t class_id_show(struct device *dev, 132 struct device_attribute *dev_attr, char *buf) 133 { 134 struct hv_device *hv_dev = device_to_hv_device(dev); 135 136 if (!hv_dev->channel) 137 return -ENODEV; 138 return sprintf(buf, "{%pUl}\n", 139 hv_dev->channel->offermsg.offer.if_type.b); 140 } 141 static DEVICE_ATTR_RO(class_id); 142 143 static ssize_t device_id_show(struct device *dev, 144 struct device_attribute *dev_attr, char *buf) 145 { 146 struct hv_device *hv_dev = device_to_hv_device(dev); 147 148 if (!hv_dev->channel) 149 return -ENODEV; 150 return sprintf(buf, "{%pUl}\n", 151 hv_dev->channel->offermsg.offer.if_instance.b); 152 } 153 static DEVICE_ATTR_RO(device_id); 154 155 static ssize_t modalias_show(struct device *dev, 156 struct device_attribute *dev_attr, char *buf) 157 { 158 struct hv_device *hv_dev = device_to_hv_device(dev); 159 char alias_name[VMBUS_ALIAS_LEN + 1]; 160 161 print_alias_name(hv_dev, alias_name); 162 return sprintf(buf, "vmbus:%s\n", alias_name); 163 } 164 static DEVICE_ATTR_RO(modalias); 165 166 static ssize_t server_monitor_pending_show(struct device *dev, 167 struct device_attribute *dev_attr, 168 char *buf) 169 { 170 struct hv_device *hv_dev = device_to_hv_device(dev); 171 172 if (!hv_dev->channel) 173 return -ENODEV; 174 return sprintf(buf, "%d\n", 175 channel_pending(hv_dev->channel, 176 vmbus_connection.monitor_pages[1])); 177 } 178 static DEVICE_ATTR_RO(server_monitor_pending); 179 180 static ssize_t client_monitor_pending_show(struct device *dev, 181 struct device_attribute *dev_attr, 182 char *buf) 183 { 184 struct hv_device *hv_dev = device_to_hv_device(dev); 185 186 if (!hv_dev->channel) 187 return -ENODEV; 188 return sprintf(buf, "%d\n", 189 channel_pending(hv_dev->channel, 190 vmbus_connection.monitor_pages[1])); 191 } 192 static DEVICE_ATTR_RO(client_monitor_pending); 193 194 static ssize_t server_monitor_latency_show(struct device *dev, 195 struct device_attribute *dev_attr, 196 char *buf) 197 { 198 struct hv_device *hv_dev = device_to_hv_device(dev); 199 200 if (!hv_dev->channel) 201 return -ENODEV; 202 return sprintf(buf, "%d\n", 203 channel_latency(hv_dev->channel, 204 vmbus_connection.monitor_pages[0])); 205 } 206 static DEVICE_ATTR_RO(server_monitor_latency); 207 208 static ssize_t client_monitor_latency_show(struct device *dev, 209 struct device_attribute *dev_attr, 210 char *buf) 211 { 212 struct hv_device *hv_dev = device_to_hv_device(dev); 213 214 if (!hv_dev->channel) 215 return -ENODEV; 216 return sprintf(buf, "%d\n", 217 channel_latency(hv_dev->channel, 218 vmbus_connection.monitor_pages[1])); 219 } 220 static DEVICE_ATTR_RO(client_monitor_latency); 221 222 static ssize_t server_monitor_conn_id_show(struct device *dev, 223 struct device_attribute *dev_attr, 224 char *buf) 225 { 226 struct hv_device *hv_dev = device_to_hv_device(dev); 227 228 if (!hv_dev->channel) 229 return -ENODEV; 230 return sprintf(buf, "%d\n", 231 channel_conn_id(hv_dev->channel, 232 vmbus_connection.monitor_pages[0])); 233 } 234 static DEVICE_ATTR_RO(server_monitor_conn_id); 235 236 static ssize_t client_monitor_conn_id_show(struct device *dev, 237 struct device_attribute *dev_attr, 238 char *buf) 239 { 240 struct hv_device *hv_dev = device_to_hv_device(dev); 241 242 if (!hv_dev->channel) 243 return -ENODEV; 244 return sprintf(buf, "%d\n", 245 channel_conn_id(hv_dev->channel, 246 vmbus_connection.monitor_pages[1])); 247 } 248 static DEVICE_ATTR_RO(client_monitor_conn_id); 249 250 static ssize_t out_intr_mask_show(struct device *dev, 251 struct device_attribute *dev_attr, char *buf) 252 { 253 struct hv_device *hv_dev = device_to_hv_device(dev); 254 struct hv_ring_buffer_debug_info outbound; 255 256 if (!hv_dev->channel) 257 return -ENODEV; 258 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound); 259 return sprintf(buf, "%d\n", outbound.current_interrupt_mask); 260 } 261 static DEVICE_ATTR_RO(out_intr_mask); 262 263 static ssize_t out_read_index_show(struct device *dev, 264 struct device_attribute *dev_attr, char *buf) 265 { 266 struct hv_device *hv_dev = device_to_hv_device(dev); 267 struct hv_ring_buffer_debug_info outbound; 268 269 if (!hv_dev->channel) 270 return -ENODEV; 271 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound); 272 return sprintf(buf, "%d\n", outbound.current_read_index); 273 } 274 static DEVICE_ATTR_RO(out_read_index); 275 276 static ssize_t out_write_index_show(struct device *dev, 277 struct device_attribute *dev_attr, 278 char *buf) 279 { 280 struct hv_device *hv_dev = device_to_hv_device(dev); 281 struct hv_ring_buffer_debug_info outbound; 282 283 if (!hv_dev->channel) 284 return -ENODEV; 285 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound); 286 return sprintf(buf, "%d\n", outbound.current_write_index); 287 } 288 static DEVICE_ATTR_RO(out_write_index); 289 290 static ssize_t out_read_bytes_avail_show(struct device *dev, 291 struct device_attribute *dev_attr, 292 char *buf) 293 { 294 struct hv_device *hv_dev = device_to_hv_device(dev); 295 struct hv_ring_buffer_debug_info outbound; 296 297 if (!hv_dev->channel) 298 return -ENODEV; 299 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound); 300 return sprintf(buf, "%d\n", outbound.bytes_avail_toread); 301 } 302 static DEVICE_ATTR_RO(out_read_bytes_avail); 303 304 static ssize_t out_write_bytes_avail_show(struct device *dev, 305 struct device_attribute *dev_attr, 306 char *buf) 307 { 308 struct hv_device *hv_dev = device_to_hv_device(dev); 309 struct hv_ring_buffer_debug_info outbound; 310 311 if (!hv_dev->channel) 312 return -ENODEV; 313 hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound); 314 return sprintf(buf, "%d\n", outbound.bytes_avail_towrite); 315 } 316 static DEVICE_ATTR_RO(out_write_bytes_avail); 317 318 static ssize_t in_intr_mask_show(struct device *dev, 319 struct device_attribute *dev_attr, char *buf) 320 { 321 struct hv_device *hv_dev = device_to_hv_device(dev); 322 struct hv_ring_buffer_debug_info inbound; 323 324 if (!hv_dev->channel) 325 return -ENODEV; 326 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound); 327 return sprintf(buf, "%d\n", inbound.current_interrupt_mask); 328 } 329 static DEVICE_ATTR_RO(in_intr_mask); 330 331 static ssize_t in_read_index_show(struct device *dev, 332 struct device_attribute *dev_attr, char *buf) 333 { 334 struct hv_device *hv_dev = device_to_hv_device(dev); 335 struct hv_ring_buffer_debug_info inbound; 336 337 if (!hv_dev->channel) 338 return -ENODEV; 339 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound); 340 return sprintf(buf, "%d\n", inbound.current_read_index); 341 } 342 static DEVICE_ATTR_RO(in_read_index); 343 344 static ssize_t in_write_index_show(struct device *dev, 345 struct device_attribute *dev_attr, char *buf) 346 { 347 struct hv_device *hv_dev = device_to_hv_device(dev); 348 struct hv_ring_buffer_debug_info inbound; 349 350 if (!hv_dev->channel) 351 return -ENODEV; 352 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound); 353 return sprintf(buf, "%d\n", inbound.current_write_index); 354 } 355 static DEVICE_ATTR_RO(in_write_index); 356 357 static ssize_t in_read_bytes_avail_show(struct device *dev, 358 struct device_attribute *dev_attr, 359 char *buf) 360 { 361 struct hv_device *hv_dev = device_to_hv_device(dev); 362 struct hv_ring_buffer_debug_info inbound; 363 364 if (!hv_dev->channel) 365 return -ENODEV; 366 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound); 367 return sprintf(buf, "%d\n", inbound.bytes_avail_toread); 368 } 369 static DEVICE_ATTR_RO(in_read_bytes_avail); 370 371 static ssize_t in_write_bytes_avail_show(struct device *dev, 372 struct device_attribute *dev_attr, 373 char *buf) 374 { 375 struct hv_device *hv_dev = device_to_hv_device(dev); 376 struct hv_ring_buffer_debug_info inbound; 377 378 if (!hv_dev->channel) 379 return -ENODEV; 380 hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound); 381 return sprintf(buf, "%d\n", inbound.bytes_avail_towrite); 382 } 383 static DEVICE_ATTR_RO(in_write_bytes_avail); 384 385 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */ 386 static struct attribute *vmbus_attrs[] = { 387 &dev_attr_id.attr, 388 &dev_attr_state.attr, 389 &dev_attr_monitor_id.attr, 390 &dev_attr_class_id.attr, 391 &dev_attr_device_id.attr, 392 &dev_attr_modalias.attr, 393 &dev_attr_server_monitor_pending.attr, 394 &dev_attr_client_monitor_pending.attr, 395 &dev_attr_server_monitor_latency.attr, 396 &dev_attr_client_monitor_latency.attr, 397 &dev_attr_server_monitor_conn_id.attr, 398 &dev_attr_client_monitor_conn_id.attr, 399 &dev_attr_out_intr_mask.attr, 400 &dev_attr_out_read_index.attr, 401 &dev_attr_out_write_index.attr, 402 &dev_attr_out_read_bytes_avail.attr, 403 &dev_attr_out_write_bytes_avail.attr, 404 &dev_attr_in_intr_mask.attr, 405 &dev_attr_in_read_index.attr, 406 &dev_attr_in_write_index.attr, 407 &dev_attr_in_read_bytes_avail.attr, 408 &dev_attr_in_write_bytes_avail.attr, 409 NULL, 410 }; 411 ATTRIBUTE_GROUPS(vmbus); 412 413 /* 414 * vmbus_uevent - add uevent for our device 415 * 416 * This routine is invoked when a device is added or removed on the vmbus to 417 * generate a uevent to udev in the userspace. The udev will then look at its 418 * rule and the uevent generated here to load the appropriate driver 419 * 420 * The alias string will be of the form vmbus:guid where guid is the string 421 * representation of the device guid (each byte of the guid will be 422 * represented with two hex characters. 423 */ 424 static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env) 425 { 426 struct hv_device *dev = device_to_hv_device(device); 427 int ret; 428 char alias_name[VMBUS_ALIAS_LEN + 1]; 429 430 print_alias_name(dev, alias_name); 431 ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name); 432 return ret; 433 } 434 435 static uuid_le null_guid; 436 437 static inline bool is_null_guid(const __u8 *guid) 438 { 439 if (memcmp(guid, &null_guid, sizeof(uuid_le))) 440 return false; 441 return true; 442 } 443 444 /* 445 * Return a matching hv_vmbus_device_id pointer. 446 * If there is no match, return NULL. 447 */ 448 static const struct hv_vmbus_device_id *hv_vmbus_get_id( 449 const struct hv_vmbus_device_id *id, 450 __u8 *guid) 451 { 452 for (; !is_null_guid(id->guid); id++) 453 if (!memcmp(&id->guid, guid, sizeof(uuid_le))) 454 return id; 455 456 return NULL; 457 } 458 459 460 461 /* 462 * vmbus_match - Attempt to match the specified device to the specified driver 463 */ 464 static int vmbus_match(struct device *device, struct device_driver *driver) 465 { 466 struct hv_driver *drv = drv_to_hv_drv(driver); 467 struct hv_device *hv_dev = device_to_hv_device(device); 468 469 if (hv_vmbus_get_id(drv->id_table, hv_dev->dev_type.b)) 470 return 1; 471 472 return 0; 473 } 474 475 /* 476 * vmbus_probe - Add the new vmbus's child device 477 */ 478 static int vmbus_probe(struct device *child_device) 479 { 480 int ret = 0; 481 struct hv_driver *drv = 482 drv_to_hv_drv(child_device->driver); 483 struct hv_device *dev = device_to_hv_device(child_device); 484 const struct hv_vmbus_device_id *dev_id; 485 486 dev_id = hv_vmbus_get_id(drv->id_table, dev->dev_type.b); 487 if (drv->probe) { 488 ret = drv->probe(dev, dev_id); 489 if (ret != 0) 490 pr_err("probe failed for device %s (%d)\n", 491 dev_name(child_device), ret); 492 493 } else { 494 pr_err("probe not set for driver %s\n", 495 dev_name(child_device)); 496 ret = -ENODEV; 497 } 498 return ret; 499 } 500 501 /* 502 * vmbus_remove - Remove a vmbus device 503 */ 504 static int vmbus_remove(struct device *child_device) 505 { 506 struct hv_driver *drv = drv_to_hv_drv(child_device->driver); 507 struct hv_device *dev = device_to_hv_device(child_device); 508 509 if (drv->remove) 510 drv->remove(dev); 511 else 512 pr_err("remove not set for driver %s\n", 513 dev_name(child_device)); 514 515 return 0; 516 } 517 518 519 /* 520 * vmbus_shutdown - Shutdown a vmbus device 521 */ 522 static void vmbus_shutdown(struct device *child_device) 523 { 524 struct hv_driver *drv; 525 struct hv_device *dev = device_to_hv_device(child_device); 526 527 528 /* The device may not be attached yet */ 529 if (!child_device->driver) 530 return; 531 532 drv = drv_to_hv_drv(child_device->driver); 533 534 if (drv->shutdown) 535 drv->shutdown(dev); 536 537 return; 538 } 539 540 541 /* 542 * vmbus_device_release - Final callback release of the vmbus child device 543 */ 544 static void vmbus_device_release(struct device *device) 545 { 546 struct hv_device *hv_dev = device_to_hv_device(device); 547 548 kfree(hv_dev); 549 550 } 551 552 /* The one and only one */ 553 static struct bus_type hv_bus = { 554 .name = "vmbus", 555 .match = vmbus_match, 556 .shutdown = vmbus_shutdown, 557 .remove = vmbus_remove, 558 .probe = vmbus_probe, 559 .uevent = vmbus_uevent, 560 .dev_groups = vmbus_groups, 561 }; 562 563 static const char *driver_name = "hyperv"; 564 565 566 struct onmessage_work_context { 567 struct work_struct work; 568 struct hv_message msg; 569 }; 570 571 static void vmbus_onmessage_work(struct work_struct *work) 572 { 573 struct onmessage_work_context *ctx; 574 575 ctx = container_of(work, struct onmessage_work_context, 576 work); 577 vmbus_onmessage(&ctx->msg); 578 kfree(ctx); 579 } 580 581 static void vmbus_on_msg_dpc(unsigned long data) 582 { 583 int cpu = smp_processor_id(); 584 void *page_addr = hv_context.synic_message_page[cpu]; 585 struct hv_message *msg = (struct hv_message *)page_addr + 586 VMBUS_MESSAGE_SINT; 587 struct onmessage_work_context *ctx; 588 589 while (1) { 590 if (msg->header.message_type == HVMSG_NONE) { 591 /* no msg */ 592 break; 593 } else { 594 ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC); 595 if (ctx == NULL) 596 continue; 597 INIT_WORK(&ctx->work, vmbus_onmessage_work); 598 memcpy(&ctx->msg, msg, sizeof(*msg)); 599 queue_work(vmbus_connection.work_queue, &ctx->work); 600 } 601 602 msg->header.message_type = HVMSG_NONE; 603 604 /* 605 * Make sure the write to MessageType (ie set to 606 * HVMSG_NONE) happens before we read the 607 * MessagePending and EOMing. Otherwise, the EOMing 608 * will not deliver any more messages since there is 609 * no empty slot 610 */ 611 mb(); 612 613 if (msg->header.message_flags.msg_pending) { 614 /* 615 * This will cause message queue rescan to 616 * possibly deliver another msg from the 617 * hypervisor 618 */ 619 wrmsrl(HV_X64_MSR_EOM, 0); 620 } 621 } 622 } 623 624 static irqreturn_t vmbus_isr(int irq, void *dev_id) 625 { 626 int cpu = smp_processor_id(); 627 void *page_addr; 628 struct hv_message *msg; 629 union hv_synic_event_flags *event; 630 bool handled = false; 631 632 page_addr = hv_context.synic_event_page[cpu]; 633 if (page_addr == NULL) 634 return IRQ_NONE; 635 636 event = (union hv_synic_event_flags *)page_addr + 637 VMBUS_MESSAGE_SINT; 638 /* 639 * Check for events before checking for messages. This is the order 640 * in which events and messages are checked in Windows guests on 641 * Hyper-V, and the Windows team suggested we do the same. 642 */ 643 644 if ((vmbus_proto_version == VERSION_WS2008) || 645 (vmbus_proto_version == VERSION_WIN7)) { 646 647 /* Since we are a child, we only need to check bit 0 */ 648 if (sync_test_and_clear_bit(0, 649 (unsigned long *) &event->flags32[0])) { 650 handled = true; 651 } 652 } else { 653 /* 654 * Our host is win8 or above. The signaling mechanism 655 * has changed and we can directly look at the event page. 656 * If bit n is set then we have an interrup on the channel 657 * whose id is n. 658 */ 659 handled = true; 660 } 661 662 if (handled) 663 tasklet_schedule(hv_context.event_dpc[cpu]); 664 665 666 page_addr = hv_context.synic_message_page[cpu]; 667 msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT; 668 669 /* Check if there are actual msgs to be processed */ 670 if (msg->header.message_type != HVMSG_NONE) { 671 handled = true; 672 tasklet_schedule(&msg_dpc); 673 } 674 675 if (handled) 676 return IRQ_HANDLED; 677 else 678 return IRQ_NONE; 679 } 680 681 /* 682 * vmbus interrupt flow handler: 683 * vmbus interrupts can concurrently occur on multiple CPUs and 684 * can be handled concurrently. 685 */ 686 687 static void vmbus_flow_handler(unsigned int irq, struct irq_desc *desc) 688 { 689 kstat_incr_irqs_this_cpu(irq, desc); 690 691 desc->action->handler(irq, desc->action->dev_id); 692 } 693 694 /* 695 * vmbus_bus_init -Main vmbus driver initialization routine. 696 * 697 * Here, we 698 * - initialize the vmbus driver context 699 * - invoke the vmbus hv main init routine 700 * - get the irq resource 701 * - retrieve the channel offers 702 */ 703 static int vmbus_bus_init(int irq) 704 { 705 int ret; 706 707 /* Hypervisor initialization...setup hypercall page..etc */ 708 ret = hv_init(); 709 if (ret != 0) { 710 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret); 711 return ret; 712 } 713 714 tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0); 715 716 ret = bus_register(&hv_bus); 717 if (ret) 718 goto err_cleanup; 719 720 ret = request_irq(irq, vmbus_isr, 0, driver_name, hv_acpi_dev); 721 722 if (ret != 0) { 723 pr_err("Unable to request IRQ %d\n", 724 irq); 725 goto err_unregister; 726 } 727 728 /* 729 * Vmbus interrupts can be handled concurrently on 730 * different CPUs. Establish an appropriate interrupt flow 731 * handler that can support this model. 732 */ 733 irq_set_handler(irq, vmbus_flow_handler); 734 735 /* 736 * Register our interrupt handler. 737 */ 738 hv_register_vmbus_handler(irq, vmbus_isr); 739 740 ret = hv_synic_alloc(); 741 if (ret) 742 goto err_alloc; 743 /* 744 * Initialize the per-cpu interrupt state and 745 * connect to the host. 746 */ 747 on_each_cpu(hv_synic_init, NULL, 1); 748 ret = vmbus_connect(); 749 if (ret) 750 goto err_alloc; 751 752 vmbus_request_offers(); 753 754 return 0; 755 756 err_alloc: 757 hv_synic_free(); 758 free_irq(irq, hv_acpi_dev); 759 760 err_unregister: 761 bus_unregister(&hv_bus); 762 763 err_cleanup: 764 hv_cleanup(); 765 766 return ret; 767 } 768 769 /** 770 * __vmbus_child_driver_register - Register a vmbus's driver 771 * @drv: Pointer to driver structure you want to register 772 * @owner: owner module of the drv 773 * @mod_name: module name string 774 * 775 * Registers the given driver with Linux through the 'driver_register()' call 776 * and sets up the hyper-v vmbus handling for this driver. 777 * It will return the state of the 'driver_register()' call. 778 * 779 */ 780 int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name) 781 { 782 int ret; 783 784 pr_info("registering driver %s\n", hv_driver->name); 785 786 ret = vmbus_exists(); 787 if (ret < 0) 788 return ret; 789 790 hv_driver->driver.name = hv_driver->name; 791 hv_driver->driver.owner = owner; 792 hv_driver->driver.mod_name = mod_name; 793 hv_driver->driver.bus = &hv_bus; 794 795 ret = driver_register(&hv_driver->driver); 796 797 return ret; 798 } 799 EXPORT_SYMBOL_GPL(__vmbus_driver_register); 800 801 /** 802 * vmbus_driver_unregister() - Unregister a vmbus's driver 803 * @drv: Pointer to driver structure you want to un-register 804 * 805 * Un-register the given driver that was previous registered with a call to 806 * vmbus_driver_register() 807 */ 808 void vmbus_driver_unregister(struct hv_driver *hv_driver) 809 { 810 pr_info("unregistering driver %s\n", hv_driver->name); 811 812 if (!vmbus_exists()) 813 driver_unregister(&hv_driver->driver); 814 } 815 EXPORT_SYMBOL_GPL(vmbus_driver_unregister); 816 817 /* 818 * vmbus_device_create - Creates and registers a new child device 819 * on the vmbus. 820 */ 821 struct hv_device *vmbus_device_create(uuid_le *type, 822 uuid_le *instance, 823 struct vmbus_channel *channel) 824 { 825 struct hv_device *child_device_obj; 826 827 child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL); 828 if (!child_device_obj) { 829 pr_err("Unable to allocate device object for child device\n"); 830 return NULL; 831 } 832 833 child_device_obj->channel = channel; 834 memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le)); 835 memcpy(&child_device_obj->dev_instance, instance, 836 sizeof(uuid_le)); 837 838 839 return child_device_obj; 840 } 841 842 /* 843 * vmbus_device_register - Register the child device 844 */ 845 int vmbus_device_register(struct hv_device *child_device_obj) 846 { 847 int ret = 0; 848 849 static atomic_t device_num = ATOMIC_INIT(0); 850 851 dev_set_name(&child_device_obj->device, "vmbus_0_%d", 852 atomic_inc_return(&device_num)); 853 854 child_device_obj->device.bus = &hv_bus; 855 child_device_obj->device.parent = &hv_acpi_dev->dev; 856 child_device_obj->device.release = vmbus_device_release; 857 858 /* 859 * Register with the LDM. This will kick off the driver/device 860 * binding...which will eventually call vmbus_match() and vmbus_probe() 861 */ 862 ret = device_register(&child_device_obj->device); 863 864 if (ret) 865 pr_err("Unable to register child device\n"); 866 else 867 pr_debug("child device %s registered\n", 868 dev_name(&child_device_obj->device)); 869 870 return ret; 871 } 872 873 /* 874 * vmbus_device_unregister - Remove the specified child device 875 * from the vmbus. 876 */ 877 void vmbus_device_unregister(struct hv_device *device_obj) 878 { 879 pr_debug("child device %s unregistered\n", 880 dev_name(&device_obj->device)); 881 882 /* 883 * Kick off the process of unregistering the device. 884 * This will call vmbus_remove() and eventually vmbus_device_release() 885 */ 886 device_unregister(&device_obj->device); 887 } 888 889 890 /* 891 * VMBUS is an acpi enumerated device. Get the the IRQ information 892 * from DSDT. 893 */ 894 895 static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *irq) 896 { 897 898 if (res->type == ACPI_RESOURCE_TYPE_IRQ) { 899 struct acpi_resource_irq *irqp; 900 irqp = &res->data.irq; 901 902 *((unsigned int *)irq) = irqp->interrupts[0]; 903 } 904 905 return AE_OK; 906 } 907 908 static int vmbus_acpi_add(struct acpi_device *device) 909 { 910 acpi_status result; 911 912 hv_acpi_dev = device; 913 914 result = acpi_walk_resources(device->handle, METHOD_NAME__CRS, 915 vmbus_walk_resources, &irq); 916 917 if (ACPI_FAILURE(result)) { 918 complete(&probe_event); 919 return -ENODEV; 920 } 921 complete(&probe_event); 922 return 0; 923 } 924 925 static const struct acpi_device_id vmbus_acpi_device_ids[] = { 926 {"VMBUS", 0}, 927 {"VMBus", 0}, 928 {"", 0}, 929 }; 930 MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids); 931 932 static struct acpi_driver vmbus_acpi_driver = { 933 .name = "vmbus", 934 .ids = vmbus_acpi_device_ids, 935 .ops = { 936 .add = vmbus_acpi_add, 937 }, 938 }; 939 940 static int __init hv_acpi_init(void) 941 { 942 int ret, t; 943 944 if (x86_hyper != &x86_hyper_ms_hyperv) 945 return -ENODEV; 946 947 init_completion(&probe_event); 948 949 /* 950 * Get irq resources first. 951 */ 952 953 ret = acpi_bus_register_driver(&vmbus_acpi_driver); 954 955 if (ret) 956 return ret; 957 958 t = wait_for_completion_timeout(&probe_event, 5*HZ); 959 if (t == 0) { 960 ret = -ETIMEDOUT; 961 goto cleanup; 962 } 963 964 if (irq <= 0) { 965 ret = -ENODEV; 966 goto cleanup; 967 } 968 969 ret = vmbus_bus_init(irq); 970 if (ret) 971 goto cleanup; 972 973 return 0; 974 975 cleanup: 976 acpi_bus_unregister_driver(&vmbus_acpi_driver); 977 hv_acpi_dev = NULL; 978 return ret; 979 } 980 981 static void __exit vmbus_exit(void) 982 { 983 984 free_irq(irq, hv_acpi_dev); 985 vmbus_free_channels(); 986 bus_unregister(&hv_bus); 987 hv_cleanup(); 988 acpi_bus_unregister_driver(&vmbus_acpi_driver); 989 } 990 991 992 MODULE_LICENSE("GPL"); 993 994 subsys_initcall(hv_acpi_init); 995 module_exit(vmbus_exit); 996