tree 1d15fa6c36e1e61ef3a918248c3f72905741a00d
parent d5c177c9a50cc71f4f32a26723931883175c90ab
author Aseda Aboagye <aaboagye@google.com> 1717817873 +0000
committer Felix Held <felix-coreboot@felixheld.de> 1718988402 +0000

ec/google/chromeec: Update ec_cmd_api.h and ec_commands.h

Generated using update_ec_headers.sh [EC-DIR].

The original include/ec_commands.h version in the EC repo is:
  d0771e49e7 MKBP: Increase key matrix size
The original include/ec_cmd_api.h version in the EC repo is:
  d0771e49e7 MKBP: Increase key matrix size

Change-Id: I4f3dfc3f145e50e6114894352cdc118ad5a9565b
Signed-off-by: Aseda Aboagye <aaboagye@google.com>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/82995
Reviewed-by: Caveh Jalali <caveh@chromium.org>
Reviewed-by: Forest Mittelberg <bmbm@google.com>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
