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 - 2018, 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   //
 193   // Report Status Code here since USB mouse will be detected next.
 194   //
 195   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 196     EFI_PROGRESS_CODE,
 197     (EFI_PERIPHERAL_MOUSE | EFI_P_PC_PRESENCE_DETECT),
 198     UsbMouseAbsolutePointerDevice->DevicePath
 199     );
 200
 201   //
 202   // Get interface & endpoint descriptor
 203   //
 204   UsbIo->UsbGetInterfaceDescriptor (
 205            UsbIo,
 206            &UsbMouseAbsolutePointerDevice->InterfaceDescriptor
 207            );
 208
 209   EndpointNumber = UsbMouseAbsolutePointerDevice->InterfaceDescriptor.NumEndpoints;
 210
 211   //
 212   // Traverse endpoints to find interrupt endpoint
 213   //
 214   Found = FALSE;
 215   for (Index = 0; Index < EndpointNumber; Index++) {
 216     UsbIo->UsbGetEndpointDescriptor (
 217              UsbIo,
 218              Index,
 219              &EndpointDescriptor
 220              );
 221
 222     if ((EndpointDescriptor.Attributes & (BIT0 | BIT1)) == USB_ENDPOINT_INTERRUPT) {
 223       //
 224       // We only care interrupt endpoint here
 225       //
 226       CopyMem (&UsbMouseAbsolutePointerDevice->IntEndpointDescriptor, &EndpointDescriptor, sizeof(EndpointDescriptor));
 227       Found = TRUE;
 228       break;
 229     }
 230   }
 231
 232   if (!Found) {
 233     //
 234     // Report Status Code to indicate that there is no USB mouse
 235     //
 236     REPORT_STATUS_CODE (
 237       EFI_ERROR_CODE | EFI_ERROR_MINOR,
 238       (EFI_PERIPHERAL_MOUSE | EFI_P_EC_NOT_DETECTED)
 239       );
 240     //
 241     // No interrupt endpoint found, then return unsupported.
 242     //
 243     Status = EFI_UNSUPPORTED;
 244     goto ErrorExit;
 245   }
 246
 247   //
 248   // Report Status Code here since USB mouse has be detected.
 249   //
 250   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 251     EFI_PROGRESS_CODE,
 252     (EFI_PERIPHERAL_MOUSE | EFI_P_PC_DETECTED),
 253     UsbMouseAbsolutePointerDevice->DevicePath
 254     );
 255
 256   Status = InitializeUsbMouseDevice (UsbMouseAbsolutePointerDevice);
 257   if (EFI_ERROR (Status)) {
 258     //
 259     // Fail to initialize USB mouse device.
 260     //
 261     REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 262       EFI_ERROR_CODE | EFI_ERROR_MINOR,
 263       (EFI_PERIPHERAL_MOUSE | EFI_P_EC_INTERFACE_ERROR),
 264       UsbMouseAbsolutePointerDevice->DevicePath
 265       );
 266
 267     goto ErrorExit;
 268   }
 269
 270   //
 271   // Initialize and install EFI Absolute Pointer Protocol.
 272   //
 273   UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol.GetState = GetMouseAbsolutePointerState;
 274   UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol.Reset    = UsbMouseAbsolutePointerReset;
 275   UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol.Mode    = &UsbMouseAbsolutePointerDevice->Mode;
 276
 277   Status = gBS->CreateEvent (
 278                   EVT_NOTIFY_WAIT,
 279                   TPL_NOTIFY,
 280                   UsbMouseAbsolutePointerWaitForInput,
 281                   UsbMouseAbsolutePointerDevice,
 282                   &((UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol).WaitForInput)
 283                   );
 284   if (EFI_ERROR (Status)) {
 285     goto ErrorExit;
 286   }
 287
 288   Status = gBS->InstallProtocolInterface (
 289                   &Controller,
 290                   &gEfiAbsolutePointerProtocolGuid,
 291                   EFI_NATIVE_INTERFACE,
 292                   &UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol
 293                   );
 294
 295   if (EFI_ERROR (Status)) {
 296     goto ErrorExit;
 297   }
 298
 299   //
 300   // The next step would be submitting Asynchronous Interrupt Transfer on this mouse device.
 301   // After that we will be able to get key data from it. Thus this is deemed as
 302   // the enable action of the mouse, so report status code accordingly.
 303   //
 304   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 305     EFI_PROGRESS_CODE,
 306     (EFI_PERIPHERAL_MOUSE | EFI_P_PC_ENABLE),
 307     UsbMouseAbsolutePointerDevice->DevicePath
 308     );
 309
 310   //
 311   // Submit Asynchronous Interrupt Transfer to manage this device.
 312   //
 313   EndpointAddr    = UsbMouseAbsolutePointerDevice->IntEndpointDescriptor.EndpointAddress;
 314   PollingInterval = UsbMouseAbsolutePointerDevice->IntEndpointDescriptor.Interval;
 315   PacketSize      = (UINT8) (UsbMouseAbsolutePointerDevice->IntEndpointDescriptor.MaxPacketSize);
 316
 317   Status = UsbIo->UsbAsyncInterruptTransfer (
 318                     UsbIo,
 319                     EndpointAddr,
 320                     TRUE,
 321                     PollingInterval,
 322                     PacketSize,
 323                     OnMouseInterruptComplete,
 324                     UsbMouseAbsolutePointerDevice
 325                     );
 326
 327   if (EFI_ERROR (Status)) {
 328     //
 329     // If submit error, uninstall that interface
 330     //
 331     gBS->UninstallProtocolInterface (
 332            Controller,
 333            &gEfiAbsolutePointerProtocolGuid,
 334            &UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol
 335            );
 336     goto ErrorExit;
 337   }
 338
 339   UsbMouseAbsolutePointerDevice->ControllerNameTable = NULL;
 340   AddUnicodeString2 (
 341     "eng",
 342     gUsbMouseAbsolutePointerComponentName.SupportedLanguages,
 343     &UsbMouseAbsolutePointerDevice->ControllerNameTable,
 344     L"Generic Usb Mouse Absolute Pointer",
 345       TRUE
 346       );
 347   AddUnicodeString2 (
 348     "en",
 349     gUsbMouseAbsolutePointerComponentName2.SupportedLanguages,
 350     &UsbMouseAbsolutePointerDevice->ControllerNameTable,
 351     L"Generic Usb Mouse Absolute Pointer",
 352     FALSE
 353     );
 354
 355   gBS->RestoreTPL (OldTpl);
 356   return EFI_SUCCESS;
 357
 358 //
 359 // Error handler
 360 //
 361 ErrorExit:
 362   if (EFI_ERROR (Status)) {
 363     gBS->CloseProtocol (
 364           Controller,
 365           &gEfiUsbIoProtocolGuid,
 366           This->DriverBindingHandle,
 367           Controller
 368           );
 369
 370     if (UsbMouseAbsolutePointerDevice != NULL) {
 371       if ((UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol).WaitForInput != NULL) {
 372         gBS->CloseEvent ((UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol).WaitForInput);
 373       }
 374
 375       FreePool (UsbMouseAbsolutePointerDevice);
 376       UsbMouseAbsolutePointerDevice = NULL;
 377     }
 378   }
 379
 380 ErrorExit1:
 381   gBS->RestoreTPL (OldTpl);
 382
 383   return Status;
 384 }
 385
 386
 387 /**
 388   Stop the USB mouse device handled by this driver.
 389
 390   @param  This                   The driver binding protocol.
 391   @param  Controller             The controller to release.
 392   @param  NumberOfChildren       The number of handles in ChildHandleBuffer.
 393   @param  ChildHandleBuffer      The array of child handle.
 394
 395   @retval EFI_SUCCESS            The device was stopped.
 396   @retval EFI_UNSUPPORTED        Absolute Pointer Protocol is not installed on Controller.
 397   @retval Others                 Fail to uninstall protocols attached on the device.
 398
 399 **/
 400 EFI_STATUS
 401 EFIAPI
 402 USBMouseAbsolutePointerDriverBindingStop (
 403   IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
 404   IN  EFI_HANDLE                    Controller,
 405   IN  UINTN                         NumberOfChildren,
 406   IN  EFI_HANDLE                    *ChildHandleBuffer
 407   )
 408 {
 409   EFI_STATUS                      Status;
 410   USB_MOUSE_ABSOLUTE_POINTER_DEV  *UsbMouseAbsolutePointerDevice;
 411   EFI_ABSOLUTE_POINTER_PROTOCOL   *AbsolutePointerProtocol;
 412   EFI_USB_IO_PROTOCOL             *UsbIo;
 413
 414   Status = gBS->OpenProtocol (
 415                   Controller,
 416                   &gEfiAbsolutePointerProtocolGuid,
 417                   (VOID **) &AbsolutePointerProtocol,
 418                   This->DriverBindingHandle,
 419                   Controller,
 420                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 421                   );
 422
 423   if (EFI_ERROR (Status)) {
 424     return EFI_UNSUPPORTED;
 425   }
 426
 427   UsbMouseAbsolutePointerDevice = USB_MOUSE_ABSOLUTE_POINTER_DEV_FROM_MOUSE_PROTOCOL (AbsolutePointerProtocol);
 428
 429   UsbIo = UsbMouseAbsolutePointerDevice->UsbIo;
 430
 431   //
 432   // The key data input from this device will be disabled.
 433   //
 434   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 435     EFI_PROGRESS_CODE,
 436     (EFI_PERIPHERAL_MOUSE | EFI_P_PC_DISABLE),
 437     UsbMouseAbsolutePointerDevice->DevicePath
 438     );
 439
 440   //
 441   // Delete the Asynchronous Interrupt Transfer from this device
 442   //
 443   UsbIo->UsbAsyncInterruptTransfer (
 444            UsbIo,
 445            UsbMouseAbsolutePointerDevice->IntEndpointDescriptor.EndpointAddress,
 446            FALSE,
 447            UsbMouseAbsolutePointerDevice->IntEndpointDescriptor.Interval,
 448            0,
 449            NULL,
 450            NULL
 451            );
 452
 453   Status = gBS->UninstallProtocolInterface (
 454                   Controller,
 455                   &gEfiAbsolutePointerProtocolGuid,
 456                   &UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol
 457                   );
 458   if (EFI_ERROR (Status)) {
 459     return Status;
 460   }
 461
 462   gBS->CloseProtocol (
 463          Controller,
 464          &gEfiUsbIoProtocolGuid,
 465          This->DriverBindingHandle,
 466          Controller
 467          );
 468
 469   //
 470   // Free all resources.
 471   //
 472   gBS->CloseEvent (UsbMouseAbsolutePointerDevice->AbsolutePointerProtocol.WaitForInput);
 473
 474   if (UsbMouseAbsolutePointerDevice->DelayedRecoveryEvent != NULL) {
 475     gBS->CloseEvent (UsbMouseAbsolutePointerDevice->DelayedRecoveryEvent);
 476     UsbMouseAbsolutePointerDevice->DelayedRecoveryEvent = NULL;
 477   }
 478
 479   if (UsbMouseAbsolutePointerDevice->ControllerNameTable != NULL) {
 480     FreeUnicodeStringTable (UsbMouseAbsolutePointerDevice->ControllerNameTable);
 481   }
 482
 483   FreePool (UsbMouseAbsolutePointerDevice);
 484
 485   return EFI_SUCCESS;
 486
 487 }
 488
 489
 490 /**
 491   Uses USB I/O to check whether the device is a USB mouse device.
 492
 493   @param  UsbIo    Pointer to a USB I/O protocol instance.
 494
 495   @retval TRUE     Device is a USB mouse device.
 496   @retval FALSE    Device is a not USB mouse device.
 497
 498 **/
 499 BOOLEAN
 500 IsUsbMouse (
 501   IN  EFI_USB_IO_PROTOCOL     *UsbIo
 502   )
 503 {
 504   EFI_STATUS                    Status;
 505   EFI_USB_INTERFACE_DESCRIPTOR  InterfaceDescriptor;
 506
 507   //
 508   // Get the default interface descriptor
 509   //
 510   Status = UsbIo->UsbGetInterfaceDescriptor (
 511                     UsbIo,
 512                     &InterfaceDescriptor
 513                     );
 514
 515   if (EFI_ERROR (Status)) {
 516     return FALSE;
 517   }
 518
 519   if ((InterfaceDescriptor.InterfaceClass == CLASS_HID) &&
 520       (InterfaceDescriptor.InterfaceSubClass == SUBCLASS_BOOT) &&
 521       (InterfaceDescriptor.InterfaceProtocol == PROTOCOL_MOUSE)
 522       ) {
 523     return TRUE;
 524   }
 525
 526   return FALSE;
 527 }
 528
 529
 530 /**
 531   Initialize the USB mouse device.
 532
 533   This function retrieves and parses HID report descriptor, and
 534   initializes state of USB_MOUSE_ABSOLUTE_POINTER_DEV. Then it sets indefinite idle
 535   rate for the device. Finally it creates event for delayed recovery,
 536   which deals with device error.
 537
 538   @param  UsbMouseAbsolutePointerDev   Device instance to be initialized.
 539
 540   @retval EFI_SUCCESS                  USB mouse device successfully initialized.
 541   @retval EFI_UNSUPPORTED              HID descriptor type is not report descriptor.
 542   @retval Other                        USB mouse device was not initialized successfully.
 543
 544 **/
 545 EFI_STATUS
 546 InitializeUsbMouseDevice (
 547   IN  USB_MOUSE_ABSOLUTE_POINTER_DEV           *UsbMouseAbsolutePointerDev
 548   )
 549 {
 550   EFI_USB_IO_PROTOCOL       *UsbIo;
 551   UINT8                     Protocol;
 552   EFI_STATUS                Status;
 553   EFI_USB_HID_DESCRIPTOR    *MouseHidDesc;
 554   UINT8                     *ReportDesc;
 555   EFI_USB_CONFIG_DESCRIPTOR ConfigDesc;
 556   VOID                      *Buf;
 557   UINT32                    TransferResult;
 558   UINT16                    Total;
 559   USB_DESC_HEAD             *Head;
 560   BOOLEAN                   Start;
 561
 562   UsbIo = UsbMouseAbsolutePointerDev->UsbIo;
 563
 564   //
 565   // Get the current configuration descriptor. Note that it doesn't include other descriptors.
 566   //
 567   Status = UsbIo->UsbGetConfigDescriptor (
 568                     UsbIo,
 569                     &ConfigDesc
 570                     );
 571   if (EFI_ERROR (Status)) {
 572     return Status;
 573   }
 574
 575   //
 576   // By issuing Get_Descriptor(Configuration) request with total length, we get the Configuration descriptor,
 577   // all Interface descriptors, all Endpoint descriptors, and the HID descriptor for each interface.
 578   //
 579   Buf = AllocateZeroPool (ConfigDesc.TotalLength);
 580   if (Buf == NULL) {
 581     return EFI_OUT_OF_RESOURCES;
 582   }
 583
 584   Status = UsbGetDescriptor (
 585              UsbIo,
 586              (UINT16)((USB_DESC_TYPE_CONFIG << 8) | (ConfigDesc.ConfigurationValue - 1)),
 587              0,
 588              ConfigDesc.TotalLength,
 589              Buf,
 590              &TransferResult
 591              );
 592   if (EFI_ERROR (Status)) {
 593     FreePool (Buf);
 594     return Status;
 595   }
 596
 597   Total = 0;
 598   Start = FALSE;
 599   Head  = (USB_DESC_HEAD *)Buf;
 600   MouseHidDesc = NULL;
 601
 602   //
 603   // Get HID descriptor from the receipt of Get_Descriptor(Configuration) request.
 604   // This algorithm is based on the fact that the HID descriptor shall be interleaved
 605   // between the interface and endpoint descriptors for HID interfaces.
 606   //
 607   while (Total < ConfigDesc.TotalLength) {
 608     if (Head->Type == USB_DESC_TYPE_INTERFACE) {
 609       if ((((USB_INTERFACE_DESCRIPTOR *)Head)->InterfaceNumber == UsbMouseAbsolutePointerDev->InterfaceDescriptor.InterfaceNumber) &&
 610         (((USB_INTERFACE_DESCRIPTOR *)Head)->AlternateSetting == UsbMouseAbsolutePointerDev->InterfaceDescriptor.AlternateSetting)) {
 611         Start = TRUE;
 612       }
 613     }
 614     if (Start && (Head->Type == USB_DESC_TYPE_ENDPOINT)) {
 615       break;
 616     }
 617     if (Start && (Head->Type == USB_DESC_TYPE_HID)) {
 618       MouseHidDesc = (EFI_USB_HID_DESCRIPTOR *)Head;
 619       break;
 620     }
 621     Total = Total + (UINT16)Head->Len;
 622     Head  = (USB_DESC_HEAD*)((UINT8 *)Buf + Total);
 623   }
 624
 625   if (MouseHidDesc == NULL) {
 626     FreePool (Buf);
 627     return EFI_UNSUPPORTED;
 628   }
 629
 630   //
 631   // Get report descriptor
 632   //
 633   if (MouseHidDesc->HidClassDesc[0].DescriptorType != USB_DESC_TYPE_REPORT) {
 634     FreePool (Buf);
 635     return EFI_UNSUPPORTED;
 636   }
 637
 638   ReportDesc = AllocateZeroPool (MouseHidDesc->HidClassDesc[0].DescriptorLength);
 639   ASSERT (ReportDesc != NULL);
 640
 641   Status = UsbGetReportDescriptor (
 642              UsbIo,
 643              UsbMouseAbsolutePointerDev->InterfaceDescriptor.InterfaceNumber,
 644              MouseHidDesc->HidClassDesc[0].DescriptorLength,
 645              ReportDesc
 646              );
 647
 648   if (EFI_ERROR (Status)) {
 649     FreePool (Buf);
 650     FreePool (ReportDesc);
 651     return Status;
 652   }
 653
 654   //
 655   // Parse report descriptor
 656   //
 657   Status = ParseMouseReportDescriptor (
 658              UsbMouseAbsolutePointerDev,
 659              ReportDesc,
 660              MouseHidDesc->HidClassDesc[0].DescriptorLength
 661              );
 662
 663   if (EFI_ERROR (Status)) {
 664     FreePool (Buf);
 665     FreePool (ReportDesc);
 666     return Status;
 667   }
 668
 669   UsbMouseAbsolutePointerDev->Mode.AbsoluteMaxX = 1024;
 670   UsbMouseAbsolutePointerDev->Mode.AbsoluteMaxY = 1024;
 671   UsbMouseAbsolutePointerDev->Mode.AbsoluteMaxZ = 0;
 672   UsbMouseAbsolutePointerDev->Mode.AbsoluteMinX = 0;
 673   UsbMouseAbsolutePointerDev->Mode.AbsoluteMinY = 0;
 674   UsbMouseAbsolutePointerDev->Mode.AbsoluteMinZ = 0;
 675   UsbMouseAbsolutePointerDev->Mode.Attributes   = 0x3;
 676
 677   //
 678   // Let the cursor's starting position is in the center of the screen.
 679   //
 680   UsbMouseAbsolutePointerDev->State.CurrentX =
 681     DivU64x32 (UsbMouseAbsolutePointerDev->Mode.AbsoluteMaxX + UsbMouseAbsolutePointerDev->Mode.AbsoluteMinX, 2);
 682   UsbMouseAbsolutePointerDev->State.CurrentY =
 683     DivU64x32 (UsbMouseAbsolutePointerDev->Mode.AbsoluteMaxY + UsbMouseAbsolutePointerDev->Mode.AbsoluteMinY, 2);
 684
 685   //
 686   // Set boot protocol for the USB mouse.
 687   // This driver only supports boot protocol.
 688   //
 689   UsbGetProtocolRequest (
 690     UsbIo,
 691     UsbMouseAbsolutePointerDev->InterfaceDescriptor.InterfaceNumber,
 692     &Protocol
 693     );
 694   if (Protocol != BOOT_PROTOCOL) {
 695     Status = UsbSetProtocolRequest (
 696                UsbIo,
 697                UsbMouseAbsolutePointerDev->InterfaceDescriptor.InterfaceNumber,
 698                BOOT_PROTOCOL
 699                );
 700
 701     if (EFI_ERROR (Status)) {
 702       FreePool (Buf);
 703       FreePool (ReportDesc);
 704       return Status;
 705     }
 706   }
 707
 708   FreePool (Buf);
 709   FreePool (ReportDesc);
 710
 711   //
 712   // Create event for delayed recovery, which deals with device error.
 713   //
 714   if (UsbMouseAbsolutePointerDev->DelayedRecoveryEvent != NULL) {
 715     gBS->CloseEvent (UsbMouseAbsolutePointerDev->DelayedRecoveryEvent);
 716     UsbMouseAbsolutePointerDev->DelayedRecoveryEvent = 0;
 717   }
 718
 719   gBS->CreateEvent (
 720          EVT_TIMER | EVT_NOTIFY_SIGNAL,
 721          TPL_NOTIFY,
 722          USBMouseRecoveryHandler,
 723          UsbMouseAbsolutePointerDev,
 724          &UsbMouseAbsolutePointerDev->DelayedRecoveryEvent
 725          );
 726
 727   return EFI_SUCCESS;
 728 }
 729
 730
 731 /**
 732   Handler function for USB mouse's asynchronous interrupt transfer.
 733
 734   This function is the handler function for USB mouse's asynchronous interrupt transfer
 735   to manage the mouse. It parses data returned from asynchronous interrupt transfer, and
 736   get button and movement state.
 737
 738   @param  Data             A pointer to a buffer that is filled with key data which is
 739                            retrieved via asynchronous interrupt transfer.
 740   @param  DataLength       Indicates the size of the data buffer.
 741   @param  Context          Pointing to USB_KB_DEV instance.
 742   @param  Result           Indicates the result of the asynchronous interrupt transfer.
 743
 744   @retval EFI_SUCCESS      Asynchronous interrupt transfer is handled successfully.
 745   @retval EFI_DEVICE_ERROR Hardware error occurs.
 746
 747 **/
 748 EFI_STATUS
 749 EFIAPI
 750 OnMouseInterruptComplete (
 751   IN  VOID        *Data,
 752   IN  UINTN       DataLength,
 753   IN  VOID        *Context,
 754   IN  UINT32      Result
 755   )
 756 {
 757   USB_MOUSE_ABSOLUTE_POINTER_DEV   *UsbMouseAbsolutePointerDevice;
 758   EFI_USB_IO_PROTOCOL              *UsbIo;
 759   UINT8                            EndpointAddr;
 760   UINT32                           UsbResult;
 761
 762   UsbMouseAbsolutePointerDevice  = (USB_MOUSE_ABSOLUTE_POINTER_DEV *) Context;
 763   UsbIo                          = UsbMouseAbsolutePointerDevice->UsbIo;
 764
 765   if (Result != EFI_USB_NOERROR) {
 766     //
 767     // Some errors happen during the process
 768     //
 769     REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 770       EFI_ERROR_CODE | EFI_ERROR_MINOR,
 771       (EFI_PERIPHERAL_MOUSE | EFI_P_EC_INPUT_ERROR),
 772       UsbMouseAbsolutePointerDevice->DevicePath
 773       );
 774
 775     if ((Result & EFI_USB_ERR_STALL) == EFI_USB_ERR_STALL) {
 776       EndpointAddr = UsbMouseAbsolutePointerDevice->IntEndpointDescriptor.EndpointAddress;
 777
 778       UsbClearEndpointHalt (
 779         UsbIo,
 780         EndpointAddr,
 781         &UsbResult
 782         );
 783     }
 784
 785     //
 786     // Delete & Submit this interrupt again
 787     // Handler of DelayedRecoveryEvent triggered by timer will re-submit the interrupt.
 788     //
 789     UsbIo->UsbAsyncInterruptTransfer (
 790              UsbIo,
 791              UsbMouseAbsolutePointerDevice->IntEndpointDescriptor.EndpointAddress,
 792              FALSE,
 793              0,
 794              0,
 795              NULL,
 796              NULL
 797              );
 798     //
 799     // EFI_USB_INTERRUPT_DELAY is defined in USB standard for error handling.
 800     //
 801     gBS->SetTimer (
 802            UsbMouseAbsolutePointerDevice->DelayedRecoveryEvent,
 803            TimerRelative,
 804            EFI_USB_INTERRUPT_DELAY
 805            );
 806     return EFI_DEVICE_ERROR;
 807   }
 808
 809   //
 810   // If no error and no data, just return EFI_SUCCESS.
 811   //
 812   if (DataLength == 0 || Data == NULL) {
 813     return EFI_SUCCESS;
 814   }
 815
 816   //
 817   // Check mouse Data
 818   // USB HID Specification specifies following data format:
 819   // Byte    Bits    Description
 820   // 0       0       Button 1
 821   //         1       Button 2
 822   //         2       Button 3
 823   //         4 to 7  Device-specific
 824   // 1       0 to 7  X displacement
 825   // 2       0 to 7  Y displacement
 826   // 3 to n  0 to 7  Device specific (optional)
 827   //
 828   if (DataLength < 3) {
 829     return EFI_DEVICE_ERROR;
 830   }
 831
 832   UsbMouseAbsolutePointerDevice->StateChanged = TRUE;
 833
 834   UsbMouseAbsolutePointerDevice->State.ActiveButtons = *(UINT8 *) Data & (BIT0 | BIT1 | BIT2);
 835
 836   UsbMouseAbsolutePointerDevice->State.CurrentX =
 837     MIN (
 838       MAX ((INT64) UsbMouseAbsolutePointerDevice->State.CurrentX + *((INT8 *) Data + 1),
 839            (INT64) UsbMouseAbsolutePointerDevice->Mode.AbsoluteMinX),
 840       (INT64) UsbMouseAbsolutePointerDevice->Mode.AbsoluteMaxX
 841       );
 842   UsbMouseAbsolutePointerDevice->State.CurrentY =
 843     MIN (
 844       MAX ((INT64) UsbMouseAbsolutePointerDevice->State.CurrentY + *((INT8 *) Data + 2),
 845            (INT64) UsbMouseAbsolutePointerDevice->Mode.AbsoluteMinY),
 846       (INT64) UsbMouseAbsolutePointerDevice->Mode.AbsoluteMaxY
 847       );
 848   if (DataLength > 3) {
 849     UsbMouseAbsolutePointerDevice->State.CurrentZ =
 850       MIN (
 851         MAX ((INT64) UsbMouseAbsolutePointerDevice->State.CurrentZ + *((INT8 *) Data + 1),
 852              (INT64) UsbMouseAbsolutePointerDevice->Mode.AbsoluteMinZ),
 853         (INT64) UsbMouseAbsolutePointerDevice->Mode.AbsoluteMaxZ
 854         );
 855   }
 856
 857   return EFI_SUCCESS;
 858 }
 859
 860 /**
 861   Retrieves the current state of a pointer device.
 862
 863   @param  This                  A pointer to the EFI_ABSOLUTE_POINTER_PROTOCOL instance.
 864   @param  MouseState            A pointer to the state information on the pointer device.
 865
 866   @retval EFI_SUCCESS           The state of the pointer device was returned in State.
 867   @retval EFI_NOT_READY         The state of the pointer device has not changed since the last call to
 868                                 GetState().
 869   @retval EFI_DEVICE_ERROR      A device error occurred while attempting to retrieve the pointer device's
 870                                 current state.
 871   @retval EFI_INVALID_PARAMETER State is NULL.
 872
 873 **/
 874 EFI_STATUS
 875 EFIAPI
 876 GetMouseAbsolutePointerState (
 877   IN   EFI_ABSOLUTE_POINTER_PROTOCOL  *This,
 878   OUT  EFI_ABSOLUTE_POINTER_STATE     *State
 879   )
 880 {
 881   USB_MOUSE_ABSOLUTE_POINTER_DEV *MouseAbsolutePointerDev;
 882
 883   if (State == NULL) {
 884     return EFI_INVALID_PARAMETER;
 885   }
 886
 887   MouseAbsolutePointerDev = USB_MOUSE_ABSOLUTE_POINTER_DEV_FROM_MOUSE_PROTOCOL (This);
 888
 889   if (!MouseAbsolutePointerDev->StateChanged) {
 890     return EFI_NOT_READY;
 891   }
 892
 893   //
 894   // Retrieve mouse state from USB_MOUSE_ABSOLUTE_POINTER_DEV,
 895   // which was filled by OnMouseInterruptComplete()
 896   //
 897   CopyMem (
 898     State,
 899     &MouseAbsolutePointerDev->State,
 900     sizeof (EFI_ABSOLUTE_POINTER_STATE)
 901     );
 902
 903   MouseAbsolutePointerDev->StateChanged = FALSE;
 904
 905   return EFI_SUCCESS;
 906 }
 907
 908
 909 /**
 910   Resets the pointer device hardware.
 911
 912   @param  This                  A pointer to the EFI_ABSOLUTE_POINTER_PROTOCOL instance.
 913   @param  ExtendedVerification  Indicates that the driver may perform a more exhaustive
 914                                 verification operation of the device during reset.
 915
 916   @retval EFI_SUCCESS           The device was reset.
 917   @retval EFI_DEVICE_ERROR      The device is not functioning correctly and could not be reset.
 918
 919 **/
 920 EFI_STATUS
 921 EFIAPI
 922 UsbMouseAbsolutePointerReset (
 923   IN EFI_ABSOLUTE_POINTER_PROTOCOL  *This,
 924   IN BOOLEAN                        ExtendedVerification
 925   )
 926 {
 927   USB_MOUSE_ABSOLUTE_POINTER_DEV       *UsbMouseAbsolutePointerDevice;
 928
 929   UsbMouseAbsolutePointerDevice  = USB_MOUSE_ABSOLUTE_POINTER_DEV_FROM_MOUSE_PROTOCOL (This);
 930
 931   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 932     EFI_PROGRESS_CODE,
 933     (EFI_PERIPHERAL_MOUSE | EFI_P_PC_RESET),
 934     UsbMouseAbsolutePointerDevice->DevicePath
 935     );
 936
 937   //
 938   // Clear mouse state.
 939   //
 940   ZeroMem (
 941     &UsbMouseAbsolutePointerDevice->State,
 942     sizeof (EFI_ABSOLUTE_POINTER_STATE)
 943     );
 944
 945   //
 946   // Let the cursor's starting position is in the center of the screen.
 947   //
 948   UsbMouseAbsolutePointerDevice->State.CurrentX =
 949     DivU64x32 (UsbMouseAbsolutePointerDevice->Mode.AbsoluteMaxX + UsbMouseAbsolutePointerDevice->Mode.AbsoluteMinX, 2);
 950   UsbMouseAbsolutePointerDevice->State.CurrentY =
 951     DivU64x32 (UsbMouseAbsolutePointerDevice->Mode.AbsoluteMaxY + UsbMouseAbsolutePointerDevice->Mode.AbsoluteMinY, 2);
 952
 953   UsbMouseAbsolutePointerDevice->StateChanged = FALSE;
 954
 955   return EFI_SUCCESS;
 956 }
 957
 958 /**
 959   Event notification function for EFI_ABSOLUTE_POINTER_PROTOCOL.WaitForInput event.
 960
 961   @param  Event        Event to be signaled when there's input from mouse.
 962   @param  Context      Points to USB_MOUSE_ABSOLUTE_POINTER_DEV instance.
 963
 964 **/
 965 VOID
 966 EFIAPI
 967 UsbMouseAbsolutePointerWaitForInput (
 968   IN  EFI_EVENT               Event,
 969   IN  VOID                    *Context
 970   )
 971 {
 972   USB_MOUSE_ABSOLUTE_POINTER_DEV *UsbMouseAbsolutePointerDev;
 973
 974   UsbMouseAbsolutePointerDev = (USB_MOUSE_ABSOLUTE_POINTER_DEV *) Context;
 975
 976   //
 977   // If there's input from mouse, signal the event.
 978   //
 979   if (UsbMouseAbsolutePointerDev->StateChanged) {
 980     gBS->SignalEvent (Event);
 981   }
 982 }
 983
 984 /**
 985   Handler for Delayed Recovery event.
 986
 987   This function is the handler for Delayed Recovery event triggered
 988   by timer.
 989   After a device error occurs, the event would be triggered
 990   with interval of EFI_USB_INTERRUPT_DELAY. EFI_USB_INTERRUPT_DELAY
 991   is defined in USB standard for error handling.
 992
 993   @param  Event                 The Delayed Recovery event.
 994   @param  Context               Points to the USB_MOUSE_ABSOLUTE_POINTER_DEV instance.
 995
 996 **/
 997 VOID
 998 EFIAPI
 999 USBMouseRecoveryHandler (
1000   IN    EFI_EVENT    Event,
1001   IN    VOID         *Context
1002   )
1003 {
1004   USB_MOUSE_ABSOLUTE_POINTER_DEV       *UsbMouseAbsolutePointerDev;
1005   EFI_USB_IO_PROTOCOL                  *UsbIo;
1006
1007   UsbMouseAbsolutePointerDev = (USB_MOUSE_ABSOLUTE_POINTER_DEV *) Context;
1008
1009   UsbIo       = UsbMouseAbsolutePointerDev->UsbIo;
1010
1011   //
1012   // Re-submit Asynchronous Interrupt Transfer for recovery.
1013   //
1014   UsbIo->UsbAsyncInterruptTransfer (
1015            UsbIo,
1016            UsbMouseAbsolutePointerDev->IntEndpointDescriptor.EndpointAddress,
1017            TRUE,
1018            UsbMouseAbsolutePointerDev->IntEndpointDescriptor.Interval,
1019            UsbMouseAbsolutePointerDev->IntEndpointDescriptor.MaxPacketSize,
1020            OnMouseInterruptComplete,
1021            UsbMouseAbsolutePointerDev
1022            );
1023 }