Introduction

EDK2 is "UEFI Firmware Development Kit" that supports building on many different platforms. You can simply think that it's an open source development toolkit of firmware implemented according to UEFI and PI specification. It is a project hosted on sourceforge and Intel is the major contributor to it. Of course you could visit it's sourceforge project for more detail:

http://sourceforge.net/projects/edk2/

This wiki page tried to provide information on how-to build EDK2 in openSUSE. The 12.1 is used for building EDK2 and both IA32 and X64 version could be successfully built. I'd say that it works quite satisfactory to me and very useful if you're interested in learning or developing UEFI. :)

Preparation

Install required packages

> zypper in -t pattern devel_basis > zypper in subversion

Create folder that holds EDK2 building work

> mkdir ~/edk2-build > cd ~/edk2-build

Retrieve EDK2 source code via SVN

> svn co https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2

Upstream sync SVN to Git, you can also try edk2 git:

> git clone git://tianocore.git.sourceforge.net/gitroot/tianocore/edk2

Setup build environment, this can be done easily via script edksetup.sh provided by EDK2. You need to build the essential BaseTools as well.

> cd edk2 > make -C BaseTools > . edksetup.sh

Remember that you need to run this step each time you login a new shell.

To verify the environment is setup correctly, use "type" command to check whether the right build command is located. It should output something like this: (that is the edk2's own build script was used, not the system wide "build" provided by build package)

> type build build is hashed (/home/user/edk2-build/edk2/BaseTools/BinWrappers/Linux-i686/build)

Build MdeModulePkg

MdeModulePkgs contains collection of modules required for making a working UEFI firmware. These modules are needed in each stage for serving specific tasks and purpose(SEC, PEI, DXE, BDS, UEFI shell applications). In an expression of more specific, it contains platform driver that provide protocol defined by spec and could be consumed to get some specific task done. I can't tell too much here as it out of scope of this howto. Anyway think these modules as basic stuff as you'll need them in UEFI firmware. :)

First, edit Conf/target.txt. You'll visit this config file quite often as it's the outer most, global config settings relevant for building.

> vim Conf/target.txt

For building target for running on IA32 architecture, change settings to follow

ACTIVE_PLATFORM = MdeModulePkg/MdeModulePkg.dsc TARGET = RELEASE TARGET_ARCH = IA32 TOOL_CHAIN_TAG = GCC46

Or, for X64 architecture, change settings to follow

ACTIVE_PLATFORM = MdeModulePkg/MdeModulePkg.dsc TARGET = RELEASE TARGET_ARCH = X64 TOOL_CHAIN_TAG = GCC46

When done, hit "build" to start the building

> build

Alternatively, the "build" command accepts command line options that could service the same purpose of config file. But remember that not specified options inherits the config's so don't forget to check if you are not sure.

For IA32

> build -a IA32 -b RELEASE -p MdeModulePkg/MdeModulePkg.dsc -t GCC46

For X64

> build -a X64 -b RELEASE -p MdeModulePkg/MdeModulePkg.dsc -t GCC46

Build SecMain

