diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..06e4985
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,96 @@
+---
+AccessModifierOffset: -4
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Left
+AlignOperands: true
+AlignTrailingComments: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: false
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterClass: false
+  AfterControlStatement: false
+  AfterEnum: false
+  AfterFunction: true
+  AfterNamespace: true
+  AfterObjCDeclaration: false
+  AfterStruct: false
+  AfterUnion: false
+  AfterExternBlock: false
+  BeforeCatch: false
+  BeforeElse: false
+  IndentBraces: false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Custom
+BreakBeforeInheritanceComma: false
+BreakBeforeTernaryOperators: false
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeComma
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: false
+ColumnLimit: 80
+CommentPragmas: '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 8
+ContinuationIndentWidth: 8
+Cpp11BracedListStyle: false
+DerivePointerAlignment: false
+DisableFormat: false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: false
+
+IncludeIsMainRegex: '(Test)?$'
+IndentCaseLabels: false
+IndentGotoLabels: false
+IndentPPDirectives: None
+IndentWidth: 8
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd: ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 8
+ObjCSpaceAfterProperty: true
+ObjCSpaceBeforeProtocolList: true
+
+PointerAlignment: Right
+ReflowComments: false
+SortIncludes: true
+SortUsingDeclarations: false
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatementsExceptForEachMacros
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles: false
+SpacesInContainerLiterals: false
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard: Cpp03
+TabWidth: 8
+UseTab: Always
+...
diff --git a/.gitignore b/.gitignore
index 3c5d464..c5c5786 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,16 +1,91 @@
-# Ignore miscellaneous files
-cscope.*
-*.swp
-*.patch
-*~
-.project
-.cproject
+### C ###
+# Prerequisites
+*.d
+build/
+unity
 
-# Ctags
-tags
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
 
