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/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 <asm/hypervisor.h>
38 #include "hyperv_vmbus.h"
41 static struct acpi_device
*hv_acpi_dev
;
43 static struct tasklet_struct msg_dpc
;
44 static struct tasklet_struct event_dpc
;
45 static struct completion probe_event
;
48 struct hv_device_info
{
55 u32 server_monitor_pending
;
56 u32 server_monitor_latency
;
57 u32 server_monitor_conn_id
;
58 u32 client_monitor_pending
;
59 u32 client_monitor_latency
;
60 u32 client_monitor_conn_id
;
62 struct hv_dev_port_info inbound
;
63 struct hv_dev_port_info outbound
;
66 static int vmbus_exists(void)
68 if (hv_acpi_dev
== NULL
)
75 static void get_channel_info(struct hv_device
*device
,
76 struct hv_device_info
*info
)
78 struct vmbus_channel_debug_info debug_info
;
83 vmbus_get_debug_info(device
->channel
, &debug_info
);
85 info
->chn_id
= debug_info
.relid
;
86 info
->chn_state
= debug_info
.state
;
87 memcpy(&info
->chn_type
, &debug_info
.interfacetype
,
89 memcpy(&info
->chn_instance
, &debug_info
.interface_instance
,
92 info
->monitor_id
= debug_info
.monitorid
;
94 info
->server_monitor_pending
= debug_info
.servermonitor_pending
;
95 info
->server_monitor_latency
= debug_info
.servermonitor_latency
;
96 info
->server_monitor_conn_id
= debug_info
.servermonitor_connectionid
;
98 info
->client_monitor_pending
= debug_info
.clientmonitor_pending
;
99 info
->client_monitor_latency
= debug_info
.clientmonitor_latency
;
100 info
->client_monitor_conn_id
= debug_info
.clientmonitor_connectionid
;
102 info
->inbound
.int_mask
= debug_info
.inbound
.current_interrupt_mask
;
103 info
->inbound
.read_idx
= debug_info
.inbound
.current_read_index
;
104 info
->inbound
.write_idx
= debug_info
.inbound
.current_write_index
;
105 info
->inbound
.bytes_avail_toread
=
106 debug_info
.inbound
.bytes_avail_toread
;
107 info
->inbound
.bytes_avail_towrite
=
108 debug_info
.inbound
.bytes_avail_towrite
;
110 info
->outbound
.int_mask
=
111 debug_info
.outbound
.current_interrupt_mask
;
112 info
->outbound
.read_idx
= debug_info
.outbound
.current_read_index
;
113 info
->outbound
.write_idx
= debug_info
.outbound
.current_write_index
;
114 info
->outbound
.bytes_avail_toread
=
115 debug_info
.outbound
.bytes_avail_toread
;
116 info
->outbound
.bytes_avail_towrite
=
117 debug_info
.outbound
.bytes_avail_towrite
;
120 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
121 static void print_alias_name(struct hv_device
*hv_dev
, char *alias_name
)
124 for (i
= 0; i
< VMBUS_ALIAS_LEN
; i
+= 2)
125 sprintf(&alias_name
[i
], "%02x", hv_dev
->dev_type
.b
[i
/2]);
129 * vmbus_show_device_attr - Show the device attribute in sysfs.
131 * This is invoked when user does a
132 * "cat /sys/bus/vmbus/devices/<busdevice>/<attr name>"
134 static ssize_t
vmbus_show_device_attr(struct device
*dev
,
135 struct device_attribute
*dev_attr
,
138 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
139 struct hv_device_info
*device_info
;
140 char alias_name
[VMBUS_ALIAS_LEN
+ 1];
143 device_info
= kzalloc(sizeof(struct hv_device_info
), GFP_KERNEL
);
147 get_channel_info(hv_dev
, device_info
);
149 if (!strcmp(dev_attr
->attr
.name
, "class_id")) {
150 ret
= sprintf(buf
, "{%pUl}\n", device_info
->chn_type
.b
);
151 } else if (!strcmp(dev_attr
->attr
.name
, "device_id")) {
152 ret
= sprintf(buf
, "{%pUl}\n", device_info
->chn_instance
.b
);
153 } else if (!strcmp(dev_attr
->attr
.name
, "modalias")) {
154 print_alias_name(hv_dev
, alias_name
);
155 ret
= sprintf(buf
, "vmbus:%s\n", alias_name
);
156 } else if (!strcmp(dev_attr
->attr
.name
, "state")) {
157 ret
= sprintf(buf
, "%d\n", device_info
->chn_state
);
158 } else if (!strcmp(dev_attr
->attr
.name
, "id")) {
159 ret
= sprintf(buf
, "%d\n", device_info
->chn_id
);
160 } else if (!strcmp(dev_attr
->attr
.name
, "out_intr_mask")) {
161 ret
= sprintf(buf
, "%d\n", device_info
->outbound
.int_mask
);
162 } else if (!strcmp(dev_attr
->attr
.name
, "out_read_index")) {
163 ret
= sprintf(buf
, "%d\n", device_info
->outbound
.read_idx
);
164 } else if (!strcmp(dev_attr
->attr
.name
, "out_write_index")) {
165 ret
= sprintf(buf
, "%d\n", device_info
->outbound
.write_idx
);
166 } else if (!strcmp(dev_attr
->attr
.name
, "out_read_bytes_avail")) {
167 ret
= sprintf(buf
, "%d\n",
168 device_info
->outbound
.bytes_avail_toread
);
169 } else if (!strcmp(dev_attr
->attr
.name
, "out_write_bytes_avail")) {
170 ret
= sprintf(buf
, "%d\n",
171 device_info
->outbound
.bytes_avail_towrite
);
172 } else if (!strcmp(dev_attr
->attr
.name
, "in_intr_mask")) {
173 ret
= sprintf(buf
, "%d\n", device_info
->inbound
.int_mask
);
174 } else if (!strcmp(dev_attr
->attr
.name
, "in_read_index")) {
175 ret
= sprintf(buf
, "%d\n", device_info
->inbound
.read_idx
);
176 } else if (!strcmp(dev_attr
->attr
.name
, "in_write_index")) {
177 ret
= sprintf(buf
, "%d\n", device_info
->inbound
.write_idx
);
178 } else if (!strcmp(dev_attr
->attr
.name
, "in_read_bytes_avail")) {
179 ret
= sprintf(buf
, "%d\n",
180 device_info
->inbound
.bytes_avail_toread
);
181 } else if (!strcmp(dev_attr
->attr
.name
, "in_write_bytes_avail")) {
182 ret
= sprintf(buf
, "%d\n",
183 device_info
->inbound
.bytes_avail_towrite
);
184 } else if (!strcmp(dev_attr
->attr
.name
, "monitor_id")) {
185 ret
= sprintf(buf
, "%d\n", device_info
->monitor_id
);
186 } else if (!strcmp(dev_attr
->attr
.name
, "server_monitor_pending")) {
187 ret
= sprintf(buf
, "%d\n", device_info
->server_monitor_pending
);
188 } else if (!strcmp(dev_attr
->attr
.name
, "server_monitor_latency")) {
189 ret
= sprintf(buf
, "%d\n", device_info
->server_monitor_latency
);
190 } else if (!strcmp(dev_attr
->attr
.name
, "server_monitor_conn_id")) {
191 ret
= sprintf(buf
, "%d\n",
192 device_info
->server_monitor_conn_id
);
193 } else if (!strcmp(dev_attr
->attr
.name
, "client_monitor_pending")) {
194 ret
= sprintf(buf
, "%d\n", device_info
->client_monitor_pending
);
195 } else if (!strcmp(dev_attr
->attr
.name
, "client_monitor_latency")) {
196 ret
= sprintf(buf
, "%d\n", device_info
->client_monitor_latency
);
197 } else if (!strcmp(dev_attr
->attr
.name
, "client_monitor_conn_id")) {
198 ret
= sprintf(buf
, "%d\n",
199 device_info
->client_monitor_conn_id
);
206 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
207 static struct device_attribute vmbus_device_attrs
[] = {
208 __ATTR(id
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
209 __ATTR(state
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
210 __ATTR(class_id
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
211 __ATTR(device_id
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
212 __ATTR(monitor_id
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
213 __ATTR(modalias
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
215 __ATTR(server_monitor_pending
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
216 __ATTR(server_monitor_latency
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
217 __ATTR(server_monitor_conn_id
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
219 __ATTR(client_monitor_pending
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
220 __ATTR(client_monitor_latency
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
221 __ATTR(client_monitor_conn_id
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
223 __ATTR(out_intr_mask
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
224 __ATTR(out_read_index
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
225 __ATTR(out_write_index
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
226 __ATTR(out_read_bytes_avail
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
227 __ATTR(out_write_bytes_avail
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
229 __ATTR(in_intr_mask
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
230 __ATTR(in_read_index
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
231 __ATTR(in_write_index
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
232 __ATTR(in_read_bytes_avail
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
233 __ATTR(in_write_bytes_avail
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
239 * vmbus_uevent - add uevent for our device
241 * This routine is invoked when a device is added or removed on the vmbus to
242 * generate a uevent to udev in the userspace. The udev will then look at its
243 * rule and the uevent generated here to load the appropriate driver
245 * The alias string will be of the form vmbus:guid where guid is the string
246 * representation of the device guid (each byte of the guid will be
247 * represented with two hex characters.
249 static int vmbus_uevent(struct device
*device
, struct kobj_uevent_env
*env
)
251 struct hv_device
*dev
= device_to_hv_device(device
);
253 char alias_name
[VMBUS_ALIAS_LEN
+ 1];
255 print_alias_name(dev
, alias_name
);
256 ret
= add_uevent_var(env
, "MODALIAS=vmbus:%s", alias_name
);
260 static uuid_le null_guid
;
262 static inline bool is_null_guid(const __u8
*guid
)
264 if (memcmp(guid
, &null_guid
, sizeof(uuid_le
)))
270 * Return a matching hv_vmbus_device_id pointer.
271 * If there is no match, return NULL.
273 static const struct hv_vmbus_device_id
*hv_vmbus_get_id(
274 const struct hv_vmbus_device_id
*id
,
277 for (; !is_null_guid(id
->guid
); id
++)
278 if (!memcmp(&id
->guid
, guid
, sizeof(uuid_le
)))
287 * vmbus_match - Attempt to match the specified device to the specified driver
289 static int vmbus_match(struct device
*device
, struct device_driver
*driver
)
291 struct hv_driver
*drv
= drv_to_hv_drv(driver
);
292 struct hv_device
*hv_dev
= device_to_hv_device(device
);
294 if (hv_vmbus_get_id(drv
->id_table
, hv_dev
->dev_type
.b
))
301 * vmbus_probe - Add the new vmbus's child device
303 static int vmbus_probe(struct device
*child_device
)
306 struct hv_driver
*drv
=
307 drv_to_hv_drv(child_device
->driver
);
308 struct hv_device
*dev
= device_to_hv_device(child_device
);
309 const struct hv_vmbus_device_id
*dev_id
;
311 dev_id
= hv_vmbus_get_id(drv
->id_table
, dev
->dev_type
.b
);
313 ret
= drv
->probe(dev
, dev_id
);
315 pr_err("probe failed for device %s (%d)\n",
316 dev_name(child_device
), ret
);
319 pr_err("probe not set for driver %s\n",
320 dev_name(child_device
));
327 * vmbus_remove - Remove a vmbus device
329 static int vmbus_remove(struct device
*child_device
)
331 struct hv_driver
*drv
= drv_to_hv_drv(child_device
->driver
);
332 struct hv_device
*dev
= device_to_hv_device(child_device
);
337 pr_err("remove not set for driver %s\n",
338 dev_name(child_device
));
345 * vmbus_shutdown - Shutdown a vmbus device
347 static void vmbus_shutdown(struct device
*child_device
)
349 struct hv_driver
*drv
;
350 struct hv_device
*dev
= device_to_hv_device(child_device
);
353 /* The device may not be attached yet */
354 if (!child_device
->driver
)
357 drv
= drv_to_hv_drv(child_device
->driver
);
367 * vmbus_device_release - Final callback release of the vmbus child device
369 static void vmbus_device_release(struct device
*device
)
371 struct hv_device
*hv_dev
= device_to_hv_device(device
);
377 /* The one and only one */
378 static struct bus_type hv_bus
= {
380 .match
= vmbus_match
,
381 .shutdown
= vmbus_shutdown
,
382 .remove
= vmbus_remove
,
383 .probe
= vmbus_probe
,
384 .uevent
= vmbus_uevent
,
385 .dev_attrs
= vmbus_device_attrs
,
388 static const char *driver_name
= "hyperv";
391 struct onmessage_work_context
{
392 struct work_struct work
;
393 struct hv_message msg
;
396 static void vmbus_onmessage_work(struct work_struct
*work
)
398 struct onmessage_work_context
*ctx
;
400 ctx
= container_of(work
, struct onmessage_work_context
,
402 vmbus_onmessage(&ctx
->msg
);
406 static void vmbus_on_msg_dpc(unsigned long data
)
408 int cpu
= smp_processor_id();
409 void *page_addr
= hv_context
.synic_message_page
[cpu
];
410 struct hv_message
*msg
= (struct hv_message
*)page_addr
+
412 struct onmessage_work_context
*ctx
;
415 if (msg
->header
.message_type
== HVMSG_NONE
) {
419 ctx
= kmalloc(sizeof(*ctx
), GFP_ATOMIC
);
422 INIT_WORK(&ctx
->work
, vmbus_onmessage_work
);
423 memcpy(&ctx
->msg
, msg
, sizeof(*msg
));
424 queue_work(vmbus_connection
.work_queue
, &ctx
->work
);
427 msg
->header
.message_type
= HVMSG_NONE
;
430 * Make sure the write to MessageType (ie set to
431 * HVMSG_NONE) happens before we read the
432 * MessagePending and EOMing. Otherwise, the EOMing
433 * will not deliver any more messages since there is
438 if (msg
->header
.message_flags
.msg_pending
) {
440 * This will cause message queue rescan to
441 * possibly deliver another msg from the
444 wrmsrl(HV_X64_MSR_EOM
, 0);
449 static irqreturn_t
vmbus_isr(int irq
, void *dev_id
)
451 int cpu
= smp_processor_id();
453 struct hv_message
*msg
;
454 union hv_synic_event_flags
*event
;
455 bool handled
= false;
458 * Check for events before checking for messages. This is the order
459 * in which events and messages are checked in Windows guests on
460 * Hyper-V, and the Windows team suggested we do the same.
463 page_addr
= hv_context
.synic_event_page
[cpu
];
464 event
= (union hv_synic_event_flags
*)page_addr
+ VMBUS_MESSAGE_SINT
;
466 /* Since we are a child, we only need to check bit 0 */
467 if (sync_test_and_clear_bit(0, (unsigned long *) &event
->flags32
[0])) {
469 tasklet_schedule(&event_dpc
);
472 page_addr
= hv_context
.synic_message_page
[cpu
];
473 msg
= (struct hv_message
*)page_addr
+ VMBUS_MESSAGE_SINT
;
475 /* Check if there are actual msgs to be processed */
476 if (msg
->header
.message_type
!= HVMSG_NONE
) {
478 tasklet_schedule(&msg_dpc
);
488 * vmbus_bus_init -Main vmbus driver initialization routine.
491 * - initialize the vmbus driver context
492 * - invoke the vmbus hv main init routine
493 * - get the irq resource
494 * - retrieve the channel offers
496 static int vmbus_bus_init(int irq
)
501 /* Hypervisor initialization...setup hypercall page..etc */
504 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret
);
508 tasklet_init(&msg_dpc
, vmbus_on_msg_dpc
, 0);
509 tasklet_init(&event_dpc
, vmbus_on_event
, 0);
511 ret
= bus_register(&hv_bus
);
515 ret
= request_irq(irq
, vmbus_isr
, 0, driver_name
, hv_acpi_dev
);
518 pr_err("Unable to request IRQ %d\n",
523 vector
= IRQ0_VECTOR
+ irq
;
526 * Notify the hypervisor of our irq and
527 * connect to the host.
529 on_each_cpu(hv_synic_init
, (void *)&vector
, 1);
530 ret
= vmbus_connect();
534 vmbus_request_offers();
539 free_irq(irq
, hv_acpi_dev
);
542 bus_unregister(&hv_bus
);
551 * __vmbus_child_driver_register - Register a vmbus's driver
552 * @drv: Pointer to driver structure you want to register
553 * @owner: owner module of the drv
554 * @mod_name: module name string
556 * Registers the given driver with Linux through the 'driver_register()' call
557 * and sets up the hyper-v vmbus handling for this driver.
558 * It will return the state of the 'driver_register()' call.
561 int __vmbus_driver_register(struct hv_driver
*hv_driver
, struct module
*owner
, const char *mod_name
)
565 pr_info("registering driver %s\n", hv_driver
->name
);
567 ret
= vmbus_exists();
571 hv_driver
->driver
.name
= hv_driver
->name
;
572 hv_driver
->driver
.owner
= owner
;
573 hv_driver
->driver
.mod_name
= mod_name
;
574 hv_driver
->driver
.bus
= &hv_bus
;
576 ret
= driver_register(&hv_driver
->driver
);
578 vmbus_request_offers();
582 EXPORT_SYMBOL_GPL(__vmbus_driver_register
);
585 * vmbus_driver_unregister() - Unregister a vmbus's driver
586 * @drv: Pointer to driver structure you want to un-register
588 * Un-register the given driver that was previous registered with a call to
589 * vmbus_driver_register()
591 void vmbus_driver_unregister(struct hv_driver
*hv_driver
)
593 pr_info("unregistering driver %s\n", hv_driver
->name
);
596 driver_unregister(&hv_driver
->driver
);
598 EXPORT_SYMBOL_GPL(vmbus_driver_unregister
);
601 * vmbus_device_create - Creates and registers a new child device
604 struct hv_device
*vmbus_device_create(uuid_le
*type
,
606 struct vmbus_channel
*channel
)
608 struct hv_device
*child_device_obj
;
610 child_device_obj
= kzalloc(sizeof(struct hv_device
), GFP_KERNEL
);
611 if (!child_device_obj
) {
612 pr_err("Unable to allocate device object for child device\n");
616 child_device_obj
->channel
= channel
;
617 memcpy(&child_device_obj
->dev_type
, type
, sizeof(uuid_le
));
618 memcpy(&child_device_obj
->dev_instance
, instance
,
622 return child_device_obj
;
626 * vmbus_device_register - Register the child device
628 int vmbus_device_register(struct hv_device
*child_device_obj
)
632 static atomic_t device_num
= ATOMIC_INIT(0);
634 dev_set_name(&child_device_obj
->device
, "vmbus_0_%d",
635 atomic_inc_return(&device_num
));
637 child_device_obj
->device
.bus
= &hv_bus
;
638 child_device_obj
->device
.parent
= &hv_acpi_dev
->dev
;
639 child_device_obj
->device
.release
= vmbus_device_release
;
642 * Register with the LDM. This will kick off the driver/device
643 * binding...which will eventually call vmbus_match() and vmbus_probe()
645 ret
= device_register(&child_device_obj
->device
);
648 pr_err("Unable to register child device\n");
650 pr_info("child device %s registered\n",
651 dev_name(&child_device_obj
->device
));
657 * vmbus_device_unregister - Remove the specified child device
660 void vmbus_device_unregister(struct hv_device
*device_obj
)
663 * Kick off the process of unregistering the device.
664 * This will call vmbus_remove() and eventually vmbus_device_release()
666 device_unregister(&device_obj
->device
);
668 pr_info("child device %s unregistered\n",
669 dev_name(&device_obj
->device
));
674 * VMBUS is an acpi enumerated device. Get the the IRQ information
678 static acpi_status
vmbus_walk_resources(struct acpi_resource
*res
, void *irq
)
681 if (res
->type
== ACPI_RESOURCE_TYPE_IRQ
) {
682 struct acpi_resource_irq
*irqp
;
683 irqp
= &res
->data
.irq
;
685 *((unsigned int *)irq
) = irqp
->interrupts
[0];
691 static int vmbus_acpi_add(struct acpi_device
*device
)
695 hv_acpi_dev
= device
;
697 result
= acpi_walk_resources(device
->handle
, METHOD_NAME__CRS
,
698 vmbus_walk_resources
, &irq
);
700 if (ACPI_FAILURE(result
)) {
701 complete(&probe_event
);
704 complete(&probe_event
);
708 static const struct acpi_device_id vmbus_acpi_device_ids
[] = {
713 MODULE_DEVICE_TABLE(acpi
, vmbus_acpi_device_ids
);
715 static struct acpi_driver vmbus_acpi_driver
= {
717 .ids
= vmbus_acpi_device_ids
,
719 .add
= vmbus_acpi_add
,
723 static int __init
hv_acpi_init(void)
727 if (x86_hyper
!= &x86_hyper_ms_hyperv
)
730 init_completion(&probe_event
);
733 * Get irq resources first.
736 ret
= acpi_bus_register_driver(&vmbus_acpi_driver
);
741 t
= wait_for_completion_timeout(&probe_event
, 5*HZ
);
752 ret
= vmbus_bus_init(irq
);
759 acpi_bus_unregister_driver(&vmbus_acpi_driver
);
764 static void __exit
vmbus_exit(void)
767 free_irq(irq
, hv_acpi_dev
);
768 vmbus_free_channels();
769 bus_unregister(&hv_bus
);
771 acpi_bus_unregister_driver(&vmbus_acpi_driver
);
775 MODULE_LICENSE("GPL");
776 MODULE_VERSION(HV_DRV_VERSION
);
778 subsys_initcall(hv_acpi_init
);
779 module_exit(vmbus_exit
);