2 * Copyright (c) 2009, Citrix Systems, Inc.
3 * Copyright (c) 2010, Microsoft Corporation.
4 * Copyright (c) 2011, Novell Inc.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 #include <linux/init.h>
16 #include <linux/module.h>
17 #include <linux/device.h>
18 #include <linux/workqueue.h>
19 #include <linux/sched.h>
20 #include <linux/wait.h>
21 #include <linux/input.h>
22 #include <linux/hid.h>
23 #include <linux/hiddev.h>
24 #include <linux/pci.h>
25 #include <linux/dmi.h>
29 #include "version_info.h"
31 #include "vmbus_api.h"
33 #include "vmbus_packet_format.h"
39 struct hv_input_dev_info
{
40 unsigned short vendor
;
41 unsigned short product
;
42 unsigned short version
;
46 /* Represents the input vsc driver */
47 /* FIXME - can be removed entirely */
48 struct mousevsc_drv_obj
{
49 struct hv_driver Base
;
53 /* The maximum size of a synthetic input message. */
54 #define SYNTHHID_MAX_INPUT_REPORT_SIZE 16
60 * Beta, RC < 2008/1/22 1,0
63 #define SYNTHHID_INPUT_VERSION_MAJOR 2
64 #define SYNTHHID_INPUT_VERSION_MINOR 0
65 #define SYNTHHID_INPUT_VERSION (SYNTHHID_INPUT_VERSION_MINOR | \
66 (SYNTHHID_INPUT_VERSION_MAJOR << 16))
71 * Message types in the synthetic input protocol
73 enum synthhid_msg_type
{
74 SynthHidProtocolRequest
,
75 SynthHidProtocolResponse
,
76 SynthHidInitialDeviceInfo
,
77 SynthHidInitialDeviceInfoAck
,
83 * Basic message structures.
85 struct synthhid_msg_hdr
{
86 enum synthhid_msg_type type
;
91 struct synthhid_msg_hdr header
;
92 char data
[1]; /* Enclosed message */
95 union synthhid_version
{
106 struct synthhid_protocol_request
{
107 struct synthhid_msg_hdr header
;
108 union synthhid_version version_requested
;
111 struct synthhid_protocol_response
{
112 struct synthhid_msg_hdr header
;
113 union synthhid_version version_requested
;
114 unsigned char approved
;
117 struct synthhid_device_info
{
118 struct synthhid_msg_hdr header
;
119 struct hv_input_dev_info hid_dev_info
;
120 struct hid_descriptor hid_descriptor
;
123 struct synthhid_device_info_ack
{
124 struct synthhid_msg_hdr header
;
125 unsigned char reserved
;
128 struct synthhid_input_report
{
129 struct synthhid_msg_hdr header
;
135 #define INPUTVSC_SEND_RING_BUFFER_SIZE 10*PAGE_SIZE
136 #define INPUTVSC_RECV_RING_BUFFER_SIZE 10*PAGE_SIZE
138 #define NBITS(x) (((x)/BITS_PER_LONG)+1)
140 enum pipe_prot_msg_type
{
141 PipeMessageInvalid
= 0,
147 struct pipe_prt_msg
{
148 enum pipe_prot_msg_type type
;
156 struct mousevsc_prt_msg
{
157 enum pipe_prot_msg_type type
;
160 struct synthhid_protocol_request request
;
161 struct synthhid_protocol_response response
;
162 struct synthhid_device_info_ack ack
;
167 * Represents an mousevsc device
169 struct mousevsc_dev
{
170 struct hv_device
*Device
;
171 /* 0 indicates the device is being destroyed */
173 int NumOutstandingRequests
;
174 unsigned char bInitializeComplete
;
175 struct mousevsc_prt_msg ProtocolReq
;
176 struct mousevsc_prt_msg ProtocolResp
;
177 /* Synchronize the request/response if needed */
178 wait_queue_head_t ProtocolWaitEvent
;
179 wait_queue_head_t DeviceInfoWaitEvent
;
180 int protocol_wait_condition
;
181 int device_wait_condition
;
182 int DeviceInfoStatus
;
184 struct hid_descriptor
*HidDesc
;
185 unsigned char *ReportDesc
;
187 struct hv_input_dev_info hid_dev_info
;
191 static const char *driver_name
= "mousevsc";
193 /* {CFA8B69E-5B4A-4cc0-B98B-8BA1A1F3F95A} */
194 static const struct hv_guid mouse_guid
= {
195 .data
= {0x9E, 0xB6, 0xA8, 0xCF, 0x4A, 0x5B, 0xc0, 0x4c,
196 0xB9, 0x8B, 0x8B, 0xA1, 0xA1, 0xF3, 0xF9, 0x5A}
199 static void deviceinfo_callback(struct hv_device
*dev
, struct hv_input_dev_info
*info
);
200 static void inputreport_callback(struct hv_device
*dev
, void *packet
, u32 len
);
201 static void reportdesc_callback(struct hv_device
*dev
, void *packet
, u32 len
);
203 static struct mousevsc_dev
*AllocInputDevice(struct hv_device
*Device
)
205 struct mousevsc_dev
*inputDevice
;
207 inputDevice
= kzalloc(sizeof(struct mousevsc_dev
), GFP_KERNEL
);
213 * Set to 2 to allow both inbound and outbound traffics
214 * (ie GetInputDevice() and MustGetInputDevice()) to proceed.
216 atomic_cmpxchg(&inputDevice
->RefCount
, 0, 2);
218 inputDevice
->Device
= Device
;
219 Device
->ext
= inputDevice
;
224 static void FreeInputDevice(struct mousevsc_dev
*Device
)
226 WARN_ON(atomic_read(&Device
->RefCount
) == 0);
231 * Get the inputdevice object if exists and its refcount > 1
233 static struct mousevsc_dev
*GetInputDevice(struct hv_device
*Device
)
235 struct mousevsc_dev
*inputDevice
;
237 inputDevice
= (struct mousevsc_dev
*)Device
->ext
;
241 * This sure isn't a valid thing to print for debugging, no matter
242 * what the intention is...
244 * printk(KERN_ERR "-------------------------> REFCOUNT = %d",
245 * inputDevice->RefCount);
248 if (inputDevice
&& atomic_read(&inputDevice
->RefCount
) > 1)
249 atomic_inc(&inputDevice
->RefCount
);
257 * Get the inputdevice object iff exists and its refcount > 0
259 static struct mousevsc_dev
*MustGetInputDevice(struct hv_device
*Device
)
261 struct mousevsc_dev
*inputDevice
;
263 inputDevice
= (struct mousevsc_dev
*)Device
->ext
;
265 if (inputDevice
&& atomic_read(&inputDevice
->RefCount
))
266 atomic_inc(&inputDevice
->RefCount
);
273 static void PutInputDevice(struct hv_device
*Device
)
275 struct mousevsc_dev
*inputDevice
;
277 inputDevice
= (struct mousevsc_dev
*)Device
->ext
;
279 atomic_dec(&inputDevice
->RefCount
);
283 * Drop ref count to 1 to effectively disable GetInputDevice()
285 static struct mousevsc_dev
*ReleaseInputDevice(struct hv_device
*Device
)
287 struct mousevsc_dev
*inputDevice
;
289 inputDevice
= (struct mousevsc_dev
*)Device
->ext
;
291 /* Busy wait until the ref drop to 2, then set it to 1 */
292 while (atomic_cmpxchg(&inputDevice
->RefCount
, 2, 1) != 2)
299 * Drop ref count to 0. No one can use InputDevice object.
301 static struct mousevsc_dev
*FinalReleaseInputDevice(struct hv_device
*Device
)
303 struct mousevsc_dev
*inputDevice
;
305 inputDevice
= (struct mousevsc_dev
*)Device
->ext
;
307 /* Busy wait until the ref drop to 1, then set it to 0 */
308 while (atomic_cmpxchg(&inputDevice
->RefCount
, 1, 0) != 1)
315 static void MousevscOnSendCompletion(struct hv_device
*Device
, struct vmpacket_descriptor
*Packet
)
317 struct mousevsc_dev
*inputDevice
;
320 inputDevice
= MustGetInputDevice(Device
);
322 pr_err("unable to get input device...device being destroyed?");
326 request
= (void *)(unsigned long)Packet
->trans_id
;
328 if (request
== &inputDevice
->ProtocolReq
) {
330 /* Shouldn't we be doing something here? */
333 PutInputDevice(Device
);
336 static void MousevscOnReceiveDeviceInfo(struct mousevsc_dev
*InputDevice
, struct synthhid_device_info
*DeviceInfo
)
339 struct hid_descriptor
*desc
;
340 struct mousevsc_prt_msg ack
;
342 /* Assume success for now */
343 InputDevice
->DeviceInfoStatus
= 0;
345 /* Save the device attr */
346 memcpy(&InputDevice
->hid_dev_info
, &DeviceInfo
->hid_dev_info
, sizeof(struct hv_input_dev_info
));
348 /* Save the hid desc */
349 desc
= &DeviceInfo
->hid_descriptor
;
350 WARN_ON(desc
->bLength
> 0);
352 InputDevice
->HidDesc
= kzalloc(desc
->bLength
, GFP_KERNEL
);
354 if (!InputDevice
->HidDesc
) {
355 pr_err("unable to allocate hid descriptor - size %d", desc
->bLength
);
359 memcpy(InputDevice
->HidDesc
, desc
, desc
->bLength
);
361 /* Save the report desc */
362 InputDevice
->ReportDescSize
= desc
->desc
[0].wDescriptorLength
;
363 InputDevice
->ReportDesc
= kzalloc(InputDevice
->ReportDescSize
,
366 if (!InputDevice
->ReportDesc
) {
367 pr_err("unable to allocate report descriptor - size %d",
368 InputDevice
->ReportDescSize
);
372 memcpy(InputDevice
->ReportDesc
,
373 ((unsigned char *)desc
) + desc
->bLength
,
374 desc
->desc
[0].wDescriptorLength
);
377 memset(&ack
, sizeof(struct mousevsc_prt_msg
), 0);
379 ack
.type
= PipeMessageData
;
380 ack
.size
= sizeof(struct synthhid_device_info_ack
);
382 ack
.ack
.header
.type
= SynthHidInitialDeviceInfoAck
;
383 ack
.ack
.header
.size
= 1;
384 ack
.ack
.reserved
= 0;
386 ret
= vmbus_sendpacket(InputDevice
->Device
->channel
,
388 sizeof(struct pipe_prt_msg
) - sizeof(unsigned char) +
389 sizeof(struct synthhid_device_info_ack
),
392 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED
);
394 pr_err("unable to send synthhid device info ack - ret %d",
399 InputDevice
->device_wait_condition
= 1;
400 wake_up(&InputDevice
->DeviceInfoWaitEvent
);
405 kfree(InputDevice
->HidDesc
);
406 InputDevice
->HidDesc
= NULL
;
408 kfree(InputDevice
->ReportDesc
);
409 InputDevice
->ReportDesc
= NULL
;
411 InputDevice
->DeviceInfoStatus
= -1;
412 InputDevice
->device_wait_condition
= 1;
413 wake_up(&InputDevice
->DeviceInfoWaitEvent
);
416 static void MousevscOnReceiveInputReport(struct mousevsc_dev
*InputDevice
, struct synthhid_input_report
*InputReport
)
418 struct mousevsc_drv_obj
*inputDriver
;
420 if (!InputDevice
->bInitializeComplete
) {
421 pr_info("Initialization incomplete...ignoring InputReport msg");
425 inputDriver
= (struct mousevsc_drv_obj
*)InputDevice
->Device
->drv
;
427 inputreport_callback(InputDevice
->Device
,
429 InputReport
->header
.size
);
432 static void MousevscOnReceive(struct hv_device
*Device
, struct vmpacket_descriptor
*Packet
)
434 struct pipe_prt_msg
*pipeMsg
;
435 struct synthhid_msg
*hidMsg
;
436 struct mousevsc_dev
*inputDevice
;
438 inputDevice
= MustGetInputDevice(Device
);
440 pr_err("unable to get input device...device being destroyed?");
444 pipeMsg
= (struct pipe_prt_msg
*)((unsigned long)Packet
+ (Packet
->offset8
<< 3));
446 if (pipeMsg
->type
!= PipeMessageData
) {
447 pr_err("unknown pipe msg type - type %d len %d",
448 pipeMsg
->type
, pipeMsg
->size
);
449 PutInputDevice(Device
);
453 hidMsg
= (struct synthhid_msg
*)&pipeMsg
->data
[0];
455 switch (hidMsg
->header
.type
) {
456 case SynthHidProtocolResponse
:
457 memcpy(&inputDevice
->ProtocolResp
, pipeMsg
,
458 pipeMsg
->size
+ sizeof(struct pipe_prt_msg
) -
459 sizeof(unsigned char));
460 inputDevice
->protocol_wait_condition
= 1;
461 wake_up(&inputDevice
->ProtocolWaitEvent
);
464 case SynthHidInitialDeviceInfo
:
465 WARN_ON(pipeMsg
->size
>= sizeof(struct hv_input_dev_info
));
468 * Parse out the device info into device attr,
469 * hid desc and report desc
471 MousevscOnReceiveDeviceInfo(inputDevice
,
472 (struct synthhid_device_info
*)&pipeMsg
->data
[0]);
474 case SynthHidInputReport
:
475 MousevscOnReceiveInputReport(inputDevice
,
476 (struct synthhid_input_report
*)&pipeMsg
->data
[0]);
480 pr_err("unsupported hid msg type - type %d len %d",
481 hidMsg
->header
.type
, hidMsg
->header
.size
);
485 PutInputDevice(Device
);
488 static void MousevscOnChannelCallback(void *Context
)
490 const int packetSize
= 0x100;
492 struct hv_device
*device
= (struct hv_device
*)Context
;
493 struct mousevsc_dev
*inputDevice
;
497 unsigned char packet
[packetSize
];
498 struct vmpacket_descriptor
*desc
;
499 unsigned char *buffer
= packet
;
500 int bufferlen
= packetSize
;
502 inputDevice
= MustGetInputDevice(device
);
505 pr_err("unable to get input device...device being destroyed?");
510 ret
= vmbus_recvpacket_raw(device
->channel
, buffer
, bufferlen
, &bytesRecvd
, &requestId
);
513 if (bytesRecvd
> 0) {
514 desc
= (struct vmpacket_descriptor
*)buffer
;
516 switch (desc
->type
) {
518 MousevscOnSendCompletion(device
,
522 case VM_PKT_DATA_INBAND
:
523 MousevscOnReceive(device
, desc
);
527 pr_err("unhandled packet type %d, tid %llx len %d\n",
535 if (bufferlen
> packetSize
) {
539 bufferlen
= packetSize
;
543 * pr_debug("nothing else to read...");
546 if (bufferlen
> packetSize
) {
550 bufferlen
= packetSize
;
554 } else if (ret
== -2) {
555 /* Handle large packet */
556 bufferlen
= bytesRecvd
;
557 buffer
= kzalloc(bytesRecvd
, GFP_KERNEL
);
559 if (buffer
== NULL
) {
561 bufferlen
= packetSize
;
563 /* Try again next time around */
564 pr_err("unable to allocate buffer of size %d!",
571 PutInputDevice(device
);
576 static int MousevscConnectToVsp(struct hv_device
*Device
)
579 struct mousevsc_dev
*inputDevice
;
580 struct mousevsc_prt_msg
*request
;
581 struct mousevsc_prt_msg
*response
;
583 inputDevice
= GetInputDevice(Device
);
586 pr_err("unable to get input device...device being destroyed?");
590 init_waitqueue_head(&inputDevice
->ProtocolWaitEvent
);
591 init_waitqueue_head(&inputDevice
->DeviceInfoWaitEvent
);
593 request
= &inputDevice
->ProtocolReq
;
596 * Now, initiate the vsc/vsp initialization protocol on the open channel
598 memset(request
, sizeof(struct mousevsc_prt_msg
), 0);
600 request
->type
= PipeMessageData
;
601 request
->size
= sizeof(struct synthhid_protocol_request
);
603 request
->request
.header
.type
= SynthHidProtocolRequest
;
604 request
->request
.header
.size
= sizeof(unsigned long);
605 request
->request
.version_requested
.version
= SYNTHHID_INPUT_VERSION
;
607 pr_info("synthhid protocol request...");
609 ret
= vmbus_sendpacket(Device
->channel
, request
,
610 sizeof(struct pipe_prt_msg
) -
611 sizeof(unsigned char) +
612 sizeof(struct synthhid_protocol_request
),
613 (unsigned long)request
,
615 VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED
);
617 pr_err("unable to send synthhid protocol request.");
621 inputDevice
->protocol_wait_condition
= 0;
622 wait_event_timeout(inputDevice
->ProtocolWaitEvent
, inputDevice
->protocol_wait_condition
, msecs_to_jiffies(1000));
623 if (inputDevice
->protocol_wait_condition
== 0) {
628 response
= &inputDevice
->ProtocolResp
;
630 if (!response
->response
.approved
) {
631 pr_err("synthhid protocol request failed (version %d)",
632 SYNTHHID_INPUT_VERSION
);
637 inputDevice
->device_wait_condition
= 0;
638 wait_event_timeout(inputDevice
->DeviceInfoWaitEvent
, inputDevice
->device_wait_condition
, msecs_to_jiffies(1000));
639 if (inputDevice
->device_wait_condition
== 0) {
645 * We should have gotten the device attr, hid desc and report
648 if (!inputDevice
->DeviceInfoStatus
)
649 pr_info("**** input channel up and running!! ****");
654 PutInputDevice(Device
);
659 static int MousevscOnDeviceAdd(struct hv_device
*Device
, void *AdditionalInfo
)
662 struct mousevsc_dev
*inputDevice
;
663 struct mousevsc_drv_obj
*inputDriver
;
664 struct hv_input_dev_info dev_info
;
666 inputDevice
= AllocInputDevice(Device
);
673 inputDevice
->bInitializeComplete
= false;
675 /* Open the channel */
676 ret
= vmbus_open(Device
->channel
,
677 INPUTVSC_SEND_RING_BUFFER_SIZE
,
678 INPUTVSC_RECV_RING_BUFFER_SIZE
,
681 MousevscOnChannelCallback
,
686 pr_err("unable to open channel: %d", ret
);
690 pr_info("InputVsc channel open: %d", ret
);
692 ret
= MousevscConnectToVsp(Device
);
695 pr_err("unable to connect channel: %d", ret
);
697 vmbus_close(Device
->channel
);
701 inputDriver
= (struct mousevsc_drv_obj
*)inputDevice
->Device
->drv
;
703 dev_info
.vendor
= inputDevice
->hid_dev_info
.vendor
;
704 dev_info
.product
= inputDevice
->hid_dev_info
.product
;
705 dev_info
.version
= inputDevice
->hid_dev_info
.version
;
706 strcpy(dev_info
.name
, "Microsoft Vmbus HID-compliant Mouse");
708 /* Send the device info back up */
709 deviceinfo_callback(Device
, &dev_info
);
711 /* Send the report desc back up */
712 /* workaround SA-167 */
713 if (inputDevice
->ReportDesc
[14] == 0x25)
714 inputDevice
->ReportDesc
[14] = 0x29;
716 reportdesc_callback(Device
, inputDevice
->ReportDesc
,
717 inputDevice
->ReportDescSize
);
719 inputDevice
->bInitializeComplete
= true;
725 static int MousevscOnDeviceRemove(struct hv_device
*Device
)
727 struct mousevsc_dev
*inputDevice
;
730 pr_info("disabling input device (%p)...",
733 inputDevice
= ReleaseInputDevice(Device
);
737 * At this point, all outbound traffic should be disable. We only
738 * allow inbound traffic (responses) to proceed
740 * so that outstanding requests can be completed.
742 while (inputDevice
->NumOutstandingRequests
) {
743 pr_info("waiting for %d requests to complete...", inputDevice
->NumOutstandingRequests
);
748 pr_info("removing input device (%p)...", Device
->ext
);
750 inputDevice
= FinalReleaseInputDevice(Device
);
752 pr_info("input device (%p) safe to remove", inputDevice
);
754 /* Close the channel */
755 vmbus_close(Device
->channel
);
757 FreeInputDevice(inputDevice
);
762 static void MousevscOnCleanup(struct hv_driver
*drv
)
769 struct input_device_context
{
770 struct hv_device
*device_ctx
;
771 struct hid_device
*hid_device
;
772 struct hv_input_dev_info device_info
;
777 static struct mousevsc_drv_obj g_mousevsc_drv
;
779 static void deviceinfo_callback(struct hv_device
*dev
, struct hv_input_dev_info
*info
)
781 struct input_device_context
*input_device_ctx
=
782 dev_get_drvdata(&dev
->device
);
784 memcpy(&input_device_ctx
->device_info
, info
,
785 sizeof(struct hv_input_dev_info
));
787 DPRINT_INFO(INPUTVSC_DRV
, "%s", __func__
);
790 static void inputreport_callback(struct hv_device
*dev
, void *packet
, u32 len
)
794 struct input_device_context
*input_dev_ctx
=
795 dev_get_drvdata(&dev
->device
);
797 ret
= hid_input_report(input_dev_ctx
->hid_device
,
798 HID_INPUT_REPORT
, packet
, len
, 1);
800 DPRINT_DBG(INPUTVSC_DRV
, "hid_input_report (ret %d)", ret
);
803 static int mousevsc_hid_open(struct hid_device
*hid
)
808 static void mousevsc_hid_close(struct hid_device
*hid
)
812 static int mousevsc_probe(struct device
*device
)
816 struct hv_driver
*drv
=
817 drv_to_hv_drv(device
->driver
);
818 struct mousevsc_drv_obj
*mousevsc_drv_obj
= drv
->priv
;
820 struct hv_device
*device_obj
= device_to_hv_device(device
);
821 struct input_device_context
*input_dev_ctx
;
823 input_dev_ctx
= kmalloc(sizeof(struct input_device_context
),
826 dev_set_drvdata(device
, input_dev_ctx
);
828 /* Call to the vsc driver to add the device */
829 ret
= mousevsc_drv_obj
->Base
.dev_add(device_obj
, NULL
);
832 DPRINT_ERR(INPUTVSC_DRV
, "unable to add input vsc device");
840 static int mousevsc_remove(struct device
*device
)
844 struct hv_driver
*drv
=
845 drv_to_hv_drv(device
->driver
);
846 struct mousevsc_drv_obj
*mousevsc_drv_obj
= drv
->priv
;
848 struct hv_device
*device_obj
= device_to_hv_device(device
);
849 struct input_device_context
*input_dev_ctx
;
851 input_dev_ctx
= kmalloc(sizeof(struct input_device_context
),
854 dev_set_drvdata(device
, input_dev_ctx
);
856 if (input_dev_ctx
->connected
) {
857 hidinput_disconnect(input_dev_ctx
->hid_device
);
858 input_dev_ctx
->connected
= 0;
861 if (!mousevsc_drv_obj
->Base
.dev_rm
)
865 * Call to the vsc driver to let it know that the device
868 ret
= mousevsc_drv_obj
->Base
.dev_rm(device_obj
);
871 DPRINT_ERR(INPUTVSC_DRV
,
872 "unable to remove vsc device (ret %d)", ret
);
875 kfree(input_dev_ctx
);
880 static void reportdesc_callback(struct hv_device
*dev
, void *packet
, u32 len
)
882 struct input_device_context
*input_device_ctx
=
883 dev_get_drvdata(&dev
->device
);
884 struct hid_device
*hid_dev
;
886 /* hid_debug = -1; */
887 hid_dev
= kmalloc(sizeof(struct hid_device
), GFP_KERNEL
);
889 if (hid_parse_report(hid_dev
, packet
, len
)) {
890 DPRINT_INFO(INPUTVSC_DRV
, "Unable to call hd_parse_report");
895 DPRINT_INFO(INPUTVSC_DRV
, "hid_device created");
897 hid_dev
->ll_driver
->open
= mousevsc_hid_open
;
898 hid_dev
->ll_driver
->close
= mousevsc_hid_close
;
900 hid_dev
->bus
= BUS_VIRTUAL
;
901 hid_dev
->vendor
= input_device_ctx
->device_info
.vendor
;
902 hid_dev
->product
= input_device_ctx
->device_info
.product
;
903 hid_dev
->version
= input_device_ctx
->device_info
.version
;
904 hid_dev
->dev
= dev
->device
;
906 sprintf(hid_dev
->name
, "%s",
907 input_device_ctx
->device_info
.name
);
910 * HJ Do we want to call it with a 0
912 if (!hidinput_connect(hid_dev
, 0)) {
913 hid_dev
->claimed
|= HID_CLAIMED_INPUT
;
915 input_device_ctx
->connected
= 1;
917 DPRINT_INFO(INPUTVSC_DRV
,
918 "HID device claimed by input\n");
921 if (!hid_dev
->claimed
) {
922 DPRINT_ERR(INPUTVSC_DRV
,
923 "HID device not claimed by "
924 "input or hiddev\n");
927 input_device_ctx
->hid_device
= hid_dev
;
933 static int mousevsc_drv_exit_cb(struct device
*dev
, void *data
)
935 struct device
**curr
= (struct device
**)data
;
941 static void mousevsc_drv_exit(void)
943 struct mousevsc_drv_obj
*mousevsc_drv_obj
= &g_mousevsc_drv
;
944 struct hv_driver
*drv
= &g_mousevsc_drv
.Base
;
947 struct device
*current_dev
= NULL
;
953 ret
= driver_for_each_device(&drv
->driver
, NULL
,
954 (void *)¤t_dev
,
955 mousevsc_drv_exit_cb
);
957 printk(KERN_ERR
"Can't find mouse device!\n");
959 if (current_dev
== NULL
)
962 /* Initiate removal from the top-down */
963 device_unregister(current_dev
);
966 if (mousevsc_drv_obj
->Base
.cleanup
)
967 mousevsc_drv_obj
->Base
.cleanup(&mousevsc_drv_obj
->Base
);
969 vmbus_child_driver_unregister(&drv
->driver
);
974 static int mouse_vsc_initialize(struct hv_driver
*Driver
)
976 struct mousevsc_drv_obj
*inputDriver
=
977 (struct mousevsc_drv_obj
*)Driver
;
980 Driver
->name
= driver_name
;
981 memcpy(&Driver
->dev_type
, &mouse_guid
,
982 sizeof(struct hv_guid
));
984 /* Setup the dispatch table */
985 inputDriver
->Base
.dev_add
= MousevscOnDeviceAdd
;
986 inputDriver
->Base
.dev_rm
= MousevscOnDeviceRemove
;
987 inputDriver
->Base
.cleanup
= MousevscOnCleanup
;
993 static int __init
mousevsc_init(void)
995 struct mousevsc_drv_obj
*input_drv_obj
= &g_mousevsc_drv
;
996 struct hv_driver
*drv
= &g_mousevsc_drv
.Base
;
998 DPRINT_INFO(INPUTVSC_DRV
, "Hyper-V Mouse driver initializing.");
1000 /* Callback to client driver to complete the initialization */
1001 mouse_vsc_initialize(&input_drv_obj
->Base
);
1003 drv
->driver
.name
= input_drv_obj
->Base
.name
;
1004 drv
->priv
= input_drv_obj
;
1006 drv
->driver
.probe
= mousevsc_probe
;
1007 drv
->driver
.remove
= mousevsc_remove
;
1009 /* The driver belongs to vmbus */
1010 vmbus_child_driver_register(&drv
->driver
);
1015 static void __exit
mousevsc_exit(void)
1017 mousevsc_drv_exit();
1021 * We don't want to automatically load this driver just yet, it's quite
1022 * broken. It's safe if you want to load it yourself manually, but
1023 * don't inflict it on unsuspecting users, that's just mean.
1028 * We use a PCI table to determine if we should autoload this driver This is
1029 * needed by distro tools to determine if the hyperv drivers should be
1030 * installed and/or configured. We don't do anything else with the table, but
1031 * it needs to be present.
1033 const static struct pci_device_id microsoft_hv_pci_table
[] = {
1034 { PCI_DEVICE(0x1414, 0x5353) }, /* VGA compatible controller */
1037 MODULE_DEVICE_TABLE(pci
, microsoft_hv_pci_table
);
1040 MODULE_LICENSE("GPL");
1041 MODULE_VERSION(HV_DRV_VERSION
);
1042 module_init(mousevsc_init
);
1043 module_exit(mousevsc_exit
);