tree f9263a220761a15ed5d83b70cc94884d8f4a33ff
parent ea49357e90441eaef30cb1cd3c80ca409eeb72ca
author Cliff Huang <cliff.huang@intel.com> 1677709841 -0800
committer Felix Held <felix-coreboot@felixheld.de> 1684323030 +0000

acpi: Warn on timeout in write_delay_until()

Make ACPI code print a debug warning message when a timeout is
detected in a loop waiting for a condition.

This timeout message won't be displayed when this function is used as
delay loop (ie. without checking variable condition).

The following is required to get this log in kernel log buffer:

    echo 1 > /sys/module/acpi/parameters/aml_debug_output

Here is an example of generated code when waiting for variable L23E to
be 0.

    Local7 = 0x08
    While ((Local7 > Zero))
    {
        If ((L23E == Zero))
        {
            Break
        }

        Sleep (0x10)
        Local7--
        If ((Local7 == Zero))
        {
            Debug = "WARN: Wait loop timeout for variable L23E"
        }
    }

BRANCH=firmware-brya-14505.B
TEST=Boot to OS and check that the Debug print is added to the
     function.

Change-Id: I3843e51988527e99822017d1b5f653ff2eaa7958
Signed-off-by: Cliff Huang <cliff.huang@intel.com>
Signed-off-by: Jeremy Compostella <jeremy.compostella@intel.com>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/73348
Reviewed-by: Nico Huber <nico.h@gmx.de>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: Lean Sheng Tan <sheng.tan@9elements.com>
