MdeModulePkg/Bus/Usb/UsbMouseAbsolutePointerDxe/UsbMouseAbsolutePointer.c

   1 /** @file
   2   USB Mouse Driver that manages USB mouse and produces Absolute Pointer Protocol.
   3
   4 Copyright (c) 2004 - 2010, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "UsbMouseAbsolutePointer.h"
  16
  17 EFI_DRIVER_BINDING_PROTOCOL gUsbMouseAbsolutePointerDriverBinding = {
  18   USBMouseAbsolutePointerDriverBindingSupported,
  19   USBMouseAbsolutePointerDriverBindingStart,
  20   USBMouseAbsolutePointerDriverBindingStop,
  21   0x1,
  22   NULL,
  23   NULL
  24 };
  25
  26 /**
  27   Entrypoint of USB Mouse Absolute Pointer Driver.
  28
  29   This function is the entrypoint of USB Mouse Driver. It installs Driver Binding
  30   Protocols together with Component Name Protocols.
  31
  32   @param  ImageHandle       The firmware allocated handle for the EFI image.
  33   @param  SystemTable       A pointer to the EFI System Table.
  34
  35   @retval EFI_SUCCESS       The entry point is executed successfully.
  36
  37 **/
  38 EFI_STATUS
  39 EFIAPI
  40 USBMouseAbsolutePointerDriverBindingEntryPoint (
  41   IN EFI_HANDLE           ImageHandle,
  42   IN EFI_SYSTEM_TABLE     *SystemTable
  43   )
  44 {
  45   EFI_STATUS              Status;
  46
  47   Status = EfiLibInstallDriverBindingComponentName2 (
  48              ImageHandle,
  49              SystemTable,
  50              &gUsbMouseAbsolutePointerDriverBinding,
  51              ImageHandle,
  52              &gUsbMouseAbsolutePointerComponentName,
  53              &gUsbMouseAbsolutePointerComponentName2
  54              );
  55   ASSERT_EFI_ERROR (Status);
  56
  57   return EFI_SUCCESS;
  58 }
  59
  60
  61 /**
  62   Check whether USB Mouse Absolute Pointer Driver supports this device.
  63
  64   @param  This                   The driver binding protocol.
  65   @param  Controller             The controller handle to check.
  66   @param  RemainingDevicePath    The remaining device path.
  67
  68   @retval EFI_SUCCESS            The driver supports this controller.
  69   @retval other                  This device isn't supported.
  70
  71 **/
  72 EFI_STATUS
  73 EFIAPI
  74 USBMouseAbsolutePointerDriverBindingSupported (
  75   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
  76   IN EFI_HANDLE                     Controller,
  77   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
  78   )
  79 {
  80   EFI_STATUS          Status;
  81   EFI_USB_IO_PROTOCOL *UsbIo;
  82
  83   Status = gBS->OpenProtocol (
  84                   Controller,
  85                   &gEfiUsbIoProtocolGuid,
  86                   (VOID **) &UsbIo,
  87                   This->DriverBindingHandle,
  88                   Controller,
  89                   EFI_OPEN_PROTOCOL_BY_DRIVER
  90                   );
  91   if (EFI_ERROR (Status)) {
  92     return Status;
  93   }
  94
  95   //
  96   // Use the USB I/O Protocol interface to check whether Controller is
  97   // a mouse device that can be managed by this driver.
  98   //
  99   Status = EFI_SUCCESS;
 100   if (!IsUsbMouse (UsbIo)) {
 101     Status = EFI_UNSUPPORTED;
 102   }
 103
 104   gBS->CloseProtocol (
 105         Controller,
 106         &gEfiUsbIoProtocolGuid,
 107         This->DriverBindingHandle,
 108         Controller
 109         );
 110
 111   return Status;
 112 }
 113
 114
 115 /**
 116   Starts the mouse device with this driver.
 117
 118   This function consumes USB I/O Portocol, intializes USB mouse device,
 119   installs Absolute Pointer Protocol, and submits Asynchronous Interrupt
 120   Transfer to manage the USB mouse device.
 121
 122   @param  This                  The driver binding instance.
 123   @param  Controller            Handle of device to bind driver to.
 124   @param  RemainingDevicePath   Optional parameter use to pick a specific child
 125                                 device to start.
 126
 127   @retval EFI_SUCCESS           This driver supports this device.
 128   @retval EFI_UNSUPPORTED       This driver does not support this device.
 129   @retval EFI_DEVICE_ERROR      This driver cannot be started due to device Error.
 130   @retval EFI_OUT_OF_RESOURCES  Can't allocate memory resources.
 131   @retval EFI_ALREADY_STARTED   This driver has been started.
 132
 133 **/
 134 EFI_STATUS
 135 EFIAPI
 136 USBMouseAbsolutePointerDriverBindingStart (
 137   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 138   IN EFI_HANDLE                     Controller,
 139   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 140   )
 141 {
 142   EFI_STATUS                     Status;
 143   EFI_USB_IO_PROTOCOL            *UsbIo;
 144   USB_MOUSE_ABSOLUTE_POINTER_DEV *UsbMouseAbsolutePointerDevice;
 145   UINT8                          EndpointNumber;
 146   EFI_USB_ENDPOINT_DESCRIPTOR    EndpointDescriptor;
 147   UINT8                          Index;
 148   UINT8                          EndpointAddr;
 149   UINT8                          PollingInterval;
 150   UINT8                          PacketSize;
 151   BOOLEAN                        Found;
 152   EFI_TPL                        OldTpl;
 153
 154   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 155   //
 156   // Open USB I/O Protocol
 157   //
 158   Status = gBS->OpenProtocol (
 159                   Controller,
 160                   &gEfiUsbIoProtocolGuid,
 161                   (VOID **) &UsbIo,
 162                   This->DriverBindingHandle,
 163                   Controller,
 164                   EFI_OPEN_PROTOCOL_BY_DRIVER
 165                   );
 166   if (EFI_ERROR (Status)) {
 167     goto ErrorExit1;
 168   }
 169
 170   UsbMouseAbsolutePointerDevice = AllocateZeroPool (sizeof (USB_MOUSE_ABSOLUTE_POINTER_DEV));
 171   ASSERT (UsbMouseAbsolutePointerDevice != NULL);
 172
 173   UsbMouseAbsolutePointerDevice->UsbIo     = UsbIo;
 174   UsbMouseAbsolutePointerDevice->Signature = USB_MOUSE_ABSOLUTE_POINTER_DEV_SIGNATURE;
 175
 176   //
 177   // Get the Device Path Protocol on Controller's handle
 178   //
 179   Status = gBS->OpenProtocol (
 180                   Controller,
 181                   &gEfiDevicePathProtocolGuid,
 182                   (VOID **) &UsbMouseAbsolutePointerDevice->DevicePath,
 183                   This->DriverBindingHandle,
 184                   Controller,
 185                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 186                   );
 187
 188   if (EFI_ERROR (Status)) {
 189     goto ErrorExit;
 190   }
 191   //
 192   // Get interface & endpoint descriptor
 193   //
 194   UsbIo->UsbGetInterfaceDescriptor (
 195            UsbIo,
 196            &UsbMouseAbsolutePointerDevice->InterfaceDescriptor
 197            );
 198
 199   EndpointNumber = UsbMouseAbsolutePointerDevice->InterfaceDescriptor.NumEndpoints;
 200
 201   //
 202   // Traverse endpoints to find interrupt endpoint
 203   //
 204   Found = FALSE;
 205   for (Index = 0; Index < EndpointNumber; Index++) {
 206     UsbIo->UsbGetEndpointDescriptor (
 207              UsbIo,
 208              Index,
 209              &EndpointDescriptor
 210              );
 211
 212     if ((EndpointDescriptor.Attributes & (BIT0 | BIT1)) == USB_ENDPOINT_INTERRUPT) {
 213       //
 214       // We only care interrupt endpoint here
 215       //
 216       CopyMem (&UsbMouseAbsolutePointerDevice->IntEndpointDescriptor, &EndpointDescriptor, sizeof(EndpointDescriptor));
 217       Found = TRUE;
 218       break;
 219     }
 220   }
 221
 222   if (!Found) {
 223     //
 224     // No interrupt endpoint found, then return unsupported.
 225     //
 226     Status = EFI_UNSUPPORTED;
 227     goto ErrorExit;
 228   }
 229
 230   Status = InitializeUsbMouseDevice (UsbMouseAbsolutePointerDevice);
 231   if (EFI_ERROR (Status)) {
 232     //
 233     // Fail to initialize USB mouse device.
 234     //
 235     REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 236       EFI_ERROR_CODE | EFI_ERROR_MINOR,
 237       (EFI_PERIPHERAL_MOUSE | EFI_P_EC_INTERFACE_ERROR),
 238       UsbMouseAbsolutePointerDevice->DevicePath
 239       );
 240
 241     goto ErrorExit;
 242   }
 243
 244   //
 245   // Initialize and install EFI Absolute Pointer Protocol.
 246   //
 247   UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol.GetState = GetMouseAbsolutePointerState;
 248   UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol.Reset    = UsbMouseAbsolutePointerReset;
 249   UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol.Mode     = &UsbMouseAbsolutePointerDevice->Mode;
 250
 251   Status = gBS->CreateEvent (
 252                   EVT_NOTIFY_WAIT,
 253                   TPL_NOTIFY,
 254                   UsbMouseAbsolutePointerWaitForInput,
 255                   UsbMouseAbsolutePointerDevice,
 256                   &((UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol).WaitForInput)
 257                   );
 258   if (EFI_ERROR (Status)) {
 259     goto ErrorExit;
 260   }
 261
 262   Status = gBS->InstallProtocolInterface (
 263                   &Controller,
 264                   &gEfiAbsolutePointerProtocolGuid,
 265                   EFI_NATIVE_INTERFACE,
 266                   &UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol
 267                   );
 268
 269   if (EFI_ERROR (Status)) {
 270     goto ErrorExit;
 271   }
 272
 273   //
 274   // The next step would be submitting Asynchronous Interrupt Transfer on this mouse device.
 275   // After that we will be able to get key data from it. Thus this is deemed as
 276   // the enable action of the mouse, so report status code accordingly.
 277   //
 278   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 279     EFI_PROGRESS_CODE,
 280     (EFI_PERIPHERAL_MOUSE | EFI_P_PC_ENABLE),
 281     UsbMouseAbsolutePointerDevice->DevicePath
 282     );
 283
 284   //
 285   // Submit Asynchronous Interrupt Transfer to manage this device.
 286   //
 287   EndpointAddr    = UsbMouseAbsolutePointerDevice->IntEndpointDescriptor.EndpointAddress;
 288   PollingInterval = UsbMouseAbsolutePointerDevice->IntEndpointDescriptor.Interval;
 289   PacketSize      = (UINT8) (UsbMouseAbsolutePointerDevice->IntEndpointDescriptor.MaxPacketSize);
 290
 291   Status = UsbIo->UsbAsyncInterruptTransfer (
 292                     UsbIo,
 293                     EndpointAddr,
 294                     TRUE,
 295                     PollingInterval,
 296                     PacketSize,
 297                     OnMouseInterruptComplete,
 298                     UsbMouseAbsolutePointerDevice
 299                     );
 300
 301   if (EFI_ERROR (Status)) {
 302     //
 303     // If submit error, uninstall that interface
 304     //
 305     gBS->UninstallProtocolInterface (
 306            Controller,
 307            &gEfiAbsolutePointerProtocolGuid,
 308            &UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol
 309            );
 310     goto ErrorExit;
 311   }
 312
 313   UsbMouseAbsolutePointerDevice->ControllerNameTable = NULL;
 314   AddUnicodeString2 (
 315     "eng",
 316     gUsbMouseAbsolutePointerComponentName.SupportedLanguages,
 317     &UsbMouseAbsolutePointerDevice->ControllerNameTable,
 318     L"Generic Usb Mouse Absolute Pointer",
 319       TRUE
 320       );
 321   AddUnicodeString2 (
 322     "en",
 323     gUsbMouseAbsolutePointerComponentName2.SupportedLanguages,
 324     &UsbMouseAbsolutePointerDevice->ControllerNameTable,
 325     L"Generic Usb Mouse Absolute Pointer",
 326     FALSE
 327     );
 328
 329   gBS->RestoreTPL (OldTpl);
 330   return EFI_SUCCESS;
 331
 332 //
 333 // Error handler
 334 //
 335 ErrorExit:
 336   if (EFI_ERROR (Status)) {
 337     gBS->CloseProtocol (
 338           Controller,
 339           &gEfiUsbIoProtocolGuid,
 340           This->DriverBindingHandle,
 341           Controller
 342           );
 343
 344     if (UsbMouseAbsolutePointerDevice != NULL) {
 345       if ((UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol).WaitForInput != NULL) {
 346         gBS->CloseEvent ((UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol).WaitForInput);
 347       }
 348
 349       FreePool (UsbMouseAbsolutePointerDevice);
 350       UsbMouseAbsolutePointerDevice = NULL;
 351     }
 352   }
 353
 354 ErrorExit1:
 355   gBS->RestoreTPL (OldTpl);
 356
 357   return Status;
 358 }
 359
 360
 361 /**
 362   Stop the USB mouse device handled by this driver.
 363
 364   @param  This                   The driver binding protocol.
 365   @param  Controller             The controller to release.
 366   @param  NumberOfChildren       The number of handles in ChildHandleBuffer.
 367   @param  ChildHandleBuffer      The array of child handle.
 368
 369   @retval EFI_SUCCESS            The device was stopped.
 370   @retval EFI_UNSUPPORTED        Absolute Pointer Protocol is not installed on Controller.
 371   @retval Others                 Fail to uninstall protocols attached on the device.
 372
 373 **/
 374 EFI_STATUS
 375 EFIAPI
 376 USBMouseAbsolutePointerDriverBindingStop (
 377   IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
 378   IN  EFI_HANDLE                    Controller,
 379   IN  UINTN                         NumberOfChildren,
 380   IN  EFI_HANDLE                    *ChildHandleBuffer
 381   )
 382 {
 383   EFI_STATUS                      Status;
 384   USB_MOUSE_ABSOLUTE_POINTER_DEV  *UsbMouseAbsolutePointerDevice;
 385   EFI_ABSOLUTE_POINTER_PROTOCOL   *AbsolutePointerProtocol;
 386   EFI_USB_IO_PROTOCOL             *UsbIo;
 387
 388   Status = gBS->OpenProtocol (
 389                   Controller,
 390                   &gEfiAbsolutePointerProtocolGuid,
 391                   (VOID **) &AbsolutePointerProtocol,
 392                   This->DriverBindingHandle,
 393                   Controller,
 394                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 395                   );
 396
 397   if (EFI_ERROR (Status)) {
 398     return EFI_UNSUPPORTED;
 399   }
 400
 401   UsbMouseAbsolutePointerDevice = USB_MOUSE_ABSOLUTE_POINTER_DEV_FROM_MOUSE_PROTOCOL (AbsolutePointerProtocol);
 402
 403   UsbIo = UsbMouseAbsolutePointerDevice->UsbIo;
 404
 405   //
 406   // The key data input from this device will be disabled.
 407   //
 408   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 409     EFI_PROGRESS_CODE,
 410     (EFI_PERIPHERAL_MOUSE | EFI_P_PC_DISABLE),
 411     UsbMouseAbsolutePointerDevice->DevicePath
 412     );
 413
 414   //
 415   // Delete the Asynchronous Interrupt Transfer from this device
 416   //
 417   UsbIo->UsbAsyncInterruptTransfer (
 418            UsbIo,
 419            UsbMouseAbsolutePointerDevice->IntEndpointDescriptor.EndpointAddress,
 420            FALSE,
 421            UsbMouseAbsolutePointerDevice->IntEndpointDescriptor.Interval,
 422            0,
 423            NULL,
 424            NULL
 425            );
 426
 427   Status = gBS->UninstallProtocolInterface (
 428                   Controller,
 429                   &gEfiAbsolutePointerProtocolGuid,
 430                   &UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol
 431                   );
 432   if (EFI_ERROR (Status)) {
 433     return Status;
 434   }
 435
 436   gBS->CloseProtocol (
 437          Controller,
 438          &gEfiUsbIoProtocolGuid,
 439          This->DriverBindingHandle,
 440          Controller
 441          );
 442
 443   //
 444   // Free all resources.
 445   //
 446   gBS->CloseEvent (UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol.WaitForInput);
 447
 448   if (UsbMouseAbsolutePointerDevice->DelayedRecoveryEvent != NULL) {
 449     gBS->CloseEvent (UsbMouseAbsolutePointerDevice->DelayedRecoveryEvent);
 450     UsbMouseAbsolutePointerDevice->DelayedRecoveryEvent = NULL;
 451   }
 452
 453   if (UsbMouseAbsolutePointerDevice->ControllerNameTable != NULL) {
 454     FreeUnicodeStringTable (UsbMouseAbsolutePointerDevice->ControllerNameTable);
 455   }
 456
 457   FreePool (UsbMouseAbsolutePointerDevice);
 458
 459   return EFI_SUCCESS;
 460
 461 }
 462
 463
 464 /**
 465   Uses USB I/O to check whether the device is a USB mouse device.
 466
 467   @param  UsbIo    Pointer to a USB I/O protocol instance.
 468
 469   @retval TRUE     Device is a USB mouse device.
 470   @retval FALSE    Device is a not USB mouse device.
 471
 472 **/
 473 BOOLEAN
 474 IsUsbMouse (
 475   IN  EFI_USB_IO_PROTOCOL     *UsbIo
 476   )
 477 {
 478   EFI_STATUS                    Status;
 479   EFI_USB_INTERFACE_DESCRIPTOR  InterfaceDescriptor;
 480
 481   //
 482   // Get the default interface descriptor
 483   //
 484   Status = UsbIo->UsbGetInterfaceDescriptor (
 485                     UsbIo,
 486                     &InterfaceDescriptor
 487                     );
 488
 489   if (EFI_ERROR (Status)) {
 490     return FALSE;
 491   }
 492
 493   if ((InterfaceDescriptor.InterfaceClass == CLASS_HID) &&
 494       (InterfaceDescriptor.InterfaceSubClass == SUBCLASS_BOOT) &&
 495       (InterfaceDescriptor.InterfaceProtocol == PROTOCOL_MOUSE)
 496       ) {
 497     return TRUE;
 498   }
 499
 500   return FALSE;
 501 }
 502
 503
 504 /**
 505   Initialize the USB mouse device.
 506
 507   This function retrieves and parses HID report descriptor, and
 508   initializes state of USB_MOUSE_ABSOLUTE_POINTER_DEV. Then it sets indefinite idle
 509   rate for the device. Finally it creates event for delayed recovery,
 510   which deals with device error.
 511
 512   @param  UsbMouseAbsolutePointerDev   Device instance to be initialized.
 513
 514   @retval EFI_SUCCESS                  USB mouse device successfully initialized.
 515   @retval EFI_UNSUPPORTED              HID descriptor type is not report descriptor.
 516   @retval Other                        USB mouse device was not initialized successfully.
 517
 518 **/
 519 EFI_STATUS
 520 InitializeUsbMouseDevice (
 521   IN  USB_MOUSE_ABSOLUTE_POINTER_DEV           *UsbMouseAbsolutePointerDev
 522   )
 523 {
 524   EFI_USB_IO_PROTOCOL     *UsbIo;
 525   UINT8                   Protocol;
 526   EFI_STATUS              Status;
 527   EFI_USB_HID_DESCRIPTOR  MouseHidDesc;
 528   UINT8                   *ReportDesc;
 529   UINT8                   ReportId;
 530   UINT8                   Duration;
 531
 532   UsbIo = UsbMouseAbsolutePointerDev->UsbIo;
 533
 534   //
 535   // Get HID descriptor
 536   //
 537   Status = UsbGetHidDescriptor (
 538              UsbIo,
 539              UsbMouseAbsolutePointerDev->InterfaceDescriptor.InterfaceNumber,
 540              &MouseHidDesc
 541              );
 542   if (EFI_ERROR (Status)) {
 543     return Status;
 544   }
 545
 546   //
 547   // Get report descriptor
 548   //
 549   if (MouseHidDesc.HidClassDesc[0].DescriptorType != USB_DESC_TYPE_REPORT) {
 550     return EFI_UNSUPPORTED;
 551   }
 552
 553   ReportDesc = AllocateZeroPool (MouseHidDesc.HidClassDesc[0].DescriptorLength);
 554   ASSERT (ReportDesc != NULL);
 555
 556   Status = UsbGetReportDescriptor (
 557              UsbIo,
 558              UsbMouseAbsolutePointerDev->InterfaceDescriptor.InterfaceNumber,
 559              MouseHidDesc.HidClassDesc[0].DescriptorLength,
 560              ReportDesc
 561              );
 562
 563   if (EFI_ERROR (Status)) {
 564     FreePool (ReportDesc);
 565     return Status;
 566   }
 567
 568   //
 569   // Parse report descriptor
 570   //
 571   Status = ParseMouseReportDescriptor (
 572              UsbMouseAbsolutePointerDev,
 573              ReportDesc,
 574              MouseHidDesc.HidClassDesc[0].DescriptorLength
 575              );
 576
 577   if (EFI_ERROR (Status)) {
 578     FreePool (ReportDesc);
 579     return Status;
 580   }
 581
 582   UsbMouseAbsolutePointerDev->Mode.AbsoluteMaxX = 1024;
 583   UsbMouseAbsolutePointerDev->Mode.AbsoluteMaxY = 1024;
 584   UsbMouseAbsolutePointerDev->Mode.AbsoluteMaxZ = 0;
 585   UsbMouseAbsolutePointerDev->Mode.AbsoluteMinX = 0;
 586   UsbMouseAbsolutePointerDev->Mode.AbsoluteMinY = 0;
 587   UsbMouseAbsolutePointerDev->Mode.AbsoluteMinZ = 0;
 588   UsbMouseAbsolutePointerDev->Mode.Attributes   = 0x3;
 589
 590   //
 591   // Set boot protocol for the USB mouse.
 592   // This driver only supports boot protocol.
 593   //
 594   UsbGetProtocolRequest (
 595     UsbIo,
 596     UsbMouseAbsolutePointerDev->InterfaceDescriptor.InterfaceNumber,
 597     &Protocol
 598     );
 599   if (Protocol != BOOT_PROTOCOL) {
 600     Status = UsbSetProtocolRequest (
 601                UsbIo,
 602                0,
 603                BOOT_PROTOCOL
 604                );
 605
 606     if (EFI_ERROR (Status)) {
 607       FreePool (ReportDesc);
 608       return Status;
 609     }
 610   }
 611
 612   //
 613   // ReportId is zero, which means the idle rate applies to all input reports.
 614   //
 615   ReportId = 0;
 616   //
 617   // Duration is zero, which means the duration is infinite.
 618   // so the endpoint will inhibit reporting forever,
 619   // and only reporting when a change is detected in the report data.
 620   //
 621   Duration = 0;
 622   UsbSetIdleRequest (
 623     UsbIo,
 624     UsbMouseAbsolutePointerDev->InterfaceDescriptor.InterfaceNumber,
 625     ReportId,
 626     Duration
 627     );
 628
 629   FreePool (ReportDesc);
 630
 631   //
 632   // Create event for delayed recovery, which deals with device error.
 633   //
 634   if (UsbMouseAbsolutePointerDev->DelayedRecoveryEvent != NULL) {
 635     gBS->CloseEvent (UsbMouseAbsolutePointerDev->DelayedRecoveryEvent);
 636     UsbMouseAbsolutePointerDev->DelayedRecoveryEvent = 0;
 637   }
 638
 639   gBS->CreateEvent (
 640          EVT_TIMER | EVT_NOTIFY_SIGNAL,
 641          TPL_NOTIFY,
 642          USBMouseRecoveryHandler,
 643          UsbMouseAbsolutePointerDev,
 644          &UsbMouseAbsolutePointerDev->DelayedRecoveryEvent
 645          );
 646
 647   return EFI_SUCCESS;
 648 }
 649
 650
 651 /**
 652   Handler function for USB mouse's asynchronous interrupt transfer.
 653
 654   This function is the handler function for USB mouse's asynchronous interrupt transfer
 655   to manage the mouse. It parses data returned from asynchronous interrupt transfer, and
 656   get button and movement state.
 657
 658   @param  Data             A pointer to a buffer that is filled with key data which is
 659                            retrieved via asynchronous interrupt transfer.
 660   @param  DataLength       Indicates the size of the data buffer.
 661   @param  Context          Pointing to USB_KB_DEV instance.
 662   @param  Result           Indicates the result of the asynchronous interrupt transfer.
 663
 664   @retval EFI_SUCCESS      Asynchronous interrupt transfer is handled successfully.
 665   @retval EFI_DEVICE_ERROR Hardware error occurs.
 666
 667 **/
 668 EFI_STATUS
 669 EFIAPI
 670 OnMouseInterruptComplete (
 671   IN  VOID        *Data,
 672   IN  UINTN       DataLength,
 673   IN  VOID        *Context,
 674   IN  UINT32      Result
 675   )
 676 {
 677   USB_MOUSE_ABSOLUTE_POINTER_DEV   *UsbMouseAbsolutePointerDevice;
 678   EFI_USB_IO_PROTOCOL              *UsbIo;
 679   UINT8                            EndpointAddr;
 680   UINT32                           UsbResult;
 681
 682   UsbMouseAbsolutePointerDevice  = (USB_MOUSE_ABSOLUTE_POINTER_DEV *) Context;
 683   UsbIo                          = UsbMouseAbsolutePointerDevice->UsbIo;
 684
 685   if (Result != EFI_USB_NOERROR) {
 686     //
 687     // Some errors happen during the process
 688     //
 689     REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 690       EFI_ERROR_CODE | EFI_ERROR_MINOR,
 691       (EFI_PERIPHERAL_MOUSE | EFI_P_EC_INPUT_ERROR),
 692       UsbMouseAbsolutePointerDevice->DevicePath
 693       );
 694
 695     if ((Result & EFI_USB_ERR_STALL) == EFI_USB_ERR_STALL) {
 696       EndpointAddr = UsbMouseAbsolutePointerDevice->IntEndpointDescriptor.EndpointAddress;
 697
 698       UsbClearEndpointHalt (
 699         UsbIo,
 700         EndpointAddr,
 701         &UsbResult
 702         );
 703     }
 704
 705     //
 706     // Delete & Submit this interrupt again
 707     // Handler of DelayedRecoveryEvent triggered by timer will re-submit the interrupt.
 708     //
 709     UsbIo->UsbAsyncInterruptTransfer (
 710              UsbIo,
 711              UsbMouseAbsolutePointerDevice->IntEndpointDescriptor.EndpointAddress,
 712              FALSE,
 713              0,
 714              0,
 715              NULL,
 716              NULL
 717              );
 718     //
 719     // EFI_USB_INTERRUPT_DELAY is defined in USB standard for error handling.
 720     //
 721     gBS->SetTimer (
 722            UsbMouseAbsolutePointerDevice->DelayedRecoveryEvent,
 723            TimerRelative,
 724            EFI_USB_INTERRUPT_DELAY
 725            );
 726     return EFI_DEVICE_ERROR;
 727   }
 728
 729   //
 730   // If no error and no data, just return EFI_SUCCESS.
 731   //
 732   if (DataLength == 0 || Data == NULL) {
 733     return EFI_SUCCESS;
 734   }
 735
 736   UsbMouseAbsolutePointerDevice->StateChanged = TRUE;
 737
 738   //
 739   // Check mouse Data
 740   // USB HID Specification specifies following data format:
 741   // Byte    Bits    Description
 742   // 0       0       Button 1
 743   //         1       Button 2
 744   //         2       Button 3
 745   //         4 to 7  Device-specific
 746   // 1       0 to 7  X displacement
 747   // 2       0 to 7  Y displacement
 748   // 3 to n  0 to 7  Device specific (optional)
 749   //
 750   UsbMouseAbsolutePointerDevice->State.CurrentX += *((INT8 *) Data + 1);
 751   UsbMouseAbsolutePointerDevice->State.CurrentY += *((INT8 *) Data + 2);
 752
 753   if (DataLength > 3) {
 754     UsbMouseAbsolutePointerDevice->State.CurrentZ += *((INT8 *) Data + 3);
 755   }
 756   UsbMouseAbsolutePointerDevice->State.ActiveButtons = *(UINT8 *) Data & (BIT0 | BIT1);
 757
 758   return EFI_SUCCESS;
 759 }
 760
 761 /**
 762   Retrieves the current state of a pointer device.
 763
 764   @param  This                  A pointer to the EFI_ABSOLUTE_POINTER_PROTOCOL instance.
 765   @param  MouseState            A pointer to the state information on the pointer device.
 766
 767   @retval EFI_SUCCESS           The state of the pointer device was returned in State.
 768   @retval EFI_NOT_READY         The state of the pointer device has not changed since the last call to
 769                                 GetState().
 770   @retval EFI_DEVICE_ERROR      A device error occurred while attempting to retrieve the pointer device's
 771                                 current state.
 772   @retval EFI_INVALID_PARAMETER State is NULL.
 773
 774 **/
 775 EFI_STATUS
 776 EFIAPI
 777 GetMouseAbsolutePointerState (
 778   IN   EFI_ABSOLUTE_POINTER_PROTOCOL  *This,
 779   OUT  EFI_ABSOLUTE_POINTER_STATE     *State
 780   )
 781 {
 782   USB_MOUSE_ABSOLUTE_POINTER_DEV *MouseAbsolutePointerDev;
 783
 784   if (State == NULL) {
 785     return EFI_INVALID_PARAMETER;
 786   }
 787
 788   MouseAbsolutePointerDev = USB_MOUSE_ABSOLUTE_POINTER_DEV_FROM_MOUSE_PROTOCOL (This);
 789
 790   if (!MouseAbsolutePointerDev->StateChanged) {
 791     return EFI_NOT_READY;
 792   }
 793
 794   //
 795   // Retrieve mouse state from USB_MOUSE_ABSOLUTE_POINTER_DEV,
 796   // which was filled by OnMouseInterruptComplete()
 797   //
 798   CopyMem (
 799     State,
 800     &MouseAbsolutePointerDev->State,
 801     sizeof (EFI_ABSOLUTE_POINTER_STATE)
 802     );
 803
 804   //
 805   // Clear previous move state
 806   //
 807   MouseAbsolutePointerDev->State.CurrentX      = 0;
 808   MouseAbsolutePointerDev->State.CurrentY      = 0;
 809   MouseAbsolutePointerDev->State.CurrentZ      = 0;
 810   MouseAbsolutePointerDev->State.ActiveButtons = 0;
 811
 812   MouseAbsolutePointerDev->StateChanged = FALSE;
 813
 814   return EFI_SUCCESS;
 815 }
 816
 817
 818 /**
 819   Resets the pointer device hardware.
 820
 821   @param  This                  A pointer to the EFI_ABSOLUTE_POINTER_PROTOCOL instance.
 822   @param  ExtendedVerification  Indicates that the driver may perform a more exhaustive
 823                                 verification operation of the device during reset.
 824
 825   @retval EFI_SUCCESS           The device was reset.
 826   @retval EFI_DEVICE_ERROR      The device is not functioning correctly and could not be reset.
 827
 828 **/
 829 EFI_STATUS
 830 EFIAPI
 831 UsbMouseAbsolutePointerReset (
 832   IN EFI_ABSOLUTE_POINTER_PROTOCOL  *This,
 833   IN BOOLEAN                        ExtendedVerification
 834   )
 835 {
 836   USB_MOUSE_ABSOLUTE_POINTER_DEV       *UsbMouseAbsolutePointerDevice;
 837
 838   UsbMouseAbsolutePointerDevice  = USB_MOUSE_ABSOLUTE_POINTER_DEV_FROM_MOUSE_PROTOCOL (This);
 839
 840   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 841     EFI_PROGRESS_CODE,
 842     (EFI_PERIPHERAL_MOUSE | EFI_P_PC_RESET),
 843     UsbMouseAbsolutePointerDevice->DevicePath
 844     );
 845
 846   //
 847   // Clear mouse state.
 848   //
 849   ZeroMem (
 850     &UsbMouseAbsolutePointerDevice->State,
 851     sizeof (EFI_ABSOLUTE_POINTER_STATE)
 852     );
 853   UsbMouseAbsolutePointerDevice->StateChanged = FALSE;
 854
 855   return EFI_SUCCESS;
 856 }
 857
 858 /**
 859   Event notification function for EFI_ABSOLUTE_POINTER_PROTOCOL.WaitForInput event.
 860
 861   @param  Event        Event to be signaled when there's input from mouse.
 862   @param  Context      Points to USB_MOUSE_ABSOLUTE_POINTER_DEV instance.
 863
 864 **/
 865 VOID
 866 EFIAPI
 867 UsbMouseAbsolutePointerWaitForInput (
 868   IN  EFI_EVENT               Event,
 869   IN  VOID                    *Context
 870   )
 871 {
 872   USB_MOUSE_ABSOLUTE_POINTER_DEV *UsbMouseAbsolutePointerDev;
 873
 874   UsbMouseAbsolutePointerDev = (USB_MOUSE_ABSOLUTE_POINTER_DEV *) Context;
 875
 876   //
 877   // If there's input from mouse, signal the event.
 878   //
 879   if (UsbMouseAbsolutePointerDev->StateChanged) {
 880     gBS->SignalEvent (Event);
 881   }
 882 }
 883
 884 /**
 885   Handler for Delayed Recovery event.
 886
 887   This function is the handler for Delayed Recovery event triggered
 888   by timer.
 889   After a device error occurs, the event would be triggered
 890   with interval of EFI_USB_INTERRUPT_DELAY. EFI_USB_INTERRUPT_DELAY
 891   is defined in USB standard for error handling.
 892
 893   @param  Event                 The Delayed Recovery event.
 894   @param  Context               Points to the USB_MOUSE_ABSOLUTE_POINTER_DEV instance.
 895
 896 **/
 897 VOID
 898 EFIAPI
 899 USBMouseRecoveryHandler (
 900   IN    EFI_EVENT    Event,
 901   IN    VOID         *Context
 902   )
 903 {
 904   USB_MOUSE_ABSOLUTE_POINTER_DEV       *UsbMouseAbsolutePointerDev;
 905   EFI_USB_IO_PROTOCOL                  *UsbIo;
 906
 907   UsbMouseAbsolutePointerDev = (USB_MOUSE_ABSOLUTE_POINTER_DEV *) Context;
 908
 909   UsbIo       = UsbMouseAbsolutePointerDev->UsbIo;
 910
 911   //
 912   // Re-submit Asynchronous Interrupt Transfer for recovery.
 913   //
 914   UsbIo->UsbAsyncInterruptTransfer (
 915            UsbIo,
 916            UsbMouseAbsolutePointerDev->IntEndpointDescriptor.EndpointAddress,
 917            TRUE,
 918            UsbMouseAbsolutePointerDev->IntEndpointDescriptor.Interval,
 919            UsbMouseAbsolutePointerDev->IntEndpointDescriptor.MaxPacketSize,
 920            OnMouseInterruptComplete,
 921            UsbMouseAbsolutePointerDev
 922            );
 923 }