• Stars
    star
    501
  • Rank 88,002 (Top 2 %)
  • Language
    C
  • License
    Other
  • Created over 8 years ago
  • Updated 8 months ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

EDK II sample platform branches and tags

This branch holds all platforms actively maintained against the edk2 master branch.

For generic information about the edk2-platforms repository, and the process under which stable and devel branches can be added for individual platforms, please see the introduction on the about branch.

The majority of the content in the EDK II open source project uses a BSD-2-Clause Plus Patent License. Additional details on EDK II open source project code contributions can be found in the edk2 repository Readme.md. The EDK II Platforms open source project contains the following components that are covered by additional licenses:

INDEX

Overview

Platform description files can be found under Platform/{Vendor}/{Platform}.

Many platforms require additional image processing beyond the EDK2 build. Any such steps should be documented (as a Readme.md), and any necessary helper scripts be contained, under said platform directory.

Any contributions to this branch should be submitted via email to the edk2-devel mailing list with a subject prefix of [platforms]. See Laszlo's excellent guide for details on how to do this successfully.

How to build (Linux Environment)

Prerequisites

The build tools themselves depend on Python (2) and libuuid. Most Linux systems will come with a Python environment installed by default, but you usually need to install uuid-dev (or uuid-devel, depending on distribution) manually.

If cross compiling

If building EDK2 for a different archtecture than the build machine, you need to obtain an appropriate cross-compiler. X64 (x86_64) compilers also support IA32, but the reverse may not always be true.

Target architecture Cross compilation prefix
AARCH64 aarch64-linux-gnu-
ARM arm-linux-gnueabihf-
IA32 i?86-linux-gnu-* or x86_64-linux-gnu-
IPF ia64-linux-gnu
X64 x86_64-linux-gnu-
RISCV64 riscv64-unknown-elf-
LOONGARCH64 loongarch64-unknown-linux-

* i386, i486, i586 or i686

GCC

Arm provides GCC toolchains for aarch64-linux-gnu and arm-linux-gnueabihf at GNU Toolchain for the A-profile Architecture compiled to run on x86_64/i686 Linux and i686 Windows. Some Linux distributions provide their own packaged cross-toolchains.

GCC for RISC-V

RISC-V open source community provides GCC toolchains for riscv64-unknown-elf compiled to run on x86 Linux.

GCC for LoongArch

Loonson open source community provides GCC toolchains for loongarch64-unknown-elf compiled to run on x86 Linux

clang

Clang does not require separate cross compilers, but it does need a target-specific binutils. These are included with any prepackaged GCC toolchain (see above), or can be installed or built separately.

Obtaining source code

  1. Create a new folder (directory) on your local development machine for use as your workspace. This example uses /work/git/tianocore, modify as appropriate for your needs.

    $ export WORKSPACE=/work/git/tianocore
    $ mkdir -p $WORKSPACE
    $ cd $WORKSPACE
    
  2. Into that folder, clone:

    1. edk2
    2. edk2-platforms
    3. edk2-non-osi (if building platforms that need it)
    $ git clone https://github.com/tianocore/edk2.git
    $ git submodule update --init
    ...
    $ git clone https://github.com/tianocore/edk2-platforms.git
    $ git submodule update --init
    ...
    $ git clone https://github.com/tianocore/edk2-non-osi.git
    
  3. Set up a PACKAGES_PATH to point to the locations of these three repositories:

    $ export PACKAGES_PATH=$PWD/edk2:$PWD/edk2-platforms:$PWD/edk2-non-osi

Manual building

  1. Set up the build environment (this will modify your environment variables)

    $ . edk2/edksetup.sh

    (This step depends on WORKSPACE being set as per above.)

  2. Build BaseTools

    make -C edk2/BaseTools

    (BaseTools can currently not be built in parallel, so do not specify any -j option, either on the command line or in a MAKEFLAGS environment variable.)

Build options

There are a number of options that can (or must) be specified at the point of building. Their default values are set in edk2/Conf/target.txt. If we are working only on a single platform, it makes sense to just update this file.

target.txt option command line Description
ACTIVE_PLATFORM -p Description file (.dsc) of platform.
TARGET -b One of DEBUG, RELEASE or NOOPT.
TARGET_ARCH -a Architecture to build for.
TOOL_CHAIN_TAG -t Toolchain profile to use for building.

There is also MAX_CONCURRENT_THREAD_NUMBER (-n), roughly equivalent to make -j.

When specified on command line, -b can be repeated multiple times in order to build multiple targets sequentially.

After a successful build, the resulting images can be found in Build/{Platform Name}/{TARGET}_{TOOL_CHAIN_TAG}/FV.

Build a platform

The main build process can run in parallel - so figure out how many threads we have available.

$ getconf _NPROCESSORS_ONLN
8

OK, so we have 8 CPUs - let's tell the build to use a little more than that:

$ NUM_CPUS=$((`getconf _NPROCESSORS_ONLN` + 2))

For the toolchain tag, use GCC5 for gcc version 5 or later, GCC4x for earlier versions, or CLANG35/CLANG38 as appropriate when building with clang.

$ build -n $NUM_CPUS -a AARCH64 -t GCC5 -p Platform/ARM/JunoPkg/ArmJuno.dsc

(Note that the description file gets resolved by the build command through searching in all locations specified in PACKAGES_PATH.)

If cross-compiling

