MdeModulePkg/Universal/Console/TerminalDxe/Terminal.c

   1 /*++
   2
   3 Copyright (c) 2006, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14     Terminal.c
  15
  16 Abstract:
  17
  18 Revision History:
  19
  20 --*/
  21
  22
  23 //
  24 // Include common header file for this module.
  25 //
  26 #include "CommonHeader.h"
  27
  28 #include "Terminal.h"
  29
  30 #include "FrameworkDxe.h"
  31
  32 //
  33 // Globals
  34 //
  35 EFI_DRIVER_BINDING_PROTOCOL gTerminalDriverBinding = {
  36   TerminalDriverBindingSupported,
  37   TerminalDriverBindingStart,
  38   TerminalDriverBindingStop,
  39   0xa,
  40   NULL,
  41   NULL
  42 };
  43
  44
  45 EFI_STATUS
  46 EFIAPI
  47 TerminalDriverBindingSupported (
  48   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
  49   IN EFI_HANDLE                     Controller,
  50   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
  51   )
  52 {
  53   EFI_STATUS                Status;
  54   EFI_DEVICE_PATH_PROTOCOL  *ParentDevicePath;
  55   EFI_SERIAL_IO_PROTOCOL    *SerialIo;
  56   VENDOR_DEVICE_PATH        *Node;
  57
  58   //
  59   // If remaining device path is not NULL, then make sure it is a
  60   // device path that describes a terminal communications protocol.
  61   //
  62   if (RemainingDevicePath != NULL) {
  63
  64     Node = (VENDOR_DEVICE_PATH *) RemainingDevicePath;
  65
  66     if (Node->Header.Type != MESSAGING_DEVICE_PATH ||
  67         Node->Header.SubType != MSG_VENDOR_DP ||
  68         DevicePathNodeLength(&Node->Header) != sizeof(VENDOR_DEVICE_PATH)) {
  69
  70       return EFI_UNSUPPORTED;
  71
  72     }
  73     //
  74     // only supports PC ANSI, VT100, VT100+ and VT-UTF8 terminal types
  75     //
  76     if (!CompareGuid (&Node->Guid, &gEfiPcAnsiGuid) &&
  77         !CompareGuid (&Node->Guid, &gEfiVT100Guid) &&
  78         !CompareGuid (&Node->Guid, &gEfiVT100PlusGuid) &&
  79         !CompareGuid (&Node->Guid, &gEfiVTUTF8Guid)) {
  80
  81       return EFI_UNSUPPORTED;
  82     }
  83   }
  84   //
  85   // Open the IO Abstraction(s) needed to perform the supported test
  86   //
  87   Status = gBS->OpenProtocol (
  88                   Controller,
  89                   &gEfiDevicePathProtocolGuid,
  90                   (VOID **) &ParentDevicePath,
  91                   This->DriverBindingHandle,
  92                   Controller,
  93                   EFI_OPEN_PROTOCOL_BY_DRIVER
  94                   );
  95   if (Status == EFI_ALREADY_STARTED) {
  96     return EFI_SUCCESS;
  97   }
  98
  99   if (EFI_ERROR (Status)) {
 100     return Status;
 101   }
 102
 103   gBS->CloseProtocol (
 104         Controller,
 105         &gEfiDevicePathProtocolGuid,
 106         This->DriverBindingHandle,
 107         Controller
 108         );
 109
 110   //
 111   // The Controller must support the Serial I/O Protocol.
 112   // This driver is a bus driver with at most 1 child device, so it is
 113   // ok for it to be already started.
 114   //
 115   Status = gBS->OpenProtocol (
 116                   Controller,
 117                   &gEfiSerialIoProtocolGuid,
 118                   (VOID **) &SerialIo,
 119                   This->DriverBindingHandle,
 120                   Controller,
 121                   EFI_OPEN_PROTOCOL_BY_DRIVER
 122                   );
 123   if (Status == EFI_ALREADY_STARTED) {
 124     return EFI_SUCCESS;
 125   }
 126
 127   if (EFI_ERROR (Status)) {
 128     return Status;
 129   }
 130   //
 131   // Close the I/O Abstraction(s) used to perform the supported test
 132   //
 133   gBS->CloseProtocol (
 134         Controller,
 135         &gEfiSerialIoProtocolGuid,
 136         This->DriverBindingHandle,
 137         Controller
 138         );
 139
 140   return Status;
 141 }
 142
 143 EFI_STATUS
 144 EFIAPI
 145 TerminalDriverBindingStart (
 146   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 147   IN EFI_HANDLE                     Controller,
 148   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 149   )
 150 /*++
 151
 152   Routine Description:
 153
 154     Start the controller.
 155
 156   Arguments:
 157
 158     This                - A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 159     Controller          - The handle of the controller to start.
 160     RemainingDevicePath - A pointer to the remaining portion of a devcie path.
 161
 162   Returns:
 163
 164     EFI_SUCCESS.
 165
 166 --*/
 167 {
 168   EFI_STATUS                          Status;
 169   EFI_SERIAL_IO_PROTOCOL              *SerialIo;
 170   EFI_DEVICE_PATH_PROTOCOL            *ParentDevicePath;
 171   VENDOR_DEVICE_PATH                  *Node;
 172   VENDOR_DEVICE_PATH                  *DefaultNode;
 173   EFI_SERIAL_IO_MODE                  *Mode;
 174   UINTN                               SerialInTimeOut;
 175   TERMINAL_DEV                        *TerminalDevice;
 176   UINT8                               TerminalType;
 177   EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfoBuffer;
 178   UINTN                               EntryCount;
 179   UINTN                               Index;
 180   EFI_DEVICE_PATH_PROTOCOL            *DevicePath;
 181
 182   TerminalDevice = NULL;
 183   DefaultNode    = NULL;
 184   //
 185   // Get the Device Path Protocol to build the device path of the child device
 186   //
 187   Status = gBS->OpenProtocol (
 188                   Controller,
 189                   &gEfiDevicePathProtocolGuid,
 190                   (VOID **) &ParentDevicePath,
 191                   This->DriverBindingHandle,
 192                   Controller,
 193                   EFI_OPEN_PROTOCOL_BY_DRIVER
 194                   );
 195   if (EFI_ERROR (Status) && Status != EFI_ALREADY_STARTED) {
 196     return Status;
 197   }
 198   //
 199   // Report that the remote terminal is being enabled
 200   //
 201   DevicePath = ParentDevicePath;
 202   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 203     EFI_PROGRESS_CODE,
 204     EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_PC_ENABLE,
 205     DevicePath
 206     );
 207
 208   //
 209   // Open the Serial I/O Protocol BY_DRIVER.  It might already be started.
 210   //
 211   Status = gBS->OpenProtocol (
 212                   Controller,
 213                   &gEfiSerialIoProtocolGuid,
 214                   (VOID **) &SerialIo,
 215                   This->DriverBindingHandle,
 216                   Controller,
 217                   EFI_OPEN_PROTOCOL_BY_DRIVER
 218                   );
 219   if (EFI_ERROR (Status) && Status != EFI_ALREADY_STARTED) {
 220     return Status;
 221   }
 222
 223   if (Status != EFI_ALREADY_STARTED) {
 224     //
 225     // If Serial I/O is not already open by this driver, then tag the handle
 226     // with the Terminal Driver GUID and update the ConInDev, ConOutDev, and
 227     // StdErrDev variables with the list of possible terminal types on this
 228     // serial port.
 229     //
 230     Status = gBS->OpenProtocol (
 231                     Controller,
 232                     &gEfiCallerIdGuid,
 233                     NULL,
 234                     This->DriverBindingHandle,
 235                     Controller,
 236                     EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 237                     );
 238     if (EFI_ERROR (Status)) {
 239       Status = gBS->InstallMultipleProtocolInterfaces (
 240                       &Controller,
 241                       &gEfiCallerIdGuid,
 242                       DuplicateDevicePath (ParentDevicePath),
 243                       NULL
 244                       );
 245       if (EFI_ERROR (Status)) {
 246         goto Error;
 247       }
 248       //
 249       // if the serial device is a hot plug device, do not update the
 250       // ConInDev, ConOutDev, and StdErrDev variables.
 251       //
 252       Status = gBS->OpenProtocol (
 253                       Controller,
 254                       &gEfiHotPlugDeviceGuid,
 255                       NULL,
 256                       This->DriverBindingHandle,
 257                       Controller,
 258                       EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 259                       );
 260       if (EFI_ERROR (Status)) {
 261         TerminalUpdateConsoleDevVariable ((CHAR16 *)VarConsoleInpDev, ParentDevicePath);
 262         TerminalUpdateConsoleDevVariable ((CHAR16 *)VarConsoleOutDev, ParentDevicePath);
 263         TerminalUpdateConsoleDevVariable ((CHAR16 *)VarErrorOutDev, ParentDevicePath);
 264       }
 265     }
 266   }
 267   //
 268   // Make sure a child handle does not already exist.  This driver can only
 269   // produce one child per serial port.
 270   //
 271   Status = gBS->OpenProtocolInformation (
 272                   Controller,
 273                   &gEfiSerialIoProtocolGuid,
 274                   &OpenInfoBuffer,
 275                   &EntryCount
 276                   );
 277   if (!EFI_ERROR (Status)) {
 278     Status = EFI_SUCCESS;
 279     for (Index = 0; Index < EntryCount; Index++) {
 280       if (OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) {
 281         Status = EFI_ALREADY_STARTED;
 282       }
 283     }
 284
 285     FreePool (OpenInfoBuffer);
 286     if (EFI_ERROR (Status)) {
 287       return Status;
 288     }
 289   }
 290   //
 291   // If RemainingDevicePath is NULL, then create default device path node
 292   //
 293   if (RemainingDevicePath == NULL) {
 294     DefaultNode = AllocatePool (sizeof (VENDOR_DEVICE_PATH));
 295     if (DefaultNode == NULL) {
 296       Status = EFI_OUT_OF_RESOURCES;
 297       goto Error;
 298     }
 299
 300     CopyMem (&DefaultNode->Guid, &gEfiPcAnsiGuid, sizeof (EFI_GUID));
 301     RemainingDevicePath = (EFI_DEVICE_PATH_PROTOCOL*) DefaultNode;
 302   }
 303   //
 304   // Use the RemainingDevicePath to determine the terminal type
 305   //
 306   Node = (VENDOR_DEVICE_PATH *) RemainingDevicePath;
 307
 308   if (CompareGuid (&Node->Guid, &gEfiPcAnsiGuid)) {
 309
 310     TerminalType = PcAnsiType;
 311
 312   } else if (CompareGuid (&Node->Guid, &gEfiVT100Guid)) {
 313
 314     TerminalType = VT100Type;
 315
 316   } else if (CompareGuid (&Node->Guid, &gEfiVT100PlusGuid)) {
 317
 318     TerminalType = VT100PlusType;
 319
 320   } else if (CompareGuid (&Node->Guid, &gEfiVTUTF8Guid)) {
 321
 322     TerminalType = VTUTF8Type;
 323
 324   } else {
 325     goto Error;
 326   }
 327   //
 328   // Initialize the Terminal Dev
 329   //
 330   TerminalDevice = AllocatePool (sizeof (TERMINAL_DEV));
 331   if (TerminalDevice == NULL) {
 332     Status = EFI_OUT_OF_RESOURCES;
 333     goto Error;
 334   }
 335
 336   ZeroMem (TerminalDevice, sizeof (TERMINAL_DEV));
 337
 338   TerminalDevice->Signature     = TERMINAL_DEV_SIGNATURE;
 339
 340   TerminalDevice->TerminalType  = TerminalType;
 341
 342   TerminalDevice->SerialIo      = SerialIo;
 343
 344   //
 345   // Simple Input Protocol
 346   //
 347   TerminalDevice->SimpleInput.Reset         = TerminalConInReset;
 348   TerminalDevice->SimpleInput.ReadKeyStroke = TerminalConInReadKeyStroke;
 349
 350   Status = gBS->CreateEvent (
 351                   EVT_NOTIFY_WAIT,
 352                   TPL_NOTIFY,
 353                   TerminalConInWaitForKey,
 354                   &TerminalDevice->SimpleInput,
 355                   &TerminalDevice->SimpleInput.WaitForKey
 356                   );
 357   if (EFI_ERROR (Status)) {
 358     goto Error;
 359   }
 360   //
 361   // initialize the FIFO buffer used for accommodating
 362   // the pre-read pending characters
 363   //
 364   InitializeRawFiFo (TerminalDevice);
 365   InitializeUnicodeFiFo (TerminalDevice);
 366   InitializeEfiKeyFiFo (TerminalDevice);
 367
 368   //
 369   // Set the timeout value of serial buffer for
 370   // keystroke response performance issue
 371   //
 372   Mode            = TerminalDevice->SerialIo->Mode;
 373
 374   SerialInTimeOut = 0;
 375   if (Mode->BaudRate != 0) {
 376     SerialInTimeOut = (1 + Mode->DataBits + Mode->StopBits) * 2 * 1000000 / (UINTN) Mode->BaudRate;
 377   }
 378
 379   Status = TerminalDevice->SerialIo->SetAttributes (
 380                                       TerminalDevice->SerialIo,
 381                                       Mode->BaudRate,
 382                                       Mode->ReceiveFifoDepth,
 383                                       (UINT32) SerialInTimeOut,
 384                                       (EFI_PARITY_TYPE) (Mode->Parity),
 385                                       (UINT8) Mode->DataBits,
 386                                       (EFI_STOP_BITS_TYPE) (Mode->StopBits)
 387                                       );
 388   if (EFI_ERROR (Status)) {
 389     //
 390     // if set attributes operation fails, invalidate
 391     // the value of SerialInTimeOut,thus make it
 392     // inconsistent with the default timeout value
 393     // of serial buffer. This will invoke the recalculation
 394     // in the readkeystroke routine.
 395     //
 396     TerminalDevice->SerialInTimeOut = 0;
 397   } else {
 398     TerminalDevice->SerialInTimeOut = SerialInTimeOut;
 399   }
 400   //
 401   // Build the device path for the child device
 402   //
 403   Status = SetTerminalDevicePath (
 404             TerminalDevice->TerminalType,
 405             ParentDevicePath,
 406             &TerminalDevice->DevicePath
 407             );
 408   if (EFI_ERROR (Status)) {
 409     goto Error;
 410   }
 411
 412   DevicePath = TerminalDevice->DevicePath;
 413
 414   Status = TerminalDevice->SimpleInput.Reset (
 415                                         &TerminalDevice->SimpleInput,
 416                                         FALSE
 417                                         );
 418   if (EFI_ERROR (Status)) {
 419     //
 420     // Need to report Error Code first
 421     //
 422     goto ReportError;
 423   }
 424   //
 425   // Simple Text Output Protocol
 426   //
 427   TerminalDevice->SimpleTextOutput.Reset              = TerminalConOutReset;
 428   TerminalDevice->SimpleTextOutput.OutputString       = TerminalConOutOutputString;
 429   TerminalDevice->SimpleTextOutput.TestString         = TerminalConOutTestString;
 430   TerminalDevice->SimpleTextOutput.QueryMode          = TerminalConOutQueryMode;
 431   TerminalDevice->SimpleTextOutput.SetMode            = TerminalConOutSetMode;
 432   TerminalDevice->SimpleTextOutput.SetAttribute       = TerminalConOutSetAttribute;
 433   TerminalDevice->SimpleTextOutput.ClearScreen        = TerminalConOutClearScreen;
 434   TerminalDevice->SimpleTextOutput.SetCursorPosition  = TerminalConOutSetCursorPosition;
 435   TerminalDevice->SimpleTextOutput.EnableCursor       = TerminalConOutEnableCursor;
 436   TerminalDevice->SimpleTextOutput.Mode               = &TerminalDevice->SimpleTextOutputMode;
 437
 438   TerminalDevice->SimpleTextOutputMode.MaxMode        = 1;
 439   //
 440   // For terminal devices, cursor is always visible
 441   //
 442   TerminalDevice->SimpleTextOutputMode.CursorVisible  = TRUE;
 443   TerminalDevice->SimpleTextOutputMode.Attribute      = EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK);
 444
 445   Status = TerminalDevice->SimpleTextOutput.Reset (
 446                                               &TerminalDevice->SimpleTextOutput,
 447                                               FALSE
 448                                               );
 449   if (EFI_ERROR (Status)) {
 450     goto ReportError;
 451   }
 452
 453   Status = TerminalDevice->SimpleTextOutput.SetMode (
 454                                               &TerminalDevice->SimpleTextOutput,
 455                                               0
 456                                               );
 457   if (EFI_ERROR (Status)) {
 458     goto ReportError;
 459   }
 460
 461   Status = TerminalDevice->SimpleTextOutput.EnableCursor (
 462                                               &TerminalDevice->SimpleTextOutput,
 463                                               TRUE
 464                                               );
 465   if (EFI_ERROR (Status)) {
 466     goto ReportError;
 467   }
 468   //
 469   //
 470   //
 471   TerminalDevice->InputState  = INPUT_STATE_DEFAULT;
 472   TerminalDevice->ResetState  = RESET_STATE_DEFAULT;
 473
 474   Status = gBS->CreateEvent (
 475                   EVT_TIMER,
 476                   TPL_CALLBACK,
 477                   NULL,
 478                   NULL,
 479                   &TerminalDevice->TwoSecondTimeOut
 480                   );
 481
 482   //
 483   // Build the component name for the child device
 484   //
 485   TerminalDevice->ControllerNameTable = NULL;
 486   switch (TerminalDevice->TerminalType) {
 487   case PcAnsiType:
 488     AddUnicodeString (
 489       "eng",
 490       gTerminalComponentName.SupportedLanguages,
 491       &TerminalDevice->ControllerNameTable,
 492       (CHAR16 *)L"PC-ANSI Serial Console"
 493       );
 494     break;
 495
 496   case VT100Type:
 497     AddUnicodeString (
 498       "eng",
 499       gTerminalComponentName.SupportedLanguages,
 500       &TerminalDevice->ControllerNameTable,
 501       (CHAR16 *)L"VT-100 Serial Console"
 502       );
 503     break;
 504
 505   case VT100PlusType:
 506     AddUnicodeString (
 507       "eng",
 508       gTerminalComponentName.SupportedLanguages,
 509       &TerminalDevice->ControllerNameTable,
 510       (CHAR16 *)L"VT-100+ Serial Console"
 511       );
 512     break;
 513
 514   case VTUTF8Type:
 515     AddUnicodeString (
 516       "eng",
 517       gTerminalComponentName.SupportedLanguages,
 518       &TerminalDevice->ControllerNameTable,
 519       (CHAR16 *)L"VT-UTF8 Serial Console"
 520       );
 521     break;
 522   }
 523   //
 524   // Install protocol interfaces for the serial device.
 525   //
 526   Status = gBS->InstallMultipleProtocolInterfaces (
 527                   &TerminalDevice->Handle,
 528                   &gEfiDevicePathProtocolGuid,
 529                   TerminalDevice->DevicePath,
 530                   &gEfiSimpleTextInProtocolGuid,
 531                   &TerminalDevice->SimpleInput,
 532                   &gEfiSimpleTextOutProtocolGuid,
 533                   &TerminalDevice->SimpleTextOutput,
 534                   NULL
 535                   );
 536   if (EFI_ERROR (Status)) {
 537     goto Error;
 538   }
 539   //
 540   // if the serial device is a hot plug device, attaches the HotPlugGuid
 541   // onto the terminal device handle.
 542   //
 543   Status = gBS->OpenProtocol (
 544                   Controller,
 545                   &gEfiHotPlugDeviceGuid,
 546                   NULL,
 547                   This->DriverBindingHandle,
 548                   Controller,
 549                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 550                   );
 551   if (!EFI_ERROR (Status)) {
 552     Status = gBS->InstallMultipleProtocolInterfaces (
 553                     &TerminalDevice->Handle,
 554                     &gEfiHotPlugDeviceGuid,
 555                     NULL,
 556                     NULL
 557                     );
 558   }
 559   //
 560   // Register the Parent-Child relationship via
 561   // EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER.
 562   //
 563   Status = gBS->OpenProtocol (
 564                   Controller,
 565                   &gEfiSerialIoProtocolGuid,
 566                   (VOID **) &TerminalDevice->SerialIo,
 567                   This->DriverBindingHandle,
 568                   TerminalDevice->Handle,
 569                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 570                   );
 571   if (EFI_ERROR (Status)) {
 572     goto Error;
 573   }
 574
 575   if (DefaultNode != NULL) {
 576     FreePool (DefaultNode);
 577   }
 578
 579   return EFI_SUCCESS;
 580
 581 ReportError:
 582   //
 583   // Report error code before exiting
 584   //
 585   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 586     EFI_ERROR_CODE | EFI_ERROR_MINOR,
 587     EFI_PERIPHERAL_LOCAL_CONSOLE | EFI_P_EC_CONTROLLER_ERROR,
 588     DevicePath
 589     );
 590
 591 Error:
 592   //
 593   // Use the Stop() function to free all resources allocated in Start()
 594   //
 595   if (TerminalDevice != NULL) {
 596
 597     if (TerminalDevice->Handle != NULL) {
 598       This->Stop (This, Controller, 1, &TerminalDevice->Handle);
 599     } else {
 600
 601       if (TerminalDevice->TwoSecondTimeOut != NULL) {
 602         gBS->CloseEvent (TerminalDevice->TwoSecondTimeOut);
 603       }
 604
 605       if (TerminalDevice->SimpleInput.WaitForKey != NULL) {
 606         gBS->CloseEvent (TerminalDevice->SimpleInput.WaitForKey);
 607       }
 608
 609       if (TerminalDevice->ControllerNameTable != NULL) {
 610         FreeUnicodeStringTable (TerminalDevice->ControllerNameTable);
 611       }
 612
 613       if (TerminalDevice->DevicePath != NULL) {
 614         FreePool (TerminalDevice->DevicePath);
 615       }
 616
 617       FreePool (TerminalDevice);
 618     }
 619   }
 620
 621   if (DefaultNode != NULL) {
 622     FreePool (DefaultNode);
 623   }
 624
 625   This->Stop (This, Controller, 0, NULL);
 626
 627   return Status;
 628 }
 629
 630 EFI_STATUS
 631 EFIAPI
 632 TerminalDriverBindingStop (
 633   IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
 634   IN  EFI_HANDLE                    Controller,
 635   IN  UINTN                         NumberOfChildren,
 636   IN  EFI_HANDLE                    *ChildHandleBuffer
 637   )
 638 /*++
 639
 640   Routine Description:
 641
 642     Stop a device controller.
 643
 644   Arguments:
 645
 646     This              - A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 647     Controller        - A handle to the device being stopped.
 648     NumberOfChildren  - The number of child device handles in ChildHandleBuffer.
 649     ChildHandleBuffer - An array of child handles to be freed.
 650
 651   Returns:
 652
 653     EFI_SUCCESS      - Operation successful.
 654     EFI_DEVICE_ERROR - Devices error.
 655
 656 --*/
 657 {
 658   EFI_STATUS                       Status;
 659   UINTN                            Index;
 660   BOOLEAN                          AllChildrenStopped;
 661   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *SimpleTextOutput;
 662   TERMINAL_DEV                     *TerminalDevice;
 663   EFI_DEVICE_PATH_PROTOCOL         *ParentDevicePath;
 664   EFI_SERIAL_IO_PROTOCOL           *SerialIo;
 665   EFI_DEVICE_PATH_PROTOCOL         *DevicePath;
 666
 667   Status = gBS->HandleProtocol (
 668                   Controller,
 669                   &gEfiDevicePathProtocolGuid,
 670                   (VOID **) &DevicePath
 671                   );
 672   if (EFI_ERROR (Status)) {
 673     return Status;
 674   }
 675   //
 676   // Report that the remote terminal is being disabled
 677   //
 678   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 679     EFI_PROGRESS_CODE,
 680     EFI_PERIPHERAL_REMOTE_CONSOLE | EFI_P_PC_DISABLE,
 681     DevicePath
 682     );
 683
 684   //
 685   // Complete all outstanding transactions to Controller.
 686   // Don't allow any new transaction to Controller to be started.
 687   //
 688   if (NumberOfChildren == 0) {
 689     //
 690     // Close the bus driver
 691     //
 692     Status = gBS->OpenProtocol (
 693                     Controller,
 694                     &gEfiCallerIdGuid,
 695                     (VOID **) &ParentDevicePath,
 696                     This->DriverBindingHandle,
 697                     Controller,
 698                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 699                     );
 700     if (!EFI_ERROR (Status)) {
 701       //
 702       // Remove Parent Device Path from
 703       // the Console Device Environment Variables
 704       //
 705       TerminalRemoveConsoleDevVariable ((CHAR16 *)VarConsoleInpDev, ParentDevicePath);
 706       TerminalRemoveConsoleDevVariable ((CHAR16 *)VarConsoleOutDev, ParentDevicePath);
 707       TerminalRemoveConsoleDevVariable ((CHAR16 *)VarErrorOutDev, ParentDevicePath);
 708
 709       //
 710       // Uninstall the Terminal Driver's GUID Tag from the Serial controller
 711       //
 712       Status = gBS->UninstallMultipleProtocolInterfaces (
 713                       Controller,
 714                       &gEfiCallerIdGuid,
 715                       ParentDevicePath,
 716                       NULL
 717                       );
 718
 719       //
 720       // Free the ParentDevicePath that was duplicated in Start()
 721       //
 722       if (!EFI_ERROR (Status)) {
 723         FreePool (ParentDevicePath);
 724       }
 725     }
 726
 727     gBS->CloseProtocol (
 728           Controller,
 729           &gEfiSerialIoProtocolGuid,
 730           This->DriverBindingHandle,
 731           Controller
 732           );
 733
 734     gBS->CloseProtocol (
 735           Controller,
 736           &gEfiDevicePathProtocolGuid,
 737           This->DriverBindingHandle,
 738           Controller
 739           );
 740
 741     return EFI_SUCCESS;
 742   }
 743
 744   AllChildrenStopped = TRUE;
 745
 746   for (Index = 0; Index < NumberOfChildren; Index++) {
 747
 748     Status = gBS->OpenProtocol (
 749                     ChildHandleBuffer[Index],
 750                     &gEfiSimpleTextOutProtocolGuid,
 751                     (VOID **) &SimpleTextOutput,
 752                     This->DriverBindingHandle,
 753                     ChildHandleBuffer[Index],
 754                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 755                     );
 756     if (!EFI_ERROR (Status)) {
 757
 758       TerminalDevice = TERMINAL_CON_OUT_DEV_FROM_THIS (SimpleTextOutput);
 759
 760       gBS->CloseProtocol (
 761             Controller,
 762             &gEfiSerialIoProtocolGuid,
 763             This->DriverBindingHandle,
 764             ChildHandleBuffer[Index]
 765             );
 766
 767       Status = gBS->UninstallMultipleProtocolInterfaces (
 768                       ChildHandleBuffer[Index],
 769                       &gEfiSimpleTextInProtocolGuid,
 770                       &TerminalDevice->SimpleInput,
 771                       &gEfiSimpleTextOutProtocolGuid,
 772                       &TerminalDevice->SimpleTextOutput,
 773                       &gEfiDevicePathProtocolGuid,
 774                       TerminalDevice->DevicePath,
 775                       NULL
 776                       );
 777       if (EFI_ERROR (Status)) {
 778         gBS->OpenProtocol (
 779               Controller,
 780               &gEfiSerialIoProtocolGuid,
 781               (VOID **) &SerialIo,
 782               This->DriverBindingHandle,
 783               ChildHandleBuffer[Index],
 784               EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 785               );
 786       } else {
 787
 788         if (TerminalDevice->ControllerNameTable != NULL) {
 789           FreeUnicodeStringTable (TerminalDevice->ControllerNameTable);
 790         }
 791
 792         Status = gBS->OpenProtocol (
 793                         ChildHandleBuffer[Index],
 794                         &gEfiHotPlugDeviceGuid,
 795                         NULL,
 796                         This->DriverBindingHandle,
 797                         Controller,
 798                         EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 799                         );
 800         if (!EFI_ERROR (Status)) {
 801           Status = gBS->UninstallMultipleProtocolInterfaces (
 802                           ChildHandleBuffer[Index],
 803                           &gEfiHotPlugDeviceGuid,
 804                           NULL,
 805                           NULL
 806                           );
 807         } else {
 808           Status = EFI_SUCCESS;
 809         }
 810
 811         gBS->CloseEvent (TerminalDevice->TwoSecondTimeOut);
 812         gBS->CloseEvent (TerminalDevice->SimpleInput.WaitForKey);
 813         FreePool (TerminalDevice->DevicePath);
 814         FreePool (TerminalDevice);
 815       }
 816     }
 817
 818     if (EFI_ERROR (Status)) {
 819       AllChildrenStopped = FALSE;
 820     }
 821   }
 822
 823   if (!AllChildrenStopped) {
 824     return EFI_DEVICE_ERROR;
 825   }
 826
 827   return EFI_SUCCESS;
 828 }
 829
 830 VOID
 831 TerminalUpdateConsoleDevVariable (
 832   IN CHAR16                    *VariableName,
 833   IN EFI_DEVICE_PATH_PROTOCOL  *ParentDevicePath
 834   )
 835 {
 836   EFI_STATUS                Status;
 837   UINTN                     VariableSize;
 838   UINT8                     TerminalType;
 839   EFI_DEVICE_PATH_PROTOCOL  *Variable;
 840   EFI_DEVICE_PATH_PROTOCOL  *NewVariable;
 841   EFI_DEVICE_PATH_PROTOCOL  *TempDevicePath;
 842
 843   Variable = NULL;
 844
 845   //
 846   // Get global variable and its size according to the name given.
 847   //
 848   Variable = TerminalGetVariableAndSize (
 849               VariableName,
 850               &gEfiGlobalVariableGuid,
 851               &VariableSize
 852               );
 853   //
 854   // Append terminal device path onto the variable.
 855   //
 856   for (TerminalType = PcAnsiType; TerminalType <= VTUTF8Type; TerminalType++) {
 857     SetTerminalDevicePath (TerminalType, ParentDevicePath, &TempDevicePath);
 858     NewVariable = AppendDevicePathInstance (Variable, TempDevicePath);
 859     if (Variable != NULL) {
 860       FreePool (Variable);
 861     }
 862
 863     if (TempDevicePath != NULL) {
 864       FreePool (TempDevicePath);
 865     }
 866
 867     Variable = NewVariable;
 868   }
 869
 870   VariableSize = GetDevicePathSize (Variable);
 871
 872   Status = gRT->SetVariable (
 873                   VariableName,
 874                   &gEfiGlobalVariableGuid,
 875                   EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 876                   VariableSize,
 877                   Variable
 878                   );
 879   ASSERT_EFI_ERROR (Status);
 880   FreePool (Variable);
 881
 882   return ;
 883 }
 884
 885 VOID
 886 TerminalRemoveConsoleDevVariable (
 887   IN CHAR16                    *VariableName,
 888   IN EFI_DEVICE_PATH_PROTOCOL  *ParentDevicePath
 889   )
 890 /*++
 891
 892   Routine Description:
 893
 894     Remove console device variable.
 895
 896   Arguments:
 897
 898     VariableName     - A pointer to the variable name.
 899     ParentDevicePath - A pointer to the parent device path.
 900
 901   Returns:
 902
 903 --*/
 904 {
 905   EFI_STATUS                Status;
 906   BOOLEAN                   FoundOne;
 907   BOOLEAN                   Match;
 908   UINTN                     VariableSize;
 909   UINTN                     InstanceSize;
 910   UINT8                     TerminalType;
 911   EFI_DEVICE_PATH_PROTOCOL  *Instance;
 912   EFI_DEVICE_PATH_PROTOCOL  *Variable;
 913   EFI_DEVICE_PATH_PROTOCOL  *OriginalVariable;
 914   EFI_DEVICE_PATH_PROTOCOL  *NewVariable;
 915   EFI_DEVICE_PATH_PROTOCOL  *SavedNewVariable;
 916   EFI_DEVICE_PATH_PROTOCOL  *TempDevicePath;
 917
 918   Variable  = NULL;
 919   Instance  = NULL;
 920
 921   //
 922   // Get global variable and its size according to the name given.
 923   //
 924   Variable = TerminalGetVariableAndSize (
 925               VariableName,
 926               &gEfiGlobalVariableGuid,
 927               &VariableSize
 928               );
 929   if (Variable == NULL) {
 930     return ;
 931   }
 932
 933   FoundOne          = FALSE;
 934   OriginalVariable  = Variable;
 935   NewVariable       = NULL;
 936
 937   //
 938   // Get first device path instance from Variable
 939   //
 940   Instance = GetNextDevicePathInstance (&Variable, &InstanceSize);
 941   if (Instance == NULL) {
 942     FreePool (OriginalVariable);
 943     return ;
 944   }
 945   //
 946   // Loop through all the device path instances of Variable
 947   //
 948   do {
 949     //
 950     // Loop through all the terminal types that this driver supports
 951     //
 952     Match = FALSE;
 953     for (TerminalType = PcAnsiType; TerminalType <= VTUTF8Type; TerminalType++) {
 954
 955       SetTerminalDevicePath (TerminalType, ParentDevicePath, &TempDevicePath);
 956
 957       //
 958       // Compare the genterated device path to the current device path instance
 959       //
 960       if (TempDevicePath != NULL) {
 961         if (CompareMem (Instance, TempDevicePath, InstanceSize) == 0) {
 962           Match     = TRUE;
 963           FoundOne  = TRUE;
 964         }
 965
 966         FreePool (TempDevicePath);
 967       }
 968     }
 969     //
 970     // If a match was not found, then keep the current device path instance
 971     //
 972     if (!Match) {
 973       SavedNewVariable  = NewVariable;
 974       NewVariable       = AppendDevicePathInstance (NewVariable, Instance);
 975       if (SavedNewVariable != NULL) {
 976         FreePool (SavedNewVariable);
 977       }
 978     }
 979     //
 980     // Get next device path instance from Variable
 981     //
 982     FreePool (Instance);
 983     Instance = GetNextDevicePathInstance (&Variable, &InstanceSize);
 984   } while (Instance != NULL);
 985
 986   FreePool (OriginalVariable);
 987
 988   if (FoundOne) {
 989     VariableSize = GetDevicePathSize (NewVariable);
 990
 991     Status = gRT->SetVariable (
 992                     VariableName,
 993                     &gEfiGlobalVariableGuid,
 994                     EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 995                     VariableSize,
 996                     NewVariable
 997                     );
 998     ASSERT_EFI_ERROR (Status);
 999   }
1000
1001   if (NewVariable != NULL) {
1002     FreePool (NewVariable);
1003   }
1004
1005   return ;
1006 }
1007
1008 VOID *
1009 TerminalGetVariableAndSize (
1010   IN  CHAR16              *Name,
1011   IN  EFI_GUID            *VendorGuid,
1012   OUT UINTN               *VariableSize
1013   )
1014 /*++
1015
1016 Routine Description:
1017   Read the EFI variable (VendorGuid/Name) and return a dynamically allocated
1018   buffer, and the size of the buffer. On failure return NULL.
1019
1020 Arguments:
1021   Name       - String part of EFI variable name
1022
1023   VendorGuid - GUID part of EFI variable name
1024
1025   VariableSize - Returns the size of the EFI variable that was read
1026
1027 Returns:
1028   Dynamically allocated memory that contains a copy of the EFI variable.
1029   Caller is repsoncible freeing the buffer.
1030
1031   NULL - Variable was not read
1032
1033 --*/
1034 {
1035   EFI_STATUS  Status;
1036   UINTN       BufferSize;
1037   VOID        *Buffer;
1038
1039   Buffer = NULL;
1040
1041   //
1042   // Pass in a small size buffer to find the actual variable size.
1043   //
1044   BufferSize  = 1;
1045   Buffer      = AllocatePool (BufferSize);
1046   if (Buffer == NULL) {
1047     *VariableSize = 0;
1048     return NULL;
1049   }
1050
1051   Status = gRT->GetVariable (Name, VendorGuid, NULL, &BufferSize, Buffer);
1052
1053   if (Status == EFI_SUCCESS) {
1054     *VariableSize = BufferSize;
1055     return Buffer;
1056
1057   } else if (Status == EFI_BUFFER_TOO_SMALL) {
1058     //
1059     // Allocate the buffer to return
1060     //
1061     FreePool (Buffer);
1062     Buffer = AllocatePool (BufferSize);
1063     if (Buffer == NULL) {
1064       *VariableSize = 0;
1065       return NULL;
1066     }
1067     //
1068     // Read variable into the allocated buffer.
1069     //
1070     Status = gRT->GetVariable (Name, VendorGuid, NULL, &BufferSize, Buffer);
1071     if (EFI_ERROR (Status)) {
1072       BufferSize = 0;
1073       FreePool (Buffer);
1074       Buffer = NULL;
1075     }
1076   } else {
1077     //
1078     // Variable not found or other errors met.
1079     //
1080     BufferSize = 0;
1081     FreePool (Buffer);
1082     Buffer = NULL;
1083   }
1084
1085   *VariableSize = BufferSize;
1086   return Buffer;
1087 }
1088
1089 EFI_STATUS
1090 SetTerminalDevicePath (
1091   IN  UINT8                       TerminalType,
1092   IN  EFI_DEVICE_PATH_PROTOCOL    *ParentDevicePath,
1093   OUT EFI_DEVICE_PATH_PROTOCOL    **TerminalDevicePath
1094   )
1095 {
1096   VENDOR_DEVICE_PATH  Node;
1097
1098   *TerminalDevicePath = NULL;
1099   Node.Header.Type    = MESSAGING_DEVICE_PATH;
1100   Node.Header.SubType = MSG_VENDOR_DP;
1101
1102   //
1103   // generate terminal device path node according to terminal type.
1104   //
1105   switch (TerminalType) {
1106
1107   case PcAnsiType:
1108     CopyMem (
1109       &Node.Guid,
1110       &gEfiPcAnsiGuid,
1111       sizeof (EFI_GUID)
1112       );
1113     break;
1114
1115   case VT100Type:
1116     CopyMem (
1117       &Node.Guid,
1118       &gEfiVT100Guid,
1119       sizeof (EFI_GUID)
1120       );
1121     break;
1122
1123   case VT100PlusType:
1124     CopyMem (
1125       &Node.Guid,
1126       &gEfiVT100PlusGuid,
1127       sizeof (EFI_GUID)
1128       );
1129     break;
1130
1131   case VTUTF8Type:
1132     CopyMem (
1133       &Node.Guid,
1134       &gEfiVTUTF8Guid,
1135       sizeof (EFI_GUID)
1136       );
1137     break;
1138
1139   default:
1140     return EFI_UNSUPPORTED;
1141     break;
1142   }
1143
1144   SetDevicePathNodeLength (
1145     &Node.Header,
1146     sizeof (VENDOR_DEVICE_PATH)
1147     );
1148   //
1149   // append the terminal node onto parent device path
1150   // to generate a complete terminal device path.
1151   //
1152   *TerminalDevicePath = AppendDevicePathNode (
1153                           ParentDevicePath,
1154                           (EFI_DEVICE_PATH_PROTOCOL *) &Node
1155                           );
1156   if (*TerminalDevicePath == NULL) {
1157     return EFI_OUT_OF_RESOURCES;
1158   }
1159
1160   return EFI_SUCCESS;
1161 }
1162
1163 VOID
1164 InitializeRawFiFo (
1165   IN  TERMINAL_DEV  *TerminalDevice
1166   )
1167 {
1168   //
1169   // Make the raw fifo empty.
1170   //
1171   TerminalDevice->RawFiFo.Head = TerminalDevice->RawFiFo.Tail;
1172 }
1173
1174 VOID
1175 InitializeUnicodeFiFo (
1176   IN  TERMINAL_DEV  *TerminalDevice
1177   )
1178 {
1179   //
1180   // Make the unicode fifo empty
1181   //
1182   TerminalDevice->UnicodeFiFo.Head = TerminalDevice->UnicodeFiFo.Tail;
1183 }
1184
1185 VOID
1186 InitializeEfiKeyFiFo (
1187   IN  TERMINAL_DEV  *TerminalDevice
1188   )
1189 {
1190   //
1191   // Make the efi key fifo empty
1192   //
1193   TerminalDevice->EfiKeyFiFo.Head = TerminalDevice->EfiKeyFiFo.Tail;
1194 }