coja/lbmk
1
0
Fork 0
mirror of https://codeberg.org/libreboot/lbmk.git synced 2026-07-11 14:02:52 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
92c6da7b210d760693d2f36c457ea96eeaf8d7a2
lbmk/script/build/boot/roms_helper
T
Leah Rowe 92c6da7b21 build/boot/roms_helper: shorten variable names 
also: further reduce the number of arguments passed,
to certain functions as and when feasible, in cases
where those are global variables that never change.

the cbfstool argument in mkUbootRom wasn't even used.
that function was only using the global variable, which
again is only set once.

i also shortened a few messages, removed a few errant
line breaks and reduced sloccount by exactly 1 in main()
by re-arranging how the shift command is used.

it's mainly about shortening variable names, to then
reduce the number of line breaks, but it's a surgical
code size reduction in build/boot/roms.

Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-10-01 04:08:30 +01:00

411 lines
14 KiB
Bash
Executable File
Raw Blame History

#!/usr/bin/env sh
# SPDX-License-Identifier: GPL-3.0-or-later
# SPDX-FileCopyrightText: 2020,2021,2023 Leah Rowe <leah@libreboot.org>
# SPDX-FileCopyrightText: 2021,2022 Ferass El Hafidi <vitali64pmemail@protonmail.com>
# SPDX-FileCopyrightText: 2022 Caleb La Grange <thonkpeasant@protonmail.com>
# SPDX-FileCopyrightText: 2022 Alper Nebi Yasak <alpernebiyasak@gmail.com>
# SPDX-FileCopyrightText: 2023 Riku Viitanen <riku.viitanen@protonmail.com>
[ "x${DEBUG+set}" = 'xset' ] && set -v
set -u -e
. "include/err.sh"
. "include/boot.sh"
read projectname < projectname
seavgabiosrom="elf/seabios/default/libgfxinit/vgabios.bin"
grub_background="background1280x800.png"
grubelf="elf/grub/grub.elf"
cfgsdir="config/coreboot"
kmapdir="config/grub/keymap"
# Disable all payloads by default.
# target.cfg files have to specifically enable [a] payload(s)
eval "$(setvars "n" payload_grub payload_grub_withseabios payload_seabios \
payload_seabios_withgrub payload_memtest payload_uboot)"
eval "$(setvars "" romdir cbdir cbfstool cbrom initmode displaymode \
cbcfg targetdir grub_timeout ubdir blobs_required)"
eval "$(setvars "undefined" grub_scan_disk tree arch uboot_config)"
# main() is in include/boot.sh
handle_targets()
{
board="${boards%% *}"
configure_target
build_dependencies
build_target
}
configure_target()
{
targetdir="${cfgsdir}/${board}"
[ -d "${targetdir}" ] || \
err "Target not defined: ${board}"
[ -f "${targetdir}/target.cfg" ] || \
err "Missing target.cfg for target: ${board}"
# Override the above defaults using target.cfg
. "${targetdir}/target.cfg"
[ "${grub_scan_disk}" = "undefined" ] && \
grub_scan_disk="both"
[ "${grub_scan_disk}" != "both" ] && \
[ "${grub_scan_disk}" != "ata" ] && \
[ "${grub_scan_disk}" != "ahci" ] && \
grub_scan_disk="both"
[ "${tree}" = "undefined" ] && \
err "Target '${board}' defines no tree. Skipping build."
[ "${arch}" = "undefined" ] && \
err "Target '${board}' defines no arch. Skipping build."
[ "${payload_memtest}" != "y" ] && \
payload_memtest="n"
[ "${payload_grub_withseabios}" = "y" ] && \
payload_grub="y"
if [ "${payload_grub_withseabios}" = "y" ]; then
payload_seabios="y"
payload_seabios_withgrub="y"
fi
[ "${payload_seabios_withgrub}" = "y" ] && \
payload_seabios="y"
# The reverse logic must not be applied. If SeaBIOS-with-GRUB works,
# that doesn't mean GRUB-withSeaBIOS will. For example, the board
# might have a graphics card whose vga rom coreboot doesn't execute
if [ "${payload_grub}" != "y" ] && \
[ "${payload_seabios}" != "y" ] && \
[ "${payload_uboot}" != "y" ]; then
for configfile in "${targetdir}/config/"*; do
[ -e "${configfile}" ] || continue
err "target '${board}' defines no payload"
done
fi
[ "${payload_uboot}" != "n" ] && [ "${payload_uboot}" != "y" ] && \
payload_uboot="n"
[ "${payload_uboot}" = "y" ] && [ "${uboot_config}" = "undefined" ] && \
uboot_config="default"
[ "${blobs_required}" != "n" ] && [ "${blobs_required}" != "y" ] && \
blobs_required="y"
# Override all payload directives with cmdline args
[ -z ${_payload} ] && return 0
printf "setting payload to: %s\n" "${_payload}"
eval "$(setvars "n" payload_grub payload_memtest payload_seabios \
payload_seabios_withgrub payload_uboot payload_grub_withseabios)"
eval "payload_${_payload}=y"
}
build_dependencies()
{
romdir="bin/${board}"
cbdir="coreboot/${board}"
[ "${board}" = "${tree}" ] || cbdir="coreboot/${tree}"
cbfstool="cbutils/${tree}/cbfstool"
cbrom="${cbdir}/build/coreboot.rom"
./build coreboot utils ${tree} || err "cannot build cbutils/${tree}"
build_dependency_seabios
memtest_bin="memtest86plus/build${arch#*_}/memtest.bin"
[ "${payload_memtest}" != "y" ] || [ -f "${memtest_bin}" ] || \
./handle make file -b ${memtest_bin%/*} || \
err "cannot build memtest86+"
rm -f "${romdir}"/* || err "cannot: rm -f \"${romdir}\"/*"
build_dependency_grub
build_dependency_uboot
}
build_dependency_seabios()
{
[ "${payload_seabios}" = "y" ] || return 0
if [ ! -f "${seavgabiosrom}" ] \
|| [ ! -f elf/seabios/default/libgfxinit/bios.bin.elf ] \
|| [ ! -f elf/seabios/default/vgarom/bios.bin.elf ] \
|| [ ! -f elf/seabios/default/normal/bios.bin.elf ]; then
./handle make config -b seabios || \
err "cannot build seabios"
fi
}
build_dependency_grub()
{
[ "${payload_grub}" != "y" ] && \
[ "${payload_seabios_withgrub}" != "y" ] && return 0
rebuild_grub="n"
[ -f "${grubelf}" ] || rebuild_grub="y"
for keymapfile in "${kmapdir}"/*.gkb; do
[ "${rebuild_grub}" = "y" ] || break
[ -f "${keymapfile}" ] || continue
keymap="${keymapfile##*/}"
keymap="${keymap%.gkb}"
[ ! -f "elf/grub/keymap_${keymap}.cfg" ] && \
rebuild_grub="y" && break
done
[ "${rebuild_grub}" = "y" ] || return 0
./build grub payload || \
err "build_dependency_grub: cannot build grub payload"
}
build_dependency_uboot()
{
[ "${payload_uboot}" = "y" ] || return 0
./handle make config -b u-boot ${board} || \
err "cannot build u-boot target: ${board}"
ubdir="elf/u-boot/${board}/${uboot_config}"
ubootelf="${ubdir}/u-boot.elf"
[ ! -f "${ubootelf}" ] && [ -f "${ubdir}/u-boot.bin" ] && \
ubootelf="${ubdir}/u-boot.bin"
[ -f "${ubootelf}" ] && return 0
err "Could not find u-boot build for board, ${board}"
}
build_target()
{
for x in "normal" "vgarom" "libgfxinit"; do
initmode="${x}"
hmode="vesafb"
[ "${initmode}" = "vgarom" ] || hmode="corebootfb"
modes="${hmode} txtmode"
[ -z ${_displaymode} ] || modes="${_displaymode}"
for y in ${modes}; do
displaymode="${y}"
[ "${initmode}" = "normal" ] && \
[ "$displaymode" != "txtmode" ] && continue
cbcfg="${targetdir}/config/${initmode}_${displaymode}"
[ "${initmode}" = "normal" ] && cbcfg="${cbcfg%_*}"
build_roms "${cbcfg}"
done
done
}
# Main ROM building function. This calls all other functions below
build_roms()
{
cbcfg="${1}"
[ ! -f "${cbcfg}" ] && \
printf "'%s' does not exist. Skipping build for %s %s %s\n" \
"${cbcfg}" "${board}" "${displaymode}" "${initmode}" \
1>&2 && return 0
./handle make config -b coreboot ${board} || \
err "build_roms: cannot build coreboot for target: ${board}"
_cbrom="elf/coreboot/${board}/${initmode}_${displaymode}"
[ "${initmode}" = "normal" ] && \
_cbrom="${_cbrom%_${displaymode}}"
_cbrom="${_cbrom}/coreboot.rom"
cbrom="$(mktemp -t coreboot_rom.XXXXXXXXXX)"
cp "${_cbrom}" "${cbrom}" || \
err "build_roms: cannot copy rom"
[ "${payload_memtest}" != "y" ] || \
"${cbfstool}" "${cbrom}" add-payload \
-f "${memtest_bin}" -n img/memtest -c lzma || \
err "build_roms: cannot add img/memtest to coreboot rom"
[ "${payload_seabios}" = "y" ] && \
build_seabios_roms
[ "${payload_grub}" != "y" ] || \
build_grub_roms "${cbrom}" "grub" || \
err "build_roms: build_grub_roms failed"
[ "${payload_uboot}" = "y" ] || return 0
build_uboot_roms
}
build_seabios_roms()
{
if [ "${payload_seabios_withgrub}" = "y" ]; then
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
cp "${cbrom}" "${tmprom}" || \
err "build_seabios_roms: cannot copy to tmprom"
build_grub_roms "${tmprom}" "seabios_withgrub" || \
err "build_roms: cannot build grub roms, seabios w/grub"
rm -f "${tmprom}" || err "build_roms: can't remove tmprom"
else
t=$(mkSeabiosRom "${cbrom}" "fallback/payload") || \
err "build_seabios_roms: cannot build tmprom"
newrom="${romdir}/seabios_${board}_${initmode}_${displaymode}"
[ "${initmode}" = "normal" ] && newrom="${romdir}/seabios" \
&& newrom="${newrom}_${board}_${initmode}"
moverom "${t}" "${newrom}.rom" || \
err "build_roms: cannot copy rom"
rm -f "${t}" || err "cannot rm ${t}"
fi
}
# Make separate ROM images with GRUB payload, for each supported keymap
build_grub_roms() {
tmprom="${1}"
payload1="${2}" # allow values: grub, seabios, seabios_withgrub
grub_cbfs="fallback/payload"
if [ "${payload_grub_withseabios}" = "y" ] && \
[ "${payload1}" = "grub" ]; then
mv "$(mkSeabiosRom "${tmprom}" "seabios.elf")" "${tmprom}" || \
err "build_grub_roms: cannot move tmp rom (seabios.elf)"
elif [ "${payload_seabios_withgrub}" = "y" ] && \
[ "${payload1}" != "grub" ]; then
mv "$(mkSeabiosRom "${tmprom}" fallback/payload)" "${tmprom}" \
|| err "build_grub_roms: cannot move SeaBIOS ROM to tmprom"
grub_cbfs="img/grub2"
fi
# we only need insert grub.elf once, for each coreboot config:
"${cbfstool}" "${tmprom}" add-payload -f "${grubelf}" -n ${grub_cbfs} \
-c lzma || err "build_grub_roms: cannot add grub payload to tmprom"
# we only need insert background.png once, for each coreboot config:
if [ "${displaymode}" = "vesafb" ] || \
[ "${displaymode}" = "corebootfb" ]; then
backgroundfile="config/grub/background/${grub_background}"
"${cbfstool}" "${tmprom}" add -f ${backgroundfile} \
-n background.png -t raw || \
err "build_grub_roms: cannot add background.png to tmprom"
fi
tmpcfg=$(mktemp -t coreboot_rom.XXXXXXXXXX) ||
err "build_grub_roms: cannot create temporary scan.cfg"
printf "set grub_scan_disk=\"%s\"\n" "${grub_scan_disk}" > \
"${tmpcfg}" || err "build_grub_roms: cannot create scan.cfg"
[ "${grub_scan_disk}" = "both" ] || \
"${cbfstool}" "${tmprom}" add -f "${tmpcfg}" -n scan.cfg -t \
raw || err "build_grub_roms: can't insert scan.cfg"
printf "set timeout=%s\n" "${grub_timeout}" > "${tmpcfg}" || \
err "build_grub_roms: can't create timeout.cfg"
[ -z "${grub_timeout}" ] || \
"${cbfstool}" "${tmprom}" add -f "${tmpcfg}" -n timeout.cfg \
-t raw || err "build_grub_roms: can't insert timeout.cfg"
rm -f "${tmpcfg}" || err "build_grub_roms: can't delete tmpcfg"
keymaps=""
for kmapfile in "${kmapdir}"/*; do
keymaps="${keymaps} ${kmapfile}"
done
[ -z ${_keyboard} ] || keymaps="${kmapdir}/${_keyboard}.gkb"
for keymapfile in ${keymaps}; do
[ -f "${keymapfile}" ] || continue
keymap="${keymapfile##*/}"
keymap="${keymap%.gkb}"
tmpgrubrom="$(mkGrubRom "${keymap}" "${tmprom}")"
newrom="${romdir}/${payload1}_${board}_${initmode}_"
newrom="${newrom}${displaymode}_${keymap}.rom"
[ "${initmode}" = "normal" ] && \
newrom="${romdir}/${payload1}_${board}_" && \
newrom="${newrom}${initmode}_${keymap}.rom"
moverom "${tmpgrubrom}" "${newrom}" || \
err "build_grub_roms, moverom"
rm -f "${tmpgrubrom}" || err "rm tmpgrubrom, build_grub_roms"
done
}
# make a rom in /tmp/ and then print the path of that ROM
mkGrubRom() {
_keymap="${1}"
_cbrom="${2}"
keymapcfg="elf/grub/keymap_${_keymap}.cfg"
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX) || \
err "mkGrubRom: cannot create tmprom"
cp "${_cbrom}" "${tmprom}" || err "mkGrubRom: cannot copy to tmprom"
"${cbfstool}" "${tmprom}" add -f "${keymapcfg}" -n keymap.cfg -t raw \
|| err "mkGrubRom: cannot add keymap.cfg to tmprom"
printf "%s\n" "${tmprom}"
}
# make a rom in /tmp/ and then print the path of that ROM
mkSeabiosRom() {
_cbrom="${1}" # rom to insert seabios in. will not be touched
# (a tmpfile will be made instead)
_seabios_cbfs_path="${2}" # e.g. fallback/payload
_seabioself="elf/seabios/default/${initmode}/bios.bin.elf"
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
cp "${_cbrom}" "${tmprom}" || \
err "mkSeabiosRom: cannot copy to tmprom"
"${cbfstool}" "${tmprom}" add-payload -f "${_seabioself}" \
-n ${_seabios_cbfs_path} -c lzma || \
err "mkSeabiosRom: can't add payload, ${_seabioself}, to rom"
"${cbfstool}" "${tmprom}" add-int -i 3000 -n etc/ps2-keyboard-spinup \
|| err "mkSeabiosRom: cbfs add-int etc/ps2-keyboard-spinup 3000"
z="2"; [ "${initmode}" = "vgarom" ] && z="0"
"${cbfstool}" "${tmprom}" add-int -i $z -n etc/pci-optionrom-exec || \
err "mkSeabiosRom: cbfs add-int etc/pci-optionrom-exec 0"
"${cbfstool}" "${tmprom}" add-int -i 0 -n etc/optionroms-checksum || \
err "mkSeabiosRom: cbfs add-int etc/optionroms-checksum 0"
[ "${initmode}" != "libgfxinit" ] || \
"${cbfstool}" "${tmprom}" add -f "${seavgabiosrom}" \
-n vgaroms/seavgabios.bin -t raw || \
err "mkSeabiosRom: cbfs add-raw vgaroms/seavgabios.bin"
printf "%s\n" "${tmprom}"
}
build_uboot_roms()
{
tmprom="$(mkUbootRom "${cbrom}" "fallback/payload")"
newrom="${romdir}/uboot_payload_${board}_${initmode}_${displaymode}.rom"
[ "${initmode}" = "normal" ] && \
newrom="${romdir}/uboot_payload_${board}_${initmode}.rom"
moverom "${tmprom}" "${newrom}" || \
err "build_roms: moverom fail (u-boot)"
rm -f "${tmprom}" || err "build_roms: cannot rm u-boot rom"
}
# make a rom in /tmp/ and then print the path of that ROM
mkUbootRom() {
_cbrom="${1}" # rom to insert u-boot in. it won't be touched
# (a tmpfile will be made instead)
_uboot_cbfs_path="${2}" # e.g. fallback/payload
_ubdir="elf/u-boot/${board}/${uboot_config}"
_ubootelf="${_ubdir}/u-boot.elf"
[ -f "${_ubootelf}" ] || _ubootelf="${_ubdir}/u-boot.bin"
[ -f "${_ubootelf}" ] || err "mkUbootRom: ${board}: cant find u-boot"
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
cp "${_cbrom}" "${tmprom}" || \
err "mkUbootRom: cannot copy to tmprom"
"${cbfstool}" "${tmprom}" add-payload -f "${_ubootelf}" \
-n ${_uboot_cbfs_path} -c lzma || \
err "mkUbootRom: cannot add u-boot to tmprom"
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}"
printf "Creating target image: %s\n" "${newrom}"
[ -d "${newrom%/*}" ] || mkdir -p "${newrom%/*}/" || \
err "moverom: cannot create rom directory: \"${newrom%/*}\""
[ "${blobs_required}" = "n" ] && newrom="${newrom%.rom}_noblobs.rom"
cp "${rompath}" "${newrom}" || err "moverom: can't copy rom"
}
main $@
Reference in New Issue View Git Blame Copy Permalink