[mirror_edk2.git] / MdeModulePkg / Bus / Pci / PciBusDxe / PciOptionRomSupport.c

/** @file\r
  PCI Rom supporting funtions implementation for PCI Bus module.\r
\r
Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "PciBus.h"\r
\r
/**\r
  Load the EFI Image from Option ROM\r
\r
  @param PciIoDevice   PCI IO device instance.\r
  @param FilePath      The file path of the EFI Image\r
  @param BufferSize    On input the size of Buffer in bytes. On output with a return\r
                       code of EFI_SUCCESS, the amount of data transferred to Buffer.\r
                       On output with a return code of EFI_BUFFER_TOO_SMALL,\r
                       the size of Buffer required to retrieve the requested file.\r
  @param Buffer        The memory buffer to transfer the file to. If Buffer is NULL,\r
                       then no the size of the requested file is returned in BufferSize.\r
\r
  @retval EFI_SUCCESS           The file was loaded.\r
  @retval EFI_INVALID_PARAMETER FilePath is not a valid device path, or\r
                                BufferSize is NULL.\r
  @retval EFI_NOT_FOUND         Not found PCI Option Rom on PCI device.\r
  @retval EFI_DEVICE_ERROR      Failed to decompress PCI Option Rom image.\r
  @retval EFI_BUFFER_TOO_SMALL  The BufferSize is too small to read the current directory entry.\r
                                BufferSize has been updated with the size needed to complete the request.\r
**/\r
EFI_STATUS\r
LocalLoadFile2 (\r
  IN PCI_IO_DEVICE            *PciIoDevice,\r
  IN EFI_DEVICE_PATH_PROTOCOL *FilePath,\r
  IN OUT UINTN                *BufferSize,\r
  IN VOID                     *Buffer      OPTIONAL\r
  )\r
{\r
  EFI_STATUS                                Status;\r
  MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH   *EfiOpRomImageNode;\r
  EFI_PCI_EXPANSION_ROM_HEADER              *EfiRomHeader;\r
  PCI_DATA_STRUCTURE                        *Pcir;\r
  UINT32                                    ImageSize;\r
  UINT8                                     *ImageBuffer;\r
  UINT32                                    ImageLength;\r
  UINT32                                    DestinationSize;\r
  UINT32                                    ScratchSize;\r
  VOID                                      *Scratch;\r
  EFI_DECOMPRESS_PROTOCOL                   *Decompress;\r
  UINT32                                    InitializationSize;\r
\r
  EfiOpRomImageNode = (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *) FilePath;\r
  if ((EfiOpRomImageNode == NULL) ||\r
      (DevicePathType (FilePath) != MEDIA_DEVICE_PATH) ||\r
      (DevicePathSubType (FilePath) != MEDIA_RELATIVE_OFFSET_RANGE_DP) ||\r
      (DevicePathNodeLength (FilePath) != sizeof (MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH)) ||\r
      (!IsDevicePathEnd (NextDevicePathNode (FilePath))) ||\r
      (EfiOpRomImageNode->StartingOffset > EfiOpRomImageNode->EndingOffset) ||\r
      (EfiOpRomImageNode->EndingOffset >= PciIoDevice->RomSize) ||\r
      (BufferSize == NULL)\r
      ) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  EfiRomHeader = (EFI_PCI_EXPANSION_ROM_HEADER *) (\r
      (UINT8 *) PciIoDevice->PciIo.RomImage + EfiOpRomImageNode->StartingOffset\r
      );\r
  if (EfiRomHeader->Signature != PCI_EXPANSION_ROM_HEADER_SIGNATURE) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
\r
  Pcir = (PCI_DATA_STRUCTURE *) ((UINT8 *) EfiRomHeader + EfiRomHeader->PcirOffset);\r
  ASSERT (Pcir->Signature == PCI_DATA_STRUCTURE_SIGNATURE);\r
\r
  if ((Pcir->CodeType == PCI_CODE_TYPE_EFI_IMAGE) &&\r
      (EfiRomHeader->EfiSignature == EFI_PCI_EXPANSION_ROM_HEADER_EFISIGNATURE) &&\r
      ((EfiRomHeader->EfiSubsystem == EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER) ||\r
       (EfiRomHeader->EfiSubsystem == EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER)) &&\r
      (EfiRomHeader->CompressionType <= EFI_PCI_EXPANSION_ROM_HEADER_COMPRESSED)\r
       ) {\r
\r
    ImageSize = Pcir->ImageLength * 512;\r
    InitializationSize = (UINT32) EfiRomHeader->InitializationSize * 512;\r
    if (InitializationSize > ImageSize || EfiRomHeader->EfiImageHeaderOffset >=  InitializationSize) {\r
      return EFI_NOT_FOUND;\r
    }\r
\r
    ImageBuffer             = (UINT8 *) EfiRomHeader + EfiRomHeader->EfiImageHeaderOffset;\r
    ImageLength             = InitializationSize - EfiRomHeader->EfiImageHeaderOffset;\r
\r
    if (EfiRomHeader->CompressionType != EFI_PCI_EXPANSION_ROM_HEADER_COMPRESSED) {\r
      //\r
      // Uncompressed: Copy the EFI Image directly to user's buffer\r
      //\r
      if (Buffer == NULL || *BufferSize < ImageLength) {\r
        *BufferSize = ImageLength;\r
        return EFI_BUFFER_TOO_SMALL;\r
      }\r
\r
      *BufferSize = ImageLength;\r
      CopyMem (Buffer, ImageBuffer, ImageLength);\r
      return EFI_SUCCESS;\r
\r
    } else {\r
      //\r
      // Compressed: Uncompress before copying\r
      //\r
      Status = gBS->LocateProtocol (&gEfiDecompressProtocolGuid, NULL, (VOID **) &Decompress);\r
      if (EFI_ERROR (Status)) {\r
        return EFI_DEVICE_ERROR;\r
      }\r
      Status = Decompress->GetInfo (\r
                             Decompress,\r
                             ImageBuffer,\r
                             ImageLength,\r
                             &DestinationSize,\r
                             &ScratchSize\r
                             );\r
      if (EFI_ERROR (Status)) {\r
        return EFI_DEVICE_ERROR;\r
      }\r
\r
      if (Buffer == NULL || *BufferSize < DestinationSize) {\r
        *BufferSize = DestinationSize;\r
        return EFI_BUFFER_TOO_SMALL;\r
      }\r
\r
      *BufferSize = DestinationSize;\r
      Scratch = AllocatePool (ScratchSize);\r
      if (Scratch == NULL) {\r
        return EFI_DEVICE_ERROR;\r
      }\r
\r
      Status = Decompress->Decompress (\r
                             Decompress,\r
                             ImageBuffer,\r
                             ImageLength,\r
                             Buffer,\r
                             DestinationSize,\r
                             Scratch,\r
                             ScratchSize\r
                             );\r
      FreePool (Scratch);\r
\r
      if (EFI_ERROR (Status)) {\r
        return EFI_DEVICE_ERROR;\r
      }\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
/**\r
  Initialize a PCI LoadFile2 instance.\r
\r
  @param PciIoDevice   PCI IO Device.\r
\r
**/\r
VOID\r
InitializePciLoadFile2 (\r
  IN PCI_IO_DEVICE       *PciIoDevice\r
  )\r
{\r
  PciIoDevice->LoadFile2.LoadFile = LoadFile2;\r
}\r
\r
/**\r
  Causes the driver to load a specified file.\r
\r
  @param This        Indicates a pointer to the calling context.\r
  @param FilePath    The device specific path of the file to load.\r
  @param BootPolicy  Should always be FALSE.\r
  @param BufferSize  On input the size of Buffer in bytes. On output with a return\r
                     code of EFI_SUCCESS, the amount of data transferred to Buffer.\r
                     On output with a return code of EFI_BUFFER_TOO_SMALL,\r
                     the size of Buffer required to retrieve the requested file.\r
  @param Buffer      The memory buffer to transfer the file to. If Buffer is NULL,\r
                     then no the size of the requested file is returned in BufferSize.\r
\r
  @retval EFI_SUCCESS           The file was loaded.\r
  @retval EFI_UNSUPPORTED       BootPolicy is TRUE.\r
  @retval EFI_INVALID_PARAMETER FilePath is not a valid device path, or\r
                                BufferSize is NULL.\r
  @retval EFI_NOT_FOUND         Not found PCI Option Rom on PCI device.\r
  @retval EFI_DEVICE_ERROR      Failed to decompress PCI Option Rom image.\r
  @retval EFI_BUFFER_TOO_SMALL  The BufferSize is too small to read the current directory entry.\r
                                BufferSize has been updated with the size needed to complete the request.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
LoadFile2 (\r
  IN EFI_LOAD_FILE2_PROTOCOL  *This,\r
  IN EFI_DEVICE_PATH_PROTOCOL *FilePath,\r
  IN BOOLEAN                  BootPolicy,\r
  IN OUT UINTN                *BufferSize,\r
  IN VOID                     *Buffer      OPTIONAL\r
  )\r
{\r
  PCI_IO_DEVICE                             *PciIoDevice;\r
\r
  if (BootPolicy) {\r
    return EFI_UNSUPPORTED;\r
  }\r
  PciIoDevice = PCI_IO_DEVICE_FROM_LOAD_FILE2_THIS (This);\r
\r
  return LocalLoadFile2 (\r
           PciIoDevice,\r
           FilePath,\r
           BufferSize,\r
           Buffer\r
           );\r
}\r
\r
/**\r
  Get Pci device's oprom information.\r
\r
  @param PciIoDevice    Input Pci device instance.\r
                        Output Pci device instance with updated OptionRom size.\r
\r
  @retval EFI_NOT_FOUND Pci device has not Option Rom.\r
  @retval EFI_SUCCESS   Pci device has Option Rom.\r
\r
**/\r
EFI_STATUS\r
GetOpRomInfo (\r
  IN OUT PCI_IO_DEVICE    *PciIoDevice\r
  )\r
{\r
  UINT8                           RomBarIndex;\r
  UINT32                          AllOnes;\r
  UINT64                          Address;\r
  EFI_STATUS                      Status;\r
  UINT8                           Bus;\r
  UINT8                           Device;\r
  UINT8                           Function;\r
  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *PciRootBridgeIo;\r
\r
  Bus             = PciIoDevice->BusNumber;\r
  Device          = PciIoDevice->DeviceNumber;\r
  Function        = PciIoDevice->FunctionNumber;\r
\r
  PciRootBridgeIo = PciIoDevice->PciRootBridgeIo;\r
\r
  //\r
  // Offset is 0x30 if is not ppb\r
  //\r
\r
  //\r
  // 0x30\r
  //\r
  RomBarIndex = PCI_EXPANSION_ROM_BASE;\r
\r
  if (IS_PCI_BRIDGE (&PciIoDevice->Pci)) {\r
    //\r
    // If is ppb, 0x38\r
    //\r
    RomBarIndex = PCI_BRIDGE_ROMBAR;\r
  }\r
  //\r
  // The bit0 is 0 to prevent the enabling of the Rom address decoder\r
  //\r
  AllOnes = 0xfffffffe;\r
  Address = EFI_PCI_ADDRESS (Bus, Device, Function, RomBarIndex);\r
\r
  Status = PciRootBridgeIo->Pci.Write (\r
                                  PciRootBridgeIo,\r
                                  EfiPciWidthUint32,\r
                                  Address,\r
                                  1,\r
                                  &AllOnes\r
                                  );\r
  if (EFI_ERROR (Status)) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  //\r
  // Read back\r
  //\r
  Status = PciRootBridgeIo->Pci.Read(\r
                                  PciRootBridgeIo,\r
                                  EfiPciWidthUint32,\r
                                  Address,\r
                                  1,\r
                                  &AllOnes\r
                                  );\r
  if (EFI_ERROR (Status)) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  //\r
  // Bits [1, 10] are reserved\r
  //\r
  AllOnes &= 0xFFFFF800;\r
  if ((AllOnes == 0) || (AllOnes == 0xFFFFF800)) {\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  PciIoDevice->RomSize = (~AllOnes) + 1;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Check if the RomImage contains EFI Images.\r
\r
  @param  RomImage  The ROM address of Image for check.\r
  @param  RomSize   Size of ROM for check.\r
\r
  @retval TRUE     ROM contain EFI Image.\r
  @retval FALSE    ROM not contain EFI Image.\r
\r
**/\r
BOOLEAN\r
ContainEfiImage (\r
  IN VOID            *RomImage,\r
  IN UINT64          RomSize\r
  )\r
{\r
  PCI_EXPANSION_ROM_HEADER  *RomHeader;\r
  PCI_DATA_STRUCTURE        *RomPcir;\r
  UINT8                     Indicator;\r
\r
  Indicator = 0;\r
  RomHeader = RomImage;\r
  if (RomHeader == NULL) {\r
    return FALSE;\r
  }\r
\r
  do {\r
    if (RomHeader->Signature != PCI_EXPANSION_ROM_HEADER_SIGNATURE) {\r
      RomHeader = (PCI_EXPANSION_ROM_HEADER *) ((UINT8 *) RomHeader + 512);\r
      continue;\r
    }\r
\r
    //\r
    // The PCI Data Structure must be DWORD aligned.\r
    //\r
    if (RomHeader->PcirOffset == 0 ||\r
        (RomHeader->PcirOffset & 3) != 0 ||\r
        (UINT8 *) RomHeader + RomHeader->PcirOffset + sizeof (PCI_DATA_STRUCTURE) > (UINT8 *) RomImage + RomSize) {\r
      break;\r
    }\r
\r
    RomPcir = (PCI_DATA_STRUCTURE *) ((UINT8 *) RomHeader + RomHeader->PcirOffset);\r
    if (RomPcir->Signature != PCI_DATA_STRUCTURE_SIGNATURE) {\r
      break;\r
    }\r
\r
    if (RomPcir->CodeType == PCI_CODE_TYPE_EFI_IMAGE) {\r
      return TRUE;\r
    }\r
\r
    Indicator = RomPcir->Indicator;\r
    RomHeader = (PCI_EXPANSION_ROM_HEADER *) ((UINT8 *) RomHeader + RomPcir->ImageLength * 512);\r
  } while (((UINT8 *) RomHeader < (UINT8 *) RomImage + RomSize) && ((Indicator & 0x80) == 0x00));\r
\r
  return FALSE;\r
}\r
\r
/**\r
  Load Option Rom image for specified PCI device.\r
\r
  @param PciDevice Pci device instance.\r
  @param RomBase   Base address of Option Rom.\r
\r
  @retval EFI_OUT_OF_RESOURCES No enough memory to hold image.\r
  @retval EFI_SUCESS           Successfully loaded Option Rom.\r
\r
**/\r
EFI_STATUS\r
LoadOpRomImage (\r
  IN PCI_IO_DEVICE   *PciDevice,\r
  IN UINT64          RomBase\r
  )\r
{\r
  UINT8                     RomBarIndex;\r
  UINT8                     Indicator;\r
  UINT16                    OffsetPcir;\r
  UINT32                    RomBarOffset;\r
  UINT32                    RomBar;\r
  EFI_STATUS                RetStatus;\r
  BOOLEAN                   FirstCheck;\r
  UINT8                     *Image;\r
  PCI_EXPANSION_ROM_HEADER  *RomHeader;\r
  PCI_DATA_STRUCTURE        *RomPcir;\r
  UINT64                    RomSize;\r
  UINT64                    RomImageSize;\r
  UINT32                    LegacyImageLength;\r
  UINT8                     *RomInMemory;\r
  UINT8                     CodeType;\r
\r
  RomSize       = PciDevice->RomSize;\r
\r
  Indicator     = 0;\r
  RomImageSize  = 0;\r
  RomInMemory   = NULL;\r
  CodeType      = 0xFF;\r
\r
  //\r
  // Get the RomBarIndex\r
  //\r
\r
  //\r
  // 0x30\r
  //\r
  RomBarIndex = PCI_EXPANSION_ROM_BASE;\r
  if (IS_PCI_BRIDGE (&(PciDevice->Pci))) {\r
    //\r
    // if is ppb\r
    //\r
\r
    //\r
    // 0x38\r
    //\r
    RomBarIndex = PCI_BRIDGE_ROMBAR;\r
  }\r
  //\r
  // Allocate memory for Rom header and PCIR\r
  //\r
  RomHeader = AllocatePool (sizeof (PCI_EXPANSION_ROM_HEADER));\r
  if (RomHeader == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  RomPcir = AllocatePool (sizeof (PCI_DATA_STRUCTURE));\r
  if (RomPcir == NULL) {\r
    FreePool (RomHeader);\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  RomBar = (UINT32) RomBase;\r
\r
  //\r
  // Enable RomBar\r
  //\r
  RomDecode (PciDevice, RomBarIndex, RomBar, TRUE);\r
\r
  RomBarOffset  = RomBar;\r
  RetStatus     = EFI_NOT_FOUND;\r
  FirstCheck    = TRUE;\r
  LegacyImageLength = 0;\r
\r
  do {\r
    PciDevice->PciRootBridgeIo->Mem.Read (\r
                                      PciDevice->PciRootBridgeIo,\r
                                      EfiPciWidthUint8,\r
                                      RomBarOffset,\r
                                      sizeof (PCI_EXPANSION_ROM_HEADER),\r
                                      (UINT8 *) RomHeader\r
                                      );\r
\r
    if (RomHeader->Signature != PCI_EXPANSION_ROM_HEADER_SIGNATURE) {\r
      RomBarOffset = RomBarOffset + 512;\r
      if (FirstCheck) {\r
        break;\r
      } else {\r
        RomImageSize = RomImageSize + 512;\r
        continue;\r
      }\r
    }\r
\r
    FirstCheck  = FALSE;\r
    OffsetPcir  = RomHeader->PcirOffset;\r
    //\r
    // If the pointer to the PCI Data Structure is invalid, no further images can be located.\r
    // The PCI Data Structure must be DWORD aligned.\r
    //\r
    if (OffsetPcir == 0 ||\r
        (OffsetPcir & 3) != 0 ||\r
        RomImageSize + OffsetPcir + sizeof (PCI_DATA_STRUCTURE) > RomSize) {\r
      break;\r
    }\r
    PciDevice->PciRootBridgeIo->Mem.Read (\r
                                      PciDevice->PciRootBridgeIo,\r
                                      EfiPciWidthUint8,\r
                                      RomBarOffset + OffsetPcir,\r
                                      sizeof (PCI_DATA_STRUCTURE),\r
                                      (UINT8 *) RomPcir\r
                                      );\r
    //\r
    // If a valid signature is not present in the PCI Data Structure, no further images can be located.\r
    //\r
    if (RomPcir->Signature != PCI_DATA_STRUCTURE_SIGNATURE) {\r
      break;\r
    }\r
    if (RomImageSize + RomPcir->ImageLength * 512 > RomSize) {\r
      break;\r
    }\r
    if (RomPcir->CodeType == PCI_CODE_TYPE_PCAT_IMAGE) {\r
      CodeType = PCI_CODE_TYPE_PCAT_IMAGE;\r
      LegacyImageLength = ((UINT32)((EFI_LEGACY_EXPANSION_ROM_HEADER *)RomHeader)->Size512) * 512;\r
    }\r
    Indicator     = RomPcir->Indicator;\r
    RomImageSize  = RomImageSize + RomPcir->ImageLength * 512;\r
    RomBarOffset  = RomBarOffset + RomPcir->ImageLength * 512;\r
  } while (((Indicator & 0x80) == 0x00) && ((RomBarOffset - RomBar) < RomSize));\r
\r
  //\r
  // Some Legacy Cards do not report the correct ImageLength so used the maximum\r
  // of the legacy length and the PCIR Image Length\r
  //\r
  if (CodeType == PCI_CODE_TYPE_PCAT_IMAGE) {\r
    RomImageSize = MAX (RomImageSize, LegacyImageLength);\r
  }\r
\r
  if (RomImageSize > 0) {\r
    RetStatus = EFI_SUCCESS;\r
    Image     = AllocatePool ((UINT32) RomImageSize);\r
    if (Image == NULL) {\r
      RomDecode (PciDevice, RomBarIndex, RomBar, FALSE);\r
      FreePool (RomHeader);\r
      FreePool (RomPcir);\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
\r
    //\r
    // Copy Rom image into memory\r
    //\r
    PciDevice->PciRootBridgeIo->Mem.Read (\r
                                      PciDevice->PciRootBridgeIo,\r
                                      EfiPciWidthUint8,\r
                                      RomBar,\r
                                      (UINT32) RomImageSize,\r
                                      Image\r
                                      );\r
    RomInMemory = Image;\r
  }\r
\r
  RomDecode (PciDevice, RomBarIndex, RomBar, FALSE);\r
\r
  PciDevice->EmbeddedRom    = TRUE;\r
  PciDevice->PciIo.RomSize  = RomImageSize;\r
  PciDevice->PciIo.RomImage = RomInMemory;\r
\r
  //\r
  // For OpROM read from PCI device:\r
  //   Add the Rom Image to internal database for later PCI light enumeration\r
  //\r
  PciRomAddImageMapping (\r
    NULL,\r
    PciDevice->PciRootBridgeIo->SegmentNumber,\r
    PciDevice->BusNumber,\r
    PciDevice->DeviceNumber,\r
    PciDevice->FunctionNumber,\r
    PciDevice->PciIo.RomImage,\r
    PciDevice->PciIo.RomSize\r
    );\r
\r
  //\r
  // Free allocated memory\r
  //\r
  FreePool (RomHeader);\r
  FreePool (RomPcir);\r
\r
  return RetStatus;\r
}\r
\r
/**\r
  Enable/Disable Option Rom decode.\r
\r
  @param PciDevice    Pci device instance.\r
  @param RomBarIndex  The BAR index of the standard PCI Configuration header to use as the\r
                      base address for resource range. The legal range for this field is 0..5.\r
  @param RomBar       Base address of Option Rom.\r
  @param Enable       Flag for enable/disable decode.\r
\r
**/\r
VOID\r
RomDecode (\r
  IN PCI_IO_DEVICE   *PciDevice,\r
  IN UINT8           RomBarIndex,\r
  IN UINT32          RomBar,\r
  IN BOOLEAN         Enable\r
  )\r
{\r
  UINT32              Value32;\r
  EFI_PCI_IO_PROTOCOL *PciIo;\r
\r
  PciIo = &PciDevice->PciIo;\r
  if (Enable) {\r
\r
    //\r
    // set the Rom base address: now is hardcode\r
    // enable its decoder\r
    //\r
    Value32 = RomBar | 0x1;\r
    PciIo->Pci.Write (\r
                 PciIo,\r
                 (EFI_PCI_IO_PROTOCOL_WIDTH) EfiPciWidthUint32,\r
                 RomBarIndex,\r
                 1,\r
                 &Value32\r
                 );\r
\r
    //\r
    // Programe all upstream bridge\r
    //\r
    ProgramUpstreamBridgeForRom (PciDevice, RomBar, TRUE);\r
\r
    //\r
    // Setting the memory space bit in the function's command register\r
    //\r
    PCI_ENABLE_COMMAND_REGISTER(PciDevice, EFI_PCI_COMMAND_MEMORY_SPACE);\r
\r
  } else {\r
\r
    //\r
    // disable command register decode to memory\r
    //\r
    PCI_DISABLE_COMMAND_REGISTER(PciDevice, EFI_PCI_COMMAND_MEMORY_SPACE);\r
\r
    //\r
    // Destroy the programmed bar in all the upstream bridge.\r
    //\r
    ProgramUpstreamBridgeForRom (PciDevice, RomBar, FALSE);\r
\r
    //\r
    // disable rom decode\r
    //\r
    Value32 = 0xFFFFFFFE;\r
    PciIo->Pci.Write (\r
                 PciIo,\r
                 (EFI_PCI_IO_PROTOCOL_WIDTH) EfiPciWidthUint32,\r
                 RomBarIndex,\r
                 1,\r
                 &Value32\r
                 );\r
\r
  }\r
}\r
\r
/**\r
  Load and start the Option Rom image.\r
\r
  @param PciDevice       Pci device instance.\r
\r
  @retval EFI_SUCCESS    Successfully loaded and started PCI Option Rom image.\r
  @retval EFI_NOT_FOUND  Failed to process PCI Option Rom image.\r
\r
**/\r
EFI_STATUS\r
ProcessOpRomImage (\r
  IN  PCI_IO_DEVICE   *PciDevice\r
  )\r
{\r
  UINT8                                    Indicator;\r
  UINT32                                   ImageSize;\r
  VOID                                     *RomBar;\r
  UINT8                                    *RomBarOffset;\r
  EFI_HANDLE                               ImageHandle;\r
  EFI_STATUS                               Status;\r
  EFI_STATUS                               RetStatus;\r
  EFI_PCI_EXPANSION_ROM_HEADER             *EfiRomHeader;\r
  PCI_DATA_STRUCTURE                       *Pcir;\r
  EFI_DEVICE_PATH_PROTOCOL                 *PciOptionRomImageDevicePath;\r
  MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH  EfiOpRomImageNode;\r
  VOID                                     *Buffer;\r
  UINTN                                    BufferSize;\r
\r
  Indicator = 0;\r
\r
  //\r
  // Get the Address of the Option Rom image\r
  //\r
  RomBar        = PciDevice->PciIo.RomImage;\r
  RomBarOffset  = (UINT8 *) RomBar;\r
  RetStatus     = EFI_NOT_FOUND;\r
\r
  if (RomBar == NULL) {\r
    return RetStatus;\r
  }\r
  ASSERT (((EFI_PCI_EXPANSION_ROM_HEADER *) RomBarOffset)->Signature == PCI_EXPANSION_ROM_HEADER_SIGNATURE);\r
\r
  do {\r
    EfiRomHeader = (EFI_PCI_EXPANSION_ROM_HEADER *) RomBarOffset;\r
    if (EfiRomHeader->Signature != PCI_EXPANSION_ROM_HEADER_SIGNATURE) {\r
      RomBarOffset += 512;\r
      continue;\r
    }\r
\r
    Pcir        = (PCI_DATA_STRUCTURE *) (RomBarOffset + EfiRomHeader->PcirOffset);\r
    ASSERT (Pcir->Signature == PCI_DATA_STRUCTURE_SIGNATURE);\r
    ImageSize   = (UINT32) (Pcir->ImageLength * 512);\r
    Indicator   = Pcir->Indicator;\r
\r
    //\r
    // Skip the image if it is not an EFI PCI Option ROM image\r
    //\r
    if (Pcir->CodeType != PCI_CODE_TYPE_EFI_IMAGE) {\r
      goto NextImage;\r
    }\r
\r
    //\r
    // Skip the EFI PCI Option ROM image if its machine type is not supported\r
    //\r
    if (!EFI_IMAGE_MACHINE_TYPE_SUPPORTED (EfiRomHeader->EfiMachineType)) {\r
      goto NextImage;\r
    }\r
\r
    //\r
    // Ignore the EFI PCI Option ROM image if it is an EFI application\r
    //\r
    if (EfiRomHeader->EfiSubsystem == EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) {\r
      goto NextImage;\r
    }\r
\r
    //\r
    // Create Pci Option Rom Image device path header\r
    //\r
    EfiOpRomImageNode.Header.Type     = MEDIA_DEVICE_PATH;\r
    EfiOpRomImageNode.Header.SubType  = MEDIA_RELATIVE_OFFSET_RANGE_DP;\r
    SetDevicePathNodeLength (&EfiOpRomImageNode.Header, sizeof (EfiOpRomImageNode));\r
    EfiOpRomImageNode.StartingOffset  = (UINTN) RomBarOffset - (UINTN) RomBar;\r
    EfiOpRomImageNode.EndingOffset    = (UINTN) RomBarOffset + ImageSize - 1 - (UINTN) RomBar;\r
\r
    PciOptionRomImageDevicePath = AppendDevicePathNode (PciDevice->DevicePath, &EfiOpRomImageNode.Header);\r
    ASSERT (PciOptionRomImageDevicePath != NULL);\r
\r
    //\r
    // load image and start image\r
    //\r
    BufferSize  = 0;\r
    Buffer      = NULL;\r
    ImageHandle = NULL;\r
\r
    Status = gBS->LoadImage (\r
                    FALSE,\r
                    gPciBusDriverBinding.DriverBindingHandle,\r
                    PciOptionRomImageDevicePath,\r
                    Buffer,\r
                    BufferSize,\r
                    &ImageHandle\r
                    );\r
    if (EFI_ERROR (Status)) {\r
      //\r
      // Record the Option ROM Image device path when LoadImage fails.\r
      // PciOverride.GetDriver() will try to look for the Image Handle using the device path later.\r
      //\r
      AddDriver (PciDevice, NULL, PciOptionRomImageDevicePath);\r
    } else {\r
      Status = gBS->StartImage (ImageHandle, NULL, NULL);\r
      if (!EFI_ERROR (Status)) {\r
        //\r
        // Record the Option ROM Image Handle\r
        //\r
        AddDriver (PciDevice, ImageHandle, NULL);\r
        PciRomAddImageMapping (\r
          ImageHandle,\r
          PciDevice->PciRootBridgeIo->SegmentNumber,\r
          PciDevice->BusNumber,\r
          PciDevice->DeviceNumber,\r
          PciDevice->FunctionNumber,\r
          PciDevice->PciIo.RomImage,\r
          PciDevice->PciIo.RomSize\r
          );\r
        RetStatus = EFI_SUCCESS;\r
      }\r
    }\r
    FreePool (PciOptionRomImageDevicePath);\r
\r
NextImage:\r
    RomBarOffset += ImageSize;\r
\r
  } while (((Indicator & 0x80) == 0x00) && (((UINTN) RomBarOffset - (UINTN) RomBar) < PciDevice->RomSize));\r
\r
  return RetStatus;\r
}\r
\r