vmbus_drv.c 23.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
 * Copyright (c) 2009, Microsoft Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place - Suite 330, Boston, MA 02111-1307 USA.
 *
 * Authors:
 *   Haiyang Zhang <haiyangz@microsoft.com>
 *   Hank Janssen  <hjanssen@microsoft.com>
20
 *   K. Y. Srinivasan <kys@microsoft.com>
21
 *
22
 */
23 24
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

25 26 27 28 29 30
#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/sysctl.h>
31
#include <linux/slab.h>
32 33
#include <linux/acpi.h>
#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
struct hv_device_info {
50 51
	struct hv_ring_buffer_debug_info inbound;
	struct hv_ring_buffer_debug_info outbound;
52 53
};

54 55 56 57 58 59 60 61
static int vmbus_exists(void)
{
	if (hv_acpi_dev == NULL)
		return -ENODEV;

	return 0;
}

62

63 64 65 66 67 68
static void get_channel_info(struct hv_device *device,
			     struct hv_device_info *info)
{
	if (!device->channel)
		return;

69 70
	hv_ringbuffer_get_debuginfo(&device->channel->inbound, &info->inbound);
	hv_ringbuffer_get_debuginfo(&device->channel->outbound, &info->outbound);
71
}
72

73 74 75 76 77 78 79 80
#define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
static void print_alias_name(struct hv_device *hv_dev, char *alias_name)
{
	int i;
	for (i = 0; i < VMBUS_ALIAS_LEN; i += 2)
		sprintf(&alias_name[i], "%02x", hv_dev->dev_type.b[i/2]);
}

81 82 83 84 85 86
/*
 * vmbus_show_device_attr - Show the device attribute in sysfs.
 *
 * This is invoked when user does a
 * "cat /sys/bus/vmbus/devices/<busdevice>/<attr name>"
 */
87 88
static ssize_t vmbus_show_device_attr(struct device *dev,
				      struct device_attribute *dev_attr,
89 90
				      char *buf)
{
91
	struct hv_device *hv_dev = device_to_hv_device(dev);
92 93
	struct hv_device_info *device_info;
	int ret = 0;
94

95 96 97
	device_info = kzalloc(sizeof(struct hv_device_info), GFP_KERNEL);
	if (!device_info)
		return ret;
98

99
	get_channel_info(hv_dev, device_info);
100

101
	if (!strcmp(dev_attr->attr.name, "out_intr_mask")) {
102
		ret = sprintf(buf, "%d\n", device_info->outbound.current_interrupt_mask);
103
	} else if (!strcmp(dev_attr->attr.name, "out_read_index")) {
104
		ret = sprintf(buf, "%d\n", device_info->outbound.current_read_index);
105
	} else if (!strcmp(dev_attr->attr.name, "out_write_index")) {
106
		ret = sprintf(buf, "%d\n", device_info->outbound.current_write_index);
107
	} else if (!strcmp(dev_attr->attr.name, "out_read_bytes_avail")) {
108 109
		ret = sprintf(buf, "%d\n",
			       device_info->outbound.bytes_avail_toread);
110
	} else if (!strcmp(dev_attr->attr.name, "out_write_bytes_avail")) {
111 112
		ret = sprintf(buf, "%d\n",
			       device_info->outbound.bytes_avail_towrite);
113
	} else if (!strcmp(dev_attr->attr.name, "in_intr_mask")) {
114
		ret = sprintf(buf, "%d\n", device_info->inbound.current_interrupt_mask);
115
	} else if (!strcmp(dev_attr->attr.name, "in_read_index")) {
116
		ret = sprintf(buf, "%d\n", device_info->inbound.current_read_index);
117
	} else if (!strcmp(dev_attr->attr.name, "in_write_index")) {
118
		ret = sprintf(buf, "%d\n", device_info->inbound.current_write_index);
119
	} else if (!strcmp(dev_attr->attr.name, "in_read_bytes_avail")) {
120 121
		ret = sprintf(buf, "%d\n",
			       device_info->inbound.bytes_avail_toread);
122
	} else if (!strcmp(dev_attr->attr.name, "in_write_bytes_avail")) {
123 124
		ret = sprintf(buf, "%d\n",
			       device_info->inbound.bytes_avail_towrite);
125
	}
126 127 128

	kfree(device_info);
	return ret;
129
}
130

