2 * Copyright (c) 2009, Microsoft Corporation.
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.
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
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.
18 * Haiyang Zhang <haiyangz@microsoft.com>
19 * Hank Janssen <hjanssen@microsoft.com>
20 * K. Y. Srinivasan <kys@microsoft.com>
23 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25 #include <linux/init.h>
26 #include <linux/module.h>
27 #include <linux/device.h>
28 #include <linux/interrupt.h>
29 #include <linux/sysctl.h>
30 #include <linux/slab.h>
31 #include <linux/acpi.h>
32 #include <linux/completion.h>
33 #include <linux/hyperv.h>
34 #include <linux/kernel_stat.h>
35 #include <linux/clockchips.h>
36 #include <linux/cpu.h>
37 #include <asm/hyperv.h>
38 #include <asm/hypervisor.h>
39 #include <asm/mshyperv.h>
40 #include "hyperv_vmbus.h"
42 static struct acpi_device
*hv_acpi_dev
;
44 static struct tasklet_struct msg_dpc
;
45 static struct completion probe_event
;
48 struct resource hyperv_mmio
= {
49 .name
= "hyperv mmio",
50 .flags
= IORESOURCE_MEM
,
52 EXPORT_SYMBOL_GPL(hyperv_mmio
);
54 static int vmbus_exists(void)
56 if (hv_acpi_dev
== NULL
)
62 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
63 static void print_alias_name(struct hv_device
*hv_dev
, char *alias_name
)
66 for (i
= 0; i
< VMBUS_ALIAS_LEN
; i
+= 2)
67 sprintf(&alias_name
[i
], "%02x", hv_dev
->dev_type
.b
[i
/2]);
70 static u8
channel_monitor_group(struct vmbus_channel
*channel
)
72 return (u8
)channel
->offermsg
.monitorid
/ 32;
75 static u8
channel_monitor_offset(struct vmbus_channel
*channel
)
77 return (u8
)channel
->offermsg
.monitorid
% 32;
80 static u32
channel_pending(struct vmbus_channel
*channel
,
81 struct hv_monitor_page
*monitor_page
)
83 u8 monitor_group
= channel_monitor_group(channel
);
84 return monitor_page
->trigger_group
[monitor_group
].pending
;
87 static u32
channel_latency(struct vmbus_channel
*channel
,
88 struct hv_monitor_page
*monitor_page
)
90 u8 monitor_group
= channel_monitor_group(channel
);
91 u8 monitor_offset
= channel_monitor_offset(channel
);
92 return monitor_page
->latency
[monitor_group
][monitor_offset
];
95 static u32
channel_conn_id(struct vmbus_channel
*channel
,
96 struct hv_monitor_page
*monitor_page
)
98 u8 monitor_group
= channel_monitor_group(channel
);
99 u8 monitor_offset
= channel_monitor_offset(channel
);
100 return monitor_page
->parameter
[monitor_group
][monitor_offset
].connectionid
.u
.id
;
103 static ssize_t
id_show(struct device
*dev
, struct device_attribute
*dev_attr
,
106 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
108 if (!hv_dev
->channel
)
110 return sprintf(buf
, "%d\n", hv_dev
->channel
->offermsg
.child_relid
);
112 static DEVICE_ATTR_RO(id
);
114 static ssize_t
state_show(struct device
*dev
, struct device_attribute
*dev_attr
,
117 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
119 if (!hv_dev
->channel
)
121 return sprintf(buf
, "%d\n", hv_dev
->channel
->state
);
123 static DEVICE_ATTR_RO(state
);
125 static ssize_t
monitor_id_show(struct device
*dev
,
126 struct device_attribute
*dev_attr
, char *buf
)
128 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
130 if (!hv_dev
->channel
)
132 return sprintf(buf
, "%d\n", hv_dev
->channel
->offermsg
.monitorid
);
134 static DEVICE_ATTR_RO(monitor_id
);
136 static ssize_t
class_id_show(struct device
*dev
,
137 struct device_attribute
*dev_attr
, char *buf
)
139 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
141 if (!hv_dev
->channel
)
143 return sprintf(buf
, "{%pUl}\n",
144 hv_dev
->channel
->offermsg
.offer
.if_type
.b
);
146 static DEVICE_ATTR_RO(class_id
);
148 static ssize_t
device_id_show(struct device
*dev
,
149 struct device_attribute
*dev_attr
, char *buf
)
151 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
153 if (!hv_dev
->channel
)
155 return sprintf(buf
, "{%pUl}\n",
156 hv_dev
->channel
->offermsg
.offer
.if_instance
.b
);
158 static DEVICE_ATTR_RO(device_id
);
160 static ssize_t
modalias_show(struct device
*dev
,
161 struct device_attribute
*dev_attr
, char *buf
)
163 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
164 char alias_name
[VMBUS_ALIAS_LEN
+ 1];
166 print_alias_name(hv_dev
, alias_name
);
167 return sprintf(buf
, "vmbus:%s\n", alias_name
);
169 static DEVICE_ATTR_RO(modalias
);
171 static ssize_t
server_monitor_pending_show(struct device
*dev
,
172 struct device_attribute
*dev_attr
,
175 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
177 if (!hv_dev
->channel
)
179 return sprintf(buf
, "%d\n",
180 channel_pending(hv_dev
->channel
,
181 vmbus_connection
.monitor_pages
[1]));
183 static DEVICE_ATTR_RO(server_monitor_pending
);
185 static ssize_t
client_monitor_pending_show(struct device
*dev
,
186 struct device_attribute
*dev_attr
,
189 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
191 if (!hv_dev
->channel
)
193 return sprintf(buf
, "%d\n",
194 channel_pending(hv_dev
->channel
,
195 vmbus_connection
.monitor_pages
[1]));
197 static DEVICE_ATTR_RO(client_monitor_pending
);
199 static ssize_t
server_monitor_latency_show(struct device
*dev
,
200 struct device_attribute
*dev_attr
,
203 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
205 if (!hv_dev
->channel
)
207 return sprintf(buf
, "%d\n",
208 channel_latency(hv_dev
->channel
,
209 vmbus_connection
.monitor_pages
[0]));
211 static DEVICE_ATTR_RO(server_monitor_latency
);
213 static ssize_t
client_monitor_latency_show(struct device
*dev
,
214 struct device_attribute
*dev_attr
,
217 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
219 if (!hv_dev
->channel
)
221 return sprintf(buf
, "%d\n",
222 channel_latency(hv_dev
->channel
,
223 vmbus_connection
.monitor_pages
[1]));
225 static DEVICE_ATTR_RO(client_monitor_latency
);
227 static ssize_t
server_monitor_conn_id_show(struct device
*dev
,
228 struct device_attribute
*dev_attr
,
231 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
233 if (!hv_dev
->channel
)
235 return sprintf(buf
, "%d\n",
236 channel_conn_id(hv_dev
->channel
,
237 vmbus_connection
.monitor_pages
[0]));
239 static DEVICE_ATTR_RO(server_monitor_conn_id
);
241 static ssize_t
client_monitor_conn_id_show(struct device
*dev
,
242 struct device_attribute
*dev_attr
,
245 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
247 if (!hv_dev
->channel
)
249 return sprintf(buf
, "%d\n",
250 channel_conn_id(hv_dev
->channel
,
251 vmbus_connection
.monitor_pages
[1]));
253 static DEVICE_ATTR_RO(client_monitor_conn_id
);
255 static ssize_t
out_intr_mask_show(struct device
*dev
,
256 struct device_attribute
*dev_attr
, char *buf
)
258 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
259 struct hv_ring_buffer_debug_info outbound
;
261 if (!hv_dev
->channel
)
263 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
, &outbound
);
264 return sprintf(buf
, "%d\n", outbound
.current_interrupt_mask
);
266 static DEVICE_ATTR_RO(out_intr_mask
);
268 static ssize_t
out_read_index_show(struct device
*dev
,
269 struct device_attribute
*dev_attr
, char *buf
)
271 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
272 struct hv_ring_buffer_debug_info outbound
;
274 if (!hv_dev
->channel
)
276 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
, &outbound
);
277 return sprintf(buf
, "%d\n", outbound
.current_read_index
);
279 static DEVICE_ATTR_RO(out_read_index
);
281 static ssize_t
out_write_index_show(struct device
*dev
,
282 struct device_attribute
*dev_attr
,
285 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
286 struct hv_ring_buffer_debug_info outbound
;
288 if (!hv_dev
->channel
)
290 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
, &outbound
);
291 return sprintf(buf
, "%d\n", outbound
.current_write_index
);
293 static DEVICE_ATTR_RO(out_write_index
);
295 static ssize_t
out_read_bytes_avail_show(struct device
*dev
,
296 struct device_attribute
*dev_attr
,
299 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
300 struct hv_ring_buffer_debug_info outbound
;
302 if (!hv_dev
->channel
)
304 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
, &outbound
);
305 return sprintf(buf
, "%d\n", outbound
.bytes_avail_toread
);
307 static DEVICE_ATTR_RO(out_read_bytes_avail
);
309 static ssize_t
out_write_bytes_avail_show(struct device
*dev
,
310 struct device_attribute
*dev_attr
,
313 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
314 struct hv_ring_buffer_debug_info outbound
;
316 if (!hv_dev
->channel
)
318 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
, &outbound
);
319 return sprintf(buf
, "%d\n", outbound
.bytes_avail_towrite
);
321 static DEVICE_ATTR_RO(out_write_bytes_avail
);
323 static ssize_t
in_intr_mask_show(struct device
*dev
,
324 struct device_attribute
*dev_attr
, char *buf
)
326 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
327 struct hv_ring_buffer_debug_info inbound
;
329 if (!hv_dev
->channel
)
331 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
332 return sprintf(buf
, "%d\n", inbound
.current_interrupt_mask
);
334 static DEVICE_ATTR_RO(in_intr_mask
);
336 static ssize_t
in_read_index_show(struct device
*dev
,
337 struct device_attribute
*dev_attr
, char *buf
)
339 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
340 struct hv_ring_buffer_debug_info inbound
;
342 if (!hv_dev
->channel
)
344 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
345 return sprintf(buf
, "%d\n", inbound
.current_read_index
);
347 static DEVICE_ATTR_RO(in_read_index
);
349 static ssize_t
in_write_index_show(struct device
*dev
,
350 struct device_attribute
*dev_attr
, char *buf
)
352 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
353 struct hv_ring_buffer_debug_info inbound
;
355 if (!hv_dev
->channel
)
357 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
358 return sprintf(buf
, "%d\n", inbound
.current_write_index
);
360 static DEVICE_ATTR_RO(in_write_index
);
362 static ssize_t
in_read_bytes_avail_show(struct device
*dev
,
363 struct device_attribute
*dev_attr
,
366 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
367 struct hv_ring_buffer_debug_info inbound
;
369 if (!hv_dev
->channel
)
371 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
372 return sprintf(buf
, "%d\n", inbound
.bytes_avail_toread
);
374 static DEVICE_ATTR_RO(in_read_bytes_avail
);
376 static ssize_t
in_write_bytes_avail_show(struct device
*dev
,
377 struct device_attribute
*dev_attr
,
380 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
381 struct hv_ring_buffer_debug_info inbound
;
383 if (!hv_dev
->channel
)
385 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
386 return sprintf(buf
, "%d\n", inbound
.bytes_avail_towrite
);
388 static DEVICE_ATTR_RO(in_write_bytes_avail
);
390 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
391 static struct attribute
*vmbus_attrs
[] = {
393 &dev_attr_state
.attr
,
394 &dev_attr_monitor_id
.attr
,
395 &dev_attr_class_id
.attr
,
396 &dev_attr_device_id
.attr
,
397 &dev_attr_modalias
.attr
,
398 &dev_attr_server_monitor_pending
.attr
,
399 &dev_attr_client_monitor_pending
.attr
,
400 &dev_attr_server_monitor_latency
.attr
,
401 &dev_attr_client_monitor_latency
.attr
,
402 &dev_attr_server_monitor_conn_id
.attr
,
403 &dev_attr_client_monitor_conn_id
.attr
,
404 &dev_attr_out_intr_mask
.attr
,
405 &dev_attr_out_read_index
.attr
,
406 &dev_attr_out_write_index
.attr
,
407 &dev_attr_out_read_bytes_avail
.attr
,
408 &dev_attr_out_write_bytes_avail
.attr
,
409 &dev_attr_in_intr_mask
.attr
,
410 &dev_attr_in_read_index
.attr
,
411 &dev_attr_in_write_index
.attr
,
412 &dev_attr_in_read_bytes_avail
.attr
,
413 &dev_attr_in_write_bytes_avail
.attr
,
416 ATTRIBUTE_GROUPS(vmbus
);
419 * vmbus_uevent - add uevent for our device
421 * This routine is invoked when a device is added or removed on the vmbus to
422 * generate a uevent to udev in the userspace. The udev will then look at its
423 * rule and the uevent generated here to load the appropriate driver
425 * The alias string will be of the form vmbus:guid where guid is the string
426 * representation of the device guid (each byte of the guid will be
427 * represented with two hex characters.
429 static int vmbus_uevent(struct device
*device
, struct kobj_uevent_env
*env
)
431 struct hv_device
*dev
= device_to_hv_device(device
);
433 char alias_name
[VMBUS_ALIAS_LEN
+ 1];
435 print_alias_name(dev
, alias_name
);
436 ret
= add_uevent_var(env
, "MODALIAS=vmbus:%s", alias_name
);
440 static const uuid_le null_guid
;
442 static inline bool is_null_guid(const __u8
*guid
)
444 if (memcmp(guid
, &null_guid
, sizeof(uuid_le
)))
450 * Return a matching hv_vmbus_device_id pointer.
451 * If there is no match, return NULL.
453 static const struct hv_vmbus_device_id
*hv_vmbus_get_id(
454 const struct hv_vmbus_device_id
*id
,
457 for (; !is_null_guid(id
->guid
); id
++)
458 if (!memcmp(&id
->guid
, guid
, sizeof(uuid_le
)))
467 * vmbus_match - Attempt to match the specified device to the specified driver
469 static int vmbus_match(struct device
*device
, struct device_driver
*driver
)
471 struct hv_driver
*drv
= drv_to_hv_drv(driver
);
472 struct hv_device
*hv_dev
= device_to_hv_device(device
);
474 if (hv_vmbus_get_id(drv
->id_table
, hv_dev
->dev_type
.b
))
481 * vmbus_probe - Add the new vmbus's child device
483 static int vmbus_probe(struct device
*child_device
)
486 struct hv_driver
*drv
=
487 drv_to_hv_drv(child_device
->driver
);
488 struct hv_device
*dev
= device_to_hv_device(child_device
);
489 const struct hv_vmbus_device_id
*dev_id
;
491 dev_id
= hv_vmbus_get_id(drv
->id_table
, dev
->dev_type
.b
);
493 ret
= drv
->probe(dev
, dev_id
);
495 pr_err("probe failed for device %s (%d)\n",
496 dev_name(child_device
), ret
);
499 pr_err("probe not set for driver %s\n",
500 dev_name(child_device
));
507 * vmbus_remove - Remove a vmbus device
509 static int vmbus_remove(struct device
*child_device
)
511 struct hv_driver
*drv
= drv_to_hv_drv(child_device
->driver
);
512 struct hv_device
*dev
= device_to_hv_device(child_device
);
517 pr_err("remove not set for driver %s\n",
518 dev_name(child_device
));
525 * vmbus_shutdown - Shutdown a vmbus device
527 static void vmbus_shutdown(struct device
*child_device
)
529 struct hv_driver
*drv
;
530 struct hv_device
*dev
= device_to_hv_device(child_device
);
533 /* The device may not be attached yet */
534 if (!child_device
->driver
)
537 drv
= drv_to_hv_drv(child_device
->driver
);
547 * vmbus_device_release - Final callback release of the vmbus child device
549 static void vmbus_device_release(struct device
*device
)
551 struct hv_device
*hv_dev
= device_to_hv_device(device
);
557 /* The one and only one */
558 static struct bus_type hv_bus
= {
560 .match
= vmbus_match
,
561 .shutdown
= vmbus_shutdown
,
562 .remove
= vmbus_remove
,
563 .probe
= vmbus_probe
,
564 .uevent
= vmbus_uevent
,
565 .dev_groups
= vmbus_groups
,
568 struct onmessage_work_context
{
569 struct work_struct work
;
570 struct hv_message msg
;
573 static void vmbus_onmessage_work(struct work_struct
*work
)
575 struct onmessage_work_context
*ctx
;
577 ctx
= container_of(work
, struct onmessage_work_context
,
579 vmbus_onmessage(&ctx
->msg
);
583 static void hv_process_timer_expiration(struct hv_message
*msg
, int cpu
)
585 struct clock_event_device
*dev
= hv_context
.clk_evt
[cpu
];
587 if (dev
->event_handler
)
588 dev
->event_handler(dev
);
590 msg
->header
.message_type
= HVMSG_NONE
;
593 * Make sure the write to MessageType (ie set to
594 * HVMSG_NONE) happens before we read the
595 * MessagePending and EOMing. Otherwise, the EOMing
596 * will not deliver any more messages since there is
601 if (msg
->header
.message_flags
.msg_pending
) {
603 * This will cause message queue rescan to
604 * possibly deliver another msg from the
607 wrmsrl(HV_X64_MSR_EOM
, 0);
611 static void vmbus_on_msg_dpc(unsigned long data
)
613 int cpu
= smp_processor_id();
614 void *page_addr
= hv_context
.synic_message_page
[cpu
];
615 struct hv_message
*msg
= (struct hv_message
*)page_addr
+
617 struct onmessage_work_context
*ctx
;
620 if (msg
->header
.message_type
== HVMSG_NONE
) {
624 ctx
= kmalloc(sizeof(*ctx
), GFP_ATOMIC
);
627 INIT_WORK(&ctx
->work
, vmbus_onmessage_work
);
628 memcpy(&ctx
->msg
, msg
, sizeof(*msg
));
629 queue_work(vmbus_connection
.work_queue
, &ctx
->work
);
632 msg
->header
.message_type
= HVMSG_NONE
;
635 * Make sure the write to MessageType (ie set to
636 * HVMSG_NONE) happens before we read the
637 * MessagePending and EOMing. Otherwise, the EOMing
638 * will not deliver any more messages since there is
643 if (msg
->header
.message_flags
.msg_pending
) {
645 * This will cause message queue rescan to
646 * possibly deliver another msg from the
649 wrmsrl(HV_X64_MSR_EOM
, 0);
654 static void vmbus_isr(void)
656 int cpu
= smp_processor_id();
658 struct hv_message
*msg
;
659 union hv_synic_event_flags
*event
;
660 bool handled
= false;
662 page_addr
= hv_context
.synic_event_page
[cpu
];
663 if (page_addr
== NULL
)
666 event
= (union hv_synic_event_flags
*)page_addr
+
669 * Check for events before checking for messages. This is the order
670 * in which events and messages are checked in Windows guests on
671 * Hyper-V, and the Windows team suggested we do the same.
674 if ((vmbus_proto_version
== VERSION_WS2008
) ||
675 (vmbus_proto_version
== VERSION_WIN7
)) {
677 /* Since we are a child, we only need to check bit 0 */
678 if (sync_test_and_clear_bit(0,
679 (unsigned long *) &event
->flags32
[0])) {
684 * Our host is win8 or above. The signaling mechanism
685 * has changed and we can directly look at the event page.
686 * If bit n is set then we have an interrup on the channel
693 tasklet_schedule(hv_context
.event_dpc
[cpu
]);
696 page_addr
= hv_context
.synic_message_page
[cpu
];
697 msg
= (struct hv_message
*)page_addr
+ VMBUS_MESSAGE_SINT
;
699 /* Check if there are actual msgs to be processed */
700 if (msg
->header
.message_type
!= HVMSG_NONE
) {
701 if (msg
->header
.message_type
== HVMSG_TIMER_EXPIRED
)
702 hv_process_timer_expiration(msg
, cpu
);
704 tasklet_schedule(&msg_dpc
);
708 #ifdef CONFIG_HOTPLUG_CPU
709 static int hyperv_cpu_disable(void)
714 static void hv_cpu_hotplug_quirk(bool vmbus_loaded
)
716 static void *previous_cpu_disable
;
719 * Offlining a CPU when running on newer hypervisors (WS2012R2, Win8,
720 * ...) is not supported at this moment as channel interrupts are
721 * distributed across all of them.
724 if ((vmbus_proto_version
== VERSION_WS2008
) ||
725 (vmbus_proto_version
== VERSION_WIN7
))
729 previous_cpu_disable
= smp_ops
.cpu_disable
;
730 smp_ops
.cpu_disable
= hyperv_cpu_disable
;
731 pr_notice("CPU offlining is not supported by hypervisor\n");
732 } else if (previous_cpu_disable
)
733 smp_ops
.cpu_disable
= previous_cpu_disable
;
736 static void hv_cpu_hotplug_quirk(bool vmbus_loaded
)
742 * vmbus_bus_init -Main vmbus driver initialization routine.
745 * - initialize the vmbus driver context
746 * - invoke the vmbus hv main init routine
747 * - get the irq resource
748 * - retrieve the channel offers
750 static int vmbus_bus_init(int irq
)
754 /* Hypervisor initialization...setup hypercall page..etc */
757 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret
);
761 tasklet_init(&msg_dpc
, vmbus_on_msg_dpc
, 0);
763 ret
= bus_register(&hv_bus
);
767 hv_setup_vmbus_irq(vmbus_isr
);
769 ret
= hv_synic_alloc();
773 * Initialize the per-cpu interrupt state and
774 * connect to the host.
776 on_each_cpu(hv_synic_init
, NULL
, 1);
777 ret
= vmbus_connect();
781 hv_cpu_hotplug_quirk(true);
782 vmbus_request_offers();
788 hv_remove_vmbus_irq();
790 bus_unregister(&hv_bus
);
799 * __vmbus_child_driver_register - Register a vmbus's driver
800 * @drv: Pointer to driver structure you want to register
801 * @owner: owner module of the drv
802 * @mod_name: module name string
804 * Registers the given driver with Linux through the 'driver_register()' call
805 * and sets up the hyper-v vmbus handling for this driver.
806 * It will return the state of the 'driver_register()' call.
809 int __vmbus_driver_register(struct hv_driver
*hv_driver
, struct module
*owner
, const char *mod_name
)
813 pr_info("registering driver %s\n", hv_driver
->name
);
815 ret
= vmbus_exists();
819 hv_driver
->driver
.name
= hv_driver
->name
;
820 hv_driver
->driver
.owner
= owner
;
821 hv_driver
->driver
.mod_name
= mod_name
;
822 hv_driver
->driver
.bus
= &hv_bus
;
824 ret
= driver_register(&hv_driver
->driver
);
828 EXPORT_SYMBOL_GPL(__vmbus_driver_register
);
831 * vmbus_driver_unregister() - Unregister a vmbus's driver
832 * @drv: Pointer to driver structure you want to un-register
834 * Un-register the given driver that was previous registered with a call to
835 * vmbus_driver_register()
837 void vmbus_driver_unregister(struct hv_driver
*hv_driver
)
839 pr_info("unregistering driver %s\n", hv_driver
->name
);
842 driver_unregister(&hv_driver
->driver
);
844 EXPORT_SYMBOL_GPL(vmbus_driver_unregister
);
847 * vmbus_device_create - Creates and registers a new child device
850 struct hv_device
*vmbus_device_create(const uuid_le
*type
,
851 const uuid_le
*instance
,
852 struct vmbus_channel
*channel
)
854 struct hv_device
*child_device_obj
;
856 child_device_obj
= kzalloc(sizeof(struct hv_device
), GFP_KERNEL
);
857 if (!child_device_obj
) {
858 pr_err("Unable to allocate device object for child device\n");
862 child_device_obj
->channel
= channel
;
863 memcpy(&child_device_obj
->dev_type
, type
, sizeof(uuid_le
));
864 memcpy(&child_device_obj
->dev_instance
, instance
,
868 return child_device_obj
;
872 * vmbus_device_register - Register the child device
874 int vmbus_device_register(struct hv_device
*child_device_obj
)
878 static atomic_t device_num
= ATOMIC_INIT(0);
880 dev_set_name(&child_device_obj
->device
, "vmbus_0_%d",
881 atomic_inc_return(&device_num
));
883 child_device_obj
->device
.bus
= &hv_bus
;
884 child_device_obj
->device
.parent
= &hv_acpi_dev
->dev
;
885 child_device_obj
->device
.release
= vmbus_device_release
;
888 * Register with the LDM. This will kick off the driver/device
889 * binding...which will eventually call vmbus_match() and vmbus_probe()
891 ret
= device_register(&child_device_obj
->device
);
894 pr_err("Unable to register child device\n");
896 pr_debug("child device %s registered\n",
897 dev_name(&child_device_obj
->device
));
903 * vmbus_device_unregister - Remove the specified child device
906 void vmbus_device_unregister(struct hv_device
*device_obj
)
908 pr_debug("child device %s unregistered\n",
909 dev_name(&device_obj
->device
));
912 * Kick off the process of unregistering the device.
913 * This will call vmbus_remove() and eventually vmbus_device_release()
915 device_unregister(&device_obj
->device
);
920 * VMBUS is an acpi enumerated device. Get the the information we
924 static acpi_status
vmbus_walk_resources(struct acpi_resource
*res
, void *ctx
)
927 case ACPI_RESOURCE_TYPE_IRQ
:
928 irq
= res
->data
.irq
.interrupts
[0];
931 case ACPI_RESOURCE_TYPE_ADDRESS64
:
932 hyperv_mmio
.start
= res
->data
.address64
.address
.minimum
;
933 hyperv_mmio
.end
= res
->data
.address64
.address
.maximum
;
940 static int vmbus_acpi_add(struct acpi_device
*device
)
943 int ret_val
= -ENODEV
;
945 hv_acpi_dev
= device
;
947 result
= acpi_walk_resources(device
->handle
, METHOD_NAME__CRS
,
948 vmbus_walk_resources
, NULL
);
950 if (ACPI_FAILURE(result
))
953 * The parent of the vmbus acpi device (Gen2 firmware) is the VMOD that
954 * has the mmio ranges. Get that.
956 if (device
->parent
) {
957 result
= acpi_walk_resources(device
->parent
->handle
,
959 vmbus_walk_resources
, NULL
);
961 if (ACPI_FAILURE(result
))
963 if (hyperv_mmio
.start
&& hyperv_mmio
.end
)
964 request_resource(&iomem_resource
, &hyperv_mmio
);
969 complete(&probe_event
);
973 static const struct acpi_device_id vmbus_acpi_device_ids
[] = {
978 MODULE_DEVICE_TABLE(acpi
, vmbus_acpi_device_ids
);
980 static struct acpi_driver vmbus_acpi_driver
= {
982 .ids
= vmbus_acpi_device_ids
,
984 .add
= vmbus_acpi_add
,
988 static int __init
hv_acpi_init(void)
992 if (x86_hyper
!= &x86_hyper_ms_hyperv
)
995 init_completion(&probe_event
);
998 * Get irq resources first.
1000 ret
= acpi_bus_register_driver(&vmbus_acpi_driver
);
1005 t
= wait_for_completion_timeout(&probe_event
, 5*HZ
);
1016 ret
= vmbus_bus_init(irq
);
1023 acpi_bus_unregister_driver(&vmbus_acpi_driver
);
1028 static void __exit
vmbus_exit(void)
1030 hv_remove_vmbus_irq();
1031 vmbus_free_channels();
1032 bus_unregister(&hv_bus
);
1034 acpi_bus_unregister_driver(&vmbus_acpi_driver
);
1035 hv_cpu_hotplug_quirk(false);
1039 MODULE_LICENSE("GPL");
1041 subsys_initcall(hv_acpi_init
);
1042 module_exit(vmbus_exit
);