IntelFrameworkModulePkg/Bus/Isa/Ps2MouseDxe/Ps2Mouse.c

   1 /**@file
   2   PS/2 Mouse driver. Routines that interacts with callers,
   3   conforming to EFI driver model
   4
   5 Copyright (c) 2006 - 2007, Intel Corporation
   6 All rights reserved. This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "Ps2Mouse.h"
  17 #include "CommPs2.h"
  18
  19 //
  20 // DriverBinding Protocol Instance
  21 //
  22 EFI_DRIVER_BINDING_PROTOCOL gPS2MouseDriver = {
  23   PS2MouseDriverSupported,
  24   PS2MouseDriverStart,
  25   PS2MouseDriverStop,
  26   0xa,
  27   NULL,
  28   NULL
  29 };
  30
  31 EFI_STATUS
  32 EFIAPI
  33 PS2MouseDriverSupported (
  34   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
  35   IN EFI_HANDLE                     Controller,
  36   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
  37   )
  38 /**
  39
  40 Routine Description:
  41
  42   ControllerDriver Protocol Method
  43
  44 Arguments:
  45
  46 Returns:
  47
  48 **/
  49 // GC_TODO:    This - add argument and description to function comment
  50 // GC_TODO:    Controller - add argument and description to function comment
  51 // GC_TODO:    RemainingDevicePath - add argument and description to function comment
  52 {
  53   EFI_STATUS                          Status;
  54   EFI_ISA_IO_PROTOCOL                 *IsaIo;
  55
  56   Status = EFI_SUCCESS;
  57
  58   //
  59   // Open the IO Abstraction(s) needed to perform the supported test
  60   //
  61   Status = gBS->OpenProtocol (
  62                   Controller,
  63                   &gEfiIsaIoProtocolGuid,
  64                   (VOID **) &IsaIo,
  65                   This->DriverBindingHandle,
  66                   Controller,
  67                   EFI_OPEN_PROTOCOL_BY_DRIVER
  68                   );
  69   if (EFI_ERROR (Status)) {
  70     return Status;
  71   }
  72   //
  73   // Use the ISA I/O Protocol to see if Controller is the Keyboard controller
  74   //
  75   switch (IsaIo->ResourceList->Device.HID) {
  76   case EISA_PNP_ID (0xF03):
  77   //
  78   // Microsoft PS/2 style mouse
  79   //
  80   case EISA_PNP_ID (0xF13):
  81     //
  82     // PS/2 Port for PS/2-style Mice
  83     //
  84     break;
  85
  86   case EISA_PNP_ID (0x303):
  87     //
  88     // IBM Enhanced (101/102-key, PS/2 mouse support)
  89     //
  90     if (IsaIo->ResourceList->Device.UID == 1) {
  91       break;
  92     }
  93
  94   default:
  95     Status = EFI_UNSUPPORTED;
  96     break;
  97   }
  98   //
  99   // Close the I/O Abstraction(s) used to perform the supported test
 100   //
 101   gBS->CloseProtocol (
 102          Controller,
 103          &gEfiIsaIoProtocolGuid,
 104          This->DriverBindingHandle,
 105          Controller
 106          );
 107
 108   return Status;
 109 }
 110
 111 EFI_STATUS
 112 EFIAPI
 113 PS2MouseDriverStart (
 114   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 115   IN EFI_HANDLE                     Controller,
 116   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 117   )
 118 /**
 119
 120 Routine Description:
 121     Start protocol interfaces for the mouse device handles.
 122
 123 Arguments:
 124     This                               - Protocol instance pointer.
 125     Controller                      - Handle of device to bind driver to.
 126     RemainingDevicePath  - Not used.
 127
 128 Returns:
 129     EFI_SUCCESS             - This driver is added to DeviceHandle.
 130     other                               - Errors occurred.
 131
 132 **/
 133 {
 134   EFI_STATUS                          Status;
 135   EFI_STATUS                          EmptyStatus;
 136   EFI_ISA_IO_PROTOCOL                 *IsaIo;
 137   PS2_MOUSE_DEV                       *MouseDev;
 138   UINT8                               Data;
 139   EFI_TPL                             OldTpl;
 140   EFI_STATUS_CODE_VALUE               StatusCode;
 141   EFI_DEVICE_PATH_PROTOCOL            *ParentDevicePath;
 142
 143   StatusCode  = 0;
 144   MouseDev    = NULL;
 145   IsaIo       = NULL;
 146
 147   //
 148   // Open the device path protocol
 149   //
 150   Status = gBS->OpenProtocol (
 151                   Controller,
 152                   &gEfiDevicePathProtocolGuid,
 153                   (VOID **) &ParentDevicePath,
 154                   This->DriverBindingHandle,
 155                   Controller,
 156                   EFI_OPEN_PROTOCOL_BY_DRIVER
 157                   );
 158   if (EFI_ERROR (Status)) {
 159     return Status;
 160   }
 161   //
 162   // Report that the keyboard is being enabled
 163   //
 164   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 165     EFI_PROGRESS_CODE,
 166     EFI_PERIPHERAL_MOUSE | EFI_P_PC_ENABLE,
 167     ParentDevicePath
 168     );
 169
 170   //
 171   // Get the ISA I/O Protocol on Controller's handle
 172   //
 173   Status = gBS->OpenProtocol (
 174                   Controller,
 175                   &gEfiIsaIoProtocolGuid,
 176                   (VOID **) &IsaIo,
 177                   This->DriverBindingHandle,
 178                   Controller,
 179                   EFI_OPEN_PROTOCOL_BY_DRIVER
 180                   );
 181   if (EFI_ERROR (Status)) {
 182     gBS->CloseProtocol (
 183            Controller,
 184            &gEfiDevicePathProtocolGuid,
 185            This->DriverBindingHandle,
 186            Controller
 187            );
 188     return EFI_INVALID_PARAMETER;
 189   }
 190   //
 191   // Raise TPL to avoid keyboard operation impact
 192   //
 193   OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 194
 195   //
 196   // Allocate private data
 197   //
 198   MouseDev = AllocateZeroPool (sizeof (PS2_MOUSE_DEV));
 199   if (MouseDev == NULL) {
 200     Status = EFI_OUT_OF_RESOURCES;
 201     goto ErrorExit;
 202   }
 203   //
 204   // Setup the device instance
 205   //
 206   MouseDev->Signature       = PS2_MOUSE_DEV_SIGNATURE;
 207   MouseDev->Handle          = Controller;
 208   MouseDev->SampleRate      = SSR_20;
 209   MouseDev->Resolution      = CMR4;
 210   MouseDev->Scaling         = SF1;
 211   MouseDev->DataPackageSize = 3;
 212   MouseDev->IsaIo           = IsaIo;
 213   MouseDev->DevicePath      = ParentDevicePath;
 214
 215   //
 216   // Resolution = 4 counts/mm
 217   //
 218   MouseDev->Mode.ResolutionX                = 4;
 219   MouseDev->Mode.ResolutionY                = 4;
 220   MouseDev->Mode.LeftButton                 = TRUE;
 221   MouseDev->Mode.RightButton                = TRUE;
 222
 223   MouseDev->SimplePointerProtocol.Reset     = MouseReset;
 224   MouseDev->SimplePointerProtocol.GetState  = MouseGetState;
 225   MouseDev->SimplePointerProtocol.Mode      = &(MouseDev->Mode);
 226
 227   //
 228   // Initialize keyboard controller if necessary
 229   //
 230   IsaIo->Io.Read (IsaIo, EfiIsaIoWidthUint8, KBC_CMD_STS_PORT, 1, &Data);
 231   if ((Data & KBC_SYSF) != KBC_SYSF) {
 232     Status = KbcSelfTest (IsaIo);
 233     if (EFI_ERROR (Status)) {
 234       StatusCode = EFI_PERIPHERAL_MOUSE | EFI_P_EC_CONTROLLER_ERROR;
 235       goto ErrorExit;
 236     }
 237   }
 238
 239   KbcEnableAux (IsaIo);
 240
 241   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 242     EFI_PROGRESS_CODE,
 243     EFI_PERIPHERAL_MOUSE | EFI_P_PC_PRESENCE_DETECT,
 244     ParentDevicePath
 245     );
 246
 247   //
 248   // Reset the mouse
 249   //
 250   Status = MouseDev->SimplePointerProtocol.Reset (&MouseDev->SimplePointerProtocol, TRUE);
 251   if (EFI_ERROR (Status)) {
 252     //
 253     // mouse not connected
 254     //
 255     Status      = EFI_SUCCESS;
 256     StatusCode  = EFI_PERIPHERAL_MOUSE | EFI_P_EC_NOT_DETECTED;
 257     goto ErrorExit;
 258   }
 259   //
 260   // Setup the WaitForKey event
 261   //
 262   Status = gBS->CreateEvent (
 263                   EVT_NOTIFY_WAIT,
 264                   TPL_NOTIFY,
 265                   MouseWaitForInput,
 266                   MouseDev,
 267                   &((MouseDev->SimplePointerProtocol).WaitForInput)
 268                   );
 269   if (EFI_ERROR (Status)) {
 270     Status = EFI_OUT_OF_RESOURCES;
 271     goto ErrorExit;
 272   }
 273   //
 274   // Setup a periodic timer, used to poll mouse state
 275   //
 276   Status = gBS->CreateEvent (
 277                   EVT_TIMER | EVT_NOTIFY_SIGNAL,
 278                   TPL_NOTIFY,
 279                   PollMouse,
 280                   MouseDev,
 281                   &MouseDev->TimerEvent
 282                   );
 283   if (EFI_ERROR (Status)) {
 284     Status = EFI_OUT_OF_RESOURCES;
 285     goto ErrorExit;
 286   }
 287   //
 288   // Start timer to poll mouse (100 samples per second)
 289   //
 290   Status = gBS->SetTimer (MouseDev->TimerEvent, TimerPeriodic, 100000);
 291   if (EFI_ERROR (Status)) {
 292     Status = EFI_OUT_OF_RESOURCES;
 293     goto ErrorExit;
 294   }
 295
 296   MouseDev->ControllerNameTable = NULL;
 297   AddUnicodeString2 (
 298     "eng",
 299     gPs2MouseComponentName.SupportedLanguages,
 300     &MouseDev->ControllerNameTable,
 301     L"PS/2 Mouse Device",
 302     TRUE
 303     );
 304   AddUnicodeString2 (
 305     "en",
 306     gPs2MouseComponentName2.SupportedLanguages,
 307     &MouseDev->ControllerNameTable,
 308     L"PS/2 Mouse Device",
 309     FALSE
 310     );
 311
 312
 313   //
 314   // Install protocol interfaces for the mouse device.
 315   //
 316   Status = gBS->InstallMultipleProtocolInterfaces (
 317                   &Controller,
 318                   &gEfiSimplePointerProtocolGuid,
 319                   &MouseDev->SimplePointerProtocol,
 320                   NULL
 321                   );
 322   if (EFI_ERROR (Status)) {
 323     goto ErrorExit;
 324   }
 325
 326   gBS->RestoreTPL (OldTpl);
 327
 328   return Status;
 329
 330 ErrorExit:
 331
 332   KbcDisableAux (IsaIo);
 333
 334   if (StatusCode != 0) {
 335     REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 336       EFI_ERROR_CODE | EFI_ERROR_MINOR,
 337       StatusCode,
 338       ParentDevicePath
 339       );
 340   }
 341
 342   if ((MouseDev != NULL) && (MouseDev->SimplePointerProtocol.WaitForInput != NULL)) {
 343     gBS->CloseEvent (MouseDev->SimplePointerProtocol.WaitForInput);
 344   }
 345
 346   if ((MouseDev != NULL) && (MouseDev->TimerEvent != NULL)) {
 347     gBS->CloseEvent (MouseDev->TimerEvent);
 348   }
 349
 350   if ((MouseDev != NULL) && (MouseDev->ControllerNameTable != NULL)) {
 351     FreeUnicodeStringTable (MouseDev->ControllerNameTable);
 352   }
 353   //
 354   // Since there will be no timer handler for mouse input any more,
 355   // exhaust input data just in case there is still mouse data left
 356   //
 357   EmptyStatus = EFI_SUCCESS;
 358   while (!EFI_ERROR (EmptyStatus)) {
 359     EmptyStatus = In8042Data (IsaIo, &Data);
 360   }
 361
 362   if (MouseDev != NULL) {
 363     gBS->FreePool (MouseDev);
 364   }
 365
 366   gBS->CloseProtocol (
 367          Controller,
 368          &gEfiDevicePathProtocolGuid,
 369          This->DriverBindingHandle,
 370          Controller
 371          );
 372
 373   gBS->CloseProtocol (
 374          Controller,
 375          &gEfiIsaIoProtocolGuid,
 376          This->DriverBindingHandle,
 377          Controller
 378          );
 379
 380   gBS->RestoreTPL (OldTpl);
 381
 382   return Status;
 383 }
 384
 385 EFI_STATUS
 386 EFIAPI
 387 PS2MouseDriverStop (
 388   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 389   IN EFI_HANDLE                     Controller,
 390   IN UINTN                          NumberOfChildren,
 391   IN EFI_HANDLE                     *ChildHandleBuffer
 392   )
 393 /**
 394
 395   Routine Description:
 396
 397   Arguments:
 398
 399   Returns:
 400
 401 **/
 402 // GC_TODO:    This - add argument and description to function comment
 403 // GC_TODO:    Controller - add argument and description to function comment
 404 // GC_TODO:    NumberOfChildren - add argument and description to function comment
 405 // GC_TODO:    ChildHandleBuffer - add argument and description to function comment
 406 // GC_TODO:    EFI_SUCCESS - add return value to function comment
 407 // GC_TODO:    EFI_SUCCESS - add return value to function comment
 408 {
 409   EFI_STATUS                  Status;
 410   EFI_SIMPLE_POINTER_PROTOCOL *SimplePointerProtocol;
 411   PS2_MOUSE_DEV               *MouseDev;
 412   UINT8                       Data;
 413
 414   Status = gBS->OpenProtocol (
 415                   Controller,
 416                   &gEfiSimplePointerProtocolGuid,
 417                   (VOID **) &SimplePointerProtocol,
 418                   This->DriverBindingHandle,
 419                   Controller,
 420                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 421                   );
 422   if (EFI_ERROR (Status)) {
 423     return EFI_SUCCESS;
 424   }
 425
 426   MouseDev = PS2_MOUSE_DEV_FROM_THIS (SimplePointerProtocol);
 427
 428   //
 429   // Report that the keyboard is being disabled
 430   //
 431   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 432     EFI_PROGRESS_CODE,
 433     EFI_PERIPHERAL_MOUSE | EFI_P_PC_DISABLE,
 434     MouseDev->DevicePath
 435     );
 436
 437   Status = gBS->UninstallProtocolInterface (
 438                   Controller,
 439                   &gEfiSimplePointerProtocolGuid,
 440                   &MouseDev->SimplePointerProtocol
 441                   );
 442   if (EFI_ERROR (Status)) {
 443     return Status;
 444   }
 445   //
 446   // Disable mouse on keyboard controller
 447   //
 448   KbcDisableAux (MouseDev->IsaIo);
 449
 450   //
 451   // Cancel mouse data polling timer, close timer event
 452   //
 453   gBS->SetTimer (MouseDev->TimerEvent, TimerCancel, 0);
 454   gBS->CloseEvent (MouseDev->TimerEvent);
 455
 456   //
 457   // Since there will be no timer handler for mouse input any more,
 458   // exhaust input data just in case there is still mouse data left
 459   //
 460   Status = EFI_SUCCESS;
 461   while (!EFI_ERROR (Status)) {
 462     Status = In8042Data (MouseDev->IsaIo, &Data);
 463   }
 464
 465   gBS->CloseEvent (MouseDev->SimplePointerProtocol.WaitForInput);
 466   FreeUnicodeStringTable (MouseDev->ControllerNameTable);
 467   gBS->FreePool (MouseDev);
 468
 469   gBS->CloseProtocol (
 470          Controller,
 471          &gEfiDevicePathProtocolGuid,
 472          This->DriverBindingHandle,
 473          Controller
 474          );
 475
 476   gBS->CloseProtocol (
 477          Controller,
 478          &gEfiIsaIoProtocolGuid,
 479          This->DriverBindingHandle,
 480          Controller
 481          );
 482
 483   return EFI_SUCCESS;
 484 }
 485
 486 EFI_STATUS
 487 EFIAPI
 488 MouseReset (
 489   IN EFI_SIMPLE_POINTER_PROTOCOL    *This,
 490   IN BOOLEAN                        ExtendedVerification
 491   )
 492 /**
 493
 494 Routine Description:
 495
 496   Reset the Mouse and do BAT test for it, if ExtendedVerification isTRUE and there is a mouse device connectted to system
 497
 498 Arguments:
 499
 500   This                 - Pointer of simple pointer Protocol.
 501   ExtendedVerification - Whether configure mouse parameters. True: do; FALSE: skip.
 502
 503 Returns:
 504
 505  EFI_SUCCESS         - The command byte is written successfully.
 506  EFI_DEVICE_ERROR    - Errors occurred during reseting keyboard.
 507
 508 **/
 509 {
 510   EFI_STATUS    Status;
 511   PS2_MOUSE_DEV *MouseDev;
 512   EFI_TPL       OldTpl;
 513   BOOLEAN       KeyboardEnable;
 514   UINT8         Data;
 515
 516   MouseDev = PS2_MOUSE_DEV_FROM_THIS (This);
 517
 518   //
 519   // Report reset progress code
 520   //
 521   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 522     EFI_PROGRESS_CODE,
 523     EFI_PERIPHERAL_MOUSE | EFI_P_PC_RESET,
 524     MouseDev->DevicePath
 525     );
 526
 527   KeyboardEnable = FALSE;
 528
 529   //
 530   // Raise TPL to avoid keyboard operation impact
 531   //
 532   OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 533
 534   ZeroMem (&MouseDev->State, sizeof (EFI_SIMPLE_POINTER_STATE));
 535   MouseDev->StateChanged = FALSE;
 536
 537   //
 538   // Exhaust input data
 539   //
 540   Status = EFI_SUCCESS;
 541   while (!EFI_ERROR (Status)) {
 542     Status = In8042Data (MouseDev->IsaIo, &Data);
 543   }
 544
 545   CheckKbStatus (MouseDev->IsaIo, &KeyboardEnable);
 546
 547   KbcDisableKb (MouseDev->IsaIo);
 548
 549   MouseDev->IsaIo->Io.Read (MouseDev->IsaIo, EfiIsaIoWidthUint8, KBC_CMD_STS_PORT, 1, &Data);
 550
 551   //
 552   // if there's data block on KBC data port, read it out
 553   //
 554   if ((Data & KBC_OUTB) == KBC_OUTB) {
 555     MouseDev->IsaIo->Io.Read (MouseDev->IsaIo, EfiIsaIoWidthUint8, KBC_DATA_PORT, 1, &Data);
 556   }
 557
 558   Status = EFI_SUCCESS;
 559   //
 560   // The PS2 mouse driver reset behavior is always successfully return no matter wheater or not there is mouse connected to system.
 561   // This behavior is needed by performance speed. The following mouse command only succeessfully finish when mouse device is
 562   // connected to system, so if PS2 mouse device not connect to system or user not ask for, we skip the mouse configuration and enabling
 563   //
 564   if (ExtendedVerification && CheckMouseConnect (MouseDev)) {
 565     //
 566     // Send mouse reset command and set mouse default configure
 567     //
 568     Status = PS2MouseReset (MouseDev->IsaIo);
 569     if (EFI_ERROR (Status)) {
 570       Status = EFI_DEVICE_ERROR;
 571       goto Exit;
 572     }
 573
 574     Status = PS2MouseSetSampleRate (MouseDev->IsaIo, MouseDev->SampleRate);
 575     if (EFI_ERROR (Status)) {
 576       Status = EFI_DEVICE_ERROR;
 577       goto Exit;
 578     }
 579
 580     Status = PS2MouseSetResolution (MouseDev->IsaIo, MouseDev->Resolution);
 581     if (EFI_ERROR (Status)) {
 582       Status = EFI_DEVICE_ERROR;
 583       goto Exit;
 584     }
 585
 586     Status = PS2MouseSetScaling (MouseDev->IsaIo, MouseDev->Scaling);
 587     if (EFI_ERROR (Status)) {
 588       Status = EFI_DEVICE_ERROR;
 589       goto Exit;
 590     }
 591
 592     Status = PS2MouseEnable (MouseDev->IsaIo);
 593     if (EFI_ERROR (Status)) {
 594       Status = EFI_DEVICE_ERROR;
 595       goto Exit;
 596     }
 597   }
 598 Exit:
 599   gBS->RestoreTPL (OldTpl);
 600
 601   if (KeyboardEnable) {
 602     KbcEnableKb (MouseDev->IsaIo);
 603   }
 604
 605   return Status;
 606 }
 607
 608 BOOLEAN
 609 CheckMouseConnect (
 610   IN  PS2_MOUSE_DEV     *MouseDev
 611   )
 612 /**
 613
 614 Routine Description:
 615
 616   Check whether there is Ps/2 mouse device in system
 617
 618 Arguments:
 619
 620   PS2_MOUSE_DEV - Mouse Private Data Structure
 621
 622 Returns:
 623
 624   TRUE                - Keyboard in System.
 625   FALSE               - Keyboard not in System.
 626
 627 **/
 628 {
 629   EFI_STATUS     Status;
 630
 631   Status = PS2MouseEnable (MouseDev->IsaIo);
 632   if (!EFI_ERROR (Status)) {
 633     return TRUE;
 634   }
 635
 636   return FALSE;
 637 }
 638
 639 EFI_STATUS
 640 EFIAPI
 641 MouseGetState (
 642   IN EFI_SIMPLE_POINTER_PROTOCOL    *This,
 643   IN OUT EFI_SIMPLE_POINTER_STATE   *State
 644   )
 645 /**
 646
 647 Routine Description:
 648
 649   GC_TODO: Add function description
 650
 651 Arguments:
 652
 653   This  - GC_TODO: add argument description
 654   State - GC_TODO: add argument description
 655
 656 Returns:
 657
 658   EFI_INVALID_PARAMETER - GC_TODO: Add description for return value
 659   EFI_NOT_READY - GC_TODO: Add description for return value
 660   EFI_SUCCESS - GC_TODO: Add description for return value
 661
 662 **/
 663 {
 664   PS2_MOUSE_DEV *MouseDev;
 665   EFI_TPL       OldTpl;
 666
 667   MouseDev = PS2_MOUSE_DEV_FROM_THIS (This);
 668
 669   if (State == NULL) {
 670     return EFI_INVALID_PARAMETER;
 671   }
 672
 673   if (!MouseDev->StateChanged) {
 674     return EFI_NOT_READY;
 675   }
 676
 677   OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
 678   CopyMem (State, &(MouseDev->State), sizeof (EFI_SIMPLE_POINTER_STATE));
 679
 680   //
 681   // clear mouse state
 682   //
 683   MouseDev->State.RelativeMovementX = 0;
 684   MouseDev->State.RelativeMovementY = 0;
 685   MouseDev->State.RelativeMovementZ = 0;
 686   MouseDev->StateChanged            = FALSE;
 687   gBS->RestoreTPL (OldTpl);
 688
 689   return EFI_SUCCESS;
 690 }
 691
 692 VOID
 693 EFIAPI
 694 MouseWaitForInput (
 695   IN  EFI_EVENT               Event,
 696   IN  VOID                    *Context
 697   )
 698 /**
 699
 700 Routine Description:
 701
 702   Event notification function for SIMPLE_POINTER.WaitForInput event
 703   Signal the event if there is input from mouse
 704
 705 Arguments:
 706
 707 Returns:
 708
 709 **/
 710 // GC_TODO:    Event - add argument and description to function comment
 711 // GC_TODO:    Context - add argument and description to function comment
 712 {
 713   PS2_MOUSE_DEV *MouseDev;
 714
 715   MouseDev = (PS2_MOUSE_DEV *) Context;
 716
 717   //
 718   // Someone is waiting on the mouse event, if there's
 719   // input from mouse, signal the event
 720   //
 721   if (MouseDev->StateChanged) {
 722     gBS->SignalEvent (Event);
 723   }
 724
 725 }
 726
 727 VOID
 728 EFIAPI
 729 PollMouse (
 730   IN EFI_EVENT  Event,
 731   IN VOID       *Context
 732   )
 733 /**
 734
 735 Routine Description:
 736
 737   Event notification function for TimerEvent event
 738   If mouse device is connected to system, try to get the mouse packet data
 739
 740 Arguments:
 741
 742   Event      -  TimerEvent in PS2_MOUSE_DEV
 743   Context  -  Pointer to PS2_MOUSE_DEV structure
 744
 745 Returns:
 746
 747   None
 748
 749 **/
 750 {
 751   PS2_MOUSE_DEV *MouseDev;
 752
 753   MouseDev = (PS2_MOUSE_DEV *) Context;
 754
 755   //
 756   // Polling mouse packet data
 757   //
 758   PS2MouseGetPacket (MouseDev);
 759 }
 760
 761 /**
 762   The user Entry Point for module Ps2Mouse. The user code starts with this function.
 763
 764   @param[in] ImageHandle    The firmware allocated handle for the EFI image.
 765   @param[in] SystemTable    A pointer to the EFI System Table.
 766
 767   @retval EFI_SUCCESS       The entry point is executed successfully.
 768   @retval other             Some error occurs when executing this entry point.
 769
 770 **/
 771 EFI_STATUS
 772 EFIAPI
 773 InitializePs2Mouse(
 774   IN EFI_HANDLE           ImageHandle,
 775   IN EFI_SYSTEM_TABLE     *SystemTable
 776   )
 777 {
 778   EFI_STATUS              Status;
 779
 780   //
 781   // Install driver model protocol(s).
 782   //
 783   Status = EfiLibInstallDriverBindingComponentName2 (
 784              ImageHandle,
 785              SystemTable,
 786              &gPS2MouseDriver,
 787              ImageHandle,
 788              &gPs2MouseComponentName,
 789              &gPs2MouseComponentName2
 790              );
 791   ASSERT_EFI_ERROR (Status);
 792
 793
 794   return Status;
 795 }