131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
static u8 channel_monitor_group(struct vmbus_channel *channel)
{
	return (u8)channel->offermsg.monitorid / 32;
}

static u8 channel_monitor_offset(struct vmbus_channel *channel)
{
	return (u8)channel->offermsg.monitorid % 32;
}

static u32 channel_pending(struct vmbus_channel *channel,
			   struct hv_monitor_page *monitor_page)
{
	u8 monitor_group = channel_monitor_group(channel);
	return monitor_page->trigger_group[monitor_group].pending;
}

148 149 150 151 152 153 154 155
static u32 channel_latency(struct vmbus_channel *channel,
			   struct hv_monitor_page *monitor_page)
{
	u8 monitor_group = channel_monitor_group(channel);
	u8 monitor_offset = channel_monitor_offset(channel);
	return monitor_page->latency[monitor_group][monitor_offset];
}

156 157 158 159 160 161 162 163
static u32 channel_conn_id(struct vmbus_channel *channel,
			   struct hv_monitor_page *monitor_page)
{
	u8 monitor_group = channel_monitor_group(channel);
	u8 monitor_offset = channel_monitor_offset(channel);
	return monitor_page->parameter[monitor_group][monitor_offset].connectionid.u.id;
}

164 165 166 167 168 169 170 171 172 173 174
static ssize_t id_show(struct device *dev, struct device_attribute *dev_attr,
		       char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n", hv_dev->channel->offermsg.child_relid);
}
static DEVICE_ATTR_RO(id);

175 176 177 178 179 180 181 182 183 184 185
static ssize_t state_show(struct device *dev, struct device_attribute *dev_attr,
			  char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n", hv_dev->channel->state);
}
static DEVICE_ATTR_RO(state);

186 187 188 189 190 191 192 193 194 195 196
static ssize_t monitor_id_show(struct device *dev,
			       struct device_attribute *dev_attr, char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n", hv_dev->channel->offermsg.monitorid);
}
static DEVICE_ATTR_RO(monitor_id);

197 198 199 200 201 202 203 204 205 206 207 208
static ssize_t class_id_show(struct device *dev,
			       struct device_attribute *dev_attr, char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "{%pUl}\n",
		       hv_dev->channel->offermsg.offer.if_type.b);
}
static DEVICE_ATTR_RO(class_id);

209 210 211 212 213 214 215 216 217 218 219 220
static ssize_t device_id_show(struct device *dev,
			      struct device_attribute *dev_attr, char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "{%pUl}\n",
		       hv_dev->channel->offermsg.offer.if_instance.b);
}
static DEVICE_ATTR_RO(device_id);

221 222 223 224 225 226 227 228 229 230 231
static ssize_t modalias_show(struct device *dev,
			     struct device_attribute *dev_attr, char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);
	char alias_name[VMBUS_ALIAS_LEN + 1];

	print_alias_name(hv_dev, alias_name);
	return sprintf(buf, "vmbus:%s\n", alias_name);
}
static DEVICE_ATTR_RO(modalias);

232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
static ssize_t server_monitor_pending_show(struct device *dev,
					   struct device_attribute *dev_attr,
					   char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n",
		       channel_pending(hv_dev->channel,
				       vmbus_connection.monitor_pages[1]));
}
static DEVICE_ATTR_RO(server_monitor_pending);

static ssize_t client_monitor_pending_show(struct device *dev,
					   struct device_attribute *dev_attr,
					   char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n",
		       channel_pending(hv_dev->channel,
				       vmbus_connection.monitor_pages[1]));
}
static DEVICE_ATTR_RO(client_monitor_pending);
259

260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
static ssize_t server_monitor_latency_show(struct device *dev,
					   struct device_attribute *dev_attr,
					   char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n",
		       channel_latency(hv_dev->channel,
				       vmbus_connection.monitor_pages[0]));
}
static DEVICE_ATTR_RO(server_monitor_latency);

static ssize_t client_monitor_latency_show(struct device *dev,
					   struct device_attribute *dev_attr,
					   char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n",
		       channel_latency(hv_dev->channel,
				       vmbus_connection.monitor_pages[1]));
}
static DEVICE_ATTR_RO(client_monitor_latency);

