2023-06-13 11:09:01 +00:00
|
|
|
#!/usr/bin/env sh
|
2023-09-25 01:19:30 +00:00
|
|
|
# SPDX-License-Identifier: GPL-3.0-or-later
|
2024-01-01 17:57:35 +00:00
|
|
|
# SPDX-FileCopyrightText: 2014-2016,2020,2021,2023,2024 Leah Rowe <leah@libreboot.org>
|
2023-10-05 02:23:07 +00:00
|
|
|
# SPDX-FileCopyrightText: 2021,2022 Ferass El Hafidi <vitali64pmemail@protonmail.com>
|
2023-09-25 01:19:30 +00:00
|
|
|
# SPDX-FileCopyrightText: 2022 Caleb La Grange <thonkpeasant@protonmail.com>
|
2023-10-13 19:41:15 +00:00
|
|
|
# SPDX-FileCopyrightText: 2022-2023 Alper Nebi Yasak <alpernebiyasak@gmail.com>
|
2023-10-05 02:23:07 +00:00
|
|
|
# SPDX-FileCopyrightText: 2023 Riku Viitanen <riku.viitanen@protonmail.com>
|
2021-05-18 12:56:12 +00:00
|
|
|
|
|
|
|
|
set -u -e
|
|
|
|
|
|
2023-09-27 20:46:20 +00:00
|
|
|
. "include/option.sh"
|
2023-08-23 17:56:31 +00:00
|
|
|
|
2024-05-09 12:52:49 +00:00
|
|
|
serprog_usage="usage: ./build roms serprog <rp2040|stm32> [board]"
|
2023-10-05 02:23:07 +00:00
|
|
|
seavgabiosrom="elf/seabios/default/libgfxinit/vgabios.bin"
|
|
|
|
|
grub_background="background1280x800.png"
|
|
|
|
|
grubelf="elf/grub/grub.elf"
|
|
|
|
|
cfgsdir="config/coreboot"
|
2024-05-09 12:52:49 +00:00
|
|
|
pico_src_dir="src/pico-serprog"
|
|
|
|
|
pico_sdk_dir="src/pico-sdk"
|
|
|
|
|
stm32_src_dir="src/stm32-vserprog"
|
2023-09-30 12:05:57 +00:00
|
|
|
|
2023-10-05 02:23:07 +00:00
|
|
|
# Disable all payloads by default.
|
|
|
|
|
# target.cfg files have to specifically enable [a] payload(s)
|
2023-12-22 13:05:32 +00:00
|
|
|
pv="payload_grub payload_grub_withseabios payload_seabios payload_memtest t"
|
2023-11-01 09:12:56 +00:00
|
|
|
pv="${pv} payload_seabios_withgrub payload_seabios_grubonly payload_uboot memtest_bin"
|
haswell: only provide NRI-based ROMs in releases
release="n" is set in target.cfg on haswell build targets
that use mrc.bin
script/update/release exports LBMK_RELEASE="y"
script/build/roms skips building a given target if release="n"
in target.cfg *and* LBMK_RELEASE="y"
you could also do the export yourself before running ./build roms,
for example:
export LBMK_RELEASE="y"
./build roms all
This would skip these ROM images. The native haswell raminit is
now stable enough in my testing, that I wish to delete the MRC-based
targets. This is in line with Libreboot's Binary Blob Reduction Policy,
which states: if a blob can be avoided, it should be avoided.
The problem is that users often run the inject script in *lbmk* from
Git, instead of from the src release archive. I forsee some users
running this on modern lbmk with older release images. If the mrc-based
target isn't there, the user may use an NRI-based target name, and
think it works; they will insert without MRC. I foresaw this ages
ago, which is why Caleb and I ensured that the script checks hashes,
and hashes are included in releases.
Therefore: for the time being, keep the MRC-based configs in lbmk
but do not include images for them in releases. This can be done
indefinitely, but I'll probably remove those configs entirely at
some point.
On the following boards, Libreboot now will *only* provide NRI-based
ROM images for the following machines:
* Dell OptiPlex 9020 SFF
* Dell OptiPlex 9020 MT
* Lenovo ThinkPad T440p
* Lenovo ThinkPad W541/W540
I now recommend exclusive use of NRI-based images, on Haswell
hardware. It's stable enough in my testing, and now supports S3.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-04-24 04:27:27 +00:00
|
|
|
v="romdir cbrom initmode displaymode cbcfg targetdir tree keymaps release"
|
2024-05-11 17:53:12 +00:00
|
|
|
v="${v} grub_timeout ubdir board grub_scan_disk uboot_config"
|
2024-05-09 12:52:49 +00:00
|
|
|
eval "$(setvars "n" ${pv} serprog)"
|
build/roms: report status when building images
export LBMK_VERSION_TYPE=x
x can be: stable, unstable
in target.cfg files, specify:
status=x
x can be: stable, unstable, broken, untested
if unset, lbmk defaults to "unknown"
if LBMK_VERSION_TYPE is set, no confirmation is asked
if the given target matches what's set (but what's set
in that environmental variable can only be stable or
unstable)
if LBMK_RELEASE="y", no confirmation is asked, unless
the target is something other than stable/unstable
"unstable" means it works, but has a few non-breaking
bugs, e.g. broken s3 on dell e6400
whereas, if raminit regularly fails or it is so absolutely
unreliable as to be unusable, then the board should be
declared "broken"
untested means: it has not been tested
With this change, it should now be easier to track whether
a given board is tested, in preparation for releases. When
working on trees/boards, status can be set for targets.
Also: in the board directory, you can add a "warn.txt" file
which will display a message. For example, if a board has a
particular quirk to watch out for, write that there. The message
will be printed during the build process, to stdout.
If status is anything *other* than stable, or it is unstable
but LBMK_VERSION_TYPE is not set to "unstable", and not building
a release, a confirmation is passed.
If the board is not specified as stable or unstable, during
a release build, the build is skipped and the ROM is not
provided in that release; this is in *addition* to
release="n" or release="y" that can be set in target.cfg,
which will skip the release build for that target if "n"
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-04-26 18:41:00 +00:00
|
|
|
eval "$(setvars "" ${v} boards _displaymode _payload _keyboard all targets \
|
2024-05-11 17:53:12 +00:00
|
|
|
serprog_boards_dir)"
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
main()
|
2023-09-30 12:21:15 +00:00
|
|
|
{
|
2023-10-05 02:23:07 +00:00
|
|
|
while [ $# -gt 0 ]; do
|
|
|
|
|
case ${1} in
|
2023-11-08 06:31:04 +00:00
|
|
|
help)
|
|
|
|
|
usage
|
|
|
|
|
exit 0 ;;
|
|
|
|
|
list)
|
2024-05-11 17:53:12 +00:00
|
|
|
x_ items config/coreboot
|
|
|
|
|
return 0 ;;
|
2024-05-09 12:52:49 +00:00
|
|
|
serprog)
|
|
|
|
|
serprog="y"
|
|
|
|
|
shift 1; break ;;
|
2023-10-05 02:23:07 +00:00
|
|
|
-d) _displaymode="${2}" ;;
|
|
|
|
|
-p) _payload="${2}" ;;
|
|
|
|
|
-k) _keyboard="${2}" ;;
|
|
|
|
|
*)
|
2023-10-06 01:53:37 +00:00
|
|
|
[ "${1}" = "all" ] && all="y"
|
2023-10-05 02:23:07 +00:00
|
|
|
boards="${1} ${boards}"
|
|
|
|
|
shift && continue ;;
|
|
|
|
|
esac
|
|
|
|
|
shift 2
|
|
|
|
|
done
|
|
|
|
|
|
2024-05-09 12:52:49 +00:00
|
|
|
if [ "$serprog" = "y" ]; then
|
|
|
|
|
handle_serprog $@
|
|
|
|
|
return 0
|
|
|
|
|
else
|
|
|
|
|
[ "${all}" != "y" ] || boards=$(items config/coreboot) || \
|
|
|
|
|
$err "Cannot generate list of boards for building"
|
|
|
|
|
for x in ${boards}; do
|
|
|
|
|
handle_coreboot_target "$x"
|
|
|
|
|
done
|
|
|
|
|
fi
|
2023-10-06 02:03:31 +00:00
|
|
|
|
2024-05-14 22:17:22 +00:00
|
|
|
bstr="directories"
|
|
|
|
|
[ "$lbmk_release" = "y" ] && bstr="tarballs"
|
|
|
|
|
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
|
|
|
[ -z "${targets}" ] && $err "No ROM images were compiled"
|
2024-05-14 22:17:22 +00:00
|
|
|
printf "\nROM images available in these %s:\n" "$bstr"
|
2023-12-23 16:16:26 +00:00
|
|
|
eval "printf \"${targets}\""
|
2024-05-14 22:17:22 +00:00
|
|
|
printf "^^ ROM images available in these %s.\n\n" "$bstr"
|
2023-10-10 05:04:47 +00:00
|
|
|
|
2024-05-14 22:17:22 +00:00
|
|
|
[ "$lbmk_release" = "y" ] && \
|
|
|
|
|
printf "Always run the inject command on release images!\n"
|
2023-12-24 09:04:36 +00:00
|
|
|
printf "DO NOT flash images from elf/ - please use bin/ instead.\n"
|
2023-09-30 12:21:15 +00:00
|
|
|
}
|
|
|
|
|
|
2024-05-09 12:52:49 +00:00
|
|
|
handle_serprog()
|
|
|
|
|
{
|
|
|
|
|
[ -z "${1+x}" ] && $err "${serprog_usage}"
|
|
|
|
|
[ "$1" != "rp2040" ] && [ "$1" != "stm32" ] && $err "$serprog_usage"
|
|
|
|
|
if [ "${1}" = "rp2040" ]; then
|
|
|
|
|
serprog_boards_dir=${pico_sdk_dir}/src/boards/include/boards
|
|
|
|
|
[ -d "$pico_src_dir" ] || x_ ./update trees -f "pico-serprog"
|
|
|
|
|
elif [ "${1}" = "stm32" ]; then
|
|
|
|
|
serprog_boards_dir=${stm32_src_dir}/boards
|
|
|
|
|
[ -d "$stm32_src_dir" ] || x_ ./update trees -f "stm32-vserprog"
|
|
|
|
|
fi
|
|
|
|
|
x_ mkdir -p "bin/serprog_${1}"
|
|
|
|
|
|
|
|
|
|
if [ $# -gt 1 ] && [ "${2}" = "list" ]; then
|
|
|
|
|
print_serprog_boards ${serprog_boards_dir}
|
2024-05-14 22:17:22 +00:00
|
|
|
return 0
|
2024-05-09 12:52:49 +00:00
|
|
|
elif [ $# -gt 1 ]; then
|
|
|
|
|
build_${1}_rom "${2}"
|
|
|
|
|
else
|
|
|
|
|
printf "Building all serprog targets\n"
|
|
|
|
|
list_serprog_boards "${serprog_boards_dir}" | \
|
|
|
|
|
while read -r board; do
|
|
|
|
|
build_${1}_rom "${board}"
|
|
|
|
|
done
|
|
|
|
|
fi
|
2024-05-14 22:17:22 +00:00
|
|
|
|
|
|
|
|
[ "$lbmk_release" = "y" ] && mktar_release "bin/serprog_$1"; return 0
|
2024-05-09 12:52:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
build_rp2040_rom()
|
|
|
|
|
{
|
|
|
|
|
board=${1}
|
|
|
|
|
printf "Building pico-serprog for %s\n" "${board}"
|
|
|
|
|
x_ cmake -DPICO_BOARD="$board" -DPICO_SDK_PATH="$pico_sdk_dir" \
|
|
|
|
|
-B "${pico_src_dir}/build" "${pico_src_dir}"
|
|
|
|
|
x_ cmake --build "${pico_src_dir}/build"
|
|
|
|
|
x_ mv ${pico_src_dir}/build/pico_serprog.uf2 \
|
|
|
|
|
bin/serprog_rp2040/serprog_${board}.uf2
|
|
|
|
|
printf "output to bin/serprog_rp2040/serprog_%s.uf2\n" "$board"
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
build_stm32_rom()
|
|
|
|
|
{
|
|
|
|
|
board=${1}
|
|
|
|
|
printf "Building stm32-vserprog for %s\n" "${board}"
|
|
|
|
|
x_ make -C $stm32_src_dir libopencm3-just-make BOARD=$board
|
|
|
|
|
x_ make -C ${stm32_src_dir} BOARD=${board}
|
|
|
|
|
x_ mv ${stm32_src_dir}/stm32-vserprog.hex \
|
|
|
|
|
bin/serprog_stm32/serprog_${board}.hex
|
|
|
|
|
printf "output to bin/serprog_stm32/serprog_%s.hex\n" "$board"
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
print_serprog_boards()
|
|
|
|
|
{
|
|
|
|
|
printf "Available boards:\n"
|
|
|
|
|
list_serprog_boards "${1}"
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
list_serprog_boards()
|
|
|
|
|
{
|
|
|
|
|
basename -a -s .h "${1}/"*.h || $err "list_boards $1: can't list boards"
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
handle_coreboot_target()
|
2024-05-05 04:09:23 +00:00
|
|
|
{
|
|
|
|
|
eval "$(setvars "n" ${pv}) $(setvars "" ${v})"
|
|
|
|
|
grub_background="background1280x800.png"
|
2024-05-05 04:28:06 +00:00
|
|
|
board="$1"
|
2024-05-05 04:09:23 +00:00
|
|
|
|
|
|
|
|
configure_target
|
2024-05-11 17:53:12 +00:00
|
|
|
[ "$board" = "$tree" ] && return 0
|
|
|
|
|
if [ "$lbmk_release" = "y" ] && [ "$release" = "n" ]; then
|
|
|
|
|
printf "Target '%s' disabled for release.\n" "$board"
|
2024-05-05 04:18:12 +00:00
|
|
|
return 0
|
|
|
|
|
fi
|
2024-05-05 04:09:23 +00:00
|
|
|
|
|
|
|
|
build_payloads
|
|
|
|
|
build_target_mainboard
|
|
|
|
|
|
|
|
|
|
[ -d "bin/${board}" ] || return 0
|
2024-05-14 22:17:22 +00:00
|
|
|
[ "$lbmk_release" = "y" ] || targets="* bin/${board}\n${targets}"
|
2024-05-15 01:36:24 +00:00
|
|
|
[ "$lbmk_release" = "y" ] || return 0
|
|
|
|
|
|
|
|
|
|
targets="* bin/${relname}_$board.tar.xz\n$targets"
|
|
|
|
|
mktar_release "bin/$board"
|
2024-05-05 04:09:23 +00:00
|
|
|
}
|
|
|
|
|
|
2023-12-24 06:02:12 +00:00
|
|
|
configure_target()
|
2023-10-05 02:23:07 +00:00
|
|
|
{
|
|
|
|
|
targetdir="${cfgsdir}/${board}"
|
|
|
|
|
[ -f "${targetdir}/target.cfg" ] || \
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
|
|
|
$err "Missing target.cfg for target: ${board}"
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
# Override the above defaults using target.cfg
|
|
|
|
|
. "${targetdir}/target.cfg"
|
|
|
|
|
|
2023-12-22 13:05:32 +00:00
|
|
|
[ -z "${grub_scan_disk}" ] && grub_scan_disk="both"
|
2023-12-24 09:04:36 +00:00
|
|
|
[ "$grub_scan_disk" != "both" ] && [ "$grub_scan_disk" != "ata" ] \
|
2023-10-05 21:16:07 +00:00
|
|
|
&& [ "${grub_scan_disk}" != "ahci" ] && \
|
2023-10-05 02:23:07 +00:00
|
|
|
grub_scan_disk="both"
|
|
|
|
|
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
|
|
|
[ -z "$tree" ] && $err "$board: tree not defined"
|
2023-10-05 02:23:07 +00:00
|
|
|
|
2023-12-22 13:05:32 +00:00
|
|
|
[ "${payload_memtest}" != "y" ] && payload_memtest="n"
|
|
|
|
|
[ "${payload_grub_withseabios}" = "y" ] && payload_grub="y"
|
2023-10-05 21:16:07 +00:00
|
|
|
[ "${payload_grub_withseabios}" = "y" ] && \
|
|
|
|
|
eval "$(setvars "y" payload_seabios payload_seabios_withgrub)"
|
2023-12-22 13:05:32 +00:00
|
|
|
[ "$payload_seabios_withgrub" = "y" ] && payload_seabios="y"
|
|
|
|
|
[ "$payload_seabios_grubonly" = "y" ] && payload_seabios="y"
|
|
|
|
|
[ "$payload_seabios_grubonly" = "y" ] && payload_seabios_withgrub="y"
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
# 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
|
2023-12-24 09:04:36 +00:00
|
|
|
[ "$payload_grub" != "y" ] && [ "$payload_seabios" != "y" ] && \
|
2023-10-05 21:16:07 +00:00
|
|
|
[ "${payload_uboot}" != "y" ] && \
|
2023-10-05 02:23:07 +00:00
|
|
|
for configfile in "${targetdir}/config/"*; do
|
|
|
|
|
[ -e "${configfile}" ] || continue
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
|
|
|
$err "target '${board}' defines no payload"
|
2023-10-05 02:23:07 +00:00
|
|
|
done
|
|
|
|
|
|
2023-12-24 09:04:36 +00:00
|
|
|
[ "$payload_uboot" != "n" ] && [ "$payload_uboot" != "y" ] && \
|
2023-10-05 02:23:07 +00:00
|
|
|
payload_uboot="n"
|
2023-12-24 09:04:36 +00:00
|
|
|
[ "$payload_uboot" = "y" ] && [ -z "$uboot_config" ] && \
|
2023-10-05 02:23:07 +00:00
|
|
|
uboot_config="default"
|
|
|
|
|
|
|
|
|
|
# Override all payload directives with cmdline args
|
2023-10-07 04:36:52 +00:00
|
|
|
[ -z "${_payload}" ] && return 0
|
2023-10-05 02:23:07 +00:00
|
|
|
printf "setting payload to: %s\n" "${_payload}"
|
|
|
|
|
eval "$(setvars "n" payload_grub payload_memtest payload_seabios \
|
2023-11-01 09:12:56 +00:00
|
|
|
payload_seabios_withgrub payload_uboot payload_grub_withseabios \
|
|
|
|
|
payload_seabios_grubonly)"
|
2023-10-05 02:23:07 +00:00
|
|
|
eval "payload_${_payload}=y"
|
|
|
|
|
}
|
|
|
|
|
|
2024-01-01 17:57:35 +00:00
|
|
|
build_payloads()
|
2023-09-30 13:13:11 +00:00
|
|
|
{
|
2023-10-05 02:23:07 +00:00
|
|
|
romdir="bin/${board}"
|
2023-10-06 21:59:36 +00:00
|
|
|
cbdir="src/coreboot/${board}"
|
|
|
|
|
[ "${board}" = "${tree}" ] || cbdir="src/coreboot/${tree}"
|
2023-10-05 02:23:07 +00:00
|
|
|
cbfstool="cbutils/${tree}/cbfstool"
|
|
|
|
|
cbrom="${cbdir}/build/coreboot.rom"
|
2023-10-02 02:54:39 +00:00
|
|
|
|
2023-12-24 09:04:36 +00:00
|
|
|
[ -f "$cbfstool" ] || x_ ./update trees -b coreboot utils $tree
|
2023-10-05 02:23:07 +00:00
|
|
|
|
2023-10-09 05:06:20 +00:00
|
|
|
memtest_bin="memtest86plus/build64/memtest.bin"
|
2023-10-06 21:59:36 +00:00
|
|
|
[ "${payload_memtest}" != "y" ] || [ -f "src/${memtest_bin}" ] || \
|
2023-10-19 23:17:30 +00:00
|
|
|
x_ ./update trees -b memtest86plus
|
2023-10-05 02:23:07 +00:00
|
|
|
|
2024-01-01 17:52:23 +00:00
|
|
|
[ "$payload_seabios" = "y" ] && x_ ./update trees -b seabios
|
2024-01-01 22:11:29 +00:00
|
|
|
if [ "$payload_grub" = "y" ] || [ "$payload_seabios_withgrub" = "y" ] \
|
|
|
|
|
|| [ "$payload_seabios_grubonly" = "y" ]; then build_grub_payload
|
|
|
|
|
fi
|
|
|
|
|
[ "${payload_uboot}" = "y" ] && build_uboot_payload; return 0
|
2023-10-05 02:23:07 +00:00
|
|
|
}
|
|
|
|
|
|
2024-01-01 17:47:43 +00:00
|
|
|
build_grub_payload()
|
2023-10-05 02:23:07 +00:00
|
|
|
{
|
2024-01-01 19:09:45 +00:00
|
|
|
x_ mkdir -p elf/grub
|
|
|
|
|
|
2024-01-01 22:04:58 +00:00
|
|
|
for keymapfile in config/grub/keymap/*.gkb; do
|
2023-10-05 02:23:07 +00:00
|
|
|
[ -f "${keymapfile}" ] || continue
|
|
|
|
|
|
2023-12-23 16:16:26 +00:00
|
|
|
keymaps="${keymaps} ${keymapfile}"
|
2023-09-30 13:13:11 +00:00
|
|
|
done
|
GRUB: insert only 1 keymap per board, in cbfs
There is no need to add multiple keymap files, because
GRUB can load keymaps from CBFS. The current build logic
is designed to avoid building multiple GRUB binaries,
which are expensive computationally because each one
would then have to be compressed for each board.
This patch provides the best of both worlds: less space
used in flash like in the old lbmk design (1 keymap per
board), but retaining the current build speeds and therefore
not re-introducing the slowness of lbmk's previous GRUB
build logic.
The grub.cfg file has been modified, accordingly. It now
only loads a keymap.gkb file from CBFS, by default. It does
this, only if that file exists; if not, GRUB already defaults
to US Qwerty layout anyway.
ALSO: compress all keymap gkb files with xz -6
GRUB automatically decompresses files when accessed.
This results in about 2KB of flash space saved in CBFS.
Here is real-world data, showing the increased flash space:
< fallback/payload 0x3eb80 simple elf 548821 none
< keymap.cfg 0xc4bc0 raw 16 none
< (empty) 0xc4c00 null 11633316 none
---
> fallback/payload 0x3eb80 simple elf 546787 none
> keymap.gkb 0xc43c0 raw 344 none
> (empty) 0xc4540 null 11635044 none
This was taken by diffing the cbfstool "print" output,
both before and after. The *after* result is with this change.
11633316. In this example, 1728 bytes have been saved. Therefore,
with compression taken into account, this patch saves about 1.7KB
of space in CBFS.
This change means that lbmk can now scale to support hundreds
of keymaps, without increasing the amount of flash space used,
in each given image. Since the keymap files are compressed in
lbmk.git, in advance, we spend no additional time on compression
at build time. The resulting change in build speed in negligible.
Adding your own keymap.gkb file was already possible, for changing
the keymap in libreboot images, if you didn't want to change the
memdisk (and thus re-compile grub.elf). Now, this is the default
behaviour, and the only way to do it. It's much more efficient.
The original keymap files can be restored, by running unxz.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-01-17 23:54:53 +00:00
|
|
|
[ -z "$_keyboard" ] || [ -f "$grubcfgsdir/keymap/$_keyboard.gkb" ] || \
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
|
|
|
$err "build_grub_payload: $_keyboard layout not defined"
|
2024-01-17 19:32:54 +00:00
|
|
|
[ -n "$_keyboard" ] && keymaps="${grubcfgsdir}/keymap/${_keyboard}.gkb"
|
2024-01-01 21:57:27 +00:00
|
|
|
[ -f "$grubelf" ] && return 0
|
2024-01-01 17:47:43 +00:00
|
|
|
[ -f "src/grub/grub-mkstandalone" ] || x_ ./update trees -b grub
|
2023-12-30 13:08:29 +00:00
|
|
|
|
|
|
|
|
./src/grub/grub-mkstandalone \
|
|
|
|
|
--grub-mkimage="src/grub/grub-mkimage" \
|
|
|
|
|
-O i386-coreboot \
|
|
|
|
|
-o "elf/grub/grub.elf" \
|
|
|
|
|
-d "src/grub/grub-core/" \
|
|
|
|
|
--fonts= --themes= --locales= \
|
|
|
|
|
--modules="${grub_modules}" \
|
|
|
|
|
--install-modules="${grub_install_modules}" \
|
|
|
|
|
"/boot/grub/grub.cfg=${grubcfgsdir}/config/grub_memdisk.cfg" \
|
|
|
|
|
"/boot/grub/grub_default.cfg=${grubcfgsdir}/config/grub.cfg" || \
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
|
|
|
$err "could not generate grub.elf"
|
2023-10-05 02:23:07 +00:00
|
|
|
}
|
|
|
|
|
|
2024-01-01 17:57:35 +00:00
|
|
|
build_uboot_payload()
|
2023-10-05 02:23:07 +00:00
|
|
|
{
|
2023-10-19 23:17:30 +00:00
|
|
|
x_ ./update trees -b u-boot ${board}
|
2023-10-05 02:23:07 +00:00
|
|
|
ubdir="elf/u-boot/${board}/${uboot_config}"
|
|
|
|
|
ubootelf="${ubdir}/u-boot.elf"
|
2023-10-13 19:41:15 +00:00
|
|
|
[ ! -f "${ubootelf}" ] && [ -f "${ubdir}/u-boot" ] && \
|
|
|
|
|
ubootelf="${ubdir}/u-boot"
|
2023-10-05 02:23:07 +00:00
|
|
|
[ -f "${ubootelf}" ] && return 0
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
|
|
|
$err "Can't find u-boot build for board, $board";
|
2023-10-05 02:23:07 +00:00
|
|
|
}
|
|
|
|
|
|
2024-01-01 18:00:53 +00:00
|
|
|
build_target_mainboard()
|
2023-10-05 02:23:07 +00:00
|
|
|
{
|
2024-05-14 22:17:22 +00:00
|
|
|
x_ rm -Rf "${romdir}"
|
2023-12-23 16:16:26 +00:00
|
|
|
|
2023-10-05 02:23:07 +00:00
|
|
|
for x in "normal" "vgarom" "libgfxinit"; do
|
|
|
|
|
initmode="${x}"
|
|
|
|
|
hmode="vesafb"
|
|
|
|
|
[ "${initmode}" = "vgarom" ] || hmode="corebootfb"
|
|
|
|
|
modes="${hmode} txtmode"
|
2023-10-07 04:36:52 +00:00
|
|
|
[ -z "${_displaymode}" ] || modes="${_displaymode}"
|
2023-10-05 02:23:07 +00:00
|
|
|
for y in ${modes}; do
|
|
|
|
|
displaymode="${y}"
|
|
|
|
|
[ "${initmode}" = "normal" ] && \
|
|
|
|
|
[ "$displaymode" != "txtmode" ] && continue
|
|
|
|
|
cbcfg="${targetdir}/config/${initmode}_${displaymode}"
|
|
|
|
|
[ "${initmode}" = "normal" ] && cbcfg="${cbcfg%_*}"
|
2024-04-25 18:03:43 +00:00
|
|
|
build_roms "${cbcfg}"
|
|
|
|
|
x_ rm -f "$cbrom"
|
2023-10-05 02:23:07 +00:00
|
|
|
done
|
|
|
|
|
done
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
# Main ROM building function. This calls all other functions below
|
|
|
|
|
build_roms()
|
|
|
|
|
{
|
|
|
|
|
cbcfg="${1}"
|
2023-11-08 06:31:04 +00:00
|
|
|
if [ ! -f "${cbcfg}" ]; then
|
2023-10-05 02:23:07 +00:00
|
|
|
printf "'%s' does not exist. Skipping build for %s %s %s\n" \
|
2023-12-22 13:05:32 +00:00
|
|
|
"$cbcfg" "$board" "$displaymode" "$initmode" 1>&2
|
2023-11-08 06:31:04 +00:00
|
|
|
return 0
|
|
|
|
|
fi
|
2023-10-05 02:23:07 +00:00
|
|
|
|
2023-10-19 23:17:30 +00:00
|
|
|
x_ ./update trees -b coreboot ${board}
|
2023-10-05 02:23:07 +00:00
|
|
|
|
2023-12-22 13:05:32 +00:00
|
|
|
_cbrom="elf/coreboot_nopayload_DO_NOT_FLASH"
|
|
|
|
|
_cbrom="${_cbrom}/${board}/${initmode}_${displaymode}"
|
2023-10-05 02:23:07 +00:00
|
|
|
[ "${initmode}" = "normal" ] && \
|
2023-12-16 07:56:26 +00:00
|
|
|
_cbrom="${_cbrom%"_${displaymode}"}"
|
2023-10-05 02:23:07 +00:00
|
|
|
_cbrom="${_cbrom}/coreboot.rom"
|
|
|
|
|
cbrom="$(mktemp -t coreboot_rom.XXXXXXXXXX)"
|
|
|
|
|
x_ cp "${_cbrom}" "${cbrom}"
|
|
|
|
|
|
|
|
|
|
[ "${payload_memtest}" != "y" ] || \
|
|
|
|
|
x_ "${cbfstool}" "${cbrom}" add-payload \
|
2023-10-06 21:59:36 +00:00
|
|
|
-f "src/${memtest_bin}" -n img/memtest -c lzma
|
2023-12-23 16:16:26 +00:00
|
|
|
[ "${payload_seabios}" = "y" ] && build_seabios_roms
|
2023-12-24 09:04:36 +00:00
|
|
|
[ "$payload_grub" != "y" ] || x_ build_grub_roms "$cbrom" "grub"
|
2023-10-05 02:23:07 +00:00
|
|
|
[ "${payload_uboot}" = "y" ] || return 0
|
2023-10-23 23:14:01 +00:00
|
|
|
x_ cp "${_cbrom}" "${cbrom}"
|
2023-10-05 02:23:07 +00:00
|
|
|
build_uboot_roms
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
build_seabios_roms()
|
|
|
|
|
{
|
|
|
|
|
if [ "${payload_seabios_withgrub}" = "y" ]; then
|
2023-12-22 13:05:32 +00:00
|
|
|
t=$(mktemp -t coreboot_rom.XXXXXXXXXX)
|
|
|
|
|
x_ cp "${cbrom}" "${t}"
|
|
|
|
|
x_ build_grub_roms "${t}" "seabios_withgrub"
|
2023-10-05 02:23:07 +00:00
|
|
|
else
|
|
|
|
|
t=$(mkSeabiosRom "${cbrom}" "fallback/payload") || \
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
|
|
|
$err "build_seabios_roms: cannot build tmprom"
|
2023-10-05 02:23:07 +00:00
|
|
|
newrom="${romdir}/seabios_${board}_${initmode}_${displaymode}"
|
|
|
|
|
[ "${initmode}" = "normal" ] && newrom="${romdir}/seabios" \
|
|
|
|
|
&& newrom="${newrom}_${board}_${initmode}"
|
|
|
|
|
x_ moverom "${t}" "${newrom}.rom"
|
|
|
|
|
fi
|
2023-12-22 13:05:32 +00:00
|
|
|
x_ rm -f "${t}"
|
2023-09-30 13:13:11 +00:00
|
|
|
}
|
|
|
|
|
|
2023-10-05 02:23:07 +00:00
|
|
|
# Make separate ROM images with GRUB payload, for each supported keymap
|
|
|
|
|
build_grub_roms()
|
2023-09-30 12:05:57 +00:00
|
|
|
{
|
2023-10-05 02:23:07 +00:00
|
|
|
tmprom="${1}"
|
|
|
|
|
payload1="${2}" # allow values: grub, seabios, seabios_withgrub
|
|
|
|
|
|
2023-10-05 21:16:07 +00:00
|
|
|
grub_cbfs="fallback/payload"
|
2023-12-23 12:16:14 +00:00
|
|
|
if [ "$payload1" = "grub" ] && [ "$payload_grub_withseabios" = "y" ]
|
|
|
|
|
then
|
|
|
|
|
_tmpmvrom=$(mkSeabiosRom "$tmprom" "seabios.elf") || \
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
|
|
|
$err "build_grub_roms 1 $board: can't build tmprom"
|
2023-12-23 12:16:14 +00:00
|
|
|
x_ mv "$_tmpmvrom" "$tmprom"
|
|
|
|
|
elif [ "$payload1" != "grub" ] && [ "$payload_seabios_withgrub" = "y" ]
|
|
|
|
|
then
|
|
|
|
|
grub_cbfs="img/grub2"
|
|
|
|
|
_tmpmvrom=$(mkSeabiosRom "$tmprom" fallback/payload) || \
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
|
|
|
$err "build_grub_roms 2 $board: can't build tmprom"
|
2023-12-23 12:16:14 +00:00
|
|
|
x_ mv "$_tmpmvrom" "$tmprom"
|
|
|
|
|
fi
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
# we only need insert grub.elf once, for each coreboot config:
|
|
|
|
|
x_ "${cbfstool}" "${tmprom}" add-payload -f "${grubelf}" \
|
|
|
|
|
-n ${grub_cbfs} -c lzma
|
|
|
|
|
|
|
|
|
|
# we only need insert background.png once, for each coreboot config:
|
|
|
|
|
if [ "${displaymode}" = "vesafb" ] || \
|
|
|
|
|
[ "${displaymode}" = "corebootfb" ]; then
|
|
|
|
|
backgroundfile="config/grub/background/${grub_background}"
|
2023-10-22 11:31:55 +00:00
|
|
|
"${cbfstool}" "${tmprom}" add -f ${backgroundfile} \
|
2023-12-22 13:05:32 +00:00
|
|
|
-n background.png -t raw || \
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
|
|
|
$err "insert background, ${backgroundfile}"
|
2023-10-05 02:23:07 +00:00
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
tmpcfg=$(mktemp -t coreboot_rom.XXXXXXXXXX)
|
2023-12-22 13:05:32 +00:00
|
|
|
printf "set grub_scan_disk=\"%s\"\n" "$grub_scan_disk" >"$tmpcfg" \
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
|
|
|
|| $err "set grub_scandisk, $grub_scan_disk, $tmpcfg"
|
2023-10-05 02:23:07 +00:00
|
|
|
[ "${grub_scan_disk}" = "both" ] || \
|
2023-12-22 13:05:32 +00:00
|
|
|
x_ "$cbfstool" "$tmprom" add -f "$tmpcfg" -n scan.cfg -t raw
|
2023-10-22 11:31:55 +00:00
|
|
|
printf "set timeout=%s\n" "${grub_timeout}" > "${tmpcfg}" || \
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
|
|
|
$err "set timeout, ${grub_timeout}, ${tmpcfg}"
|
2023-10-05 02:23:07 +00:00
|
|
|
[ -z "${grub_timeout}" ] || x_ "${cbfstool}" "${tmprom}" add \
|
|
|
|
|
-f "${tmpcfg}" -n timeout.cfg -t raw
|
|
|
|
|
x_ rm -f "${tmpcfg}"
|
|
|
|
|
|
|
|
|
|
for keymapfile in ${keymaps}; do
|
|
|
|
|
[ -f "${keymapfile}" ] || continue
|
|
|
|
|
keymap="${keymapfile##*/}"
|
|
|
|
|
keymap="${keymap%.gkb}"
|
GRUB: insert only 1 keymap per board, in cbfs
There is no need to add multiple keymap files, because
GRUB can load keymaps from CBFS. The current build logic
is designed to avoid building multiple GRUB binaries,
which are expensive computationally because each one
would then have to be compressed for each board.
This patch provides the best of both worlds: less space
used in flash like in the old lbmk design (1 keymap per
board), but retaining the current build speeds and therefore
not re-introducing the slowness of lbmk's previous GRUB
build logic.
The grub.cfg file has been modified, accordingly. It now
only loads a keymap.gkb file from CBFS, by default. It does
this, only if that file exists; if not, GRUB already defaults
to US Qwerty layout anyway.
ALSO: compress all keymap gkb files with xz -6
GRUB automatically decompresses files when accessed.
This results in about 2KB of flash space saved in CBFS.
Here is real-world data, showing the increased flash space:
< fallback/payload 0x3eb80 simple elf 548821 none
< keymap.cfg 0xc4bc0 raw 16 none
< (empty) 0xc4c00 null 11633316 none
---
> fallback/payload 0x3eb80 simple elf 546787 none
> keymap.gkb 0xc43c0 raw 344 none
> (empty) 0xc4540 null 11635044 none
This was taken by diffing the cbfstool "print" output,
both before and after. The *after* result is with this change.
11633316. In this example, 1728 bytes have been saved. Therefore,
with compression taken into account, this patch saves about 1.7KB
of space in CBFS.
This change means that lbmk can now scale to support hundreds
of keymaps, without increasing the amount of flash space used,
in each given image. Since the keymap files are compressed in
lbmk.git, in advance, we spend no additional time on compression
at build time. The resulting change in build speed in negligible.
Adding your own keymap.gkb file was already possible, for changing
the keymap in libreboot images, if you didn't want to change the
memdisk (and thus re-compile grub.elf). Now, this is the default
behaviour, and the only way to do it. It's much more efficient.
The original keymap files can be restored, by running unxz.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-01-17 23:54:53 +00:00
|
|
|
|
|
|
|
|
tmpgrubrom="$(mktemp -t coreboot_rom.XXXXXXXXXX)"
|
|
|
|
|
x_ cp "${tmprom}" "${tmpgrubrom}"
|
|
|
|
|
x_ "$cbfstool" "$tmpgrubrom" add -f "$keymapfile" \
|
|
|
|
|
-n keymap.gkb -t raw
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
newrom="${romdir}/${payload1}_${board}_${initmode}_"
|
|
|
|
|
newrom="${newrom}${displaymode}_${keymap}.rom"
|
|
|
|
|
[ "${initmode}" = "normal" ] && \
|
|
|
|
|
newrom="${romdir}/${payload1}_${board}_" && \
|
|
|
|
|
newrom="${newrom}${initmode}_${keymap}.rom"
|
|
|
|
|
x_ moverom "${tmpgrubrom}" "${newrom}"
|
2024-04-28 18:56:25 +00:00
|
|
|
if [ "${payload_seabios_grubonly}" = "y" ]; then
|
2024-04-28 19:21:35 +00:00
|
|
|
x_ "$cbfstool" "$tmpgrubrom" add \
|
|
|
|
|
-f "config/grub/bootorder" -n bootorder -t raw
|
|
|
|
|
x_ moverom "$tmpgrubrom" "${newrom%.rom}_grubfirst.rom"
|
|
|
|
|
x_ "$cbfstool" "$tmpgrubrom" add-int -i 0 \
|
|
|
|
|
-n etc/show-boot-menu
|
|
|
|
|
x_ moverom "$tmpgrubrom" "${newrom%.rom}_grubonly.rom"
|
2024-04-28 18:56:25 +00:00
|
|
|
fi
|
2023-10-05 02:23:07 +00:00
|
|
|
x_ rm -f "${tmpgrubrom}"
|
|
|
|
|
done
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
# 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)
|
|
|
|
|
|
|
|
|
|
x_ cp "${_cbrom}" "${tmprom}"
|
2023-12-24 09:04:36 +00:00
|
|
|
x_ "$cbfstool" "$tmprom" add-payload -f "$_seabioself" \
|
2023-12-16 07:56:26 +00:00
|
|
|
-n "${_seabios_cbfs_path}" -c lzma
|
2023-12-22 13:05:32 +00:00
|
|
|
x_ "$cbfstool" "$tmprom" add-int -i 3000 -n etc/ps2-keyboard-spinup
|
2023-10-05 02:23:07 +00:00
|
|
|
|
2023-12-24 09:04:36 +00:00
|
|
|
z="2"; [ "$initmode" = "vgarom" ] && z="0"
|
|
|
|
|
x_ "$cbfstool" "$tmprom" add-int -i $z -n etc/pci-optionrom-exec
|
|
|
|
|
x_ "$cbfstool" "$tmprom" add-int -i 0 -n etc/optionroms-checksum
|
|
|
|
|
[ "$initmode" != "libgfxinit" ] || \
|
|
|
|
|
x_ "$cbfstool" "$tmprom" add -f "$seavgabiosrom" \
|
2023-10-05 02:23:07 +00:00
|
|
|
-n vgaroms/seavgabios.bin -t raw
|
|
|
|
|
|
|
|
|
|
printf "%s\n" "${tmprom}"
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
build_uboot_roms()
|
|
|
|
|
{
|
2023-12-23 12:16:14 +00:00
|
|
|
tmprom=$(mkUbootRom "${cbrom}" "fallback/payload") || \
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
|
|
|
$err "build_uboot_roms $board: could not create tmprom"
|
2023-10-05 02:23:07 +00:00
|
|
|
newrom="${romdir}/uboot_payload_${board}_${initmode}_${displaymode}.rom"
|
|
|
|
|
x_ moverom "${tmprom}" "${newrom}"
|
|
|
|
|
x_ rm -f "${tmprom}"
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
# make a rom in /tmp/ and then print the path of that ROM
|
|
|
|
|
mkUbootRom() {
|
2023-10-05 21:16:07 +00:00
|
|
|
_cbrom="${1}"
|
|
|
|
|
_uboot_cbfs_path="${2}"
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
_ubdir="elf/u-boot/${board}/${uboot_config}"
|
|
|
|
|
_ubootelf="${_ubdir}/u-boot.elf"
|
2023-10-13 19:41:15 +00:00
|
|
|
[ -f "${_ubootelf}" ] || _ubootelf="${_ubdir}/u-boot"
|
safer, simpler error handling in lbmk
in shell scripts, a function named the same as a program included in
the $PATH will override that program. for example, you could make a
function called ls() and this would override the standand "ls".
in lbmk, a part of it was first trying to run the "fail" command,
deferring to "err", because some scripts call fail() which does
some minor cleanup before calling err.
in most cases, fail() is not defined, and it's possible that the user
could have a program called "fail" in their $PATH, the behaviour of
which we could not determine, and it could have disastrous effects.
lbmk error handling has been re-engineered in such a way that the
err function is defined in a variable, which defaults to err_ which
calls err_, so defined under include/err.sh.
in functions that require cleanup prior to error handling, a fail()
function is still defined, and err is overridden, thus:
err="fail"
this change has made xx_() obsolete, so now only x_ is used. the x_
function is a wrapper that can be used to run a command and exit with
non-zero status (from lbmk) if the command fails. the xx_ command
did the same thing, but called fail() which would have called err();
now everything is $err
example:
rm -f "$filename" || err "could not delete file"
this would now be:
rm -f "$filename" || $err "could not delete file"
overriding of err= must be done *after* including err.sh. for
example:
err="fail"
. "include/err.sh"
^ this is wrong. instead, one must do:
. "include/err.sh"
err="fail"
this is because err is set as a global variable under err.sh
the new error handling is much cleaner, and safer. it also reduces
the chance of mistakes such as: calling err when you meant to
call fail. this is because the standard way is now to call $err,
so you set err="fail" at the top of the script and all is well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2024-03-27 01:19:39 +00:00
|
|
|
[ -f "$_ubootelf" ] || $err "mkUbootRom: $board: cant find u-boot"
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
|
|
|
|
|
|
|
|
|
|
x_ cp "${_cbrom}" "${tmprom}"
|
2023-12-24 09:04:36 +00:00
|
|
|
x_ "$cbfstool" "$tmprom" add-payload -f "$_ubootelf" \
|
2023-12-16 07:56:26 +00:00
|
|
|
-n "${_uboot_cbfs_path}" -c lzma
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
printf "%s\n" "${tmprom}"
|
|
|
|
|
}
|
|
|
|
|
|
don't delete microcode updates in rom images
at present, lbmk can remove microcode updates on images for
a given target, if the target specifies
microcode_required="n" in target.cfg
lbmk then provides images with microcode, and images without,
in a given release. although the user can also remove them
manually, this just makes it a bit more convenient, for those
users who do wish to run without the updates. this functionality
is provided only on those platforms where no-microcode is tested.
well, this behaviour implements a compromise on libreboot policy,
which is to always include microcode updates by default. see:
Binary Blob Reduction Policy
the *canoeboot* project now exists, developed in parallel with
libreboot, and it ships without microcode updates, on the same
targets where lbmk also handled this.
running without microcode updates is foolish, and should not
be encouraged. clean up lbmk by not providing this kludge.
the libreboot documentation will be updated, telling such users
to try canoeboot instead, or to remove the update from a given
libreboot rom - this is still possible, and mitigations such as
PECI disablement on GM45 are still in place (and will be kept),
so that this continues to work well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-12-23 06:54:56 +00:00
|
|
|
moverom()
|
|
|
|
|
{
|
|
|
|
|
printf "Creating target image: %s\n" "$2"
|
2023-10-05 02:23:07 +00:00
|
|
|
|
don't delete microcode updates in rom images
at present, lbmk can remove microcode updates on images for
a given target, if the target specifies
microcode_required="n" in target.cfg
lbmk then provides images with microcode, and images without,
in a given release. although the user can also remove them
manually, this just makes it a bit more convenient, for those
users who do wish to run without the updates. this functionality
is provided only on those platforms where no-microcode is tested.
well, this behaviour implements a compromise on libreboot policy,
which is to always include microcode updates by default. see:
Binary Blob Reduction Policy
the *canoeboot* project now exists, developed in parallel with
libreboot, and it ships without microcode updates, on the same
targets where lbmk also handled this.
running without microcode updates is foolish, and should not
be encouraged. clean up lbmk by not providing this kludge.
the libreboot documentation will be updated, telling such users
to try canoeboot instead, or to remove the update from a given
libreboot rom - this is still possible, and mitigations such as
PECI disablement on GM45 are still in place (and will be kept),
so that this continues to work well.
Signed-off-by: Leah Rowe <leah@libreboot.org>
2023-12-23 06:54:56 +00:00
|
|
|
x_ mkdir -p "${2%/*}"
|
|
|
|
|
x_ cp "$1" "$2"
|
2024-05-14 22:17:22 +00:00
|
|
|
[ "$lbmk_release" = "y" ] || return 0
|
|
|
|
|
|
2024-05-14 23:37:12 +00:00
|
|
|
mksha512sum "${2}" "vendorhashes"
|
2024-05-14 22:17:22 +00:00
|
|
|
x_ ./vendor inject -r "${2}" -b "$board" -n nuke
|
2023-10-05 02:23:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
usage()
|
|
|
|
|
{
|
|
|
|
|
cat <<- EOF
|
2023-10-19 23:17:30 +00:00
|
|
|
USAGE: ./build roms targetname
|
|
|
|
|
To build *all* boards, do this: ./build roms all
|
|
|
|
|
To list *all* boards, do this: ./build roms list
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
Optional Flags:
|
|
|
|
|
-d: displaymode
|
|
|
|
|
-p: payload
|
|
|
|
|
-k: keyboard layout
|
|
|
|
|
|
|
|
|
|
Example commands:
|
2023-10-10 22:48:03 +00:00
|
|
|
|
2023-10-19 23:17:30 +00:00
|
|
|
./build roms x60
|
|
|
|
|
./build roms x200_8mb x60
|
|
|
|
|
./build roms x60 -p grub -d corebootfb -k usqwerty
|
2023-10-05 02:23:07 +00:00
|
|
|
|
2024-04-26 22:32:10 +00:00
|
|
|
to see possible values for 'target':
|
|
|
|
|
|
|
|
|
|
./build roms list
|
|
|
|
|
|
2024-05-09 12:56:35 +00:00
|
|
|
Can also build serprog images:
|
|
|
|
|
${serprog_usage}
|
|
|
|
|
|
2024-04-26 22:32:10 +00:00
|
|
|
to see targets of only a given status (stable, unstable,
|
|
|
|
|
broken, untested and unknown), try e.g.
|
|
|
|
|
|
|
|
|
|
./build roms list stable
|
|
|
|
|
./build roms list unstable untested
|
|
|
|
|
./build roms list unknown
|
|
|
|
|
./build roms list broken
|
|
|
|
|
./build roms list broken stable
|
|
|
|
|
|
|
|
|
|
the value is set in target.cfg for each board. if status
|
|
|
|
|
is unitialised, it defaults to "unknown". only stable/unstable
|
|
|
|
|
targets are permitted in releases; broken, untested and
|
|
|
|
|
unknown are not allowed, but are accessible via normal building
|
2023-10-05 02:23:07 +00:00
|
|
|
|
|
|
|
|
Refer to the ${projectname} documentation for more information.
|
|
|
|
|
EOF
|
2023-09-30 12:05:57 +00:00
|
|
|
}
|
|
|
|
|
|
2023-05-10 04:39:11 +00:00
|
|
|
main $@
|