coja/lbmk
1
0
Fork 0
mirror of https://codeberg.org/libreboot/lbmk.git synced 2026-07-20 05:36:23 +02:00
Code Issues Packages Projects Releases Wiki Activity

build/roms_helper: reset d521fca7, backport fixes

Browse Source 
I keep getting random linker issues when running:

./build boot roms all

I think the issue lies somewhere in here, from when
I did that massive audit. So I'm undoing the audit
which mostly re-factored the code style here.

These changes are being backported:
f338697b build/boot/roms: Support removing microcode
941fbcb run coreboot utils from own directory
f256ce98 build/boot/roms: say board name on stderr

I removed this change:
6d6bd5ee (the script now uses dedicated utils directory)

additionally:

cbutils is built much earlier on in the script, first
thing after initialising variables

the other changes not backported are all code style
changes, and I believe these are responsible.

if no other fixes occur to this fire before the next
libreboot release, then my hunch was right.

Signed-off-by: Leah Rowe <leah@libreboot.org>
This commit is contained in:
Leah Rowe
2023-06-25 11:45:40 +01:00
parent 46e6a40c10
commit 2e85a63a0a
1 changed files with 460 additions and 496 deletions
Download Patch File Download Diff File Expand all files Collapse all files
resources/scripts/build/boot/roms_helper
+349 -385
View File
@@ -31,43 +31,13 @@ set -u -e
projectname="$(cat projectname)" projectname="$(cat projectname)"
cbcfgdir="resources/coreboot" blobs_required=""
boardcfgdir="" microcode_required=""
kmapdir="resources/grub/keymap" kmapdir="resources/grub/keymap"
displaymodes="" displaymodes=""
payloads="" payloads=""
keyboard_layouts="" 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=""
# almost all boards will set at least one of these to "n"
blobs_required=""
microcode_required=""
CROSS_COMPILE=""
main()
{
while [ $# -gt 0 ]; do while [ $# -gt 0 ]; do
case ${1} in case ${1} in
-d) -d)
@@ -85,56 +55,49 @@ main()
shift shift
done done
printf "\n\nboard %s , kb %s , displaymode %s , payloads %s\n" \ printf "\n\nboard is %s , kb is %s , displaymode is %s , payloads is %s\n" \
${board} ${keyboard_layouts} ${displaymodes} \ ${board} ${keyboard_layouts} ${displaymodes} ${payloads} 1>&2
${payloads} 1>&2
if [ "${board}" = "" ]; then if [ ! -d "resources/coreboot/${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} printf "build/roms: Target not defined: %s\n" ${board}
exit 1 exit 1
fi fi
if [ ! -f "${boardcfgdir}/board.cfg" ]; then
printf "build/roms %s: Missing board.cfg\n" ${board} if [ ! -f "resources/coreboot/${board}/board.cfg" ]; then
printf "build/roms: Missing board.cfg for target: %s\n" ${board}
exit 1 exit 1
fi fi
. "${boardcfgdir}/board.cfg"
if [ "${board}" != "${cbtree}" ]; then grub_scan_disk="undefined"
cbdir="coreboot/${cbtree}" cbtree="undefined"
else romtype="normal" # optional parameter in board.cfg. "normal" is default
cbdir="coreboot/${board}" arch="undefined"
fi
romdir="bin/${board}" # Disable all payloads by default.
cbfstool="cbutils/${cbtree}/cbfstool" # board.cfg files have to specifically enable [a] payload(s)
seavgabiosrom="payload/seabios/seavgabios.bin" payload_grub="n"
corebootrom="${cbdir}/build/coreboot.rom" payload_grub_withseabios="n" # seabios chainloaded from grub
payload_seabios="n"
payload_seabios_withgrub="n" # i386-coreboot grub from SeaBIOS boot menu
seabios_opromloadonly="0"
payload_memtest="n"
payload_uboot="n"
uboot_config="undefined"
# Override the above defaults using board.cfg
. "resources/coreboot/${board}/board.cfg"
if [ "${grub_scan_disk}" = "undefined" ]; then if [ "${grub_scan_disk}" = "undefined" ]; then
printf "build/roms '%s': grub_scan_disk is undefined. " \ printf "build/roms: Target '%s' does not define grub_scan_disk. " \
${board} ${board}
printf "Defaulting to 'both'.\n" printf "Defaulting to 'both'.\n"
grub_scan_disk="both" grub_scan_disk="both"
fi fi
if [ "${grub_scan_disk}" != "both" ] && \ if [ "${grub_scan_disk}" != "both" ] && \
[ "${grub_scan_disk}" != "ata" ] && \ [ "${grub_scan_disk}" != "ata" ] && \
[ "${grub_scan_disk}" != "ahci" ]; then [ "${grub_scan_disk}" != "ahci" ]; then
printf "build/roms '%s': invalid grub_scan_disk config. " \ printf "build/roms: Target '%s' defines bad grub_scan_disk option. " \
${board} ${board}
printf "Defaulting to 'both'.\n" printf "Defaulting to 'both'.\n"
grub_scan_disk="both" grub_scan_disk="both"
@@ -142,18 +105,22 @@ load_config()
fi fi
if [ "${cbtree}" = "undefined" ]; then if [ "${cbtree}" = "undefined" ]; then
printf "build/roms '%s': undefined coreboot tree. " \ printf "build/roms: Target '%s' does not define a coreboot tree. " \
${board} ${board}
printf "Skipping build.\n" printf "Skipping build.\n"
exit 1 exit 1
fi fi
if [ "${arch}" = "undefined" ]; then if [ "${arch}" = "undefined" ]; then
printf "build/roms '%s': undefined CPU type. " \ printf "build/roms: Target '%s' does not define a CPU type. " \
${board} ${board}
printf "Skipping build.\n" printf "Skipping build.\n"
exit 1 exit 1
fi fi
if [ "${seabios_opromloadonly}" != "0" ] && \
[ "${seabios_opromloadonly}" != "1" ]; then
seabios_opromloadonly="0"
fi
if [ "${payload_memtest}" != "n" ] && \ if [ "${payload_memtest}" != "n" ] && \
[ "${payload_memtest}" != "y" ]; then [ "${payload_memtest}" != "y" ]; then
payload_memtest="n" payload_memtest="n"
@@ -168,14 +135,32 @@ load_config()
if [ "${payload_seabios_withgrub}" = "y" ]; then if [ "${payload_seabios_withgrub}" = "y" ]; then
payload_seabios="y" payload_seabios="y"
fi fi
# NOTE: reverse logic must NOT be applied. If SeaBIOS-with-GRUB works, that
# doesn't necessarily mean GRUb-with-SeaBIOS will. For example, the board
# might have an external GPU, where it's recommended to boot SeaBIOS first
if [ "${payload_grub}" != "y" ] && [ "${payload_seabios}" != "y" ] \
&& [ "${payload_uboot}" != "y" ]; then
for configfile in "resources/coreboot/${board}/config/"*; do
if [ ! -e "${configfile}" ]; then
continue
fi
printf "ERROR build/roms: Target '%s' defines no payload. " \
${board}
printf "Exiting.\n"
exit 1
done
fi
if [ "${payload_uboot}" != "n" ] && \ if [ "${payload_uboot}" != "n" ] && \
[ "${payload_uboot}" != "y" ]; then [ "${payload_uboot}" != "y" ]; then
payload_uboot="n" payload_uboot="n"
fi fi
if [ "${payload_uboot}" = "y" ] && \ if [ "${payload_uboot}" = "y" ] && \
[ "${uboot_config}" = "undefined" ]; then [ "${uboot_config}" = "undefined" ]; then
uboot_config="default" uboot_config="default"
fi fi
if [ "${microcode_required}" != "n" ] \ if [ "${microcode_required}" != "n" ] \
&& [ "${microcode_required}" != "y" ]; then && [ "${microcode_required}" != "y" ]; then
microcode_required="y" microcode_required="y"
@@ -185,70 +170,39 @@ load_config()
blobs_required="y" blobs_required="y"
fi fi
load_config_overrides
die_if_cbconfig_and_nopayload
}
load_config_overrides()
{
# Override all payload directives with cmdline args # Override all payload directives with cmdline args
if [ -z ${payloads} ]; then if [ ! -z ${payloads} ]; then
return 0
fi
echo "setting payloads $payloads" echo "setting payloads $payloads"
payload_grub="n" payload_grub="n"
payload_grub_withseabios="n" # seabios chainloaded from grub payload_grub_withseabios="n" # seabios chainloaded from grub
payload_seabios="n" payload_seabios="n"
payload_seabios_withgrub="n" # grub from SeaBIOS menu payload_seabios_withgrub="n" # i386-coreboot grub from SeaBIOS menu
payload_uboot="n" payload_uboot="n"
seabios_opromloadonly="0"
payload_memtest="n" payload_memtest="n"
for payload in ${payloads} ; do for payload in ${payloads} ; do
eval "payload_${payload}=y" eval "payload_${payload}=y"
done 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 fi
for configfile in "${boardcfgdir}/config/"*; do romdir="bin/${board}"
if [ ! -e "${configfile}" ]; then cbdir="coreboot/${board}"
continue if [ "${board}" != "${cbtree}" ]; then
cbdir="coreboot/${cbtree}"
fi fi
printf "build/roms %s: Payload undefined. Exiting.\n" \ cbfstool="cbutils/${cbtree}/cbfstool"
${board} corebootrom="${cbdir}/build/coreboot.rom"
exit 1 seavgabiosrom="payload/seabios/seavgabios.bin"
done
} ./build module cbutils ${cbtree} || exit 1
build_dependencies()
{
if [ ! -d "${cbdir}" ]; then if [ ! -d "${cbdir}" ]; then
./download coreboot ${cbtree} ./download coreboot ${cbtree}
fi fi
./build module cbutils ${cbtree} || exit 1
cat version > "${cbdir}/.coreboot-version" cat version > "${cbdir}/.coreboot-version"
build_dependency_crossgcc
build_dependency_seabios
build_dependency_grub
build_dependency_uboot
}
build_dependency_crossgcc()
{
make distclean -C "${cbdir}"
if [ "${arch}" = "x86_32" ] || [ "${arch}" = "x86_64" ]; then if [ "${arch}" = "x86_32" ] || [ "${arch}" = "x86_64" ]; then
if [ ! -d "${cbdir}/util/crossgcc/xgcc/i386-elf/" ]; then if [ ! -d "${cbdir}/util/crossgcc/xgcc/i386-elf/" ]; then
# Even for 64-bit machines, coreboot builds 32-bit ROM # Even for 64-bit machines, coreboot builds 32-bit ROM
@@ -282,10 +236,7 @@ build_dependency_crossgcc()
fi fi
export PATH="$(pwd)/${cbdir}/util/crossgcc/xgcc/bin:$PATH" export PATH="$(pwd)/${cbdir}/util/crossgcc/xgcc/bin:$PATH"
}
build_dependency_seabios()
{
if [ ! -f "${seavgabiosrom}" ] \ if [ ! -f "${seavgabiosrom}" ] \
|| [ ! -f payload/seabios/seabios_libgfxinit.elf ] \ || [ ! -f payload/seabios/seabios_libgfxinit.elf ] \
|| [ ! -f payload/seabios/seabios_vgarom.elf ] \ || [ ! -f payload/seabios/seabios_vgarom.elf ] \
@@ -293,40 +244,39 @@ build_dependency_seabios()
if [ "${payload_seabios}" = "y" ]; then if [ "${payload_seabios}" = "y" ]; then
./build payload seabios ./build payload seabios
elif [ "${payload_grub}" = "y" ] \ elif [ "${payload_grub}" = "y" ] \
&& [ "${payload_grub_withseabios}" = "y" ] && [ "${payload_grub_withseabios}" = "y" ]; then
then
./build payload seabios ./build payload seabios
fi fi
fi fi
if [ "${payload_memtest}" = "y" ] && [ ! -f "memtest86plus/memtest" ]
then if [ "${payload_memtest}" = "y" ]; then
if [ ! -f "memtest86plus/memtest" ]; then
./build module memtest86plus ./build module memtest86plus
fi fi
}
build_dependency_grub()
{
if [ "${payload_grub}" != "y" ] \
&& [ "${payload_seabios_withgrub}" != "y" ]; then
return 0
fi fi
[ -d "${romdir}/" ] || mkdir -p "${romdir}/"
rm -f "${romdir}"/*
if [ "${payload_grub}" = "y" ] \
|| [ "${payload_seabios_withgrub}" = "y" ]; then
if [ -f "payload/grub/grub_usqwerty.cfg" ]; then if [ -f "payload/grub/grub_usqwerty.cfg" ]; then
sha1cmd="sha1sum resources/grub/config/grub.cfg" sha1sumcmd="sha1sum resources/grub/config/grub.cfg"
grubrefchecksum="$(${sha1cmd} | awk '{print $1}')" grubrefchecksum="$(${sha1sumcmd} | awk '{print $1}')"
sha1cmd="sha1sum payload/grub/grub_usqwerty.cfg" sha1sumcmd="sha1sum payload/grub/grub_usqwerty.cfg"
grubsha1="$(${sha1cmd} | awk '{print $1}')" grubbuildchecksum="$(${sha1sumcmd} | awk '{print $1}')"
if [ "${grubrefchecksum}" != "${grubsha1}" ]; then if [ "${grubrefchecksum}" != "${grubbuildchecksum}" ]; then
rm -Rf payload/grub/ rm -Rf payload/grub/
printf "GRUB change detected. Rebuilding:\n" printf "Changes detected to GRUB. Re-building now:\n"
fi fi
else else
printf "GRUB payloads needed. Building:\n" printf "Required GRUB payloads not yet built. Building now:\n"
rm -Rf payload/grub/ # just in case rm -Rf payload/grub/ # just in case
fi fi
for keymapfile in ${kmapdir}/*; do for keymapfile in ${kmapdir}/*; do
if [ ! -f "${keymapfile}" ]; then if [ ! -f "${keymapfile}" ]; then
continue continue
fi fi
@@ -343,15 +293,9 @@ build_dependency_grub()
./build payload grub ./build payload grub
fi fi
done done
}
build_dependency_uboot()
{
if [ "${payload_uboot}" != "y" ]; then
return 0
fi fi
ubdir="" if [ "${payload_uboot}" = "y" ]; then
if [ "${uboot_config}" = "default" ]; then if [ "${uboot_config}" = "default" ]; then
ubdir="payload/u-boot/${board}" ubdir="payload/u-boot/${board}"
else else
@@ -363,152 +307,118 @@ build_dependency_uboot()
elif [ -f "${ubdir}/u-boot" ]; then elif [ -f "${ubdir}/u-boot" ]; then
ubootelf="${ubdir}/u-boot" ubootelf="${ubdir}/u-boot"
else else
printf "U-Boot needed. Building:\n" printf "Required U-Boot payload not yet built. Building now\n"
rm -Rf "payload/u-boot/${board}" # just in case rm -Rf "payload/u-boot/${board}" # just in case
./build payload u-boot "${board}" ./build payload u-boot "${board}"
fi fi
} fi
build_rom_images() # it is assumed that no other work will be done on the ROM
{ # after calling this function. therefore this function is "final"
[ -d "${romdir}/" ] || mkdir -p "${romdir}/" moverom() {
rm -f "${romdir}"/* rompath="$1"
newrompath="$2"
cuttype="$3"
for initmode in "normal" "vgarom" "libgfxinit"; do if [ "${blobs_required}" = "n" ]; then
hmode="vesafb" newrompath="${newrompath%.rom}_noblobs.rom"
if [ "${initmode}" != "vgarom" ]; then
hmode="corebootfb"
fi fi
modes="${hmode} txtmode"
if [ ! -z ${displaymodes} ]; then printf "\nCreating new ROM image: %s\n" "${newrompath}"
modes="${displaymodes}"
if [ "${cuttype}" = "4MiB IFD BIOS region" ]; then
dd if=${rompath} of=${newrompath} bs=1 \
skip=$(($(stat -c %s ${rompath}) - 0x400000)) \
count=4194304
else
cp ${rompath} ${newrompath}
fi fi
for displaymode in ${modes}; do
if [ "${initmode}" = "normal" ] \ for romsize in 4 8 16; do
&& [ "$displaymode" != "txtmode" ]; then ifdgbe="descriptors/ich9m/ich9fdgbe_${romsize}m.bin"
continue if [ "${cuttype}" = "${romsize}MiB ICH9 IFD NOR flash" ]; then
if [ ! -f "${ifdgbe}" ]; then
./build descriptors ich9m
fi fi
cbcfg="${boardcfgdir}/config/${initmode}" dd if=${ifdgbe} of=${newrompath} bs=1 count=12k \
cbcfg="${cbcfg}_${displaymode}" conv=notrunc
if [ "${initmode}" = "normal" ]; then fi
cbcfg="${cbcfg%_*}" cmpstr="${romsize}MiB ICH9 IFD NOGBE NOR flash"
ifdgbe="descriptors/ich9m/ich9fdnogbe_${romsize}m.bin"
if [ "${cuttype}" = "${cmpstr}" ]; then
if [ ! -f "${ifdgbe}" ]; then
./build descriptors ich9m
fi
dd if=${ifdgbe} of=${newrompath} bs=1 count=4k \
conv=notrunc
fi fi
mkRoms "${cbcfg}" "${displaymode}" "${initmode}"
done
done done
make distclean -BC "${cbdir}" if [ "${cuttype}" = "i945 laptop" ]; then
} dd if=${newrompath} of=top64k.bin bs=1 \
skip=$(($(stat -c %s ${newrompath}) - 0x10000)) \
# Main ROM building function. This calls all other functions count=64k
mkRoms() dd if=top64k.bin of=${newrompath} bs=1 \
{ seek=$(($(stat -c %s ${newrompath}) - 0x20000)) \
_cbcfg="${1}" count=64k conv=notrunc
displaymode="${2}" rm -f top64k.bin
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 fi
# make coreboot ROM without a payload in it if [ "${microcode_required}" = "n" ]; then
mkCoreboot "${_cbcfg}" _newrom_b="${newrompath%.rom}_nomicrocode.rom"
cp "${newrompath}" "${_newrom_b}" || exit 1
# now add payloads, per user config: microcode_present="y"
"${cbfstool}" "${_newrom_b}" remove -n \
if [ "${displaymode}" = "txtmode" ] \ cpu_microcode_blob.bin || microcode_present="n"
&& [ "${payload_memtest}" = "y" ]; then if [ "${microcode_present}" = "n" ]; then
"${cbfstool}" "${corebootrom}" add-payload \ rm -f "${_newrom_b}" || exit 1
-f memtest86plus/memtest -n img/memtest \ printf "REMARK: '%s' already lacks microcode\n" \
-c lzma || exit 1 ${newrompath}
printf "Renaming default ROM file instead.\n"
mv "${newrompath}" "${_newrom_b}" || exit 1
fi 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 fi
} }
# expected: configs must not specify a payload # expected: configs must not specify a payload
mkCoreboot() mkCoreboot() {
{ cbdir="${1}" # eg. coreboot/default
_cbcfg="${1}" # eg. resources/coreboot/e6400nvidia_4mb/config/normal cbcfgpath="${2}" # eg. resources/coreboot/e6400nvidia_4mb/config/normal
if [ ! -f "${cbcfgpath}" ]; then
if [ ! -f "${_cbcfg}" ]; then
printf "\nmkCoreboot: coreboot config '%s' does not exist. " \ printf "\nmkCoreboot: coreboot config '%s' does not exist. " \
${_cbcfg} ${cbcfgpath}
printf "Skipping build.\n" printf "Skipping build.\n"
return 0 return 0
fi fi
printf "%s-%s\n" "$(cat projectname)" "$(cat version)" \ printf "%s-%s\n" "$(cat projectname)" "$(cat version)" \
> "${cbdir}/.coreboot-version" > "${cbdir}/.coreboot-version"
(
if [ -f "${cbfstool}" ]; then if [ -f "${cbfstool}" ]; then
mv "${cbfstool}" "${cbdir}/cbfstool" mv "${cbfstool}" "${cbdir}/cbfstool"
fi fi
make distclean -BC "${cbdir}"
cd "${cbdir}"
make distclean
cd -
if [ -f "${cbdir}/cbfstool" ]; then if [ -f "${cbdir}/cbfstool" ]; then
mv "${cbdir}/cbfstool" "${cbfstool}" mv "${cbdir}/cbfstool" "${cbfstool}"
fi fi
)
cp "${_cbcfg}" "${cbdir}"/.config cp "${cbcfgpath}" "${cbdir}"/.config
(
make -j$(nproc) -BC "${cbdir}" cd "${cbdir}"
make -j$(nproc)
)
} }
# make a rom in /tmp/ and then print the path of that ROM # make a rom in /tmp/ and then print the path of that ROM
mkSeabiosRom() mkSeabiosRom() {
{
target_cbrom="${1}" # rom to insert seabios in. will not be touched target_cbrom="${1}" # rom to insert seabios in. will not be touched
# (a tmpfile will be made instead) # (a tmpfile will be made instead)
target_seabios_cbfs_path="${2}" # e.g. fallback/payload target_seabios_cbfs_path="${2}" # e.g. fallback/payload
target_initmode="${3}" # e.g. libgfxinit target_opromloadonly="${3}" # TODO: purge (useless setting)
target_initmode="${4}" # e.g. libgfxinit
target_seabioself="payload/seabios/seabios_${target_initmode}.elf" target_seabioself="payload/seabios/seabios_${target_initmode}.elf"
target_seavgabios_rom="payload/seabios/seavgabios.bin" target_seavgabios_rom="payload/seabios/seavgabios.bin"
@@ -519,6 +429,7 @@ mkSeabiosRom()
"${cbfstool}" "${tmprom}" add-payload -f "${target_seabioself}" \ "${cbfstool}" "${tmprom}" add-payload -f "${target_seabioself}" \
-n ${target_seabios_cbfs_path} -c lzma || exit 1 -n ${target_seabios_cbfs_path} -c lzma || exit 1
"${cbfstool}" "${tmprom}" add-int -i 3000 -n etc/ps2-keyboard-spinup \ "${cbfstool}" "${tmprom}" add-int -i 3000 -n etc/ps2-keyboard-spinup \
|| exit 1 || exit 1
@@ -534,6 +445,9 @@ mkSeabiosRom()
"${cbfstool}" "${tmprom}" add-int -i 0 -n etc/optionroms-checksum \ "${cbfstool}" "${tmprom}" add-int -i 0 -n etc/optionroms-checksum \
|| exit 1 || exit 1
"${cbfstool}" "${tmprom}" add-int -i ${target_opromloadonly} \
-n etc/only-load-option-roms || exit 1
if [ "${target_initmode}" = "libgfxinit" ]; then if [ "${target_initmode}" = "libgfxinit" ]; then
"${cbfstool}" "${tmprom}" add -f "${target_seavgabios_rom}" \ "${cbfstool}" "${tmprom}" add -f "${target_seavgabios_rom}" \
-n vgaroms/seavgabios.bin -t raw || exit 1 -n vgaroms/seavgabios.bin -t raw || exit 1
@@ -542,71 +456,37 @@ mkSeabiosRom()
printf "%s\n" "${tmprom}" printf "%s\n" "${tmprom}"
} }
# Make separate ROM images with GRUB payload, for each supported keymap # make a rom in /tmp/ and then print the path of that ROM
mkRomsWithGrub() mkUbootRom() {
{ target_cbrom="${1}" # rom to insert u-boot in. it won't be touched
tmprompath="${1}" # (a tmpfile will be made instead)
initmode="${2}" target_uboot_cbfs_path="${2}" # e.g. fallback/payload
displaymode="${3}" target_uboot_config="${3}"
firstpayloadname="${4}" # allow values: grub, seabios, seabios_withgrub cbfstool_path="${4}"
x=${tmprompath} if [ "${target_uboot_config}" = "default" ]; then
y=${initmode} target_ubdir="payload/u-boot/${board}"
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 else
for keymapname in ${keyboard_layouts}; do target_ubdir="payload/u-boot/${board}/${target_uboot_config}"
keymaps="${keymaps} ${kmapdir}/${keymapname}.gkb"
done
fi
for keymapfile in ${keymaps}; do
if [ ! -f "${keymapfile}" ]; then
continue
fi fi
keymap="${keymapfile##*/}" if [ -f "${target_ubdir}/u-boot.elf" ]; then
keymap="${keymap%.gkb}" target_ubootelf="${target_ubdir}/u-boot.elf"
elif [ -f "${target_ubdir}/u-boot" ]; then
grub_path_in_cbfs="fallback/payload" target_ubootelf="${target_ubdir}/u-boot"
if [ "${firstpayloadname}" != "grub" ]; then
grub_path_in_cbfs="img/grub2"
fi fi
# evil bofh rfc 2646 compliance hack tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
x=${keymap}
y=${tmprompath}
z=${grub_path_in_cbfs}
tmpgrubrom="$(mkGrubRom "${x}" "${y}" "${z}")"
_newrom="${romdir}/${firstpayloadname}_${board}_${initmode}_" cp "${target_cbrom}" "${tmprom}"
if [ "${initmode}" = "normal" ]; then "${cbfstool}" "${tmprom}" add-payload -f "${target_ubootelf}" \
_newrom="${_newrom}${keymap}.rom" -n ${target_uboot_cbfs_path} -c lzma || exit 1
else
_newrom="${_newrom}${displaymode}_${keymap}.rom"
fi
# rom image ready to be flashed: printf "%s\n" "${tmprom}"
moverom "${tmpgrubrom}" "${_newrom}" "${romtype}"
rm -f "${tmpgrubrom}"
done
} }
# make a rom in /tmp/ and then print the path of that ROM # make a rom in /tmp/ and then print the path of that ROM
mkGrubRom() mkGrubRom() {
{
target_keymap="${1}" target_keymap="${1}"
target_cbrom="${2}" target_cbrom="${2}"
target_grubelf_cbfs_path="${3}" # e.g. fallback/payload target_grubelf_cbfs_path="${3}" # e.g. fallback/payload
@@ -616,7 +496,6 @@ mkGrubRom()
grubtestcfg="payload/grub/grub_${target_keymap}_test.cfg" grubtestcfg="payload/grub/grub_${target_keymap}_test.cfg"
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX) || exit 1 tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX) || exit 1
cp "${target_cbrom}" "${tmprom}" || exit 1 cp "${target_cbrom}" "${tmprom}" || exit 1
"${cbfstool}" "${tmprom}" add-payload -f "${grubelf}" \ "${cbfstool}" "${tmprom}" add-payload -f "${grubelf}" \
@@ -645,6 +524,7 @@ mkGrubRom()
"${cbfstool}" "${tmprom}" add -f "${tmpgrubcfg}" -n grub.cfg -t raw \ "${cbfstool}" "${tmprom}" add -f "${tmpgrubcfg}" -n grub.cfg -t raw \
|| exit 1 || exit 1
"${cbfstool}" "${tmprom}" add -f "${tmpgrubtestcfg}" -n grubtest.cfg \ "${cbfstool}" "${tmprom}" add -f "${tmpgrubtestcfg}" -n grubtest.cfg \
-t raw || exit 1 -t raw || exit 1
rm -f "${tmpgrubcfg}" "${tmpgrubtestcfg}" rm -f "${tmpgrubcfg}" "${tmpgrubtestcfg}"
@@ -661,96 +541,180 @@ mkGrubRom()
printf "%s\n" "${tmprom}" printf "%s\n" "${tmprom}"
} }
# make a rom in /tmp/ and then print the path of that ROM # Make separate ROM images with GRUB payload, for each supported keymap
mkUbootRom() mkRomsWithGrub() {
{ tmprompath="${1}"
target_cbrom="${1}" # rom to insert u-boot in. it won't be touched initmode="${2}"
# (a tmpfile will be made instead) displaymode="${3}"
target_uboot_cbfs_path="${2}" # e.g. fallback/payload firstpayloadname="${4}" # allow values: grub, seabios, seabios_withgrub
target_uboot_config="${3}"
cbfstool_path="${4}"
if [ "${target_uboot_config}" = "default" ]; then x=${tmprompath}
target_ubdir="payload/u-boot/${board}" y=${seabios_opromloadonly}
z=${initmode}
if [ "${payload_grub_withseabios}" = "y" ] \
&& [ "${firstpayloadname}" = "grub" ]; then
mv "$(mkSeabiosRom "${x}" "seabios.elf" "${y}" "${z}")" \
"${tmprompath}"
elif [ "${payload_seabios_withgrub}" ] \
&& [ "${firstpayloadname}" != "grub" ]; then
mv "$(mkSeabiosRom "${x}" "fallback/payload" "$y" "$z")" \
"${tmprompath}"
fi
keymaps=""
if [ -z ${keyboard_layouts} ]; then
for kmapfile in "${kmapdir}"/*
do
keymaps="${keymaps} ${kmapfile}"
done
else else
target_ubdir="payload/u-boot/${board}/${target_uboot_config}" for keymapname in ${keyboard_layouts}; do
keymaps="${keymaps} ${kmapdir}/${keymapname}.gkb"
done
fi fi
for keymapfile in ${keymaps}; do
echo "keymaps is $keymaps, keymapfile is $keymapfile"
if [ -f "${target_ubdir}/u-boot.elf" ]; then if [ ! -f "${keymapfile}" ]; 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"
if [ "${blobs_required}" = "n" ]; then
_newrom="${_newrom%.rom}_noblobs.rom"
fi
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
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 continue
fi 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
if [ "${microcode_required}" = "n" ]; then keymap="${keymapfile##*/}"
_newrom_b="${_newrom%.rom}_nomicrocode.rom" keymap="${keymap%.gkb}"
cp "${_newrom}" "${_newrom_b}" || exit 1
microcode_present="y" grub_path_in_cbfs="fallback/payload"
"${cbfstool}" "${_newrom_b}" remove -n \ if [ "${firstpayloadname}" != "grub" ]; then
cpu_microcode_blob.bin || microcode_present="n" grub_path_in_cbfs="img/grub2"
if [ "${microcode_present}" = "n" ]; then
rm -f "${_newrom_b}" || exit 1
printf "REMARK: '%s' already lacks microcode\n" \
${_newrom}
printf "Renaming default ROM file instead.\n"
mv "${_newrom}" "${_newrom_b}" || exit 1
fi fi
# evil bofh rfc 2646 compliance hack
x=${keymap}
y=${tmprompath}
z=${grub_path_in_cbfs}
tmpgrubrom="$(mkGrubRom "${x}" "${y}" "${z}")"
if [ "${initmode}" = "normal" ]; then
newrompath="${romdir}/${firstpayloadname}_${board}_"
newrompath="${newrompath}${initmode}_${keymap}.rom"
else
newrompath="${romdir}/${firstpayloadname}_${board}_"
newrompath="${newrompath}${initmode}_${displaymode}_"
newrompath="${newrompath}${keymap}.rom"
fi
moverom "${tmpgrubrom}" "${newrompath}" "${romtype}"
rm -f "${tmpgrubrom}"
done
}
# Main ROM building function. This calls all other functions
mkRoms() {
cbcfgpath="${1}"
displaymode="${2}"
initmode="${3}"
if [ ! -f "${cbcfgpath}" ]; then
printf "'%s' does not exist. Skipping build for %s %s %s\n" \
${cbcfgpath} ${board} \
${displaymode} ${initmode}
return 0
fi
mkCoreboot "${cbdir}" "${cbcfgpath}"
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=${seabios_opromloadonly}
z=${initmode}
t=$(mkSeabiosRom "$x" "fallback/payload" "$y" "$z")
if [ "${initmode}" = "normal" ]; then
newrompath="${romdir}/seabios_${board}_"
newrompath="${newrompath}${initmode}.rom"
else
newrompath="${romdir}/seabios_${board}_"
newrompath="${newrompath}${initmode}_"
newrompath="${newrompath}${displaymode}.rom"
fi
moverom "${t}" "${newrompath}" "${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
newrompath="${romdir}/uboot_payload_${board}_"
newrompath="${newrompath}${initmode}.rom"
else
newrompath="${romdir}/uboot_payload_${board}_"
newrompath="${newrompath}${initmode}_${displaymode}.rom"
fi
moverom "${tmpubootrom}" "${newrompath}" "${romtype}"
rm -f "${tmpubootrom}"
fi fi
} }
main $@ if [ -z ${displaymodes} ]; then
initmode="libgfxinit"
for displaymode in corebootfb txtmode; do
cbcfgpath="resources/coreboot/${board}/config/${initmode}_"
cbcfgpath="${cbcfgpath}${displaymode}"
mkRoms "${cbcfgpath}" "${displaymode}" "${initmode}"
done
initmode="vgarom"
for displaymode in vesafb txtmode; do
cbcfgpath="resources/coreboot/${board}/config/${initmode}_"
cbcfgpath="${cbcfgpath}${displaymode}"
mkRoms "${cbcfgpath}" "${displaymode}" "${initmode}"
done
initmode="normal"
displaymode="txtmode"
cbcfgpath="resources/coreboot/${board}/config/${initmode}"
mkRoms "${cbcfgpath}" "${displaymode}" "${initmode}"
else
echo "special displaymode defined as $displaymodes"
initmode="libgfxinit"
for displaymode in ${displaymodes}; do
cbcfgpath="resources/coreboot/${board}/config/${initmode}_"
cbcfgpath="${cbcfgpath}${displaymode}"
mkRoms "${cbcfgpath}" "${displaymode}" "${initmode}"
done
initmode="vgarom"
for displaymode in ${displaymodes}; do
cbcfgpath="resources/coreboot/${board}/config/${initmode}_"
cbcfgpath="${cbcfgpath}${displaymode}"
mkRoms "${cbcfgpath}" "${displaymode}" "${initmode}"
done
fi
(
cd "${cbdir}"
make distclean
)