288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
static ssize_t server_monitor_conn_id_show(struct device *dev,
					   struct device_attribute *dev_attr,
					   char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n",
		       channel_conn_id(hv_dev->channel,
				       vmbus_connection.monitor_pages[0]));
}
static DEVICE_ATTR_RO(server_monitor_conn_id);

static ssize_t client_monitor_conn_id_show(struct device *dev,
					   struct device_attribute *dev_attr,
					   char *buf)
{
	struct hv_device *hv_dev = device_to_hv_device(dev);

	if (!hv_dev->channel)
		return -ENODEV;
	return sprintf(buf, "%d\n",
		       channel_conn_id(hv_dev->channel,
				       vmbus_connection.monitor_pages[1]));
}
static DEVICE_ATTR_RO(client_monitor_conn_id);

316 317
static struct attribute *vmbus_attrs[] = {
	&dev_attr_id.attr,
318
	&dev_attr_state.attr,
319
	&dev_attr_monitor_id.attr,
320
	&dev_attr_class_id.attr,
321
	&dev_attr_device_id.attr,
322
	&dev_attr_modalias.attr,
323 324
	&dev_attr_server_monitor_pending.attr,
	&dev_attr_client_monitor_pending.attr,
325 326
	&dev_attr_server_monitor_latency.attr,
	&dev_attr_client_monitor_latency.attr,
327 328
	&dev_attr_server_monitor_conn_id.attr,
	&dev_attr_client_monitor_conn_id.attr,
329 330 331 332
	NULL,
};
ATTRIBUTE_GROUPS(vmbus);

333
/* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
static struct device_attribute vmbus_device_attrs[] = {
	__ATTR(out_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL),
	__ATTR(out_read_index, S_IRUGO, vmbus_show_device_attr, NULL),
	__ATTR(out_write_index, S_IRUGO, vmbus_show_device_attr, NULL),
	__ATTR(out_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
	__ATTR(out_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),

	__ATTR(in_intr_mask, S_IRUGO, vmbus_show_device_attr, NULL),
	__ATTR(in_read_index, S_IRUGO, vmbus_show_device_attr, NULL),
	__ATTR(in_write_index, S_IRUGO, vmbus_show_device_attr, NULL),
	__ATTR(in_read_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
	__ATTR(in_write_bytes_avail, S_IRUGO, vmbus_show_device_attr, NULL),
	__ATTR_NULL
};

349

350 351 352 353 354 355
/*
 * vmbus_uevent - add uevent for our device
 *
 * This routine is invoked when a device is added or removed on the vmbus to
 * generate a uevent to udev in the userspace. The udev will then look at its
 * rule and the uevent generated here to load the appropriate driver
356 357 358 359
 *
 * The alias string will be of the form vmbus:guid where guid is the string
 * representation of the device guid (each byte of the guid will be
 * represented with two hex characters.
360 361 362 363
 */
static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env)
{
	struct hv_device *dev = device_to_hv_device(device);
364 365
	int ret;
	char alias_name[VMBUS_ALIAS_LEN + 1];
366

367
	print_alias_name(dev, alias_name);
368 369
	ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name);
	return ret;
370 371
}

372 373 374 375 376 377 378 379 380
static uuid_le null_guid;

static inline bool is_null_guid(const __u8 *guid)
{
	if (memcmp(guid, &null_guid, sizeof(uuid_le)))
		return false;
	return true;
}

381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
/*
 * Return a matching hv_vmbus_device_id pointer.
 * If there is no match, return NULL.
 */
static const struct hv_vmbus_device_id *hv_vmbus_get_id(
					const struct hv_vmbus_device_id *id,
					__u8 *guid)
{
	for (; !is_null_guid(id->guid); id++)
		if (!memcmp(&id->guid, guid, sizeof(uuid_le)))
			return id;

	return NULL;
}


397 398 399 400 401 402 403

/*
 * vmbus_match - Attempt to match the specified device to the specified driver
 */
static int vmbus_match(struct device *device, struct device_driver *driver)
{
	struct hv_driver *drv = drv_to_hv_drv(driver);
404
	struct hv_device *hv_dev = device_to_hv_device(device);
405

406 407
	if (hv_vmbus_get_id(drv->id_table, hv_dev->dev_type.b))
		return 1;
408

409
	return 0;
410 411
}

