build/boot/roms: use the new coding style

lbmk's new style is inspired by the bsd coding styles:
top-down logic, main simplified to a skeleton showing
overall program structure, variables well-defined,
rigorous (yet deceptively simple) error checking.

this was attempted before, but caused problems; coreboot
wasn't being cleaned properly, and rather than audit it,
i simply reverted this back to the old style.

this is actually attempt number 5, because i made 3 more
attempts between then and this one. i've build-tested this
using "./build boot roms all" (which is what b0rked on
the first attempt, months ago). it should be stable(tm).

the code is much nicer to read / work on now. this is the
beating heart of lbmk. get this script wrong, and you break
all of libreboot.

Signed-off-by: Leah Rowe <leah@libreboot.org>
btrfsvols
Leah Rowe 2023-08-28 09:42:20 +01:00
parent 4623f3f2b2
commit d9292cec6a
1 changed files with 451 additions and 413 deletions

View File

@ -23,10 +23,6 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>. # along with this program. If not, see <http://www.gnu.org/licenses/>.
# #
# This script assumes that the working directory is the root
# of git or release archive
[ "x${DEBUG+set}" = 'xset' ] && set -v [ "x${DEBUG+set}" = 'xset' ] && set -v
set -u -e set -u -e
@ -34,6 +30,8 @@ set -u -e
projectname="$(cat projectname)" projectname="$(cat projectname)"
cfgsdir="resources/coreboot"
blobs_required="" blobs_required=""
microcode_required="" microcode_required=""
@ -43,31 +41,6 @@ kmapdir="resources/grub/keymap"
displaymodes="" displaymodes=""
payloads="" payloads=""
keyboard_layouts="" keyboard_layouts=""
while [ $# -gt 0 ]; do
case ${1} in
-d)
displaymodes="${displaymodes}${2}"
shift ;;
-p)
payloads="${payloads}${2}"
shift ;;
-k)
keyboard_layouts="${keyboard_layouts}${2}"
shift ;;
*)
board=${1} ;;
esac
shift
done
printf "\n\nboard is %s , kb is %s , displaymode is %s , payloads is %s\n" \
${board} ${keyboard_layouts} ${displaymodes} ${payloads} 1>&2
[ -d "resources/coreboot/${board}" ] || \
err "Target not defined: ${board}"
[ -f "resources/coreboot/${board}/target.cfg" ] || \
err "Missing target.cfg for target: ${board}"
grub_scan_disk="undefined" grub_scan_disk="undefined"
tree="undefined" tree="undefined"
@ -83,97 +56,165 @@ payload_seabios_withgrub="n" # i386-coreboot grub from SeaBIOS boot menu
payload_memtest="n" payload_memtest="n"
payload_uboot="n" payload_uboot="n"
uboot_config="undefined" uboot_config="undefined"
# Override the above defaults using target.cfg
. "resources/coreboot/${board}/target.cfg"
[ "${grub_scan_disk}" = "undefined" ] && \ romdir=""
grub_scan_disk="both" cbdir=""
[ "${grub_scan_disk}" != "both" ] && [ "${grub_scan_disk}" != "ata" ] && \ cbfstool=""
[ "${grub_scan_disk}" != "ahci" ] && \ corebootrom=""
grub_scan_disk="both"
[ "${tree}" = "undefined" ] && \
err "Target '${board}' does not define a coreboot tree. Skipping build."
[ "${arch}" = "undefined" ] && \
err "Target '${board}' does not define a CPU type. Skipping build."
[ "${payload_memtest}" != "y" ] && \
payload_memtest="n"
[ "${payload_grub_withseabios}" = "y" ] && \
payload_grub="y"
if [ "${payload_grub_withseabios}" = "y" ]; then
payload_seabios="y"
payload_seabios_withgrub="y"
fi
[ "${payload_seabios_withgrub}" = "y" ] && \
payload_seabios="y"
# 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
[ -e "${configfile}" ] || continue
err "target '${board}' defines no payload"
done
fi
[ "${payload_uboot}" != "n" ] && [ "${payload_uboot}" != "y" ] && \
payload_uboot="n"
[ "${payload_uboot}" = "y" ] && [ "${uboot_config}" = "undefined" ] && \
uboot_config="default"
[ "${microcode_required}" != "n" ] && [ "${microcode_required}" != "y" ] && \
microcode_required="y"
[ "${blobs_required}" != "n" ] && [ "${blobs_required}" != "y" ] && \
blobs_required="y"
# Override all payload directives with cmdline args
if [ ! -z ${payloads} ]; then
echo "setting payloads $payloads"
payload_grub="n"
payload_grub_withseabios="n" # seabios chainloaded from grub
payload_seabios="n"
payload_seabios_withgrub="n" # i386-coreboot grub from SeaBIOS menu
payload_uboot="n"
payload_memtest="n"
for payload in ${payloads} ; do
eval "payload_${payload}=y"
done
fi
romdir="bin/${board}"
cbdir="coreboot/${board}"
[ "${board}" = "${tree}" ] || \
cbdir="coreboot/${tree}"
cbfstool="cbutils/${tree}/cbfstool"
corebootrom="${cbdir}/build/coreboot.rom"
seavgabiosrom="elf/seabios/default/libgfxinit/vgabios.bin" seavgabiosrom="elf/seabios/default/libgfxinit/vgabios.bin"
./build coreboot utils ${tree} || err "cannot build cbutils/${tree}" initmode=""
displaymode=""
cbcfg=""
targetdir=""
if [ ! -f "${seavgabiosrom}" ] \ main()
|| [ ! -f elf/seabios/default/libgfxinit/bios.bin.elf ] \ {
|| [ ! -f elf/seabios/default/vgarom/bios.bin.elf ] \ while [ $# -gt 0 ]; do
|| [ ! -f elf/seabios/default/normal/bios.bin.elf ]; then case ${1} in
[ "${payload_seabios}" != "y" ] || \ -d)
displaymodes="${displaymodes}${2}"
shift ;;
-p)
payloads="${payloads}${2}"
shift ;;
-k)
keyboard_layouts="${keyboard_layouts}${2}"
shift ;;
*)
board=${1} ;;
esac
shift
done
printf "\n\nboard %s, kb %s, displaymode %s, payloads %s\n" \
"${board}" "${keyboard_layouts}" "${displaymodes}" "${payloads}"
configure_target
build_dependencies
build_target
}
configure_target()
{
targetdir="${cfgsdir}/${board}"
[ -d "${targetdir}" ] || \
err "Target not defined: ${board}"
[ -f "${targetdir}/target.cfg" ] || \
err "Missing target.cfg for target: ${board}"
# Override the above defaults using target.cfg
. "${targetdir}/target.cfg"
[ "${grub_scan_disk}" = "undefined" ] && \
grub_scan_disk="both"
[ "${grub_scan_disk}" != "both" ] && \
[ "${grub_scan_disk}" != "ata" ] && \
[ "${grub_scan_disk}" != "ahci" ] && \
grub_scan_disk="both"
[ "${tree}" = "undefined" ] && \
err "Target '${board}' defines no tree. Skipping build."
[ "${arch}" = "undefined" ] && \
err "Target '${board}' defines no arch. Skipping build."
[ "${payload_memtest}" != "y" ] && \
payload_memtest="n"
[ "${payload_grub_withseabios}" = "y" ] && \
payload_grub="y"
if [ "${payload_grub_withseabios}" = "y" ]; then
payload_seabios="y"
payload_seabios_withgrub="y"
fi
[ "${payload_seabios_withgrub}" = "y" ] && \
payload_seabios="y"
# The reverse logic must not be applied. If SeaBIOS-with-GRUB works,
# that doesn't mean GRUB-withSeaBIOS will. For example, the board
# might have a graphics card whose vga rom coreboot doesn't execute
if [ "${payload_grub}" != "y" ] && \
[ "${payload_seabios}" != "y" ] && \
[ "${payload_uboot}" != "y" ]; then
for configfile in "${targetdir}/config/"*; do
[ -e "${configfile}" ] || continue
err "target '${board}' defines no payload"
done
fi
[ "${payload_uboot}" != "n" ] && [ "${payload_uboot}" != "y" ] && \
payload_uboot="n"
[ "${payload_uboot}" = "y" ] && [ "${uboot_config}" = "undefined" ] && \
uboot_config="default"
[ "${microcode_required}" != "n" ] && \
[ "${microcode_required}" != "y" ] && \
microcode_required="y"
[ "${blobs_required}" != "n" ] && [ "${blobs_required}" != "y" ] && \
blobs_required="y"
# Override all payload directives with cmdline args
if [ ! -z ${payloads} ]; then
echo "setting payloads $payloads"
payload_grub="n"
payload_grub_withseabios="n" # seabios chainloaded from grub
payload_seabios="n"
payload_seabios_withgrub="n" # i386-coreboot grub from SeaBIOS
payload_uboot="n"
payload_memtest="n"
for payload in ${payloads} ; do
eval "payload_${payload}=y"
done
fi
}
build_dependencies()
{
romdir="bin/${board}"
cbdir="coreboot/${board}"
[ "${board}" = "${tree}" ] || \
cbdir="coreboot/${tree}"
cbfstool="cbutils/${tree}/cbfstool"
corebootrom="${cbdir}/build/coreboot.rom"
./build coreboot utils ${tree} || err "cannot build cbutils/${tree}"
build_dependency_seabios
memtest_bin="memtest86plus/build${arch#*_}/memtest.bin"
[ "${payload_memtest}" != "y" ] || [ -f "${memtest_bin}" ] || \
./handle make file -b ${memtest_bin%/*} || \
err "cannot build memtest86+"
[ -d "${romdir}/" ] || mkdir -p "${romdir}/" || \
err "cannot create rom directory: \"${romdir}\""
rm -f "${romdir}"/* || err "cannot: rm -f \"${romdir}\"/*"
build_dependency_grub
build_dependency_uboot
}
build_dependency_seabios()
{
[ "${payload_seabios}" = "y" ] || return 0
if [ ! -f "${seavgabiosrom}" ] \
|| [ ! -f elf/seabios/default/libgfxinit/bios.bin.elf ] \
|| [ ! -f elf/seabios/default/vgarom/bios.bin.elf ] \
|| [ ! -f elf/seabios/default/normal/bios.bin.elf ]; then
./handle make config -b seabios || \ ./handle make config -b seabios || \
err "cannot build seabios" err "cannot build seabios"
fi fi
}
memtest_bin="memtest86plus/build${arch#*_}/memtest.bin" build_dependency_grub()
[ "${payload_memtest}" != "y" ] || [ -f "${memtest_bin}" ] || \ {
./handle make file -b ${memtest_bin%/*} || \ [ "${payload_grub}" != "y" ] && \
err "cannot build memtest86+" [ "${payload_seabios_withgrub}" != "y" ] && return 0
[ -d "${romdir}/" ] || mkdir -p "${romdir}/" || \
err "cannot create rom directory: \"${romdir}\""
rm -f "${romdir}"/* || err "cannot: rm -f \"${romdir}\"/*"
if [ "${payload_grub}" = "y" ] || \
[ "${payload_seabios_withgrub}" = "y" ]; then
if [ -f "elf/grub/grub_usqwerty.cfg" ]; then if [ -f "elf/grub/grub_usqwerty.cfg" ]; then
sha1sumcmd="sha1sum resources/grub/config/grub.cfg" sha1sumcmd="sha1sum resources/grub/config/grub.cfg"
grubrefchecksum="$(${sha1sumcmd} | awk '{print $1}')" grubrefchecksum="$(${sha1sumcmd} | awk '{print $1}')"
@ -181,13 +222,10 @@ if [ "${payload_grub}" = "y" ] || \
sha1sumcmd="sha1sum elf/grub/grub_usqwerty.cfg" sha1sumcmd="sha1sum elf/grub/grub_usqwerty.cfg"
grubbuildchecksum="$(${sha1sumcmd} | awk '{print $1}')" grubbuildchecksum="$(${sha1sumcmd} | awk '{print $1}')"
if [ "${grubrefchecksum}" != "${grubbuildchecksum}" ]; then [ "${grubrefchecksum}" != "${grubbuildchecksum}" ] && \
printf "Changes detected to GRUB. Re-building now.\n" \ printf "GRUB change detected. Re-building.\n" 1>&2
1>&2
fi
else else
printf "Required GRUB payloads not yet built. Building now.\n" \ printf "GRUB not built yet. Building now.\n" 1>&2
1>&2
fi fi
for keymapfile in "${kmapdir}"/*; do for keymapfile in "${kmapdir}"/*; do
[ -f "${keymapfile}" ] || continue [ -f "${keymapfile}" ] || continue
@ -201,173 +239,176 @@ if [ "${payload_grub}" = "y" ] || \
if [ ! -f "${grubelf}" ] || [ ! -f "${grubcfg}" ] || \ if [ ! -f "${grubelf}" ] || [ ! -f "${grubcfg}" ] || \
[ ! -f "${grubtestcfg}" ]; then [ ! -f "${grubtestcfg}" ]; then
./build grub payload || err "cannot build grub payload" ./build grub payload || \
err "cannot build grub payload"
fi fi
done done
fi }
build_dependency_uboot()
{
[ "${payload_uboot}" = "y" ] || return 0
if [ "${payload_uboot}" = "y" ]; then
./handle make config -b u-boot ${board} || \ ./handle make config -b u-boot ${board} || \
err "cannot build u-boot target: ${board}" err "cannot build u-boot target: ${board}"
ubdir="elf/u-boot/${board}/${uboot_config}" ubdir="elf/u-boot/${board}/${uboot_config}"
ubootelf="${ubdir}/u-boot.elf" ubootelf="${ubdir}/u-boot.elf"
[ ! -f "${ubootelf}" ] && [ -f "${ubdir}/u-boot.bin" ] && \ [ ! -f "${ubootelf}" ] && [ -f "${ubdir}/u-boot.bin" ] && \
ubootelf="${ubdir}/u-boot.bin" ubootelf="${ubdir}/u-boot.bin"
[ -f "${ubootelf}" ] || \ if [ ! -f "${ubootelf}" ]; then
err "Could not find u-boot build for board, ${board}" err "Could not find u-boot build for board, ${board}"
fi
# 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"
newrompath="$2"
cuttype="$3"
[ "${blobs_required}" = "n" ] && \
newrompath="${newrompath%.rom}_noblobs.rom"
printf "\nCreating new ROM image: %s\n" "${newrompath}"
if [ "${cuttype}" = "4MiB IFD BIOS region" ]; then
dd if="${rompath}" of="${newrompath}" bs=1 \
skip=$(($(stat -c %s "${rompath}") - 0x400000)) \
count=4194304 || err "moverom: cannot cut 4MB section"
else
cp "${rompath}" "${newrompath}" || err "moverom: can't copy rom"
fi fi
}
# pike2008 cards cause a system hang when loading option roms in seabios build_target()
# if there is an empty option rom in cbfs, no option rom will be loaded {
if [ "${cuttype}" = "d8d16sas" ]; then for x in "normal" "vgarom" "libgfxinit"; do
emptyrom=$(mktemp -t coreboot_rom.XXXXXXXXXX) initmode="${x}"
rm -f "${emptyrom}" || err "cannot remove fake oprom" hmode="vesafb"
touch "${emptyrom}" || err "cannot create fake oprom" [ "${initmode}" = "vgarom" ] || hmode="corebootfb"
for deviceID in "0072" "3050"; do modes="${hmode} txtmode"
"${cbfstool}" "${newrompath}" add -f "${emptyrom}" \ [ -z ${displaymodes} ] || modes="${displaymodes}"
-n "pci1000,${deviceID}.rom" -t raw || \ for y in ${modes}; do
err "moverom: cannot insert fake pike2008 rom" displaymode="${y}"
[ "${initmode}" = "normal" ] && \
[ "$displaymode" != "txtmode" ] && continue
cbcfg="${targetdir}/config/${initmode}_${displaymode}"
[ "${initmode}" = "normal" ] && cbcfg="${cbcfg%_*}"
build_roms "${cbcfg}" "${displaymode}" "${initmode}"
done done
rm -f "${emptyrom}" || err "moverom: cannot remove pike2008 rom"
fi
for romsize in 4 8 16; do
ifdgbe="descriptors/ich9m/ich9fdgbe_${romsize}m.bin"
if [ "${cuttype}" = "${romsize}MiB ICH9 IFD NOR flash" ]; then
[ -f "${ifdgbe}" ] || \
./build descriptors ich9m || \
err "moverom: cannot create ich9m ifd"
dd if="${ifdgbe}" of="${newrompath}" bs=1 count=12k \
conv=notrunc || err "moverom: cant insert ich9m ifd"
fi
cmpstr="${romsize}MiB ICH9 IFD NOGBE NOR flash"
ifdgbe="descriptors/ich9m/ich9fdnogbe_${romsize}m.bin"
if [ "${cuttype}" = "${cmpstr}" ]; then
[ -f "${ifdgbe}" ] || \
./build descriptors ich9m || \
err "moverom: cannot create ich9m ifd"
dd if="${ifdgbe}" of="${newrompath}" bs=1 count=4k \
conv=notrunc || err "moverom: cant insert ich9m ifd"
fi
done done
}
if [ "${cuttype}" = "i945 laptop" ]; then # Main ROM building function. This calls all other functions below
dd if="${newrompath}" of=top64k.bin bs=1 \ build_roms()
skip=$(($(stat -c %s "${newrompath}") - 0x10000)) \ {
count=64k || \ cbcfg="${1}"
err "moverom: cannot copy boot block from i945 rom" displaymode="${2}"
dd if=top64k.bin of="${newrompath}" bs=1 \ initmode="${3}"
seek=$(($(stat -c %s "${newrompath}") - 0x20000)) \
count=64k conv=notrunc || \ [ ! -f "${cbcfg}" ] && \
err "moverom: cannot copy boot block into i945 rom" printf "'%s' does not exist. Skipping build for %s %s %s\n" \
rm -f top64k.bin || err "moverom: can't remove top64k.bin" "${cbcfg}" "${board}" "${displaymode}" "${initmode}" \
1>&2 && return 0
./handle make config -b coreboot ${board} || \
err "build_roms: cannot build coreboot for target: ${board}"
_corebootrom="elf/coreboot/${board}/${initmode}_${displaymode}"
[ "${initmode}" = "normal" ] && \
_corebootrom="${_corebootrom%_${displaymode}}"
_corebootrom="${_corebootrom}/coreboot.rom"
corebootrom="$(mktemp -t coreboot_rom.XXXXXXXXXX)"
cp "${_corebootrom}" "${corebootrom}" || \
err "build_roms: cannot copy rom"
[ "${payload_memtest}" != "y" ] || \
"${cbfstool}" "${corebootrom}" add-payload \
-f "${memtest_bin}" -n img/memtest -c lzma || \
err "build_roms: cannot add img/memtest to coreboot rom"
[ "${payload_seabios}" = "y" ] && \
build_seabios_roms
[ "${payload_grub}" != "y" ] || \
build_grub_roms "${corebootrom}" "${initmode}" \
"${displaymode}" "grub" || \
err "build_roms: build_grub_roms failed"
if [ "${payload_uboot}" = "y" ]; then
build_uboot_roms
fi fi
}
if [ "${microcode_required}" = "n" ]; then build_seabios_roms()
_newrom_b="${newrompath%.rom}_nomicrocode.rom" {
cp "${newrompath}" "${_newrom_b}" || \ if [ "${payload_seabios_withgrub}" = "y" ]; then
err "moverom: cp \"${newrompath}\" \"${_newrom_b}\"" tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
microcode_present="y" cp "${corebootrom}" "${tmprom}"
"${cbfstool}" "${_newrom_b}" remove -n \ build_grub_roms "${tmprom}" "${initmode}" \
cpu_microcode_blob.bin || microcode_present="n" "${displaymode}" "seabios_withgrub" || \
if [ "${microcode_present}" = "n" ]; then err "build_roms: cannot build grub roms, seabios w/grub"
rm -f "${_newrom_b}" || err "cannot remove ${_newrom_b}" rm -f "${tmprom}" || err "build_roms: can't remove tmprom"
printf "REMARK: '%s' already lacks microcode\n" \ else
"${newrompath}" x=${corebootrom}
printf "Renaming default ROM file instead.\n" y=${initmode}
mv "${newrompath}" "${_newrom_b}" || \ t=$(mkSeabiosRom "$x" "fallback/payload" "$y")
err "moverom: mv \"${newrompath}\" \"${_newrom_b}\"" 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 fi
moverom "${t}" "${newrompath}" "${romtype}" || \
err "build_roms: cannot copy rom"
rm -f "${t}" || err "cannot rm ${t}"
fi fi
} }
# make a rom in /tmp/ and then print the path of that ROM # Make separate ROM images with GRUB payload, for each supported keymap
mkSeabiosRom() { build_grub_roms() {
target_cbrom="${1}" # rom to insert seabios in. will not be touched tmprompath="${1}"
# (a tmpfile will be made instead) initmode="${2}"
target_seabios_cbfs_path="${2}" # e.g. fallback/payload displaymode="${3}"
target_initmode="${3}" # e.g. libgfxinit firstpayloadname="${4}" # allow values: grub, seabios, seabios_withgrub
target_seabioself="elf/seabios/default/${target_initmode}/bios.bin.elf" x=${tmprompath}
y=${initmode}
if [ "${payload_grub_withseabios}" = "y" ] && \
[ "${firstpayloadname}" = "grub" ]; then
mv "$(mkSeabiosRom "${x}" "seabios.elf" "${y}")" "${tmprompath}"
elif [ "${payload_seabios_withgrub}" ] && \
[ "${firstpayloadname}" != "grub" ]; then
mv "$(mkSeabiosRom "${x}" "fallback/payload" "$y")" \
"${tmprompath}" || \
err "build_grub_roms: cannot move SeaBIOS ROM to tmprom"
fi
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX) keymaps=""
if [ -z ${keyboard_layouts} ]; then
for kmapfile in "${kmapdir}"/*; do
keymaps="${keymaps} ${kmapfile}"
done
else
for keymapname in ${keyboard_layouts}; do
keymaps="${keymaps} ${kmapdir}/${keymapname}.gkb"
done
fi
for keymapfile in ${keymaps}; do
echo "keymaps is $keymaps, keymapfile is $keymapfile"
cp "${target_cbrom}" "${tmprom}" || \ [ -f "${keymapfile}" ] || continue
err "mkSeabiosRom: cannot copy to tmprom"
"${cbfstool}" "${tmprom}" add-payload -f "${target_seabioself}" \ keymap="${keymapfile##*/}"
-n ${target_seabios_cbfs_path} -c lzma || \ keymap="${keymap%.gkb}"
err "mkSeabiosRom: can't add payload, ${target_seabioself}, to rom"
"${cbfstool}" "${tmprom}" add-int -i 3000 -n etc/ps2-keyboard-spinup \ grub_path_in_cbfs="fallback/payload"
|| err "mkSeabiosRom: cbfs add-int etc/ps2-keyboard-spinup 3000" [ "${firstpayloadname}" = "grub" ] || \
grub_path_in_cbfs="img/grub2"
if [ "${target_initmode}" = "normal" ] || \ # evil bofh rfc 2646 compliance hack
[ "${target_initmode}" = "libgfxinit" ]; then x=${keymap}
"${cbfstool}" "${tmprom}" add-int -i 2 \ y=${tmprompath}
-n etc/pci-optionrom-exec || \ z=${grub_path_in_cbfs}
err "mkSeabiosRom: cbfs add-int etc/pci-optionrom-exec 2"
elif [ "${target_initmode}" = "vgarom" ]; then # coreboot executes it
"${cbfstool}" "${tmprom}" add-int -i 0 \
-n etc/pci-optionrom-exec || \
err "mkSeabiosRom: cbfs add-int etc/pci-optionrom-exec 0"
fi # for undefined modes, don't add this integer. use SeaBIOS defaults
"${cbfstool}" "${tmprom}" add-int -i 0 -n etc/optionroms-checksum || \ tmpgrubrom="$(mkGrubRom "${x}" "${y}" "${z}")"
err "mkSeabiosRom: cbfs add-int etc/optionroms-checksum 0"
[ "${target_initmode}" != "libgfxinit" ] || \ if [ "${initmode}" = "normal" ]; then
"${cbfstool}" "${tmprom}" add -f "${seavgabiosrom}" \ newrompath="${romdir}/${firstpayloadname}_${board}_"
-n vgaroms/seavgabios.bin -t raw || \ newrompath="${newrompath}${initmode}_${keymap}.rom"
err "mkSeabiosRom: cbfs add-raw vgaroms/seavgabios.bin" else
newrompath="${romdir}/${firstpayloadname}_${board}_"
printf "%s\n" "${tmprom}" newrompath="${newrompath}${initmode}_${displaymode}_"
} newrompath="${newrompath}${keymap}.rom"
fi
# make a rom in /tmp/ and then print the path of that ROM moverom "${tmpgrubrom}" "${newrompath}" "${romtype}" || \
mkUbootRom() { err "build_grub_roms, moverom"
target_cbrom="${1}" # rom to insert u-boot in. it won't be touched rm -f "${tmpgrubrom}" || err "rm tmpgrubrom, build_grub_roms"
# (a tmpfile will be made instead) done
target_uboot_cbfs_path="${2}" # e.g. fallback/payload
target_uboot_config="${3}"
cbfstool_path="${4}"
target_ubdir="elf/u-boot/${board}/${target_uboot_config}"
target_ubootelf="${target_ubdir}/u-boot.elf"
[ -f "${target_ubootelf}" ] || \
target_ubootelf="${target_ubdir}/u-boot.bin"
[ -f "${target_ubootelf}" ] || \
err "mkUbootRom: cant find u-boot build for board, ${board}"
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
cp "${target_cbrom}" "${tmprom}" || \
err "mkUbootRom: cannot copy to tmprom"
"${cbfstool}" "${tmprom}" add-payload -f "${target_ubootelf}" \
-n ${target_uboot_cbfs_path} -c lzma || \
err "mkUbootRom: cannot add u-boot to tmprom"
printf "%s\n" "${tmprom}"
} }
# 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
@ -433,181 +474,178 @@ mkGrubRom() {
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() { mkSeabiosRom() {
tmprompath="${1}" target_cbrom="${1}" # rom to insert seabios in. will not be touched
initmode="${2}" # (a tmpfile will be made instead)
displaymode="${3}" target_seabios_cbfs_path="${2}" # e.g. fallback/payload
firstpayloadname="${4}" # allow values: grub, seabios, seabios_withgrub target_initmode="${3}" # e.g. libgfxinit
x=${tmprompath} target_seabioself="elf/seabios/default/${target_initmode}/bios.bin.elf"
y=${initmode}
if [ "${payload_grub_withseabios}" = "y" ] && \
[ "${firstpayloadname}" = "grub" ]; then
mv "$(mkSeabiosRom "${x}" "seabios.elf" "${y}")" "${tmprompath}"
elif [ "${payload_seabios_withgrub}" ] && \
[ "${firstpayloadname}" != "grub" ]; then
mv "$(mkSeabiosRom "${x}" "fallback/payload" "$y")" \
"${tmprompath}" || \
err "mkRomsWithGrub: cannot move SeaBIOS ROM to tmprom"
fi
keymaps="" tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
if [ -z ${keyboard_layouts} ]; then
for kmapfile in "${kmapdir}"/*; do
keymaps="${keymaps} ${kmapfile}"
done
else
for keymapname in ${keyboard_layouts}; do
keymaps="${keymaps} ${kmapdir}/${keymapname}.gkb"
done
fi
for keymapfile in ${keymaps}; do
echo "keymaps is $keymaps, keymapfile is $keymapfile"
[ -f "${keymapfile}" ] || continue cp "${target_cbrom}" "${tmprom}" || \
err "mkSeabiosRom: cannot copy to tmprom"
keymap="${keymapfile##*/}" "${cbfstool}" "${tmprom}" add-payload -f "${target_seabioself}" \
keymap="${keymap%.gkb}" -n ${target_seabios_cbfs_path} -c lzma || \
err "mkSeabiosRom: can't add payload, ${target_seabioself}, to rom"
grub_path_in_cbfs="fallback/payload" "${cbfstool}" "${tmprom}" add-int -i 3000 -n etc/ps2-keyboard-spinup \
[ "${firstpayloadname}" = "grub" ] || \ || err "mkSeabiosRom: cbfs add-int etc/ps2-keyboard-spinup 3000"
grub_path_in_cbfs="img/grub2"
# evil bofh rfc 2646 compliance hack if [ "${target_initmode}" = "normal" ] || \
x=${keymap} [ "${target_initmode}" = "libgfxinit" ]; then
y=${tmprompath} "${cbfstool}" "${tmprom}" add-int -i 2 \
z=${grub_path_in_cbfs} -n etc/pci-optionrom-exec || \
err "mkSeabiosRom: cbfs add-int etc/pci-optionrom-exec 2"
elif [ "${target_initmode}" = "vgarom" ]; then # coreboot executes it
"${cbfstool}" "${tmprom}" add-int -i 0 \
-n etc/pci-optionrom-exec || \
err "mkSeabiosRom: cbfs add-int etc/pci-optionrom-exec 0"
fi # for undefined modes, don't add this integer. use SeaBIOS defaults
tmpgrubrom="$(mkGrubRom "${x}" "${y}" "${z}")" "${cbfstool}" "${tmprom}" add-int -i 0 -n etc/optionroms-checksum || \
err "mkSeabiosRom: cbfs add-int etc/optionroms-checksum 0"
if [ "${initmode}" = "normal" ]; then [ "${target_initmode}" != "libgfxinit" ] || \
newrompath="${romdir}/${firstpayloadname}_${board}_" "${cbfstool}" "${tmprom}" add -f "${seavgabiosrom}" \
newrompath="${newrompath}${initmode}_${keymap}.rom" -n vgaroms/seavgabios.bin -t raw || \
else err "mkSeabiosRom: cbfs add-raw vgaroms/seavgabios.bin"
newrompath="${romdir}/${firstpayloadname}_${board}_"
newrompath="${newrompath}${initmode}_${displaymode}_" printf "%s\n" "${tmprom}"
newrompath="${newrompath}${keymap}.rom"
fi
moverom "${tmpgrubrom}" "${newrompath}" "${romtype}" || \
err "mkRomsWithGrub, moverom"
rm -f "${tmpgrubrom}" || err "rm tmpgrubrom, mkRomsWithGrub"
done
} }
# Main ROM building function. This calls all other functions build_uboot_roms()
mkRoms()
{ {
cbcfgpath="${1}" x=${corebootrom}
displaymode="${2}" y=${uboot_config}
initmode="${3}" z=${cbfstool}
tmprom="$(mkUbootRom "$x" "fallback/payload" "$y" "$z")"
if [ ! -f "${cbcfgpath}" ]; then newrompath= \
printf "'%s' does not exist. Skipping build for %s %s %s\n" \ "${romdir}/uboot_payload_${board}_${initmode}_${displaymode}.rom"
"${cbcfgpath}" "${board}" "${displaymode}" "${initmode}" \
1>&2
return 0
fi
./handle make config -b coreboot ${board} || \
err "mkRoms: cannot build coreboot for target: ${board}"
_corebootrom="elf/coreboot/${board}/${initmode}_${displaymode}"
[ "${initmode}" = "normal" ] && \ [ "${initmode}" = "normal" ] && \
_corebootrom="${_corebootrom%_${displaymode}}" newrompath="${romdir}/uboot_payload_${board}_${initmode}.rom"
_corebootrom="${_corebootrom}/coreboot.rom" moverom "${tmprom}" "${newrompath}" "${romtype}" || \
corebootrom="$(mktemp -t coreboot_rom.XXXXXXXXXX)" err "build_roms: moverom fail (u-boot)"
cp "${_corebootrom}" "${corebootrom}" || err "mkRoms: cannot copy rom" rm -f "${tmprom}" || \
err "build_roms: cannot rm u-boot rom"
}
if [ "${payload_memtest}" = "y" ]; then # make a rom in /tmp/ and then print the path of that ROM
"${cbfstool}" "${corebootrom}" add-payload \ mkUbootRom() {
-f "${memtest_bin}" -n img/memtest -c lzma || \ target_cbrom="${1}" # rom to insert u-boot in. it won't be touched
err "mkRoms: cannot add img/memtest to coreboot rom" # (a tmpfile will be made instead)
target_uboot_cbfs_path="${2}" # e.g. fallback/payload
target_uboot_config="${3}"
cbfstool_path="${4}"
target_ubdir="elf/u-boot/${board}/${target_uboot_config}"
target_ubootelf="${target_ubdir}/u-boot.elf"
[ -f "${target_ubootelf}" ] || \
target_ubootelf="${target_ubdir}/u-boot.bin"
[ -f "${target_ubootelf}" ] || \
err "mkUbootRom: ${board}: cant find u-boot build"
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
cp "${target_cbrom}" "${tmprom}" || \
err "mkUbootRom: cannot copy to tmprom"
"${cbfstool}" "${tmprom}" add-payload -f "${target_ubootelf}" \
-n ${target_uboot_cbfs_path} -c lzma || \
err "mkUbootRom: cannot add u-boot to tmprom"
printf "%s\n" "${tmprom}"
}
# it is assumed that no other work will be done on the ROM
# after calling this function. therefore this function is "final"
moverom() {
rompath="$1"
newrompath="$2"
cuttype="$3"
[ "${blobs_required}" = "n" ] && \
newrompath="${newrompath%.rom}_noblobs.rom"
printf "\nCreating new ROM image: %s\n" "${newrompath}"
if [ "${cuttype}" = "4MiB IFD BIOS region" ]; then
dd if="${rompath}" of="${newrompath}" bs=1 \
skip=$(($(stat -c %s "${rompath}") - 0x400000)) \
count=4194304 || err "moverom: cannot cut 4MB section"
else
cp "${rompath}" "${newrompath}" || \
err "moverom: can't copy rom"
fi fi
if [ "${payload_seabios}" = "y" ]; then # pike2008 cards cause a system hang when loading option roms in seabios
if [ "${payload_seabios_withgrub}" = "n" ]; then # if there is an empty option rom in cbfs, no option rom will be loaded
x=${corebootrom} if [ "${cuttype}" = "d8d16sas" ]; then
y=${initmode} emptyrom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
t=$(mkSeabiosRom "$x" "fallback/payload" "$y") rm -f "${emptyrom}" || err "cannot remove fake oprom"
if [ "${initmode}" = "normal" ]; then touch "${emptyrom}" || err "cannot create fake oprom"
newrompath="${romdir}/seabios_${board}_" for deviceID in "0072" "3050"; do
newrompath="${newrompath}${initmode}.rom" "${cbfstool}" "${newrompath}" add -f "${emptyrom}" \
else -n "pci1000,${deviceID}.rom" -t raw || \
newrompath="${romdir}/seabios_${board}_" err "moverom: cannot insert fake pike2008 rom"
newrompath="${newrompath}${initmode}_" done
newrompath="${newrompath}${displaymode}.rom" rm -f "${emptyrom}" || \
fi err "moverom: cannot remove pike2008 rom"
moverom "${t}" "${newrompath}" "${romtype}" || \
err "mkRoms: cannot copy rom"
rm -f "${t}" || err "cannot rm ${t}"
else
tmprom=$(mktemp -t coreboot_rom.XXXXXXXXXX)
cp "${corebootrom}" "${tmprom}"
mkRomsWithGrub "${tmprom}" "${initmode}" \
"${displaymode}" "seabios_withgrub" || \
err "mkRoms: cannot build grub roms, seabios w/grub"
rm -f "${tmprom}" || err "mkRoms: can't remove tmprom"
fi
fi fi
[ "${payload_grub}" != "y" ] || \ for romsize in 4 8 16; do
mkRomsWithGrub "${corebootrom}" "${initmode}" \ ifdgbe="descriptors/ich9m/ich9fdgbe_${romsize}m.bin"
"${displaymode}" "grub" || \ if [ "${cuttype}" = "${romsize}MiB ICH9 IFD NOR flash" ]; then
err "mkRoms: mkRomsWithGrub failed" [ -f "${ifdgbe}" ] || \
./build descriptors ich9m || \
if [ "${payload_uboot}" = "y" ]; then err "moverom: cannot create ich9m ifd"
x=${corebootrom} dd if="${ifdgbe}" of="${newrompath}" bs=1 count=12k \
y=${uboot_config} conv=notrunc || \
z=${cbfstool} err "moverom: cant insert ich9m ifd"
tmpubootrom="$(mkUbootRom "$x" "fallback/payload" "$y" "$z")" fi
if [ "${initmode}" = "normal" ]; then cmpstr="${romsize}MiB ICH9 IFD NOGBE NOR flash"
newrompath="${romdir}/uboot_payload_${board}_" ifdgbe="descriptors/ich9m/ich9fdnogbe_${romsize}m.bin"
newrompath="${newrompath}${initmode}.rom" if [ "${cuttype}" = "${cmpstr}" ]; then
else [ -f "${ifdgbe}" ] || \
newrompath="${romdir}/uboot_payload_${board}_" ./build descriptors ich9m || \
newrompath="${newrompath}${initmode}_${displaymode}.rom" err "moverom: cannot create ich9m ifd"
dd if="${ifdgbe}" of="${newrompath}" bs=1 count=4k \
conv=notrunc || \
err "moverom: cant insert ich9m ifd"
fi
done
if [ "${cuttype}" = "i945 laptop" ]; then
dd if="${newrompath}" of=top64k.bin bs=1 \
skip=$(($(stat -c %s "${newrompath}") - 0x10000)) \
count=64k || \
err "moverom: cannot copy boot block from i945 rom"
dd if=top64k.bin of="${newrompath}" bs=1 \
seek=$(($(stat -c %s "${newrompath}") - 0x20000)) \
count=64k conv=notrunc || \
err "moverom: cannot copy boot block into i945 rom"
rm -f top64k.bin || err "moverom: can't remove top64k.bin"
fi
if [ "${microcode_required}" = "n" ]; then
_newrom_b="${newrompath%.rom}_nomicrocode.rom"
cp "${newrompath}" "${_newrom_b}" || \
err "moverom: cp \"${newrompath}\" \"${_newrom_b}\""
microcode_present="y"
"${cbfstool}" "${_newrom_b}" remove -n \
cpu_microcode_blob.bin || microcode_present="n"
if [ "${microcode_present}" = "n" ]; then
rm -f "${_newrom_b}" || \
err "cannot remove ${_newrom_b}"
printf "REMARK: '%s' already lacks microcode\n" \
"${newrompath}"
printf "Renaming default ROM file instead.\n"
mv "${newrompath}" "${_newrom_b}" || \
err "moverom: mv \"${newrompath}\" \"${_newrom_b}\""
fi fi
moverom "${tmpubootrom}" "${newrompath}" "${romtype}" || \
err "mkRoms: moverom fail (u-boot)"
rm -f "${tmpubootrom}" || err "mkRoms: cannot rm u-boot rom"
fi fi
} }
if [ -z ${displaymodes} ]; then main $@
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