path: root/uefi.sh

#!/bin/bash
# Script used by CI to build UEFI for various boards
# Requirements: uuid-dev package

set -e

if [ -z "${WORKSPACE}" ]; then
  # Local build
  export WORKSPACE=`pwd`
  export BUILD_NUMBER=0
  export JOB_NAME=${JOB_NAME:-linaro-edk2}
fi

atf_version=53d069c28c2738c3a4f59211fbc61323ec28208c

repo=linaro-edk2
pkg_repository=git://git.linaro.org/uefi/${repo}.git

case "${JOB_NAME}" in
  linaro-edk2)
    branch=release
    RELEASE_SUFFIX=
    ;;
  linaro-edk2-prep)
    branch=release-prep
    RELEASE_SUFFIX=-prep
    ;;
esac

pkg_source=edk2-${JOB_NAME}

if [ "${BUILD_NUMBER}" -eq 0 ]; then
	rm -rf ${repo}
fi

#
# Check out linaro-edk2 sources
#
if [ ! -d ${repo} ]; then
	echo "Cloning ${repo}-${branch}"
	git clone --depth 1 ${pkg_repository} -b ${branch}
else
	echo "${repo} already exists; cleaning..."
	pushd ${repo}
	git clean -dfx
	git fetch origin
	git branch -D ${branch} || true
	git checkout --track origin/${branch}
	popd
fi

if [ -f ${repo}/.gitmodules ]; then
	pushd ${repo}
	if [ ! -d .git/modules ]; then
		git submodule init
	fi
	git submodule update
	popd
fi

#
# Check out arm-trusted-firmware - at a locked-down known-good version
#
atf_dir=arm-trusted-firmware
atf_repo=https://github.com/ARM-software/arm-trusted-firmware.git
if [ ! -d ${atf_dir} ]; then
	echo "Cloning ${atf_dir}"
	git clone ${atf_repo}
	pushd ${atf_dir}
	git checkout -b ${atf_version} ${atf_version}
	popd
else
	echo "${atf_dir} already exists; cleaning..."
	pushd ${atf_dir}
	git clean -dfx
	git fetch origin
	git reset --hard HEAD
	git checkout master
	git branch -D ${atf_version} || true
	git checkout -b ${atf_version} ${atf_version}
	popd
fi

scm_commit=`cd ${repo} && git log -n1 --pretty=format:%h`
if [ -z "${scm_commit}" ]; then
	echo "Invalid git revision: ${scm_commit}" >&2
	exit 1
fi

base_version=0.1
pkg_version=${base_version}+git${BUILD_NUMBER}+`date +%Y%m%d`+${scm_commit}
pkg_dir=${pkg_source}-${pkg_version}

unset ARCH
export builddir=${WORKSPACE}/${JOB_NAME}-build
export EDK2_DIR=${WORKSPACE}/${repo}

rm -rf ${builddir} && mkdir -p ${builddir}

# Create source tarball
cd ${EDK2_DIR}
git checkout ${branch}
tar cjf ${pkg_source}_${pkg_version}.orig.tar.bz2 --transform "s,^,${pkg_dir}/," --exclude .git * .??*
mv ${pkg_source}_${pkg_version}.orig.tar.bz2 ${builddir}
cd ${WORKSPACE}

# Get the UEFI tools
UEFI_TOOLS_DIR=${WORKSPACE}/uefi-tools
if [ ! -d ${UEFI_TOOLS_DIR} ]; then
	git clone git://git.linaro.org/uefi/uefi-tools.git
else
	git --git-dir=${UEFI_TOOLS_DIR}/.git pull
fi

if [ "$AARCH32_TOOLCHAIN" == "" ]; then
	gcc_version=$(${CROSS_COMPILE}gcc -dumpversion)
	case $gcc_version in
	4.6|4.7|4.8)
		AARCH32_TOOLCHAIN=GCC$(echo ${gcc_version} | sed s-\\.--g)
		echo "Set AARCH32_TOOLCHAIN to ${AARCH32_TOOLCHAIN}"
		;;
	*)
		echo "Unknown toolchain version '$gcc_version'" >&2
		echo "Attempting to build using GCC48 profile." >&2
		AARCH32_TOOLCHAIN=GCC48
		;;
	esac