412 413 414 415 416 417 418 419
/*
 * vmbus_probe - Add the new vmbus's child device
 */
static int vmbus_probe(struct device *child_device)
{
	int ret = 0;
	struct hv_driver *drv =
			drv_to_hv_drv(child_device->driver);
420
	struct hv_device *dev = device_to_hv_device(child_device);
421
	const struct hv_vmbus_device_id *dev_id;
422

423
	dev_id = hv_vmbus_get_id(drv->id_table, dev->dev_type.b);
424
	if (drv->probe) {
425
		ret = drv->probe(dev, dev_id);
426
		if (ret != 0)
427 428
			pr_err("probe failed for device %s (%d)\n",
			       dev_name(child_device), ret);
429 430

	} else {
431 432
		pr_err("probe not set for driver %s\n",
		       dev_name(child_device));
433
		ret = -ENODEV;
434 435 436 437
	}
	return ret;
}

438 439 440 441 442
/*
 * vmbus_remove - Remove a vmbus device
 */
static int vmbus_remove(struct device *child_device)
{
443
	struct hv_driver *drv = drv_to_hv_drv(child_device->driver);
444
	struct hv_device *dev = device_to_hv_device(child_device);
445

446 447 448 449 450
	if (drv->remove)
		drv->remove(dev);
	else
		pr_err("remove not set for driver %s\n",
			dev_name(child_device));
451 452 453 454

	return 0;
}

455 456 457 458 459 460 461

/*
 * vmbus_shutdown - Shutdown a vmbus device
 */
static void vmbus_shutdown(struct device *child_device)
{
	struct hv_driver *drv;
462
	struct hv_device *dev = device_to_hv_device(child_device);
463 464 465 466 467 468 469 470


	/* The device may not be attached yet */
	if (!child_device->driver)
		return;

	drv = drv_to_hv_drv(child_device->driver);

471 472
	if (drv->shutdown)
		drv->shutdown(dev);
473 474 475 476

	return;
}

477 478 479 480 481 482

/*
 * vmbus_device_release - Final callback release of the vmbus child device
 */
static void vmbus_device_release(struct device *device)
{
483
	struct hv_device *hv_dev = device_to_hv_device(device);
484

485
	kfree(hv_dev);
486 487 488

}

489
/* The one and only one */
490 491 492 493 494 495 496 497
static struct bus_type  hv_bus = {
	.name =		"vmbus",
	.match =		vmbus_match,
	.shutdown =		vmbus_shutdown,
	.remove =		vmbus_remove,
	.probe =		vmbus_probe,
	.uevent =		vmbus_uevent,
	.dev_attrs =	vmbus_device_attrs,
498
	.dev_groups =		vmbus_groups,
499 500
};

501
static const char *driver_name = "hyperv";
G
Greg Kroah-Hartman 已提交
502 503


504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
struct onmessage_work_context {
	struct work_struct work;
	struct hv_message msg;
};

static void vmbus_onmessage_work(struct work_struct *work)
{
	struct onmessage_work_context *ctx;

	ctx = container_of(work, struct onmessage_work_context,
			   work);
	vmbus_onmessage(&ctx->msg);
	kfree(ctx);
}

519
static void vmbus_on_msg_dpc(unsigned long data)
G
Greg Kroah-Hartman 已提交
520 521 522 523 524
{
	int cpu = smp_processor_id();
	void *page_addr = hv_context.synic_message_page[cpu];
	struct hv_message *msg = (struct hv_message *)page_addr +
				  VMBUS_MESSAGE_SINT;
525
	struct onmessage_work_context *ctx;
G
Greg Kroah-Hartman 已提交
526 527 528 529 530 531

	while (1) {
		if (msg->header.message_type == HVMSG_NONE) {
			/* no msg */
			break;
		} else {
532 533
			ctx = kmalloc(sizeof(*ctx), GFP_ATOMIC);
			if (ctx == NULL)
G
Greg Kroah-Hartman 已提交
534
				continue;
535 536
			INIT_WORK(&ctx->work, vmbus_onmessage_work);
			memcpy(&ctx->msg, msg, sizeof(*msg));
537
			queue_work(vmbus_connection.work_queue, &ctx->work);
G
Greg Kroah-Hartman 已提交
538 539 540 541 542 543 544 545 546 547 548
		}

		msg->header.message_type = HVMSG_NONE;

		/*
		 * Make sure the write to MessageType (ie set to
		 * HVMSG_NONE) happens before we read the
		 * MessagePending and EOMing. Otherwise, the EOMing
		 * will not deliver any more messages since there is
		 * no empty slot
		 */
549
		mb();
G
Greg Kroah-Hartman 已提交
550 551 552 553 554 555 556 557 558 559 560 561

		if (msg->header.message_flags.msg_pending) {
			/*
			 * This will cause message queue rescan to
			 * possibly deliver another msg from the
			 * hypervisor
			 */
			wrmsrl(HV_X64_MSR_EOM, 0);
		}
	}
}

