mirror of
https://codeberg.org/libreboot/lbmk.git
synced 2026-07-11 05:52:36 +02:00
Leah Rowe
2e38ddaa9b
This reverts commit a4ea286731.
The licensing audit has been abandoned. I will not be re-licensing
in bulk to MIT.
I can still use MIT license on new works, e.g. utilities, but there's
really no pressing need to re-license lbmk. It's just shell scripts,
and most of what it interacts with (coreboot, grub, seabios) is GPL
anyway.
So who cares?
Ferass's patch was removed due to refusal to re-license, but the
decision to re-license has been canceled.
I'm now aiming for a quick stable release.
729 lines
18 KiB
Bash
Executable File
729 lines
18 KiB
Bash
Executable File
#!/usr/bin/env sh
|
|
|
|
# helper script: create ROM images for a given mainboard
|
|
#
|
|
# Copyright (C) 2020,2021,2023 Leah Rowe <info@minifree.org>
|
|
# Copyright (C) 2021,2022 Ferass El Hafidi
|
|
# <vitali64pmemail@protonmail.com>
|
|
# Copyright (C) 2022 Caleb La Grange <thonkpeasant@protonmail.com>
|
|
# Copyright (C) 2022 Alper Nebi Yasak <alpernebiyasak@gmail.com>
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
|
|
# This script assumes that the working directory is the root
|
|
# of git or release archive
|
|
|
|
|
|
[ "x${DEBUG+set}" = 'xset' ] && set -v
|
|
set -u -e
|
|
|
|
projectname="$(cat projectname)"
|
|
|
|
cbcfgdir="resources/coreboot"
|
|
boardcfgdir=""
|
|
kmapdir="resources/grub/keymap"
|
|
displaymodes=""
|
|
payloads=""
|
|
keyboard_layouts=""
|
|
board=""
|
|
|
|
grub_scan_disk="undefined"
|
|
cbtree="undefined"
|
|
romtype="normal" # optional parameter in board.cfg. "normal" is default
|
|
arch="undefined"
|
|
|
|
# Disable all payloads by default.
|
|
# board.cfg files have to specifically enable [a] payload(s)
|
|
payload_grub="n"
|
|
payload_grub_withseabios="n" # seabios chainloaded from grub
|
|
payload_seabios="n"
|
|
payload_seabios_withgrub="n" # i386-coreboot grub from SeaBIOS boot menu
|
|
payload_memtest="n"
|
|
payload_uboot="n"
|
|
uboot_config="undefined"
|
|
|
|
romdir=""
|
|
cbdir=""
|
|
cbfstool=""
|
|
corebootrom=""
|
|
seavgabiosrom=""
|
|
|
|
CROSS_COMPILE=""
|
|
|
|
main()
|
|
{
|
|
while [ $# -gt 0 ]; do
|
|
case ${1} in
|
|
-d)
|
|
displaymodes="${displaymodes}${2}"
|
|
shift ;;
|
|
-p)
|
|
payloads="${payloads}${2}"
|
|
shift ;;
|
|
-k)
|
|
keyboard_layouts="${keyboard_layouts}${2}"
|
|
shift ;;
|
|
*)
|
|
board=${1} ;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
printf "board %s , kb %s , displaymode %s , payloads %s\n" \
|
|
${board} ${keyboard_layouts} ${displaymodes} \
|
|
${payloads}
|
|
|
|
if [ "${board}" = "" ]; then
|
|
printf "build/roms: undefined board. Exiting\n"
|
|
exit 1
|
|
fi
|
|
|
|
load_config
|
|
build_dependencies
|
|
build_rom_images
|
|
}
|
|
|
|
load_config()
|
|
{
|
|
boardcfgdir="${cbcfgdir}/${board}"
|
|
|
|
if [ ! -d "${boardcfgdir}" ]; then
|
|
printf "build/roms: Target not defined: %s\n" ${board}
|
|
exit 1
|
|
fi
|
|
if [ ! -f "${boardcfgdir}/board.cfg" ]; then
|
|
printf "build/roms %s: Missing board.cfg\n" ${board}
|
|
exit 1
|
|
fi
|
|
|
|
. "${boardcfgdir}/board.cfg"
|
|
|
|
if [ "${board}" != "${cbtree}" ]; then
|
|
cbdir="coreboot/${cbtree}"
|
|
else
|
|
cbdir="coreboot/${board}"
|
|
fi
|
|
|
|
romdir="bin/${board}"
|
|
cbfstool="${cbdir}/util/cbfstool/cbfstool"
|
|
seavgabiosrom="payload/seabios/seavgabios.bin"
|
|
corebootrom="${cbdir}/build/coreboot.rom"
|
|
|
|
if [ "${grub_scan_disk}" = "undefined" ]; then
|
|
printf "build/roms '%s': grub_scan_disk is undefined. " \
|
|
${board}
|
|
printf "Defaulting to 'both'.\n"
|
|
grub_scan_disk="both"
|
|
fi
|
|
if [ "${grub_scan_disk}" != "both" ] && \
|
|
[ "${grub_scan_disk}" != "ata" ] && \
|
|
[ "${grub_scan_disk}" != "ahci" ]; then
|
|
printf "build/roms '%s': invalid grub_scan_disk config. " \
|
|
${board}
|
|
printf "Defaulting to 'both'.\n"
|
|
grub_scan_disk="both"
|
|
# erroring out would be silly. just use the default
|
|
fi
|
|
|
|
if [ "${cbtree}" = "undefined" ]; then
|
|
printf "build/roms '%s': undefined coreboot tree. " \
|
|
${board}
|
|
printf "Skipping build.\n"
|
|
exit 1
|
|
fi
|
|
if [ "${arch}" = "undefined" ]; then
|
|
printf "build/roms '%s': undefined CPU type. " \
|
|
${board}
|
|
printf "Skipping build.\n"
|
|
exit 1
|
|
fi
|
|
|
|
if [ "${payload_memtest}" != "n" ] && \
|
|
[ "${payload_memtest}" != "y" ]; then
|
|
payload_memtest="n"
|
|
fi
|
|
if [ "${payload_grub_withseabios}" = "y" ]; then
|
|
payload_grub="y"
|
|
fi
|
|
if [ "${payload_grub_withseabios}" = "y" ]; then
|
|
payload_seabios="y"
|
|
payload_seabios_withgrub="y"
|
|
fi
|
|
if [ "${payload_seabios_withgrub}" = "y" ]; then
|
|
payload_seabios="y"
|
|
fi
|
|
if [ "${payload_uboot}" != "n" ] && \
|
|
[ "${payload_uboot}" != "y" ]; then
|
|
payload_uboot="n"
|
|
fi
|
|
if [ "${payload_uboot}" = "y" ] && \
|
|
[ "${uboot_config}" = "undefined" ]; then
|
|
uboot_config="default"
|
|
fi
|
|
|
|
load_config_overrides
|
|
die_if_cbconfig_and_nopayload
|
|
}
|
|
|
|
load_config_overrides()
|
|
{
|
|
# Override all payload directives with cmdline args
|
|
if [ -z ${payloads} ]; then
|
|
return 0
|
|
fi
|
|
|
|
echo "setting payloads $payloads"
|
|
payload_grub="n"
|
|
payload_grub_withseabios="n" # seabios chainloaded from grub
|
|
payload_seabios="n"
|
|
payload_seabios_withgrub="n" # grub from SeaBIOS menu
|
|
payload_uboot="n"
|
|
payload_memtest="n"
|
|
|
|
for payload in ${payloads} ; do
|
|
eval "payload_${payload}=y"
|
|
done
|
|
}
|
|
|
|
die_if_cbconfig_and_nopayload()
|
|
{
|
|
# if a coreboot config exists, and payloads are not
|
|
# defined in the lbmk config, exit with error
|
|
# if no configs exist, this won't fail. this way, cbtrees
|
|
# like "default" can exist which just contain patches
|
|
|
|
if [ "${payload_grub}" = "y" ] || [ "${payload_seabios}" = "y" ] \
|
|
|| [ "${payload_uboot}" = "y" ]; then
|
|
return 0
|
|
fi
|
|
|
|
for configfile in "${boardcfgdir}/config/"*; do
|
|
if [ ! -e "${configfile}" ]; then
|
|
continue
|
|
fi
|
|
printf "build/roms %s: Payload undefined. Exiting.\n" \
|
|
${board}
|
|
exit 1
|
|
done
|
|
}
|
|
|
|
build_dependencies()
|
|
{
|
|
if [ ! -d "${cbdir}" ]; then
|
|
./download coreboot ${cbtree}
|
|
fi
|
|
if [ ! -f "${cbfstool}" ]; then
|
|
./build module cbutils ${cbtree} || exit 1
|
|
fi
|
|
cat version > "${cbdir}/.coreboot-version"
|
|
|
|
build_dependency_crossgcc
|
|
|
|
build_dependency_seabios
|
|
build_dependency_grub
|
|
build_dependency_uboot
|
|
}
|
|
|
|
build_dependency_crossgcc()
|
|
{
|
|
if [ "${arch}" = "x86_32" ] || [ "${arch}" = "x86_64" ]; then
|
|
if [ ! -d "${cbdir}/util/crossgcc/xgcc/i386-elf/" ]; then
|
|
# Even for 64-bit machines, coreboot builds 32-bit ROM
|
|
# images, so we only need to worry about i386-elf
|
|
make -C "${cbdir}" crossgcc-i386 CPUS=$(nproc)
|
|
fi
|
|
case "$(uname -m)" in
|
|
x86*|i*86|amd64) : ;;
|
|
*) export CROSS_COMPILE=i386-elf- ;;
|
|
esac
|
|
elif [ "${arch}" = "ARMv7" ]; then
|
|
if [ ! -d "${cbdir}/util/crossgcc/xgcc/arm-eabi/" ]; then
|
|
make -C "${cbdir}" crossgcc-arm CPUS=$(nproc)
|
|
fi
|
|
case "$(uname -m)" in
|
|
arm|arm32|armv6*|armv7*) : ;;
|
|
*) export CROSS_COMPILE=arm-eabi- ;;
|
|
esac
|
|
elif [ "${arch}" = "AArch64" ]; then
|
|
if [ ! -d "${cbdir}/util/crossgcc/xgcc/aarch64-elf/" ]; then
|
|
make -C "${cbdir}" crossgcc-aarch64 CPUS=$(nproc)
|
|
fi
|
|
# aarch64 also needs armv7 toolchain for arm-trusted-firmware
|
|
if [ ! -d "${cbdir}/util/crossgcc/xgcc/arm-eabi/" ]; then
|
|
make -C "${cbdir}" crossgcc-arm CPUS=$(nproc)
|
|
fi
|
|
case "$(uname -m)" in
|
|
arm64|aarch64) : ;;
|
|
*) export CROSS_COMPILE=aarch64-elf- ;;
|
|
esac
|
|
fi
|
|
|
|
export PATH="$(pwd)/${cbdir}/util/crossgcc/xgcc/bin:$PATH"
|
|
}
|
|
|
|
build_dependency_seabios()
|
|
{
|
|
if [ ! -f "${seavgabiosrom}" ] \
|
|
|| [ ! -f payload/seabios/seabios_libgfxinit.elf ] \
|
|
|| [ ! -f payload/seabios/seabios_vgarom.elf ] \
|
|
|| [ ! -f payload/seabios/seabios_normal.elf ]; then
|
|
if [ "${payload_seabios}" = "y" ]; then
|
|
./build payload seabios
|
|
elif [ "${payload_grub}" = "y" ] \
|
|
&& [ "${payload_grub_withseabios}" = "y" ]
|
|
then
|
|
./build payload seabios
|
|
fi
|
|
fi
|
|
if [ "${payload_memtest}" = "y" ] && [ ! -f "memtest86plus/memtest" ]
|
|
then
|
|
./build module memtest86plus
|
|
fi
|
|
}
|
|
|
|
build_dependency_grub()
|
|
{
|
|
if [ "${payload_grub}" != "y" ] \
|
|
&& [ "${payload_seabios_withgrub}" != "y" ]; then
|
|
return 0
|
|
fi
|
|
|
|
if [ -f "payload/grub/grub_usqwerty.cfg" ]; then
|
|
sha1cmd="sha1sum resources/grub/config/grub.cfg"
|
|
grubrefchecksum="$(${sha1cmd} | awk '{print $1}')"
|
|
|
|
sha1cmd="sha1sum payload/grub/grub_usqwerty.cfg"
|
|
grubsha1="$(${sha1cmd} | awk '{print $1}')"
|
|
|
|
if [ "${grubrefchecksum}" != "${grubsha1}" ]; then
|
|
rm -Rf payload/grub/
|
|
printf "GRUB change detected. Rebuilding:\n"
|
|
fi
|
|
else
|
|
printf "GRUB payloads needed. Building:\n"
|
|
rm -Rf payload/grub/ # just in case
|
|
fi
|
|
for keymapfile in ${kmapdir}/*; do
|
|
if [ ! -f "${keymapfile}" ]; then
|
|
continue
|
|
fi
|
|
|
|
keymap="${keymapfile##*/}"
|
|
keymap="${keymap%.gkb}"
|
|
|
|
grubelf="payload/grub/grub_${keymap}.elf"
|
|
grubcfg="payload/grub/grub_${keymap}.cfg"
|
|
grubtestcfg="payload/grub/grub_${keymap}_test.cfg"
|
|
|
|
if [ ! -f "${grubelf}" ] || [ ! -f "${grubcfg}" ] || \
|
|
[ ! -f "${grubtestcfg}" ]; then
|
|
./build payload grub
|
|
fi
|
|
done
|
|
}
|
|
|
|
build_dependency_uboot()
|
|
{
|
|
if [ "${payload_uboot}" != "y" ]; then
|
|
return 0
|
|
fi
|
|
|
|
ubdir=""
|
|
if [ "${uboot_config}" = "default" ]; then
|
|
ubdir="payload/u-boot/${board}"
|
|
else
|
|
ubdir="payload/u-boot/${board}/${uboot_config}"
|
|
fi
|
|
|
|
if [ -f "${ubdir}/u-boot.elf" ]; then
|
|
ubootelf="${ubdir}/u-boot.elf"
|
|
elif [ -f "${ubdir}/u-boot" ]; then
|
|
ubootelf="${ubdir}/u-boot"
|
|
else
|
|
printf "U-Boot needed. Building:\n"
|
|
rm -Rf "payload/u-boot/${board}" # just in case
|
|
./build payload u-boot "${board}"
|
|
fi
|
|
}
|
|
|
|
build_rom_images()
|
|
{
|
|
[ -d "${romdir}/" ] || mkdir -p "${romdir}/"
|
|
rm -f "${romdir}"/*
|
|
|
|
for initmode in "normal" "vgarom" "libgfxinit"; do
|
|
hmode="vesafb"
|
|
if [ "${initmode}" != "vgarom" ]; then
|
|
hmode="corebootfb"
|
|
fi
|
|
modes="${hmode} txtmode"
|
|
if [ ! -z ${displaymodes} ]; then
|
|
modes="${displaymodes}"
|
|
fi
|
|
for displaymode in ${modes}; do
|
|
if [ "${initmode}" = "normal" ] \
|
|
&& [ "$displaymode" != "txtmode" ]; then
|
|
continue
|
|
fi
|
|
cbcfg="${boardcfgdir}/config/${initmode}"
|
|
cbcfg="${cbcfg}_${displaymode}"
|
|
if [ "${initmode}" = "normal" ]; then
|
|
cbcfg="${cbcfg%_*}"
|
|
fi
|
|
mkRoms "${cbcfg}" "${displaymode}" "${initmode}"
|
|
done
|
|
done
|
|
|
|
make distclean -BC "${cbdir}"
|
|
}
|
|
|
|
# Main ROM building function. This calls all other functions
|
|
mkRoms()
|
|
{
|
|
_cbcfg="${1}"
|
|
displaymode="${2}"
|
|
initmode="${3}"
|
|
|
|
if [ ! -f "${_cbcfg}" ]; then
|
|
printf "'%s' does not exist. Skipping build for %s %s %s\n" \
|
|
${_cbcfg} ${board} \
|
|
${displaymode} ${initmode}
|
|
return 0
|
|
fi
|
|
|
|
# make coreboot ROM without a payload in it
|
|
mkCoreboot "${_cbcfg}"
|
|
|
|
# now add payloads, per user config:
|
|
|
|
if [ "${displaymode}" = "txtmode" ] \
|
|
&& [ "${payload_memtest}" = "y" ]; then
|
|
"${cbfstool}" "${corebootrom}" add-payload \
|
|
-f memtest86plus/memtest -n img/memtest \
|
|
-c lzma || exit 1
|
|
fi
|
|
|
|
if [ "${payload_seabios}" = "y" ]; then
|
|
if [ "${payload_seabios_withgrub}" = "n" ]; then
|
|
x=${corebootrom}
|
|
y=${initmode}
|
|
t=$(mkSeabiosRom "$x" "fallback/payload" "$y")
|
|
|
|
_newrom="${romdir}/seabios_${board}_${initmode}.rom"
|
|
if [ "${initmode}" != "normal" ]; then
|
|
_newrom="${_newrom%.rom}_${displaymode}.rom"
|
|
fi
|
|
|
|
# rom image ready to be flashed:
|
|
moverom "${t}" "${_newrom}" "${romtype}"
|
|
rm -f "${t}"
|
|
else
|
|
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
|
|
cp "${corebootrom}" "${tmprom}"
|
|
mkRomsWithGrub "${tmprom}" "${initmode}" \
|
|
"${displaymode}" "seabios_withgrub"
|
|
rm -f "${tmprom}"
|
|
fi
|
|
fi
|
|
|
|
if [ "${payload_grub}" = "y" ]; then
|
|
mkRomsWithGrub "${corebootrom}" "${initmode}" \
|
|
"${displaymode}" "grub"
|
|
fi
|
|
|
|
if [ "${payload_uboot}" = "y" ]; then
|
|
x=${corebootrom}
|
|
y=${uboot_config}
|
|
z=${cbfstool}
|
|
tmpubootrom="$(mkUbootRom "$x" "fallback/payload" "$y" "$z")"
|
|
if [ "${initmode}" = "normal" ]; then
|
|
_newrom="${romdir}/uboot_payload_${board}_"
|
|
_newrom="${_newrom}${initmode}.rom"
|
|
else
|
|
_newrom="${romdir}/uboot_payload_${board}_"
|
|
_newrom="${_newrom}${initmode}_${displaymode}.rom"
|
|
fi
|
|
|
|
# rom image ready to be flashed:
|
|
moverom "${tmpubootrom}" "${_newrom}" "${romtype}"
|
|
rm -f "${tmpubootrom}"
|
|
fi
|
|
}
|
|
|
|
# expected: configs must not specify a payload
|
|
mkCoreboot()
|
|
{
|
|
_cbcfg="${1}" # eg. resources/coreboot/e6400nvidia_4mb/config/normal
|
|
|
|
if [ ! -f "${_cbcfg}" ]; then
|
|
printf "\nmkCoreboot: coreboot config '%s' does not exist. " \
|
|
${_cbcfg}
|
|
printf "Skipping build.\n"
|
|
return 0
|
|
fi
|
|
|
|
printf "%s-%s\n" "$(cat projectname)" "$(cat version)" \
|
|
> "${cbdir}/.coreboot-version"
|
|
|
|
if [ -f "${cbfstool}" ]; then
|
|
mv "${cbfstool}" "${cbdir}/cbfstool"
|
|
fi
|
|
make clean -BC "${cbdir}"
|
|
|
|
if [ -f "${cbdir}/cbfstool" ]; then
|
|
mv "${cbdir}/cbfstool" "${cbfstool}"
|
|
fi
|
|
|
|
cp "${_cbcfg}" "${cbdir}"/.config
|
|
./build module cbutils ${cbdir#coreboot/} || exit 1
|
|
|
|
make -j$(nproc) -BC "${cbdir}"
|
|
}
|
|
|
|
# make a rom in /tmp/ and then print the path of that ROM
|
|
mkSeabiosRom()
|
|
{
|
|
target_cbrom="${1}" # rom to insert seabios in. will not be touched
|
|
# (a tmpfile will be made instead)
|
|
target_seabios_cbfs_path="${2}" # e.g. fallback/payload
|
|
target_initmode="${3}" # e.g. libgfxinit
|
|
|
|
target_seabioself="payload/seabios/seabios_${target_initmode}.elf"
|
|
target_seavgabios_rom="payload/seabios/seavgabios.bin"
|
|
|
|
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
|
|
|
|
cp "${target_cbrom}" "${tmprom}"
|
|
|
|
"${cbfstool}" "${tmprom}" add-payload -f "${target_seabioself}" \
|
|
-n ${target_seabios_cbfs_path} -c lzma || exit 1
|
|
"${cbfstool}" "${tmprom}" add-int -i 3000 -n etc/ps2-keyboard-spinup \
|
|
|| exit 1
|
|
|
|
if [ "${target_initmode}" = "normal" ] \
|
|
|| [ "${target_initmode}" = "libgfxinit" ]; then
|
|
"${cbfstool}" "${tmprom}" add-int -i 2 \
|
|
-n etc/pci-optionrom-exec || exit 1
|
|
elif [ "${target_initmode}" = "vgarom" ]; then # coreboot executes it
|
|
"${cbfstool}" "${tmprom}" add-int -i 0 \
|
|
-n etc/pci-optionrom-exec || exit 1
|
|
fi # for undefined modes, don't add this integer. use SeaBIOS defaults
|
|
|
|
"${cbfstool}" "${tmprom}" add-int -i 0 -n etc/optionroms-checksum \
|
|
|| exit 1
|
|
|
|
if [ "${target_initmode}" = "libgfxinit" ]; then
|
|
"${cbfstool}" "${tmprom}" add -f "${target_seavgabios_rom}" \
|
|
-n vgaroms/seavgabios.bin -t raw || exit 1
|
|
fi
|
|
|
|
printf "%s\n" "${tmprom}"
|
|
}
|
|
|
|
# Make separate ROM images with GRUB payload, for each supported keymap
|
|
mkRomsWithGrub()
|
|
{
|
|
tmprompath="${1}"
|
|
initmode="${2}"
|
|
displaymode="${3}"
|
|
firstpayloadname="${4}" # allow values: grub, seabios, seabios_withgrub
|
|
|
|
x=${tmprompath}
|
|
y=${initmode}
|
|
if [ "${payload_grub_withseabios}" = "y" ] \
|
|
&& [ "${firstpayloadname}" = "grub" ]; then
|
|
mv "$(mkSeabiosRom "${x}" "seabios.elf" "${y}")" \
|
|
"${tmprompath}"
|
|
elif [ "${payload_seabios_withgrub}" ] \
|
|
&& [ "${firstpayloadname}" != "grub" ]; then
|
|
mv "$(mkSeabiosRom "${x}" "fallback/payload" "${y}")" \
|
|
"${tmprompath}"
|
|
fi
|
|
|
|
keymaps=""
|
|
if [ -z ${keyboard_layouts} ]; then
|
|
for kmapfile in "${kmapdir}"/*; do
|
|
keymaps="${keymaps} ${kmapfile}"
|
|
done
|
|
else
|
|
for keymapname in ${keyboard_layouts}; do
|
|
keymaps="${keymaps} ${kmapdir}/${keymapname}.gkb"
|
|
done
|
|
fi
|
|
for keymapfile in ${keymaps}; do
|
|
if [ ! -f "${keymapfile}" ]; then
|
|
continue
|
|
fi
|
|
|
|
keymap="${keymapfile##*/}"
|
|
keymap="${keymap%.gkb}"
|
|
|
|
grub_path_in_cbfs="fallback/payload"
|
|
if [ "${firstpayloadname}" != "grub" ]; then
|
|
grub_path_in_cbfs="img/grub2"
|
|
fi
|
|
|
|
# evil bofh rfc 2646 compliance hack
|
|
x=${keymap}
|
|
y=${tmprompath}
|
|
z=${grub_path_in_cbfs}
|
|
tmpgrubrom="$(mkGrubRom "${x}" "${y}" "${z}")"
|
|
|
|
_newrom="${romdir}/${firstpayloadname}_${board}_${initmode}_"
|
|
if [ "${initmode}" = "normal" ]; then
|
|
_newrom="${_newrom}${keymap}.rom"
|
|
else
|
|
_newrom="${_newrom}${displaymode}_${keymap}.rom"
|
|
fi
|
|
|
|
# rom image ready to be flashed:
|
|
moverom "${tmpgrubrom}" "${_newrom}" "${romtype}"
|
|
rm -f "${tmpgrubrom}"
|
|
done
|
|
}
|
|
|
|
# make a rom in /tmp/ and then print the path of that ROM
|
|
mkGrubRom()
|
|
{
|
|
target_keymap="${1}"
|
|
target_cbrom="${2}"
|
|
target_grubelf_cbfs_path="${3}" # e.g. fallback/payload
|
|
|
|
grubelf="payload/grub/grub_${target_keymap}.elf"
|
|
grubcfg="payload/grub/grub_${target_keymap}.cfg"
|
|
grubtestcfg="payload/grub/grub_${target_keymap}_test.cfg"
|
|
|
|
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX) || exit 1
|
|
|
|
cp "${target_cbrom}" "${tmprom}" || exit 1
|
|
|
|
"${cbfstool}" "${tmprom}" add-payload -f "${grubelf}" \
|
|
-n ${target_grubelf_cbfs_path} -c lzma || exit 1
|
|
|
|
tmpgrubcfg=$(mktemp -t grub.cfg.XXXXXXXXXX)
|
|
tmpgrubtestcfg=$(mktemp -t grubtest.cfg.XXXXXXXXXX)
|
|
if [ "${grub_scan_disk}" = "ahci" ]; then
|
|
sed \
|
|
's/set\ grub_scan_disk=\"both\"/set\ grub_scan_disk=\"ahci\"/' \
|
|
"${grubcfg}" > "${tmpgrubcfg}"
|
|
sed \
|
|
's/set\ grub_scan_disk=\"both\"/set\ grub_scan_disk=\"ahci\"/' \
|
|
"${grubtestcfg}" > "${tmpgrubtestcfg}"
|
|
elif [ "${grub_scan_disk}" = "ata" ]; then
|
|
sed \
|
|
's/set\ grub_scan_disk=\"both\"/set\ grub_scan_disk=\"ata\"/' \
|
|
"${grubcfg}" > "${tmpgrubcfg}"
|
|
sed \
|
|
's/set\ grub_scan_disk=\"both\"/set\ grub_scan_disk=\"ata\"/' \
|
|
"${grubtestcfg}" > "${tmpgrubtestcfg}"
|
|
else
|
|
cp "${grubcfg}" "${tmpgrubcfg}"
|
|
cp "${grubtestcfg}" "${tmpgrubtestcfg}"
|
|
fi
|
|
|
|
"${cbfstool}" "${tmprom}" add -f "${tmpgrubcfg}" -n grub.cfg -t raw \
|
|
|| exit 1
|
|
"${cbfstool}" "${tmprom}" add -f "${tmpgrubtestcfg}" -n grubtest.cfg \
|
|
-t raw || exit 1
|
|
rm -f "${tmpgrubcfg}" "${tmpgrubtestcfg}"
|
|
|
|
backgroundfile="background1280x800.png"
|
|
if [ "${board}" = "x60" ] || [ "${board}" = "t60_intelgpu" ]; then
|
|
# TODO: don't hardcode this. do it in board.cfg per board
|
|
backgroundfile="background1024x768.png"
|
|
fi
|
|
backgroundfile="resources/grub/background/${backgroundfile}"
|
|
"${cbfstool}" "${tmprom}" add -f ${backgroundfile} -n background.png \
|
|
-t raw || exit 1
|
|
|
|
printf "%s\n" "${tmprom}"
|
|
}
|
|
|
|
# make a rom in /tmp/ and then print the path of that ROM
|
|
mkUbootRom()
|
|
{
|
|
target_cbrom="${1}" # rom to insert u-boot in. it won't be touched
|
|
# (a tmpfile will be made instead)
|
|
target_uboot_cbfs_path="${2}" # e.g. fallback/payload
|
|
target_uboot_config="${3}"
|
|
cbfstool_path="${4}"
|
|
|
|
if [ "${target_uboot_config}" = "default" ]; then
|
|
target_ubdir="payload/u-boot/${board}"
|
|
else
|
|
target_ubdir="payload/u-boot/${board}/${target_uboot_config}"
|
|
fi
|
|
|
|
if [ -f "${target_ubdir}/u-boot.elf" ]; then
|
|
target_ubootelf="${target_ubdir}/u-boot.elf"
|
|
elif [ -f "${target_ubdir}/u-boot" ]; then
|
|
target_ubootelf="${target_ubdir}/u-boot"
|
|
fi
|
|
|
|
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
|
|
|
|
cp "${target_cbrom}" "${tmprom}"
|
|
"${cbfstool}" "${tmprom}" add-payload -f "${target_ubootelf}" \
|
|
-n ${target_uboot_cbfs_path} -c lzma || exit 1
|
|
|
|
printf "%s\n" "${tmprom}"
|
|
}
|
|
|
|
# it is assumed that no other work will be done on the ROM
|
|
# after calling this function. therefore this function is "final"
|
|
moverom()
|
|
{
|
|
rompath="$1"
|
|
_newrom="$2"
|
|
cuttype="$3"
|
|
|
|
printf "\nCreating new ROM image: %s\n" "${_newrom}"
|
|
|
|
cp ${rompath} ${_newrom}
|
|
|
|
if [ "${cuttype}" = "i945 laptop" ]; then
|
|
dd if=${_newrom} of=top64k.bin bs=1 \
|
|
skip=$(($(stat -c %s ${_newrom}) - 0x10000)) \
|
|
count=64k
|
|
dd if=top64k.bin of=${_newrom} bs=1 \
|
|
seek=$(($(stat -c %s ${_newrom}) - 0x20000)) \
|
|
count=64k conv=notrunc
|
|
rm -f top64k.bin
|
|
return 0
|
|
fi
|
|
|
|
for romsize in 4 8 16; do
|
|
for x in "IFD" "IFD NOGBE"; do
|
|
if [ "${romsize}MiB ICH9 ${x} NOR flash" \
|
|
!= "${cuttype}" ]; then
|
|
continue
|
|
fi
|
|
c=4
|
|
ifdgbe="descriptors/ich9m/ich9fdnogbe_${romsize}m.bin"
|
|
if [ "${x}" = "IFD" ]; then
|
|
c=12
|
|
ifdgbe="descriptors/ich9m/ich9fdgbe_${romsize}m.bin"
|
|
fi
|
|
if [ ! -f "${ifdgbe}" ]; then
|
|
./build descriptors ich9m
|
|
fi
|
|
dd if=${ifdgbe} of=${_newrom} bs=${c}k count=1 \
|
|
conv=notrunc
|
|
done
|
|
done
|
|
}
|
|
|
|
main $@
|