-# common python virtual environment directories
-.env/
-env/
-.venv/
-venv/
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Kernel Module Compile Results
+*.mod*
+*.cmd
+.tmp_versions/
+modules.order
+Module.symvers
+Mkfile.old
+dkms.conf
+
+### C++ ###
+# Prerequisites
+
+# Compiled Object files
+*.slo
+
+# Precompiled Headers
+
+# Compiled Dynamic libraries
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+
+# Executables
+
+### CMake ###
+CMakeLists.txt.user
+CMakeCache.txt
+CMakeFiles
+CMakeScripts
+Testing
+Makefile
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+_deps
+
+### CMake Patch ###
+# External projects
+*-prefix/
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..7291140
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,36 @@
+#
+# Copyright (c) 2025, Arm Limited. All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+cmake_minimum_required(VERSION 3.15)
+
+project(libeventlog VERSION 0.9 LANGUAGES C CXX ASM)
+
+set(CMAKE_C_STANDARD_REQUIRED TRUE)
+set(CMAKE_C_EXTENSIONS TRUE)
+
+add_library(cxx_compiler_flags INTERFACE)
+target_compile_features(cxx_compiler_flags INTERFACE cxx_std_11)
+
+SET(TARGET_GROUP release CACHE STRING "Specify the Build Target [\"release\" by default]")
+
+if(HASH_ALGORITHM STREQUAL "SHA512")
+    add_compile_definitions(TPM_ALG_ID=TPM_ALG_SHA512)
+    add_compile_definitions(TCG_DIGEST_SIZE=64U)
+elseif(HASH_ALGORITHM STREQUAL "SHA384")
+    add_compile_definitions(TPM_ALG_ID=TPM_ALG_SHA384)
+    add_compile_definitions(TCG_DIGEST_SIZE=48U)
+else()
+    add_compile_definitions(TPM_ALG_ID=TPM_ALG_SHA256)
+    add_compile_definitions(TCG_DIGEST_SIZE=32U)
+endif()
+
+add_library(eventlog STATIC
+    ${PROJECT_SOURCE_DIR}/src/event_log.c
+    ${PROJECT_SOURCE_DIR}/src/event_print.c
+)
+
+target_include_directories(eventlog PUBLIC ${CMAKE_SOURCE_DIR}/include)
+target_link_libraries(eventlog PUBLIC cxx_compiler_flags)
diff --git a/DCO b/DCO
new file mode 100644
index 0000000..49b8cb0
--- /dev/null
+++ b/DCO
@@ -0,0 +1,34 @@
+Developer Certificate of Origin
+Version 1.1
+
+Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..b71e918
--- /dev/null
+++ b/README.md
@@ -0,0 +1,94 @@
+# Event Log Library (LibEvLog)
+
+LibEvLog is a library that provides interfaces for parsing and handling TCG2
+(Trusted Computing Group 2) event logs, which are generated during the pre-boot
+phase of a system. These logs capture measurements of critical components and
+actions by recording hash values into Platform Configuration Registers (PCRs).
+Each event in the log includes metadata about the measurement, its type, and the
+resulting PCR value.
+
+Event logs play a key role in remote attestation, where a system proves its
+integrity to a remote verifier. While PCR values alone are difficult to
+interpret, the accompanying event log offers detailed insights into what was
+measured and when. As described in the TCG specifications:
+
+> Attestation is used to provide information about the platform’s state to a
+> challenger. However, PCR contents are difficult to interpret; therefore,
+> attestation is typically more useful when the PCR contents are accompanied by a
+> measurement log… The PCR contents are used to provide the validation of the
+> measurement log.”
+
+libevlog makes it easier to work with these logs by providing structured access
+to the data, enabling inspection, analysis, and validation of system
+measurements.
+
+## Minimum Supporting Tooling Requirements
+
+| Tool         | Minimum Version |
+| ------------ | --------------- |
+| Clang-Format | 14              |
+| CMake        | 3.15            |
+
+## Building with CMake
+
+To configure the project, use the following command. This will default to using
+GCC as the toolchain and create a build directory named `build/`:
+
+```sh
+cmake -B build
+```
+
+To build the project, use:
+
+```sh
+cmake --build build
+```
+
+This will output libtl.a in the build directory.
+
+For cross-compilation or selecting a different compiler, specify the target
+compiler using `CC` or `CROSS_COMPILE`:
+
+```sh
+CC=aarch64-none-elf-gcc cmake -B build -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY
+```
+
+## Configuration Options
+
+### `HASH_ALGORITHM`
+
+This CMake option controls which hash algorithm the library is compiled to
+support. Currently, the library is designed to support **only a single algorithm
+at a time**, chosen at compile time. The selection sets corresponding
+preprocessor definitions, which configure internal behavior for digest size and
+algorithm identifiers.
+
+| `HASH_ALGORITHM` | Defined Macro(s)                                             |
+|------------------|--------------------------------------------------------------|
+| `SHA512`         | `TPM_ALG_ID=TPM_ALG_SHA512`, `TCG_DIGEST_SIZE=64U`           |
+| `SHA324`         | `TPM_ALG_ID=TPM_ALG_SHA384`, `TCG_DIGEST_SIZE=48U`           |
+| _(default)_      | `TPM_ALG_ID=TPM_ALG_SHA256`, `TCG_DIGEST_SIZE=32U`           |
+
+These macros configure the internal logic of the library for the specified hash
+function.
+
+> **Note:** The current implementation only supports compiling with a single
+algorithm. However, the long-term goal is to allow users to specify and use
+**multiple hash functions** within the same build. This will enable more
+flexible and dynamic cryptographic functionality.
+
+### Example Usage
+
+**To build the library with SHA384 support:**
+
+```bash
+cmake -DHASH_ALGORITHM=SHA324 ..
+make
+```
+
+**To build the library with default SHA256:**
+
+```bash
+cmake ..
+make
+```
diff --git a/include/event_log.h b/include/event_log.h
new file mode 100644
index 0000000..f97c580
--- /dev/null
+++ b/include/event_log.h
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) 2020-2025, Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef EVENT_LOG_H
+#define EVENT_LOG_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <tcg.h>
+
+/* Number of hashing algorithms supported */
+#define HASH_ALG_COUNT 1U
+
+#define EVLOG_INVALID_ID UINT32_MAX
+
+/* Maximum digest size based on the strongest hash algorithm i.e. SHA-512. */
+#define MAX_DIGEST_SIZE 64U
+
+#define MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
+
+typedef struct {
+	unsigned int id;
+	const char *name;
+	unsigned int pcr;
+} event_log_metadata_t;
+
+typedef int (*evlog_hash_func_t)(uint32_t alg, void *data, unsigned int len,
+				 uint8_t *digest);
+
+struct event_log_hash_info {
+	evlog_hash_func_t func;
+	const uint32_t *ids;
+	size_t count;
+};
+
+#define ID_EVENT_SIZE                                           \
+	(sizeof(id_event_headers_t) +                           \
+	 (sizeof(id_event_algorithm_size_t) * HASH_ALG_COUNT) + \
+	 sizeof(id_event_struct_data_t))
+
+#define LOC_EVENT_SIZE                                                 \
+	(sizeof(event2_header_t) + sizeof(tpmt_ha) + TCG_DIGEST_SIZE + \
+	 sizeof(event2_data_t) + sizeof(startup_locality_event_t))
+
+#define LOG_MIN_SIZE (ID_EVENT_SIZE + LOC_EVENT_SIZE)
+
+#define EVENT2_HDR_SIZE                                                \
+	(sizeof(event2_header_t) + sizeof(tpmt_ha) + TCG_DIGEST_SIZE + \
+	 sizeof(event2_data_t))
+
+/* Functions' declarations */
+
+/**
+ * Initialize the Event Log buffer.
+ *
+ * Sets global pointers to manage the Event Log memory region,
+ * allowing subsequent log operations to write into the buffer.
+ *
+ * @param[in] start  Pointer to the start of the Event Log buffer.
+ * @param[in] finish Pointer to the end of the buffer
+ *                             (i.e., one byte past the last valid address).
+ *
+ * @return 0 on success, or -EINVAL if the input range is invalid.
+ */
+int event_log_buf_init(uint8_t *start, uint8_t *finish);
+
+/**
+ * Dump the contents of the Event Log.
+ *
+ * Outputs the raw contents of the Event Log buffer, typically
+ * for debugging or audit purposes.
+ *
+ * @param[in] log_addr Pointer to the start of the Event Log buffer.
+ * @param[in] log_size Size of the Event Log buffer in bytes.
+ *
+ * @return 0 on success, or a negative error code on failure.
+ */
+int event_log_dump(uint8_t *log_addr, size_t log_size);
+
+/**
+ * Initialize the Event Log subsystem.
+ *
+ * Wrapper around `event_log_buf_init()` to configure the memory range
+ * for the Event Log buffer.
+ *
+ * @param[in] start  Pointer to the start of the Event Log buffer.
+ * @param[in] finish Pointer to the end of the buffer
+ *                             (i.e., one byte past the last valid address).
+ *
+ * @return 0 on success, or a negative error code on failure.
+ */
+int event_log_init(uint8_t *start, uint8_t *finish);
+
+/**
+ * Initialize the Event Log and register supported hash functions.
+ *
+ * Initializes the Event Log subsystem using the provided memory region
+ * and registers one or more cryptographic hash functions for use in
+ * event measurements. This function must be called before any measurements
+ * or event recording can take place.
+ *
+ * @param[in] start      Pointer to the beginning of the Event Log buffer.
+ * @param[in] finish     Pointer to the end of the Event Log buffer.
+ * @param[in] hash_info  Pointer to a structure containing the hash function
+ *                       pointer and associated algorithm identifiers.
+ *
+ * @return 0 on success,
+ *         -EEXIST if hash functions have already been registered,
+ *         -EINVAL if the input parameters are invalid,
+ *         or a negative error code from the underlying initialization logic.
+ */
+int event_log_init_and_reg(uint8_t *start, uint8_t *finish,
+			   const struct event_log_hash_info *hash_info);
+
+/**
+ * Measure input data and log its hash to the Event Log.
+ *
+ * Computes the cryptographic hash of the specified data and records it
+ * in the Event Log as a TCG_PCR_EVENT2 structure using event type EV_POST_CODE.
+ * Useful for firmware or image attestation.
+ *
+ * @param[in] data_base     Pointer to the base of the data to be measured.
+ * @param[in] data_size     Size of the data in bytes.
+ * @param[in] data_id       Identifier used to match against metadata.
+ * @param[in] metadata_ptr  Pointer to an array of event_log_metadata_t.
+ *
+ * @return 0 on success, or a negative error code on failure.
+ */
+int event_log_measure_and_record(uintptr_t data_base, uint32_t data_size,
+				 uint32_t data_id,
+				 const event_log_metadata_t *metadata_ptr);
+
+/**
+ * Measure the input data and return its hash.
+ *
+ * Computes the cryptographic hash of the specified memory region using
+ * the default hashing algorithm configured in the Event Log subsystem.
+ *
+ * @param[in]  data_base  Pointer to the base of the data to be measured.
+ * @param[in]  data_size  Size of the data in bytes.
+ * @param[out] hash_data  Buffer to hold the resulting hash output
+ *                        (must be at least CRYPTO_MD_MAX_SIZE bytes).
+ *
+ * @return 0 on success, or an error code on failure.
+ */
+int event_log_measure(uintptr_t data_base, uint32_t data_size,
+		      unsigned char *hash_data);
+
+/**
+ * Record a measurement event in the Event Log.
+ *
+ * Writes a TCG_PCR_EVENT2 structure to the Event Log using the
+ * provided hash and metadata. This function assumes the buffer
+ * has enough space and that `event_log_buf_init()` has been called.
+ *
+ * @param[in] hash         Pointer to the digest (TCG_DIGEST_SIZE bytes).
+ * @param[in] event_type   Type of the event, as defined in tcg.h.
+ * @param[in] metadata_ptr Pointer to an event_log_metadata_t structure
+ *                         providing event-specific context (e.g., PCR index, name).
+ *
+ * @return 0 on success, or -ENOMEM if the buffer has insufficient space.
+ */
+int event_log_record(const uint8_t *hash, uint32_t event_type,
+		     const event_log_metadata_t *metadata_ptr);
+
+/**
+ * Initialize the Event Log with mandatory header events.
+ *
+ * Writes the Specification ID (SpecID) and Startup Locality events
+ * as required by the TCG PC Client Platform Firmware Profile.
+ * These must be the first entries in the Event Log.
+ *
+ * @return 0 on success, or a negative error code on failure.
+ */
+int event_log_write_header(void);
+
+/**
+ * Write the SpecID event to the Event Log.
+ *
+ * Records the TCG_EfiSpecIDEventStruct to declare the structure
+ * and supported algorithms of the Event Log format.
+ *
+ * @return 0 on success, or a negative error code on failure.
+ */
+int event_log_write_specid_event(void);
+
+/**
+ * Get the current size of the Event Log.
+ *
+ * Calculates how many bytes of the Event Log buffer have been used,
+ * based on the current log pointer and the start of the buffer.
+ *
+ * @param[in] start Pointer to the start of the Event Log buffer.
+ *
+ * @return The number of bytes currently used in the Event Log.
+ */
+size_t event_log_get_cur_size(uint8_t *start);
+
+#endif /* EVENT_LOG_H */
diff --git a/include/sha_common_macros.h b/include/sha_common_macros.h
new file mode 100644
index 0000000..e90552f
--- /dev/null
+++ b/include/sha_common_macros.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2024, NVIDIA Corporation. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef SHA_COMMON_MACROS_H
+#define SHA_COMMON_MACROS_H
+
+#define MD5_DIGEST_SIZE 16U
+#define SHA1_DIGEST_SIZE 20U
+#define SHA224_DIGEST_SIZE 28U
+#define SHA256_DIGEST_SIZE 32U
+#define SHA384_DIGEST_SIZE 48U
+#define SHA512_224_DIGEST_SIZE 28U
+#define SHA512_256_DIGEST_SIZE 32U
+#define SHA512_DIGEST_SIZE 64U
+
+#endif /* SHA_COMMON_MACROS_H */
diff --git a/include/tcg.h b/include/tcg.h
new file mode 100644
index 0000000..c9bb341
--- /dev/null
+++ b/include/tcg.h
@@ -0,0 +1,304 @@
+/*
+ * Copyright (c) 2020-2022, Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef TCG_H
+#define TCG_H
+
+#include <sha_common_macros.h>
+#include <stdint.h>
+
+#define TCG_ID_EVENT_SIGNATURE_03 "Spec ID Event03"
+#define TCG_STARTUP_LOCALITY_SIGNATURE "StartupLocality"
+
+#define TCG_SPEC_VERSION_MAJOR_TPM2 2
+#define TCG_SPEC_VERSION_MINOR_TPM2 0
+#define TCG_SPEC_ERRATA_TPM2 2
+
+/*
+ * Event types
+ * Ref. Table 9 Events
+ * TCG PC Client Platform Firmware Profile Specification.
+ */
+#define EV_PREBOOT_CERT 0x00000000U
+#define EV_POST_CODE 0x00000001U
+#define EV_UNUSED 0x00000002U
+#define EV_NO_ACTION 0x00000003U
+#define EV_SEPARATOR 0x00000004U
+#define EV_ACTION 0x00000005U
+#define EV_EVENT_TAG 0x00000006U
+#define EV_S_CRTM_CONTENTS 0x00000007U
+#define EV_S_CRTM_VERSION 0x00000008U
+#define EV_CPU_MICROCODE 0x00000009U
+#define EV_PLATFORM_CONFIG_FLAGS 0x0000000AU
+#define EV_TABLE_OF_DEVICES 0x0000000BU
+#define EV_COMPACT_HASH 0x0000000CU
+#define EV_IPL 0x0000000DU
+#define EV_IPL_PARTITION_DATA 0x0000000EU
+#define EV_NONHOST_CODE 0x0000000FU
+#define EV_NONHOST_CONFIG 0x00000010U
+#define EV_NONHOST_INFO 0x00000011U
+#define EV_OMIT_BOOT_DEVICE_EVENTS 0x00000012U
+#define EV_EFI_EVENT_BASE 0x80000000U
+#define EV_EFI_VARIABLE_DRIVER_CONFIG 0x80000001U
+#define EV_EFI_VARIABLE_BOOT 0x80000002U
+#define EV_EFI_BOOT_SERVICES_APPLICATION 0x80000003U
+#define EV_EFI_BOOT_SERVICES_DRIVER 0x80000004U
+#define EV_EFI_RUNTIME_SERVICES_DRIVER 0x80000005U
+#define EV_EFI_GPT_EVENT 0x80000006U
+#define EV_EFI_ACTION 0x80000007U
+#define EV_EFI_PLATFORM_FIRMWARE_BLOB 0x80000008U
+#define EV_EFI_HANDOFF_TABLES 0x80000009U
+#define EV_EFI_HCRTM_EVENT 0x80000010U
+#define EV_EFI_VARIABLE_AUTHORITY 0x800000E0U
+
+/*
+ * TPM_ALG_ID constants.
+ * Ref. Table 9 - Definition of (UINT16) TPM_ALG_ID Constants
+ * Trusted Platform Module Library. Part 2: Structures
+ */
+#define TPM_ALG_SHA256 0x000B
+#define TPM_ALG_SHA384 0x000C
+#define TPM_ALG_SHA512 0x000D
+
+/* TCG Platform Type */
+#define PLATFORM_CLASS_CLIENT 0
+#define PLATFORM_CLASS_SERVER 1
+
+enum {
+	/*
+	 * SRTM, BIOS, Host Platform Extensions, Embedded
+	 * Option ROMs and PI Drivers
+	 */
+	PCR_0 = 0,
+	/* Host Platform Configuration */
+	PCR_1,
+	/* UEFI driver and application Code */
+	PCR_2,
+	/* UEFI driver and application Configuration and Data */
+	PCR_3,
+	/* UEFI Boot Manager Code (usually the MBR) and Boot Attempts */
+	PCR_4,
+	/*
+	 * Boot Manager Code Configuration and Data (for use
+	 * by the Boot Manager Code) and GPT/Partition Table
+	 */
+	PCR_5,
+	/* Host Platform Manufacturer Specific */
+	PCR_6,
+	/* Secure Boot Policy */
+	PCR_7,
+	/* 8-15: Defined for use by the Static OS */
+	PCR_8,
+	/* Debug */
+	PCR_16 = 16,
+
+	/* D-CRTM-measurements by DRTM implementation */
+	PCR_17 = 17,
+	/* DCE measurements by DRTM implementation */
+	PCR_18 = 18
+};
+
+#pragma pack(push, 1)
+
+/*
+ * PCR Event Header
+ * TCG EFI Protocol Specification
+ * 5.3 Event Log Header
+ */
+typedef struct {
+	/* PCRIndex:
+	 * The PCR Index to which this event is extended
+	 */
+	uint32_t pcr_index;
+
+	/* EventType:
+	 * SHALL be an EV_NO_ACTION event
+	 */
+	uint32_t event_type;
+
+	/* SHALL be 20 Bytes of 0x00 */
+	uint8_t digest[SHA1_DIGEST_SIZE];
+
+	/* The size of the event */
+	uint32_t event_size;
+
+	/* SHALL be a TCG_EfiSpecIdEvent */
+	uint8_t event[]; /* [event_data_size] */
+} tcg_pcr_event_t;
+
+/*
+ * Log Header Entry Data
+ * Ref. Table 14 TCG_EfiSpecIdEventAlgorithmSize
+ * TCG PC Client Platform Firmware Profile 9.4.5.1
+ */
+typedef struct {
+	/* Algorithm ID (hashAlg) of the Hash used by BIOS */
+	uint16_t algorithm_id;
+
+	/* The size of the digest produced by the implemented Hash algorithm */
+	uint16_t digest_size;
+} id_event_algorithm_size_t;
+
+/*
+ * TCG_EfiSpecIdEvent structure
+ * Ref. Table 15 TCG_EfiSpecIdEvent
+ * TCG PC Client Platform Firmware Profile 9.4.5.1
+ */
+typedef struct {
+	/*
+	 * The NUL-terminated ASCII string "Spec ID Event03".
+	 * SHALL be set to {0x53, 0x70, 0x65, 0x63, 0x20, 0x49, 0x44,
+	 * 0x20, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x30, 0x33, 0x00}.
+	 */
+	uint8_t signature[16];
+
+	/*
+	 * The value for the Platform Class.
+	 * The enumeration is defined in the TCG ACPI Specification Client
+	 * Common Header.
+	 */
+	uint32_t platform_class;
+
+	/*
+	 * The PC Client Platform Profile Specification minor version number
+	 * this BIOS supports.
+	 * Any BIOS supporting this version (2.0) MUST set this value to 0x00.
+	 */
+	uint8_t spec_version_minor;
+
+	/*
+	 * The PC Client Platform Profile Specification major version number
+	 * this BIOS supports.
+	 * Any BIOS supporting this version (2.0) MUST set this value to 0x02.
+	 */
+	uint8_t spec_version_major;
+
+	/*
+	 * The PC Client Platform Profile Specification errata version number
+	 * this BIOS supports.
+	 * Any BIOS supporting this version (2.0) MUST set this value to 0x02.
+	 */
+	uint8_t spec_errata;
+
+	/*
+	 * Specifies the size of the UINTN fields used in various data
+	 * structures used in this specification.
+	 * 0x01 indicates UINT32 and 0x02 indicates UINT64.
+	 */
+	uint8_t uintn_size;
+
+	/*
+	 * The number of Hash algorithms in the digestSizes field.
+	 * This field MUST be set to a value of 0x01 or greater.
+	 */
+	uint32_t number_of_algorithms;
+
+	/*
+	 * Each TCG_EfiSpecIdEventAlgorithmSize SHALL contain an algorithmId
+	 * and digestSize for each hash algorithm used in the TCG_PCR_EVENT2
+	 * structure, the first of which is a Hash algorithmID and the second
+	 * is the size of the respective digest.
+	 */
+	id_event_algorithm_size_t digest_size[]; /* number_of_algorithms */
+} id_event_struct_header_t;
+
+typedef struct {
+	/*
+	 * Size in bytes of the VendorInfo field.
+	 * Maximum value MUST be FFh bytes.
+	 */
+	uint8_t vendor_info_size;
+
+	/*
+	 * Provided for use by Platform Firmware implementer. The value might
+	 * be used, for example, to provide more detailed information about the
+	 * specific BIOS such as BIOS revision numbers, etc. The values within
+	 * this field are not standardized and are implementer-specific.
+	 * Platform-specific or -unique information MUST NOT be provided in
+	 * this field.
+	 *
+	 */
+	uint8_t vendor_info[]; /* [vendorInfoSize] */
+} id_event_struct_data_t;
+
+typedef struct {
+	id_event_struct_header_t struct_header;
+	id_event_struct_data_t struct_data;
+} id_event_struct_t;
+
+typedef struct {
+	tcg_pcr_event_t header;
+	id_event_struct_header_t struct_header;
+} id_event_headers_t;
+
+/* TPMT_HA Structure */
+typedef struct {
+	/* Selector of the hash contained in the digest that implies
+	 * the size of the digest
+	 */
+	uint16_t algorithm_id; /* AlgorithmId */
+
+	/* Digest, depends on AlgorithmId */
+	uint8_t digest[]; /* Digest[] */
+} tpmt_ha;
+
+/*
+ * TPML_DIGEST_VALUES Structure
+ */
+typedef struct {
+	/* The number of digests in the list */
+	uint32_t count; /* Count */
+
+	/* The list of tagged digests, as sent to the TPM as part of a
+	 * TPM2_PCR_Extend or as received from a TPM2_PCR_Event command
+	 */
+	tpmt_ha digests[]; /* Digests[Count] */
+} tpml_digest_values;
+
+/*
+ * TCG_PCR_EVENT2 header
+ */
+typedef struct {
+	/* The PCR Index to which this event was extended */
+	uint32_t pcr_index; /* PCRIndex */
+
+	/* Type of event */
+	uint32_t event_type; /* EventType */
+
+	/* Digests:
+	 * A counted list of tagged digests, which contain the digest of
+	 * the event data (or external data) for all active PCR banks
+	 */
+	tpml_digest_values digests; /* Digests */
+} event2_header_t;
+
+typedef struct event2_data {
+	/* The size of the event data */
+	uint32_t event_size; /* EventSize */
+
+	/* The data of the event */
+	uint8_t event[]; /* Event[EventSize] */
+} event2_data_t;
+
+/*
+ * Startup Locality Event
+ * Ref. TCG PC Client Platform Firmware Profile 9.4.5.3
+ */
+typedef struct {
+	/*
+	 * The NUL-terminated ASCII string "StartupLocality" SHALL be
+	 * set to {0x53 0x74 0x61 0x72 0x74 0x75 0x70 0x4C 0x6F 0x63
+	 * 0x61 0x6C 0x69 0x74 0x79 0x00}
+	 */
+	uint8_t signature[16];
+
+	/* The Locality Indicator which sent the TPM2_Startup command */
+	uint8_t startup_locality;
+} startup_locality_event_t;
+
+#pragma pack(pop)
+
+#endif /* TCG_H */
diff --git a/src/event_log.c b/src/event_log.c
new file mode 100644
index 0000000..d59346b
--- /dev/null
+++ b/src/event_log.c
@@ -0,0 +1,315 @@
+/*
+ * Copyright (c) 2020-2025, Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <assert.h>
+#include <errno.h>
+#include <string.h>
+
+#include "event_log.h"
+
+/* Running Event Log Pointer */
+static uint8_t *log_ptr;
+
+/* Pointer to the first byte past end of the Event Log buffer */
+static uintptr_t log_end;
+
+/* Hash function for event log operations set by user. */
+static const struct event_log_hash_info *crypto_hash_info;
+
+/* TCG_EfiSpecIdEvent */
+static const id_event_headers_t id_event_header = {
+	.header = { .pcr_index = PCR_0,
+		    .event_type = EV_NO_ACTION,
+		    .digest = { 0 },
+		    .event_size =
+			    (uint32_t)(sizeof(id_event_struct_t) +
+				       (sizeof(id_event_algorithm_size_t) *
+					HASH_ALG_COUNT)) },
+
+	.struct_header = { .signature = TCG_ID_EVENT_SIGNATURE_03,
+			   .platform_class = PLATFORM_CLASS_CLIENT,
+			   .spec_version_minor = TCG_SPEC_VERSION_MINOR_TPM2,
+			   .spec_version_major = TCG_SPEC_VERSION_MAJOR_TPM2,
+			   .spec_errata = TCG_SPEC_ERRATA_TPM2,
+			   .uintn_size = (uint8_t)(sizeof(unsigned int) /
+						   sizeof(uint32_t)),
+			   .number_of_algorithms = HASH_ALG_COUNT }
+};
+
+static const event2_header_t locality_event_header = {
+	/*
+	 * All EV_NO_ACTION events SHALL set
+	 * TCG_PCR_EVENT2.pcrIndex = 0, unless otherwise specified
+	 */
+	.pcr_index = PCR_0,
+
+	/*
+	 * All EV_NO_ACTION events SHALL set
+	 * TCG_PCR_EVENT2.eventType = 03h
+	 */
+	.event_type = EV_NO_ACTION,
+
+	/*
+	 * All EV_NO_ACTION events SHALL set TCG_PCR_EVENT2.digests to all
+	 * 0x00's for each allocated Hash algorithm
+	 */
+	.digests = { .count = HASH_ALG_COUNT }
+};
+
+/* Message digest algorithm */
+enum crypto_md_algo {
+	CRYPTO_MD_SHA256,
+	CRYPTO_MD_SHA384,
+	CRYPTO_MD_SHA512,
+};
+
+int event_log_record(const uint8_t *hash, uint32_t event_type,
+		     const event_log_metadata_t *metadata_ptr)
+{
+	void *ptr = log_ptr;
+	uint32_t name_len = 0U;
+
+	/* event_log_buf_init() must have been called prior to this. */
+	if (hash == NULL || metadata_ptr == NULL || log_ptr == NULL) {
+		return -EINVAL;
+	}
+
+	if (metadata_ptr->name != NULL) {
+		name_len = (uint32_t)strlen(metadata_ptr->name) + 1U;
+	}
+
+	/* Check for space in Event Log buffer */
+	if (((uintptr_t)ptr + (uint32_t)EVENT2_HDR_SIZE + name_len) > log_end) {
+		return -ENOMEM;
+	}
+
+	/*
+	 * As per TCG specifications, firmware components that are measured
+	 * into PCR[0] must be logged in the event log using the event type
+	 * EV_POST_CODE.
+	 */
+	/* TCG_PCR_EVENT2.PCRIndex */
+	((event2_header_t *)ptr)->pcr_index = metadata_ptr->pcr;
+
+	/* TCG_PCR_EVENT2.EventType */
+	((event2_header_t *)ptr)->event_type = event_type;
+
+	/* TCG_PCR_EVENT2.Digests.Count */
+	ptr = (uint8_t *)ptr + offsetof(event2_header_t, digests);
+	((tpml_digest_values *)ptr)->count = HASH_ALG_COUNT;
+
+	/* TCG_PCR_EVENT2.Digests[] */
+	ptr = (uint8_t *)((uintptr_t)ptr +
+			  offsetof(tpml_digest_values, digests));
+
+	/* TCG_PCR_EVENT2.Digests[].AlgorithmId */
+	((tpmt_ha *)ptr)->algorithm_id = TPM_ALG_ID;
+
+	/* TCG_PCR_EVENT2.Digests[].Digest[] */
+	ptr = (uint8_t *)((uintptr_t)ptr + offsetof(tpmt_ha, digest));
+
+	/* Copy digest */
+	(void)memcpy(ptr, (const void *)hash, TCG_DIGEST_SIZE);
+
+	/* TCG_PCR_EVENT2.EventSize */
+	ptr = (uint8_t *)((uintptr_t)ptr + TCG_DIGEST_SIZE);
+	((event2_data_t *)ptr)->event_size = name_len;
+
+	/* Copy event data to TCG_PCR_EVENT2.Event */
+	if (metadata_ptr->name != NULL) {
+		(void)memcpy((void *)(((event2_data_t *)ptr)->event),
+			     (const void *)metadata_ptr->name, name_len);
+	}
+
+	/* End of event data */
+	log_ptr = (uint8_t *)((uintptr_t)ptr + offsetof(event2_data_t, event) +
+			      name_len);
+
+	return 0;
+}
+
+int event_log_init(uint8_t *start, uint8_t *finish)
+{
+	if ((start == NULL || finish == NULL) || start > finish) {
+		return -EINVAL;
+	}
+
+	log_ptr = start;
+	log_end = (uintptr_t)finish;
+
+	return 0;
+}
+
+int event_log_write_specid_event(void)
+{
+	void *ptr;
+
+	/* event_log_buf_init() must have been called prior to this. */
+	if (log_ptr == NULL) {
+		return -EFAULT;
+	}
+
+	if (((uintptr_t)log_ptr + ID_EVENT_SIZE) > log_end) {
+		return -ENOMEM;
+	}
+
+	ptr = log_ptr;
+
+	/*
+	 * Add Specification ID Event first
+	 *
+	 * Copy TCG_EfiSpecIDEventStruct structure header
+	 */
+	(void)memcpy(ptr, (const void *)&id_event_header,
+		     sizeof(id_event_header));
+	ptr = (uint8_t *)((uintptr_t)ptr + sizeof(id_event_header));
+
+	/* TCG_EfiSpecIdEventAlgorithmSize structure */
+	((id_event_algorithm_size_t *)ptr)->algorithm_id = TPM_ALG_ID;
+	((id_event_algorithm_size_t *)ptr)->digest_size = TCG_DIGEST_SIZE;
+	ptr = (uint8_t *)((uintptr_t)ptr + sizeof(id_event_algorithm_size_t));
+
+	/*
+	 * TCG_EfiSpecIDEventStruct.vendorInfoSize
+	 * No vendor data
+	 */
+	((id_event_struct_data_t *)ptr)->vendor_info_size = 0;
+	log_ptr = (uint8_t *)((uintptr_t)ptr +
+			      offsetof(id_event_struct_data_t, vendor_info));
+
+	return 0;
+}
+
+int event_log_write_header(void)
+{
+	const char locality_signature[] = TCG_STARTUP_LOCALITY_SIGNATURE;
+	void *ptr;
+	int rc;
+
+	rc = event_log_write_specid_event();
+	if (rc < 0) {
+		return rc;
+	}
+
+	if (((uintptr_t)log_ptr + LOC_EVENT_SIZE) > log_end) {
+		return -ENOMEM;
+	}
+
+	ptr = log_ptr;
+
+	/*
+	 * The Startup Locality event should be placed in the log before
+	 * any event which extends PCR[0].
+	 *
+	 * Ref. TCG PC Client Platform Firmware Profile 9.4.5.3
+	 */
+
+	/* Copy Startup Locality Event Header */
+	(void)memcpy(ptr, (const void *)&locality_event_header,
+		     sizeof(locality_event_header));
+	ptr = (uint8_t *)((uintptr_t)ptr + sizeof(locality_event_header));
+
+	/* TCG_PCR_EVENT2.Digests[].AlgorithmId */
+	((tpmt_ha *)ptr)->algorithm_id = TPM_ALG_ID;
+
+	/* TCG_PCR_EVENT2.Digests[].Digest[] */
+	(void)memset(&((tpmt_ha *)ptr)->digest, 0, TCG_DIGEST_SIZE);
+	ptr = (uint8_t *)((uintptr_t)ptr + offsetof(tpmt_ha, digest) +
+			  TCG_DIGEST_SIZE);
+
+	/* TCG_PCR_EVENT2.EventSize */
+	((event2_data_t *)ptr)->event_size =
+		(uint32_t)sizeof(startup_locality_event_t);
+	ptr = (uint8_t *)((uintptr_t)ptr + offsetof(event2_data_t, event));
+
+	/* TCG_EfiStartupLocalityEvent.Signature */
+	(void)memcpy(ptr, (const void *)locality_signature,
+		     sizeof(TCG_STARTUP_LOCALITY_SIGNATURE));
+
+	/*
+	 * TCG_EfiStartupLocalityEvent.StartupLocality = 0:
+	 * the platform's boot firmware
+	 */
+	((startup_locality_event_t *)ptr)->startup_locality = 0U;
+	log_ptr =
+		(uint8_t *)((uintptr_t)ptr + sizeof(startup_locality_event_t));
+
+	return 0;
+}
+
+int event_log_measure(uintptr_t data_base, uint32_t data_size,
+		      unsigned char *hash_data)
+{
+	if (crypto_hash_info == NULL) {
+		return -EINVAL;
+	}
+
+	return crypto_hash_info->func(crypto_hash_info->ids[0],
+				      (void *)data_base, data_size, hash_data);
+}
+
+int event_log_init_and_reg(uint8_t *start, uint8_t *finish,
+			   const struct event_log_hash_info *hash_info)
+{
+	int rc = event_log_init(start, finish);
+	if (rc < 0) {
+		return rc;
+	}
+
+	if (crypto_hash_info != NULL) {
+		return -EEXIST;
+	}
+
+	if (hash_info == NULL || hash_info->func == NULL ||
+	    hash_info->count < 0 || hash_info->count > HASH_ALG_COUNT) {
+		return -EINVAL;
+	}
+
+	crypto_hash_info = hash_info;
+	return 0;
+}
+
+int event_log_measure_and_record(uintptr_t data_base, uint32_t data_size,
+				 uint32_t data_id,
+				 const event_log_metadata_t *metadata_ptr)
+{
+	unsigned char hash_data[MAX_DIGEST_SIZE];
+	int rc;
+
+	if (metadata_ptr == NULL) {
+		return -EINVAL;
+	}
+
+	/* Get the metadata associated with this image. */
+	while (metadata_ptr->id != data_id) {
+		if (metadata_ptr->id == EVLOG_INVALID_ID) {
+			return -EINVAL;
+		}
+
+		metadata_ptr++;
+	}
+
+	/* Measure the payload with algorithm selected by EventLog driver */
+	rc = event_log_measure(data_base, data_size, hash_data);
+	if (rc != 0) {
+		return rc;
+	}
+
+	rc = event_log_record(hash_data, EV_POST_CODE, metadata_ptr);
+	if (rc != 0) {
+		return rc;
+	}
+
+	return 0;
+}
+
+size_t event_log_get_cur_size(uint8_t *_start)
+{
+	assert(_start != NULL);
+	assert(log_ptr >= _start);
+
+	return (size_t)((uintptr_t)log_ptr - (uintptr_t)_start);
+}
diff --git a/src/event_print.c b/src/event_print.c
new file mode 100644
index 0000000..72a1c7c
--- /dev/null
+++ b/src/event_print.c
@@ -0,0 +1,305 @@
+/*
+ * Copyright (c) 2020-2025, Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <errno.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "event_log.h"
+
+/**
+ * Print a TCG_EfiSpecIDEventStruct entry from the event log.
+ *
+ * This function extracts and prints a TCG_EfiSpecIDEventStruct
+ * entry from the event log for debugging or auditing purposes.
+ *
+ * @param[in,out] log_addr  Pointer to the current position in the Event Log.
+ *                          Updated to the next entry after processing.
+ * @param[in,out] log_size  Pointer to the remaining Event Log size.
+ *                          Updated to reflect the remaining bytes.
+ *
+ * @return 0 on success, or a negative error code on failure.
+ */
+static int event_log_print_id_event(uint8_t **log_addr, size_t *log_size)
+{
+	unsigned int i;
+	uint8_t info_size, *info_size_ptr;
+	void *ptr = *log_addr;
+	id_event_headers_t *event = (id_event_headers_t *)ptr;
+	id_event_algorithm_size_t *alg_ptr;
+	uint32_t event_size, number_of_algorithms;
+	size_t digest_len;
+	const uint8_t *end_ptr = (uint8_t *)((uintptr_t)*log_addr + *log_size);
+
+	if (*log_size < sizeof(id_event_headers_t)) {
+		return -EINVAL;
+	}
+
+	/* The fields of the event log header are defined to be PCRIndex of 0,
+	 * EventType of EV_NO_ACTION, Digest of 20 bytes of 0, and
+	 * Event content defined as TCG_EfiSpecIDEventStruct.
+	 */
+	printf("TCG_EfiSpecIDEvent:\n");
+	printf("  PCRIndex           : %u\n", event->header.pcr_index);
+	if (event->header.pcr_index != (uint32_t)PCR_0) {
+		return -EINVAL;
+	}
+
+	printf("  EventType          : %u\n", event->header.event_type);
+	if (event->header.event_type != EV_NO_ACTION) {
+		return -EINVAL;
+	}
+
+	printf("  Digest             :");
+	for (i = 0U; i < sizeof(event->header.digest); ++i) {
+		uint8_t val = event->header.digest[i];
+
+		(void)printf(" %02x", val);
+		if ((i & 0xFU) == 0U) {
+			(void)printf("\n");
+			printf("\t\t      :");
+		}
+	}
+
+	if ((i & 0xFU) != 0U) {
+		(void)printf("\n");
+	}
+
+	/* EventSize */
+	event_size = event->header.event_size;
+	printf("  EventSize          : %u\n", event_size);
+
+	printf("  Signature          : %s\n", event->struct_header.signature);
+	printf("  PlatformClass      : %u\n",
+	       event->struct_header.platform_class);
+	printf("  SpecVersion        : %u.%u.%u\n",
+	       event->struct_header.spec_version_major,
+	       event->struct_header.spec_version_minor,
+	       event->struct_header.spec_errata);
+	printf("  UintnSize          : %u\n", event->struct_header.uintn_size);
+
+	/* NumberOfAlgorithms */
+	number_of_algorithms = event->struct_header.number_of_algorithms;
+	printf("  NumberOfAlgorithms : %u\n", number_of_algorithms);
+
+	/* Address of DigestSizes[] */
+	alg_ptr = event->struct_header.digest_size;
+
+	/* Size of DigestSizes[] */
+	digest_len = number_of_algorithms * sizeof(id_event_algorithm_size_t);
+	if (digest_len > (uintptr_t)end_ptr - (uintptr_t)alg_ptr) {
+		return -EFAULT;
+	}
+
+	printf("  DigestSizes        :\n");
+	for (i = 0U; i < number_of_algorithms; ++i) {
+		printf("    #%u AlgorithmId   : SHA", i);
+		uint16_t algorithm_id = alg_ptr[i].algorithm_id;
+
+		switch (algorithm_id) {
+		case TPM_ALG_SHA256:
+			(void)printf("256\n");
+			break;
+		case TPM_ALG_SHA384:
+			(void)printf("384\n");
+			break;
+		case TPM_ALG_SHA512:
+			(void)printf("512\n");
+			break;
+		default:
+			(void)printf("?\n");
+			// ERROR("Algorithm 0x%x not found\n", algorithm_id);
+			printf("Algorithm 0x%x not found\n", algorithm_id);
+			return -ENOENT;
+		}
+
+		printf("       DigestSize    : %u\n", alg_ptr[i].digest_size);
+	}
+
+	/* Address of VendorInfoSize */
+	info_size_ptr = (uint8_t *)((uintptr_t)alg_ptr + digest_len);
+	if ((uintptr_t)info_size_ptr > (uintptr_t)end_ptr) {
+		return -EFAULT;
+	}
+
+	info_size = *info_size_ptr++;
+	printf("  VendorInfoSize     : %u\n", info_size);
+
+	/* Check VendorInfo end address */
+	if (((uintptr_t)info_size_ptr + info_size) > (uintptr_t)end_ptr) {
+		return -EFAULT;
+	}
+
+	/* Check EventSize */
+	if (event_size !=
+	    (sizeof(id_event_struct_t) + digest_len + info_size)) {
+		return -EFAULT;
+	}
+
+	if (info_size != 0U) {
+		printf("  VendorInfo         :");
+		for (i = 0U; i < info_size; ++i) {
+			(void)printf(" %02x", *info_size_ptr++);
+		}
+		(void)printf("\n");
+	}
+
+	*log_size -= (uintptr_t)info_size_ptr - (uintptr_t)*log_addr;
+	*log_addr = info_size_ptr;
+
+	return 0;
+}
+
+/**
+ * Print a TCG_PCR_EVENT2 entry from the event log.
+ *
+ * This function extracts and prints a TCG_PCR_EVENT2 structure
+ * from the event log for debugging or auditing purposes.
+ *
+ * @param[in,out] log_addr  Pointer to the current position in the Event Log.
+ *                          Updated to the next entry after processing.
+ * @param[in,out] log_size  Pointer to the remaining Event Log size.
+ *                          Updated to reflect the remaining bytes.
+ *
+ * @return 0 on success, or a negative error code on failure.
+ */
+static int event_log_print_pcr_event2(uint8_t **log_addr, size_t *log_size)
+{
+	uint32_t event_size, count;
+	size_t sha_size, digests_size = 0U;
+	void *ptr = *log_addr;
+	const uint8_t *end_ptr = (uint8_t *)((uintptr_t)*log_addr + *log_size);
+
+	if (*log_size < sizeof(event2_header_t)) {
+		return -EINVAL;
+	}
+
+	printf("PCR_Event2:\n");
+	printf("  PCRIndex           : %u\n",
+	       ((event2_header_t *)ptr)->pcr_index);
+	printf("  EventType          : %u\n",
+	       ((event2_header_t *)ptr)->event_type);
+
+	count = ((event2_header_t *)ptr)->digests.count;
+	if (count < 1U) {
+		printf("Invalid Digests Count      : %u\n", count);
+		return -EINVAL;
+	}
+
+	printf("  Digests Count      : %u\n", count);
+
+	/* Address of TCG_PCR_EVENT2.Digests[] */
+	ptr = (uint8_t *)ptr + sizeof(event2_header_t);
+	if ((uintptr_t)ptr > (uintptr_t)end_ptr) {
+		return -EFAULT;
+	}
+
+	for (unsigned int i = 0U; i < count; ++i) {
+		/* Check AlgorithmId address */
+		if (((uintptr_t)ptr + offsetof(tpmt_ha, digest)) >
+		    (uintptr_t)end_ptr) {
+			return -EFAULT;
+		}
+
+		printf("    #%u AlgorithmId   : SHA", i);
+		switch (((tpmt_ha *)ptr)->algorithm_id) {
+		case TPM_ALG_SHA256:
+			sha_size = SHA256_DIGEST_SIZE;
+			(void)printf("256\n");
+			break;
+		case TPM_ALG_SHA384:
+			sha_size = SHA384_DIGEST_SIZE;
+			(void)printf("384\n");
+			break;
+		case TPM_ALG_SHA512:
+			sha_size = SHA512_DIGEST_SIZE;
+			(void)printf("512\n");
+			break;
+		default:
+			(void)printf("?\n");
+			printf("Algorithm 0x%x not found\n",
+			       ((tpmt_ha *)ptr)->algorithm_id);
+			return -ENOENT;
+		}
+
+		/* End of Digest[] */
+		ptr = (uint8_t *)((uintptr_t)ptr + offsetof(tpmt_ha, digest));
+		if (((uintptr_t)ptr + sha_size) > (uintptr_t)end_ptr) {
+			return -EFAULT;
+		}
+
+		/* Total size of all digests */
+		digests_size += sha_size;
+
+		printf("       Digest        :");
+		for (unsigned int j = 0U; j < sha_size; ++j) {
+			(void)printf(" %02x", *(uint8_t *)ptr++);
+			if ((j & 0xFU) == 0xFU) {
+				(void)printf("\n");
+				if (j < (sha_size - 1U)) {
+					printf("\t\t      :");
+				}
+			}
+		}
+	}
+
+	/* TCG_PCR_EVENT2.EventSize */
+	if (((uintptr_t)ptr + offsetof(event2_data_t, event)) >
+	    (uintptr_t)end_ptr) {
+		return -EFAULT;
+	}
+
+	event_size = ((event2_data_t *)ptr)->event_size;
+	printf("  EventSize          : %u\n", event_size);
+
+	/* Address of TCG_PCR_EVENT2.Event[EventSize] */
+	ptr = (uint8_t *)((uintptr_t)ptr + offsetof(event2_data_t, event));
+
+	/* End of TCG_PCR_EVENT2.Event[EventSize] */
+	if (((uintptr_t)ptr + event_size) > (uintptr_t)end_ptr) {
+		return -EFAULT;
+	}
+
+	if ((event_size == sizeof(startup_locality_event_t)) &&
+	    (strcmp((const char *)ptr, TCG_STARTUP_LOCALITY_SIGNATURE) == 0)) {
+		printf("  Signature          : %s\n",
+		       ((startup_locality_event_t *)ptr)->signature);
+		printf("  StartupLocality    : %u\n",
+		       ((startup_locality_event_t *)ptr)->startup_locality);
+	} else {
+		printf("  Event              : %s\n", (uint8_t *)ptr);
+	}
+
+	*log_size -= (uintptr_t)ptr + event_size - (uintptr_t)*log_addr;
+	*log_addr = (uint8_t *)ptr + event_size;
+
+	return 0;
+}
+
+int event_log_dump(uint8_t *log_addr, size_t log_size)
+{
+	int rc;
+
+	if (log_addr == NULL) {
+		return -EINVAL;
+	}
+
+	/* Print TCG_EfiSpecIDEvent */
+	rc = event_log_print_id_event(&log_addr, &log_size);
+
+	if (rc < 0) {
+		return rc;
+	}
+
+	while (log_size != 0U) {
+		rc = event_log_print_pcr_event2(&log_addr, &log_size);
+		if (rc < 0) {
+			return rc;
+		}
+	}
+	return 0;
+}