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>
21 #include <linux/init.h>
22 #include <linux/module.h>
23 #include <linux/device.h>
24 #include <linux/irq.h>
25 #include <linux/interrupt.h>
26 #include <linux/sysctl.h>
27 #include <linux/pci.h>
28 #include <linux/dmi.h>
29 #include <linux/slab.h>
30 #include <linux/completion.h>
31 #include "version_info.h"
36 #include "vmbus_private.h"
39 /* FIXME! We need to do this dynamically for PIC and APIC system */
41 #define VMBUS_IRQ_VECTOR IRQ5_VECTOR
43 /* Main vmbus driver data structure */
44 struct vmbus_driver_context
{
45 /* !! These must be the first 2 fields !! */
46 /* FIXME, this is a bug */
47 /* The driver field is not used in here. Instead, the bus field is */
48 /* used to represent the driver */
49 struct driver_context drv_ctx
;
50 struct hv_driver drv_obj
;
53 struct tasklet_struct msg_dpc
;
54 struct tasklet_struct event_dpc
;
56 /* The bus root device */
57 struct vm_device device_ctx
;
60 static int vmbus_match(struct device
*device
, struct device_driver
*driver
);
61 static int vmbus_probe(struct device
*device
);
62 static int vmbus_remove(struct device
*device
);
63 static void vmbus_shutdown(struct device
*device
);
64 static int vmbus_uevent(struct device
*device
, struct kobj_uevent_env
*env
);
65 static void vmbus_msg_dpc(unsigned long data
);
66 static void vmbus_event_dpc(unsigned long data
);
68 static irqreturn_t
vmbus_isr(int irq
, void *dev_id
);
70 static void vmbus_device_release(struct device
*device
);
71 static void vmbus_bus_release(struct device
*device
);
73 static ssize_t
vmbus_show_device_attr(struct device
*dev
,
74 struct device_attribute
*dev_attr
,
78 unsigned int vmbus_loglevel
= (ALL_MODULES
<< 16 | INFO_LVL
);
79 EXPORT_SYMBOL(vmbus_loglevel
);
80 /* (ALL_MODULES << 16 | DEBUG_LVL_ENTEREXIT); */
81 /* (((VMBUS | VMBUS_DRV)<<16) | DEBUG_LVL_ENTEREXIT); */
83 static int vmbus_irq
= VMBUS_IRQ
;
85 /* Set up per device attributes in /sys/bus/vmbus/devices/<bus device> */
86 static struct device_attribute vmbus_device_attrs
[] = {
87 __ATTR(id
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
88 __ATTR(state
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
89 __ATTR(class_id
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
90 __ATTR(device_id
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
91 __ATTR(monitor_id
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
93 __ATTR(server_monitor_pending
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
94 __ATTR(server_monitor_latency
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
95 __ATTR(server_monitor_conn_id
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
97 __ATTR(client_monitor_pending
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
98 __ATTR(client_monitor_latency
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
99 __ATTR(client_monitor_conn_id
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
101 __ATTR(out_intr_mask
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
102 __ATTR(out_read_index
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
103 __ATTR(out_write_index
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
104 __ATTR(out_read_bytes_avail
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
105 __ATTR(out_write_bytes_avail
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
107 __ATTR(in_intr_mask
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
108 __ATTR(in_read_index
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
109 __ATTR(in_write_index
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
110 __ATTR(in_read_bytes_avail
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
111 __ATTR(in_write_bytes_avail
, S_IRUGO
, vmbus_show_device_attr
, NULL
),
115 /* The one and only one */
116 static struct vmbus_driver_context g_vmbus_drv
= {
118 .bus
.match
= vmbus_match
,
119 .bus
.shutdown
= vmbus_shutdown
,
120 .bus
.remove
= vmbus_remove
,
121 .bus
.probe
= vmbus_probe
,
122 .bus
.uevent
= vmbus_uevent
,
123 .bus
.dev_attrs
= vmbus_device_attrs
,
126 static const char *gDriverName
= "hyperv";
129 * Windows vmbus does not defined this.
130 * We defined this to be consistent with other devices
132 /* {c5295816-f63a-4d5f-8d1a-4daf999ca185} */
133 static const struct hv_guid gVmbusDeviceType
= {
135 0x16, 0x58, 0x29, 0xc5, 0x3a, 0xf6, 0x5f, 0x4d,
136 0x8d, 0x1a, 0x4d, 0xaf, 0x99, 0x9c, 0xa1, 0x85
140 /* {ac3760fc-9adf-40aa-9427-a70ed6de95c5} */
141 static const struct hv_guid gVmbusDeviceId
= {
143 0xfc, 0x60, 0x37, 0xac, 0xdf, 0x9a, 0xaa, 0x40,
144 0x94, 0x27, 0xa7, 0x0e, 0xd6, 0xde, 0x95, 0xc5
148 static struct hv_driver
*gDriver
; /* vmbus driver object */
149 static struct hv_device
*gDevice
; /* vmbus root device */
152 * VmbusChildDeviceAdd - Registers the child device with the vmbus
154 int VmbusChildDeviceAdd(struct hv_device
*ChildDevice
)
156 return vmbus_child_device_register(gDevice
, ChildDevice
);
160 * VmbusOnDeviceAdd - Callback when the root bus device is added
162 static int VmbusOnDeviceAdd(struct hv_device
*dev
, void *AdditionalInfo
)
164 u32
*irqvector
= AdditionalInfo
;
169 memcpy(&gDevice
->deviceType
, &gVmbusDeviceType
, sizeof(struct hv_guid
));
170 memcpy(&gDevice
->deviceInstance
, &gVmbusDeviceId
,
171 sizeof(struct hv_guid
));
173 /* strcpy(dev->name, "vmbus"); */
175 on_each_cpu(hv_synic_init
, (void *)irqvector
, 1);
177 /* Connect to VMBus in the root partition */
178 ret
= VmbusConnect();
180 /* VmbusSendEvent(device->localPortId+1); */
185 * VmbusOnDeviceRemove - Callback when the root bus device is removed
187 static int VmbusOnDeviceRemove(struct hv_device
*dev
)
191 vmbus_release_unattached_channels();
193 on_each_cpu(hv_synic_cleanup
, NULL
, 1);
198 * VmbusOnCleanup - Perform any cleanup when the driver is removed
200 static void VmbusOnCleanup(struct hv_driver
*drv
)
202 /* struct vmbus_driver *driver = (struct vmbus_driver *)drv; */
208 * vmbus_on_msg_dpc - DPC routine to handle messages from the hypervisior
210 void vmbus_on_msg_dpc(struct hv_driver
*drv
)
212 int cpu
= smp_processor_id();
213 void *page_addr
= hv_context
.synic_message_page
[cpu
];
214 struct hv_message
*msg
= (struct hv_message
*)page_addr
+
216 struct hv_message
*copied
;
219 if (msg
->header
.message_type
== HVMSG_NONE
) {
223 copied
= kmemdup(msg
, sizeof(*copied
), GFP_ATOMIC
);
227 osd_schedule_callback(gVmbusConnection
.WorkQueue
,
232 msg
->header
.message_type
= HVMSG_NONE
;
235 * Make sure the write to MessageType (ie set to
236 * HVMSG_NONE) happens before we read the
237 * MessagePending and EOMing. Otherwise, the EOMing
238 * will not deliver any more messages since there is
243 if (msg
->header
.message_flags
.msg_pending
) {
245 * This will cause message queue rescan to
246 * possibly deliver another msg from the
249 wrmsrl(HV_X64_MSR_EOM
, 0);
255 * vmbus_on_event_dpc - DPC routine to handle events from the hypervisior
257 void vmbus_on_event_dpc(struct hv_driver
*drv
)
259 /* TODO: Process any events */
264 * vmbus_on_isr - ISR routine
266 int vmbus_on_isr(struct hv_driver
*drv
)
269 int cpu
= smp_processor_id();
271 struct hv_message
*msg
;
272 union hv_synic_event_flags
*event
;
274 page_addr
= hv_context
.synic_message_page
[cpu
];
275 msg
= (struct hv_message
*)page_addr
+ VMBUS_MESSAGE_SINT
;
277 /* Check if there are actual msgs to be process */
278 if (msg
->header
.message_type
!= HVMSG_NONE
) {
279 DPRINT_DBG(VMBUS
, "received msg type %d size %d",
280 msg
->header
.message_type
,
281 msg
->header
.payload_size
);
285 /* TODO: Check if there are events to be process */
286 page_addr
= hv_context
.synic_event_page
[cpu
];
287 event
= (union hv_synic_event_flags
*)page_addr
+ VMBUS_MESSAGE_SINT
;
289 /* Since we are a child, we only need to check bit 0 */
290 if (test_and_clear_bit(0, (unsigned long *) &event
->flags32
[0])) {
291 DPRINT_DBG(VMBUS
, "received event %d", event
->flags32
[0]);
299 * VmbusInitialize - Main entry point
301 static int VmbusInitialize(struct hv_driver
*driver
)
305 DPRINT_INFO(VMBUS
, "+++++++ HV Driver version = %s +++++++",
307 DPRINT_INFO(VMBUS
, "+++++++ Vmbus supported version = %d +++++++",
308 VMBUS_REVISION_NUMBER
);
309 DPRINT_INFO(VMBUS
, "+++++++ Vmbus using SINT %d +++++++",
311 DPRINT_DBG(VMBUS
, "sizeof(vmbus_channel_packet_page_buffer)=%zd, "
312 "sizeof(VMBUS_CHANNEL_PACKET_MULITPAGE_BUFFER)=%zd",
313 sizeof(struct vmbus_channel_packet_page_buffer
),
314 sizeof(struct vmbus_channel_packet_multipage_buffer
));
316 driver
->name
= gDriverName
;
317 memcpy(&driver
->deviceType
, &gVmbusDeviceType
, sizeof(struct hv_guid
));
319 /* Setup dispatch table */
320 driver
->OnDeviceAdd
= VmbusOnDeviceAdd
;
321 driver
->OnDeviceRemove
= VmbusOnDeviceRemove
;
322 driver
->OnCleanup
= VmbusOnCleanup
;
324 /* Hypervisor initialization...setup hypercall page..etc */
327 DPRINT_ERR(VMBUS
, "Unable to initialize the hypervisor - 0x%x",
334 static void get_channel_info(struct hv_device
*device
,
335 struct hv_device_info
*info
)
337 struct vmbus_channel_debug_info debug_info
;
339 if (!device
->channel
)
342 vmbus_get_debug_info(device
->channel
, &debug_info
);
344 info
->ChannelId
= debug_info
.relid
;
345 info
->ChannelState
= debug_info
.state
;
346 memcpy(&info
->ChannelType
, &debug_info
.interfacetype
,
347 sizeof(struct hv_guid
));
348 memcpy(&info
->ChannelInstance
, &debug_info
.interface_instance
,
349 sizeof(struct hv_guid
));
351 info
->MonitorId
= debug_info
.monitorid
;
353 info
->ServerMonitorPending
= debug_info
.servermonitor_pending
;
354 info
->ServerMonitorLatency
= debug_info
.servermonitor_latency
;
355 info
->ServerMonitorConnectionId
= debug_info
.servermonitor_connectionid
;
357 info
->ClientMonitorPending
= debug_info
.clientmonitor_pending
;
358 info
->ClientMonitorLatency
= debug_info
.clientmonitor_latency
;
359 info
->ClientMonitorConnectionId
= debug_info
.clientmonitor_connectionid
;
361 info
->Inbound
.InterruptMask
= debug_info
.inbound
.current_interrupt_mask
;
362 info
->Inbound
.ReadIndex
= debug_info
.inbound
.current_read_index
;
363 info
->Inbound
.WriteIndex
= debug_info
.inbound
.current_write_index
;
364 info
->Inbound
.BytesAvailToRead
= debug_info
.inbound
.bytes_avail_toread
;
365 info
->Inbound
.BytesAvailToWrite
=
366 debug_info
.inbound
.bytes_avail_towrite
;
368 info
->Outbound
.InterruptMask
=
369 debug_info
.outbound
.current_interrupt_mask
;
370 info
->Outbound
.ReadIndex
= debug_info
.outbound
.current_read_index
;
371 info
->Outbound
.WriteIndex
= debug_info
.outbound
.current_write_index
;
372 info
->Outbound
.BytesAvailToRead
=
373 debug_info
.outbound
.bytes_avail_toread
;
374 info
->Outbound
.BytesAvailToWrite
=
375 debug_info
.outbound
.bytes_avail_towrite
;
379 * vmbus_show_device_attr - Show the device attribute in sysfs.
381 * This is invoked when user does a
382 * "cat /sys/bus/vmbus/devices/<busdevice>/<attr name>"
384 static ssize_t
vmbus_show_device_attr(struct device
*dev
,
385 struct device_attribute
*dev_attr
,
388 struct vm_device
*device_ctx
= device_to_vm_device(dev
);
389 struct hv_device_info device_info
;
391 memset(&device_info
, 0, sizeof(struct hv_device_info
));
393 get_channel_info(&device_ctx
->device_obj
, &device_info
);
395 if (!strcmp(dev_attr
->attr
.name
, "class_id")) {
396 return sprintf(buf
, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-"
397 "%02x%02x%02x%02x%02x%02x%02x%02x}\n",
398 device_info
.ChannelType
.data
[3],
399 device_info
.ChannelType
.data
[2],
400 device_info
.ChannelType
.data
[1],
401 device_info
.ChannelType
.data
[0],
402 device_info
.ChannelType
.data
[5],
403 device_info
.ChannelType
.data
[4],
404 device_info
.ChannelType
.data
[7],
405 device_info
.ChannelType
.data
[6],
406 device_info
.ChannelType
.data
[8],
407 device_info
.ChannelType
.data
[9],
408 device_info
.ChannelType
.data
[10],
409 device_info
.ChannelType
.data
[11],
410 device_info
.ChannelType
.data
[12],
411 device_info
.ChannelType
.data
[13],
412 device_info
.ChannelType
.data
[14],
413 device_info
.ChannelType
.data
[15]);
414 } else if (!strcmp(dev_attr
->attr
.name
, "device_id")) {
415 return sprintf(buf
, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-"
416 "%02x%02x%02x%02x%02x%02x%02x%02x}\n",
417 device_info
.ChannelInstance
.data
[3],
418 device_info
.ChannelInstance
.data
[2],
419 device_info
.ChannelInstance
.data
[1],
420 device_info
.ChannelInstance
.data
[0],
421 device_info
.ChannelInstance
.data
[5],
422 device_info
.ChannelInstance
.data
[4],
423 device_info
.ChannelInstance
.data
[7],
424 device_info
.ChannelInstance
.data
[6],
425 device_info
.ChannelInstance
.data
[8],
426 device_info
.ChannelInstance
.data
[9],
427 device_info
.ChannelInstance
.data
[10],
428 device_info
.ChannelInstance
.data
[11],
429 device_info
.ChannelInstance
.data
[12],
430 device_info
.ChannelInstance
.data
[13],
431 device_info
.ChannelInstance
.data
[14],
432 device_info
.ChannelInstance
.data
[15]);
433 } else if (!strcmp(dev_attr
->attr
.name
, "state")) {
434 return sprintf(buf
, "%d\n", device_info
.ChannelState
);
435 } else if (!strcmp(dev_attr
->attr
.name
, "id")) {
436 return sprintf(buf
, "%d\n", device_info
.ChannelId
);
437 } else if (!strcmp(dev_attr
->attr
.name
, "out_intr_mask")) {
438 return sprintf(buf
, "%d\n", device_info
.Outbound
.InterruptMask
);
439 } else if (!strcmp(dev_attr
->attr
.name
, "out_read_index")) {
440 return sprintf(buf
, "%d\n", device_info
.Outbound
.ReadIndex
);
441 } else if (!strcmp(dev_attr
->attr
.name
, "out_write_index")) {
442 return sprintf(buf
, "%d\n", device_info
.Outbound
.WriteIndex
);
443 } else if (!strcmp(dev_attr
->attr
.name
, "out_read_bytes_avail")) {
444 return sprintf(buf
, "%d\n",
445 device_info
.Outbound
.BytesAvailToRead
);
446 } else if (!strcmp(dev_attr
->attr
.name
, "out_write_bytes_avail")) {
447 return sprintf(buf
, "%d\n",
448 device_info
.Outbound
.BytesAvailToWrite
);
449 } else if (!strcmp(dev_attr
->attr
.name
, "in_intr_mask")) {
450 return sprintf(buf
, "%d\n", device_info
.Inbound
.InterruptMask
);
451 } else if (!strcmp(dev_attr
->attr
.name
, "in_read_index")) {
452 return sprintf(buf
, "%d\n", device_info
.Inbound
.ReadIndex
);
453 } else if (!strcmp(dev_attr
->attr
.name
, "in_write_index")) {
454 return sprintf(buf
, "%d\n", device_info
.Inbound
.WriteIndex
);
455 } else if (!strcmp(dev_attr
->attr
.name
, "in_read_bytes_avail")) {
456 return sprintf(buf
, "%d\n",
457 device_info
.Inbound
.BytesAvailToRead
);
458 } else if (!strcmp(dev_attr
->attr
.name
, "in_write_bytes_avail")) {
459 return sprintf(buf
, "%d\n",
460 device_info
.Inbound
.BytesAvailToWrite
);
461 } else if (!strcmp(dev_attr
->attr
.name
, "monitor_id")) {
462 return sprintf(buf
, "%d\n", device_info
.MonitorId
);
463 } else if (!strcmp(dev_attr
->attr
.name
, "server_monitor_pending")) {
464 return sprintf(buf
, "%d\n", device_info
.ServerMonitorPending
);
465 } else if (!strcmp(dev_attr
->attr
.name
, "server_monitor_latency")) {
466 return sprintf(buf
, "%d\n", device_info
.ServerMonitorLatency
);
467 } else if (!strcmp(dev_attr
->attr
.name
, "server_monitor_conn_id")) {
468 return sprintf(buf
, "%d\n",
469 device_info
.ServerMonitorConnectionId
);
470 } else if (!strcmp(dev_attr
->attr
.name
, "client_monitor_pending")) {
471 return sprintf(buf
, "%d\n", device_info
.ClientMonitorPending
);
472 } else if (!strcmp(dev_attr
->attr
.name
, "client_monitor_latency")) {
473 return sprintf(buf
, "%d\n", device_info
.ClientMonitorLatency
);
474 } else if (!strcmp(dev_attr
->attr
.name
, "client_monitor_conn_id")) {
475 return sprintf(buf
, "%d\n",
476 device_info
.ClientMonitorConnectionId
);
483 * vmbus_bus_init -Main vmbus driver initialization routine.
486 * - initialize the vmbus driver context
487 * - setup various driver entry points
488 * - invoke the vmbus hv main init routine
489 * - get the irq resource
490 * - invoke the vmbus to add the vmbus root device
491 * - setup the vmbus root device
492 * - retrieve the channel offers
494 static int vmbus_bus_init(void)
496 struct vmbus_driver_context
*vmbus_drv_ctx
= &g_vmbus_drv
;
497 struct hv_driver
*driver
= &g_vmbus_drv
.drv_obj
;
498 struct vm_device
*dev_ctx
= &g_vmbus_drv
.device_ctx
;
502 /* Call to bus driver to initialize */
503 ret
= VmbusInitialize(driver
);
505 DPRINT_ERR(VMBUS_DRV
, "Unable to initialize vmbus (%d)", ret
);
510 if (!driver
->OnDeviceAdd
) {
511 DPRINT_ERR(VMBUS_DRV
, "OnDeviceAdd() routine not set");
516 vmbus_drv_ctx
->bus
.name
= driver
->name
;
518 /* Initialize the bus context */
519 tasklet_init(&vmbus_drv_ctx
->msg_dpc
, vmbus_msg_dpc
,
520 (unsigned long)driver
);
521 tasklet_init(&vmbus_drv_ctx
->event_dpc
, vmbus_event_dpc
,
522 (unsigned long)driver
);
524 /* Now, register the bus driver with LDM */
525 ret
= bus_register(&vmbus_drv_ctx
->bus
);
531 /* Get the interrupt resource */
532 ret
= request_irq(vmbus_irq
, vmbus_isr
, IRQF_SAMPLE_RANDOM
,
536 DPRINT_ERR(VMBUS_DRV
, "ERROR - Unable to request IRQ %d",
539 bus_unregister(&vmbus_drv_ctx
->bus
);
544 vector
= VMBUS_IRQ_VECTOR
;
546 DPRINT_INFO(VMBUS_DRV
, "irq 0x%x vector 0x%x", vmbus_irq
, vector
);
548 /* Call to bus driver to add the root device */
549 memset(dev_ctx
, 0, sizeof(struct vm_device
));
551 ret
= driver
->OnDeviceAdd(&dev_ctx
->device_obj
, &vector
);
553 DPRINT_ERR(VMBUS_DRV
,
554 "ERROR - Unable to add vmbus root device");
556 free_irq(vmbus_irq
, NULL
);
558 bus_unregister(&vmbus_drv_ctx
->bus
);
563 /* strcpy(dev_ctx->device.bus_id, dev_ctx->device_obj.name); */
564 dev_set_name(&dev_ctx
->device
, "vmbus_0_0");
565 memcpy(&dev_ctx
->class_id
, &dev_ctx
->device_obj
.deviceType
,
566 sizeof(struct hv_guid
));
567 memcpy(&dev_ctx
->device_id
, &dev_ctx
->device_obj
.deviceInstance
,
568 sizeof(struct hv_guid
));
570 /* No need to bind a driver to the root device. */
571 dev_ctx
->device
.parent
= NULL
;
572 /* NULL; vmbus_remove() does not get invoked */
573 dev_ctx
->device
.bus
= &vmbus_drv_ctx
->bus
;
575 /* Setup the device dispatch table */
576 dev_ctx
->device
.release
= vmbus_bus_release
;
578 /* Setup the bus as root device */
579 ret
= device_register(&dev_ctx
->device
);
581 DPRINT_ERR(VMBUS_DRV
,
582 "ERROR - Unable to register vmbus root device");
584 free_irq(vmbus_irq
, NULL
);
585 bus_unregister(&vmbus_drv_ctx
->bus
);
591 vmbus_request_offers();
592 wait_for_completion(&hv_channel_ready
);
599 * vmbus_bus_exit - Terminate the vmbus driver.
601 * This routine is opposite of vmbus_bus_init()
603 static void vmbus_bus_exit(void)
605 struct hv_driver
*driver
= &g_vmbus_drv
.drv_obj
;
606 struct vmbus_driver_context
*vmbus_drv_ctx
= &g_vmbus_drv
;
608 struct vm_device
*dev_ctx
= &g_vmbus_drv
.device_ctx
;
610 /* Remove the root device */
611 if (driver
->OnDeviceRemove
)
612 driver
->OnDeviceRemove(&dev_ctx
->device_obj
);
614 if (driver
->OnCleanup
)
615 driver
->OnCleanup(driver
);
617 /* Unregister the root bus device */
618 device_unregister(&dev_ctx
->device
);
620 bus_unregister(&vmbus_drv_ctx
->bus
);
622 free_irq(vmbus_irq
, NULL
);
624 tasklet_kill(&vmbus_drv_ctx
->msg_dpc
);
625 tasklet_kill(&vmbus_drv_ctx
->event_dpc
);
630 * vmbus_child_driver_register() - Register a vmbus's child driver
631 * @driver_ctx: Pointer to driver structure you want to register
633 * @driver_ctx is of type &struct driver_context
635 * Registers the given driver with Linux through the 'driver_register()' call
636 * And sets up the hyper-v vmbus handling for this driver.
637 * It will return the state of the 'driver_register()' call.
639 * Mainly used by Hyper-V drivers.
641 int vmbus_child_driver_register(struct driver_context
*driver_ctx
)
645 DPRINT_INFO(VMBUS_DRV
, "child driver (%p) registering - name %s",
646 driver_ctx
, driver_ctx
->driver
.name
);
648 /* The child driver on this vmbus */
649 driver_ctx
->driver
.bus
= &g_vmbus_drv
.bus
;
651 ret
= driver_register(&driver_ctx
->driver
);
653 vmbus_request_offers();
657 EXPORT_SYMBOL(vmbus_child_driver_register
);
660 * vmbus_child_driver_unregister() - Unregister a vmbus's child driver
661 * @driver_ctx: Pointer to driver structure you want to un-register
663 * @driver_ctx is of type &struct driver_context
665 * Un-register the given driver with Linux through the 'driver_unregister()'
666 * call. And ungegisters the driver from the Hyper-V vmbus handler.
668 * Mainly used by Hyper-V drivers.
670 void vmbus_child_driver_unregister(struct driver_context
*driver_ctx
)
672 DPRINT_INFO(VMBUS_DRV
, "child driver (%p) unregistering - name %s",
673 driver_ctx
, driver_ctx
->driver
.name
);
675 driver_unregister(&driver_ctx
->driver
);
677 driver_ctx
->driver
.bus
= NULL
;
679 EXPORT_SYMBOL(vmbus_child_driver_unregister
);
682 * vmbus_child_device_create - Creates and registers a new child device
685 struct hv_device
*vmbus_child_device_create(struct hv_guid
*type
,
686 struct hv_guid
*instance
,
687 struct vmbus_channel
*channel
)
689 struct vm_device
*child_device_ctx
;
690 struct hv_device
*child_device_obj
;
692 /* Allocate the new child device */
693 child_device_ctx
= kzalloc(sizeof(struct vm_device
), GFP_KERNEL
);
694 if (!child_device_ctx
) {
695 DPRINT_ERR(VMBUS_DRV
,
696 "unable to allocate device_context for child device");
700 DPRINT_DBG(VMBUS_DRV
, "child device (%p) allocated - "
701 "type {%02x%02x%02x%02x-%02x%02x-%02x%02x-"
702 "%02x%02x%02x%02x%02x%02x%02x%02x},"
703 "id {%02x%02x%02x%02x-%02x%02x-%02x%02x-"
704 "%02x%02x%02x%02x%02x%02x%02x%02x}",
705 &child_device_ctx
->device
,
706 type
->data
[3], type
->data
[2], type
->data
[1], type
->data
[0],
707 type
->data
[5], type
->data
[4], type
->data
[7], type
->data
[6],
708 type
->data
[8], type
->data
[9], type
->data
[10], type
->data
[11],
709 type
->data
[12], type
->data
[13], type
->data
[14], type
->data
[15],
710 instance
->data
[3], instance
->data
[2],
711 instance
->data
[1], instance
->data
[0],
712 instance
->data
[5], instance
->data
[4],
713 instance
->data
[7], instance
->data
[6],
714 instance
->data
[8], instance
->data
[9],
715 instance
->data
[10], instance
->data
[11],
716 instance
->data
[12], instance
->data
[13],
717 instance
->data
[14], instance
->data
[15]);
719 child_device_obj
= &child_device_ctx
->device_obj
;
720 child_device_obj
->channel
= channel
;
721 memcpy(&child_device_obj
->deviceType
, type
, sizeof(struct hv_guid
));
722 memcpy(&child_device_obj
->deviceInstance
, instance
,
723 sizeof(struct hv_guid
));
725 memcpy(&child_device_ctx
->class_id
, type
, sizeof(struct hv_guid
));
726 memcpy(&child_device_ctx
->device_id
, instance
, sizeof(struct hv_guid
));
728 return child_device_obj
;
732 * vmbus_child_device_register - Register the child device on the specified bus
734 int vmbus_child_device_register(struct hv_device
*root_device_obj
,
735 struct hv_device
*child_device_obj
)
738 struct vm_device
*root_device_ctx
=
739 to_vm_device(root_device_obj
);
740 struct vm_device
*child_device_ctx
=
741 to_vm_device(child_device_obj
);
742 static atomic_t device_num
= ATOMIC_INIT(0);
744 DPRINT_DBG(VMBUS_DRV
, "child device (%p) registering",
747 /* Set the device name. Otherwise, device_register() will fail. */
748 dev_set_name(&child_device_ctx
->device
, "vmbus_0_%d",
749 atomic_inc_return(&device_num
));
751 /* The new device belongs to this bus */
752 child_device_ctx
->device
.bus
= &g_vmbus_drv
.bus
; /* device->dev.bus; */
753 child_device_ctx
->device
.parent
= &root_device_ctx
->device
;
754 child_device_ctx
->device
.release
= vmbus_device_release
;
757 * Register with the LDM. This will kick off the driver/device
758 * binding...which will eventually call vmbus_match() and vmbus_probe()
760 ret
= device_register(&child_device_ctx
->device
);
762 /* vmbus_probe() error does not get propergate to device_register(). */
763 ret
= child_device_ctx
->probe_error
;
766 DPRINT_ERR(VMBUS_DRV
, "unable to register child device (%p)",
767 &child_device_ctx
->device
);
769 DPRINT_INFO(VMBUS_DRV
, "child device (%p) registered",
770 &child_device_ctx
->device
);
776 * vmbus_child_device_unregister - Remove the specified child device
779 void vmbus_child_device_unregister(struct hv_device
*device_obj
)
781 struct vm_device
*device_ctx
= to_vm_device(device_obj
);
783 DPRINT_INFO(VMBUS_DRV
, "unregistering child device (%p)",
784 &device_ctx
->device
);
787 * Kick off the process of unregistering the device.
788 * This will call vmbus_remove() and eventually vmbus_device_release()
790 device_unregister(&device_ctx
->device
);
792 DPRINT_INFO(VMBUS_DRV
, "child device (%p) unregistered",
793 &device_ctx
->device
);
797 * vmbus_uevent - add uevent for our device
799 * This routine is invoked when a device is added or removed on the vmbus to
800 * generate a uevent to udev in the userspace. The udev will then look at its
801 * rule and the uevent generated here to load the appropriate driver
803 static int vmbus_uevent(struct device
*device
, struct kobj_uevent_env
*env
)
805 struct vm_device
*device_ctx
= device_to_vm_device(device
);
808 DPRINT_INFO(VMBUS_DRV
, "generating uevent - VMBUS_DEVICE_CLASS_GUID={"
809 "%02x%02x%02x%02x-%02x%02x-%02x%02x-"
810 "%02x%02x%02x%02x%02x%02x%02x%02x}",
811 device_ctx
->class_id
.data
[3], device_ctx
->class_id
.data
[2],
812 device_ctx
->class_id
.data
[1], device_ctx
->class_id
.data
[0],
813 device_ctx
->class_id
.data
[5], device_ctx
->class_id
.data
[4],
814 device_ctx
->class_id
.data
[7], device_ctx
->class_id
.data
[6],
815 device_ctx
->class_id
.data
[8], device_ctx
->class_id
.data
[9],
816 device_ctx
->class_id
.data
[10],
817 device_ctx
->class_id
.data
[11],
818 device_ctx
->class_id
.data
[12],
819 device_ctx
->class_id
.data
[13],
820 device_ctx
->class_id
.data
[14],
821 device_ctx
->class_id
.data
[15]);
823 ret
= add_uevent_var(env
, "VMBUS_DEVICE_CLASS_GUID={"
824 "%02x%02x%02x%02x-%02x%02x-%02x%02x-"
825 "%02x%02x%02x%02x%02x%02x%02x%02x}",
826 device_ctx
->class_id
.data
[3],
827 device_ctx
->class_id
.data
[2],
828 device_ctx
->class_id
.data
[1],
829 device_ctx
->class_id
.data
[0],
830 device_ctx
->class_id
.data
[5],
831 device_ctx
->class_id
.data
[4],
832 device_ctx
->class_id
.data
[7],
833 device_ctx
->class_id
.data
[6],
834 device_ctx
->class_id
.data
[8],
835 device_ctx
->class_id
.data
[9],
836 device_ctx
->class_id
.data
[10],
837 device_ctx
->class_id
.data
[11],
838 device_ctx
->class_id
.data
[12],
839 device_ctx
->class_id
.data
[13],
840 device_ctx
->class_id
.data
[14],
841 device_ctx
->class_id
.data
[15]);
846 ret
= add_uevent_var(env
, "VMBUS_DEVICE_DEVICE_GUID={"
847 "%02x%02x%02x%02x-%02x%02x-%02x%02x-"
848 "%02x%02x%02x%02x%02x%02x%02x%02x}",
849 device_ctx
->device_id
.data
[3],
850 device_ctx
->device_id
.data
[2],
851 device_ctx
->device_id
.data
[1],
852 device_ctx
->device_id
.data
[0],
853 device_ctx
->device_id
.data
[5],
854 device_ctx
->device_id
.data
[4],
855 device_ctx
->device_id
.data
[7],
856 device_ctx
->device_id
.data
[6],
857 device_ctx
->device_id
.data
[8],
858 device_ctx
->device_id
.data
[9],
859 device_ctx
->device_id
.data
[10],
860 device_ctx
->device_id
.data
[11],
861 device_ctx
->device_id
.data
[12],
862 device_ctx
->device_id
.data
[13],
863 device_ctx
->device_id
.data
[14],
864 device_ctx
->device_id
.data
[15]);
872 * vmbus_match - Attempt to match the specified device to the specified driver
874 static int vmbus_match(struct device
*device
, struct device_driver
*driver
)
877 struct driver_context
*driver_ctx
= driver_to_driver_context(driver
);
878 struct vm_device
*device_ctx
= device_to_vm_device(device
);
880 /* We found our driver ? */
881 if (memcmp(&device_ctx
->class_id
, &driver_ctx
->class_id
,
882 sizeof(struct hv_guid
)) == 0) {
884 * !! NOTE: The driver_ctx is not a vmbus_drv_ctx. We typecast
885 * it here to access the struct hv_driver field
887 struct vmbus_driver_context
*vmbus_drv_ctx
=
888 (struct vmbus_driver_context
*)driver_ctx
;
890 device_ctx
->device_obj
.Driver
= &vmbus_drv_ctx
->drv_obj
;
891 DPRINT_INFO(VMBUS_DRV
,
892 "device object (%p) set to driver object (%p)",
893 &device_ctx
->device_obj
,
894 device_ctx
->device_obj
.Driver
);
902 * vmbus_probe_failed_cb - Callback when a driver probe failed in vmbus_probe()
904 * We need a callback because we cannot invoked device_unregister() inside
905 * vmbus_probe() since vmbus_probe() may be invoked inside device_register()
906 * i.e. we cannot call device_unregister() inside device_register()
908 static void vmbus_probe_failed_cb(struct work_struct
*context
)
910 struct vm_device
*device_ctx
= (struct vm_device
*)context
;
913 * Kick off the process of unregistering the device.
914 * This will call vmbus_remove() and eventually vmbus_device_release()
916 device_unregister(&device_ctx
->device
);
918 /* put_device(&device_ctx->device); */
922 * vmbus_probe - Add the new vmbus's child device
924 static int vmbus_probe(struct device
*child_device
)
927 struct driver_context
*driver_ctx
=
928 driver_to_driver_context(child_device
->driver
);
929 struct vm_device
*device_ctx
=
930 device_to_vm_device(child_device
);
932 /* Let the specific open-source driver handles the probe if it can */
933 if (driver_ctx
->probe
) {
934 ret
= device_ctx
->probe_error
= driver_ctx
->probe(child_device
);
936 DPRINT_ERR(VMBUS_DRV
, "probe() failed for device %s "
937 "(%p) on driver %s (%d)...",
938 dev_name(child_device
), child_device
,
939 child_device
->driver
->name
, ret
);
941 INIT_WORK(&device_ctx
->probe_failed_work_item
,
942 vmbus_probe_failed_cb
);
943 schedule_work(&device_ctx
->probe_failed_work_item
);
946 DPRINT_ERR(VMBUS_DRV
, "probe() method not set for driver - %s",
947 child_device
->driver
->name
);
954 * vmbus_remove - Remove a vmbus device
956 static int vmbus_remove(struct device
*child_device
)
959 struct driver_context
*driver_ctx
;
961 /* Special case root bus device */
962 if (child_device
->parent
== NULL
) {
964 * No-op since it is statically defined and handle in
970 if (child_device
->driver
) {
971 driver_ctx
= driver_to_driver_context(child_device
->driver
);
974 * Let the specific open-source driver handles the removal if
977 if (driver_ctx
->remove
) {
978 ret
= driver_ctx
->remove(child_device
);
980 DPRINT_ERR(VMBUS_DRV
,
981 "remove() method not set for driver - %s",
982 child_device
->driver
->name
);
991 * vmbus_shutdown - Shutdown a vmbus device
993 static void vmbus_shutdown(struct device
*child_device
)
995 struct driver_context
*driver_ctx
;
997 /* Special case root bus device */
998 if (child_device
->parent
== NULL
) {
1000 * No-op since it is statically defined and handle in
1006 /* The device may not be attached yet */
1007 if (!child_device
->driver
)
1010 driver_ctx
= driver_to_driver_context(child_device
->driver
);
1012 /* Let the specific open-source driver handles the removal if it can */
1013 if (driver_ctx
->shutdown
)
1014 driver_ctx
->shutdown(child_device
);
1020 * vmbus_bus_release - Final callback release of the vmbus root device
1022 static void vmbus_bus_release(struct device
*device
)
1025 /* Empty release functions are a bug, or a major sign
1026 * of a problem design, this MUST BE FIXED! */
1027 dev_err(device
, "%s needs to be fixed!\n", __func__
);
1032 * vmbus_device_release - Final callback release of the vmbus child device
1034 static void vmbus_device_release(struct device
*device
)
1036 struct vm_device
*device_ctx
= device_to_vm_device(device
);
1040 /* !!DO NOT REFERENCE device_ctx anymore at this point!! */
1044 * vmbus_msg_dpc - Tasklet routine to handle hypervisor messages
1046 static void vmbus_msg_dpc(unsigned long data
)
1048 struct hv_driver
*driver
= (struct hv_driver
*)data
;
1050 /* Call to bus driver to handle interrupt */
1051 vmbus_on_msg_dpc(driver
);
1055 * vmbus_event_dpc - Tasklet routine to handle hypervisor events
1057 static void vmbus_event_dpc(unsigned long data
)
1059 struct hv_driver
*driver
= (struct hv_driver
*)data
;
1061 /* Call to bus driver to handle interrupt */
1062 vmbus_on_event_dpc(driver
);
1065 static irqreturn_t
vmbus_isr(int irq
, void *dev_id
)
1067 struct hv_driver
*driver
= &g_vmbus_drv
.drv_obj
;
1070 /* Call to bus driver to handle interrupt */
1071 ret
= vmbus_on_isr(driver
);
1073 /* Schedules a dpc if necessary */
1075 if (test_bit(0, (unsigned long *)&ret
))
1076 tasklet_schedule(&g_vmbus_drv
.msg_dpc
);
1078 if (test_bit(1, (unsigned long *)&ret
))
1079 tasklet_schedule(&g_vmbus_drv
.event_dpc
);
1087 static struct dmi_system_id __initdata microsoft_hv_dmi_table
[] = {
1091 DMI_MATCH(DMI_SYS_VENDOR
, "Microsoft Corporation"),
1092 DMI_MATCH(DMI_PRODUCT_NAME
, "Virtual Machine"),
1093 DMI_MATCH(DMI_BOARD_NAME
, "Virtual Machine"),
1098 MODULE_DEVICE_TABLE(dmi
, microsoft_hv_dmi_table
);
1100 static int __init
vmbus_init(void)
1102 DPRINT_INFO(VMBUS_DRV
,
1103 "Vmbus initializing.... current log level 0x%x (%x,%x)",
1104 vmbus_loglevel
, HIWORD(vmbus_loglevel
), LOWORD(vmbus_loglevel
));
1105 /* Todo: it is used for loglevel, to be ported to new kernel. */
1107 if (!dmi_check_system(microsoft_hv_dmi_table
))
1110 return vmbus_bus_init();
1113 static void __exit
vmbus_exit(void)
1116 /* Todo: it is used for loglevel, to be ported to new kernel. */
1120 * We use a PCI table to determine if we should autoload this driver This is
1121 * needed by distro tools to determine if the hyperv drivers should be
1122 * installed and/or configured. We don't do anything else with the table, but
1123 * it needs to be present.
1125 static const struct pci_device_id microsoft_hv_pci_table
[] = {
1126 { PCI_DEVICE(0x1414, 0x5353) }, /* VGA compatible controller */
1129 MODULE_DEVICE_TABLE(pci
, microsoft_hv_pci_table
);
1131 MODULE_LICENSE("GPL");
1132 MODULE_VERSION(HV_DRV_VERSION
);
1133 module_param(vmbus_irq
, int, S_IRUGO
);
1134 module_param(vmbus_loglevel
, int, S_IRUGO
);
1136 module_init(vmbus_init
);
1137 module_exit(vmbus_exit
);