fi
if [ "$AARCH64_TOOLCHAIN" == "" ]; then
	gcc_version=$(aarch64-linux-gnu-gcc -dumpversion)
	case $gcc_version in
	4.6|4.7|4.8)
		AARCH64_TOOLCHAIN=GCC$(echo ${gcc_version} | sed s-\\.--g)
		echo "Set AARCH64_TOOLCHAIN to ${AARCH64_TOOLCHAIN}"
		;;
	*)
		echo "Unknown AArch64 toolchain version '$gcc_version'" >&2
		echo "Attempting to build using GCC48 profile." >&2
		AARCH64_TOOLCHAIN=GCC48
		;;
	esac
fi

# disable exit on error
set +e

#
# Fix WORKSPACE environment variable conflict with Jenkins
# (Store Jenkins value before first edk2/SCT build step.)
#
JENKINS_WORKSPACE=${WORKSPACE}
unset WORKSPACE

cd ${EDK2_DIR}
# Extract release version
RELEASE_STRING=linaro-edk2-`git rev-parse --symbolic --tags="tianocore-edk2-*" | sort | cut -d- -f3 | tail -1`${RELEASE_SUFFIX}

# Extract platforms to build, and build EDK2
platforms="`${UEFI_TOOLS_DIR}/parse-platforms.py -c LinaroPkg/platforms.config list`"
${UEFI_TOOLS_DIR}/uefi-build.sh -c LinaroPkg/platforms.config -b RELEASE -b DEBUG -a ../$atf_dir -D FIRMWARE_VER=${RELEASE_STRING} $platforms

for platform in $platforms; do
	BUILD_ATF="`${UEFI_TOOLS_DIR}/parse-platforms.py -c LinaroPkg/platforms.config -p $platform -o BUILD_ATF get`"
	IMAGES="`${UEFI_TOOLS_DIR}/parse-platforms.py -c LinaroPkg/platforms.config -p $platform images`"
	IMAGE_DIR="`${UEFI_TOOLS_DIR}/parse-platforms.py -c LinaroPkg/platforms.config -p $platform -o UEFI_IMAGE_DIR get`"
	DEBUG_DIR="${builddir}/debug/${platform}/"
	RELEASE_DIR="${builddir}/release/${platform}/"
	mkdir -p "$DEBUG_DIR" "$RELEASE_DIR"
	echo "Copying images for platform '$platform':"
	for image in $IMAGES; do
		cp "$EDK2_DIR"/Build/"$IMAGE_DIR"/RELEASE_*/FV/"$image" "$RELEASE_DIR"
		cp "$EDK2_DIR"/Build/"$IMAGE_DIR"/DEBUG_*/FV/"$image" "$DEBUG_DIR"
		echo -e "\t`basename $image`"
	done
done

SCT=${SCT:-0}
if [ "${SCT}" -ne 0 ]; then
  git clone --branch linaro-internal-topic-sct --depth 1 ssh://linaro-private.git.linaro.org/srv/linaro-private.git.linaro.org/uefi/sct.git ${EDK2_DIR}/SctPkg

  sed -i 's/-Werror//g' ${basetools}/Conf/tools_def.template
  sed -i 's/-Werror//g' ${EDK2_DIR}/Conf/tools_def.txt
  mkdir -p ${basetools}/Bin/Linux-x86_64
#  rm -f \
#    ${EDK2_DIR}/Conf/BuildEnv.sh \
#    ${EDK2_DIR}/Conf/build_rule.txt \
#    ${EDK2_DIR}/Conf/target.txt \
#    ${EDK2_DIR}/Conf/tools_def.txt
  cd ${EDK2_DIR}
  ./SctPkg/BuildSct.sh ARM ${AARCH32_TOOLCHAIN}
  cp -a ${EDK2_DIR}/Build/UefiSct/DEBUG_${AARCH32_TOOLCHAIN}/SctPackageARM ${builddir}/
fi

#
# Fix WORKSPACE environment variable conflict with Jenkins
# (Restore Jenkins value after last edk2/SCT build step.)
#
unset WORKSPACE
export WORKSPACE=${JENKINS_WORKSPACE}

# We want to return 0 if something built so that the files get copied to snapshots.linaro.org
exit 0