MdeModulePkg/Bus/Pci/PciSioSerialDxe/Serial.c

   1 /** @file
   2   Serial driver for PCI or SIO UARTS.
   3
   4 Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved.<BR>
   5 This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "Serial.h"
  16
  17 //
  18 // ISA Serial Driver Global Variables
  19 //
  20
  21 EFI_DRIVER_BINDING_PROTOCOL gSerialControllerDriver = {
  22   SerialControllerDriverSupported,
  23   SerialControllerDriverStart,
  24   SerialControllerDriverStop,
  25   0xa,
  26   NULL,
  27   NULL
  28 };
  29
  30 CONTROLLER_DEVICE_PATH mControllerDevicePathTemplate = {
  31   {
  32     HARDWARE_DEVICE_PATH,
  33     HW_CONTROLLER_DP,
  34     {
  35       (UINT8) (sizeof (CONTROLLER_DEVICE_PATH)),
  36       (UINT8) ((sizeof (CONTROLLER_DEVICE_PATH)) >> 8)
  37     }
  38   },
  39   0
  40 };
  41
  42 SERIAL_DEV  gSerialDevTemplate = {
  43   SERIAL_DEV_SIGNATURE,
  44   NULL,
  45   {
  46     SERIAL_IO_INTERFACE_REVISION,
  47     SerialReset,
  48     SerialSetAttributes,
  49     SerialSetControl,
  50     SerialGetControl,
  51     SerialWrite,
  52     SerialRead,
  53     NULL
  54   },                                       // SerialIo
  55   {
  56     SERIAL_PORT_SUPPORT_CONTROL_MASK,
  57     SERIAL_PORT_DEFAULT_TIMEOUT,
  58     0,
  59     16,
  60     0,
  61     0,
  62     0
  63   },                                       // SerialMode
  64   NULL,                                    // DevicePath
  65   NULL,                                    // ParentDevicePath
  66   {
  67     {
  68       MESSAGING_DEVICE_PATH,
  69       MSG_UART_DP,
  70       {
  71         (UINT8) (sizeof (UART_DEVICE_PATH)),
  72         (UINT8) ((sizeof (UART_DEVICE_PATH)) >> 8)
  73       }
  74     },
  75     0, 0, 0, 0, 0
  76   },                                       // UartDevicePath
  77   0,                                       // BaseAddress
  78   FALSE,                                   // MmioAccess
  79   1,                                       // RegisterStride
  80   0,                                       // ClockRate
  81   16,                                      // ReceiveFifoDepth
  82   { 0, 0 },                                // Receive;
  83   16,                                      // TransmitFifoDepth
  84   { 0, 0 },                                // Transmit;
  85   FALSE,                                   // SoftwareLoopbackEnable;
  86   FALSE,                                   // HardwareFlowControl;
  87   NULL,                                    // *ControllerNameTable;
  88   FALSE,                                   // ContainsControllerNode;
  89   0,                                       // Instance;
  90   NULL                                     // *PciDeviceInfo;
  91 };
  92
  93 /**
  94   Check the device path node whether it's the Flow Control node or not.
  95
  96   @param[in] FlowControl    The device path node to be checked.
  97
  98   @retval TRUE              It's the Flow Control node.
  99   @retval FALSE             It's not.
 100
 101 **/
 102 BOOLEAN
 103 IsUartFlowControlDevicePathNode (
 104   IN UART_FLOW_CONTROL_DEVICE_PATH *FlowControl
 105   )
 106 {
 107   return (BOOLEAN) (
 108            (DevicePathType (FlowControl) == MESSAGING_DEVICE_PATH) &&
 109            (DevicePathSubType (FlowControl) == MSG_VENDOR_DP) &&
 110            (CompareGuid (&FlowControl->Guid, &gEfiUartDevicePathGuid))
 111            );
 112 }
 113
 114 /**
 115   The user Entry Point for module PciSioSerial. The user code starts with this function.
 116
 117   @param[in] ImageHandle    The firmware allocated handle for the EFI image.
 118   @param[in] SystemTable    A pointer to the EFI System Table.
 119
 120   @retval EFI_SUCCESS       The entry point is executed successfully.
 121   @retval other             Some error occurs when executing this entry point.
 122
 123 **/
 124 EFI_STATUS
 125 EFIAPI
 126 InitializePciSioSerial (
 127   IN EFI_HANDLE           ImageHandle,
 128   IN EFI_SYSTEM_TABLE     *SystemTable
 129   )
 130 {
 131   EFI_STATUS              Status;
 132
 133   //
 134   // Install driver model protocol(s).
 135   //
 136   Status = EfiLibInstallDriverBindingComponentName2 (
 137              ImageHandle,
 138              SystemTable,
 139              &gSerialControllerDriver,
 140              ImageHandle,
 141              &gPciSioSerialComponentName,
 142              &gPciSioSerialComponentName2
 143              );
 144   ASSERT_EFI_ERROR (Status);
 145
 146   //
 147   // Initialize UART default setting in gSerialDevTempate
 148   //
 149   gSerialDevTemplate.SerialMode.BaudRate = PcdGet64 (PcdUartDefaultBaudRate);
 150   gSerialDevTemplate.SerialMode.DataBits = PcdGet8 (PcdUartDefaultDataBits);
 151   gSerialDevTemplate.SerialMode.Parity   = PcdGet8 (PcdUartDefaultParity);
 152   gSerialDevTemplate.SerialMode.StopBits = PcdGet8 (PcdUartDefaultStopBits);
 153   gSerialDevTemplate.UartDevicePath.BaudRate = PcdGet64 (PcdUartDefaultBaudRate);
 154   gSerialDevTemplate.UartDevicePath.DataBits = PcdGet8 (PcdUartDefaultDataBits);
 155   gSerialDevTemplate.UartDevicePath.Parity   = PcdGet8 (PcdUartDefaultParity);
 156   gSerialDevTemplate.UartDevicePath.StopBits = PcdGet8 (PcdUartDefaultStopBits);
 157   gSerialDevTemplate.ClockRate = PcdGet32 (PcdSerialClockRate);
 158
 159   return Status;
 160 }
 161
 162 /**
 163   Return whether the controller is a SIO serial controller.
 164
 165   @param  Controller   The controller handle.
 166
 167   @retval EFI_SUCCESS  The controller is a SIO serial controller.
 168   @retval others       The controller is not a SIO serial controller.
 169 **/
 170 EFI_STATUS
 171 IsSioSerialController (
 172   EFI_HANDLE               Controller
 173   )
 174 {
 175   EFI_STATUS               Status;
 176   EFI_SIO_PROTOCOL         *Sio;
 177   EFI_DEVICE_PATH_PROTOCOL *DevicePath;
 178   ACPI_HID_DEVICE_PATH     *Acpi;
 179
 180   //
 181   // Open the IO Abstraction(s) needed to perform the supported test
 182   //
 183   Status = gBS->OpenProtocol (
 184                   Controller,
 185                   &gEfiSioProtocolGuid,
 186                   (VOID **) &Sio,
 187                   gSerialControllerDriver.DriverBindingHandle,
 188                   Controller,
 189                   EFI_OPEN_PROTOCOL_BY_DRIVER
 190                   );
 191   if (Status == EFI_ALREADY_STARTED) {
 192     return EFI_SUCCESS;
 193   }
 194
 195   if (!EFI_ERROR (Status)) {
 196     //
 197     // Close the I/O Abstraction(s) used to perform the supported test
 198     //
 199     gBS->CloseProtocol (
 200            Controller,
 201            &gEfiSioProtocolGuid,
 202            gSerialControllerDriver.DriverBindingHandle,
 203            Controller
 204            );
 205
 206     Status = gBS->OpenProtocol (
 207       Controller,
 208       &gEfiDevicePathProtocolGuid,
 209       (VOID **) &DevicePath,
 210       gSerialControllerDriver.DriverBindingHandle,
 211       Controller,
 212       EFI_OPEN_PROTOCOL_BY_DRIVER
 213       );
 214     ASSERT (Status != EFI_ALREADY_STARTED);
 215
 216     if (!EFI_ERROR (Status)) {
 217       do {
 218         Acpi = (ACPI_HID_DEVICE_PATH *) DevicePath;
 219         DevicePath = NextDevicePathNode (DevicePath);
 220       } while (!IsDevicePathEnd (DevicePath));
 221
 222       if (DevicePathType (Acpi) != ACPI_DEVICE_PATH ||
 223           (DevicePathSubType (Acpi) != ACPI_DP && DevicePathSubType (Acpi) != ACPI_EXTENDED_DP) ||
 224           Acpi->HID != EISA_PNP_ID (0x501)
 225           ) {
 226         Status = EFI_UNSUPPORTED;
 227       }
 228     }
 229
 230     //
 231     // Close protocol, don't use device path protocol in the Support() function
 232     //
 233     gBS->CloseProtocol (
 234       Controller,
 235       &gEfiDevicePathProtocolGuid,
 236       gSerialControllerDriver.DriverBindingHandle,
 237       Controller
 238       );
 239   }
 240   return Status;
 241 }
 242
 243 /**
 244   Return whether the controller is a PCI serial controller.
 245
 246   @param  Controller   The controller handle.
 247
 248   @retval EFI_SUCCESS  The controller is a PCI serial controller.
 249   @retval others       The controller is not a PCI serial controller.
 250 **/
 251 EFI_STATUS
 252 IsPciSerialController (
 253   EFI_HANDLE               Controller
 254   )
 255 {
 256   EFI_STATUS               Status;
 257   EFI_PCI_IO_PROTOCOL      *PciIo;
 258   EFI_DEVICE_PATH_PROTOCOL *DevicePath;
 259   PCI_TYPE00               Pci;
 260   PCI_SERIAL_PARAMETER     *PciSerialParameter;
 261
 262   //
 263   // Open the IO Abstraction(s) needed to perform the supported test
 264   //
 265   Status = gBS->OpenProtocol (
 266     Controller,
 267     &gEfiPciIoProtocolGuid,
 268     (VOID **) &PciIo,
 269     gSerialControllerDriver.DriverBindingHandle,
 270     Controller,
 271     EFI_OPEN_PROTOCOL_BY_DRIVER
 272     );
 273   if (Status == EFI_ALREADY_STARTED) {
 274     return EFI_SUCCESS;
 275   }
 276
 277   if (!EFI_ERROR (Status)) {
 278     Status = PciIo->Pci.Read (PciIo, EfiPciIoWidthUint8, 0, sizeof (Pci), &Pci);
 279     if (!EFI_ERROR (Status)) {
 280       if (!IS_PCI_16550_SERIAL (&Pci)) {
 281         for (PciSerialParameter = (PCI_SERIAL_PARAMETER *) PcdGetPtr (PcdPciSerialParameters)
 282              ; PciSerialParameter->VendorId != 0xFFFF
 283              ; PciSerialParameter++
 284              ) {
 285           if ((Pci.Hdr.VendorId == PciSerialParameter->VendorId) &&
 286               (Pci.Hdr.DeviceId == PciSerialParameter->DeviceId)
 287               ) {
 288             break;
 289           }
 290         }
 291         if (PciSerialParameter->VendorId == 0xFFFF) {
 292           Status = EFI_UNSUPPORTED;
 293         } else {
 294           Status = EFI_SUCCESS;
 295         }
 296       }
 297     }
 298
 299     //
 300     // Close the I/O Abstraction(s) used to perform the supported test
 301     //
 302     gBS->CloseProtocol (
 303       Controller,
 304       &gEfiPciIoProtocolGuid,
 305       gSerialControllerDriver.DriverBindingHandle,
 306       Controller
 307       );
 308   }
 309   if (EFI_ERROR (Status)) {
 310     return Status;
 311   }
 312
 313   //
 314   // Open the EFI Device Path protocol needed to perform the supported test
 315   //
 316   Status = gBS->OpenProtocol (
 317     Controller,
 318     &gEfiDevicePathProtocolGuid,
 319     (VOID **) &DevicePath,
 320     gSerialControllerDriver.DriverBindingHandle,
 321     Controller,
 322     EFI_OPEN_PROTOCOL_BY_DRIVER
 323     );
 324   ASSERT (Status != EFI_ALREADY_STARTED);
 325
 326   //
 327   // Close protocol, don't use device path protocol in the Support() function
 328   //
 329   gBS->CloseProtocol (
 330     Controller,
 331     &gEfiDevicePathProtocolGuid,
 332     gSerialControllerDriver.DriverBindingHandle,
 333     Controller
 334     );
 335
 336   return Status;
 337 }
 338
 339 /**
 340   Check to see if this driver supports the given controller
 341
 342   @param  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 343   @param  Controller           The handle of the controller to test.
 344   @param  RemainingDevicePath  A pointer to the remaining portion of a device path.
 345
 346   @return EFI_SUCCESS          This driver can support the given controller
 347
 348 **/
 349 EFI_STATUS
 350 EFIAPI
 351 SerialControllerDriverSupported (
 352   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 353   IN EFI_HANDLE                     Controller,
 354   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 355   )
 356
 357 {
 358   EFI_STATUS                                Status;
 359   UART_DEVICE_PATH                          *Uart;
 360   UART_FLOW_CONTROL_DEVICE_PATH             *FlowControl;
 361
 362   //
 363   // Test RemainingDevicePath
 364   //
 365   if ((RemainingDevicePath != NULL) && !IsDevicePathEnd (RemainingDevicePath)) {
 366     Status = EFI_UNSUPPORTED;
 367
 368     Uart = SkipControllerDevicePathNode (RemainingDevicePath, NULL, NULL);
 369     if (DevicePathType (Uart) != MESSAGING_DEVICE_PATH ||
 370         DevicePathSubType (Uart) != MSG_UART_DP ||
 371         DevicePathNodeLength (Uart) != sizeof (UART_DEVICE_PATH)
 372         ) {
 373       return EFI_UNSUPPORTED;
 374     }
 375
 376     //
 377     // Do a rough check because Clock Rate is unknown until DriverBindingStart()
 378     //
 379     if (!VerifyUartParameters (0, Uart->BaudRate, Uart->DataBits, Uart->Parity, Uart->StopBits, NULL, NULL)) {
 380       return EFI_UNSUPPORTED;
 381     }
 382
 383     FlowControl = (UART_FLOW_CONTROL_DEVICE_PATH *) NextDevicePathNode (Uart);
 384     if (IsUartFlowControlDevicePathNode (FlowControl)) {
 385       //
 386       // If the second node is Flow Control Node,
 387       //   return error when it request other than hardware flow control.
 388       //
 389       if ((ReadUnaligned32 (&FlowControl->FlowControlMap) & ~UART_FLOW_CONTROL_HARDWARE) != 0) {
 390         return EFI_UNSUPPORTED;
 391       }
 392     }
 393   }
 394
 395   Status = IsSioSerialController (Controller);
 396   if (EFI_ERROR (Status)) {
 397     Status = IsPciSerialController (Controller);
 398   }
 399   return Status;
 400 }
 401
 402 /**
 403   Create the child serial device instance.
 404
 405   @param Controller           The parent controller handle.
 406   @param Uart                 Pointer to the UART device path node in RemainingDevicePath,
 407                               or NULL if RemainingDevicePath is NULL.
 408   @param ParentDevicePath     Pointer to the parent device path.
 409   @param CreateControllerNode TRUE to create the controller node.
 410   @param Instance             Instance number of the serial device.
 411                               The value will be set to the controller node
 412                               if CreateControllerNode is TRUE.
 413   @param ParentIo             A union type pointer to either Sio or PciIo.
 414   @param PciSerialParameter   The PCI serial parameter to be used by current serial device.
 415                               NULL for SIO serial device.
 416   @param PciDeviceInfo        The PCI device info for the current serial device.
 417                               NULL for SIO serial device.
 418
 419   @retval EFI_SUCCESS         The serial device was created successfully.
 420   @retval others              The serial device wasn't created.
 421 **/
 422 EFI_STATUS
 423 CreateSerialDevice (
 424   IN EFI_HANDLE                     Controller,
 425   IN UART_DEVICE_PATH               *Uart,
 426   IN EFI_DEVICE_PATH_PROTOCOL       *ParentDevicePath,
 427   IN BOOLEAN                        CreateControllerNode,
 428   IN UINT32                         Instance,
 429   IN PARENT_IO_PROTOCOL_PTR         ParentIo,
 430   IN PCI_SERIAL_PARAMETER           *PciSerialParameter, OPTIONAL
 431   IN PCI_DEVICE_INFO                *PciDeviceInfo       OPTIONAL
 432   )
 433 {
 434   EFI_STATUS                                 Status;
 435   SERIAL_DEV                                 *SerialDevice;
 436   UINT8                                      BarIndex;
 437   UINT64                                     Offset;
 438   UART_FLOW_CONTROL_DEVICE_PATH              *FlowControl;
 439   UINT32                                     FlowControlMap;
 440   ACPI_RESOURCE_HEADER_PTR                   Resources;
 441   EFI_ACPI_IO_PORT_DESCRIPTOR                *Io;
 442   EFI_ACPI_FIXED_LOCATION_IO_PORT_DESCRIPTOR *FixedIo;
 443   EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR          *AddressSpace;
 444   EFI_DEVICE_PATH_PROTOCOL                   *TempDevicePath;
 445
 446   BarIndex = 0;
 447   Offset = 0;
 448   FlowControl = NULL;
 449   FlowControlMap = 0;
 450
 451   //
 452   // Initialize the serial device instance
 453   //
 454   SerialDevice = AllocateCopyPool (sizeof (SERIAL_DEV), &gSerialDevTemplate);
 455   ASSERT (SerialDevice != NULL);
 456
 457   SerialDevice->SerialIo.Mode    = &(SerialDevice->SerialMode);
 458   SerialDevice->ParentDevicePath = ParentDevicePath;
 459   SerialDevice->PciDeviceInfo    = PciDeviceInfo;
 460   SerialDevice->Instance         = Instance;
 461
 462   if (Uart != NULL) {
 463     CopyMem (&SerialDevice->UartDevicePath, Uart, sizeof (UART_DEVICE_PATH));
 464     FlowControl = (UART_FLOW_CONTROL_DEVICE_PATH *) NextDevicePathNode (Uart);
 465     if (IsUartFlowControlDevicePathNode (FlowControl)) {
 466       FlowControlMap = ReadUnaligned32 (&FlowControl->FlowControlMap);
 467     } else {
 468       FlowControl = NULL;
 469     }
 470   }
 471
 472   //
 473   // For PCI serial device, use the information from PCD
 474   //
 475   if (PciSerialParameter != NULL) {
 476     BarIndex = (PciSerialParameter->BarIndex == PCI_BAR_ALL) ? 0 : PciSerialParameter->BarIndex;
 477     Offset = PciSerialParameter->Offset;
 478     if (PciSerialParameter->RegisterStride != 0) {
 479       SerialDevice->RegisterStride = PciSerialParameter->RegisterStride;
 480     }
 481     if (PciSerialParameter->ClockRate != 0) {
 482       SerialDevice->ClockRate = PciSerialParameter->ClockRate;
 483     }
 484     if (PciSerialParameter->ReceiveFifoDepth != 0) {
 485       SerialDevice->ReceiveFifoDepth = PciSerialParameter->ReceiveFifoDepth;
 486     }
 487     if (PciSerialParameter->TransmitFifoDepth != 0) {
 488       SerialDevice->TransmitFifoDepth = PciSerialParameter->TransmitFifoDepth;
 489     }
 490   }
 491
 492   //
 493   // Pass NULL ActualBaudRate to VerifyUartParameters to disallow baudrate degrade.
 494   // DriverBindingStart() shouldn't create a handle with different UART device path.
 495   //
 496   if (!VerifyUartParameters (SerialDevice->ClockRate, SerialDevice->UartDevicePath.BaudRate, SerialDevice->UartDevicePath.DataBits,
 497                             SerialDevice->UartDevicePath.Parity, SerialDevice->UartDevicePath.StopBits, NULL, NULL
 498                             )) {
 499     Status = EFI_INVALID_PARAMETER;
 500     goto CreateError;
 501   }
 502
 503   if (PciSerialParameter == NULL) {
 504     Status = ParentIo.Sio->GetResources (ParentIo.Sio, &Resources);
 505   } else {
 506     Status = ParentIo.PciIo->GetBarAttributes (ParentIo.PciIo, BarIndex, NULL, (VOID **) &Resources);
 507   }
 508
 509   if (!EFI_ERROR (Status)) {
 510     //
 511     // Get the base address information from ACPI resource descriptor.
 512     // ACPI_IO_PORT_DESCRIPTOR and ACPI_FIXED_LOCATION_IO_PORT_DESCRIPTOR are returned from Sio;
 513     // ACPI_ADDRESS_SPACE_DESCRIPTOR is returned from PciIo.
 514     //
 515     while ((Resources.SmallHeader->Byte != ACPI_END_TAG_DESCRIPTOR) && (SerialDevice->BaseAddress == 0)) {
 516       switch (Resources.SmallHeader->Byte) {
 517       case ACPI_IO_PORT_DESCRIPTOR:
 518         Io = (EFI_ACPI_IO_PORT_DESCRIPTOR *) Resources.SmallHeader;
 519         if (Io->Length != 0) {
 520           SerialDevice->BaseAddress = Io->BaseAddressMin;
 521         }
 522         break;
 523
 524       case ACPI_FIXED_LOCATION_IO_PORT_DESCRIPTOR:
 525         FixedIo = (EFI_ACPI_FIXED_LOCATION_IO_PORT_DESCRIPTOR *) Resources.SmallHeader;
 526         if (FixedIo->Length != 0) {
 527           SerialDevice->BaseAddress = FixedIo->BaseAddress;
 528         }
 529         break;
 530
 531       case ACPI_ADDRESS_SPACE_DESCRIPTOR:
 532         AddressSpace = (EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *) Resources.SmallHeader;
 533         if (AddressSpace->AddrLen != 0) {
 534           if (AddressSpace->ResType == ACPI_ADDRESS_SPACE_TYPE_MEM) {
 535             SerialDevice->MmioAccess = TRUE;
 536           }
 537           SerialDevice->BaseAddress = AddressSpace->AddrRangeMin + Offset;
 538         }
 539         break;
 540       }
 541
 542       if (Resources.SmallHeader->Bits.Type == 0) {
 543         Resources.SmallHeader = (ACPI_SMALL_RESOURCE_HEADER *) ((UINT8 *) Resources.SmallHeader
 544                                                                 + Resources.SmallHeader->Bits.Length
 545                                                                 + sizeof (*Resources.SmallHeader));
 546       } else {
 547         Resources.LargeHeader = (ACPI_LARGE_RESOURCE_HEADER *) ((UINT8 *) Resources.LargeHeader
 548                                                                 + Resources.LargeHeader->Length
 549                                                                 + sizeof (*Resources.LargeHeader));
 550       }
 551     }
 552   }
 553
 554   if (SerialDevice->BaseAddress == 0) {
 555     Status = EFI_INVALID_PARAMETER;
 556     goto CreateError;
 557   }
 558
 559   SerialDevice->HardwareFlowControl = (BOOLEAN) (FlowControlMap == UART_FLOW_CONTROL_HARDWARE);
 560
 561   //
 562   // Report status code the serial present
 563   //
 564   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 565     EFI_PROGRESS_CODE,
 566     EFI_P_PC_PRESENCE_DETECT | EFI_PERIPHERAL_SERIAL_PORT,
 567     SerialDevice->ParentDevicePath
 568     );
 569
 570   if (!SerialPresent (SerialDevice)) {
 571     Status = EFI_DEVICE_ERROR;
 572     REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 573       EFI_ERROR_CODE,
 574       EFI_P_EC_NOT_DETECTED | EFI_PERIPHERAL_SERIAL_PORT,
 575       SerialDevice->ParentDevicePath
 576       );
 577     goto CreateError;
 578   }
 579
 580   //
 581   // 1. Append Controller device path node.
 582   //
 583   if (CreateControllerNode) {
 584     mControllerDevicePathTemplate.ControllerNumber = SerialDevice->Instance;
 585     SerialDevice->DevicePath = AppendDevicePathNode (
 586                                  SerialDevice->ParentDevicePath,
 587                                  (EFI_DEVICE_PATH_PROTOCOL *) &mControllerDevicePathTemplate
 588                                  );
 589     SerialDevice->ContainsControllerNode = TRUE;
 590   }
 591
 592   //
 593   // 2. Append UART device path node.
 594   //    The Uart setings are zero here.
 595   //    SetAttribute() will update them to match the default setings.
 596   //
 597   TempDevicePath = SerialDevice->DevicePath;
 598   if (TempDevicePath != NULL) {
 599     SerialDevice->DevicePath = AppendDevicePathNode (
 600                                  TempDevicePath,
 601                                  (EFI_DEVICE_PATH_PROTOCOL *) &SerialDevice->UartDevicePath
 602                                  );
 603     FreePool (TempDevicePath);
 604   } else {
 605     SerialDevice->DevicePath = AppendDevicePathNode (
 606                                  SerialDevice->ParentDevicePath,
 607                                  (EFI_DEVICE_PATH_PROTOCOL *) &SerialDevice->UartDevicePath
 608                                  );
 609   }
 610   //
 611   // 3. Append the Flow Control device path node.
 612   //    Only produce the Flow Control node when remaining device path has it
 613   //
 614   if (FlowControl != NULL) {
 615     TempDevicePath = SerialDevice->DevicePath;
 616     if (TempDevicePath != NULL) {
 617       SerialDevice->DevicePath = AppendDevicePathNode (
 618                                    TempDevicePath,
 619                                    (EFI_DEVICE_PATH_PROTOCOL *) FlowControl
 620                                    );
 621       FreePool (TempDevicePath);
 622     }
 623   }
 624   ASSERT (SerialDevice->DevicePath != NULL);
 625
 626   //
 627   // Fill in Serial I/O Mode structure based on either the RemainingDevicePath or defaults.
 628   //
 629   SerialDevice->SerialMode.BaudRate = SerialDevice->UartDevicePath.BaudRate;
 630   SerialDevice->SerialMode.DataBits = SerialDevice->UartDevicePath.DataBits;
 631   SerialDevice->SerialMode.Parity   = SerialDevice->UartDevicePath.Parity;
 632   SerialDevice->SerialMode.StopBits = SerialDevice->UartDevicePath.StopBits;
 633
 634   //
 635   // Issue a reset to initialize the COM port
 636   //
 637   Status = SerialDevice->SerialIo.Reset (&SerialDevice->SerialIo);
 638   if (EFI_ERROR (Status)) {
 639     REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 640       EFI_ERROR_CODE,
 641       EFI_P_EC_CONTROLLER_ERROR | EFI_PERIPHERAL_SERIAL_PORT,
 642       SerialDevice->DevicePath
 643       );
 644     goto CreateError;
 645   }
 646
 647   AddName (SerialDevice, Instance);
 648   //
 649   // Install protocol interfaces for the serial device.
 650   //
 651   Status = gBS->InstallMultipleProtocolInterfaces (
 652                   &SerialDevice->Handle,
 653                   &gEfiDevicePathProtocolGuid, SerialDevice->DevicePath,
 654                   &gEfiSerialIoProtocolGuid, &SerialDevice->SerialIo,
 655                   NULL
 656                   );
 657   if (EFI_ERROR (Status)) {
 658     goto CreateError;
 659   }
 660   //
 661   // Open For Child Device
 662   //
 663   Status = gBS->OpenProtocol (
 664                   Controller,
 665                   PciSerialParameter != NULL ? &gEfiPciIoProtocolGuid : &gEfiSioProtocolGuid,
 666                   (VOID **) &ParentIo,
 667                   gSerialControllerDriver.DriverBindingHandle,
 668                   SerialDevice->Handle,
 669                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 670                   );
 671
 672   if (EFI_ERROR (Status)) {
 673     gBS->UninstallMultipleProtocolInterfaces (
 674            &SerialDevice->Handle,
 675            &gEfiDevicePathProtocolGuid, SerialDevice->DevicePath,
 676            &gEfiSerialIoProtocolGuid, &SerialDevice->SerialIo,
 677            NULL
 678            );
 679   }
 680
 681 CreateError:
 682   if (EFI_ERROR (Status)) {
 683     if (SerialDevice->DevicePath != NULL) {
 684       FreePool (SerialDevice->DevicePath);
 685     }
 686     if (SerialDevice->ControllerNameTable != NULL) {
 687       FreeUnicodeStringTable (SerialDevice->ControllerNameTable);
 688     }
 689     FreePool (SerialDevice);
 690   }
 691   return Status;
 692 }
 693
 694 /**
 695   Returns an array of pointers containing all the child serial device pointers.
 696
 697   @param Controller      The parent controller handle.
 698   @param IoProtocolGuid  The protocol GUID, either equals to gEfiSioProtocolGuid
 699                          or equals to gEfiPciIoProtocolGuid.
 700   @param Count           Count of the serial devices.
 701
 702   @return  An array of pointers containing all the child serial device pointers.
 703 **/
 704 SERIAL_DEV **
 705 GetChildSerialDevices (
 706   IN EFI_HANDLE                       Controller,
 707   IN EFI_GUID                         *IoProtocolGuid,
 708   OUT UINTN                           *Count
 709   )
 710 {
 711   EFI_STATUS                                 Status;
 712   UINTN                                      Index;
 713   EFI_OPEN_PROTOCOL_INFORMATION_ENTRY        *OpenInfoBuffer;
 714   UINTN                                      EntryCount;
 715   SERIAL_DEV                                 **SerialDevices;
 716   EFI_SERIAL_IO_PROTOCOL                     *SerialIo;
 717   BOOLEAN                                    OpenByDriver;
 718
 719   *Count = 0;
 720   //
 721   // If the SerialIo instance specified by RemainingDevicePath is already created,
 722   // update the attributes/control.
 723   //
 724   Status = gBS->OpenProtocolInformation (
 725     Controller,
 726     IoProtocolGuid,
 727     &OpenInfoBuffer,
 728     &EntryCount
 729     );
 730   if (EFI_ERROR (Status)) {
 731     return NULL;
 732   }
 733
 734   SerialDevices = AllocatePool (EntryCount * sizeof (SERIAL_DEV *));
 735   ASSERT (SerialDevices != NULL);
 736
 737   *Count = 0;
 738   OpenByDriver = FALSE;
 739   for (Index = 0; Index < EntryCount; Index++) {
 740     if ((OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
 741       Status = gBS->OpenProtocol (
 742         OpenInfoBuffer[Index].ControllerHandle,
 743         &gEfiSerialIoProtocolGuid,
 744         (VOID **) &SerialIo,
 745         gSerialControllerDriver.DriverBindingHandle,
 746         Controller,
 747         EFI_OPEN_PROTOCOL_GET_PROTOCOL
 748         );
 749       if (!EFI_ERROR (Status)) {
 750         SerialDevices[(*Count)++] = SERIAL_DEV_FROM_THIS (SerialIo);
 751       }
 752     }
 753
 754
 755     if ((OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
 756       ASSERT (OpenInfoBuffer[Index].AgentHandle == gSerialControllerDriver.DriverBindingHandle);
 757       OpenByDriver = TRUE;
 758     }
 759   }
 760   if (OpenInfoBuffer != NULL) {
 761     FreePool (OpenInfoBuffer);
 762   }
 763
 764   ASSERT ((*Count == 0) || (OpenByDriver));
 765
 766   return SerialDevices;
 767 }
 768
 769 /**
 770   Start to management the controller passed in
 771
 772   @param  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
 773   @param  Controller           The handle of the controller to test.
 774   @param  RemainingDevicePath  A pointer to the remaining portion of a device path.
 775
 776   @return EFI_SUCCESS   Driver is started successfully
 777 **/
 778 EFI_STATUS
 779 EFIAPI
 780 SerialControllerDriverStart (
 781   IN EFI_DRIVER_BINDING_PROTOCOL    *This,
 782   IN EFI_HANDLE                     Controller,
 783   IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath
 784   )
 785 {
 786   EFI_STATUS                                 Status;
 787   UINTN                                      Index;
 788   EFI_DEVICE_PATH_PROTOCOL                   *ParentDevicePath;
 789   EFI_DEVICE_PATH_PROTOCOL                   *Node;
 790   EFI_SERIAL_IO_PROTOCOL                     *SerialIo;
 791   UINT32                                     ControllerNumber;
 792   UART_DEVICE_PATH                           *Uart;
 793   UART_FLOW_CONTROL_DEVICE_PATH              *FlowControl;
 794   UINT32                                     Control;
 795   PARENT_IO_PROTOCOL_PTR                     ParentIo;
 796   ACPI_HID_DEVICE_PATH                       *Acpi;
 797   EFI_GUID                                   *IoProtocolGuid;
 798   PCI_SERIAL_PARAMETER                       *PciSerialParameter;
 799   PCI_SERIAL_PARAMETER                       DefaultPciSerialParameter;
 800   PCI_TYPE00                                 Pci;
 801   UINT32                                     PciSerialCount;
 802   SERIAL_DEV                                 **SerialDevices;
 803   UINTN                                      SerialDeviceCount;
 804   PCI_DEVICE_INFO                            *PciDeviceInfo;
 805   UINT64                                     Supports;
 806   BOOLEAN                                    ContainsControllerNode;
 807
 808   //
 809   // Get the Parent Device Path
 810   //
 811   Status = gBS->OpenProtocol (
 812                   Controller,
 813                   &gEfiDevicePathProtocolGuid,
 814                   (VOID **) &ParentDevicePath,
 815                   This->DriverBindingHandle,
 816                   Controller,
 817                   EFI_OPEN_PROTOCOL_BY_DRIVER
 818                   );
 819   if (EFI_ERROR (Status) && Status != EFI_ALREADY_STARTED) {
 820     return Status;
 821   }
 822   //
 823   // Report status code enable the serial
 824   //
 825   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
 826     EFI_PROGRESS_CODE,
 827     EFI_P_PC_ENABLE | EFI_PERIPHERAL_SERIAL_PORT,
 828     ParentDevicePath
 829     );
 830
 831   //
 832   // Grab the IO abstraction we need to get any work done
 833   //
 834   IoProtocolGuid = &gEfiSioProtocolGuid;
 835   Status = gBS->OpenProtocol (
 836                   Controller,
 837                   IoProtocolGuid,
 838                   (VOID **) &ParentIo,
 839                   This->DriverBindingHandle,
 840                   Controller,
 841                   EFI_OPEN_PROTOCOL_BY_DRIVER
 842                   );
 843   if (EFI_ERROR (Status) && Status != EFI_ALREADY_STARTED) {
 844     IoProtocolGuid = &gEfiPciIoProtocolGuid;
 845     Status = gBS->OpenProtocol (
 846                     Controller,
 847                     IoProtocolGuid,
 848                     (VOID **) &ParentIo,
 849                     This->DriverBindingHandle,
 850                     Controller,
 851                     EFI_OPEN_PROTOCOL_BY_DRIVER
 852                     );
 853   }
 854   ASSERT (!EFI_ERROR (Status) || Status == EFI_ALREADY_STARTED);
 855
 856   //
 857   // Do nothing for END device path node
 858   //
 859   if ((RemainingDevicePath != NULL) && IsDevicePathEnd (RemainingDevicePath)) {
 860     return EFI_SUCCESS;
 861   }
 862
 863   ControllerNumber = 0;
 864   ContainsControllerNode = FALSE;
 865   SerialDevices = GetChildSerialDevices (Controller, IoProtocolGuid, &SerialDeviceCount);
 866   //
 867   // If the SerialIo instance specified by RemainingDevicePath is already created,
 868   // update the attributes/control.
 869   //
 870   if ((SerialDeviceCount != 0) && (RemainingDevicePath != NULL)) {
 871     Uart = (UART_DEVICE_PATH *) SkipControllerDevicePathNode (RemainingDevicePath, &ContainsControllerNode, &ControllerNumber);
 872     for (Index = 0; Index < SerialDeviceCount; Index++) {
 873       ASSERT ((SerialDevices != NULL) && (SerialDevices[Index] != NULL));
 874       if ((!SerialDevices[Index]->ContainsControllerNode && !ContainsControllerNode) ||
 875           (SerialDevices[Index]->ContainsControllerNode && ContainsControllerNode && SerialDevices[Index]->Instance == ControllerNumber)
 876           ) {
 877         SerialIo = &SerialDevices[Index]->SerialIo;
 878         Status = EFI_INVALID_PARAMETER;
 879         //
 880         // Pass NULL ActualBaudRate to VerifyUartParameters to disallow baudrate degrade.
 881         // DriverBindingStart() shouldn't create a handle with different UART device path.
 882         //
 883         if (VerifyUartParameters (SerialDevices[Index]->ClockRate, Uart->BaudRate, Uart->DataBits,
 884                                   (EFI_PARITY_TYPE) Uart->Parity, (EFI_STOP_BITS_TYPE) Uart->StopBits, NULL, NULL)) {
 885           Status = SerialIo->SetAttributes (
 886                                SerialIo,
 887                                Uart->BaudRate,
 888                                SerialIo->Mode->ReceiveFifoDepth,
 889                                SerialIo->Mode->Timeout,
 890                                (EFI_PARITY_TYPE) Uart->Parity,
 891                                Uart->DataBits,
 892                                (EFI_STOP_BITS_TYPE) Uart->StopBits
 893                                );
 894         }
 895         FlowControl = (UART_FLOW_CONTROL_DEVICE_PATH *) NextDevicePathNode (Uart);
 896         if (!EFI_ERROR (Status) && IsUartFlowControlDevicePathNode (FlowControl)) {
 897           Status = SerialIo->GetControl (SerialIo, &Control);
 898           if (!EFI_ERROR (Status)) {
 899             if (ReadUnaligned32 (&FlowControl->FlowControlMap) == UART_FLOW_CONTROL_HARDWARE) {
 900               Control |= EFI_SERIAL_HARDWARE_FLOW_CONTROL_ENABLE;
 901             } else {
 902               Control &= ~EFI_SERIAL_HARDWARE_FLOW_CONTROL_ENABLE;
 903             }
 904             //
 905             // Clear the bits that are not allowed to pass to SetControl
 906             //
 907             Control &= (EFI_SERIAL_REQUEST_TO_SEND | EFI_SERIAL_DATA_TERMINAL_READY |
 908                         EFI_SERIAL_HARDWARE_LOOPBACK_ENABLE | EFI_SERIAL_SOFTWARE_LOOPBACK_ENABLE |
 909                         EFI_SERIAL_HARDWARE_FLOW_CONTROL_ENABLE);
 910             Status = SerialIo->SetControl (SerialIo, Control);
 911           }
 912         }
 913         break;
 914       }
 915     }
 916     if (Index != SerialDeviceCount) {
 917       //
 918       // Directly return if the SerialIo instance specified by RemainingDevicePath is found and updated.
 919       // Otherwise continue to create the instance specified by RemainingDevicePath.
 920       //
 921       if (SerialDevices != NULL) {
 922         FreePool (SerialDevices);
 923       }
 924       return Status;
 925     }
 926   }
 927
 928   if (RemainingDevicePath != NULL) {
 929     Uart = (UART_DEVICE_PATH *) SkipControllerDevicePathNode (RemainingDevicePath, &ContainsControllerNode, &ControllerNumber);
 930   } else {
 931     Uart = NULL;
 932   }
 933
 934   PciDeviceInfo = NULL;
 935   if (IoProtocolGuid == &gEfiSioProtocolGuid) {
 936     Status = EFI_NOT_FOUND;
 937     if (RemainingDevicePath == NULL || !ContainsControllerNode) {
 938       Node = ParentDevicePath;
 939       do {
 940         Acpi = (ACPI_HID_DEVICE_PATH *) Node;
 941         Node = NextDevicePathNode (Node);
 942       } while (!IsDevicePathEnd (Node));
 943       Status = CreateSerialDevice (Controller, Uart, ParentDevicePath, FALSE, Acpi->UID, ParentIo, NULL, NULL);
 944       DEBUG ((EFI_D_INFO, "PciSioSerial: Create SIO child serial device - %r\n", Status));
 945     }
 946   } else {
 947     Status = ParentIo.PciIo->Pci.Read (ParentIo.PciIo, EfiPciIoWidthUint8, 0, sizeof (Pci), &Pci);
 948     if (!EFI_ERROR (Status)) {
 949       //
 950       // PcdPciSerialParameters takes the higher priority.
 951       //
 952       PciSerialCount = 0;
 953       for (PciSerialParameter = PcdGetPtr (PcdPciSerialParameters); PciSerialParameter->VendorId != 0xFFFF; PciSerialParameter++) {
 954         if ((PciSerialParameter->VendorId == Pci.Hdr.VendorId) &&
 955             (PciSerialParameter->DeviceId == Pci.Hdr.DeviceId)
 956             ) {
 957           PciSerialCount++;
 958         }
 959       }
 960
 961       if (SerialDeviceCount == 0) {
 962         //
 963         // Enable the IO & MEM decoding when creating the first child.
 964         // Restore the PCI attributes when all children is destroyed (PciDeviceInfo->ChildCount == 0).
 965         //
 966         PciDeviceInfo = AllocatePool (sizeof (PCI_DEVICE_INFO));
 967         ASSERT (PciDeviceInfo != NULL);
 968         PciDeviceInfo->ChildCount = 0;
 969         PciDeviceInfo->PciIo = ParentIo.PciIo;
 970         Status = ParentIo.PciIo->Attributes (
 971           ParentIo.PciIo,
 972           EfiPciIoAttributeOperationGet,
 973           0,
 974           &PciDeviceInfo->PciAttributes
 975           );
 976
 977         if (!EFI_ERROR (Status)) {
 978           Status = ParentIo.PciIo->Attributes (
 979             ParentIo.PciIo,
 980             EfiPciIoAttributeOperationSupported,
 981             0,
 982             &Supports
 983             );
 984           if (!EFI_ERROR (Status)) {
 985             Supports &= EFI_PCI_IO_ATTRIBUTE_IO | EFI_PCI_IO_ATTRIBUTE_MEMORY;
 986             Status = ParentIo.PciIo->Attributes (
 987               ParentIo.PciIo,
 988               EfiPciIoAttributeOperationEnable,
 989               Supports,
 990               NULL
 991               );
 992           }
 993         }
 994       } else {
 995         //
 996         // Re-use the PciDeviceInfo stored in existing children.
 997         //
 998         ASSERT ((SerialDevices != NULL) && (SerialDevices[0] != NULL));
 999         PciDeviceInfo = SerialDevices[0]->PciDeviceInfo;
1000         ASSERT (PciDeviceInfo != NULL);
1001       }
1002
1003       Status = EFI_NOT_FOUND;
1004       if (PciSerialCount <= 1) {
1005         //
1006         // PCI serial device contains only one UART
1007         //
1008         if (RemainingDevicePath == NULL || !ContainsControllerNode) {
1009           //
1010           // This PCI serial device is matched by class code in Supported()
1011           //
1012           if (PciSerialCount == 0) {
1013             DefaultPciSerialParameter.VendorId = Pci.Hdr.VendorId;
1014             DefaultPciSerialParameter.DeviceId = Pci.Hdr.DeviceId;
1015             DefaultPciSerialParameter.BarIndex = 0;
1016             DefaultPciSerialParameter.Offset = 0;
1017             DefaultPciSerialParameter.RegisterStride = 0;
1018             DefaultPciSerialParameter.ClockRate = 0;
1019             PciSerialParameter = &DefaultPciSerialParameter;
1020           } else if (PciSerialCount == 1) {
1021             PciSerialParameter = PcdGetPtr (PcdPciSerialParameters);
1022           }
1023
1024           Status = CreateSerialDevice (Controller, Uart, ParentDevicePath, FALSE, 0, ParentIo, PciSerialParameter, PciDeviceInfo);
1025           DEBUG ((EFI_D_INFO, "PciSioSerial: Create PCI child serial device (single) - %r\n", Status));
1026           if (!EFI_ERROR (Status)) {
1027             PciDeviceInfo->ChildCount++;
1028           }
1029         }
1030       } else {
1031         //
1032         // PCI serial device contains multiple UARTs
1033         //
1034         if (RemainingDevicePath == NULL || ContainsControllerNode) {
1035           PciSerialCount = 0;
1036           for (PciSerialParameter = PcdGetPtr (PcdPciSerialParameters); PciSerialParameter->VendorId != 0xFFFF; PciSerialParameter++) {
1037             if ((PciSerialParameter->VendorId == Pci.Hdr.VendorId) &&
1038                 (PciSerialParameter->DeviceId == Pci.Hdr.DeviceId) &&
1039                 ((RemainingDevicePath == NULL) || (ControllerNumber == PciSerialCount))
1040                 ) {
1041               //
1042               // Create controller node when PCI serial device contains multiple UARTs
1043               //
1044               Status = CreateSerialDevice (Controller, Uart, ParentDevicePath, TRUE, PciSerialCount, ParentIo, PciSerialParameter, PciDeviceInfo);
1045               PciSerialCount++;
1046               DEBUG ((EFI_D_INFO, "PciSioSerial: Create PCI child serial device (multiple) - %r\n", Status));
1047               if (!EFI_ERROR (Status)) {
1048                 PciDeviceInfo->ChildCount++;
1049               }
1050             }
1051           }
1052         }
1053       }
1054     }
1055   }
1056
1057   if (SerialDevices != NULL) {
1058     FreePool (SerialDevices);
1059   }
1060
1061   //
1062   // For multiple PCI serial devices, set Status to SUCCESS if one child is created successfully
1063   //
1064   if ((PciDeviceInfo != NULL) && (PciDeviceInfo->ChildCount != 0)) {
1065     Status = EFI_SUCCESS;
1066   }
1067
1068   if (EFI_ERROR (Status) && (SerialDeviceCount == 0)) {
1069     if (PciDeviceInfo != NULL) {
1070       Status = ParentIo.PciIo->Attributes (
1071         ParentIo.PciIo,
1072         EfiPciIoAttributeOperationSet,
1073         PciDeviceInfo->PciAttributes,
1074         NULL
1075         );
1076       ASSERT_EFI_ERROR (Status);
1077       FreePool (PciDeviceInfo);
1078     }
1079     gBS->CloseProtocol (
1080            Controller,
1081            &gEfiDevicePathProtocolGuid,
1082            This->DriverBindingHandle,
1083            Controller
1084            );
1085     gBS->CloseProtocol (
1086            Controller,
1087            IoProtocolGuid,
1088            This->DriverBindingHandle,
1089            Controller
1090            );
1091   }
1092
1093   return Status;
1094 }
1095
1096 /**
1097   Disconnect this driver with the controller, uninstall related protocol instance
1098
1099   @param  This                  A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
1100   @param  Controller            The handle of the controller to test.
1101   @param  NumberOfChildren      Number of child device.
1102   @param  ChildHandleBuffer     A pointer to the remaining portion of a device path.
1103
1104   @retval EFI_SUCCESS           Operation successfully
1105   @retval EFI_DEVICE_ERROR      Cannot stop the driver successfully
1106
1107 **/
1108 EFI_STATUS
1109 EFIAPI
1110 SerialControllerDriverStop (
1111   IN  EFI_DRIVER_BINDING_PROTOCOL    *This,
1112   IN  EFI_HANDLE                     Controller,
1113   IN  UINTN                          NumberOfChildren,
1114   IN  EFI_HANDLE                     *ChildHandleBuffer
1115   )
1116
1117 {
1118   EFI_STATUS                          Status;
1119   UINTN                               Index;
1120   BOOLEAN                             AllChildrenStopped;
1121   EFI_SERIAL_IO_PROTOCOL              *SerialIo;
1122   SERIAL_DEV                          *SerialDevice;
1123   VOID                                *IoProtocol;
1124   EFI_DEVICE_PATH_PROTOCOL            *DevicePath;
1125   PCI_DEVICE_INFO                     *PciDeviceInfo;
1126
1127   PciDeviceInfo = NULL;
1128
1129   Status = gBS->HandleProtocol (
1130                   Controller,
1131                   &gEfiDevicePathProtocolGuid,
1132                   (VOID **) &DevicePath
1133                   );
1134
1135   //
1136   // Report the status code disable the serial
1137   //
1138   REPORT_STATUS_CODE_WITH_DEVICE_PATH (
1139     EFI_PROGRESS_CODE,
1140     EFI_P_PC_DISABLE | EFI_PERIPHERAL_SERIAL_PORT,
1141     DevicePath
1142     );
1143
1144   if (NumberOfChildren == 0) {
1145     //
1146     // Close the bus driver
1147     //
1148     Status = gBS->OpenProtocol (
1149                     Controller,
1150                     &gEfiPciIoProtocolGuid,
1151                     &IoProtocol,
1152                     This->DriverBindingHandle,
1153                     Controller,
1154                     EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1155                     );
1156     gBS->CloseProtocol (
1157            Controller,
1158            !EFI_ERROR (Status) ? &gEfiPciIoProtocolGuid : &gEfiSioProtocolGuid,
1159            This->DriverBindingHandle,
1160            Controller
1161            );
1162
1163     gBS->CloseProtocol (
1164            Controller,
1165            &gEfiDevicePathProtocolGuid,
1166            This->DriverBindingHandle,
1167            Controller
1168            );
1169     return EFI_SUCCESS;
1170   }
1171
1172   AllChildrenStopped = TRUE;
1173
1174   for (Index = 0; Index < NumberOfChildren; Index++) {
1175
1176     Status = gBS->OpenProtocol (
1177                     ChildHandleBuffer[Index],
1178                     &gEfiSerialIoProtocolGuid,
1179                     (VOID **) &SerialIo,
1180                     This->DriverBindingHandle,
1181                     Controller,
1182                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
1183                     );
1184     if (!EFI_ERROR (Status)) {
1185
1186       SerialDevice = SERIAL_DEV_FROM_THIS (SerialIo);
1187       ASSERT ((PciDeviceInfo == NULL) || (PciDeviceInfo == SerialDevice->PciDeviceInfo));
1188       PciDeviceInfo = SerialDevice->PciDeviceInfo;
1189
1190       Status = gBS->CloseProtocol (
1191                       Controller,
1192                       PciDeviceInfo != NULL ? &gEfiPciIoProtocolGuid : &gEfiSioProtocolGuid,
1193                       This->DriverBindingHandle,
1194                       ChildHandleBuffer[Index]
1195                       );
1196
1197       Status = gBS->UninstallMultipleProtocolInterfaces (
1198                       ChildHandleBuffer[Index],
1199                       &gEfiDevicePathProtocolGuid, SerialDevice->DevicePath,
1200                       &gEfiSerialIoProtocolGuid,   &SerialDevice->SerialIo,
1201                       NULL
1202                       );
1203       if (EFI_ERROR (Status)) {
1204         gBS->OpenProtocol (
1205                Controller,
1206                PciDeviceInfo != NULL ? &gEfiPciIoProtocolGuid : &gEfiSioProtocolGuid,
1207                &IoProtocol,
1208                This->DriverBindingHandle,
1209                ChildHandleBuffer[Index],
1210                EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
1211                );
1212       } else {
1213         FreePool (SerialDevice->DevicePath);
1214         FreeUnicodeStringTable (SerialDevice->ControllerNameTable);
1215         FreePool (SerialDevice);
1216
1217         if (PciDeviceInfo != NULL) {
1218           ASSERT (PciDeviceInfo->ChildCount != 0);
1219           PciDeviceInfo->ChildCount--;
1220         }
1221       }
1222     }
1223
1224     if (EFI_ERROR (Status)) {
1225       AllChildrenStopped = FALSE;
1226     }
1227   }
1228
1229   if (!AllChildrenStopped) {
1230     return EFI_DEVICE_ERROR;
1231   } else {
1232     //
1233     // If all children are destroyed, restore the PCI attributes.
1234     //
1235     if ((PciDeviceInfo != NULL) && (PciDeviceInfo->ChildCount == 0)) {
1236       ASSERT (PciDeviceInfo->PciIo != NULL);
1237       Status = PciDeviceInfo->PciIo->Attributes (
1238         PciDeviceInfo->PciIo,
1239         EfiPciIoAttributeOperationSet,
1240         PciDeviceInfo->PciAttributes,
1241         NULL
1242         );
1243       ASSERT_EFI_ERROR (Status);
1244       FreePool (PciDeviceInfo);
1245     }
1246     return EFI_SUCCESS;
1247   }
1248 }