1 /** @file 2 3 PS/2 Keyboard driver. Routines that interacts with callers, 4 conforming to EFI driver model 5 6 Copyright (c) 2006 - 2016, Intel Corporation. All rights reserved.<BR> 7 This program and the accompanying materials 8 are licensed and made available under the terms and conditions of the BSD License 9 which accompanies this distribution. The full text of the license may be found at 10 http://opensource.org/licenses/bsd-license.php 11 12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 14 15 **/ 16 17 #include "Ps2Keyboard.h" 18 19 // 20 // Function prototypes 21 // 22 /** 23 Test controller is a keyboard Controller. 24 25 @param This Pointer of EFI_DRIVER_BINDING_PROTOCOL 26 @param Controller driver's controller 27 @param RemainingDevicePath children device path 28 29 @retval EFI_UNSUPPORTED controller is not floppy disk 30 @retval EFI_SUCCESS controller is floppy disk 31 **/ 32 EFI_STATUS 33 EFIAPI 34 KbdControllerDriverSupported ( 35 IN EFI_DRIVER_BINDING_PROTOCOL *This, 36 IN EFI_HANDLE Controller, 37 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath 38 ); 39 40 /** 41 Create KEYBOARD_CONSOLE_IN_DEV instance on controller. 42 43 @param This Pointer of EFI_DRIVER_BINDING_PROTOCOL 44 @param Controller driver controller handle 45 @param RemainingDevicePath Children's device path 46 47 @retval whether success to create floppy control instance. 48 **/ 49 EFI_STATUS 50 EFIAPI 51 KbdControllerDriverStart ( 52 IN EFI_DRIVER_BINDING_PROTOCOL *This, 53 IN EFI_HANDLE Controller, 54 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath 55 ); 56 57 /** 58 Stop this driver on ControllerHandle. Support stopping any child handles 59 created by this driver. 60 61 @param This Protocol instance pointer. 62 @param ControllerHandle Handle of device to stop driver on 63 @param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of 64 children is zero stop the entire bus driver. 65 @param ChildHandleBuffer List of Child Handles to Stop. 66 67 @retval EFI_SUCCESS This driver is removed ControllerHandle 68 @retval other This driver was not removed from this device 69 70 **/ 71 EFI_STATUS 72 EFIAPI 73 KbdControllerDriverStop ( 74 IN EFI_DRIVER_BINDING_PROTOCOL *This, 75 IN EFI_HANDLE Controller, 76 IN UINTN NumberOfChildren, 77 IN EFI_HANDLE *ChildHandleBuffer 78 ); 79 80 /** 81 Free the waiting key notify list. 82 83 @param ListHead Pointer to list head 84 85 @retval EFI_INVALID_PARAMETER ListHead is NULL 86 @retval EFI_SUCCESS Sucess to free NotifyList 87 **/ 88 EFI_STATUS 89 KbdFreeNotifyList ( 90 IN OUT LIST_ENTRY *ListHead 91 ); 92 93 // 94 // DriverBinding Protocol Instance 95 // 96 EFI_DRIVER_BINDING_PROTOCOL gKeyboardControllerDriver = { 97 KbdControllerDriverSupported, 98 KbdControllerDriverStart, 99 KbdControllerDriverStop, 100 0xa, 101 NULL, 102 NULL 103 }; 104 105 /** 106 Test controller is a keyboard Controller. 107 108 @param This Pointer of EFI_DRIVER_BINDING_PROTOCOL 109 @param Controller driver's controller 110 @param RemainingDevicePath children device path 111 112 @retval EFI_UNSUPPORTED controller is not floppy disk 113 @retval EFI_SUCCESS controller is floppy disk 114 **/ 115 EFI_STATUS 116 EFIAPI 117 KbdControllerDriverSupported ( 118 IN EFI_DRIVER_BINDING_PROTOCOL *This, 119 IN EFI_HANDLE Controller, 120 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath 121 ) 122 { 123 EFI_STATUS Status; 124 EFI_ISA_IO_PROTOCOL *IsaIo; 125 126 // 127 // Open the IO Abstraction(s) needed to perform the supported test 128 // 129 Status = gBS->OpenProtocol ( 130 Controller, 131 &gEfiIsaIoProtocolGuid, 132 (VOID **) &IsaIo, 133 This->DriverBindingHandle, 134 Controller, 135 EFI_OPEN_PROTOCOL_BY_DRIVER 136 ); 137 if (EFI_ERROR (Status)) { 138 return Status; 139 } 140 // 141 // Use the ISA I/O Protocol to see if Controller is the Keyboard controller 142 // 143 if (IsaIo->ResourceList->Device.HID != EISA_PNP_ID (0x303) || IsaIo->ResourceList->Device.UID != 0) { 144 Status = EFI_UNSUPPORTED; 145 } 146 // 147 // Close the I/O Abstraction(s) used to perform the supported test 148 // 149 gBS->CloseProtocol ( 150 Controller, 151 &gEfiIsaIoProtocolGuid, 152 This->DriverBindingHandle, 153 Controller 154 ); 155 156 return Status; 157 } 158 159 /** 160 Create KEYBOARD_CONSOLE_IN_DEV instance on controller. 161 162 @param This Pointer of EFI_DRIVER_BINDING_PROTOCOL 163 @param Controller driver controller handle 164 @param RemainingDevicePath Children's device path 165 166 @retval whether success to create floppy control instance. 167 **/ 168 EFI_STATUS 169 EFIAPI 170 KbdControllerDriverStart ( 171 IN EFI_DRIVER_BINDING_PROTOCOL *This, 172 IN EFI_HANDLE Controller, 173 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath 174 ) 175 { 176 EFI_STATUS Status; 177 EFI_STATUS Status1; 178 EFI_ISA_IO_PROTOCOL *IsaIo; 179 KEYBOARD_CONSOLE_IN_DEV *ConsoleIn; 180 UINT8 Data; 181 EFI_STATUS_CODE_VALUE StatusCode; 182 EFI_DEVICE_PATH_PROTOCOL *ParentDevicePath; 183 184 StatusCode = 0; 185 186 Status = gBS->OpenProtocol ( 187 Controller, 188 &gEfiDevicePathProtocolGuid, 189 (VOID **) &ParentDevicePath, 190 This->DriverBindingHandle, 191 Controller, 192 EFI_OPEN_PROTOCOL_BY_DRIVER 193 ); 194 if (EFI_ERROR (Status)) { 195 return Status; 196 } 197 // 198 // Report that the keyboard is being enabled 199 // 200 REPORT_STATUS_CODE_WITH_DEVICE_PATH ( 201 EFI_PROGRESS_CODE, 202 EFI_PERIPHERAL_KEYBOARD | EFI_P_PC_ENABLE, 203 ParentDevicePath 204 ); 205 206 // 207 // Get the ISA I/O Protocol on Controller's handle 208 // 209 Status = gBS->OpenProtocol ( 210 Controller, 211 &gEfiIsaIoProtocolGuid, 212 (VOID **) &IsaIo, 213 This->DriverBindingHandle, 214 Controller, 215 EFI_OPEN_PROTOCOL_BY_DRIVER 216 ); 217 if (EFI_ERROR (Status)) { 218 gBS->CloseProtocol ( 219 Controller, 220 &gEfiDevicePathProtocolGuid, 221 This->DriverBindingHandle, 222 Controller 223 ); 224 return EFI_INVALID_PARAMETER; 225 } 226 // 227 // Allocate private data 228 // 229 ConsoleIn = AllocateZeroPool (sizeof (KEYBOARD_CONSOLE_IN_DEV)); 230 if (ConsoleIn == NULL) { 231 Status = EFI_OUT_OF_RESOURCES; 232 StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_CONTROLLER_ERROR; 233 goto ErrorExit; 234 } 235 // 236 // Setup the device instance 237 // 238 ConsoleIn->Signature = KEYBOARD_CONSOLE_IN_DEV_SIGNATURE; 239 ConsoleIn->Handle = Controller; 240 (ConsoleIn->ConIn).Reset = KeyboardEfiReset; 241 (ConsoleIn->ConIn).ReadKeyStroke = KeyboardReadKeyStroke; 242 ConsoleIn->DataRegisterAddress = KEYBOARD_8042_DATA_REGISTER; 243 ConsoleIn->StatusRegisterAddress = KEYBOARD_8042_STATUS_REGISTER; 244 ConsoleIn->CommandRegisterAddress = KEYBOARD_8042_COMMAND_REGISTER; 245 ConsoleIn->IsaIo = IsaIo; 246 ConsoleIn->DevicePath = ParentDevicePath; 247 248 ConsoleIn->ConInEx.Reset = KeyboardEfiResetEx; 249 ConsoleIn->ConInEx.ReadKeyStrokeEx = KeyboardReadKeyStrokeEx; 250 ConsoleIn->ConInEx.SetState = KeyboardSetState; 251 ConsoleIn->ConInEx.RegisterKeyNotify = KeyboardRegisterKeyNotify; 252 ConsoleIn->ConInEx.UnregisterKeyNotify = KeyboardUnregisterKeyNotify; 253 254 InitializeListHead (&ConsoleIn->NotifyList); 255 256 // 257 // Fix for random hangs in System waiting for the Key if no KBC is present in BIOS. 258 // When KBC decode (IO port 0x60/0x64 decode) is not enabled, 259 // KeyboardRead will read back as 0xFF and return status is EFI_SUCCESS. 260 // So instead we read status register to detect after read if KBC decode is enabled. 261 // 262 263 // 264 // Return code is ignored on purpose. 265 // 266 if (!PcdGetBool (PcdFastPS2Detection)) { 267 KeyboardRead (ConsoleIn, &Data); 268 if ((KeyReadStatusRegister (ConsoleIn) & (KBC_PARE | KBC_TIM)) == (KBC_PARE | KBC_TIM)) { 269 // 270 // If nobody decodes KBC I/O port, it will read back as 0xFF. 271 // Check the Time-Out and Parity bit to see if it has an active KBC in system 272 // 273 Status = EFI_DEVICE_ERROR; 274 StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_NOT_DETECTED; 275 goto ErrorExit; 276 } 277 } 278 279 // 280 // Setup the WaitForKey event 281 // 282 Status = gBS->CreateEvent ( 283 EVT_NOTIFY_WAIT, 284 TPL_NOTIFY, 285 KeyboardWaitForKey, 286 ConsoleIn, 287 &((ConsoleIn->ConIn).WaitForKey) 288 ); 289 if (EFI_ERROR (Status)) { 290 Status = EFI_OUT_OF_RESOURCES; 291 StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_CONTROLLER_ERROR; 292 goto ErrorExit; 293 } 294 // 295 // Setup the WaitForKeyEx event 296 // 297 Status = gBS->CreateEvent ( 298 EVT_NOTIFY_WAIT, 299 TPL_NOTIFY, 300 KeyboardWaitForKeyEx, 301 ConsoleIn, 302 &(ConsoleIn->ConInEx.WaitForKeyEx) 303 ); 304 if (EFI_ERROR (Status)) { 305 Status = EFI_OUT_OF_RESOURCES; 306 StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_CONTROLLER_ERROR; 307 goto ErrorExit; 308 } 309 310 // Setup a periodic timer, used for reading keystrokes at a fixed interval 311 // 312 Status = gBS->CreateEvent ( 313 EVT_TIMER | EVT_NOTIFY_SIGNAL, 314 TPL_NOTIFY, 315 KeyboardTimerHandler, 316 ConsoleIn, 317 &ConsoleIn->TimerEvent 318 ); 319 if (EFI_ERROR (Status)) { 320 Status = EFI_OUT_OF_RESOURCES; 321 StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_CONTROLLER_ERROR; 322 goto ErrorExit; 323 } 324 325 Status = gBS->SetTimer ( 326 ConsoleIn->TimerEvent, 327 TimerPeriodic, 328 KEYBOARD_TIMER_INTERVAL 329 ); 330 if (EFI_ERROR (Status)) { 331 Status = EFI_OUT_OF_RESOURCES; 332 StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_CONTROLLER_ERROR; 333 goto ErrorExit; 334 } 335 336 Status = gBS->CreateEvent ( 337 EVT_NOTIFY_SIGNAL, 338 TPL_CALLBACK, 339 KeyNotifyProcessHandler, 340 ConsoleIn, 341 &ConsoleIn->KeyNotifyProcessEvent 342 ); 343 if (EFI_ERROR (Status)) { 344 Status = EFI_OUT_OF_RESOURCES; 345 StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_CONTROLLER_ERROR; 346 goto ErrorExit; 347 } 348 349 REPORT_STATUS_CODE_WITH_DEVICE_PATH ( 350 EFI_PROGRESS_CODE, 351 EFI_PERIPHERAL_KEYBOARD | EFI_P_PC_PRESENCE_DETECT, 352 ParentDevicePath 353 ); 354 355 // 356 // Reset the keyboard device 357 // 358 Status = ConsoleIn->ConInEx.Reset (&ConsoleIn->ConInEx, FeaturePcdGet (PcdPs2KbdExtendedVerification)); 359 if (EFI_ERROR (Status)) { 360 Status = EFI_DEVICE_ERROR; 361 StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_NOT_DETECTED; 362 goto ErrorExit; 363 } 364 365 REPORT_STATUS_CODE_WITH_DEVICE_PATH ( 366 EFI_PROGRESS_CODE, 367 EFI_PERIPHERAL_KEYBOARD | EFI_P_PC_DETECTED, 368 ParentDevicePath 369 ); 370 371 ConsoleIn->ControllerNameTable = NULL; 372 AddUnicodeString2 ( 373 "eng", 374 gPs2KeyboardComponentName.SupportedLanguages, 375 &ConsoleIn->ControllerNameTable, 376 L"PS/2 Keyboard Device", 377 TRUE 378 ); 379 AddUnicodeString2 ( 380 "en", 381 gPs2KeyboardComponentName2.SupportedLanguages, 382 &ConsoleIn->ControllerNameTable, 383 L"PS/2 Keyboard Device", 384 FALSE 385 ); 386 387 388 // 389 // Install protocol interfaces for the keyboard device. 390 // 391 Status = gBS->InstallMultipleProtocolInterfaces ( 392 &Controller, 393 &gEfiSimpleTextInProtocolGuid, 394 &ConsoleIn->ConIn, 395 &gEfiSimpleTextInputExProtocolGuid, 396 &ConsoleIn->ConInEx, 397 NULL 398 ); 399 if (EFI_ERROR (Status)) { 400 StatusCode = EFI_PERIPHERAL_KEYBOARD | EFI_P_EC_CONTROLLER_ERROR; 401 goto ErrorExit; 402 } 403 404 return Status; 405 406 ErrorExit: 407 // 408 // Report error code 409 // 410 if (StatusCode != 0) { 411 REPORT_STATUS_CODE_WITH_DEVICE_PATH ( 412 EFI_ERROR_CODE | EFI_ERROR_MINOR, 413 StatusCode, 414 ParentDevicePath 415 ); 416 } 417 418 if ((ConsoleIn != NULL) && (ConsoleIn->ConIn.WaitForKey != NULL)) { 419 gBS->CloseEvent (ConsoleIn->ConIn.WaitForKey); 420 } 421 422 if ((ConsoleIn != NULL) && (ConsoleIn->TimerEvent != NULL)) { 423 gBS->CloseEvent (ConsoleIn->TimerEvent); 424 } 425 if ((ConsoleIn != NULL) && (ConsoleIn->ConInEx.WaitForKeyEx != NULL)) { 426 gBS->CloseEvent (ConsoleIn->ConInEx.WaitForKeyEx); 427 } 428 if ((ConsoleIn != NULL) && (ConsoleIn->KeyNotifyProcessEvent != NULL)) { 429 gBS->CloseEvent (ConsoleIn->KeyNotifyProcessEvent); 430 } 431 KbdFreeNotifyList (&ConsoleIn->NotifyList); 432 if ((ConsoleIn != NULL) && (ConsoleIn->ControllerNameTable != NULL)) { 433 FreeUnicodeStringTable (ConsoleIn->ControllerNameTable); 434 } 435 // 436 // Since there will be no timer handler for keyboard input any more, 437 // exhaust input data just in case there is still keyboard data left 438 // 439 if (ConsoleIn != NULL) { 440 Status1 = EFI_SUCCESS; 441 while (!EFI_ERROR (Status1) && (Status != EFI_DEVICE_ERROR)) { 442 Status1 = KeyboardRead (ConsoleIn, &Data);; 443 } 444 } 445 446 if (ConsoleIn != NULL) { 447 gBS->FreePool (ConsoleIn); 448 } 449 450 gBS->CloseProtocol ( 451 Controller, 452 &gEfiDevicePathProtocolGuid, 453 This->DriverBindingHandle, 454 Controller 455 ); 456 457 gBS->CloseProtocol ( 458 Controller, 459 &gEfiIsaIoProtocolGuid, 460 This->DriverBindingHandle, 461 Controller 462 ); 463 464 return Status; 465 } 466 467 /** 468 Stop this driver on ControllerHandle. Support stopping any child handles 469 created by this driver. 470 471 @param This Protocol instance pointer. 472 @param ControllerHandle Handle of device to stop driver on 473 @param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of 474 children is zero stop the entire bus driver. 475 @param ChildHandleBuffer List of Child Handles to Stop. 476 477 @retval EFI_SUCCESS This driver is removed ControllerHandle 478 @retval other This driver was not removed from this device 479 480 **/ 481 EFI_STATUS 482 EFIAPI 483 KbdControllerDriverStop ( 484 IN EFI_DRIVER_BINDING_PROTOCOL *This, 485 IN EFI_HANDLE Controller, 486 IN UINTN NumberOfChildren, 487 IN EFI_HANDLE *ChildHandleBuffer 488 ) 489 { 490 EFI_STATUS Status; 491 EFI_SIMPLE_TEXT_INPUT_PROTOCOL *ConIn; 492 KEYBOARD_CONSOLE_IN_DEV *ConsoleIn; 493 UINT8 Data; 494 495 // 496 // Disable Keyboard 497 // 498 Status = gBS->OpenProtocol ( 499 Controller, 500 &gEfiSimpleTextInProtocolGuid, 501 (VOID **) &ConIn, 502 This->DriverBindingHandle, 503 Controller, 504 EFI_OPEN_PROTOCOL_GET_PROTOCOL 505 ); 506 if (EFI_ERROR (Status)) { 507 return Status; 508 } 509 Status = gBS->OpenProtocol ( 510 Controller, 511 &gEfiSimpleTextInputExProtocolGuid, 512 NULL, 513 This->DriverBindingHandle, 514 Controller, 515 EFI_OPEN_PROTOCOL_TEST_PROTOCOL 516 ); 517 if (EFI_ERROR (Status)) { 518 return Status; 519 } 520 521 ConsoleIn = KEYBOARD_CONSOLE_IN_DEV_FROM_THIS (ConIn); 522 523 // 524 // Report that the keyboard is being disabled 525 // 526 REPORT_STATUS_CODE_WITH_DEVICE_PATH ( 527 EFI_PROGRESS_CODE, 528 EFI_PERIPHERAL_KEYBOARD | EFI_P_PC_DISABLE, 529 ConsoleIn->DevicePath 530 ); 531 532 if (ConsoleIn->TimerEvent != NULL) { 533 gBS->CloseEvent (ConsoleIn->TimerEvent); 534 ConsoleIn->TimerEvent = NULL; 535 } 536 537 // 538 // Since there will be no timer handler for keyboard input any more, 539 // exhaust input data just in case there is still keyboard data left 540 // 541 Status = EFI_SUCCESS; 542 while (!EFI_ERROR (Status)) { 543 Status = KeyboardRead (ConsoleIn, &Data);; 544 } 545 // 546 // Uninstall the SimpleTextIn and SimpleTextInEx protocols 547 // 548 Status = gBS->UninstallMultipleProtocolInterfaces ( 549 Controller, 550 &gEfiSimpleTextInProtocolGuid, 551 &ConsoleIn->ConIn, 552 &gEfiSimpleTextInputExProtocolGuid, 553 &ConsoleIn->ConInEx, 554 NULL 555 ); 556 if (EFI_ERROR (Status)) { 557 return Status; 558 } 559 560 gBS->CloseProtocol ( 561 Controller, 562 &gEfiDevicePathProtocolGuid, 563 This->DriverBindingHandle, 564 Controller 565 ); 566 567 gBS->CloseProtocol ( 568 Controller, 569 &gEfiIsaIoProtocolGuid, 570 This->DriverBindingHandle, 571 Controller 572 ); 573 574 // 575 // Free other resources 576 // 577 if ((ConsoleIn->ConIn).WaitForKey != NULL) { 578 gBS->CloseEvent ((ConsoleIn->ConIn).WaitForKey); 579 (ConsoleIn->ConIn).WaitForKey = NULL; 580 } 581 if (ConsoleIn->ConInEx.WaitForKeyEx != NULL) { 582 gBS->CloseEvent (ConsoleIn->ConInEx.WaitForKeyEx); 583 ConsoleIn->ConInEx.WaitForKeyEx = NULL; 584 } 585 if (ConsoleIn->KeyNotifyProcessEvent != NULL) { 586 gBS->CloseEvent (ConsoleIn->KeyNotifyProcessEvent); 587 ConsoleIn->KeyNotifyProcessEvent = NULL; 588 } 589 KbdFreeNotifyList (&ConsoleIn->NotifyList); 590 FreeUnicodeStringTable (ConsoleIn->ControllerNameTable); 591 gBS->FreePool (ConsoleIn); 592 593 return EFI_SUCCESS; 594 } 595 596 /** 597 Free the waiting key notify list. 598 599 @param ListHead Pointer to list head 600 601 @retval EFI_INVALID_PARAMETER ListHead is NULL 602 @retval EFI_SUCCESS Sucess to free NotifyList 603 **/ 604 EFI_STATUS 605 KbdFreeNotifyList ( 606 IN OUT LIST_ENTRY *ListHead 607 ) 608 { 609 KEYBOARD_CONSOLE_IN_EX_NOTIFY *NotifyNode; 610 611 if (ListHead == NULL) { 612 return EFI_INVALID_PARAMETER; 613 } 614 while (!IsListEmpty (ListHead)) { 615 NotifyNode = CR ( 616 ListHead->ForwardLink, 617 KEYBOARD_CONSOLE_IN_EX_NOTIFY, 618 NotifyEntry, 619 KEYBOARD_CONSOLE_IN_EX_NOTIFY_SIGNATURE 620 ); 621 RemoveEntryList (ListHead->ForwardLink); 622 gBS->FreePool (NotifyNode); 623 } 624 625 return EFI_SUCCESS; 626 } 627 628 /** 629 The module Entry Point for module Ps2Keyboard. 630 631 @param[in] ImageHandle The firmware allocated handle for the EFI image. 632 @param[in] SystemTable A pointer to the EFI System Table. 633 634 @retval EFI_SUCCESS The entry point is executed successfully. 635 @retval other Some error occurs when executing this entry point. 636 637 **/ 638 EFI_STATUS 639 EFIAPI 640 InitializePs2Keyboard( 641 IN EFI_HANDLE ImageHandle, 642 IN EFI_SYSTEM_TABLE *SystemTable 643 ) 644 { 645 EFI_STATUS Status; 646 647 // 648 // Install driver model protocol(s). 649 // 650 Status = EfiLibInstallDriverBindingComponentName2 ( 651 ImageHandle, 652 SystemTable, 653 &gKeyboardControllerDriver, 654 ImageHandle, 655 &gPs2KeyboardComponentName, 656 &gPs2KeyboardComponentName2 657 ); 658 ASSERT_EFI_ERROR (Status); 659 660 661 return Status; 662 } 663 664
