32. EFI_PCI_IO_PROTOCOL을 사용해 PCI Option ROM 이미지 표시

이번 장에서는 시스템의 PCI Device에 존재하는 OptionROM을 확인한다.

그래픽 카드와 같은 일부 PCI Device는 BIOS 단계에서 작동하기 위해 추가적인 드라이버가 필요하다.

그러나 BIOS는 OS가 아니기 때문에 보드에 연결할 수 있는 모든 PCI Device의 드라이버를 모두 포함할 수는 없다. 이런 문제를 해결하기 위해 복잡한 PCI Device는 자체 펌웨어를 드라이버로 저장한다. 이게 PCI Option ROM으로 알려진 개념이다. https://en.wikipedia.org/wiki/Option_ROM

BIOS는 모든 PCI 장치의 PCI 구성 공간을 쿼리하고 Option ROM이 있는지 확인한다. BIOS가 있는 경우 BIOS 설정에 따라 옵션 ROM에서 코드를 실행할 수 있다.

PCI Option ROM은 그 자체로 여러 코드 이미지를 가질 수 있다. 일반적인 경우는 Option ROM에 두 개의 이미지가 포함되어 있다.

driver for legacy BIOS (Legacy OpROM)
driver for the UEFI BIOS (UEFI OpROM)

오래된 그래픽 카드는 Legacy BIOS용 드라이버만 포함할 수 있고, 최신/미래의 그래픽 카드는 UEFI BIOS용 드라이버만 포함할 수 있다.

현재 Legacy BIOS 인터페이스를 UEFI 전환하고 있다. UEFI 펌웨어는 Legacy OpROM과 함께 동작할 수 없다. 그러나 현재 Vendor들은 여전히 CSM 모드를 통해 Legacy 인터페이스로 작업할 수 있도록 했다.

하지만 UEFI OpROM만 로드하도록 BIOS를 설정하고 그래픽 카드에는 Legacy OpROM만 포함되어 있으면 화면 출력을 확인할 수 없다.

또한 OptionROM은 다양한 CPU 아키텍처를 위한 다양한 코드 이미지를 가지고 있으므로 PCI 디바이스는 ARM CPU와 x86 CPU 모두 동작할 수 있다.

PCI 장치에 어떤 옵션이 포함되어 있는지 확인하는 것은 흥미로울 수 있다. 그러니 이제 UEFI Shell 유틸리티를 작성한다.

EFI_PCI_IO_PROTOCOL

PCI 디바이스에 접근하려면 EFI_PCI_IO_PROTOCOL을 사용해야 한다. https://github.com/tianocore/edk2/blob/master/MdePkg/Include/Protocol/PciRootBridgeIo.h

typedef struct _EFI_PCI_IO_PROTOCOL {
EFI_PCI_IO_PROTOCOL_POLL_IO_MEM PollMem;
 EFI_PCI_IO_PROTOCOL_POLL_IO_MEM PollIo;
 EFI_PCI_IO_PROTOCOL_ACCESS Mem;
 EFI_PCI_IO_PROTOCOL_ACCESS Io;
 EFI_PCI_IO_PROTOCOL_CONFIG_ACCESS Pci;
 EFI_PCI_IO_PROTOCOL_COPY_MEM CopyMem;
 EFI_PCI_IO_PROTOCOL_MAP Map;
 EFI_PCI_IO_PROTOCOL_UNMAP Unmap;
 EFI_PCI_IO_PROTOCOL_ALLOCATE_BUFFER AllocateBuffer;
 EFI_PCI_IO_PROTOCOL_FREE_BUFFER FreeBuffer;
 EFI_PCI_IO_PROTOCOL_FLUSH Flush;
 EFI_PCI_IO_PROTOCOL_GET_LOCATION GetLocation;
 EFI_PCI_IO_PROTOCOL_ATTRIBUTES Attributes;
 EFI_PCI_IO_PROTOCOL_GET_BAR_ATTRIBUTES GetBarAttributes;
 EFI_PCI_IO_PROTOCOL_SET_BAR_ATTRIBUTES SetBarAttributes;
 UINT64 RomSize;
 VOID *RomImage;
} EFI_PCI_IO_PROTOCOL;

보면 알 수 있듯이 EFI_PCI_IO_PROTOCOL은 EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL과 유사하다. 아래는 이 둘을 비교한 것이다.

