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/delay.h>
  18 #include <linux/device.h>
  19 #include <linux/workqueue.h>
  20 #include <linux/sched.h>
  21 #include <linux/wait.h>
  22 #include <linux/input.h>
  23 #include <linux/hid.h>
  24 #include <linux/hiddev.h>
  25
  26 #include "hyperv.h"
  27
  28
  29 /*
  30  * Data types
  31  */
  32 struct hv_input_dev_info {
  33         unsigned short vendor;
  34         unsigned short product;
  35         unsigned short version;
  36         char name[128];
  37 };
  38
  39 /* The maximum size of a synthetic input message. */
  40 #define SYNTHHID_MAX_INPUT_REPORT_SIZE 16
  41
  42 /*
  43  * Current version
  44  *
  45  * History:
  46  * Beta, RC < 2008/1/22        1,0
  47  * RC > 2008/1/22              2,0
  48  */
  49 #define SYNTHHID_INPUT_VERSION_MAJOR    2
  50 #define SYNTHHID_INPUT_VERSION_MINOR    0
  51 #define SYNTHHID_INPUT_VERSION          (SYNTHHID_INPUT_VERSION_MINOR | \
  52                                          (SYNTHHID_INPUT_VERSION_MAJOR << 16))
  53
  54
  55 #pragma pack(push, 1)
  56 /*
  57  * Message types in the synthetic input protocol
  58  */
  59 enum synthhid_msg_type {
  60         SynthHidProtocolRequest,
  61         SynthHidProtocolResponse,
  62         SynthHidInitialDeviceInfo,
  63         SynthHidInitialDeviceInfoAck,
  64         SynthHidInputReport,
  65         SynthHidMax
  66 };
  67
  68 /*
  69  * Basic message structures.
  70  */
  71 struct synthhid_msg_hdr {
  72         enum synthhid_msg_type type;
  73         u32 size;
  74 };
  75
  76 struct synthhid_msg {
  77         struct synthhid_msg_hdr header;
  78         char data[1]; /* Enclosed message */
  79 };
  80
  81 union synthhid_version {
  82         struct {
  83                 u16 minor_version;
  84                 u16 major_version;
  85         };
  86         u32 version;
  87 };
  88
  89 /*
  90  * Protocol messages
  91  */
  92 struct synthhid_protocol_request {
  93         struct synthhid_msg_hdr header;
  94         union synthhid_version version_requested;
  95 };
  96
  97 struct synthhid_protocol_response {
  98         struct synthhid_msg_hdr header;
  99         union synthhid_version version_requested;
 100         unsigned char approved;
 101 };
 102
 103 struct synthhid_device_info {
 104         struct synthhid_msg_hdr header;
 105         struct hv_input_dev_info hid_dev_info;
 106         struct hid_descriptor hid_descriptor;
 107 };
 108
 109 struct synthhid_device_info_ack {
 110         struct synthhid_msg_hdr header;
 111         unsigned char reserved;
 112 };
 113
 114 struct synthhid_input_report {
 115         struct synthhid_msg_hdr header;
 116         char buffer[1];
 117 };
 118
 119 #pragma pack(pop)
 120
 121 #define INPUTVSC_SEND_RING_BUFFER_SIZE          (10*PAGE_SIZE)
 122 #define INPUTVSC_RECV_RING_BUFFER_SIZE          (10*PAGE_SIZE)
 123
 124 #define NBITS(x) (((x)/BITS_PER_LONG)+1)
 125
 126 enum pipe_prot_msg_type {
 127         PipeMessageInvalid = 0,
 128         PipeMessageData,
 129         PipeMessageMaximum
 130 };
 131
 132
 133 struct pipe_prt_msg {
 134         enum pipe_prot_msg_type type;
 135         u32 size;
 136         char data[1];
 137 };
 138
 139 /*
 140  * Data types
 141  */
 142 struct  mousevsc_prt_msg {
 143         enum pipe_prot_msg_type type;
 144         u32 size;
 145         union {
 146                 struct synthhid_protocol_request request;
 147                 struct synthhid_protocol_response response;
 148                 struct synthhid_device_info_ack ack;
 149         };
 150 };
 151
 152 /*
 153  * Represents an mousevsc device
 154  */
 155 struct mousevsc_dev {
 156         struct hv_device        *device;
 157         /* 0 indicates the device is being destroyed */
 158         atomic_t                ref_count;
 159         int                     num_outstanding_req;
 160         unsigned char           init_complete;
 161         struct mousevsc_prt_msg protocol_req;
 162         struct mousevsc_prt_msg protocol_resp;
 163         /* Synchronize the request/response if needed */
 164         wait_queue_head_t       protocol_wait_event;
 165         wait_queue_head_t       dev_info_wait_event;
 166         int                     protocol_wait_condition;
 167         int                     device_wait_condition;
 168         int                     dev_info_status;
 169
 170         struct hid_descriptor   *hid_desc;
 171         unsigned char           *report_desc;
 172         u32                     report_desc_size;
 173         struct hv_input_dev_info hid_dev_info;
 174 };
 175
 176 struct input_device_context {
 177         struct hv_device        *device_ctx;
 178         struct hid_device       *hid_device;
 179         struct hv_input_dev_info device_info;
 180         int                     connected;
 181 };
 182
 183 static void inputreport_callback(struct hv_device *dev, void *packet, u32 len);
 184 static void reportdesc_callback(struct hv_device *dev, void *packet, u32 len);
 185
 186 static struct mousevsc_dev *alloc_input_device(struct hv_device *device)
 187 {
 188         struct mousevsc_dev *input_dev;
 189
 190         input_dev = kzalloc(sizeof(struct mousevsc_dev), GFP_KERNEL);
 191
 192         if (!input_dev)
 193                 return NULL;
 194
 195         /*
 196          * Set to 2 to allow both inbound and outbound traffics
 197          * (ie get_input_device() and must_get_input_device()) to proceed.
 198          */
 199         atomic_cmpxchg(&input_dev->ref_count, 0, 2);
 200
 201         input_dev->device = device;
 202         device->ext = input_dev;
 203
 204         return input_dev;
 205 }
 206
 207 static void free_input_device(struct mousevsc_dev *device)
 208 {
 209         WARN_ON(atomic_read(&device->ref_count) == 0);
 210         kfree(device);
 211 }
 212
 213 /*
 214  * Get the inputdevice object if exists and its refcount > 1
 215  */
 216 static struct mousevsc_dev *get_input_device(struct hv_device *device)
 217 {
 218         struct mousevsc_dev *input_dev;
 219
 220         input_dev = (struct mousevsc_dev *)device->ext;
 221
 222 /*
 223  *      FIXME
 224  *      This sure isn't a valid thing to print for debugging, no matter
 225  *      what the intention is...
 226  *
 227  *      printk(KERN_ERR "-------------------------> REFCOUNT = %d",
 228  *             input_dev->ref_count);
 229  */
 230
 231         if (input_dev && atomic_read(&input_dev->ref_count) > 1)
 232                 atomic_inc(&input_dev->ref_count);
 233         else
 234                 input_dev = NULL;
 235
 236         return input_dev;
 237 }
 238
 239 /*
 240  * Get the inputdevice object iff exists and its refcount > 0
 241  */
 242 static struct mousevsc_dev *must_get_input_device(struct hv_device *device)
 243 {
 244         struct mousevsc_dev *input_dev;
 245
 246         input_dev = (struct mousevsc_dev *)device->ext;
 247
 248         if (input_dev && atomic_read(&input_dev->ref_count))
 249                 atomic_inc(&input_dev->ref_count);
 250         else
 251                 input_dev = NULL;
 252
 253         return input_dev;
 254 }
 255
 256 static void put_input_device(struct hv_device *device)
 257 {
 258         struct mousevsc_dev *input_dev;
 259
 260         input_dev = (struct mousevsc_dev *)device->ext;
 261
 262         atomic_dec(&input_dev->ref_count);
 263 }
 264
 265 /*
 266  * Drop ref count to 1 to effectively disable get_input_device()
 267  */
 268 static struct mousevsc_dev *release_input_device(struct hv_device *device)
 269 {
 270         struct mousevsc_dev *input_dev;
 271
 272         input_dev = (struct mousevsc_dev *)device->ext;
 273
 274         /* Busy wait until the ref drop to 2, then set it to 1  */
 275         while (atomic_cmpxchg(&input_dev->ref_count, 2, 1) != 2)
 276                 udelay(100);
 277
 278         return input_dev;
 279 }
 280
 281 /*
 282  * Drop ref count to 0. No one can use input_device object.
 283  */
 284 static struct mousevsc_dev *final_release_input_device(struct hv_device *device)
 285 {
 286         struct mousevsc_dev *input_dev;
 287
 288         input_dev = (struct mousevsc_dev *)device->ext;
 289
 290         /* Busy wait until the ref drop to 1, then set it to 0  */
 291         while (atomic_cmpxchg(&input_dev->ref_count, 1, 0) != 1)
 292                 udelay(100);
 293
 294         device->ext = NULL;
 295         return input_dev;
 296 }
 297
 298 static void mousevsc_on_send_completion(struct hv_device *device,
 299                                         struct vmpacket_descriptor *packet)
 300 {
 301         struct mousevsc_dev *input_dev;
 302         void *request;
 303
 304         input_dev = must_get_input_device(device);
 305         if (!input_dev) {
 306                 pr_err("unable to get input device...device being destroyed?");
 307                 return;
 308         }
 309
 310         request = (void *)(unsigned long)packet->trans_id;
 311
 312         if (request == &input_dev->protocol_req) {
 313                 /* FIXME */
 314                 /* Shouldn't we be doing something here? */
 315         }
 316
 317         put_input_device(device);
 318 }
 319
 320 static void mousevsc_on_receive_device_info(struct mousevsc_dev *input_device,
 321                                 struct synthhid_device_info *device_info)
 322 {
 323         int ret = 0;
 324         struct hid_descriptor *desc;
 325         struct mousevsc_prt_msg ack;
 326
 327         /* Assume success for now */
 328         input_device->dev_info_status = 0;
 329
 330         /* Save the device attr */
 331         memcpy(&input_device->hid_dev_info, &device_info->hid_dev_info,
 332                 sizeof(struct hv_input_dev_info));
 333
 334         /* Save the hid desc */
 335         desc = &device_info->hid_descriptor;
 336         WARN_ON(desc->bLength > 0);
 337
 338         input_device->hid_desc = kzalloc(desc->bLength, GFP_KERNEL);
 339
 340         if (!input_device->hid_desc) {
 341                 pr_err("unable to allocate hid descriptor - size %d", desc->bLength);
 342                 goto cleanup;
 343         }
 344
 345         memcpy(input_device->hid_desc, desc, desc->bLength);
 346
 347         /* Save the report desc */
 348         input_device->report_desc_size = desc->desc[0].wDescriptorLength;
 349         input_device->report_desc = kzalloc(input_device->report_desc_size,
 350                                           GFP_KERNEL);
 351
 352         if (!input_device->report_desc) {
 353                 pr_err("unable to allocate report descriptor - size %d",
 354                            input_device->report_desc_size);
 355                 goto cleanup;
 356         }
 357
 358         memcpy(input_device->report_desc,
 359                ((unsigned char *)desc) + desc->bLength,
 360                desc->desc[0].wDescriptorLength);
 361
 362         /* Send the ack */
 363         memset(&ack, 0, sizeof(struct mousevsc_prt_msg));
 364
 365         ack.type = PipeMessageData;
 366         ack.size = sizeof(struct synthhid_device_info_ack);
 367
 368         ack.ack.header.type = SynthHidInitialDeviceInfoAck;
 369         ack.ack.header.size = 1;
 370         ack.ack.reserved = 0;
 371
 372         ret = vmbus_sendpacket(input_device->device->channel,
 373                         &ack,
 374                         sizeof(struct pipe_prt_msg) - sizeof(unsigned char) +
 375                         sizeof(struct synthhid_device_info_ack),
 376                         (unsigned long)&ack,
 377                         VM_PKT_DATA_INBAND,
 378                         VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 379         if (ret != 0) {
 380                 pr_err("unable to send synthhid device info ack - ret %d",
 381                            ret);
 382                 goto cleanup;
 383         }
 384
 385         input_device->device_wait_condition = 1;
 386         wake_up(&input_device->dev_info_wait_event);
 387
 388         return;
 389
 390 cleanup:
 391         kfree(input_device->hid_desc);
 392         input_device->hid_desc = NULL;
 393
 394         kfree(input_device->report_desc);
 395         input_device->report_desc = NULL;
 396
 397         input_device->dev_info_status = -1;
 398         input_device->device_wait_condition = 1;
 399         wake_up(&input_device->dev_info_wait_event);
 400 }
 401
 402 static void mousevsc_on_receive_input_report(struct mousevsc_dev *input_device,
 403                                 struct synthhid_input_report *input_report)
 404 {
 405         struct hv_driver *input_drv;
 406
 407         if (!input_device->init_complete) {
 408                 pr_info("Initialization incomplete...ignoring input_report msg");
 409                 return;
 410         }
 411
 412         input_drv = drv_to_hv_drv(input_device->device->device.driver);
 413
 414         inputreport_callback(input_device->device,
 415                              input_report->buffer,
 416                              input_report->header.size);
 417 }
 418
 419 static void mousevsc_on_receive(struct hv_device *device,
 420                                 struct vmpacket_descriptor *packet)
 421 {
 422         struct pipe_prt_msg *pipe_msg;
 423         struct synthhid_msg *hid_msg;
 424         struct mousevsc_dev *input_dev;
 425
 426         input_dev = must_get_input_device(device);
 427         if (!input_dev) {
 428                 pr_err("unable to get input device...device being destroyed?");
 429                 return;
 430         }
 431
 432         pipe_msg = (struct pipe_prt_msg *)((unsigned long)packet +
 433                                                 (packet->offset8 << 3));
 434
 435         if (pipe_msg->type != PipeMessageData) {
 436                 pr_err("unknown pipe msg type - type %d len %d",
 437                            pipe_msg->type, pipe_msg->size);
 438                 put_input_device(device);
 439                 return ;
 440         }
 441
 442         hid_msg = (struct synthhid_msg *)&pipe_msg->data[0];
 443
 444         switch (hid_msg->header.type) {
 445         case SynthHidProtocolResponse:
 446                 memcpy(&input_dev->protocol_resp, pipe_msg,
 447                        pipe_msg->size + sizeof(struct pipe_prt_msg) -
 448                        sizeof(unsigned char));
 449                 input_dev->protocol_wait_condition = 1;
 450                 wake_up(&input_dev->protocol_wait_event);
 451                 break;
 452
 453         case SynthHidInitialDeviceInfo:
 454                 WARN_ON(pipe_msg->size >= sizeof(struct hv_input_dev_info));
 455
 456                 /*
 457                  * Parse out the device info into device attr,
 458                  * hid desc and report desc
 459                  */
 460                 mousevsc_on_receive_device_info(input_dev,
 461                         (struct synthhid_device_info *)&pipe_msg->data[0]);
 462                 break;
 463         case SynthHidInputReport:
 464                 mousevsc_on_receive_input_report(input_dev,
 465                         (struct synthhid_input_report *)&pipe_msg->data[0]);
 466
 467                 break;
 468         default:
 469                 pr_err("unsupported hid msg type - type %d len %d",
 470                        hid_msg->header.type, hid_msg->header.size);
 471                 break;
 472         }
 473
 474         put_input_device(device);
 475 }
 476
 477 static void mousevsc_on_channel_callback(void *context)
 478 {
 479         const int packetSize = 0x100;
 480         int ret = 0;
 481         struct hv_device *device = (struct hv_device *)context;
 482         struct mousevsc_dev *input_dev;
 483
 484         u32 bytes_recvd;
 485         u64 req_id;
 486         unsigned char packet[0x100];
 487         struct vmpacket_descriptor *desc;
 488         unsigned char   *buffer = packet;
 489         int     bufferlen = packetSize;
 490
 491         input_dev = must_get_input_device(device);
 492
 493         if (!input_dev) {
 494                 pr_err("unable to get input device...device being destroyed?");
 495                 return;
 496         }
 497
 498         do {
 499                 ret = vmbus_recvpacket_raw(device->channel, buffer,
 500                                         bufferlen, &bytes_recvd, &req_id);
 501
 502                 if (ret == 0) {
 503                         if (bytes_recvd > 0) {
 504                                 desc = (struct vmpacket_descriptor *)buffer;
 505
 506                                 switch (desc->type) {
 507                                 case VM_PKT_COMP:
 508                                         mousevsc_on_send_completion(
 509                                                 device, desc);
 510                                         break;
 511
 512                                 case VM_PKT_DATA_INBAND:
 513                                         mousevsc_on_receive(
 514                                                 device, desc);
 515                                         break;
 516
 517                                 default:
 518                                         pr_err("unhandled packet type %d, tid %llx len %d\n",
 519                                                    desc->type,
 520                                                    req_id,
 521                                                    bytes_recvd);
 522                                         break;
 523                                 }
 524
 525                                 /* reset */
 526                                 if (bufferlen > packetSize) {
 527                                         kfree(buffer);
 528
 529                                         buffer = packet;
 530                                         bufferlen = packetSize;
 531                                 }
 532                         } else {
 533                                 /*
 534                                  * pr_debug("nothing else to read...");
 535                                  * reset
 536                                  */
 537                                 if (bufferlen > packetSize) {
 538                                         kfree(buffer);
 539
 540                                         buffer = packet;
 541                                         bufferlen = packetSize;
 542                                 }
 543                                 break;
 544                         }
 545                 } else if (ret == -ENOBUFS) {
 546                         /* Handle large packet */
 547                         bufferlen = bytes_recvd;
 548                         buffer = kzalloc(bytes_recvd, GFP_KERNEL);
 549
 550                         if (buffer == NULL) {
 551                                 buffer = packet;
 552                                 bufferlen = packetSize;
 553
 554                                 /* Try again next time around */
 555                                 pr_err("unable to allocate buffer of size %d!",
 556                                        bytes_recvd);
 557                                 break;
 558                         }
 559                 }
 560         } while (1);
 561
 562         put_input_device(device);
 563
 564         return;
 565 }
 566
 567 static int mousevsc_connect_to_vsp(struct hv_device *device)
 568 {
 569         int ret = 0;
 570         struct mousevsc_dev *input_dev;
 571         struct mousevsc_prt_msg *request;
 572         struct mousevsc_prt_msg *response;
 573
 574         input_dev = get_input_device(device);
 575
 576         if (!input_dev) {
 577                 pr_err("unable to get input device...device being destroyed?");
 578                 return -1;
 579         }
 580
 581         init_waitqueue_head(&input_dev->protocol_wait_event);
 582         init_waitqueue_head(&input_dev->dev_info_wait_event);
 583
 584         request = &input_dev->protocol_req;
 585
 586         /*
 587          * Now, initiate the vsc/vsp initialization protocol on the open channel
 588          */
 589         memset(request, 0, sizeof(struct mousevsc_prt_msg));
 590
 591         request->type = PipeMessageData;
 592         request->size = sizeof(struct synthhid_protocol_request);
 593
 594         request->request.header.type = SynthHidProtocolRequest;
 595         request->request.header.size = sizeof(unsigned long);
 596         request->request.version_requested.version = SYNTHHID_INPUT_VERSION;
 597
 598         pr_info("synthhid protocol request...");
 599
 600         ret = vmbus_sendpacket(device->channel, request,
 601                                         sizeof(struct pipe_prt_msg) -
 602                                         sizeof(unsigned char) +
 603                                         sizeof(struct synthhid_protocol_request),
 604                                         (unsigned long)request,
 605                                         VM_PKT_DATA_INBAND,
 606                                         VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED);
 607         if (ret != 0) {
 608                 pr_err("unable to send synthhid protocol request.");
 609                 goto cleanup;
 610         }
 611
 612         input_dev->protocol_wait_condition = 0;
 613         wait_event_timeout(input_dev->protocol_wait_event,
 614                 input_dev->protocol_wait_condition, msecs_to_jiffies(1000));
 615         if (input_dev->protocol_wait_condition == 0) {
 616                 ret = -ETIMEDOUT;
 617                 goto cleanup;
 618         }
 619
 620         response = &input_dev->protocol_resp;
 621
 622         if (!response->response.approved) {
 623                 pr_err("synthhid protocol request failed (version %d)",
 624                        SYNTHHID_INPUT_VERSION);
 625                 ret = -1;
 626                 goto cleanup;
 627         }
 628
 629         input_dev->device_wait_condition = 0;
 630         wait_event_timeout(input_dev->dev_info_wait_event,
 631                 input_dev->device_wait_condition, msecs_to_jiffies(1000));
 632         if (input_dev->device_wait_condition == 0) {
 633                 ret = -ETIMEDOUT;
 634                 goto cleanup;
 635         }
 636
 637         /*
 638          * We should have gotten the device attr, hid desc and report
 639          * desc at this point
 640          */
 641         if (!input_dev->dev_info_status)
 642                 pr_info("**** input channel up and running!! ****");
 643         else
 644                 ret = -1;
 645
 646 cleanup:
 647         put_input_device(device);
 648
 649         return ret;
 650 }
 651
 652 static int mousevsc_on_device_add(struct hv_device *device,
 653                                         void *additional_info)
 654 {
 655         int ret = 0;
 656         struct mousevsc_dev *input_dev;
 657         struct hv_driver *input_drv;
 658         struct hv_input_dev_info dev_info;
 659         struct input_device_context *input_device_ctx;
 660
 661         input_dev = alloc_input_device(device);
 662
 663         if (!input_dev) {
 664                 ret = -1;
 665                 goto cleanup;
 666         }
 667
 668         input_dev->init_complete = false;
 669
 670         /* Open the channel */
 671         ret = vmbus_open(device->channel,
 672                 INPUTVSC_SEND_RING_BUFFER_SIZE,
 673                 INPUTVSC_RECV_RING_BUFFER_SIZE,
 674                 NULL,
 675                 0,
 676                 mousevsc_on_channel_callback,
 677                 device
 678                 );
 679
 680         if (ret != 0) {
 681                 pr_err("unable to open channel: %d", ret);
 682                 free_input_device(input_dev);
 683                 return -1;
 684         }
 685
 686         pr_info("InputVsc channel open: %d", ret);
 687
 688         ret = mousevsc_connect_to_vsp(device);
 689
 690         if (ret != 0) {
 691                 pr_err("unable to connect channel: %d", ret);
 692
 693                 vmbus_close(device->channel);
 694                 free_input_device(input_dev);
 695                 return ret;
 696         }
 697
 698         input_drv = drv_to_hv_drv(input_dev->device->device.driver);
 699
 700         dev_info.vendor = input_dev->hid_dev_info.vendor;
 701         dev_info.product = input_dev->hid_dev_info.product;
 702         dev_info.version = input_dev->hid_dev_info.version;
 703         strcpy(dev_info.name, "Microsoft Vmbus HID-compliant Mouse");
 704
 705         /* Send the device info back up */
 706         input_device_ctx = dev_get_drvdata(&device->device);
 707         memcpy(&input_device_ctx->device_info, &dev_info,
 708                sizeof(struct hv_input_dev_info));
 709
 710         /* Send the report desc back up */
 711         /* workaround SA-167 */
 712         if (input_dev->report_desc[14] == 0x25)
 713                 input_dev->report_desc[14] = 0x29;
 714
 715         reportdesc_callback(device, input_dev->report_desc,
 716                             input_dev->report_desc_size);
 717
 718         input_dev->init_complete = true;
 719
 720 cleanup:
 721         return ret;
 722 }
 723
 724 static int mousevsc_on_device_remove(struct hv_device *device)
 725 {
 726         struct mousevsc_dev *input_dev;
 727         int ret = 0;
 728
 729         pr_info("disabling input device (%p)...",
 730                     device->ext);
 731
 732         input_dev = release_input_device(device);
 733
 734
 735         /*
 736          * At this point, all outbound traffic should be disable. We only
 737          * allow inbound traffic (responses) to proceed
 738          *
 739          * so that outstanding requests can be completed.
 740          */
 741         while (input_dev->num_outstanding_req) {
 742                 pr_info("waiting for %d requests to complete...",
 743                         input_dev->num_outstanding_req);
 744
 745                 udelay(100);
 746         }
 747
 748         pr_info("removing input device (%p)...", device->ext);
 749
 750         input_dev = final_release_input_device(device);
 751
 752         pr_info("input device (%p) safe to remove", input_dev);
 753
 754         /* Close the channel */
 755         vmbus_close(device->channel);
 756
 757         free_input_device(input_dev);
 758
 759         return ret;
 760 }
 761
 762
 763 static void inputreport_callback(struct hv_device *dev, void *packet, u32 len)
 764 {
 765         int ret = 0;
 766
 767         struct input_device_context *input_dev_ctx =
 768                 dev_get_drvdata(&dev->device);
 769
 770         ret = hid_input_report(input_dev_ctx->hid_device,
 771                               HID_INPUT_REPORT, packet, len, 1);
 772
 773         DPRINT_DBG(INPUTVSC_DRV, "hid_input_report (ret %d)", ret);
 774 }
 775
 776 static int mousevsc_hid_open(struct hid_device *hid)
 777 {
 778         return 0;
 779 }
 780
 781 static void mousevsc_hid_close(struct hid_device *hid)
 782 {
 783 }
 784
 785 static int mousevsc_probe(struct hv_device *dev)
 786 {
 787         int ret = 0;
 788
 789         struct input_device_context *input_dev_ctx;
 790
 791         input_dev_ctx = kmalloc(sizeof(struct input_device_context),
 792                                 GFP_KERNEL);
 793
 794         dev_set_drvdata(&dev->device, input_dev_ctx);
 795
 796         /* Call to the vsc driver to add the device */
 797         ret = mousevsc_on_device_add(dev, NULL);
 798
 799         if (ret != 0) {
 800                 DPRINT_ERR(INPUTVSC_DRV, "unable to add input vsc device");
 801
 802                 return -1;
 803         }
 804
 805         return 0;
 806 }
 807
 808 static int mousevsc_remove(struct hv_device *dev)
 809 {
 810         int ret = 0;
 811
 812         struct input_device_context *input_dev_ctx;
 813
 814         input_dev_ctx = kmalloc(sizeof(struct input_device_context),
 815                                 GFP_KERNEL);
 816
 817         dev_set_drvdata(&dev->device, input_dev_ctx);
 818
 819         if (input_dev_ctx->connected) {
 820                 hidinput_disconnect(input_dev_ctx->hid_device);
 821                 input_dev_ctx->connected = 0;
 822         }
 823
 824         /*
 825          * Call to the vsc driver to let it know that the device
 826          * is being removed
 827          */
 828         ret = mousevsc_on_device_remove(dev);
 829
 830         if (ret != 0) {
 831                 DPRINT_ERR(INPUTVSC_DRV,
 832                            "unable to remove vsc device (ret %d)", ret);
 833         }
 834
 835         kfree(input_dev_ctx);
 836
 837         return ret;
 838 }
 839
 840 static void reportdesc_callback(struct hv_device *dev, void *packet, u32 len)
 841 {
 842         struct input_device_context *input_device_ctx =
 843                 dev_get_drvdata(&dev->device);
 844         struct hid_device *hid_dev;
 845
 846         /* hid_debug = -1; */
 847         hid_dev = kmalloc(sizeof(struct hid_device), GFP_KERNEL);
 848
 849         if (hid_parse_report(hid_dev, packet, len)) {
 850                 DPRINT_INFO(INPUTVSC_DRV, "Unable to call hd_parse_report");
 851                 return;
 852         }
 853
 854         if (hid_dev) {
 855                 DPRINT_INFO(INPUTVSC_DRV, "hid_device created");
 856
 857                 hid_dev->ll_driver->open  = mousevsc_hid_open;
 858                 hid_dev->ll_driver->close = mousevsc_hid_close;
 859
 860                 hid_dev->bus = BUS_VIRTUAL;
 861                 hid_dev->vendor = input_device_ctx->device_info.vendor;
 862                 hid_dev->product = input_device_ctx->device_info.product;
 863                 hid_dev->version = input_device_ctx->device_info.version;
 864                 hid_dev->dev = dev->device;
 865
 866                 sprintf(hid_dev->name, "%s",
 867                         input_device_ctx->device_info.name);
 868
 869                 /*
 870                  * HJ Do we want to call it with a 0
 871                  */
 872                 if (!hidinput_connect(hid_dev, 0)) {
 873                         hid_dev->claimed |= HID_CLAIMED_INPUT;
 874
 875                         input_device_ctx->connected = 1;
 876
 877                         DPRINT_INFO(INPUTVSC_DRV,
 878                                      "HID device claimed by input\n");
 879                 }
 880
 881                 if (!hid_dev->claimed) {
 882                         DPRINT_ERR(INPUTVSC_DRV,
 883                                     "HID device not claimed by "
 884                                     "input or hiddev\n");
 885                 }
 886
 887                 input_device_ctx->hid_device = hid_dev;
 888         }
 889
 890         kfree(hid_dev);
 891 }
 892
 893 static const struct hv_vmbus_device_id id_table[] = {
 894         /* Mouse guid */
 895         { VMBUS_DEVICE(0x9E, 0xB6, 0xA8, 0xCF, 0x4A, 0x5B, 0xc0, 0x4c,
 896                        0xB9, 0x8B, 0x8B, 0xA1, 0xA1, 0xF3, 0xF9, 0x5A) },
 897         { },
 898 };
 899
 900 /*
 901  * The mouse driver is not functional; do not auto-load it.
 902  */
 903 /* MODULE_DEVICE_TABLE(vmbus, id_table); */
 904
 905 static struct  hv_driver mousevsc_drv = {
 906         .name = "mousevsc",
 907         .id_table = id_table,
 908         .probe = mousevsc_probe,
 909         .remove = mousevsc_remove,
 910 };
 911
 912 static int __init mousevsc_init(void)
 913 {
 914         return vmbus_driver_register(&mousevsc_drv);
 915 }
 916
 917 static void __exit mousevsc_exit(void)
 918 {
 919         vmbus_driver_unregister(&mousevsc_drv);
 920 }
 921
 922 MODULE_LICENSE("GPL");
 923 MODULE_VERSION(HV_DRV_VERSION);
 924 module_init(mousevsc_init);
 925 module_exit(mousevsc_exit);
 926