drivers/staging/hv/hv_mouse.c

   1 /*
   2  *  Copyright (c) 2009, Citrix Systems, Inc.
   3  *  Copyright (c) 2010, Microsoft Corporation.
   4  *  Copyright (c) 2011, Novell Inc.
   5  *
   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.
   9  *
  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
  13  *  more details.
  14  */
  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>
  26
  27 #include "hv_api.h"
  28 #include "logging.h"
  29 #include "version_info.h"
  30 #include "vmbus.h"
  31 #include "vmbus_api.h"
  32 #include "channel.h"
  33 #include "vmbus_packet_format.h"
  34
  35
  36 /*
  37  * Data types
  38  */
  39 struct hv_input_dev_info {
  40         unsigned short vendor;
  41         unsigned short product;
  42         unsigned short version;
  43         char name[128];
  44 };
  45
  46 /* Represents the input vsc driver */
  47 /* FIXME - can be removed entirely */
  48 struct mousevsc_drv_obj {
  49         struct hv_driver Base;
  50 };
  51
  52
  53 /* The maximum size of a synthetic input message. */
  54 #define SYNTHHID_MAX_INPUT_REPORT_SIZE 16
  55
  56 /*
  57  * Current version
  58  *
  59  * History:
  60  * Beta, RC < 2008/1/22        1,0
  61  * RC > 2008/1/22              2,0
  62  */
  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))
  67
  68
  69 #pragma pack(push,1)
  70 /*
  71  * Message types in the synthetic input protocol
  72  */
  73 enum synthhid_msg_type {
  74         SynthHidProtocolRequest,
  75         SynthHidProtocolResponse,
  76         SynthHidInitialDeviceInfo,
  77         SynthHidInitialDeviceInfoAck,
  78         SynthHidInputReport,
  79         SynthHidMax
  80 };
  81
  82 /*
  83  * Basic message structures.
  84  */
  85 struct synthhid_msg_hdr {
  86         enum synthhid_msg_type type;
  87         u32 size;
  88 };
  89
  90 struct synthhid_msg {
  91         struct synthhid_msg_hdr header;
  92         char data[1]; /* Enclosed message */
  93 };
  94
  95 union synthhid_version {
  96         struct {
  97                 u16 minor_version;
  98                 u16 major_version;
  99         };
 100         u32 version;
 101 };
 102
 103 /*
 104  * Protocol messages
 105  */
 106 struct synthhid_protocol_request {
 107         struct synthhid_msg_hdr header;
 108         union synthhid_version version_requested;
 109 };
 110
 111 struct synthhid_protocol_response {
 112         struct synthhid_msg_hdr header;
 113         union synthhid_version version_requested;
 114         unsigned char approved;
 115 };
 116
 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;
 121 };
 122
 123 struct synthhid_device_info_ack {
 124         struct synthhid_msg_hdr header;
 125         unsigned char reserved;
 126 };
 127
 128 struct synthhid_input_report {
 129         struct synthhid_msg_hdr header;
 130         char buffer[1];
 131 };
 132
 133 #pragma pack(pop)
 134
 135 #define INPUTVSC_SEND_RING_BUFFER_SIZE          10*PAGE_SIZE
 136 #define INPUTVSC_RECV_RING_BUFFER_SIZE          10*PAGE_SIZE
 137
 138 #define NBITS(x) (((x)/BITS_PER_LONG)+1)
 139
 140 enum pipe_prot_msg_type {
 141         PipeMessageInvalid = 0,
 142         PipeMessageData,
 143         PipeMessageMaximum
 144 };
 145
 146
 147 struct pipe_prt_msg {
 148         enum pipe_prot_msg_type type;
 149         u32 size;
 150         char data[1];
 151 };
 152
 153 /*
 154  * Data types
 155  */
 156 struct  mousevsc_prt_msg {
 157         enum pipe_prot_msg_type type;
 158         u32 size;
 159         union {
 160                 struct synthhid_protocol_request request;
 161                 struct synthhid_protocol_response response;
 162                 struct synthhid_device_info_ack ack;
 163         };
 164 };
 165
 166 /*
 167  * Represents an mousevsc device
 168  */
 169 struct mousevsc_dev {
 170         struct hv_device        *Device;
 171         /* 0 indicates the device is being destroyed */
 172         atomic_t                RefCount;
 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;
 183
 184         struct hid_descriptor   *HidDesc;
 185         unsigned char           *ReportDesc;
 186         u32                     ReportDescSize;
 187         struct hv_input_dev_info hid_dev_info;
 188 };
 189
 190
 191 static const char *driver_name = "mousevsc";
 192
 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}
 197 };
 198
 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);
 202
 203 static struct mousevsc_dev *AllocInputDevice(struct hv_device *Device)
 204 {
 205         struct mousevsc_dev *inputDevice;
 206
 207         inputDevice = kzalloc(sizeof(struct mousevsc_dev), GFP_KERNEL);
 208
 209         if (!inputDevice)
 210                 return NULL;
 211
 212         /*
 213          * Set to 2 to allow both inbound and outbound traffics
 214          * (ie GetInputDevice() and MustGetInputDevice()) to proceed.
 215          */
 216         atomic_cmpxchg(&inputDevice->RefCount, 0, 2);
 217
 218         inputDevice->Device = Device;
 219         Device->ext = inputDevice;
 220
 221         return inputDevice;
 222 }
 223
 224 static void FreeInputDevice(struct mousevsc_dev *Device)
 225 {
 226         WARN_ON(atomic_read(&Device->RefCount) == 0);
 227         kfree(Device);
 228 }
 229
 230 /*
 231  * Get the inputdevice object if exists and its refcount > 1
 232  */
 233 static struct mousevsc_dev *GetInputDevice(struct hv_device *Device)
 234 {
 235         struct mousevsc_dev *inputDevice;
 236
 237         inputDevice = (struct mousevsc_dev *)Device->ext;
 238
 239 /*
 240  *      FIXME
 241  *      This sure isn't a valid thing to print for debugging, no matter
 242  *      what the intention is...
 243  *
 244  *      printk(KERN_ERR "-------------------------> REFCOUNT = %d",
 245  *             inputDevice->RefCount);
 246  */
 247
 248         if (inputDevice && atomic_read(&inputDevice->RefCount) > 1)
 249                 atomic_inc(&inputDevice->RefCount);
 250         else
 251                 inputDevice = NULL;
 252
 253         return inputDevice;
 254 }
 255
 256 /*
 257  * Get the inputdevice object iff exists and its refcount > 0
 258  */
 259 static struct mousevsc_dev *MustGetInputDevice(struct hv_device *Device)
 260 {
 261         struct mousevsc_dev *inputDevice;
 262
 263         inputDevice = (struct mousevsc_dev *)Device->ext;
 264
 265         if (inputDevice && atomic_read(&inputDevice->RefCount))
 266                 atomic_inc(&inputDevice->RefCount);
 267         else
 268                 inputDevice = NULL;
 269
 270         return inputDevice;
 271 }
 272
 273 static void PutInputDevice(struct hv_device *Device)
 274 {
 275         struct mousevsc_dev *inputDevice;
 276
 277         inputDevice = (struct mousevsc_dev *)Device->ext;
 278
 279         atomic_dec(&inputDevice->RefCount);
 280 }
 281
 282 /*
 283  * Drop ref count to 1 to effectively disable GetInputDevice()
 284  */
 285 static struct mousevsc_dev *ReleaseInputDevice(struct hv_device *Device)
 286 {
 287         struct mousevsc_dev *inputDevice;
 288
 289         inputDevice = (struct mousevsc_dev *)Device->ext;
 290
 291         /* Busy wait until the ref drop to 2, then set it to 1  */
 292         while (atomic_cmpxchg(&inputDevice->RefCount, 2, 1) != 2)
 293                 udelay(100);
 294
 295         return inputDevice;
 296 }
 297
 298 /*
 299  * Drop ref count to 0. No one can use InputDevice object.
 300  */
 301 static struct mousevsc_dev *FinalReleaseInputDevice(struct hv_device *Device)
 302 {
 303         struct mousevsc_dev *inputDevice;
 304
 305         inputDevice = (struct mousevsc_dev *)Device->ext;
 306
 307         /* Busy wait until the ref drop to 1, then set it to 0  */
 308         while (atomic_cmpxchg(&inputDevice->RefCount, 1, 0) != 1)
 309                 udelay(100);
 310
 311         Device->ext = NULL;
 312         return inputDevice;
 313 }
 314
 315 static void MousevscOnSendCompletion(struct hv_device *Device, struct vmpacket_descriptor *Packet)
 316 {
 317         struct mousevsc_dev *inputDevice;
 318         void *request;
 319
 320         inputDevice = MustGetInputDevice(Device);
 321         if (!inputDevice) {
 322                 pr_err("unable to get input device...device being destroyed?");
 323                 return;
 324         }
 325
 326         request = (void *)(unsigned long)Packet->trans_id;
 327
 328         if (request == &inputDevice->ProtocolReq) {
 329                 /* FIXME */
 330                 /* Shouldn't we be doing something here? */
 331         }
 332
 333         PutInputDevice(Device);
 334 }
 335
 336 static void MousevscOnReceiveDeviceInfo(struct mousevsc_dev *InputDevice, struct synthhid_device_info *DeviceInfo)
 337 {
 338         int ret = 0;
 339         struct hid_descriptor *desc;
 340         struct mousevsc_prt_msg ack;
 341
 342         /* Assume success for now */
 343         InputDevice->DeviceInfoStatus = 0;
 344
 345         /* Save the device attr */
 346         memcpy(&InputDevice->hid_dev_info, &DeviceInfo->hid_dev_info, sizeof(struct hv_input_dev_info));
 347
 348         /* Save the hid desc */
 349         desc = &DeviceInfo->hid_descriptor;
 350         WARN_ON(desc->bLength > 0);
 351
 352         InputDevice->HidDesc = kzalloc(desc->bLength, GFP_KERNEL);
 353
 354         if (!InputDevice->HidDesc) {
 355                 pr_err("unable to allocate hid descriptor - size %d", desc->bLength);
 356                 goto Cleanup;
 357         }
 358
 359         memcpy(InputDevice->HidDesc, desc, desc->bLength);
 360
 361         /* Save the report desc */
 362         InputDevice->ReportDescSize = desc->desc[0].wDescriptorLength;
 363         InputDevice->ReportDesc = kzalloc(InputDevice->ReportDescSize,
 364                                           GFP_KERNEL);
 365
 366         if (!InputDevice->ReportDesc) {
 367                 pr_err("unable to allocate report descriptor - size %d",
 368                            InputDevice->ReportDescSize);
 369                 goto Cleanup;
 370         }
 371
 372         memcpy(InputDevice->ReportDesc,
 373                ((unsigned char *)desc) + desc->bLength,
 374                desc->desc[0].wDescriptorLength);
 375
 376         /* Send the ack */
 377         memset(&ack, sizeof(struct mousevsc_prt_msg), 0);
 378
 379         ack.type = PipeMessageData;
 380         ack.size = sizeof(struct synthhid_device_info_ack);
 381
 382         ack.ack.header.type = SynthHidInitialDeviceInfoAck;
 383         ack.ack.header.size = 1;
 384         ack.ack.reserved = 0;
 385
 386         ret = vmbus_sendpacket(InputDevice->Device->channel,
 387                         &ack,
 388                         sizeof(struct pipe_prt_msg) - sizeof(unsigned char) +
 389                         sizeof(struct synthhid_device_info_ack),
 390                         (unsigned long)&ack,
 391                         VM_PKT_DATA_INBAND,
 392                         VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 393         if (ret != 0) {
 394                 pr_err("unable to send synthhid device info ack - ret %d",
 395                            ret);
 396                 goto Cleanup;
 397         }
 398
 399         InputDevice->device_wait_condition = 1;
 400         wake_up(&InputDevice->DeviceInfoWaitEvent);
 401
 402         return;
 403
 404 Cleanup:
 405         kfree(InputDevice->HidDesc);
 406         InputDevice->HidDesc = NULL;
 407
 408         kfree(InputDevice->ReportDesc);
 409         InputDevice->ReportDesc = NULL;
 410
 411         InputDevice->DeviceInfoStatus = -1;
 412         InputDevice->device_wait_condition = 1;
 413         wake_up(&InputDevice->DeviceInfoWaitEvent);
 414 }
 415
 416 static void MousevscOnReceiveInputReport(struct mousevsc_dev *InputDevice, struct synthhid_input_report *InputReport)
 417 {
 418         struct mousevsc_drv_obj *inputDriver;
 419
 420         if (!InputDevice->bInitializeComplete) {
 421                 pr_info("Initialization incomplete...ignoring InputReport msg");
 422                 return;
 423         }
 424
 425         inputDriver = (struct mousevsc_drv_obj *)InputDevice->Device->drv;
 426
 427         inputreport_callback(InputDevice->Device,
 428                              InputReport->buffer,
 429                              InputReport->header.size);
 430 }
 431
 432 static void MousevscOnReceive(struct hv_device *Device, struct vmpacket_descriptor *Packet)
 433 {
 434         struct pipe_prt_msg *pipeMsg;
 435         struct synthhid_msg *hidMsg;
 436         struct mousevsc_dev *inputDevice;
 437
 438         inputDevice = MustGetInputDevice(Device);
 439         if (!inputDevice) {
 440                 pr_err("unable to get input device...device being destroyed?");
 441                 return;
 442         }
 443
 444         pipeMsg = (struct pipe_prt_msg *)((unsigned long)Packet + (Packet->offset8 << 3));
 445
 446         if (pipeMsg->type != PipeMessageData) {
 447                 pr_err("unknown pipe msg type - type %d len %d",
 448                            pipeMsg->type, pipeMsg->size);
 449                 PutInputDevice(Device);
 450                 return ;
 451         }
 452
 453         hidMsg = (struct synthhid_msg *)&pipeMsg->data[0];
 454
 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);
 462                 break;
 463
 464         case SynthHidInitialDeviceInfo:
 465                 WARN_ON(pipeMsg->size >= sizeof(struct hv_input_dev_info));
 466
 467                 /*
 468                  * Parse out the device info into device attr,
 469                  * hid desc and report desc
 470                  */
 471                 MousevscOnReceiveDeviceInfo(inputDevice,
 472                                             (struct synthhid_device_info *)&pipeMsg->data[0]);
 473                 break;
 474         case SynthHidInputReport:
 475                 MousevscOnReceiveInputReport(inputDevice,
 476                                              (struct synthhid_input_report *)&pipeMsg->data[0]);
 477
 478                 break;
 479         default:
 480                 pr_err("unsupported hid msg type - type %d len %d",
 481                        hidMsg->header.type, hidMsg->header.size);
 482                 break;
 483         }
 484
 485         PutInputDevice(Device);
 486 }
 487
 488 static void MousevscOnChannelCallback(void *Context)
 489 {
 490         const int packetSize = 0x100;
 491         int ret = 0;
 492         struct hv_device *device = (struct hv_device *)Context;
 493         struct mousevsc_dev *inputDevice;
 494
 495         u32 bytesRecvd;
 496         u64 requestId;
 497         unsigned char packet[packetSize];
 498         struct vmpacket_descriptor *desc;
 499         unsigned char   *buffer = packet;
 500         int     bufferlen = packetSize;
 501
 502         inputDevice = MustGetInputDevice(device);
 503
 504         if (!inputDevice) {
 505                 pr_err("unable to get input device...device being destroyed?");
 506                 return;
 507         }
 508
 509         do {
 510                 ret = vmbus_recvpacket_raw(device->channel, buffer, bufferlen, &bytesRecvd, &requestId);
 511
 512                 if (ret == 0) {
 513                         if (bytesRecvd > 0) {
 514                                 desc = (struct vmpacket_descriptor *)buffer;
 515
 516                                 switch (desc->type) {
 517                                         case VM_PKT_COMP:
 518                                                 MousevscOnSendCompletion(device,
 519                                                                          desc);
 520                                                 break;
 521
 522                                         case VM_PKT_DATA_INBAND:
 523                                                 MousevscOnReceive(device, desc);
 524                                                 break;
 525
 526                                         default:
 527                                                 pr_err("unhandled packet type %d, tid %llx len %d\n",
 528                                                            desc->type,
 529                                                            requestId,
 530                                                            bytesRecvd);
 531                                                 break;
 532                                 }
 533
 534                                 /* reset */
 535                                 if (bufferlen > packetSize) {
 536                                         kfree(buffer);
 537
 538                                         buffer = packet;
 539                                         bufferlen = packetSize;
 540                                 }
 541                         } else {
 542                                 /*
 543                                  * pr_debug("nothing else to read...");
 544                                  * reset
 545                                  */
 546                                 if (bufferlen > packetSize) {
 547                                         kfree(buffer);
 548
 549                                         buffer = packet;
 550                                         bufferlen = packetSize;
 551                                 }
 552                                 break;
 553                         }
 554                 } else if (ret == -2) {
 555                         /* Handle large packet */
 556                         bufferlen = bytesRecvd;
 557                         buffer = kzalloc(bytesRecvd, GFP_KERNEL);
 558
 559                         if (buffer == NULL) {
 560                                 buffer = packet;
 561                                 bufferlen = packetSize;
 562
 563                                 /* Try again next time around */
 564                                 pr_err("unable to allocate buffer of size %d!",
 565                                        bytesRecvd);
 566                                 break;
 567                         }
 568                 }
 569         } while (1);
 570
 571         PutInputDevice(device);
 572
 573         return;
 574 }
 575
 576 static int MousevscConnectToVsp(struct hv_device *Device)
 577 {
 578         int ret = 0;
 579         struct mousevsc_dev *inputDevice;
 580         struct mousevsc_prt_msg *request;
 581         struct mousevsc_prt_msg *response;
 582
 583         inputDevice = GetInputDevice(Device);
 584
 585         if (!inputDevice) {
 586                 pr_err("unable to get input device...device being destroyed?");
 587                 return -1;
 588         }
 589
 590         init_waitqueue_head(&inputDevice->ProtocolWaitEvent);
 591         init_waitqueue_head(&inputDevice->DeviceInfoWaitEvent);
 592
 593         request = &inputDevice->ProtocolReq;
 594
 595         /*
 596          * Now, initiate the vsc/vsp initialization protocol on the open channel
 597          */
 598         memset(request, sizeof(struct mousevsc_prt_msg), 0);
 599
 600         request->type = PipeMessageData;
 601         request->size = sizeof(struct synthhid_protocol_request);
 602
 603         request->request.header.type = SynthHidProtocolRequest;
 604         request->request.header.size = sizeof(unsigned long);
 605         request->request.version_requested.version = SYNTHHID_INPUT_VERSION;
 606
 607         pr_info("synthhid protocol request...");
 608
 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,
 614                                         VM_PKT_DATA_INBAND,
 615                                         VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 616         if (ret != 0) {
 617                 pr_err("unable to send synthhid protocol request.");
 618                 goto Cleanup;
 619         }
 620
 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) {
 624                 ret = -ETIMEDOUT;
 625                 goto Cleanup;
 626         }
 627
 628         response = &inputDevice->ProtocolResp;
 629
 630         if (!response->response.approved) {
 631                 pr_err("synthhid protocol request failed (version %d)",
 632                        SYNTHHID_INPUT_VERSION);
 633                 ret = -1;
 634                 goto Cleanup;
 635         }
 636
 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) {
 640                 ret = -ETIMEDOUT;
 641                 goto Cleanup;
 642         }
 643
 644         /*
 645          * We should have gotten the device attr, hid desc and report
 646          * desc at this point
 647          */
 648         if (!inputDevice->DeviceInfoStatus)
 649                 pr_info("**** input channel up and running!! ****");
 650         else
 651                 ret = -1;
 652
 653 Cleanup:
 654         PutInputDevice(Device);
 655
 656         return ret;
 657 }
 658
 659 static int MousevscOnDeviceAdd(struct hv_device *Device, void *AdditionalInfo)
 660 {
 661         int ret = 0;
 662         struct mousevsc_dev *inputDevice;
 663         struct mousevsc_drv_obj *inputDriver;
 664         struct hv_input_dev_info dev_info;
 665
 666         inputDevice = AllocInputDevice(Device);
 667
 668         if (!inputDevice) {
 669                 ret = -1;
 670                 goto Cleanup;
 671         }
 672
 673         inputDevice->bInitializeComplete = false;
 674
 675         /* Open the channel */
 676         ret = vmbus_open(Device->channel,
 677                 INPUTVSC_SEND_RING_BUFFER_SIZE,
 678                 INPUTVSC_RECV_RING_BUFFER_SIZE,
 679                 NULL,
 680                 0,
 681                 MousevscOnChannelCallback,
 682                 Device
 683                 );
 684
 685         if (ret != 0) {
 686                 pr_err("unable to open channel: %d", ret);
 687                 FreeInputDevice(inputDevice);
 688                 return -1;
 689         }
 690
 691         pr_info("InputVsc channel open: %d", ret);
 692
 693         ret = MousevscConnectToVsp(Device);
 694
 695         if (ret != 0) {
 696                 pr_err("unable to connect channel: %d", ret);
 697
 698                 vmbus_close(Device->channel);
 699                 FreeInputDevice(inputDevice);
 700                 return ret;
 701         }
 702
 703         inputDriver = (struct mousevsc_drv_obj *)inputDevice->Device->drv;
 704
 705         dev_info.vendor = inputDevice->hid_dev_info.vendor;
 706         dev_info.product = inputDevice->hid_dev_info.product;
 707         dev_info.version = inputDevice->hid_dev_info.version;
 708         strcpy(dev_info.name, "Microsoft Vmbus HID-compliant Mouse");
 709
 710         /* Send the device info back up */
 711         deviceinfo_callback(Device, &dev_info);
 712
 713         /* Send the report desc back up */
 714         /* workaround SA-167 */
 715         if (inputDevice->ReportDesc[14] == 0x25)
 716                 inputDevice->ReportDesc[14] = 0x29;
 717
 718         reportdesc_callback(Device, inputDevice->ReportDesc,
 719                             inputDevice->ReportDescSize);
 720
 721         inputDevice->bInitializeComplete = true;
 722
 723 Cleanup:
 724         return ret;
 725 }
 726
 727 static int MousevscOnDeviceRemove(struct hv_device *Device)
 728 {
 729         struct mousevsc_dev *inputDevice;
 730         int ret = 0;
 731
 732         pr_info("disabling input device (%p)...",
 733                     Device->ext);
 734
 735         inputDevice = ReleaseInputDevice(Device);
 736
 737
 738         /*
 739          * At this point, all outbound traffic should be disable. We only
 740          * allow inbound traffic (responses) to proceed
 741          *
 742          * so that outstanding requests can be completed.
 743          */
 744         while (inputDevice->NumOutstandingRequests) {
 745                 pr_info("waiting for %d requests to complete...", inputDevice->NumOutstandingRequests);
 746
 747                 udelay(100);
 748         }
 749
 750         pr_info("removing input device (%p)...", Device->ext);
 751
 752         inputDevice = FinalReleaseInputDevice(Device);
 753
 754         pr_info("input device (%p) safe to remove", inputDevice);
 755
 756         /* Close the channel */
 757         vmbus_close(Device->channel);
 758
 759         FreeInputDevice(inputDevice);
 760
 761         return ret;
 762 }
 763
 764 static void MousevscOnCleanup(struct hv_driver *drv)
 765 {
 766 }
 767
 768 /*
 769  * Data types
 770  */
 771 struct input_device_context {
 772         struct hv_device        *device_ctx;
 773         struct hid_device       *hid_device;
 774         struct hv_input_dev_info device_info;
 775         int                     connected;
 776 };
 777
 778
 779 static struct  mousevsc_drv_obj g_mousevsc_drv;
 780
 781 static void deviceinfo_callback(struct hv_device *dev, struct hv_input_dev_info *info)
 782 {
 783         struct input_device_context *input_device_ctx =
 784                 dev_get_drvdata(&dev->device);
 785
 786         memcpy(&input_device_ctx->device_info, info,
 787                sizeof(struct hv_input_dev_info));
 788
 789         DPRINT_INFO(INPUTVSC_DRV, "%s", __func__);
 790 }
 791
 792 static void inputreport_callback(struct hv_device *dev, void *packet, u32 len)
 793 {
 794         int ret = 0;
 795
 796         struct input_device_context *input_dev_ctx =
 797                 dev_get_drvdata(&dev->device);
 798
 799         ret = hid_input_report(input_dev_ctx->hid_device,
 800                               HID_INPUT_REPORT, packet, len, 1);
 801
 802         DPRINT_DBG(INPUTVSC_DRV, "hid_input_report (ret %d)", ret);
 803 }
 804
 805 static int mousevsc_hid_open(struct hid_device *hid)
 806 {
 807         return 0;
 808 }
 809
 810 static void mousevsc_hid_close(struct hid_device *hid)
 811 {
 812 }
 813
 814 static int mousevsc_probe(struct device *device)
 815 {
 816         int ret = 0;
 817
 818         struct hv_driver *drv =
 819                 drv_to_hv_drv(device->driver);
 820         struct mousevsc_drv_obj *mousevsc_drv_obj = drv->priv;
 821
 822         struct hv_device *device_obj = device_to_hv_device(device);
 823         struct input_device_context *input_dev_ctx;
 824
 825         input_dev_ctx = kmalloc(sizeof(struct input_device_context),
 826                                 GFP_KERNEL);
 827
 828         dev_set_drvdata(device, input_dev_ctx);
 829
 830         /* Call to the vsc driver to add the device */
 831         ret = mousevsc_drv_obj->Base.dev_add(device_obj, NULL);
 832
 833         if (ret != 0) {
 834                 DPRINT_ERR(INPUTVSC_DRV, "unable to add input vsc device");
 835
 836                 return -1;
 837         }
 838
 839         return 0;
 840 }
 841
 842 static int mousevsc_remove(struct device *device)
 843 {
 844         int ret = 0;
 845
 846         struct hv_driver *drv =
 847                 drv_to_hv_drv(device->driver);
 848         struct mousevsc_drv_obj *mousevsc_drv_obj = drv->priv;
 849
 850         struct hv_device *device_obj = device_to_hv_device(device);
 851         struct input_device_context *input_dev_ctx;
 852
 853         input_dev_ctx = kmalloc(sizeof(struct input_device_context),
 854                                 GFP_KERNEL);
 855
 856         dev_set_drvdata(device, input_dev_ctx);
 857
 858         if (input_dev_ctx->connected) {
 859                 hidinput_disconnect(input_dev_ctx->hid_device);
 860                 input_dev_ctx->connected = 0;
 861         }
 862
 863         if (!mousevsc_drv_obj->Base.dev_rm)
 864                 return -1;
 865
 866         /*
 867          * Call to the vsc driver to let it know that the device
 868          * is being removed
 869          */
 870         ret = mousevsc_drv_obj->Base.dev_rm(device_obj);
 871
 872         if (ret != 0) {
 873                 DPRINT_ERR(INPUTVSC_DRV,
 874                            "unable to remove vsc device (ret %d)", ret);
 875         }
 876
 877         kfree(input_dev_ctx);
 878
 879         return ret;
 880 }
 881
 882 static void reportdesc_callback(struct hv_device *dev, void *packet, u32 len)
 883 {
 884         struct input_device_context *input_device_ctx =
 885                 dev_get_drvdata(&dev->device);
 886         struct hid_device *hid_dev;
 887
 888         /* hid_debug = -1; */
 889         hid_dev = kmalloc(sizeof(struct hid_device), GFP_KERNEL);
 890
 891         if (hid_parse_report(hid_dev, packet, len)) {
 892                 DPRINT_INFO(INPUTVSC_DRV, "Unable to call hd_parse_report");
 893                 return;
 894         }
 895
 896         if (hid_dev) {
 897                 DPRINT_INFO(INPUTVSC_DRV, "hid_device created");
 898
 899                 hid_dev->ll_driver->open  = mousevsc_hid_open;
 900                 hid_dev->ll_driver->close = mousevsc_hid_close;
 901
 902                 hid_dev->bus = BUS_VIRTUAL;
 903                 hid_dev->vendor = input_device_ctx->device_info.vendor;
 904                 hid_dev->product = input_device_ctx->device_info.product;
 905                 hid_dev->version = input_device_ctx->device_info.version;
 906                 hid_dev->dev = dev->device;
 907
 908                 sprintf(hid_dev->name, "%s",
 909                         input_device_ctx->device_info.name);
 910
 911                 /*
 912                  * HJ Do we want to call it with a 0
 913                  */
 914                 if (!hidinput_connect(hid_dev, 0)) {
 915                         hid_dev->claimed |= HID_CLAIMED_INPUT;
 916
 917                         input_device_ctx->connected = 1;
 918
 919                         DPRINT_INFO(INPUTVSC_DRV,
 920                                      "HID device claimed by input\n");
 921                 }
 922
 923                 if (!hid_dev->claimed) {
 924                         DPRINT_ERR(INPUTVSC_DRV,
 925                                     "HID device not claimed by "
 926                                     "input or hiddev\n");
 927                 }
 928
 929                 input_device_ctx->hid_device = hid_dev;
 930         }
 931
 932         kfree(hid_dev);
 933 }
 934
 935 static int mousevsc_drv_exit_cb(struct device *dev, void *data)
 936 {
 937         struct device **curr = (struct device **)data;
 938         *curr = dev;
 939
 940         return 1;
 941 }
 942
 943 static void mousevsc_drv_exit(void)
 944 {
 945         struct mousevsc_drv_obj *mousevsc_drv_obj = &g_mousevsc_drv;
 946         struct hv_driver *drv = &g_mousevsc_drv.Base;
 947         int ret;
 948
 949         struct device *current_dev = NULL;
 950
 951         while (1) {
 952                 current_dev = NULL;
 953
 954                 /* Get the device */
 955                 ret = driver_for_each_device(&drv->driver, NULL,
 956                                              (void *)&current_dev,
 957                                              mousevsc_drv_exit_cb);
 958                 if (ret)
 959                         printk(KERN_ERR "Can't find mouse device!\n");
 960
 961                 if (current_dev == NULL)
 962                         break;
 963
 964                 /* Initiate removal from the top-down */
 965                 device_unregister(current_dev);
 966         }
 967
 968         if (mousevsc_drv_obj->Base.cleanup)
 969                 mousevsc_drv_obj->Base.cleanup(&mousevsc_drv_obj->Base);
 970
 971         vmbus_child_driver_unregister(&drv->driver);
 972
 973         return;
 974 }
 975
 976 static int mouse_vsc_initialize(struct hv_driver *Driver)
 977 {
 978         struct mousevsc_drv_obj *inputDriver =
 979                 (struct mousevsc_drv_obj *)Driver;
 980         int ret = 0;
 981
 982         Driver->name = driver_name;
 983         memcpy(&Driver->dev_type, &mouse_guid,
 984                sizeof(struct hv_guid));
 985
 986         /* Setup the dispatch table */
 987         inputDriver->Base.dev_add = MousevscOnDeviceAdd;
 988         inputDriver->Base.dev_rm = MousevscOnDeviceRemove;
 989         inputDriver->Base.cleanup = MousevscOnCleanup;
 990
 991         return ret;
 992 }
 993
 994
 995 static int __init mousevsc_init(void)
 996 {
 997         struct mousevsc_drv_obj *input_drv_obj = &g_mousevsc_drv;
 998         struct hv_driver *drv = &g_mousevsc_drv.Base;
 999
1000         DPRINT_INFO(INPUTVSC_DRV, "Hyper-V Mouse driver initializing.");
1001
1002         /* Callback to client driver to complete the initialization */
1003         mouse_vsc_initialize(&input_drv_obj->Base);
1004
1005         drv->driver.name = input_drv_obj->Base.name;
1006         drv->priv = input_drv_obj;
1007
1008         drv->driver.probe = mousevsc_probe;
1009         drv->driver.remove = mousevsc_remove;
1010
1011         /* The driver belongs to vmbus */
1012         vmbus_child_driver_register(&drv->driver);
1013
1014         return 0;
1015 }
1016
1017 static void __exit mousevsc_exit(void)
1018 {
1019         mousevsc_drv_exit();
1020 }
1021
1022 /*
1023  * We don't want to automatically load this driver just yet, it's quite
1024  * broken.  It's safe if you want to load it yourself manually, but
1025  * don't inflict it on unsuspecting users, that's just mean.
1026  */
1027 #if 0
1028
1029 /*
1030  * We use a PCI table to determine if we should autoload this driver  This is
1031  * needed by distro tools to determine if the hyperv drivers should be
1032  * installed and/or configured.  We don't do anything else with the table, but
1033  * it needs to be present.
1034  */
1035 const static struct pci_device_id microsoft_hv_pci_table[] = {
1036         { PCI_DEVICE(0x1414, 0x5353) }, /* VGA compatible controller */
1037         { 0 }
1038 };
1039 MODULE_DEVICE_TABLE(pci, microsoft_hv_pci_table);
1040 #endif
1041
1042 MODULE_LICENSE("GPL");
1043 MODULE_VERSION(HV_DRV_VERSION);
1044 module_init(mousevsc_init);
1045 module_exit(mousevsc_exit);
1046