typedef struct _EFI_PCI_IO_PROTOCOL {                        typedef struct _EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL {
                                                              EFI_HANDLE ParentHandle;
 EFI_PCI_IO_PROTOCOL_POLL_IO_MEM PollMem;                     EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_POLL_IO_MEM PollMem;
 EFI_PCI_IO_PROTOCOL_POLL_IO_MEM PollIo;                      EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_POLL_IO_MEM PollIo;
 EFI_PCI_IO_PROTOCOL_ACCESS Mem;                              EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS Mem;
 EFI_PCI_IO_PROTOCOL_ACCESS Io;                               EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS Io;
 EFI_PCI_IO_PROTOCOL_CONFIG_ACCESS Pci;                       EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ACCESS Pci;
 EFI_PCI_IO_PROTOCOL_COPY_MEM CopyMem;                        EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_COPY_MEM CopyMem;
 EFI_PCI_IO_PROTOCOL_MAP Map;                                 EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_MAP Map;
 EFI_PCI_IO_PROTOCOL_UNMAP Unmap;                             EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_UNMAP Unmap;
 EFI_PCI_IO_PROTOCOL_ALLOCATE_BUFFER AllocateBuffer;          EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_ALLOCATE_BUFFER AllocateBuffer;
 EFI_PCI_IO_PROTOCOL_FREE_BUFFER FreeBuffer;                  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FREE_BUFFER FreeBuffer;
 EFI_PCI_IO_PROTOCOL_FLUSH Flush;                             EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_FLUSH Flush;
 EFI_PCI_IO_PROTOCOL_GET_LOCATION GetLocation;
 EFI_PCI_IO_PROTOCOL_ATTRIBUTES Attributes;
 EFI_PCI_IO_PROTOCOL_GET_BAR_ATTRIBUTES GetBarAttributes;     EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GET_ATTRIBUTES GetAttributes;
 EFI_PCI_IO_PROTOCOL_SET_BAR_ATTRIBUTES SetBarAttributes;     EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_SET_ATTRIBUTES SetAttributes;
 UINT64 RomSize;
 VOID *RomImage;
                                                              EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_CONFIGURATION Configuration;
                                                              UINT32 SegmentNumber;
} EFI_PCI_IO_PROTOCOL;                                       } EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL;

주요 차이점은 EFI_PCI_IO_PROTOCOL이 시스템의 모든 PCI Device에 연결되어 있으면 EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL은 PCI Root Bridges에만 연결되어 있다는 점이다.

PCI OptionROM에 접근하려면 EFI_PCI_IO_PROTOCOL에서 아래와 같은 매개변수를 사용해야 한다.

RomSize 	The size, in bytes, of the ROM image.
RomImage 	A pointer to the in memory copy of the ROM image. The PCI Bus Driver is responsible
		for allocating memory for the ROM image, and copying the contents of the ROM to memory.
		The contents of this buffer are either from the PCI option ROM that can be accessed
		through the ROM BAR of the PCI controller, or it is from a platformspecific location.
		The Attributes() function can be used to determine from which of these two sources 
		the RomImage buffer was initialized

먼저 EFI_PCI_IO_PROTOCOL을 사용해 시스템의 PCI 장치를 확인한다. 로직은 이전 장에서 사용했던 것과 비슷하다. 먼저 LocateHandleBuffer API를 통해 EFI_PCI_IO_PROTOCOL 프로토콜이 있는 모든 핸들을 찾은 다음 OpenProtocol을 호출해 각 프로토콜을 가져올 수 있다. 모든 프로토콜에서 PrintPCI를 사용한다. 이번 애플리케이션은 PCIRomInfo.efi로 생성한다.

