Nt32Pkg/WinNtSerialIoDxe/WinNtSerialIo.c

   1 /**@file
   2
   3 Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
   4 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   WinNtSerialIo.c
  15
  16 Abstract:
  17
  18   Our DriverBinding member functions operate on the handles
  19   created by the NT Bus driver.
  20
  21   Handle(1) - WinNtIo - DevicePath(1)
  22
  23   If a serial port is added to the system this driver creates a new handle.
  24   The new handle is required, since the serial device must add an UART device
  25   pathnode.
  26
  27   Handle(2) - SerialIo - DevicePath(1)\UART
  28
  29   The driver then adds a gEfiWinNtSerialPortGuid as a protocol to Handle(1).
  30   The instance data for this protocol is the private data used to create
  31   Handle(2).
  32
  33   Handle(1) - WinNtIo - DevicePath(1) - WinNtSerialPort
  34
  35   If the driver is unloaded Handle(2) is removed from the system and
  36   gEfiWinNtSerialPortGuid is removed from Handle(1).
  37
  38   Note: Handle(1) is any handle created by the Win NT Bus driver that is passed
  39   into the DriverBinding member functions of this driver. This driver requires
  40   a Handle(1) to contain a WinNtIo protocol, a DevicePath protocol, and
  41   the TypeGuid in the WinNtIo must be gEfiWinNtSerialPortGuid.
  42
  43   If Handle(1) contains a gEfiWinNtSerialPortGuid protocol then the driver is
  44   loaded on the device.
  45
  46 **/
  47
  48 #include "WinNtSerialIo.h"
  49
  50 EFI_DRIVER_BINDING_PROTOCOL gWinNtSerialIoDriverBinding = {
  51   WinNtSerialIoDriverBindingSupported,
  52   WinNtSerialIoDriverBindingStart,
  53   WinNtSerialIoDriverBindingStop,
  54   0xa,
  55   NULL,
  56   NULL
  57 };
  58
  59 //
  60 // List of supported baud rate
  61 //
  62 UINT64 mBaudRateCurrentSupport[] = {50, 75, 110, 134, 150, 300, 600, 1200, 1800, 2000, 2400, 3600, 4800, 7200, 9600, 19200, 38400, 57600, 115200, SERIAL_PORT_MAX_BAUD_RATE + 1};
  63
  64 /**
  65   Check the device path node whether it's the Flow Control node or not.
  66
  67   @param[in] FlowControl    The device path node to be checked.
  68
  69   @retval TRUE              It's the Flow Control node.
  70   @retval FALSE             It's not.
  71
  72 **/
  73 BOOLEAN
  74 IsUartFlowControlNode (
  75   IN UART_FLOW_CONTROL_DEVICE_PATH *FlowControl
  76   )
  77 {
  78   return (BOOLEAN) (
  79            (DevicePathType (FlowControl) == MESSAGING_DEVICE_PATH) &&
  80            (DevicePathSubType (FlowControl) == MSG_VENDOR_DP) &&
  81            (CompareGuid (&FlowControl->Guid, &gEfiUartDevicePathGuid))
  82            );
  83 }
  84
  85 /**
  86   Check the device path node whether it contains Flow Control node or not.
  87
  88   @param[in] DevicePath     The device path to be checked.
  89
  90   @retval TRUE              It contains the Flow Control node.
  91   @retval FALSE             It doesn't.
  92
  93 **/
  94 BOOLEAN
  95 ContainsFlowControl (
  96   IN EFI_DEVICE_PATH_PROTOCOL      *DevicePath
  97   )
  98 {
  99   while (!IsDevicePathEnd (DevicePath)) {
 100     if (IsUartFlowControlNode ((UART_FLOW_CONTROL_DEVICE_PATH *) DevicePath)) {
 101       return TRUE;
 102     }
 103     DevicePath = NextDevicePathNode (DevicePath);
 104   }
 105
 106   return FALSE;
 107 }
 108
 109 /**
 110   The user Entry Point for module WinNtSerialIo. The user code starts with this function.
 111
 112   @param[in] ImageHandle    The firmware allocated handle for the EFI image.
 113   @param[in] SystemTable    A pointer to the EFI System Table.
 114
 115   @retval EFI_SUCCESS       The entry point is executed successfully.
 116   @retval other             Some error occurs when executing this entry point.
 117
 118 **/
 119 EFI_STATUS
 120 EFIAPI
 121 InitializeWinNtSerialIo(
 122   IN EFI_HANDLE           ImageHandle,
 123   IN EFI_SYSTEM_TABLE     *SystemTable
 124   )
 125 {
 126   EFI_STATUS              Status;
 127
 128   //
 129   // Install driver model protocol(s).
 130   //
 131   Status = EfiLibInstallDriverBindingComponentName2 (
 132              ImageHandle,
 133              SystemTable,
 134              &gWinNtSerialIoDriverBinding,
 135              ImageHandle,
 136              &gWinNtSerialIoComponentName,
 137              &gWinNtSerialIoComponentName2
 138              );
 139   ASSERT_EFI_ERROR (Status);
 140
 141
 142   return Status;
 143 }
 144
 145 EFI_STATUS
 146 EFIAPI
 147 WinNtSerialIoDriverBindingSupported (
 148   IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
 149   IN  EFI_HANDLE                    Handle,
 150   IN  EFI_DEVICE_PATH_PROTOCOL      *RemainingDevicePath
 151   )
 152 /*++
 153
 154 Routine Description:
 155
 156 Arguments:
 157
 158 Returns:
 159
 160   None
 161
 162 --*/
 163 // TODO:    This - add argument and description to function comment
 164 // TODO:    Handle - add argument and description to function comment
 165 // TODO:    RemainingDevicePath - add argument and description to function comment
 166 // TODO:    EFI_SUCCESS - add return value to function comment
 167 // TODO:    EFI_SUCCESS - add return value to function comment
 168 {
 169   EFI_STATUS                          Status;
 170   EFI_DEVICE_PATH_PROTOCOL            *ParentDevicePath;
 171   EFI_WIN_NT_IO_PROTOCOL              *WinNtIo;
 172   UART_DEVICE_PATH                    *UartNode;
 173   EFI_DEVICE_PATH_PROTOCOL            *DevicePath;
 174   UART_FLOW_CONTROL_DEVICE_PATH       *FlowControlNode;
 175   EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfoBuffer;
 176   UINTN                               EntryCount;
 177   UINTN                               Index;
 178   BOOLEAN                             RemainingDevicePathContainsFlowControl;
 179
 180   //
 181   // Check RemainingDevicePath validation
 182   //
 183   if (RemainingDevicePath != NULL) {
 184     //
 185     // Check if RemainingDevicePath is the End of Device Path Node,
 186     // if yes, go on checking other conditions
 187     //
 188     if (!IsDevicePathEnd (RemainingDevicePath)) {
 189       //
 190       // If RemainingDevicePath isn't the End of Device Path Node,
 191       // check its validation
 192       //
 193       Status = EFI_UNSUPPORTED;
 194
 195       UartNode  = (UART_DEVICE_PATH *) RemainingDevicePath;
 196       if (UartNode->Header.Type != MESSAGING_DEVICE_PATH ||
 197           UartNode->Header.SubType != MSG_UART_DP ||
 198           DevicePathNodeLength((EFI_DEVICE_PATH_PROTOCOL *)UartNode) != sizeof(UART_DEVICE_PATH)) {
 199         goto Error;
 200       }
 201       if ( UartNode->BaudRate > SERIAL_PORT_MAX_BAUD_RATE) {
 202         goto Error;
 203       }
 204       if (UartNode->Parity < NoParity || UartNode->Parity > SpaceParity) {
 205         goto Error;
 206       }
 207       if (UartNode->DataBits < 5 || UartNode->DataBits > 8) {
 208         goto Error;
 209       }
 210       if (UartNode->StopBits < OneStopBit || UartNode->StopBits > TwoStopBits) {
 211         goto Error;
 212       }
 213       if ((UartNode->DataBits == 5) && (UartNode->StopBits == TwoStopBits)) {
 214         goto Error;
 215       }
 216       if ((UartNode->DataBits >= 6) && (UartNode->DataBits <= 8) && (UartNode->StopBits == OneFiveStopBits)) {
 217         goto Error;
 218       }
 219
 220       FlowControlNode = (UART_FLOW_CONTROL_DEVICE_PATH *) NextDevicePathNode (UartNode);
 221       if (IsUartFlowControlNode (FlowControlNode)) {
 222         //
 223         // If the second node is Flow Control Node,
 224         //   return error when it request other than hardware flow control.
 225         //
 226         if ((FlowControlNode->FlowControlMap & ~UART_FLOW_CONTROL_HARDWARE) != 0) {
 227           goto Error;
 228         }
 229       }
 230     }
 231   }
 232
 233   //
 234   // Open the IO Abstraction(s) needed to perform the supported test
 235   //
 236   Status = gBS->OpenProtocol (
 237                   Handle,
 238                   &gEfiWinNtIoProtocolGuid,
 239                   (VOID **) &WinNtIo,
 240                   This->DriverBindingHandle,
 241                   Handle,
 242                   EFI_OPEN_PROTOCOL_BY_DRIVER
 243                   );
 244   if (Status == EFI_ALREADY_STARTED) {
 245     if (RemainingDevicePath == NULL || IsDevicePathEnd (RemainingDevicePath)) {
 246       //
 247       // If RemainingDevicePath is NULL or is the End of Device Path Node
 248       //
 249       return EFI_SUCCESS;
 250     }
 251     //
 252     // When the driver has produced device path with flow control node but RemainingDevicePath only contains UART node,
 253     //   return unsupported, and vice versa.
 254     //
 255     Status = gBS->OpenProtocolInformation (
 256                     Handle,
 257                     &gEfiWinNtIoProtocolGuid,
 258                     &OpenInfoBuffer,
 259                     &EntryCount
 260                     );
 261     if (EFI_ERROR (Status)) {
 262       return Status;
 263     }
 264
 265     //
 266     // See if RemainingDevicePath has a Flow Control device path node
 267     //
 268     RemainingDevicePathContainsFlowControl = ContainsFlowControl (RemainingDevicePath);
 269
 270     for (Index = 0; Index < EntryCount; Index++) {
 271       if ((OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
 272         Status = gBS->OpenProtocol (
 273                         OpenInfoBuffer[Index].ControllerHandle,
 274                         &gEfiDevicePathProtocolGuid,
 275                         (VOID **) &DevicePath,
 276                         This->DriverBindingHandle,
 277                         Handle,
 278                         EFI_OPEN_PROTOCOL_GET_PROTOCOL
 279                         );
 280         if (!EFI_ERROR (Status)) {
 281           if (RemainingDevicePathContainsFlowControl ^ ContainsFlowControl (DevicePath)) {
 282             Status = EFI_UNSUPPORTED;
 283           }
 284         }
 285         break;
 286       }
 287     }
 288     FreePool (OpenInfoBuffer);
 289     return Status;
 290   }
 291
 292   if (EFI_ERROR (Status)) {
 293     return Status;
 294   }
 295
 296   //
 297   // Close the I/O Abstraction(s) used to perform the supported test
 298   //
 299   gBS->CloseProtocol (
 300         Handle,
 301         &gEfiWinNtIoProtocolGuid,
 302         This->DriverBindingHandle,
 303         Handle
 304         );
 305
 306   //
 307   // Open the EFI Device Path protocol needed to perform the supported test
 308   //
 309   Status = gBS->OpenProtocol (
 310                   Handle,
 311                   &gEfiDevicePathProtocolGuid,
 312                   (VOID **) &ParentDevicePath,
 313                   This->DriverBindingHandle,
 314                   Handle,
 315                   EFI_OPEN_PROTOCOL_BY_DRIVER
 316                   );
 317   if (Status == EFI_ALREADY_STARTED) {
 318     return EFI_SUCCESS;
 319   }
 320
 321   if (EFI_ERROR (Status)) {
 322     return Status;
 323   }
 324
 325   //
 326   // Close protocol, don't use device path protocol in the Support() function
 327   //
 328   gBS->CloseProtocol (
 329         Handle,
 330         &gEfiDevicePathProtocolGuid,
 331         This->DriverBindingHandle,
 332         Handle
 333         );
 334
 335   //
 336   // Make sure that the WinNt Thunk Protocol is valid
 337   //
 338   if (WinNtIo->WinNtThunk->Signature != EFI_WIN_NT_THUNK_PROTOCOL_SIGNATURE) {
 339     Status = EFI_UNSUPPORTED;
 340     goto Error;
 341   }
 342
 343   //
 344   // Check the GUID to see if this is a handle type the driver supports
 345   //
 346   if (!CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtSerialPortGuid)) {
 347     Status = EFI_UNSUPPORTED;
 348     goto Error;
 349   }
 350
 351   return EFI_SUCCESS;
 352
 353 Error:
 354   return Status;
 355 }
 356
 357 EFI_STATUS
 358 EFIAPI
 359 WinNtSerialIoDriverBindingStart (
 360   IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
 361   IN  EFI_HANDLE                    Handle,
 362   IN  EFI_DEVICE_PATH_PROTOCOL      *RemainingDevicePath
 363   )
 364 /*++
 365
 366 Routine Description:
 367
 368 Arguments:
 369
 370 Returns:
 371
 372   None
 373
 374 --*/
 375 // TODO:    This - add argument and description to function comment
 376 // TODO:    Handle - add argument and description to function comment
 377 // TODO:    RemainingDevicePath - add argument and description to function comment
 378 // TODO:    EFI_SUCCESS - add return value to function comment
 379 // TODO:    EFI_SUCCESS - add return value to function comment
 380 {
 381   EFI_STATUS                          Status;
 382   EFI_WIN_NT_IO_PROTOCOL              *WinNtIo;
 383   WIN_NT_SERIAL_IO_PRIVATE_DATA       *Private;
 384   HANDLE                              NtHandle;
 385   UART_DEVICE_PATH                    UartNode;
 386   EFI_DEVICE_PATH_PROTOCOL            *ParentDevicePath;
 387   EFI_OPEN_PROTOCOL_INFORMATION_ENTRY *OpenInfoBuffer;
 388   UINTN                               EntryCount;
 389   UINTN                               Index;
 390   EFI_SERIAL_IO_PROTOCOL              *SerialIo;
 391   UART_DEVICE_PATH                    *Uart;
 392   UINT32                              FlowControlMap;
 393   UART_FLOW_CONTROL_DEVICE_PATH       *FlowControl;
 394   EFI_DEVICE_PATH_PROTOCOL            *TempDevicePath;
 395   UINT32                              Control;
 396
 397   Private   = NULL;
 398   NtHandle  = INVALID_HANDLE_VALUE;
 399
 400   //
 401   // Get the Parent Device Path
 402   //
 403   Status = gBS->OpenProtocol (
 404                   Handle,
 405                   &gEfiDevicePathProtocolGuid,
 406                   (VOID **) &ParentDevicePath,
 407                   This->DriverBindingHandle,
 408                   Handle,
 409                   EFI_OPEN_PROTOCOL_BY_DRIVER
 410                   );
 411   if (EFI_ERROR (Status) && Status != EFI_ALREADY_STARTED) {
 412     return Status;
 413   }
 414
 415   //
 416   // Grab the IO abstraction we need to get any work done
 417   //
 418   Status = gBS->OpenProtocol (
 419                   Handle,
 420                   &gEfiWinNtIoProtocolGuid,
 421                   (VOID **) &WinNtIo,
 422                   This->DriverBindingHandle,
 423                   Handle,
 424                   EFI_OPEN_PROTOCOL_BY_DRIVER
 425                   );
 426   if (EFI_ERROR (Status) && Status != EFI_ALREADY_STARTED) {
 427     gBS->CloseProtocol (
 428           Handle,
 429           &gEfiDevicePathProtocolGuid,
 430           This->DriverBindingHandle,
 431           Handle
 432           );
 433     return Status;
 434   }
 435
 436   if (Status == EFI_ALREADY_STARTED) {
 437
 438     if (RemainingDevicePath == NULL || IsDevicePathEnd (RemainingDevicePath)) {
 439       //
 440       // If RemainingDevicePath is NULL or is the End of Device Path Node
 441       //
 442       return EFI_SUCCESS;
 443     }
 444
 445     //
 446     // Make sure a child handle does not already exist.  This driver can only
 447     // produce one child per serial port.
 448     //
 449     Status = gBS->OpenProtocolInformation (
 450                     Handle,
 451                     &gEfiWinNtIoProtocolGuid,
 452                     &OpenInfoBuffer,
 453                     &EntryCount
 454                     );
 455     if (EFI_ERROR (Status)) {
 456       return Status;
 457     }
 458
 459     Status = EFI_ALREADY_STARTED;
 460     for (Index = 0; Index < EntryCount; Index++) {
 461       if ((OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
 462         Status = gBS->OpenProtocol (
 463                         OpenInfoBuffer[Index].ControllerHandle,
 464                         &gEfiSerialIoProtocolGuid,
 465                         (VOID **) &SerialIo,
 466                         This->DriverBindingHandle,
 467                         Handle,
 468                         EFI_OPEN_PROTOCOL_GET_PROTOCOL
 469                         );
 470         if (!EFI_ERROR (Status)) {
 471           Uart   = (UART_DEVICE_PATH *) RemainingDevicePath;
 472           Status = SerialIo->SetAttributes (
 473                                SerialIo,
 474                                Uart->BaudRate,
 475                                SerialIo->Mode->ReceiveFifoDepth,
 476                                SerialIo->Mode->Timeout,
 477                                (EFI_PARITY_TYPE) Uart->Parity,
 478                                Uart->DataBits,
 479                                (EFI_STOP_BITS_TYPE) Uart->StopBits
 480                                );
 481           FlowControl = (UART_FLOW_CONTROL_DEVICE_PATH *) NextDevicePathNode (Uart);
 482           if (!EFI_ERROR (Status) && IsUartFlowControlNode (FlowControl)) {
 483             Status = SerialIo->GetControl (SerialIo, &Control);
 484             if (!EFI_ERROR (Status)) {
 485               if (FlowControl->FlowControlMap == UART_FLOW_CONTROL_HARDWARE) {
 486                 Control |= EFI_SERIAL_HARDWARE_FLOW_CONTROL_ENABLE;
 487               } else {
 488                 Control &= ~EFI_SERIAL_HARDWARE_FLOW_CONTROL_ENABLE;
 489               }
 490               //
 491               // Clear the bits that are not allowed to pass to SetControl
 492               //
 493               Control &= (EFI_SERIAL_REQUEST_TO_SEND | EFI_SERIAL_DATA_TERMINAL_READY |
 494                           EFI_SERIAL_HARDWARE_LOOPBACK_ENABLE | EFI_SERIAL_SOFTWARE_LOOPBACK_ENABLE |
 495                           EFI_SERIAL_HARDWARE_FLOW_CONTROL_ENABLE);
 496               Status = SerialIo->SetControl (SerialIo, Control);
 497             }
 498           }
 499         }
 500         break;
 501       }
 502     }
 503
 504     FreePool (OpenInfoBuffer);
 505     return Status;
 506   }
 507
 508   FlowControl    = NULL;
 509   FlowControlMap = 0;
 510   if (RemainingDevicePath == NULL) {
 511     //
 512     // Build the device path by appending the UART node to the ParentDevicePath
 513     // from the WinNtIo handle. The Uart setings are zero here, since
 514     // SetAttribute() will update them to match the default setings.
 515     //
 516     ZeroMem (&UartNode, sizeof (UART_DEVICE_PATH));
 517     UartNode.Header.Type     = MESSAGING_DEVICE_PATH;
 518     UartNode.Header.SubType  = MSG_UART_DP;
 519     SetDevicePathNodeLength ((EFI_DEVICE_PATH_PROTOCOL *) &UartNode, sizeof (UART_DEVICE_PATH));
 520
 521   } else if (!IsDevicePathEnd (RemainingDevicePath)) {
 522     //
 523     // If RemainingDevicePath isn't the End of Device Path Node,
 524     // only scan the specified device by RemainingDevicePath
 525     //
 526     //
 527     // Match the configuration of the RemainingDevicePath. IsHandleSupported()
 528     // already checked to make sure the RemainingDevicePath contains settings
 529     // that we can support.
 530     //
 531     CopyMem (&UartNode, RemainingDevicePath, sizeof (UART_DEVICE_PATH));
 532     FlowControl = (UART_FLOW_CONTROL_DEVICE_PATH *) NextDevicePathNode (RemainingDevicePath);
 533     if (IsUartFlowControlNode (FlowControl)) {
 534       FlowControlMap = FlowControl->FlowControlMap;
 535     } else {
 536       FlowControl    = NULL;
 537     }
 538
 539   } else {
 540     //
 541     // If RemainingDevicePath is the End of Device Path Node,
 542     // skip enumerate any device and return EFI_SUCESSS
 543     //
 544     return EFI_SUCCESS;
 545   }
 546
 547   //
 548   // Check to see if we can access the hardware device. If it's Open in NT we
 549   // will not get access.
 550   //
 551   NtHandle = WinNtIo->WinNtThunk->CreateFile (
 552                                     WinNtIo->EnvString,
 553                                     GENERIC_READ | GENERIC_WRITE,
 554                                     0,
 555                                     NULL,
 556                                     OPEN_EXISTING,
 557                                     0,
 558                                     NULL
 559                                     );
 560   if (NtHandle == INVALID_HANDLE_VALUE) {
 561     Status = EFI_DEVICE_ERROR;
 562     goto Error;
 563   }
 564
 565   //
 566   // Construct Private data
 567   //
 568   Private = AllocatePool (sizeof (WIN_NT_SERIAL_IO_PRIVATE_DATA));
 569   if (Private == NULL) {
 570     goto Error;
 571   }
 572
 573   //
 574   // This signature must be valid before any member function is called
 575   //
 576   Private->Signature              = WIN_NT_SERIAL_IO_PRIVATE_DATA_SIGNATURE;
 577   Private->NtHandle               = NtHandle;
 578   Private->ControllerHandle       = Handle;
 579   Private->Handle                 = NULL;
 580   Private->WinNtThunk             = WinNtIo->WinNtThunk;
 581   Private->ParentDevicePath       = ParentDevicePath;
 582   Private->ControllerNameTable    = NULL;
 583
 584   Private->SoftwareLoopbackEnable = FALSE;
 585   Private->HardwareLoopbackEnable = FALSE;
 586   Private->HardwareFlowControl    = (BOOLEAN) (FlowControlMap == UART_FLOW_CONTROL_HARDWARE);
 587   Private->Fifo.First             = 0;
 588   Private->Fifo.Last              = 0;
 589   Private->Fifo.Surplus           = SERIAL_MAX_BUFFER_SIZE;
 590
 591   CopyMem (&Private->UartDevicePath, &UartNode, sizeof (UART_DEVICE_PATH));
 592
 593   AddUnicodeString2 (
 594     "eng",
 595     gWinNtSerialIoComponentName.SupportedLanguages,
 596     &Private->ControllerNameTable,
 597     WinNtIo->EnvString,
 598     TRUE
 599     );
 600   AddUnicodeString2 (
 601     "en",
 602     gWinNtSerialIoComponentName2.SupportedLanguages,
 603     &Private->ControllerNameTable,
 604     WinNtIo->EnvString,
 605     FALSE
 606     );
 607
 608
 609   Private->SerialIo.Revision      = SERIAL_IO_INTERFACE_REVISION;
 610   Private->SerialIo.Reset         = WinNtSerialIoReset;
 611   Private->SerialIo.SetAttributes = WinNtSerialIoSetAttributes;
 612   Private->SerialIo.SetControl    = WinNtSerialIoSetControl;
 613   Private->SerialIo.GetControl    = WinNtSerialIoGetControl;
 614   Private->SerialIo.Write         = WinNtSerialIoWrite;
 615   Private->SerialIo.Read          = WinNtSerialIoRead;
 616   Private->SerialIo.Mode          = &Private->SerialIoMode;
 617
 618   //
 619   // Build the device path by appending the UART node to the ParentDevicePath
 620   // from the WinNtIo handle. The Uart setings are zero here, since
 621   // SetAttribute() will update them to match the current setings.
 622   //
 623   Private->DevicePath = AppendDevicePathNode (
 624                           ParentDevicePath,
 625                           (EFI_DEVICE_PATH_PROTOCOL *) &Private->UartDevicePath
 626                           );
 627   //
 628   // Only produce the FlowControl node when remaining device path has it
 629   //
 630   if (FlowControl != NULL) {
 631     TempDevicePath = Private->DevicePath;
 632     if (TempDevicePath != NULL) {
 633       Private->DevicePath = AppendDevicePathNode (
 634                               TempDevicePath,
 635                               (EFI_DEVICE_PATH_PROTOCOL *) FlowControl
 636                               );
 637       FreePool (TempDevicePath);
 638     }
 639   }
 640   if (Private->DevicePath == NULL) {
 641     Status = EFI_OUT_OF_RESOURCES;
 642     goto Error;
 643   }
 644
 645   //
 646   // Fill in Serial I/O Mode structure based on either the RemainingDevicePath or defaults.
 647   //
 648   Private->SerialIoMode.ControlMask       = SERIAL_CONTROL_MASK;
 649   Private->SerialIoMode.Timeout           = SERIAL_TIMEOUT_DEFAULT;
 650   Private->SerialIoMode.BaudRate          = Private->UartDevicePath.BaudRate;
 651   Private->SerialIoMode.ReceiveFifoDepth  = SERIAL_FIFO_DEFAULT;
 652   Private->SerialIoMode.DataBits          = Private->UartDevicePath.DataBits;
 653   Private->SerialIoMode.Parity            = Private->UartDevicePath.Parity;
 654   Private->SerialIoMode.StopBits          = Private->UartDevicePath.StopBits;
 655
 656   //
 657   // Issue a reset to initialize the COM port
 658   //
 659   Status = Private->SerialIo.Reset (&Private->SerialIo);
 660   if (EFI_ERROR (Status)) {
 661     goto Error;
 662   }
 663
 664   //
 665   // Create new child handle
 666   //
 667   Status = gBS->InstallMultipleProtocolInterfaces (
 668                   &Private->Handle,
 669                   &gEfiSerialIoProtocolGuid,
 670                   &Private->SerialIo,
 671                   &gEfiDevicePathProtocolGuid,
 672                   Private->DevicePath,
 673                   NULL
 674                   );
 675   if (EFI_ERROR (Status)) {
 676     goto Error;
 677   }
 678
 679   //
 680   // Open For Child Device
 681   //
 682   Status = gBS->OpenProtocol (
 683                   Handle,
 684                   &gEfiWinNtIoProtocolGuid,
 685                   (VOID **) &WinNtIo,
 686                   This->DriverBindingHandle,
 687                   Private->Handle,
 688                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 689                   );
 690   if (EFI_ERROR (Status)) {
 691     goto Error;
 692   }
 693
 694   return EFI_SUCCESS;
 695
 696 Error:
 697   //
 698   // Use the Stop() function to free all resources allocated in Start()
 699   //
 700   if (Private != NULL) {
 701     if (Private->Handle != NULL) {
 702       This->Stop (This, Handle, 1, &Private->Handle);
 703     } else {
 704       if (NtHandle != INVALID_HANDLE_VALUE) {
 705         Private->WinNtThunk->CloseHandle (NtHandle);
 706       }
 707
 708       if (Private->DevicePath != NULL) {
 709         FreePool (Private->DevicePath);
 710       }
 711
 712       FreeUnicodeStringTable (Private->ControllerNameTable);
 713
 714       FreePool (Private);
 715     }
 716   }
 717
 718   This->Stop (This, Handle, 0, NULL);
 719
 720   return Status;
 721 }
 722
 723 EFI_STATUS
 724 EFIAPI
 725 WinNtSerialIoDriverBindingStop (
 726   IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
 727   IN  EFI_HANDLE                    Handle,
 728   IN  UINTN                         NumberOfChildren,
 729   IN  EFI_HANDLE                    *ChildHandleBuffer
 730   )
 731 /*++
 732
 733 Routine Description:
 734
 735   TODO: Add function description
 736
 737 Arguments:
 738
 739   This              - TODO: add argument description
 740   Handle            - TODO: add argument description
 741   NumberOfChildren  - TODO: add argument description
 742   ChildHandleBuffer - TODO: add argument description
 743
 744 Returns:
 745
 746   EFI_DEVICE_ERROR - TODO: Add description for return value
 747   EFI_SUCCESS - TODO: Add description for return value
 748
 749 --*/
 750 {
 751   EFI_STATUS                    Status;
 752   UINTN                         Index;
 753   BOOLEAN                       AllChildrenStopped;
 754   EFI_SERIAL_IO_PROTOCOL        *SerialIo;
 755   WIN_NT_SERIAL_IO_PRIVATE_DATA *Private;
 756   EFI_WIN_NT_IO_PROTOCOL        *WinNtIo;
 757
 758   //
 759   // Complete all outstanding transactions to Controller.
 760   // Don't allow any new transaction to Controller to be started.
 761   //
 762
 763   if (NumberOfChildren == 0) {
 764     //
 765     // Close the bus driver
 766     //
 767     Status = gBS->CloseProtocol (
 768                     Handle,
 769                     &gEfiWinNtIoProtocolGuid,
 770                     This->DriverBindingHandle,
 771                     Handle
 772                     );
 773     Status = gBS->CloseProtocol (
 774                     Handle,
 775                     &gEfiDevicePathProtocolGuid,
 776                     This->DriverBindingHandle,
 777                     Handle
 778                     );
 779     return Status;
 780   }
 781
 782   AllChildrenStopped = TRUE;
 783
 784   for (Index = 0; Index < NumberOfChildren; Index++) {
 785     Status = gBS->OpenProtocol (
 786                     ChildHandleBuffer[Index],
 787                     &gEfiSerialIoProtocolGuid,
 788                     (VOID **) &SerialIo,
 789                     This->DriverBindingHandle,
 790                     Handle,
 791                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 792                     );
 793     if (!EFI_ERROR (Status)) {
 794       Private = WIN_NT_SERIAL_IO_PRIVATE_DATA_FROM_THIS (SerialIo);
 795
 796       ASSERT (Private->Handle == ChildHandleBuffer[Index]);
 797
 798       Status = gBS->CloseProtocol (
 799                       Handle,
 800                       &gEfiWinNtIoProtocolGuid,
 801                       This->DriverBindingHandle,
 802                       ChildHandleBuffer[Index]
 803                       );
 804
 805       Status = gBS->UninstallMultipleProtocolInterfaces (
 806                       ChildHandleBuffer[Index],
 807                       &gEfiSerialIoProtocolGuid,
 808                       &Private->SerialIo,
 809                       &gEfiDevicePathProtocolGuid,
 810                       Private->DevicePath,
 811                       NULL
 812                       );
 813
 814       if (EFI_ERROR (Status)) {
 815         gBS->OpenProtocol (
 816               Handle,
 817               &gEfiWinNtIoProtocolGuid,
 818               (VOID **) &WinNtIo,
 819               This->DriverBindingHandle,
 820               ChildHandleBuffer[Index],
 821               EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 822               );
 823       } else {
 824         Private->WinNtThunk->CloseHandle (Private->NtHandle);
 825
 826         FreePool (Private->DevicePath);
 827
 828         FreeUnicodeStringTable (Private->ControllerNameTable);
 829
 830         FreePool (Private);
 831       }
 832     }
 833
 834     if (EFI_ERROR (Status)) {
 835       AllChildrenStopped = FALSE;
 836     }
 837   }
 838
 839   if (!AllChildrenStopped) {
 840     return EFI_DEVICE_ERROR;
 841   }
 842
 843   return EFI_SUCCESS;
 844 }
 845
 846 //
 847 // Serial IO Protocol member functions
 848 //
 849
 850 EFI_STATUS
 851 EFIAPI
 852 WinNtSerialIoReset (
 853   IN EFI_SERIAL_IO_PROTOCOL *This
 854   )
 855 /*++
 856
 857 Routine Description:
 858
 859   TODO: Add function description
 860
 861 Arguments:
 862
 863   This  - TODO: add argument description
 864
 865 Returns:
 866
 867   TODO: add return values
 868
 869 --*/
 870 {
 871   WIN_NT_SERIAL_IO_PRIVATE_DATA *Private;
 872   EFI_TPL                       Tpl;
 873
 874   Tpl     = gBS->RaiseTPL (TPL_NOTIFY);
 875
 876   Private = WIN_NT_SERIAL_IO_PRIVATE_DATA_FROM_THIS (This);
 877
 878   Private->WinNtThunk->PurgeComm (
 879                         Private->NtHandle,
 880                         PURGE_TXCLEAR | PURGE_RXCLEAR
 881                         );
 882
 883   gBS->RestoreTPL (Tpl);
 884
 885   return This->SetAttributes (
 886                 This,
 887                 This->Mode->BaudRate,
 888                 This->Mode->ReceiveFifoDepth,
 889                 This->Mode->Timeout,
 890                 (EFI_PARITY_TYPE)This->Mode->Parity,
 891                 (UINT8) This->Mode->DataBits,
 892                 (EFI_STOP_BITS_TYPE)This->Mode->StopBits
 893                 );
 894 }
 895
 896 EFI_STATUS
 897 EFIAPI
 898 WinNtSerialIoSetAttributes (
 899   IN EFI_SERIAL_IO_PROTOCOL *This,
 900   IN UINT64                 BaudRate,
 901   IN UINT32                 ReceiveFifoDepth,
 902   IN UINT32                 Timeout,
 903   IN EFI_PARITY_TYPE        Parity,
 904   IN UINT8                  DataBits,
 905   IN EFI_STOP_BITS_TYPE     StopBits
 906   )
 907 /*++
 908
 909 Routine Description:
 910
 911   This function is used to set the attributes.
 912
 913 Arguments:
 914
 915   This              - A pointer to the EFI_SERIAL_IO_PROTOCOL structrue.
 916   BaudRate          - The Baud rate of the serial device.
 917   ReceiveFifoDepth  - The request depth of fifo on receive side.
 918   Timeout           - the request timeout for a single charact.
 919   Parity            - The type of parity used in serial device.
 920   DataBits          - Number of deata bits used in serial device.
 921   StopBits          - Number of stop bits used in serial device.
 922
 923 Returns:
 924   Status code
 925
 926   None
 927
 928 --*/
 929 // TODO:    EFI_SUCCESS - add return value to function comment
 930 // TODO:    EFI_DEVICE_ERROR - add return value to function comment
 931 // TODO:    EFI_DEVICE_ERROR - add return value to function comment
 932 // TODO:    EFI_DEVICE_ERROR - add return value to function comment
 933 // TODO:    EFI_SUCCESS - add return value to function comment
 934 // TODO:    EFI_DEVICE_ERROR - add return value to function comment
 935 // TODO:    EFI_SUCCESS - add return value to function comment
 936 {
 937   EFI_STATUS                    Status;
 938   UINTN                         Index;
 939   WIN_NT_SERIAL_IO_PRIVATE_DATA *Private;
 940   COMMTIMEOUTS                  PortTimeOuts;
 941   DWORD                         ConvertedTime;
 942   BOOL                          Result;
 943   UART_DEVICE_PATH              *Uart;
 944   EFI_TPL                       Tpl;
 945
 946   Private = WIN_NT_SERIAL_IO_PRIVATE_DATA_FROM_THIS (This);
 947
 948   //
 949   //  Some of our arguments have defaults if a null value is passed in, and
 950   //   we must set the default values if a null argument is passed in.
 951   //
 952   if (BaudRate == 0) {
 953     BaudRate = PcdGet64 (PcdUartDefaultBaudRate);
 954   }
 955
 956   if (ReceiveFifoDepth == 0) {
 957     ReceiveFifoDepth = SERIAL_FIFO_DEFAULT;
 958   }
 959
 960   if (Timeout == 0) {
 961     Timeout = SERIAL_TIMEOUT_DEFAULT;
 962   }
 963
 964   if (Parity == DefaultParity) {
 965     Parity = (EFI_PARITY_TYPE) (PcdGet8 (PcdUartDefaultParity));
 966   }
 967
 968   if (DataBits == 0) {
 969     DataBits = PcdGet8 (PcdUartDefaultDataBits);
 970   }
 971
 972   if (StopBits == DefaultStopBits) {
 973     StopBits = (EFI_STOP_BITS_TYPE) PcdGet8 (PcdUartDefaultStopBits);
 974   }
 975
 976   //
 977   // Make sure all parameters are valid
 978   //
 979   if ((BaudRate > SERIAL_PORT_MAX_BAUD_RATE) || (BaudRate < SERIAL_PORT_MIN_BAUD_RATE)) {
 980     return EFI_INVALID_PARAMETER;
 981   }
 982
 983   //
 984   //The lower baud rate supported by the serial device will be selected without exceeding the unsupported BaudRate parameter
 985   //
 986
 987   for (Index = 1; Index < (sizeof (mBaudRateCurrentSupport) / sizeof (mBaudRateCurrentSupport[0])); Index++) {
 988     if (BaudRate < mBaudRateCurrentSupport[Index]) {
 989       BaudRate = mBaudRateCurrentSupport[Index-1];
 990       break;
 991       }
 992   }
 993
 994   if ((ReceiveFifoDepth < 1) || (ReceiveFifoDepth > SERIAL_PORT_MAX_RECEIVE_FIFO_DEPTH)) {
 995     return EFI_INVALID_PARAMETER;
 996   }
 997
 998   if ((Timeout < SERIAL_PORT_MIN_TIMEOUT) || (Timeout > SERIAL_PORT_MAX_TIMEOUT)) {
 999     return EFI_INVALID_PARAMETER;
1000   }
1001
1002   if ((Parity < NoParity) || (Parity > SpaceParity)) {
1003     return EFI_INVALID_PARAMETER;
1004   }
1005
1006   if ((StopBits < OneStopBit) || (StopBits > TwoStopBits)) {
1007     return EFI_INVALID_PARAMETER;
1008   }
1009
1010   //
1011   // Now we only support DataBits=7,8.
1012   //
1013   if ((DataBits < 7) || (DataBits > 8)) {
1014     return EFI_INVALID_PARAMETER;
1015   }
1016
1017   //
1018   // Now we only support DataBits=7,8.
1019   // for DataBits = 6,7,8, StopBits can not set OneFiveStopBits.
1020   //
1021   if (StopBits == OneFiveStopBits) {
1022     return EFI_INVALID_PARAMETER;
1023   }
1024
1025   //
1026   // See if the new attributes already match the current attributes
1027   //
1028   if (Private->UartDevicePath.BaudRate       == BaudRate         &&
1029       Private->UartDevicePath.DataBits       == DataBits         &&
1030       Private->UartDevicePath.Parity         == Parity           &&
1031       Private->UartDevicePath.StopBits       == StopBits         &&
1032       Private->SerialIoMode.ReceiveFifoDepth == ReceiveFifoDepth &&
1033       Private->SerialIoMode.Timeout          == Timeout             ) {
1034     return EFI_SUCCESS;
1035   }
1036
1037   Tpl     = gBS->RaiseTPL (TPL_NOTIFY);
1038
1039   //
1040   //  Get current values from NT
1041   //
1042   ZeroMem (&Private->NtDCB, sizeof (DCB));
1043   Private->NtDCB.DCBlength = sizeof (DCB);
1044
1045   if (!Private->WinNtThunk->GetCommState (Private->NtHandle, &Private->NtDCB)) {
1046     Private->NtError = Private->WinNtThunk->GetLastError ();
1047     DEBUG ((EFI_D_ERROR, "SerialSetAttributes: GetCommState %d\n", Private->NtError));
1048     gBS->RestoreTPL (Tpl);
1049     return EFI_DEVICE_ERROR;
1050   }
1051
1052   //
1053   // Map EFI com setting to NT
1054   //
1055   Private->NtDCB.BaudRate         = ConvertBaud2Nt (BaudRate);
1056   Private->NtDCB.ByteSize         = ConvertData2Nt (DataBits);
1057   Private->NtDCB.Parity           = ConvertParity2Nt (Parity);
1058   Private->NtDCB.StopBits         = ConvertStop2Nt (StopBits);
1059
1060   Private->NtDCB.fBinary          = TRUE;
1061   Private->NtDCB.fParity          = Private->NtDCB.Parity == NOPARITY ? FALSE : TRUE;
1062   Private->NtDCB.fOutxCtsFlow     = FALSE;
1063   Private->NtDCB.fOutxDsrFlow     = FALSE;
1064   Private->NtDCB.fDtrControl      = DTR_CONTROL_ENABLE;
1065   Private->NtDCB.fDsrSensitivity  = FALSE;
1066   Private->NtDCB.fOutX            = FALSE;
1067   Private->NtDCB.fInX             = FALSE;
1068   Private->NtDCB.fRtsControl      = RTS_CONTROL_ENABLE;
1069   Private->NtDCB.fNull            = FALSE;
1070
1071   //
1072   //  Set new values
1073   //
1074   Result = Private->WinNtThunk->SetCommState (Private->NtHandle, &Private->NtDCB);
1075   if (!Result) {
1076     Private->NtError = Private->WinNtThunk->GetLastError ();
1077     DEBUG ((EFI_D_ERROR, "SerialSetAttributes: SetCommState %d\n", Private->NtError));
1078     gBS->RestoreTPL (Tpl);
1079     return EFI_DEVICE_ERROR;
1080   }
1081
1082   //
1083   //  Set com port read/write timeout values
1084   //
1085   ConvertedTime = ConvertTime2Nt (Timeout);
1086   PortTimeOuts.ReadIntervalTimeout = MAXDWORD;
1087   PortTimeOuts.ReadTotalTimeoutMultiplier = 0;
1088   PortTimeOuts.ReadTotalTimeoutConstant = ConvertedTime;
1089   PortTimeOuts.WriteTotalTimeoutMultiplier = ConvertedTime == 0 ? 1 : ConvertedTime;
1090   PortTimeOuts.WriteTotalTimeoutConstant = 0;
1091
1092   if (!Private->WinNtThunk->SetCommTimeouts (Private->NtHandle, &PortTimeOuts)) {
1093     Private->NtError = Private->WinNtThunk->GetLastError ();
1094     DEBUG ((EFI_D_ERROR, "SerialSetAttributes: SetCommTimeouts %d\n", Private->NtError));
1095     gBS->RestoreTPL (Tpl);
1096     return EFI_DEVICE_ERROR;
1097   }
1098
1099   //
1100   //  Update mode
1101   //
1102   Private->SerialIoMode.BaudRate          = BaudRate;
1103   Private->SerialIoMode.ReceiveFifoDepth  = ReceiveFifoDepth;
1104   Private->SerialIoMode.Timeout           = Timeout;
1105   Private->SerialIoMode.Parity            = Parity;
1106   Private->SerialIoMode.DataBits          = DataBits;
1107   Private->SerialIoMode.StopBits          = StopBits;
1108
1109   //
1110   // See if Device Path Node has actually changed
1111   //
1112   if (Private->UartDevicePath.BaudRate     == BaudRate &&
1113       Private->UartDevicePath.DataBits     == DataBits &&
1114       Private->UartDevicePath.Parity       == Parity   &&
1115       Private->UartDevicePath.StopBits     == StopBits    ) {
1116     gBS->RestoreTPL(Tpl);
1117     return EFI_SUCCESS;
1118   }
1119
1120   //
1121   // Update the device path
1122   //
1123   Private->UartDevicePath.BaudRate  = BaudRate;
1124   Private->UartDevicePath.DataBits  = DataBits;
1125   Private->UartDevicePath.Parity    = (UINT8) Parity;
1126   Private->UartDevicePath.StopBits  = (UINT8) StopBits;
1127
1128   Status = EFI_SUCCESS;
1129   if (Private->Handle != NULL) {
1130     Uart = (UART_DEVICE_PATH *) (
1131              (UINTN) Private->DevicePath
1132              + GetDevicePathSize (Private->ParentDevicePath)
1133              - END_DEVICE_PATH_LENGTH
1134              );
1135     CopyMem (Uart, &Private->UartDevicePath, sizeof (UART_DEVICE_PATH));
1136     Status = gBS->ReinstallProtocolInterface (
1137                     Private->Handle,
1138                     &gEfiDevicePathProtocolGuid,
1139                     Private->DevicePath,
1140                     Private->DevicePath
1141                     );
1142   }
1143
1144   gBS->RestoreTPL (Tpl);
1145
1146   return Status;
1147 }
1148
1149 EFI_STATUS
1150 EFIAPI
1151 WinNtSerialIoSetControl (
1152   IN EFI_SERIAL_IO_PROTOCOL *This,
1153   IN UINT32                 Control
1154   )
1155 /*++
1156
1157 Routine Description:
1158
1159   TODO: Add function description
1160
1161 Arguments:
1162
1163   This    - TODO: add argument description
1164   Control - TODO: add argument description
1165
1166 Returns:
1167
1168   EFI_DEVICE_ERROR - TODO: Add description for return value
1169   EFI_DEVICE_ERROR - TODO: Add description for return value
1170   EFI_SUCCESS - TODO: Add description for return value
1171
1172 --*/
1173 {
1174   WIN_NT_SERIAL_IO_PRIVATE_DATA *Private;
1175   BOOL                          Result;
1176   DCB                           Dcb;
1177   EFI_TPL                       Tpl;
1178   UART_FLOW_CONTROL_DEVICE_PATH *FlowControl;
1179   EFI_STATUS                    Status;
1180
1181   //
1182   // first determine the parameter is invalid
1183   //
1184   if (Control & (~(EFI_SERIAL_REQUEST_TO_SEND | EFI_SERIAL_DATA_TERMINAL_READY |
1185                    EFI_SERIAL_HARDWARE_LOOPBACK_ENABLE | EFI_SERIAL_SOFTWARE_LOOPBACK_ENABLE |
1186                    EFI_SERIAL_HARDWARE_FLOW_CONTROL_ENABLE))) {
1187     return EFI_UNSUPPORTED;
1188   }
1189
1190   Tpl     = gBS->RaiseTPL (TPL_NOTIFY);
1191
1192   Private = WIN_NT_SERIAL_IO_PRIVATE_DATA_FROM_THIS (This);
1193
1194   Result  = Private->WinNtThunk->GetCommState (Private->NtHandle, &Dcb);
1195
1196   if (!Result) {
1197     Private->NtError = Private->WinNtThunk->GetLastError ();
1198     DEBUG ((EFI_D_ERROR, "SerialSetControl: GetCommState %d\n", Private->NtError));
1199     gBS->RestoreTPL (Tpl);
1200     return EFI_DEVICE_ERROR;
1201   }
1202
1203   Dcb.fRtsControl                 = RTS_CONTROL_DISABLE;
1204   Dcb.fDtrControl                 = DTR_CONTROL_DISABLE;
1205   Private->HardwareFlowControl    = FALSE;
1206   Private->SoftwareLoopbackEnable = FALSE;
1207   Private->HardwareLoopbackEnable = FALSE;
1208
1209   if (Control & EFI_SERIAL_REQUEST_TO_SEND) {
1210     Dcb.fRtsControl = RTS_CONTROL_ENABLE;
1211   }
1212
1213   if (Control & EFI_SERIAL_DATA_TERMINAL_READY) {
1214     Dcb.fDtrControl = DTR_CONTROL_ENABLE;
1215   }
1216
1217   if (Control & EFI_SERIAL_HARDWARE_FLOW_CONTROL_ENABLE) {
1218     Private->HardwareFlowControl = TRUE;
1219   }
1220
1221   if (Control & EFI_SERIAL_SOFTWARE_LOOPBACK_ENABLE) {
1222     Private->SoftwareLoopbackEnable = TRUE;
1223   }
1224
1225   if (Control & EFI_SERIAL_HARDWARE_LOOPBACK_ENABLE) {
1226     Private->HardwareLoopbackEnable = TRUE;
1227   }
1228
1229   Result = Private->WinNtThunk->SetCommState (
1230                                   Private->NtHandle,
1231                                   &Dcb
1232                                   );
1233
1234   if (!Result) {
1235     Private->NtError = Private->WinNtThunk->GetLastError ();
1236     DEBUG ((EFI_D_ERROR, "SerialSetControl: SetCommState %d\n", Private->NtError));
1237     gBS->RestoreTPL (Tpl);
1238     return EFI_DEVICE_ERROR;
1239   }
1240
1241   Status = EFI_SUCCESS;
1242   if (Private->Handle != NULL) {
1243     FlowControl = (UART_FLOW_CONTROL_DEVICE_PATH *) (
1244                     (UINTN) Private->DevicePath
1245                     + GetDevicePathSize (Private->ParentDevicePath)
1246                     - END_DEVICE_PATH_LENGTH
1247                     + sizeof (UART_DEVICE_PATH)
1248                     );
1249     if (IsUartFlowControlNode (FlowControl) &&
1250         ((FlowControl->FlowControlMap == UART_FLOW_CONTROL_HARDWARE) ^ Private->HardwareFlowControl)) {
1251       //
1252       // Flow Control setting is changed, need to reinstall device path protocol
1253       //
1254       FlowControl->FlowControlMap = Private->HardwareFlowControl ? UART_FLOW_CONTROL_HARDWARE : 0;
1255       Status = gBS->ReinstallProtocolInterface (
1256                       Private->Handle,
1257                       &gEfiDevicePathProtocolGuid,
1258                       Private->DevicePath,
1259                       Private->DevicePath
1260                       );
1261     }
1262   }
1263
1264   gBS->RestoreTPL (Tpl);
1265
1266   return Status;
1267 }
1268
1269 EFI_STATUS
1270 EFIAPI
1271 WinNtSerialIoGetControl (
1272   IN  EFI_SERIAL_IO_PROTOCOL  *This,
1273   OUT UINT32                  *Control
1274   )
1275 /*++
1276
1277 Routine Description:
1278
1279   TODO: Add function description
1280
1281 Arguments:
1282
1283   This    - TODO: add argument description
1284   Control - TODO: add argument description
1285
1286 Returns:
1287
1288   EFI_DEVICE_ERROR - TODO: Add description for return value
1289   EFI_DEVICE_ERROR - TODO: Add description for return value
1290   EFI_DEVICE_ERROR - TODO: Add description for return value
1291   EFI_SUCCESS - TODO: Add description for return value
1292
1293 --*/
1294 {
1295   WIN_NT_SERIAL_IO_PRIVATE_DATA *Private;
1296   DWORD                         ModemStatus;
1297   DWORD                         Errors;
1298   UINT32                        Bits;
1299   DCB                           Dcb;
1300   EFI_TPL                       Tpl;
1301
1302   Tpl     = gBS->RaiseTPL (TPL_NOTIFY);
1303
1304   Private = WIN_NT_SERIAL_IO_PRIVATE_DATA_FROM_THIS (This);
1305
1306   //
1307   //  Get modem status
1308   //
1309   if (!Private->WinNtThunk->GetCommModemStatus (Private->NtHandle, &ModemStatus)) {
1310     Private->NtError = Private->WinNtThunk->GetLastError ();
1311     gBS->RestoreTPL (Tpl);
1312     return EFI_DEVICE_ERROR;
1313   }
1314
1315   Bits = 0;
1316   if (ModemStatus & MS_CTS_ON) {
1317     Bits |= EFI_SERIAL_CLEAR_TO_SEND;
1318   }
1319
1320   if (ModemStatus & MS_DSR_ON) {
1321     Bits |= EFI_SERIAL_DATA_SET_READY;
1322   }
1323
1324   if (ModemStatus & MS_RING_ON) {
1325     Bits |= EFI_SERIAL_RING_INDICATE;
1326   }
1327
1328   if (ModemStatus & MS_RLSD_ON) {
1329     Bits |= EFI_SERIAL_CARRIER_DETECT;
1330   }
1331
1332   //
1333   // Get ctrl status
1334   //
1335   if (!Private->WinNtThunk->GetCommState (Private->NtHandle, &Dcb)) {
1336     Private->NtError = Private->WinNtThunk->GetLastError ();
1337     DEBUG ((EFI_D_ERROR, "SerialGetControl: GetCommState %d\n", Private->NtError));
1338     gBS->RestoreTPL (Tpl);
1339     return EFI_DEVICE_ERROR;
1340   }
1341
1342   if (Dcb.fDtrControl == DTR_CONTROL_ENABLE) {
1343     Bits |= EFI_SERIAL_DATA_TERMINAL_READY;
1344   }
1345
1346   if (Dcb.fRtsControl == RTS_CONTROL_ENABLE) {
1347     Bits |= EFI_SERIAL_REQUEST_TO_SEND;
1348   }
1349
1350   if (Private->HardwareFlowControl) {
1351     Bits |= EFI_SERIAL_HARDWARE_FLOW_CONTROL_ENABLE;
1352   }
1353
1354   if (Private->SoftwareLoopbackEnable) {
1355     Bits |= EFI_SERIAL_SOFTWARE_LOOPBACK_ENABLE;
1356   }
1357
1358   if (Private->HardwareLoopbackEnable) {
1359     Bits |= EFI_SERIAL_HARDWARE_LOOPBACK_ENABLE;
1360   }
1361
1362   //
1363   //  Get input buffer status
1364   //
1365   if (!Private->WinNtThunk->ClearCommError (Private->NtHandle, &Errors, &Private->NtComStatus)) {
1366     Private->NtError = Private->WinNtThunk->GetLastError ();
1367     DEBUG ((EFI_D_ERROR, "SerialGetControl: ClearCommError %d\n", Private->NtError));
1368     gBS->RestoreTPL (Tpl);
1369     return EFI_DEVICE_ERROR;
1370   }
1371
1372   if (Private->NtComStatus.cbInQue == 0) {
1373     Bits |= EFI_SERIAL_INPUT_BUFFER_EMPTY;
1374   }
1375
1376   *Control = Bits;
1377
1378   gBS->RestoreTPL (Tpl);
1379
1380   return EFI_SUCCESS;
1381 }
1382
1383 EFI_STATUS
1384 EFIAPI
1385 WinNtSerialIoWrite (
1386   IN EFI_SERIAL_IO_PROTOCOL   *This,
1387   IN OUT UINTN                *BufferSize,
1388   IN VOID                     *Buffer
1389   )
1390 /*++
1391
1392 Routine Description:
1393
1394   TODO: Add function description
1395
1396 Arguments:
1397
1398   This        - TODO: add argument description
1399   BufferSize  - TODO: add argument description
1400   Buffer      - TODO: add argument description
1401
1402 Returns:
1403
1404   EFI_DEVICE_ERROR - TODO: Add description for return value
1405   EFI_SUCCESS - TODO: Add description for return value
1406
1407 --*/
1408 {
1409   WIN_NT_SERIAL_IO_PRIVATE_DATA *Private;
1410   UINT8                         *ByteBuffer;
1411   UINTN                         TotalBytesWritten;
1412   DWORD                         BytesToGo;
1413   DWORD                         BytesWritten;
1414   BOOL                          Result;
1415   UINT32                        Index;
1416   UINT32                        Control;
1417   EFI_TPL                       Tpl;
1418
1419   Tpl               = gBS->RaiseTPL (TPL_NOTIFY);
1420
1421   Private           = WIN_NT_SERIAL_IO_PRIVATE_DATA_FROM_THIS (This);
1422
1423   ByteBuffer        = (UINT8 *) Buffer;
1424   TotalBytesWritten = 0;
1425
1426   if (Private->SoftwareLoopbackEnable || Private->HardwareLoopbackEnable) {
1427     for (Index = 0; Index < *BufferSize; Index++) {
1428       if (IsaSerialFifoAdd (&Private->Fifo, ByteBuffer[Index]) == EFI_SUCCESS) {
1429         TotalBytesWritten++;
1430       } else {
1431         break;
1432       }
1433     }
1434   } else {
1435     BytesToGo = (DWORD) (*BufferSize);
1436
1437     do {
1438       if (Private->HardwareFlowControl) {
1439         //
1440         // Send RTS
1441         //
1442         WinNtSerialIoGetControl (&Private->SerialIo, &Control);
1443         Control |= EFI_SERIAL_REQUEST_TO_SEND;
1444         WinNtSerialIoSetControl (&Private->SerialIo, Control);
1445       }
1446
1447       //
1448       //  Do the write
1449       //
1450       Result = Private->WinNtThunk->WriteFile (
1451                                       Private->NtHandle,
1452                                       &ByteBuffer[TotalBytesWritten],
1453                                       BytesToGo,
1454                                       &BytesWritten,
1455                                       NULL
1456                                       );
1457
1458       if (Private->HardwareFlowControl) {
1459         //
1460         // Assert RTS
1461         //
1462         WinNtSerialIoGetControl (&Private->SerialIo, &Control);
1463         Control &= ~ (UINT32) EFI_SERIAL_REQUEST_TO_SEND;
1464         WinNtSerialIoSetControl (&Private->SerialIo, Control);
1465       }
1466
1467       TotalBytesWritten += BytesWritten;
1468       BytesToGo -= BytesWritten;
1469       if (!Result) {
1470         Private->NtError = Private->WinNtThunk->GetLastError ();
1471         DEBUG ((EFI_D_ERROR, "SerialWrite: FileWrite %d\n", Private->NtError));
1472         *BufferSize = TotalBytesWritten;
1473         gBS->RestoreTPL (Tpl);
1474         return EFI_DEVICE_ERROR;
1475       }
1476     } while (BytesToGo > 0);
1477   }
1478
1479   *BufferSize = TotalBytesWritten;
1480
1481   gBS->RestoreTPL (Tpl);
1482
1483   return EFI_SUCCESS;
1484 }
1485
1486 EFI_STATUS
1487 EFIAPI
1488 WinNtSerialIoRead (
1489   IN  EFI_SERIAL_IO_PROTOCOL  *This,
1490   IN  OUT UINTN               *BufferSize,
1491   OUT VOID                    *Buffer
1492   )
1493 /*++
1494
1495 Routine Description:
1496
1497   TODO: Add function description
1498
1499 Arguments:
1500
1501   This        - TODO: add argument description
1502   BufferSize  - TODO: add argument description
1503   Buffer      - TODO: add argument description
1504
1505 Returns:
1506
1507   EFI_DEVICE_ERROR - TODO: Add description for return value
1508
1509 --*/
1510 {
1511   WIN_NT_SERIAL_IO_PRIVATE_DATA *Private;
1512   BOOL                          Result;
1513   DWORD                         BytesRead;
1514   EFI_STATUS                    Status;
1515   UINT32                        Index;
1516   UINT8                         Data;
1517   UINT32                        Control;
1518   EFI_TPL                       Tpl;
1519
1520   Tpl     = gBS->RaiseTPL (TPL_NOTIFY);
1521
1522   Private = WIN_NT_SERIAL_IO_PRIVATE_DATA_FROM_THIS (This);
1523
1524   //
1525   //  Do the read
1526   //
1527   if (Private->SoftwareLoopbackEnable || Private->HardwareLoopbackEnable) {
1528     for (Index = 0, BytesRead = 0; Index < *BufferSize; Index++) {
1529       if (IsaSerialFifoRemove (&Private->Fifo, &Data) == EFI_SUCCESS) {
1530         ((UINT8 *) Buffer)[Index] = Data;
1531         BytesRead++;
1532       } else {
1533         break;
1534       }
1535     }
1536   } else {
1537     if (Private->HardwareFlowControl) {
1538       WinNtSerialIoGetControl (&Private->SerialIo, &Control);
1539       Control |= EFI_SERIAL_DATA_TERMINAL_READY;
1540       WinNtSerialIoSetControl (&Private->SerialIo, Control);
1541     }
1542
1543     Result = Private->WinNtThunk->ReadFile (
1544                                     Private->NtHandle,
1545                                     Buffer,
1546                                     (DWORD) *BufferSize,
1547                                     &BytesRead,
1548                                     NULL
1549                                     );
1550
1551     if (Private->HardwareFlowControl) {
1552       WinNtSerialIoGetControl (&Private->SerialIo, &Control);
1553       Control &= ~ (UINT32) EFI_SERIAL_DATA_TERMINAL_READY;
1554       WinNtSerialIoSetControl (&Private->SerialIo, Control);
1555     }
1556
1557     if (!Result) {
1558       Private->NtError = Private->WinNtThunk->GetLastError ();
1559       gBS->RestoreTPL (Tpl);
1560       return EFI_DEVICE_ERROR;
1561     }
1562   }
1563
1564   if (BytesRead != *BufferSize) {
1565     Status = EFI_TIMEOUT;
1566   } else {
1567     Status = EFI_SUCCESS;
1568   }
1569
1570   *BufferSize = (UINTN) BytesRead;
1571
1572   gBS->RestoreTPL (Tpl);
1573
1574   return Status;
1575 }
1576
1577 BOOLEAN
1578 IsaSerialFifoFull (
1579   IN SERIAL_DEV_FIFO *Fifo
1580   )
1581 /*++
1582
1583   Routine Description:
1584   Detect whether specific FIFO is full or not
1585
1586   Arguments:
1587   Fifo  SERIAL_DEV_FIFO *: A pointer to the Data Structure SERIAL_DEV_FIFO
1588
1589   Returns:
1590   TRUE:  the FIFO is full
1591   FALSE: the FIFO is not full
1592
1593 --*/
1594 {
1595   if (Fifo->Surplus == 0) {
1596     return TRUE;
1597   }
1598
1599   return FALSE;
1600 }
1601
1602 BOOLEAN
1603 IsaSerialFifoEmpty (
1604   IN SERIAL_DEV_FIFO *Fifo
1605   )
1606 /*++
1607
1608   Routine Description:
1609   Detect whether specific FIFO is empty or not
1610
1611   Arguments:
1612     Fifo  SERIAL_DEV_FIFO *: A pointer to the Data Structure SERIAL_DEV_FIFO
1613
1614   Returns:
1615     TRUE:  the FIFO is empty
1616     FALSE: the FIFO is not empty
1617
1618 --*/
1619 {
1620   if (Fifo->Surplus == SERIAL_MAX_BUFFER_SIZE) {
1621     return TRUE;
1622   }
1623
1624   return FALSE;
1625 }
1626
1627 EFI_STATUS
1628 IsaSerialFifoAdd (
1629   IN SERIAL_DEV_FIFO *Fifo,
1630   IN UINT8           Data
1631   )
1632 /*++
1633
1634   Routine Description:
1635   Add data to specific FIFO
1636
1637   Arguments:
1638     Fifo  SERIAL_DEV_FIFO *: A pointer to the Data Structure SERIAL_DEV_FIFO
1639     Data  UINT8: the data added to FIFO
1640
1641   Returns:
1642     EFI_SUCCESS:  Add data to specific FIFO successfully
1643     EFI_OUT_RESOURCE: Failed to add data because FIFO is already full
1644
1645 --*/
1646 // TODO:    EFI_OUT_OF_RESOURCES - add return value to function comment
1647 {
1648   //
1649   // if FIFO full can not add data
1650   //
1651   if (IsaSerialFifoFull (Fifo)) {
1652     return EFI_OUT_OF_RESOURCES;
1653   }
1654
1655   //
1656   // FIFO is not full can add data
1657   //
1658   Fifo->Data[Fifo->Last] = Data;
1659   Fifo->Surplus--;
1660   Fifo->Last++;
1661   if (Fifo->Last >= SERIAL_MAX_BUFFER_SIZE) {
1662     Fifo->Last = 0;
1663   }
1664
1665   return EFI_SUCCESS;
1666 }
1667
1668 EFI_STATUS
1669 IsaSerialFifoRemove (
1670   IN  SERIAL_DEV_FIFO *Fifo,
1671   OUT UINT8           *Data
1672   )
1673 /*++
1674
1675   Routine Description:
1676   Remove data from specific FIFO
1677
1678   Arguments:
1679     Fifo  SERIAL_DEV_FIFO *: A pointer to the Data Structure SERIAL_DEV_FIFO
1680     Data  UINT8*: the data removed from FIFO
1681
1682   Returns:
1683     EFI_SUCCESS:  Remove data from specific FIFO successfully
1684     EFI_OUT_RESOURCE: Failed to remove data because FIFO is empty
1685
1686 --*/
1687 // TODO:    EFI_OUT_OF_RESOURCES - add return value to function comment
1688 {
1689   //
1690   // if FIFO is empty, no data can remove
1691   //
1692   if (IsaSerialFifoEmpty (Fifo)) {
1693     return EFI_OUT_OF_RESOURCES;
1694   }
1695
1696   //
1697   // FIFO is not empty, can remove data
1698   //
1699   *Data = Fifo->Data[Fifo->First];
1700   Fifo->Surplus++;
1701   Fifo->First++;
1702   if (Fifo->First >= SERIAL_MAX_BUFFER_SIZE) {
1703     Fifo->First = 0;
1704   }
1705
1706   return EFI_SUCCESS;
1707 }