When cross-compiling, or building with a different version of the compiler than the default gcc or clang(/binutils), we additionally need to inform the build command which toolchain to use. We do this by setting the environment variable {TOOL_CHAIN_TAG}_{TARGET_ARCH}_PREFIX - in the case above, GCC5_AARCH64_PREFIX.

So, referring to the cross compiler toolchain table above, we should prepend the build command line with GCC5_AARCH64_PREFIX=aarch64-linux-gnu-.

Using uefi-tools helper scripts

uefi-tools is a completely unofficial set of helper-scripts developed by Linaro. They automate figuring out all of the manual options above, and store the paths to platform description files in a separate configuration file. Additionally, they simplify bulk-building large numbers of platforms.

The (best effort) intent is to keep this configuration up to date with all platforms that exist in the edk2-platforms master branch.

The equivalent of the manual example above would be

$ git clone https://git.linaro.org/uefi/uefi-tools.git
...
$ ./uefi-tools/edk2-build.sh juno
...
------------------------------------------------------------
                         aarch64 Juno (AARCH64) RELEASE pass
------------------------------------------------------------
pass   1
fail   0

The build finishes with a summary of which platforms/targets were built, which succeeded and which failed (and the total number of either).

Like the build command itself, edk2-build.sh it supports specifying multiple targets on a single command line, but it also lets you specify multiple platforms (or all for building all known platforms). So in order to build all platforms described by the configuration file, for both DEBUG and RELEASE targets:

$ ./uefi-tools/edk2-build.sh -b DEBUG -b RELEASE

How To Build (Windows Environment)

(I genuinely have no idea. Please help!)

Supported Platforms

These are the platforms currently supported by this tree - grouped by Processor/SoC vendor, rather than platform vendor.

If there are any additional build steps beyond the generic ones listed above, they will be documented with the platform.

AMD

Ampere

ARM

BeagleBoard

Hisilicon

Intel

Minimum Platforms

For more information, see the EDK II Minimum Platform Specification.

Other Platforms

Intelยฎ Quark SoC X1000 based platforms
Minnowboard Max/Turbot based on Intel Valleyview2 SoC

Loongson

Marvell

Raspberry Pi

RISC-V

SiFive

Socionext

NXP

Qemu

Maintainers

See Maintainers.txt.

Submodules

Submodule in EDK II Platforms is allowed but submodule chain should be avoided as possible as we can. Currently EDK II Platforms contains the following submodules

  • Silicon/RISC-V/ProcessorPkg/Library/RiscVOpensbiLib/opensbi

To get a full, buildable EDK II repository, use following steps of git command

  git clone https://github.com/tianocore/edk2-platforms.git
  cd edk2-platforms
  git submodule update --init
  cd ..

If there's update for submodules, use following git commands to get the latest submodules code.

  cd edk2-platforms
  git pull
  git submodule update

Note: When cloning submodule repos, '--recursive' option is not recommended. EDK II Platforms itself will not use any code/feature from submodules in above submodules. So using '--recursive' adds a dependency on being able to reach servers we do not actually want any code from, as well as needlessly downloading code we will not use.

More Repositories

1

edk2

EDK II
C
4,196
star
2

tianocore.github.io

Tianocore website
HTML
1,216
star
3

edk2-staging

EDK II new feature staging
143
star
4

edk2-libc

Port of libc to EDK II with applications that depend on libc
Python
86
star
5

edk2-test

Test infrastructure and test cases for EDK II based firmware
C
68
star
6

edk2-BaseTools-win32

git-svn mirror of https://svn.code.sf.net/p/edk2-toolbinaries/code/trunk/Win32
Batchfile
64
star
7

udk

UEFI Development Kit
C
63
star
8

edk2-non-osi

EDK II non-OSI licensed content
Assembly
57
star
9

edk2-pytool-extensions

Extensions to the edk2 build system allowing for a more robust and plugin based build system and tool execution environment
Python
55
star
10

edk2-pytool-library

Python library package that supports UEFI development
Python
54
star
11

edk2-archive

Archive of old branches for EDK II
C
32
star
12

edk

Git mirror of EDK
C
29
star
13

edk2-basetools

EDK II BaseTools Python tools as a PIP module
Python
23
star
14

buildtools-BaseTools

DEPRECATED. Use BaseTools under EDK II instead.
Python
21
star
15

containers

Repository to maintain and manage edk2 containers
Dockerfile
19
star
16

edk2-share

Python
17
star
17

edk2-edkrepo

Repository for the edkrepo utility
Python
16
star
18

edk-Shell

Older, deprecated EFI Shell
C
13
star
19

edk2-FatPkg

EDK II FatPkg
C
11
star
20

edk2-NetNt32Io

C
9
star
21

edk2-codereview

Temporary repository used to evaluate the GitHub based code review process with a GitHub webhook that generates an email archive of the code review activities.
C
7
star
22

edk2-cmocka

Mirror of https://git.cryptomilk.org/projects/cmocka.git
6
star
23

edk2-edkrepo-manifest

Platforms manifests used by the edkrepo utility
5
star
24

edk2-redfish-client

Utilizes the EFI protocols provided by EDK2 Redfish Foundation to communicate with the Redfish service for creating, consuming, and updating the Redfish properties which are managed by firmware.
C
5
star
25

projects

Empty repository to track all issues associated with TianoCore Projects
1
star