tree 0676546e88c4b1d17ff97d14fd579e721d0cd566
parent dd63418f81771b8686f8a14faff10fb8a593b6d2
author Alper Nebi Yasak <alpernebiyasak@gmail.com> 1707292979 +0300
committer Matt DeVillier <matt.devillier@gmail.com> 1709065338 +0000

mb/qemu/fw_cfg: Use fw_cfg_read() to read SMBIOS data

The QEMU firmware configuration driver can help initialize SMBIOS tables
using the table data that QEMU provides over the device. While doing so,
it reads from the device "file" manually using port-based IO.

Use the fw_cfg_read() helper function to read the SMBIOS-related file,
so that the driver is easier to port the driver to other architectures.

Change-Id: I18e60b8e9de34f2b0ff67af4113beec1d7467329
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/80367
Reviewed-by: Nico Huber <nico.h@gmx.de>
Reviewed-by: Martin L Roth <gaumless@gmail.com>
Reviewed-by: Matt DeVillier <matt.devillier@gmail.com>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