SecMain is a UEFI shell emulator running on your host OS (don't need UEFI support). It also provides UNIX version. If you want to play with the shell a bit but don't have an available UEFI box, try this emulator. Also it is good for testing and developing some simple shell applications.

Build the base tool. Some helper utilities in it is necessary for building secmain.

> make -C BaseTools/Source/C

Build UnixPkg, as SecMain is included in it. You could achieve it through edit config's ACTIVE_PLATFORM field.

> vim Conf/target.txt

For building target for running on IA32 architecture

ACTIVE_PLATFORM = UnixPkg/UnixPkg.dsc TARGET = RELEASE TARGET_ARCH = IA32 TOOL_CHAIN_TAG = GCC46

Or, for X64 architecture,

ACTIVE_PLATFORM = UnixPkg/UnixPkgX64.dsc TARGET = RELEASE TARGET_ARCH = X64 TOOL_CHAIN_TAG = GCC46

When done, hit build to start building

> build

Alternatively, you could do one stop shopping by assigning them as build's options.

For IA32

> build -a IA32 -b RELEASE -p UnixPkg/UnixPkg.dsc -t GCC46

For X64

> build -a X64 -b RELEASE -p UnixPkg/UnixPkgX64.dsc -t GCC46

Run

To run and test the SecMain, use the steps

For IA32

> cd ./Build/Unix/RELEASE_GCC46/IA32 > ./SecMain

For X64

> cd ./Build/Unix/RELEASE_GCC46/X64 > ./SecMain

Screenshots

Build OVMF - Method 1

OVMF stands for "Open Virtual Machine Firmware". It's goal is to provide EDK2 based virtual machine firmware to virtual machines likes QEMU and KVM. If setup properly it would be a big assistance to you for developing. You are not restricted to shell and are free to do anythings like on a real host, like testing OS installation and developing your own UEFI stuff against some most recent features provided by UEFI (via boot-time or run-time service)

Edit Conf/target.txt

> vim Conf/target.txt

For IA32, set ACTIVE_PLATFORM to OvmfPkg/OvmfPkgIa32.dsc

ACTIVE_PLATFORM = OvmfPkg/OvmfPkgIa32.dsc TARGET = RELEASE TARGET_ARCH = IA32 TOOL_CHAIN_TAG = GCC46

For X64, set ACTIVE_PLATFORM to OvmfPkg/OvmfPkgX64.dsc

ACTIVE_PLATFORM = OvmfPkg/OvmfPkgX64.dsc TARGET = RELEASE TARGET_ARCH = IA32 TOOL_CHAIN_TAG = GCC46

Start building

> build

The same task could be accomplished via command line options to build

IA32

> build -a IA32 -b RELEASE -p OvmfPkg/OvmfPkgIa32.dsc -t GCC46

X64

> build -a X64 -b RELEASE -p OvmfPkg/OvmfPkgX64.dsc -t GCC46

Test OVMF with QEMU

Install QEMU

> zypper in qemu

Create directory for running QEMU and OMVF

> mkdir ~/test-ovmf

Copy OMVF firmware volume, OVMF.Fv, to working directory and rename it to bios.bin

> cp ./Build/OvmfIa32/RELEASE_GCC46/FV/OVMF.fd ~/test-ovmf/bios.bin

Next copy video bios, OvmfVideo.rom, to working directory and rename it to vgabios-cirrus.bin

> cp ./Build/OvmfIa32/RELEASE_GCC46/FV/OvmfVideo.rom ~/test-ovmf/vgabios-cirrus.bin

Create disk simulating folder for QEMU

> mkdir ~/test-ovmf/hda-contents

Now change to working directory

> cd ~/test-ovmf

Run QEMU with firmware files in the working directory

> qemu-system-i386 -L . -hda fat:hda-contents

PS. For X64, the steps is similar but remember use qemu-system-x86_64 in last step.

> qemu-system-x86_64 -L . -hda fat:hda-contents

Both IA32 and X64 are tested and working under openSUSE12.1. :)

Build OVMF - Method 2

Thanks to Jordan Justen, he points me a better approach for building and running OVMF. It's much more out-of-box and don't bother to touch the config file. :)

For building, on IA32

> OvmfPkg/build.sh -a IA32

on X86_64

> OvmfPkg/build.sh -a X64

For running, on IA32

> OvmfPkg/build.sh -a IA32 qemu

on X86_64

> OvmfPkg/build.sh -a X64 qemu

Verified on openSUSE 12.1, work as expected. :)

Screenshots

Build EmulatorPkg

EmulatorPkg also provides emulated environment on hosts (x86_64 and IA32) on which no UEFI environment is available. You can think it as a better replacement for SecMain, seems like SecMain would be superseded by it?

Anyway, building and running it are also verified well on openSUSE 12.1. However the steps are simplified (Yes, thanks to the good job made by uEFI developers :)).

To build on both IA32 and X86_64, use

> EmulatorPkg/build.sh

To run the emulator. use

> EmulatorPkg/build.sh run

Also it accepts IA32 building and running under X86_64

> EmulatorPkg/build.sh -a IA32 > EmulatorPkg/build.sh -a IA32 run