1 /** @file 2 USB Mouse Driver that manages USB mouse and produces Absolute Pointer Protocol. 3 4 Copyright (c) 2004 - 2012, 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 // Set boot protocol for the USB mouse. 679 // This driver only supports boot protocol. 680 // 681 UsbGetProtocolRequest ( 682 UsbIo, 683 UsbMouseAbsolutePointerDev->InterfaceDescriptor.InterfaceNumber, 684 &Protocol 685 ); 686 if (Protocol != BOOT_PROTOCOL) { 687 Status = UsbSetProtocolRequest ( 688 UsbIo, 689 UsbMouseAbsolutePointerDev->InterfaceDescriptor.InterfaceNumber, 690 BOOT_PROTOCOL 691 ); 692 693 if (EFI_ERROR (Status)) { 694 FreePool (Buf); 695 FreePool (ReportDesc); 696 return Status; 697 } 698 } 699 700 FreePool (Buf); 701 FreePool (ReportDesc); 702 703 // 704 // Create event for delayed recovery, which deals with device error. 705 // 706 if (UsbMouseAbsolutePointerDev->DelayedRecoveryEvent != NULL) { 707 gBS->CloseEvent (UsbMouseAbsolutePointerDev->DelayedRecoveryEvent); 708 UsbMouseAbsolutePointerDev->DelayedRecoveryEvent = 0; 709 } 710 711 gBS->CreateEvent ( 712 EVT_TIMER | EVT_NOTIFY_SIGNAL, 713 TPL_NOTIFY, 714 USBMouseRecoveryHandler, 715 UsbMouseAbsolutePointerDev, 716 &UsbMouseAbsolutePointerDev->DelayedRecoveryEvent 717 ); 718 719 return EFI_SUCCESS; 720 } 721 722 723 /** 724 Handler function for USB mouse's asynchronous interrupt transfer. 725 726 This function is the handler function for USB mouse's asynchronous interrupt transfer 727 to manage the mouse. It parses data returned from asynchronous interrupt transfer, and 728 get button and movement state. 729 730 @param Data A pointer to a buffer that is filled with key data which is 731 retrieved via asynchronous interrupt transfer. 732 @param DataLength Indicates the size of the data buffer. 733 @param Context Pointing to USB_KB_DEV instance. 734 @param Result Indicates the result of the asynchronous interrupt transfer. 735 736 @retval EFI_SUCCESS Asynchronous interrupt transfer is handled successfully. 737 @retval EFI_DEVICE_ERROR Hardware error occurs. 738 739 **/ 740 EFI_STATUS 741 EFIAPI 742 OnMouseInterruptComplete ( 743 IN VOID *Data, 744 IN UINTN DataLength, 745 IN VOID *Context, 746 IN UINT32 Result 747 ) 748 { 749 USB_MOUSE_ABSOLUTE_POINTER_DEV *UsbMouseAbsolutePointerDevice; 750 EFI_USB_IO_PROTOCOL *UsbIo; 751 UINT8 EndpointAddr; 752 UINT32 UsbResult; 753 754 UsbMouseAbsolutePointerDevice = (USB_MOUSE_ABSOLUTE_POINTER_DEV *) Context; 755 UsbIo = UsbMouseAbsolutePointerDevice->UsbIo; 756 757 if (Result != EFI_USB_NOERROR) { 758 // 759 // Some errors happen during the process 760 // 761 REPORT_STATUS_CODE_WITH_DEVICE_PATH ( 762 EFI_ERROR_CODE | EFI_ERROR_MINOR, 763 (EFI_PERIPHERAL_MOUSE | EFI_P_EC_INPUT_ERROR), 764 UsbMouseAbsolutePointerDevice->DevicePath 765 ); 766 767 if ((Result & EFI_USB_ERR_STALL) == EFI_USB_ERR_STALL) { 768 EndpointAddr = UsbMouseAbsolutePointerDevice->IntEndpointDescriptor.EndpointAddress; 769 770 UsbClearEndpointHalt ( 771 UsbIo, 772 EndpointAddr, 773 &UsbResult 774 ); 775 } 776 777 // 778 // Delete & Submit this interrupt again 779 // Handler of DelayedRecoveryEvent triggered by timer will re-submit the interrupt. 780 // 781 UsbIo->UsbAsyncInterruptTransfer ( 782 UsbIo, 783 UsbMouseAbsolutePointerDevice->IntEndpointDescriptor.EndpointAddress, 784 FALSE, 785 0, 786 0, 787 NULL, 788 NULL 789 ); 790 // 791 // EFI_USB_INTERRUPT_DELAY is defined in USB standard for error handling. 792 // 793 gBS->SetTimer ( 794 UsbMouseAbsolutePointerDevice->DelayedRecoveryEvent, 795 TimerRelative, 796 EFI_USB_INTERRUPT_DELAY 797 ); 798 return EFI_DEVICE_ERROR; 799 } 800 801 // 802 // If no error and no data, just return EFI_SUCCESS. 803 // 804 if (DataLength == 0 || Data == NULL) { 805 return EFI_SUCCESS; 806 } 807 808 UsbMouseAbsolutePointerDevice->StateChanged = TRUE; 809 810 // 811 // Check mouse Data 812 // USB HID Specification specifies following data format: 813 // Byte Bits Description 814 // 0 0 Button 1 815 // 1 Button 2 816 // 2 Button 3 817 // 4 to 7 Device-specific 818 // 1 0 to 7 X displacement 819 // 2 0 to 7 Y displacement 820 // 3 to n 0 to 7 Device specific (optional) 821 // 822 UsbMouseAbsolutePointerDevice->State.CurrentX += *((INT8 *) Data + 1); 823 UsbMouseAbsolutePointerDevice->State.CurrentY += *((INT8 *) Data + 2); 824 825 if (DataLength > 3) { 826 UsbMouseAbsolutePointerDevice->State.CurrentZ += *((INT8 *) Data + 3); 827 } 828 UsbMouseAbsolutePointerDevice->State.ActiveButtons = *(UINT8 *) Data & (BIT0 | BIT1); 829 830 return EFI_SUCCESS; 831 } 832 833 /** 834 Retrieves the current state of a pointer device. 835 836 @param This A pointer to the EFI_ABSOLUTE_POINTER_PROTOCOL instance. 837 @param MouseState A pointer to the state information on the pointer device. 838 839 @retval EFI_SUCCESS The state of the pointer device was returned in State. 840 @retval EFI_NOT_READY The state of the pointer device has not changed since the last call to 841 GetState(). 842 @retval EFI_DEVICE_ERROR A device error occurred while attempting to retrieve the pointer device's 843 current state. 844 @retval EFI_INVALID_PARAMETER State is NULL. 845 846 **/ 847 EFI_STATUS 848 EFIAPI 849 GetMouseAbsolutePointerState ( 850 IN EFI_ABSOLUTE_POINTER_PROTOCOL *This, 851 OUT EFI_ABSOLUTE_POINTER_STATE *State 852 ) 853 { 854 USB_MOUSE_ABSOLUTE_POINTER_DEV *MouseAbsolutePointerDev; 855 856 if (State == NULL) { 857 return EFI_INVALID_PARAMETER; 858 } 859 860 MouseAbsolutePointerDev = USB_MOUSE_ABSOLUTE_POINTER_DEV_FROM_MOUSE_PROTOCOL (This); 861 862 if (!MouseAbsolutePointerDev->StateChanged) { 863 return EFI_NOT_READY; 864 } 865 866 // 867 // Retrieve mouse state from USB_MOUSE_ABSOLUTE_POINTER_DEV, 868 // which was filled by OnMouseInterruptComplete() 869 // 870 CopyMem ( 871 State, 872 &MouseAbsolutePointerDev->State, 873 sizeof (EFI_ABSOLUTE_POINTER_STATE) 874 ); 875 876 // 877 // Clear previous move state 878 // 879 MouseAbsolutePointerDev->State.CurrentX = 0; 880 MouseAbsolutePointerDev->State.CurrentY = 0; 881 MouseAbsolutePointerDev->State.CurrentZ = 0; 882 MouseAbsolutePointerDev->State.ActiveButtons = 0; 883 884 MouseAbsolutePointerDev->StateChanged = FALSE; 885 886 return EFI_SUCCESS; 887 } 888 889 890 /** 891 Resets the pointer device hardware. 892 893 @param This A pointer to the EFI_ABSOLUTE_POINTER_PROTOCOL instance. 894 @param ExtendedVerification Indicates that the driver may perform a more exhaustive 895 verification operation of the device during reset. 896 897 @retval EFI_SUCCESS The device was reset. 898 @retval EFI_DEVICE_ERROR The device is not functioning correctly and could not be reset. 899 900 **/ 901 EFI_STATUS 902 EFIAPI 903 UsbMouseAbsolutePointerReset ( 904 IN EFI_ABSOLUTE_POINTER_PROTOCOL *This, 905 IN BOOLEAN ExtendedVerification 906 ) 907 { 908 USB_MOUSE_ABSOLUTE_POINTER_DEV *UsbMouseAbsolutePointerDevice; 909 910 UsbMouseAbsolutePointerDevice = USB_MOUSE_ABSOLUTE_POINTER_DEV_FROM_MOUSE_PROTOCOL (This); 911 912 REPORT_STATUS_CODE_WITH_DEVICE_PATH ( 913 EFI_PROGRESS_CODE, 914 (EFI_PERIPHERAL_MOUSE | EFI_P_PC_RESET), 915 UsbMouseAbsolutePointerDevice->DevicePath 916 ); 917 918 // 919 // Clear mouse state. 920 // 921 ZeroMem ( 922 &UsbMouseAbsolutePointerDevice->State, 923 sizeof (EFI_ABSOLUTE_POINTER_STATE) 924 ); 925 UsbMouseAbsolutePointerDevice->StateChanged = FALSE; 926 927 return EFI_SUCCESS; 928 } 929 930 /** 931 Event notification function for EFI_ABSOLUTE_POINTER_PROTOCOL.WaitForInput event. 932 933 @param Event Event to be signaled when there's input from mouse. 934 @param Context Points to USB_MOUSE_ABSOLUTE_POINTER_DEV instance. 935 936 **/ 937 VOID 938 EFIAPI 939 UsbMouseAbsolutePointerWaitForInput ( 940 IN EFI_EVENT Event, 941 IN VOID *Context 942 ) 943 { 944 USB_MOUSE_ABSOLUTE_POINTER_DEV *UsbMouseAbsolutePointerDev; 945 946 UsbMouseAbsolutePointerDev = (USB_MOUSE_ABSOLUTE_POINTER_DEV *) Context; 947 948 // 949 // If there's input from mouse, signal the event. 950 // 951 if (UsbMouseAbsolutePointerDev->StateChanged) { 952 gBS->SignalEvent (Event); 953 } 954 } 955 956 /** 957 Handler for Delayed Recovery event. 958 959 This function is the handler for Delayed Recovery event triggered 960 by timer. 961 After a device error occurs, the event would be triggered 962 with interval of EFI_USB_INTERRUPT_DELAY. EFI_USB_INTERRUPT_DELAY 963 is defined in USB standard for error handling. 964 965 @param Event The Delayed Recovery event. 966 @param Context Points to the USB_MOUSE_ABSOLUTE_POINTER_DEV instance. 967 968 **/ 969 VOID 970 EFIAPI 971 USBMouseRecoveryHandler ( 972 IN EFI_EVENT Event, 973 IN VOID *Context 974 ) 975 { 976 USB_MOUSE_ABSOLUTE_POINTER_DEV *UsbMouseAbsolutePointerDev; 977 EFI_USB_IO_PROTOCOL *UsbIo; 978 979 UsbMouseAbsolutePointerDev = (USB_MOUSE_ABSOLUTE_POINTER_DEV *) Context; 980 981 UsbIo = UsbMouseAbsolutePointerDev->UsbIo; 982 983 // 984 // Re-submit Asynchronous Interrupt Transfer for recovery. 985 // 986 UsbIo->UsbAsyncInterruptTransfer ( 987 UsbIo, 988 UsbMouseAbsolutePointerDev->IntEndpointDescriptor.EndpointAddress, 989 TRUE, 990 UsbMouseAbsolutePointerDev->IntEndpointDescriptor.Interval, 991 UsbMouseAbsolutePointerDev->IntEndpointDescriptor.MaxPacketSize, 992 OnMouseInterruptComplete, 993 UsbMouseAbsolutePointerDev 994 ); 995 } 996