562
static irqreturn_t vmbus_isr(int irq, void *dev_id)
G
Greg Kroah-Hartman 已提交
563 564 565 566 567
{
	int cpu = smp_processor_id();
	void *page_addr;
	struct hv_message *msg;
	union hv_synic_event_flags *event;
568
	bool handled = false;
G
Greg Kroah-Hartman 已提交
569

570 571 572 573 574 575
	page_addr = hv_context.synic_event_page[cpu];
	if (page_addr == NULL)
		return IRQ_NONE;

	event = (union hv_synic_event_flags *)page_addr +
					 VMBUS_MESSAGE_SINT;
576 577 578 579 580
	/*
	 * Check for events before checking for messages. This is the order
	 * in which events and messages are checked in Windows guests on
	 * Hyper-V, and the Windows team suggested we do the same.
	 */
G
Greg Kroah-Hartman 已提交
581

582 583
	if ((vmbus_proto_version == VERSION_WS2008) ||
		(vmbus_proto_version == VERSION_WIN7)) {
G
Greg Kroah-Hartman 已提交
584

585 586 587 588 589 590 591 592 593 594 595 596
		/* Since we are a child, we only need to check bit 0 */
		if (sync_test_and_clear_bit(0,
			(unsigned long *) &event->flags32[0])) {
			handled = true;
		}
	} else {
		/*
		 * Our host is win8 or above. The signaling mechanism
		 * has changed and we can directly look at the event page.
		 * If bit n is set then we have an interrup on the channel
		 * whose id is n.
		 */
597 598
		handled = true;
	}
599

600
	if (handled)
601
		tasklet_schedule(hv_context.event_dpc[cpu]);
602 603


604 605 606 607 608 609 610 611 612
	page_addr = hv_context.synic_message_page[cpu];
	msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;

	/* Check if there are actual msgs to be processed */
	if (msg->header.message_type != HVMSG_NONE) {
		handled = true;
		tasklet_schedule(&msg_dpc);
	}

613
	if (handled)
614
		return IRQ_HANDLED;
615
	else
616 617 618
		return IRQ_NONE;
}

619 620 621 622 623 624
/*
 * vmbus interrupt flow handler:
 * vmbus interrupts can concurrently occur on multiple CPUs and
 * can be handled concurrently.
 */

625
static void vmbus_flow_handler(unsigned int irq, struct irq_desc *desc)
626 627 628 629 630 631
{
	kstat_incr_irqs_this_cpu(irq, desc);

	desc->action->handler(irq, desc->action->dev_id);
}

632
/*
633 634 635
 * vmbus_bus_init -Main vmbus driver initialization routine.
 *
 * Here, we
636 637 638 639
 *	- initialize the vmbus driver context
 *	- invoke the vmbus hv main init routine
 *	- get the irq resource
 *	- retrieve the channel offers
640
 */