EFI_STATUS
EFIAPI
UefiMain (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS             Status;
  UINTN                  HandleCount;
  EFI_HANDLE             *HandleBuffer;
  Status = gBS->LocateHandleBuffer(
                  ByProtocol,
                  &gEfiPciIoProtocolGuid,
                  NULL,
                  &HandleCount,
                  &HandleBuffer
                );
  if (EFI_ERROR (Status)) {
    Print(L"Can't locate EFI_PCI_IO_PROTOCOL: %r\n", Status);
    return Status;
  }

  //Print(L"Number of PCI devices in the system: %d\n", HandleCount);
  EFI_PCI_IO_PROTOCOL* PciIo;
  for (UINTN Index = 0; Index < HandleCount; Index++) {
    Status = gBS->OpenProtocol (
                    HandleBuffer[Index],
                    &gEfiPciIoProtocolGuid,
                    (VOID **)&PciIo,
                    ImageHandle,
                    NULL,
                    EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
    if (EFI_ERROR(Status)) {
      Print(L"Can't open protocol: %r\n", Status);
      return Status;
    }
    Status = PrintPCI(PciIo);
    if (EFI_ERROR(Status)) {
      Print(L"Error in PCI printing\n");
    }

  }
  FreePool(HandleBuffer);

  return EFI_SUCCESS;
}

EFI_PCI_IO_PROTOCOL이 있으면 GetLocation()을 통해 현재 PCI 컨트롤러의 주소를 확인할 수 있다.

EFI_PCI_IO_PROTOCOL.GetLocation()

Summary:
Retrieves this PCI controller’s current PCI bus number, device number, and function number.

Prototype:
typedef
EFI_STATUS
(EFIAPI *EFI_PCI_IO_PROTOCOL_GET_LOCATION) (
 IN EFI_PCI_IO_PROTOCOL *This,
 OUT UINTN *SegmentNumber,
 OUT UINTN *BusNumber,
 OUT UINTN *DeviceNumber,
 OUT UINTN *FunctionNumber
 );

Parameters:
This 		A pointer to the EFI_PCI_IO_PROTOCOL instance.
SegmentNumber 	The PCI controller’s current PCI segment number.
BusNumber 	The PCI controller’s current PCI bus number.
DeviceNumber 	The PCI controller’s current PCI device number.
FunctionNumber 	The PCI controller’s current PCI function number.

Description:
The GetLocation() function retrieves a PCI controller’s current location on a PCI Host Bridge. This is
specified by a PCI segment number, PCI bus number, PCI device number, and PCI function number. These
values can be used with the PCI Root Bridge I/O Protocol to perform PCI configuration cycles on the PCI
controller, or any of its peer PCI controller’s on the same PCI Host Bridge.

이제 PrintPCI 함수를 작성한다.

EFI_STATUS PrintPCI(EFI_PCI_IO_PROTOCOL* PciIo)
{
  UINTN SegmentNumber;
  UINTN BusNumber;
  UINTN DeviceNumber;
  UINTN FunctionNumber;
  EFI_STATUS Status = PciIo->GetLocation(PciIo,
                                         &SegmentNumber,
                                         &BusNumber,
                                         &DeviceNumber,
                                         &FunctionNumber);
  if (EFI_ERROR(Status)) {
    Print(L"Error in getting PCI location: %r\n", Status);
    return Status;
  }

  PCI_DEVICE_INDEPENDENT_REGION PCIConfHdr;
  Status = PciIo->Pci.Read(PciIo,
                           EfiPciIoWidthUint8,
                           0,
                           sizeof(PCI_DEVICE_INDEPENDENT_REGION),
                           &PCIConfHdr);

  if (EFI_ERROR(Status)) {
    Print(L"Error in reading PCI conf space: %r\n", Status);
    return Status;
  }

  Print(L"%02x:%02x.%02x - Vendor:%04x, Device:%04x\n", BusNumber,
                                                      DeviceNumber,
                                                      FunctionNumber,
                                                      PCIConfHdr.VendorId,
                                                      PCIConfHdr.DeviceId);
    
  return Status;
}

GetLocation API를 사용한 후 Pci.Read를 호출하여 이전 장과 같이 PCI 구성 공간을 읽는다.

이번 애플리케이션에 필요한 헤더 파일은 아래와 같다.

#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiLib.h>

#include <Protocol/PciIo.h>
#include <Library/MemoryAllocationLib.h>
#include <IndustryStandard/Pci.h>
#include <Library/PrintLib.h>

*.inf 파일에도 프로토콜을 추가한다.

[Protocols]
  gEfiPciIoProtocolGuid

애플리케이션을 빌드하고 실행하면 EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL로 확인한 것과 동일한 PCI Device 목록을 확인할 수 있다.

FS0:\> PCIRomInfo.efi
00:00.00 - Vendor:8086, Device:1237
00:01.00 - Vendor:8086, Device:7000
00:01.01 - Vendor:8086, Device:7010
00:01.03 - Vendor:8086, Device:7113
00:02.00 - Vendor:1234, Device:1111

PCI Option ROM이 있는 Device만 확인하기 위해 Print 부분을 아래와 같이 수정한다.

if (PciIo->RomSize) {
  Print(L"%02x:%02x.%02x - Vendor:%04x, Device:%04x", BusNumber,
                                                      DeviceNumber,
                                                      FunctionNumber,
                                                      PCIConfHdr.VendorId,
                                                      PCIConfHdr.DeviceId);

  CHAR16 VendorDesc[DESCRIPTOR_STR_MAX_SIZE];
  CHAR16 DeviceDesc[DESCRIPTOR_STR_MAX_SIZE];
  Status = FindPCIDevDescription(PCIConfHdr.VendorId,
                                 PCIConfHdr.DeviceId,
                                 VendorDesc,
                                 DeviceDesc,
                                 DESCRIPTOR_STR_MAX_SIZE);
  if (!EFI_ERROR(Status)) {
    Print(L":    %s, %s\n", VendorDesc, DeviceDesc);
  } else {
    Print(L"\n");
  }
  PrintOptionROM(PciIo->RomImage, PciIo->RomSize);
}

여기서 FindPCIDevDescription 함수를 사용했기 때문에 이전 장에서 해당 함수를 복사해야 한다. OptionRom을 출력하기 위한 함수인 PrintOptionROM은 아래에서 작성할 것이다.

코드를 작성하기 전에 먼저 알아야 할 것이 있다.

메모리의 OptionRom 이미지에는 특수 헤더가 있다. 헤더 구조에 대한 EDKII 정의는 PCI_EXPANSION_ROM_HEADER이다. 이 헤더에서는 0xAA55와 같은 Signature필드가 포함되어 있다. https://github.com/tianocore/edk2/blob/master/MdePkg/Include/IndustryStandard/Pci22.h

#define PCI_EXPANSION_ROM_HEADER_SIGNATURE              0xaa55

...

///
/// Standard PCI Expansion ROM Header
/// Section 13.4.2, Unified Extensible Firmware Interface Specification, Version 2.1
///
typedef struct {
  UINT16  Signature;    ///< 0xaa55
  UINT8   Reserved[0x16];
  UINT16  PcirOffset;
} PCI_EXPANSION_ROM_HEADER;

이 헤더에는 다른 헤더 PCI_DATA_STRUCTURE에 대한 오프셋(PcirOffset)이 있다. 이 경우 PCIR과 동일한 Signature 필드가 있다.

///
/// PCI Data Structure Format
/// Section 6.3.1.2, PCI Local Bus Specification, 2.2
///
typedef struct {
  UINT32  Signature;    ///< "PCIR"
  UINT16  VendorId;
  UINT16  DeviceId;
  UINT16  Reserved0;
  UINT16  Length;
  UINT8   Revision;
  UINT8   ClassCode[3];
  UINT16  ImageLength;
  UINT16  CodeRevision;
  UINT8   CodeType;
  UINT8   Indicator;
  UINT16  Reserved1;
} PCI_DATA_STRUCTURE;

이 두 개의 헤더는 Option ROM의 모든 코드 이미지 앞에 추가된다. Option ROM에는 여러 코드 이미지가 존재할 수 있다. 필요한 것들을 찾기 위해서는 헤더 구조를 통과해야 한다.

PCI_DATA_STRUCTURE.ImageLength - 총 코드 이미지 크기를 512 바이트 단위로 설명한다.
PCI_DATA_STRUCTURE.Indicator - 바이트의 가장 중요한 비트는 Option ROM의 마지막 코드 이미지인지 나타낸다.

Option ROM을 파싱하기 위한 함수를 작성한다.

VOID PrintOptionROM(VOID *RomImage, UINT64 RomSize)
{
  Print(L"Has OptionROM at memory %p-%p\n", RomImage, (UINT8*)RomImage + RomSize);
  PCI_EXPANSION_ROM_HEADER* RomHeader = (PCI_EXPANSION_ROM_HEADER*) RomImage;
  UINTN RomImageIndex = 1;
  while (TRUE)
  {
    if (RomHeader->Signature != PCI_EXPANSION_ROM_HEADER_SIGNATURE) {
      Print(L"Error! OptionROM has a wrong signature\n");
      return;
    }
    PCI_DATA_STRUCTURE* RomImage = (PCI_DATA_STRUCTURE*)((UINT8*)RomHeader + RomHeader->PcirOffset);
    if ((((CHAR8)((RomImage->Signature >>  0) & 0xFF)) != 'P') &&
        (((CHAR8)((RomImage->Signature >>  8) & 0xFF)) != 'C') &&
        (((CHAR8)((RomImage->Signature >> 16) & 0xFF)) != 'I') &&
        (((CHAR8)((RomImage->Signature >> 24) & 0xFF)) != 'R')) {
      Print(L"Error! OptionROM image has wrong signature\n");
      return;
    }

    <...>

    if ((RomImage->Indicator) & 0x80) {
      break;
    }
    RomHeader = (PCI_EXPANSION_ROM_HEADER*)((UINT8*) RomHeader + (RomImage->ImageLength)*512);
    RomImageIndex++;
  }
  Print(L"------------------\n");
}

<...>에는 코드 이미지의 파싱을 위한 코드를 작성한다.

UEFI 스펙은 UEFI가 시작될 때 이미 존재했던 현재 Option ROM 설계에 적용할 수 있도록 했다. 원래의 Option ROM 설계는 확장성을 생각하지 않은 것으로 보인다. 따라서 UEFI는 Option ROM을 가능한 한 확장했고, 그래서 파싱 프로세스는 약간 이상하게 보일 수 있다.

먼저 두 번째 헤더의 PCI_DATA_STRUCTURE.CodeType 필드를 살펴봐야 한다. 그리고 이 필드를 통해 첫 번째 `PCI_EXPANSION_ROM_HEADER를 살펴본다.

Pci22.h에 낮선 union이 있는 이유다. https://github.com/tianocore/edk2/blob/master/MdePkg/Include/IndustryStandard/Pci22.h

typedef union {
  UINT8                           *Raw;
  PCI_EXPANSION_ROM_HEADER        *Generic;
  EFI_PCI_EXPANSION_ROM_HEADER    *Efi;
  EFI_LEGACY_EXPANSION_ROM_HEADER *PcAt;
} EFI_PCI_ROM_HEADER;

이미지가 Legacy(PCI_DATA_STRUCTURE.CodeType = 0x00)인 경우 EFI_PCI_ROM_HEADER를 EFI_LEGACY_EXPANSION_ROM_HEADER로 처리해야 한다.
이미지가 UEFI(PCI_DATA_STRUCTURE.CodeType = 0x03)인 경우 EFI_PCI_ROM_HEADER를 EFI_PCI_EXPANSION_ROM_HEADER로 처리해야 한다.
이미지 유형을 아직 모르는 경우 EFI_PCI_ROM_HEADER만 PCI_EXPANSION_ROM_HEADER로 처리할 수 있다.

EFI_LEGACY_EXPANSION_ROM_HEADER에는 유용한 정보가 없으므로 이미지가 EFI인 경우에만 추가 정보를 출력하도록 한다.

Print(L"---Code Image %d---\n", RomImageIndex);
Print(L"Address: %p-%p\n", RomHeader, (UINT8*)RomHeader + (RomImage->ImageLength)*512);
Print(L"PCIR address: %p\n", RomImage);
Print(L"VendorId: %04x, DeviceId: %04x\n", RomImage->VendorId, RomImage->DeviceId);
Print(L"Type: ");
switch (RomImage->CodeType) {
  case 0x00:
    Print(L"IA-32, PC-AT compatible\n");
    break;
  case 0x01:
    Print(L"Open Firmware standard for PCI\n");
    break;
  case 0x02:
    Print(L"Hewlett-Packard PA RISC\n");
    break;
  case 0x03:
    Print(L"EFI Image\n");
    break;
  default:
    Print(L"Unknown\n");
    break;
}
if (RomImage->CodeType == 0x03) {
  EFI_PCI_EXPANSION_ROM_HEADER* EfiRomHeader =  (EFI_PCI_EXPANSION_ROM_HEADER*) RomHeader;
  if (EfiRomHeader->EfiSignature == EFI_PCI_EXPANSION_ROM_HEADER_EFISIGNATURE) {
    <print additional EFI image info>
  } else {
    Print(L"EFI signature is incorrect!\n");
  }
}

이미지가 EFI인 경우 타입, CPU 아키텍처, 압축에 대한 정보를 출력할 수 있다. 이 코드는 위 코드의 <print additional EFI image info> 부분에 작성한다.

Print(L"Subsystem: ");
switch (EfiRomHeader->EfiSubsystem) {
  case EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION:
    Print(L"EFI Application\n");
    break;
  case EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
    Print(L"EFI Boot Service Driver\n");
    break;
  case EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
    Print(L"EFI Runtime Driver\n");
    break;
  case EFI_IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
    Print(L"EFI SAL Runtime Driver\n");
    break;
  default:
    Print(L"Unknown\n");
    break;
}
Print(L"Machine type: ");
switch (EfiRomHeader->EfiMachineType) {
  case IMAGE_FILE_MACHINE_I386:
    Print(L"IA-32\n");
    break;
  case IMAGE_FILE_MACHINE_IA64:
    Print(L"Itanium\n");
    break;
  case IMAGE_FILE_MACHINE_EBC:
    Print(L"EFI Byte Code (EBC)\n");
    break;
  case IMAGE_FILE_MACHINE_X64:
    Print(L"X64\n");
    break;
  case IMAGE_FILE_MACHINE_ARMTHUMB_MIXED:
    Print(L"ARM\n");
    break;
  case IMAGE_FILE_MACHINE_ARM64:
    Print(L"ARM 64-bit\n");
    break;
  case IMAGE_FILE_MACHINE_RISCV32:
    Print(L"RISCV32\n");
    break;
  case IMAGE_FILE_MACHINE_RISCV64:
    Print(L"RISCV64\n");
    break;
  case IMAGE_FILE_MACHINE_RISCV128:
    Print(L"RISCV128\n");
    break;
  default:
    Print(L"Unknown\n");
    break;
}
switch (EfiRomHeader->CompressionType) {
  case EFI_PCI_EXPANSION_ROM_HEADER_COMPRESSED:
    Print(L"Compressed following the UEFI Compression Algorithm\n");
    break;
  case 0:
    Print(L"Uncompressed\n");
    break;
  default:
    Print(L"Unknown compression type\n");
    break;
}

파싱 프로세스에 대한 설명은 UEFI 스펙의 PCI Option ROM 부분을 확인하면 된다. 또한 switch문의 일부 case는 PE 사양의 상수를 사용하므로 PE 이미지 헤더를 포함해야 한다. https://github.com/tianocore/edk2/blob/master/MdePkg/Include/IndustryStandard/PeImage.h

#include <IndustryStandard/PeImage.h>

빌드 전에 이전 장에서 사용했던 FindPCIDevDescription 를 붙여넣었기 때문에 여기에 필요한 추가적인 코드들도 함께 붙여 넣어야 한다.

#include <Library/ShellLib.h>

#define DESCRIPTOR_STR_MAX_SIZE 200
#define BLOCK_READ_SIZE (1024*4)

VOID ToLowerASCII(CHAR8* Str, UINTN Size)
{
  for (UINT8 i=0; i<Size; i++) {
    if ((Str[i]>='A')&&(Str[i]<='Z')) {
      Str[i]+=32;
    }
  }
}

추가적으로 *.inf 파일에도 ShellLib에 대한 부분을 추가한다.

[Packages]
  ...
  ShellPkg/ShellPkg.dec

[LibraryClasses]
  ...
  ShellLib

빌드 후 PCIRomInfo.efi를 실행하면 아래와 같은 결과를 확인할 수 있다.

FS0:\> PCIRomInfo.efi
00:02.00 - Vendor:1234, Device:1111:    Undefined, Undefined
Has OptionROM at memory 6EA5018-6EAEA18
---Code Image 1---
Address: 6EA5018-6EAEA18
PCIR address: 6EAE854
VendorId: 1234, DeviceId: 1111
Type: IA-32, PC-AT compatible
------------------

dmem을 사용하여 Option ROM 영역을 peak로 설정할 수 있다. 6EA5018에서 AA55 시그니처가 있는 첫 번째 헤더를 확인할 수 있다.

FS0:\> dmem 6EA5018 30
Memory Address 0000000006EA5018 30 Bytes
  06EA5018: 55 AA 4D E9 AE 55 B4 00-00 00 00 00 00 00 00 00  *U.M..U..........*
  06EA5028: 00 00 00 00 00 00 00 00-3C 98 00 00 00 00 49 42  *........<.....IB*
  06EA5038: 4D 00 2E 8B 16 C6 98 85-D2 74 01 EE C2 02 00 66  *M........t.....f*

그리고 6EAE854에서 PCIR 시그니처로 두 번째 헤더를 확인할 수 있다. PCI Vendor/Device 쌍(1234:1111) 바로 뒤에 있다.

FS0:\> dmem 6EAE854 30
Memory Address 0000000006EAE854 30 Bytes
  06EAE854: 50 43 49 52 34 12 11 11-00 00 18 00 00 00 00 03  *PCIR4...........*
  06EAE864: 4D 00 01 00 00 80 00 00-66 90 66 90 66 90 66 90  *M.......f.f.f.f.*
  06EAE874: 66 90 66 90 67 63 63 3A-20 28 55 62 75 6E 74 75  *f.f.gcc: (Ubuntu*

지금까지는 QEMU를 실행할 때 -net none 옵션을 사용했다. 이 옵션을 빼고 QEMU를 실행한다.

qemu-system-x86_64 -drive if=pflash,format=raw,file=Build/OvmfX64/RELEASE_GCC5/FV/OVMF.fd \
  9     -drive format=raw,file=fat:rw:~/UEFI_disk

그러면 네트워크를 사용하기 위한 Device가 연결된 것을 확인할 수 있다.

FS0:\> PCIRomInfo.efi
00:02.00 - Vendor:1234, Device:1111:    Undefined, Undefined
Has OptionROM at memory 6EA5018-6EAEA18
---Code Image 1---
Address: 6EA5018-6EAEA18
PCIR address: 6EAE854
VendorId: 1234, DeviceId: 1111
Type: IA-32, PC-AT compatible
------------------
00:03.00 - Vendor:8086, Device:100E:    Intel Corporation, 82540EM Gigabit Ethernet Controller
Has OptionROM at memory 6E59018-6EA4218
---Code Image 1---
Address: 6E59018-6E6F418
PCIR address: 6E59034
VendorId: 8086, DeviceId: 100E
Type: IA-32, PC-AT compatible
---Code Image 2---
Address: 6E6F418-6EA4218
PCIR address: 6E6F434
VendorId: 8086, DeviceId: 100E
Type: EFI Image
Subsystem: EFI Boot Service Driver
Machine type: X64
Uncompressed
------------------

이제 1234:1111 VGA QEMU device용이 Legacy Option ROM 외에 또 다른 Option ROM이 있다.

두 번째 Option ROM은 PCI 네트워크 카드용이며 Legacy BIOS용과 UEFI용의 두 가지 코드 이미지가 있다.

두 번째 이미지의 peak에는 iPXE(https://ipxe.org/start) 이미지라는 것을 알 수 있는 문자열을 확인할 수 있다.

FS0:\> dmem 6E59018 c0
Memory Address 0000000006E59018 C0 Bytes
  06E59018: 55 AA B2 E9 A2 00 22 00-00 00 00 00 00 00 00 00  *U.....".........*
  06E59028: 9C 00 00 00 00 00 84 00-1C 00 40 00 50 43 49 52  *..........@.PCIR*
  06E59038: 86 80 0E 10 BF 04 1C 00-03 02 00 00 B2 00 01 00  *................*
  06E59048: 00 00 07 00 00 00 00 00-8D B4 00 00 8D B4 00 00  *................*
  06E59058: 24 50 6E 50 01 02 00 00-00 7D 00 00 00 00 60 00  *$PnP.....}....`.*
  06E59068: 70 00 02 00 00 F4 00 00-00 00 85 03 00 00 00 00  *p...............*
  06E59078: 68 74 74 70 3A 2F 2F 69-70 78 65 2E 6F 72 67 00  *http://ipxe.org.*
  06E59088: 69 50 58 45 00 28 50 43-49 20 78 78 3A 78 78 2E  *iPXE.(PCI xx:xx.*
  06E59098: 78 29 00 90 55 4E 44 49-16 1D 00 00 01 02 A4 04  *x)..UNDI........*
  06E590A8: 10 2D 10 2D 42 08 50 43-49 52 66 90 69 50 58 45  *.-.-B.PCIRf.iPXE*
  06E590B8: 0C 4E 07 00 FE DB B2 BE-60 1E 06 0F A0 0F A8 FC  *.N......`.......*
  06E590C8: 0E 1F BE 27 03 31 FF E8-4C 04 8E EB 31 FF E8 3D  *...'.1..L...1..=*

Previous31. ShellLib/PrintLib 함수를 사용해 PCI Vendor/Device 정보 가져오기 Next33. EfiRom 유틸리티를 사용한 PCI Option ROM 이미지 파싱 및 생성

Last updated 1 year ago