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 <asm/hyperv.h>
36 #include <asm/hypervisor.h>
37 #include <asm/mshyperv.h>
38 #include "hyperv_vmbus.h"
40 static struct acpi_device
*hv_acpi_dev
;
42 static struct tasklet_struct msg_dpc
;
43 static struct completion probe_event
;
46 struct resource hyperv_mmio
= {
47 .name
= "hyperv mmio",
48 .flags
= IORESOURCE_MEM
,
50 EXPORT_SYMBOL_GPL(hyperv_mmio
);
52 static int vmbus_exists(void)
54 if (hv_acpi_dev
== NULL
)
60 #define VMBUS_ALIAS_LEN ((sizeof((struct hv_vmbus_device_id *)0)->guid) * 2)
61 static void print_alias_name(struct hv_device
*hv_dev
, char *alias_name
)
64 for (i
= 0; i
< VMBUS_ALIAS_LEN
; i
+= 2)
65 sprintf(&alias_name
[i
], "%02x", hv_dev
->dev_type
.b
[i
/2]);
68 static u8
channel_monitor_group(struct vmbus_channel
*channel
)
70 return (u8
)channel
->offermsg
.monitorid
/ 32;
73 static u8
channel_monitor_offset(struct vmbus_channel
*channel
)
75 return (u8
)channel
->offermsg
.monitorid
% 32;
78 static u32
channel_pending(struct vmbus_channel
*channel
,
79 struct hv_monitor_page
*monitor_page
)
81 u8 monitor_group
= channel_monitor_group(channel
);
82 return monitor_page
->trigger_group
[monitor_group
].pending
;
85 static u32
channel_latency(struct vmbus_channel
*channel
,
86 struct hv_monitor_page
*monitor_page
)
88 u8 monitor_group
= channel_monitor_group(channel
);
89 u8 monitor_offset
= channel_monitor_offset(channel
);
90 return monitor_page
->latency
[monitor_group
][monitor_offset
];
93 static u32
channel_conn_id(struct vmbus_channel
*channel
,
94 struct hv_monitor_page
*monitor_page
)
96 u8 monitor_group
= channel_monitor_group(channel
);
97 u8 monitor_offset
= channel_monitor_offset(channel
);
98 return monitor_page
->parameter
[monitor_group
][monitor_offset
].connectionid
.u
.id
;
101 static ssize_t
id_show(struct device
*dev
, struct device_attribute
*dev_attr
,
104 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
106 if (!hv_dev
->channel
)
108 return sprintf(buf
, "%d\n", hv_dev
->channel
->offermsg
.child_relid
);
110 static DEVICE_ATTR_RO(id
);
112 static ssize_t
state_show(struct device
*dev
, struct device_attribute
*dev_attr
,
115 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
117 if (!hv_dev
->channel
)
119 return sprintf(buf
, "%d\n", hv_dev
->channel
->state
);
121 static DEVICE_ATTR_RO(state
);
123 static ssize_t
monitor_id_show(struct device
*dev
,
124 struct device_attribute
*dev_attr
, char *buf
)
126 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
128 if (!hv_dev
->channel
)
130 return sprintf(buf
, "%d\n", hv_dev
->channel
->offermsg
.monitorid
);
132 static DEVICE_ATTR_RO(monitor_id
);
134 static ssize_t
class_id_show(struct device
*dev
,
135 struct device_attribute
*dev_attr
, char *buf
)
137 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
139 if (!hv_dev
->channel
)
141 return sprintf(buf
, "{%pUl}\n",
142 hv_dev
->channel
->offermsg
.offer
.if_type
.b
);
144 static DEVICE_ATTR_RO(class_id
);
146 static ssize_t
device_id_show(struct device
*dev
,
147 struct device_attribute
*dev_attr
, char *buf
)
149 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
151 if (!hv_dev
->channel
)
153 return sprintf(buf
, "{%pUl}\n",
154 hv_dev
->channel
->offermsg
.offer
.if_instance
.b
);
156 static DEVICE_ATTR_RO(device_id
);
158 static ssize_t
modalias_show(struct device
*dev
,
159 struct device_attribute
*dev_attr
, char *buf
)
161 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
162 char alias_name
[VMBUS_ALIAS_LEN
+ 1];
164 print_alias_name(hv_dev
, alias_name
);
165 return sprintf(buf
, "vmbus:%s\n", alias_name
);
167 static DEVICE_ATTR_RO(modalias
);
169 static ssize_t
server_monitor_pending_show(struct device
*dev
,
170 struct device_attribute
*dev_attr
,
173 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
175 if (!hv_dev
->channel
)
177 return sprintf(buf
, "%d\n",
178 channel_pending(hv_dev
->channel
,
179 vmbus_connection
.monitor_pages
[1]));
181 static DEVICE_ATTR_RO(server_monitor_pending
);
183 static ssize_t
client_monitor_pending_show(struct device
*dev
,
184 struct device_attribute
*dev_attr
,
187 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
189 if (!hv_dev
->channel
)
191 return sprintf(buf
, "%d\n",
192 channel_pending(hv_dev
->channel
,
193 vmbus_connection
.monitor_pages
[1]));
195 static DEVICE_ATTR_RO(client_monitor_pending
);
197 static ssize_t
server_monitor_latency_show(struct device
*dev
,
198 struct device_attribute
*dev_attr
,
201 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
203 if (!hv_dev
->channel
)
205 return sprintf(buf
, "%d\n",
206 channel_latency(hv_dev
->channel
,
207 vmbus_connection
.monitor_pages
[0]));
209 static DEVICE_ATTR_RO(server_monitor_latency
);
211 static ssize_t
client_monitor_latency_show(struct device
*dev
,
212 struct device_attribute
*dev_attr
,
215 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
217 if (!hv_dev
->channel
)
219 return sprintf(buf
, "%d\n",
220 channel_latency(hv_dev
->channel
,
221 vmbus_connection
.monitor_pages
[1]));
223 static DEVICE_ATTR_RO(client_monitor_latency
);
225 static ssize_t
server_monitor_conn_id_show(struct device
*dev
,
226 struct device_attribute
*dev_attr
,
229 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
231 if (!hv_dev
->channel
)
233 return sprintf(buf
, "%d\n",
234 channel_conn_id(hv_dev
->channel
,
235 vmbus_connection
.monitor_pages
[0]));
237 static DEVICE_ATTR_RO(server_monitor_conn_id
);
239 static ssize_t
client_monitor_conn_id_show(struct device
*dev
,
240 struct device_attribute
*dev_attr
,
243 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
245 if (!hv_dev
->channel
)
247 return sprintf(buf
, "%d\n",
248 channel_conn_id(hv_dev
->channel
,
249 vmbus_connection
.monitor_pages
[1]));
251 static DEVICE_ATTR_RO(client_monitor_conn_id
);
253 static ssize_t
out_intr_mask_show(struct device
*dev
,
254 struct device_attribute
*dev_attr
, char *buf
)
256 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
257 struct hv_ring_buffer_debug_info outbound
;
259 if (!hv_dev
->channel
)
261 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
, &outbound
);
262 return sprintf(buf
, "%d\n", outbound
.current_interrupt_mask
);
264 static DEVICE_ATTR_RO(out_intr_mask
);
266 static ssize_t
out_read_index_show(struct device
*dev
,
267 struct device_attribute
*dev_attr
, char *buf
)
269 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
270 struct hv_ring_buffer_debug_info outbound
;
272 if (!hv_dev
->channel
)
274 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
, &outbound
);
275 return sprintf(buf
, "%d\n", outbound
.current_read_index
);
277 static DEVICE_ATTR_RO(out_read_index
);
279 static ssize_t
out_write_index_show(struct device
*dev
,
280 struct device_attribute
*dev_attr
,
283 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
284 struct hv_ring_buffer_debug_info outbound
;
286 if (!hv_dev
->channel
)
288 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
, &outbound
);
289 return sprintf(buf
, "%d\n", outbound
.current_write_index
);
291 static DEVICE_ATTR_RO(out_write_index
);
293 static ssize_t
out_read_bytes_avail_show(struct device
*dev
,
294 struct device_attribute
*dev_attr
,
297 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
298 struct hv_ring_buffer_debug_info outbound
;
300 if (!hv_dev
->channel
)
302 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
, &outbound
);
303 return sprintf(buf
, "%d\n", outbound
.bytes_avail_toread
);
305 static DEVICE_ATTR_RO(out_read_bytes_avail
);
307 static ssize_t
out_write_bytes_avail_show(struct device
*dev
,
308 struct device_attribute
*dev_attr
,
311 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
312 struct hv_ring_buffer_debug_info outbound
;
314 if (!hv_dev
->channel
)
316 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->outbound
, &outbound
);
317 return sprintf(buf
, "%d\n", outbound
.bytes_avail_towrite
);
319 static DEVICE_ATTR_RO(out_write_bytes_avail
);
321 static ssize_t
in_intr_mask_show(struct device
*dev
,
322 struct device_attribute
*dev_attr
, char *buf
)
324 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
325 struct hv_ring_buffer_debug_info inbound
;
327 if (!hv_dev
->channel
)
329 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
330 return sprintf(buf
, "%d\n", inbound
.current_interrupt_mask
);
332 static DEVICE_ATTR_RO(in_intr_mask
);
334 static ssize_t
in_read_index_show(struct device
*dev
,
335 struct device_attribute
*dev_attr
, char *buf
)
337 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
338 struct hv_ring_buffer_debug_info inbound
;
340 if (!hv_dev
->channel
)
342 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
343 return sprintf(buf
, "%d\n", inbound
.current_read_index
);
345 static DEVICE_ATTR_RO(in_read_index
);
347 static ssize_t
in_write_index_show(struct device
*dev
,
348 struct device_attribute
*dev_attr
, char *buf
)
350 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
351 struct hv_ring_buffer_debug_info inbound
;
353 if (!hv_dev
->channel
)
355 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
356 return sprintf(buf
, "%d\n", inbound
.current_write_index
);
358 static DEVICE_ATTR_RO(in_write_index
);
360 static ssize_t
in_read_bytes_avail_show(struct device
*dev
,
361 struct device_attribute
*dev_attr
,
364 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
365 struct hv_ring_buffer_debug_info inbound
;
367 if (!hv_dev
->channel
)
369 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
370 return sprintf(buf
, "%d\n", inbound
.bytes_avail_toread
);
372 static DEVICE_ATTR_RO(in_read_bytes_avail
);
374 static ssize_t
in_write_bytes_avail_show(struct device
*dev
,
375 struct device_attribute
*dev_attr
,
378 struct hv_device
*hv_dev
= device_to_hv_device(dev
);
379 struct hv_ring_buffer_debug_info inbound
;
381 if (!hv_dev
->channel
)
383 hv_ringbuffer_get_debuginfo(&hv_dev
->channel
->inbound
, &inbound
);
384 return sprintf(buf
, "%d\n", inbound
.bytes_avail_towrite
);
386 static DEVICE_ATTR_RO(in_write_bytes_avail
);
388 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
389 static struct attribute
*vmbus_attrs
[] = {
391 &dev_attr_state
.attr
,
392 &dev_attr_monitor_id
.attr
,
393 &dev_attr_class_id
.attr
,
394 &dev_attr_device_id
.attr
,
395 &dev_attr_modalias
.attr
,
396 &dev_attr_server_monitor_pending
.attr
,
397 &dev_attr_client_monitor_pending
.attr
,
398 &dev_attr_server_monitor_latency
.attr
,
399 &dev_attr_client_monitor_latency
.attr
,
400 &dev_attr_server_monitor_conn_id
.attr
,
401 &dev_attr_client_monitor_conn_id
.attr
,
402 &dev_attr_out_intr_mask
.attr
,
403 &dev_attr_out_read_index
.attr
,
404 &dev_attr_out_write_index
.attr
,
405 &dev_attr_out_read_bytes_avail
.attr
,
406 &dev_attr_out_write_bytes_avail
.attr
,
407 &dev_attr_in_intr_mask
.attr
,
408 &dev_attr_in_read_index
.attr
,
409 &dev_attr_in_write_index
.attr
,
410 &dev_attr_in_read_bytes_avail
.attr
,
411 &dev_attr_in_write_bytes_avail
.attr
,
414 ATTRIBUTE_GROUPS(vmbus
);
417 * vmbus_uevent - add uevent for our device
419 * This routine is invoked when a device is added or removed on the vmbus to
420 * generate a uevent to udev in the userspace. The udev will then look at its
421 * rule and the uevent generated here to load the appropriate driver
423 * The alias string will be of the form vmbus:guid where guid is the string
424 * representation of the device guid (each byte of the guid will be
425 * represented with two hex characters.
427 static int vmbus_uevent(struct device
*device
, struct kobj_uevent_env
*env
)
429 struct hv_device
*dev
= device_to_hv_device(device
);
431 char alias_name
[VMBUS_ALIAS_LEN
+ 1];
433 print_alias_name(dev
, alias_name
);
434 ret
= add_uevent_var(env
, "MODALIAS=vmbus:%s", alias_name
);
438 static uuid_le null_guid
;
440 static inline bool is_null_guid(const __u8
*guid
)
442 if (memcmp(guid
, &null_guid
, sizeof(uuid_le
)))
448 * Return a matching hv_vmbus_device_id pointer.
449 * If there is no match, return NULL.
451 static const struct hv_vmbus_device_id
*hv_vmbus_get_id(
452 const struct hv_vmbus_device_id
*id
,
455 for (; !is_null_guid(id
->guid
); id
++)
456 if (!memcmp(&id
->guid
, guid
, sizeof(uuid_le
)))
465 * vmbus_match - Attempt to match the specified device to the specified driver
467 static int vmbus_match(struct device
*device
, struct device_driver
*driver
)
469 struct hv_driver
*drv
= drv_to_hv_drv(driver
);
470 struct hv_device
*hv_dev
= device_to_hv_device(device
);
472 if (hv_vmbus_get_id(drv
->id_table
, hv_dev
->dev_type
.b
))
479 * vmbus_probe - Add the new vmbus's child device
481 static int vmbus_probe(struct device
*child_device
)
484 struct hv_driver
*drv
=
485 drv_to_hv_drv(child_device
->driver
);
486 struct hv_device
*dev
= device_to_hv_device(child_device
);
487 const struct hv_vmbus_device_id
*dev_id
;
489 dev_id
= hv_vmbus_get_id(drv
->id_table
, dev
->dev_type
.b
);
491 ret
= drv
->probe(dev
, dev_id
);
493 pr_err("probe failed for device %s (%d)\n",
494 dev_name(child_device
), ret
);
497 pr_err("probe not set for driver %s\n",
498 dev_name(child_device
));
505 * vmbus_remove - Remove a vmbus device
507 static int vmbus_remove(struct device
*child_device
)
509 struct hv_driver
*drv
= drv_to_hv_drv(child_device
->driver
);
510 struct hv_device
*dev
= device_to_hv_device(child_device
);
515 pr_err("remove not set for driver %s\n",
516 dev_name(child_device
));
523 * vmbus_shutdown - Shutdown a vmbus device
525 static void vmbus_shutdown(struct device
*child_device
)
527 struct hv_driver
*drv
;
528 struct hv_device
*dev
= device_to_hv_device(child_device
);
531 /* The device may not be attached yet */
532 if (!child_device
->driver
)
535 drv
= drv_to_hv_drv(child_device
->driver
);
545 * vmbus_device_release - Final callback release of the vmbus child device
547 static void vmbus_device_release(struct device
*device
)
549 struct hv_device
*hv_dev
= device_to_hv_device(device
);
555 /* The one and only one */
556 static struct bus_type hv_bus
= {
558 .match
= vmbus_match
,
559 .shutdown
= vmbus_shutdown
,
560 .remove
= vmbus_remove
,
561 .probe
= vmbus_probe
,
562 .uevent
= vmbus_uevent
,
563 .dev_groups
= vmbus_groups
,
566 struct onmessage_work_context
{
567 struct work_struct work
;
568 struct hv_message msg
;
571 static void vmbus_onmessage_work(struct work_struct
*work
)
573 struct onmessage_work_context
*ctx
;
575 ctx
= container_of(work
, struct onmessage_work_context
,
577 vmbus_onmessage(&ctx
->msg
);
581 static void vmbus_on_msg_dpc(unsigned long data
)
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
+
587 struct onmessage_work_context
*ctx
;
590 if (msg
->header
.message_type
== HVMSG_NONE
) {
594 ctx
= kmalloc(sizeof(*ctx
), GFP_ATOMIC
);
597 INIT_WORK(&ctx
->work
, vmbus_onmessage_work
);
598 memcpy(&ctx
->msg
, msg
, sizeof(*msg
));
599 queue_work(vmbus_connection
.work_queue
, &ctx
->work
);
602 msg
->header
.message_type
= HVMSG_NONE
;
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
613 if (msg
->header
.message_flags
.msg_pending
) {
615 * This will cause message queue rescan to
616 * possibly deliver another msg from the
619 wrmsrl(HV_X64_MSR_EOM
, 0);
624 static void vmbus_isr(void)
626 int cpu
= smp_processor_id();
628 struct hv_message
*msg
;
629 union hv_synic_event_flags
*event
;
630 bool handled
= false;
632 page_addr
= hv_context
.synic_event_page
[cpu
];
633 if (page_addr
== NULL
)
636 event
= (union hv_synic_event_flags
*)page_addr
+
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.
644 if ((vmbus_proto_version
== VERSION_WS2008
) ||
645 (vmbus_proto_version
== VERSION_WIN7
)) {
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])) {
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
663 tasklet_schedule(hv_context
.event_dpc
[cpu
]);
666 page_addr
= hv_context
.synic_message_page
[cpu
];
667 msg
= (struct hv_message
*)page_addr
+ VMBUS_MESSAGE_SINT
;
669 /* Check if there are actual msgs to be processed */
670 if (msg
->header
.message_type
!= HVMSG_NONE
)
671 tasklet_schedule(&msg_dpc
);
675 * vmbus_bus_init -Main vmbus driver initialization routine.
678 * - initialize the vmbus driver context
679 * - invoke the vmbus hv main init routine
680 * - get the irq resource
681 * - retrieve the channel offers
683 static int vmbus_bus_init(int irq
)
687 /* Hypervisor initialization...setup hypercall page..etc */
690 pr_err("Unable to initialize the hypervisor - 0x%x\n", ret
);
694 tasklet_init(&msg_dpc
, vmbus_on_msg_dpc
, 0);
696 ret
= bus_register(&hv_bus
);
700 hv_setup_vmbus_irq(vmbus_isr
);
702 ret
= hv_synic_alloc();
706 * Initialize the per-cpu interrupt state and
707 * connect to the host.
709 on_each_cpu(hv_synic_init
, NULL
, 1);
710 ret
= vmbus_connect();
714 vmbus_request_offers();
720 hv_remove_vmbus_irq();
722 bus_unregister(&hv_bus
);
731 * __vmbus_child_driver_register - Register a vmbus's driver
732 * @drv: Pointer to driver structure you want to register
733 * @owner: owner module of the drv
734 * @mod_name: module name string
736 * Registers the given driver with Linux through the 'driver_register()' call
737 * and sets up the hyper-v vmbus handling for this driver.
738 * It will return the state of the 'driver_register()' call.
741 int __vmbus_driver_register(struct hv_driver
*hv_driver
, struct module
*owner
, const char *mod_name
)
745 pr_info("registering driver %s\n", hv_driver
->name
);
747 ret
= vmbus_exists();
751 hv_driver
->driver
.name
= hv_driver
->name
;
752 hv_driver
->driver
.owner
= owner
;
753 hv_driver
->driver
.mod_name
= mod_name
;
754 hv_driver
->driver
.bus
= &hv_bus
;
756 ret
= driver_register(&hv_driver
->driver
);
760 EXPORT_SYMBOL_GPL(__vmbus_driver_register
);
763 * vmbus_driver_unregister() - Unregister a vmbus's driver
764 * @drv: Pointer to driver structure you want to un-register
766 * Un-register the given driver that was previous registered with a call to
767 * vmbus_driver_register()
769 void vmbus_driver_unregister(struct hv_driver
*hv_driver
)
771 pr_info("unregistering driver %s\n", hv_driver
->name
);
774 driver_unregister(&hv_driver
->driver
);
776 EXPORT_SYMBOL_GPL(vmbus_driver_unregister
);
779 * vmbus_device_create - Creates and registers a new child device
782 struct hv_device
*vmbus_device_create(uuid_le
*type
,
784 struct vmbus_channel
*channel
)
786 struct hv_device
*child_device_obj
;
788 child_device_obj
= kzalloc(sizeof(struct hv_device
), GFP_KERNEL
);
789 if (!child_device_obj
) {
790 pr_err("Unable to allocate device object for child device\n");
794 child_device_obj
->channel
= channel
;
795 memcpy(&child_device_obj
->dev_type
, type
, sizeof(uuid_le
));
796 memcpy(&child_device_obj
->dev_instance
, instance
,
800 return child_device_obj
;
804 * vmbus_device_register - Register the child device
806 int vmbus_device_register(struct hv_device
*child_device_obj
)
810 static atomic_t device_num
= ATOMIC_INIT(0);
812 dev_set_name(&child_device_obj
->device
, "vmbus_0_%d",
813 atomic_inc_return(&device_num
));
815 child_device_obj
->device
.bus
= &hv_bus
;
816 child_device_obj
->device
.parent
= &hv_acpi_dev
->dev
;
817 child_device_obj
->device
.release
= vmbus_device_release
;
820 * Register with the LDM. This will kick off the driver/device
821 * binding...which will eventually call vmbus_match() and vmbus_probe()
823 ret
= device_register(&child_device_obj
->device
);
826 pr_err("Unable to register child device\n");
828 pr_debug("child device %s registered\n",
829 dev_name(&child_device_obj
->device
));
835 * vmbus_device_unregister - Remove the specified child device
838 void vmbus_device_unregister(struct hv_device
*device_obj
)
840 pr_debug("child device %s unregistered\n",
841 dev_name(&device_obj
->device
));
844 * Kick off the process of unregistering the device.
845 * This will call vmbus_remove() and eventually vmbus_device_release()
847 device_unregister(&device_obj
->device
);
852 * VMBUS is an acpi enumerated device. Get the the information we
856 static acpi_status
vmbus_walk_resources(struct acpi_resource
*res
, void *ctx
)
859 case ACPI_RESOURCE_TYPE_IRQ
:
860 irq
= res
->data
.irq
.interrupts
[0];
863 case ACPI_RESOURCE_TYPE_ADDRESS64
:
864 hyperv_mmio
.start
= res
->data
.address64
.minimum
;
865 hyperv_mmio
.end
= res
->data
.address64
.maximum
;
872 static int vmbus_acpi_add(struct acpi_device
*device
)
875 int ret_val
= -ENODEV
;
877 hv_acpi_dev
= device
;
879 result
= acpi_walk_resources(device
->handle
, METHOD_NAME__CRS
,
880 vmbus_walk_resources
, NULL
);
882 if (ACPI_FAILURE(result
))
885 * The parent of the vmbus acpi device (Gen2 firmware) is the VMOD that
886 * has the mmio ranges. Get that.
888 if (device
->parent
) {
889 result
= acpi_walk_resources(device
->parent
->handle
,
891 vmbus_walk_resources
, NULL
);
893 if (ACPI_FAILURE(result
))
895 if (hyperv_mmio
.start
&& hyperv_mmio
.end
)
896 request_resource(&iomem_resource
, &hyperv_mmio
);
901 complete(&probe_event
);
905 static const struct acpi_device_id vmbus_acpi_device_ids
[] = {
910 MODULE_DEVICE_TABLE(acpi
, vmbus_acpi_device_ids
);
912 static struct acpi_driver vmbus_acpi_driver
= {
914 .ids
= vmbus_acpi_device_ids
,
916 .add
= vmbus_acpi_add
,
920 static int __init
hv_acpi_init(void)
924 if (x86_hyper
!= &x86_hyper_ms_hyperv
)
927 init_completion(&probe_event
);
930 * Get irq resources first.
932 ret
= acpi_bus_register_driver(&vmbus_acpi_driver
);
937 t
= wait_for_completion_timeout(&probe_event
, 5*HZ
);
948 ret
= vmbus_bus_init(irq
);
955 acpi_bus_unregister_driver(&vmbus_acpi_driver
);
960 static void __exit
vmbus_exit(void)
962 hv_remove_vmbus_irq();
963 vmbus_free_channels();
964 bus_unregister(&hv_bus
);
966 acpi_bus_unregister_driver(&vmbus_acpi_driver
);
970 MODULE_LICENSE("GPL");
972 subsys_initcall(hv_acpi_init
);
973 module_exit(vmbus_exit
);