641
static int vmbus_bus_init(int irq)
642
{
643
	int ret;
644

645 646
	/* Hypervisor initialization...setup hypercall page..etc */
	ret = hv_init();
647
	if (ret != 0) {
648
		pr_err("Unable to initialize the hypervisor - 0x%x\n", ret);
649
		return ret;
650 651
	}

652
	tasklet_init(&msg_dpc, vmbus_on_msg_dpc, 0);
653

654
	ret = bus_register(&hv_bus);
655
	if (ret)
656
		goto err_cleanup;
657

658
	ret = request_irq(irq, vmbus_isr, 0, driver_name, hv_acpi_dev);
659

660
	if (ret != 0) {
661
		pr_err("Unable to request IRQ %d\n",
662
			   irq);
663
		goto err_unregister;
664 665
	}

666 667 668 669 670 671 672
	/*
	 * Vmbus interrupts can be handled concurrently on
	 * different CPUs. Establish an appropriate interrupt flow
	 * handler that can support this model.
	 */
	irq_set_handler(irq, vmbus_flow_handler);

673 674 675 676
	/*
	 * Register our interrupt handler.
	 */
	hv_register_vmbus_handler(irq, vmbus_isr);
677

678 679 680
	ret = hv_synic_alloc();
	if (ret)
		goto err_alloc;
681
	/*
682
	 * Initialize the per-cpu interrupt state and
683 684
	 * connect to the host.
	 */
685
	on_each_cpu(hv_synic_init, NULL, 1);
686
	ret = vmbus_connect();
687
	if (ret)
688
		goto err_alloc;
689

690
	vmbus_request_offers();
691

692
	return 0;
693

694 695
err_alloc:
	hv_synic_free();
696 697 698 699 700 701 702 703 704
	free_irq(irq, hv_acpi_dev);

err_unregister:
	bus_unregister(&hv_bus);

err_cleanup:
	hv_cleanup();

	return ret;
705 706
}

707
/**
708 709 710 711
 * __vmbus_child_driver_register - Register a vmbus's driver
 * @drv: Pointer to driver structure you want to register
 * @owner: owner module of the drv
 * @mod_name: module name string
712 713
 *
 * Registers the given driver with Linux through the 'driver_register()' call
714
 * and sets up the hyper-v vmbus handling for this driver.
715 716
 * It will return the state of the 'driver_register()' call.
 *
717
 */
718
int __vmbus_driver_register(struct hv_driver *hv_driver, struct module *owner, const char *mod_name)
719
{
720
	int ret;
721

722
	pr_info("registering driver %s\n", hv_driver->name);
723

724 725 726 727
	ret = vmbus_exists();
	if (ret < 0)
		return ret;

728 729 730 731
	hv_driver->driver.name = hv_driver->name;
	hv_driver->driver.owner = owner;
	hv_driver->driver.mod_name = mod_name;
	hv_driver->driver.bus = &hv_bus;
732

733
	ret = driver_register(&hv_driver->driver);
734

735
	return ret;
736
}
737
EXPORT_SYMBOL_GPL(__vmbus_driver_register);
738

739
/**
740 741
 * vmbus_driver_unregister() - Unregister a vmbus's driver
 * @drv: Pointer to driver structure you want to un-register
742
 *
743 744
 * Un-register the given driver that was previous registered with a call to
 * vmbus_driver_register()
745
 */
746
void vmbus_driver_unregister(struct hv_driver *hv_driver)
747
{
748
	pr_info("unregistering driver %s\n", hv_driver->name);
749

750
	if (!vmbus_exists())
751
		driver_unregister(&hv_driver->driver);
752
}
753
EXPORT_SYMBOL_GPL(vmbus_driver_unregister);
754

755
/*
756
 * vmbus_device_create - Creates and registers a new child device
757
 * on the vmbus.
758
 */
759
struct hv_device *vmbus_device_create(uuid_le *type,
760
					    uuid_le *instance,
761
					    struct vmbus_channel *channel)
762
{
763
	struct hv_device *child_device_obj;
764

765 766
	child_device_obj = kzalloc(sizeof(struct hv_device), GFP_KERNEL);
	if (!child_device_obj) {
767
		pr_err("Unable to allocate device object for child device\n");
768 769 770
		return NULL;
	}

771
	child_device_obj->channel = channel;
772
	memcpy(&child_device_obj->dev_type, type, sizeof(uuid_le));
773
	memcpy(&child_device_obj->dev_instance, instance,
774
	       sizeof(uuid_le));
775 776 777 778 779


	return child_device_obj;
}

780
/*
781
 * vmbus_device_register - Register the child device
782
 */
783
int vmbus_device_register(struct hv_device *child_device_obj)
784
{
785
	int ret = 0;
786

787
	static atomic_t device_num = ATOMIC_INIT(0);
788

789
	dev_set_name(&child_device_obj->device, "vmbus_0_%d",
790
		     atomic_inc_return(&device_num));
791

792
	child_device_obj->device.bus = &hv_bus;
793
	child_device_obj->device.parent = &hv_acpi_dev->dev;
794
	child_device_obj->device.release = vmbus_device_release;
795

796 797 798 799
	/*
	 * Register with the LDM. This will kick off the driver/device
	 * binding...which will eventually call vmbus_match() and vmbus_probe()
	 */
800
	ret = device_register(&child_device_obj->device);
801 802

	if (ret)
803
		pr_err("Unable to register child device\n");
804
	else
805
		pr_debug("child device %s registered\n",
806
			dev_name(&child_device_obj->device));
807 808 809 810

	return ret;
}

811
/*
812
 * vmbus_device_unregister - Remove the specified child device
813
 * from the vmbus.
814
 */
815
void vmbus_device_unregister(struct hv_device *device_obj)
816
{
817 818 819
	pr_debug("child device %s unregistered\n",
		dev_name(&device_obj->device));

820 821 822 823
	/*
	 * Kick off the process of unregistering the device.
	 * This will call vmbus_remove() and eventually vmbus_device_release()
	 */
824
	device_unregister(&device_obj->device);
825 826 827
}


828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849
/*
 * VMBUS is an acpi enumerated device. Get the the IRQ information
 * from DSDT.
 */

static acpi_status vmbus_walk_resources(struct acpi_resource *res, void *irq)
{

	if (res->type == ACPI_RESOURCE_TYPE_IRQ) {
		struct acpi_resource_irq *irqp;
		irqp = &res->data.irq;

		*((unsigned int *)irq) = irqp->interrupts[0];
	}

	return AE_OK;
}

static int vmbus_acpi_add(struct acpi_device *device)
{
	acpi_status result;

850 851
	hv_acpi_dev = device;

852 853
	result = acpi_walk_resources(device->handle, METHOD_NAME__CRS,
					vmbus_walk_resources, &irq);
854 855 856 857 858 859 860 861 862 863 864

	if (ACPI_FAILURE(result)) {
		complete(&probe_event);
		return -ENODEV;
	}
	complete(&probe_event);
	return 0;
}

static const struct acpi_device_id vmbus_acpi_device_ids[] = {
	{"VMBUS", 0},
865
	{"VMBus", 0},
866 867 868 869 870 871 872 873 874 875 876 877
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, vmbus_acpi_device_ids);

static struct acpi_driver vmbus_acpi_driver = {
	.name = "vmbus",
	.ids = vmbus_acpi_device_ids,
	.ops = {
		.add = vmbus_acpi_add,
	},
};

878
static int __init hv_acpi_init(void)
879
{
880
	int ret, t;
881

882
	if (x86_hyper != &x86_hyper_ms_hyperv)
883 884
		return -ENODEV;

885 886 887 888 889 890
	init_completion(&probe_event);

	/*
	 * Get irq resources first.
	 */

891 892
	ret = acpi_bus_register_driver(&vmbus_acpi_driver);

893 894 895
	if (ret)
		return ret;

896 897 898 899 900
	t = wait_for_completion_timeout(&probe_event, 5*HZ);
	if (t == 0) {
		ret = -ETIMEDOUT;
		goto cleanup;
	}
901 902

	if (irq <= 0) {
903 904
		ret = -ENODEV;
		goto cleanup;
905 906
	}

907 908
	ret = vmbus_bus_init(irq);
	if (ret)
909 910 911 912 913 914
		goto cleanup;

	return 0;

cleanup:
	acpi_bus_unregister_driver(&vmbus_acpi_driver);
915
	hv_acpi_dev = NULL;
916
	return ret;
917 918
}

919 920 921 922 923 924 925 926 927 928
static void __exit vmbus_exit(void)
{

	free_irq(irq, hv_acpi_dev);
	vmbus_free_channels();
	bus_unregister(&hv_bus);
	hv_cleanup();
	acpi_bus_unregister_driver(&vmbus_acpi_driver);
}

929

930
MODULE_LICENSE("GPL");
931

932
subsys_initcall(hv_acpi_init);
933
module_exit(vmbus_exit);