fwk: Integrate logging functionality into the framework

This commit moves the message logging functionality, previously only
available through the logging module, into the framework as a
free-function interface.

A number of improvements to this interface have been made, owing to the
tighter integration this new interface has with the framework and its
scheduler:

- Simplistic synchronous logging can be enabled before the framework
   has fully initialized
- Message logging may be filtered at preprocessing-time to reduce
   the size of the code and read-only data sections in the firmware
   binary
- Logging is deprioritized at runtime to reduce response latency caused
   by logging to output devices

Change-Id: I5112df359df8a304a176e68994e2408d91f6ac89
Signed-off-by: Chris Kay <chris.kay@arm.com>

118 files changed, 1528 insertions, 2256 deletions

diff --git a/arch/src/host_thread.c b/arch/src/host_thread.c
index 292a9b90..9e76fac4 100644
--- a/arch/src/host_thread.c
+++ b/arch/src/host_thread.c
@@ -142,7 +142,9 @@ uint32_t osThreadFlagsWait(uint32_t flags, uint32_t options, uint32_t timeout)
     }
 
     tmp_signal_flags = local_thread_data->signal_flags;
-    local_thread_data->signal_flags &= ~flags;
+
+    if (!(options & osFlagsNoClear))
+        local_thread_data->signal_flags &= ~flags;
 
     return tmp_signal_flags;
 }
@@ -165,6 +167,15 @@ uint32_t osThreadFlagsSet(osThreadId_t thread_id, uint32_t flags)
     return flags;
 }
 
+uint32_t osThreadFlagsClear(uint32_t flags)
+{
+    uint32_t old_flags = local_thread_data->signal_flags;
+
+    local_thread_data->signal_flags &= ~flags;
+
+    return old_flags;
+}
+
 osThreadId_t osThreadNew(osThreadFunc_t func, void *argument,
     const osThreadAttr_t *attr)
 {
diff --git a/doc/code_rules.md b/doc/code_rules.md
index 5adbcbe8..6bd4d5df 100644
--- a/doc/code_rules.md
+++ b/doc/code_rules.md
@@ -55,7 +55,7 @@ C Standard Library
 When developing a module, only the following headers of the C standard library
 are allowed to be included:
 `<limits.h>`, `<stdarg.h>`, `<stdbool.h>`, `<stddef.h>`, `<stdint.h>`,
-`<stdio.h>`, `<stdlib.h>` and `<string.h>`.
+`<stdio.h>`, `<stdlib.h>`, `<string.h>` and `<inttypes.h>`.
 
 Concerning the library functions defined in `<stdio.h>`, only `snprintf()` may
 be used.
diff --git a/framework/include/fwk_host.h b/framework/include/fwk_host.h
deleted file mode 100644
index 107027ef..00000000
--- a/framework/include/fwk_host.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Arm SCP/MCP Software
- * Copyright (c) 2015-2020, Arm Limited and Contributors. All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#ifndef FWK_HOST_H
-#define FWK_HOST_H
-
-#ifdef BUILD_HOST
-#    include <stdio.h>
-
-/*!
- * \brief Print a message using the host's standard output.
- *
- * \param fmt Const char pointer to the message format string.
- * \param ... Additional arguments for the % specifiers within the message.
- *
- * \return On success, the number of characters written.
- * \return On failure, a negative number containing the error code as per the
- *      printf() specification.
- */
-#define FWK_HOST_PRINT printf
-
-#else
-#define FWK_HOST_PRINT(...) \
-    do { \
-    } while (0)
-#endif
-
-#endif /* FWK_HOST_H */
diff --git a/framework/include/fwk_log.h b/framework/include/fwk_log.h
index c7733d05..f664f3f3 100644
--- a/framework/include/fwk_log.h
+++ b/framework/include/fwk_log.h
@@ -10,8 +10,8 @@
 
 #include <fwk_macros.h>
 
-#ifdef BUILD_HAS_MOD_LOG
-#    include <mod_log.h>
+#if __has_include(<fmw_log.h>)
+#    include <fmw_log.h>
 #endif
 
 /*!
@@ -21,11 +21,122 @@
 
 /*!
  * \addtogroup GroupLogging Logging
+ *
+ *  \details This framework component provides logging facilities to the
+ *      firmware. It is intended to be simple and flexible to enable rapid
+ *      prototyping of debug-quality code, and performant release-quality code.
+ *
+ *      This component provides five filter levels for logging messages.
+ *      Log messages are assigned a filter level based on the logging macro
+ *      used. These macros are as follows:
+ *
+ *       - ::FWK_LOG_TRACE
+ *       - ::FWK_LOG_INFO
+ *       - ::FWK_LOG_WARN
+ *       - ::FWK_LOG_ERR
+ *       - ::FWK_LOG_CRIT
+ *
+ *      For a brief description of the meaning of each level, see the
+ *      documentation for each macro.
+ *
+ *      The value of the `FWK_LOG_LEVEL` macro, which can be set through the
+ *      build system configuration options, determines the minimum level a log
+ *      message must be for it to be included in the binary.
+ *
+ *      The logging framework component supports two different backends: the
+ *      always-on backend, which provides basic logging facilities for very
+ *      early logging, and the dynamic backend, which is intended to
+ *      supplant the always-on backend at runtime to provide a more flexible
+ *      implementation. These backends are registered through
+ *      ::fwk_log_register_aon() and ::fwk_log_register().
+ *
+ *      An always-on backend can be registered by any firmware at a very early
+ *      stage of the boot-up process, including before initialization of
+ *      individual modules. This backend is intended to provide a bridge to a
+ *      simple always-on device, such as a UART, that can be used as an output
+ *      for log messages before a dynamic backend has been registered. See the
+ *      documentation for ::fwk_log_register_aon() for more information.
+ *
+ *      A dynamic backend should be registered by a module, and is expected to
+ *      handle more complex scenarios more robustly. This backend may choose to
+ *      support multiple log devices of its own, or may support devices that are
+ *      not always available. A reference implementation is provided as part of
+ *      the standard logging module.
+ *
+ *      If buffering has been enabled (via ::FMW_LOG_BUFFER_SIZE) then log
+ *      messages may be buffered to reduce response latency; these buffered log
+ *      messages will be flushed to the dynamic backend once the system has
+ *      reached an idle state.
+ *
+ *      If buffering is enabled, log messages will be buffered if:
+ *
+ *       - A dynamic backend is currently registered, or
+ *       - No backends are currently registered
+ *
+ *      Buffered log messages will only ever be flushed to the dynamic backend.
+ *
+ *      Log messages will be written directly to the always-on backend if:
+ *
+ *       - An always-on backend is currently registered, and
+ *       - No dynamic backend is currently registered
+ *
+ *      If buffering is disabled, log messages will be written directly to the
+ *      dynamic backend if one is registered, otherwise to the always-on backend
+ *      if one is registered.
+ *
+ *      In any other case, log messages will be dropped.
  * \{
  */
 
-#ifdef BUILD_HAS_MOD_LOG
-#    define FWK_LOG_ENABLED
+/*!
+ * \def FMW_LOG_BUFFER_SIZE
+ *
+ * \brief Size of the internal log buffer in bytes.
+ *
+ * \details Log messages, for reasons of performance, are buffered unless an
+ *      always-on backend is currently in use (and a dynamic backend is not).
+ *      This definition dictates the size of the buffer, and can be overridden
+ *      by each individual firmware through a definition in a `<fmw_log.h>`
+ *      header.
+ *
+ * \note This definition has a default value of four kilobytes in release builds
+ *      and zero in debug builds.
+ *
+ * \note Setting this definition to a value of `0` will disable buffering. If
+ *      buffering is disabled, messages will be transmitted immediately.
+ */
+
+#ifndef FMW_LOG_BUFFER_SIZE
+#    ifdef BUILD_MODE_DEBUG
+#        define FMW_LOG_BUFFER_SIZE 0
+#    else
+#        define FMW_LOG_BUFFER_SIZE (4 * FWK_KIB)
+#    endif
+#endif
+
+#if FMW_LOG_BUFFER_SIZE > 0
+/*!
+ * \def FWK_LOG_BUFFERED
+ *
+ * \brief Determines whether buffering has been enabled within the logging
+ *      framework.
+ */
+#    define FWK_LOG_BUFFERED
+#endif
+
+/*!
+ * \def FMW_LOG_COLUMNS
+ *
+ * \brief Number of columns per line the framework will limit itself to.
+ *
+ * \details Messages printed using any of the logging functions will be limited
+ *      to this column count.
+ *
+ * \note This definition has a default value of `80`.
+ */
+
+#ifndef FMW_LOG_COLUMNS
+#    define FMW_LOG_COLUMNS 80
 #endif
 
 /*!
@@ -111,29 +222,6 @@
     } while (0)
 
 /*!
- * \internal
- *
- * \def FWK_LOG_IMPL
- *
- * \brief Log a message.
- *
- * \details This macro logs a message with a specified level.
- *
- * \param[in] API Pointer to a logging API implementing ::mod_log_api.
- * \param[in] LEVEL Filter level of the message.
- * \param[in] ... Format string and any associated parameters.
- */
-
-#ifdef FWK_LOG_ENABLED
-#    define FWK_LOG_IMPL(API, LEVEL, ...) \
-        ((API)->log((enum mod_log_group)(1 << LEVEL), __VA_ARGS__))
-#else
-#    define FWK_LOG_IMPL(API, LEVEL, ...) FWK_LOG_VOID(API, LEVEL, __VA_ARGS__)
-#endif
-
-/*!
- * \def FWK_LOG_FLUSH
- *
  * \brief Flush the logging backend.
  *
  * \details Flushing ensures that all data buffered by either the framework or
@@ -143,30 +231,21 @@
  * \warning Flushing can be an expensive operation, and should only be used when
  *      you absolutely need to make sure there is no more buffered data (such
  *      as before powering down a logging backend).
- *
- * \param[in] API API implementing ::mod_log_api.
  */
-
-#ifdef FWK_LOG_ENABLED
-#    define FWK_LOG_FLUSH(API) ((API)->flush())
-#else
-#    define FWK_LOG_FLUSH(API) FWK_LOG_VOID_EXPR(API)
-#endif
+#define FWK_LOG_FLUSH() fwk_log_flush()
 
 /*!
  * \def FWK_LOG_TRACE
  *
  * \brief Log a [trace](::FWK_LOG_LEVEL_TRACE) message.
  *
- * \param[in] API Pointer to a logging API implementing ::mod_log_api.
  * \param[in] ... Format string and any associated parameters.
  */
 
 #if FWK_LOG_LEVEL <= FWK_LOG_LEVEL_TRACE
-#    define FWK_LOG_TRACE(API, ...) \
-        FWK_LOG_IMPL(API, FWK_LOG_LEVEL_TRACE, __VA_ARGS__)
+#    define FWK_LOG_TRACE(...) fwk_log_snprintf(__VA_ARGS__)
 #else
-#    define FWK_LOG_TRACE(API, ...) FWK_LOG_VOID(API, __VA_ARGS__)
+#    define FWK_LOG_TRACE(...) FWK_LOG_VOID(__VA_ARGS__)
 #endif
 
 /*!
@@ -174,15 +253,13 @@
  *
  * \brief Log an [informational](::FWK_LOG_LEVEL_INFO) message.
  *
- * \param[in] API Pointer to a logging API implementing ::mod_log_api.
  * \param[in] ... Format string and any associated parameters.
  */
 
 #if FWK_LOG_LEVEL <= FWK_LOG_LEVEL_INFO
-#    define FWK_LOG_INFO(API, ...) \
-        FWK_LOG_IMPL(API, FWK_LOG_LEVEL_INFO, __VA_ARGS__)
+#    define FWK_LOG_INFO(...) fwk_log_snprintf(__VA_ARGS__)
 #else
-#    define FWK_LOG_INFO(API, ...) FWK_LOG_VOID(API, __VA_ARGS__)
+#    define FWK_LOG_INFO(...) FWK_LOG_VOID(__VA_ARGS__)
 #endif
 
 /*!
@@ -190,15 +267,13 @@
  *
  * \brief Log a [warning](::FWK_LOG_LEVEL_WARN) message.
  *
- * \param[in] API Pointer to a logging API implementing ::mod_log_api.
  * \param[in] ... Format string and any associated parameters.
  */
 
 #if FWK_LOG_LEVEL <= FWK_LOG_LEVEL_WARN
-#    define FWK_LOG_WARN(API, ...) \
-        FWK_LOG_IMPL(API, FWK_LOG_LEVEL_WARN, __VA_ARGS__)
+#    define FWK_LOG_WARN(...) fwk_log_snprintf(__VA_ARGS__)
 #else
-#    define FWK_LOG_WARN(API, ...) FWK_LOG_VOID(API, __VA_ARGS__)
+#    define FWK_LOG_WARN(...) FWK_LOG_VOID(__VA_ARGS__)
 #endif
 
 /*!
@@ -206,15 +281,13 @@
  *
  * \brief Log an [error](::FWK_LOG_LEVEL_ERROR) message.
  *
- * \param[in] API Pointer to a logging API implementing ::mod_log_api.
  * \param[in] ... Format string and any associated parameters.
  */
 
 #if FWK_LOG_LEVEL <= FWK_LOG_LEVEL_ERROR
-#    define FWK_LOG_ERR(API, ...) \
-        FWK_LOG_IMPL(API, FWK_LOG_LEVEL_ERROR, __VA_ARGS__)
+#    define FWK_LOG_ERR(...) fwk_log_snprintf(__VA_ARGS__)
 #else
-#    define FWK_LOG_ERR(API, ...) FWK_LOG_VOID(API, __VA_ARGS__)
+#    define FWK_LOG_ERR(...) FWK_LOG_VOID(__VA_ARGS__)
 #endif
 
 /*!
@@ -222,18 +295,159 @@
  *
  * \brief Log a [critical](::FWK_LOG_LEVEL_CRIT) message.
  *
- * \param[in] API Pointer to a logging API implementing ::mod_log_api.
  * \param[in] ... Format string and any associated parameters.
  */
 
 #if FWK_LOG_LEVEL <= FWK_LOG_LEVEL_CRIT
-#    define FWK_LOG_CRIT(API, ...) \
-        FWK_LOG_IMPL(API, FWK_LOG_LEVEL_CRIT, __VA_ARGS__)
+#    define FWK_LOG_CRIT(...) fwk_log_snprintf(__VA_ARGS__)
 #else
-#    define FWK_LOG_CRIT(API, ...) FWK_LOG_VOID(API, __VA_ARGS__)
+#    define FWK_LOG_CRIT(...) FWK_LOG_VOID(__VA_ARGS__)
 #endif
 
 /*!
+ * \brief Logging backend interface.
+ *
+ * \details This interface represents the medium through which the framework
+ *      logging logic transmits data to one or more logging backends.
+ */
+struct fwk_log_backend {
+    /*!
+     * \brief Buffer a single character.
+     *
+     * \note If the backend is not buffered, it may instead choose to print
+     *      the character immediately.
+     *
+     * \param[in] ch Character to buffer.
+     *
+     * \retval ::FWK_E_DEVICE The operation failed.
+     * \retval ::FWK_SUCCESS The operation succeeded.
+     *
+     * \return Status code representing the result of the operation.
+     */
+    int (*print)(char ch);
+
+    /*!
+     * \brief Flush the backend's buffer (if one exists).
+     *
+     * \note May be set to \c NULL if the backend is not buffered.
+     *
+     * \param[in] backend Logging backend.
+     *
+     * \retval ::FWK_E_DEVICE The operation failed.
+     * \retval ::FWK_SUCCESS The operation succeeded.
+     *
+     * \return Status code representing the result of the operation.
+     */
+    int (*flush)(void);
+};
+
+/*!
+ * \brief Register an always-on backend.
+ *
+ * \details For very early printf-style debugging, an always-on backend may be
+ *      registered from within a [constructor function].
+ *
+ *      [constructor function]:
+ * https://developer.arm.com/docs/100067/latest/compiler-specific-function-variable-and-type-attributes/__attribute__constructorpriority-function-attribute
+ *
+ * \param[in] backend Logging backend to register.
+ *
+ * \retval ::FWK_E_PARAM One or more parameters were invalid.
+ * \retval ::FWK_SUCCESS The operation succeeded.
+ *
+ * \return Status code representing the result of the operation.
+ */
+int fwk_log_register_aon(const struct fwk_log_backend *backend);
+
+/*!
+ * \brief Deregister the current always-on backend.
+ *
+ * \details This step is recommended if your logging backend can no longer
+ *      supply the facilities required.
+ *
+ * \return The previously registered backend, or \c NULL if no backend was
+ *      registered.
+ */
+const struct fwk_log_backend *fwk_log_deregister_aon(void);
+
+/*!
+ * \brief Register a dynamic backend.
+ *
+ * \details The dynamic backend is intended to be the primary runtime backend,
+ *      and can be used to handle more complex devices such as a UART behind a
+ *      power domain.
+ *
+ * \note If buffering is enabled and a dynamic backend has been
+ *      registered, log messages will be buffered.
+ *
+ * \param[in] backend Logging backend to register.
+ *
+ * \retval ::FWK_E_PARAM One or more parameters were invalid.
+ * \retval ::FWK_SUCCESS The operation succeeded.
+ *
+ * \return Status code representing the result of the operation.
+ */
+int fwk_log_register(const struct fwk_log_backend *backend);
+
+/*!
+ * \brief Deregister the current dynamic backend.
+ *
+ * \details This step is recommended if your logging backend can no longer
+ *      supply the facilities required.
+ *
+ * \return The previously registered backend, or \c NULL if no backend was
+ *      registered.
+ */
+const struct fwk_log_backend *fwk_log_deregister(void);
+
+/*!
+ * \internal
+ *
+ * \brief Initialize the logging component.
+ *
+ * \details This function initializes the logging component, enabling log
+ *      messages to be buffered until a backend is registered.
+ */
+void fwk_log_init(void);
+
+/*!
+ * \internal
+ *
+ * \brief Log a message with a specified filter level.
+ *
+ * \param[in] format Format string.
+ * \param[in] ... Associated parameters.
+ */
+void fwk_log_snprintf(const char *format, ...)
+    __attribute__((format(printf, 1, 2)));
+
+/*!
+ * \internal
+ *
+ * \brief Flush the logging backend(s).
+ */
+void fwk_log_flush(void);
+
+/*!
+ * \internal
+ *
+ * \brief Unbuffer a single character and send it to the logging backend.
+ *
+ * \details This function is reserved for the framework implementation, and is
+ *      used by the scheduler to print opportunistically when idling, and when
+ *      flushing to flush the buffer to the logging backend.
+ *
+ * \retval ::FWK_PENDING The character was unbuffered successfully but there are
+ *      still characters remaining in the buffer.
+ * \retval ::FWK_SUCCESS The character was unbuffered successfully and the
+ *      buffer is now empty.
+ * \retval ::FWK_E_DEVICE The backend returned an error.
+ *
+ * \return Status code representing the result of the operation.
+ */
+int fwk_log_unbuffer(void);
+
+/*!
  * \}
  */
 
diff --git a/framework/include/internal/fwk_multi_thread.h b/framework/include/internal/fwk_multi_thread.h
index 2ec2c6f5..141d7e65 100644
--- a/framework/include/internal/fwk_multi_thread.h
+++ b/framework/include/internal/fwk_multi_thread.h
@@ -114,6 +114,8 @@ struct __fwk_multi_thread_ctx {
      * ready to execute as soon as the CPU becomes available for them.
      */
     struct fwk_slist thread_ready_queue;
+
+    osThreadId_t log_thread_id;
 };
 
 /*
diff --git a/framework/src/Makefile b/framework/src/Makefile
index fb70828f..d594d4c6 100644
--- a/framework/src/Makefile
+++ b/framework/src/Makefile
@@ -12,6 +12,7 @@ BS_LIB_SOURCES += fwk_assert.c
 BS_LIB_SOURCES += fwk_dlist.c
 BS_LIB_SOURCES += fwk_id.c
 BS_LIB_SOURCES += fwk_interrupt.c
+BS_LIB_SOURCES += fwk_log.c
 BS_LIB_SOURCES += fwk_mm.c
 BS_LIB_SOURCES += fwk_module.c
 BS_LIB_SOURCES += fwk_ring.c
diff --git a/framework/src/fwk_arch.c b/framework/src/fwk_arch.c
index b9092bb2..8789596c 100644
--- a/framework/src/fwk_arch.c
+++ b/framework/src/fwk_arch.c
@@ -11,7 +11,7 @@
 #include <internal/fwk_module.h>
 
 #include <fwk_arch.h>
-#include <fwk_host.h>
+#include <fwk_log.h>
 #include <fwk_status.h>
 
 extern int fwk_mm_init(uintptr_t start, size_t size);
@@ -64,7 +64,7 @@ int fwk_arch_init(const struct fwk_arch_init_driver *driver)
 {
     int status;
 
-    FWK_HOST_PRINT("[Framework] Initializing\n");
+    fwk_log_init();
 
     if (driver == NULL)
         return FWK_E_PARAM;
diff --git a/framework/src/fwk_log.c b/framework/src/fwk_log.c
new file mode 100644
index 00000000..9e2e6745
--- /dev/null
+++ b/framework/src/fwk_log.c
@@ -0,0 +1,347 @@
+/*
+ * Arm SCP/MCP Software
+ * Copyright (c) 2020, Arm Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <fwk_assert.h>
+#include <fwk_interrupt.h>
+#include <fwk_log.h>
+#include <fwk_ring.h>
+#include <fwk_status.h>
+
+#include <limits.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+
+static const char FWK_LOG_TERMINATOR[] = { '\r', '\n', '\0' };
+
+static struct {
+    unsigned int dropped; /* Count of messages lost */
+
+    const struct fwk_log_backend *aon_backend; /* Always-on logging backend */
+    const struct fwk_log_backend *backend; /* Dynamic logging backend */
+
+#ifdef FWK_LOG_BUFFERED
+    struct fwk_ring ring; /* Buffer for formatted messages */
+
+    unsigned char remaining; /* Remaining characters in the current message */
+#endif
+} fwk_log_ctx = { 0 };
+
+static int fwk_log_print(const struct fwk_log_backend *backend, char ch)
+{
+    int status;
+
+    if (ch == '\0') {
+        /*
+         * The null terminator indicates the end of the message. We don't want
+         * to send that to the terminal - it doesn't mean anything - but we can
+         * take this opportunity to flush the message out, ensuring the user
+         * doesn't see just half of a message.
+         */
+
+        if (backend->flush == NULL)
+            status = FWK_SUCCESS;
+        else
+            status = backend->flush();
+    } else
+        status = backend->print(ch);
+
+    if (status != FWK_SUCCESS)
+        status = FWK_E_DEVICE;
+
+    return status;
+}
+
+#ifdef FWK_LOG_BUFFERED
+static bool fwk_log_buffer(struct fwk_ring *ring, const char *message)
+{
+    unsigned char length = strlen(message) + 1; /* +1 for null terminator */
+
+    /*
+     * Log messages are stored in the ring buffer prefixed with their length
+     * (including the null terminator). Care must be taken to ensure the length
+     * of each message does not exceed `UCHAR_MAX`.
+     */
+
+    if ((sizeof(length) + length) > fwk_ring_get_free(ring))
+        return false; /* Not enough buffer space */
+
+    fwk_ring_push(ring, (char *)&length, sizeof(length));
+    fwk_ring_push(ring, message, length);
+
+    return true;
+}
+#endif
+
+static void fwk_log_format(
+    char (*buffer)[FMW_LOG_COLUMNS + sizeof(FWK_LOG_TERMINATOR)],
+    const char *format,
+    va_list *args)
+{
+    char *newline;
+
+    /*
+     * Firstly, we need to `snprintf()` the message into a temporary buffer
+     * because we need to manipulate it before we store it in the ring buffer.
+     */
+
+    (void)vsnprintf(
+        *buffer,
+        sizeof(*buffer) - sizeof(FWK_LOG_TERMINATOR) + 1,
+        format,
+        *args);
+
+    /*
+     * Secondly, we need to figure out if the user has accidentally included
+     * their own newline, in which case we consider that to be the end of the
+     * message.
+     */
+
+    newline = strchr(*buffer, '\n');
+    if (newline != NULL)
+        *newline = '\0';
+    else
+        newline = *buffer + strlen(*buffer);
+
+    /*
+     * Lastly, we follow through on that termination with a proper carriage
+     * return and newline. Terminals that don't care about the carriage return
+     * will generally ignore it, but most terminals require it in order to start
+     * the next line at the first column.
+     */
+
+    memcpy(newline, FWK_LOG_TERMINATOR, sizeof(FWK_LOG_TERMINATOR));
+}
+
+void fwk_log_snprintf(const char *format, ...)
+{
+    const struct fwk_log_backend *backend = NULL;
+    bool buffered = false;
+
+    char buffer[FMW_LOG_COLUMNS + sizeof(FWK_LOG_TERMINATOR)];
+
+    va_list args;
+
+    va_start(args, format);
+    fwk_log_format(&buffer, format, &args);
+    va_end(args);
+
+    if (fwk_log_ctx.backend != NULL) {
+        backend = fwk_log_ctx.backend;
+
+#ifdef FWK_LOG_BUFFERED
+        buffered = true;
+#endif
+    } else if (fwk_log_ctx.aon_backend != NULL)
+        backend = fwk_log_ctx.aon_backend;
+    else {
+#ifdef FWK_LOG_BUFFERED
+        buffered = true;
+#endif
+    }
+
+    fwk_interrupt_global_disable(); /* Facilitate reentrancy */
+
+    if (buffered) {
+#ifdef FWK_LOG_BUFFERED
+        /*
+         * Buffer the message that we've received so that the scheduler can
+         * choose when we do the heavy-lifting (typically once we're in an idle
+         * state).
+         */
+
+        bool dropped = !fwk_log_buffer(&fwk_log_ctx.ring, buffer);
+
+        if (dropped) {
+            /*
+             * If we don't have enough room left in the buffer, then we're out
+             * of luck. We don't want to spend what are likely to be precious
+             * cycles printing on the always-on backend, so our best option is
+             * simply to mark the message as dropped and move on.
+             */
+
+            fwk_log_ctx.dropped++;
+        }
+#endif
+    } else if (backend != NULL) {
+        /*
+         * Print the message right now. This is used if buffering is not
+         * enabled, or when a dynamic backend hasn't been registered but an
+         * always-on backend has.
+         */
+
+        char *ch = buffer;
+
+        while (*ch != '\0') {
+            int status = fwk_log_print(backend, *ch++);
+
+            if (status == FWK_PENDING)
+                break;
+        }
+    } else {
+        /*
+         * We can't buffer the message, and we haven't been given a backend
+         * through which we can print the message now, so we just have to drop
+         * this message.
+         */
+
+        fwk_log_ctx.dropped++;
+    }
+
+    fwk_interrupt_global_enable();
+}
+
+void fwk_log_init(void)
+{
+#ifdef FWK_LOG_BUFFERED
+    static char storage[FMW_LOG_BUFFER_SIZE];
+
+    fwk_ring_init(&fwk_log_ctx.ring, storage, sizeof(storage));
+#endif
+}
+
+int fwk_log_unbuffer(void)
+{
+    int status = FWK_SUCCESS;
+
+#ifdef FWK_LOG_BUFFERED
+    unsigned char fetched;
+    char ch;
+
+    fwk_interrupt_global_disable();
+
+    if (fwk_log_ctx.remaining == 0) {
+        /*
+         * We've finished printing whatever message we were previously on, so we
+         * need to try and fetch the next one.
+         */
+
+        bool empty = !fwk_ring_pop(
+            &fwk_log_ctx.ring,
+            (char *)&fwk_log_ctx.remaining,
+            sizeof(fwk_log_ctx.remaining));
+
+        if (empty) {
+            /*
+             * At this point we've cleared the buffer of any remaining messages.
+             * If we were forced to drop any messages prior to this point, now
+             * is a good time to let the user know.
+             */
+
+            if (fwk_log_ctx.dropped > 0) {
+                fwk_log_snprintf(
+                    "[FWK] ... and %u more messages...", fwk_log_ctx.dropped);
+
+                fwk_log_ctx.dropped = 0;
+
+                status = FWK_PENDING;
+            }
+
+            goto exit;
+        }
+    }
+
+    /*
+     * Before we try to print anything, we should ensure that we still have a
+     * dynamic backend available on which to print - it may have been
+     * deregistered.
+     */
+
+    if (fwk_log_ctx.backend == NULL) {
+        status = FWK_PENDING;
+
+        goto exit;
+    }
+
+    /*
+     * Grab the next character from the ring buffer and try to print it.
+     * Printing the character successfully will result in a pending return value
+     * even if it is the last character in the message - the next call to this
+     * function will run the logic above to finalize the message.
+     */
+
+    fetched = fwk_ring_pop(&fwk_log_ctx.ring, &ch, sizeof(ch));
+    fwk_assert(fetched == sizeof(char));
+
+    status = fwk_log_print(fwk_log_ctx.backend, ch);
+    if (status == FWK_SUCCESS) {
+        fwk_log_ctx.remaining--;
+
+        status = FWK_PENDING;
+    }
+
+exit:
+    fwk_interrupt_global_enable();
+#endif
+
+    return status;
+}
+
+void fwk_log_flush(void)
+{
+#ifdef FWK_LOG_BUFFERED
+    int status;
+
+    fwk_interrupt_global_disable();
+
+    do {
+        status = fwk_log_unbuffer();
+    } while (status == FWK_PENDING);
+
+    fwk_interrupt_global_enable();
+#endif
+
+    if (fwk_log_ctx.backend != NULL)
+        fwk_log_ctx.backend->flush();
+
+    if (fwk_log_ctx.aon_backend != NULL)
+        fwk_log_ctx.aon_backend->flush();
+}
+
+int fwk_log_register_aon(const struct fwk_log_backend *backend)
+{
+    if (fwk_log_ctx.aon_backend != NULL)
+        return FWK_E_INIT;
+
+    fwk_log_ctx.aon_backend = backend;
+
+    return FWK_SUCCESS;
+}
+
+const struct fwk_log_backend *fwk_log_deregister_aon(void)
+{
+    const struct fwk_log_backend *backend = NULL;
+
+    backend = fwk_log_ctx.aon_backend;
+
+    fwk_log_ctx.aon_backend = NULL;
+
+    return backend;
+}
+
+int fwk_log_register(const struct fwk_log_backend *backend)
+{
+    if (fwk_log_ctx.backend != NULL)
+        return FWK_E_INIT;
+
+    fwk_log_ctx.backend = backend;
+
+    return FWK_SUCCESS;
+}
+
+const struct fwk_log_backend *fwk_log_deregister(void)
+{
+    const struct fwk_log_backend *backend = NULL;
+
+    backend = fwk_log_ctx.backend;
+
+    fwk_log_ctx.backend = NULL;
+
+    return backend;
+}
diff --git a/framework/src/fwk_module.c b/framework/src/fwk_module.c
index c617d74e..b4d8da64 100644
--- a/framework/src/fwk_module.c
+++ b/framework/src/fwk_module.c
@@ -20,8 +20,8 @@
 #include <fwk_cli_dbg.h>
 #include <fwk_dlist.h>
 #include <fwk_element.h>
-#include <fwk_host.h>
 #include <fwk_list.h>
+#include <fwk_log.h>
 #include <fwk_mm.h>
 #include <fwk_module.h>
 #include <fwk_status.h>
@@ -67,10 +67,8 @@ extern const struct fwk_module_config *module_config_table[];
 
 static struct context ctx;
 
-#ifdef BUILD_HOST
-static const char err_msg_line[] = "[MOD] Error %d in %s @%d\n";
-static const char err_msg_func[] = "[MOD] Error %d in %s\n";
-#endif
+static const char err_msg_line[] = "[MOD] Error %d in %s @%d";
+static const char err_msg_func[] = "[MOD] Error %d in %s";
 
 /*
  * Static functions
@@ -121,7 +119,7 @@ static int init_elements(struct fwk_module_ctx *module_ctx,
 
         /* Each element must have a valid pointer to specific data */
         if (!fwk_expect(element->data != NULL)) {
-            FWK_HOST_PRINT(err_msg_line, FWK_E_DATA, __func__, __LINE__);
+            FWK_LOG_CRIT(err_msg_line, FWK_E_DATA, __func__, __LINE__);
             return FWK_E_DATA;
         }
 
@@ -141,7 +139,7 @@ static int init_elements(struct fwk_module_ctx *module_ctx,
         status = module->element_init(
             element_id, element->sub_element_count, element->data);
         if (!fwk_expect(status == FWK_SUCCESS)) {
-            FWK_HOST_PRINT(err_msg_func, status, __func__);
+            FWK_LOG_CRIT(err_msg_func, status, __func__);
             return status;
         }
 
@@ -196,14 +194,14 @@ static int init_module(struct fwk_module_ctx *module_ctx,
     status = module->init(module_ctx->id, module_ctx->element_count,
                           module_config->data);
     if (!fwk_expect(status == FWK_SUCCESS)) {
-        FWK_HOST_PRINT(err_msg_line, status, __func__, __LINE__);
+        FWK_LOG_CRIT(err_msg_line, status, __func__, __LINE__);
         return status;
     }
 
     if (module_ctx->element_count > 0) {
         status = init_elements(module_ctx, element_table);
         if (status != FWK_SUCCESS) {
-            FWK_HOST_PRINT(err_msg_line, status, __func__, __LINE__);
+            FWK_LOG_CRIT(err_msg_line, status, __func__, __LINE__);
             return status;
         }
     }
@@ -211,7 +209,7 @@ static int init_module(struct fwk_module_ctx *module_ctx,
     if (module->post_init != NULL) {
         status = module->post_init(module_ctx->id);
         if (!fwk_expect(status == FWK_SUCCESS)) {
-            FWK_HOST_PRINT(err_msg_line, status, __func__, __LINE__);
+            FWK_LOG_CRIT(err_msg_line, status, __func__, __LINE__);
             return status;
         }
     }
@@ -239,7 +237,7 @@ static int init_modules(void)
         status = init_module(module_ctx, module_table[module_idx],
                              module_config_table[module_idx]);
         if (status != FWK_SUCCESS) {
-            FWK_HOST_PRINT(err_msg_line, status, __func__, __LINE__);
+            FWK_LOG_CRIT(err_msg_line, status, __func__, __LINE__);
             return status;
         }
     }
@@ -262,7 +260,7 @@ static int bind_elements(struct fwk_module_ctx *module_ctx,
         ctx.bind_id = fwk_id_build_element_id(module_ctx->id, element_idx);
         status = module->bind(ctx.bind_id, round);
         if (!fwk_expect(status == FWK_SUCCESS)) {
-            FWK_HOST_PRINT(err_msg_func, status, __func__);
+            FWK_LOG_CRIT(err_msg_func, status, __func__);
             return status;
         }
 
@@ -290,7 +288,7 @@ static int bind_module(struct fwk_module_ctx *module_ctx,
     ctx.bind_id = module_ctx->id;
     status = module->bind(module_ctx->id, round);
     if (!fwk_expect(status == FWK_SUCCESS)) {
-        FWK_HOST_PRINT(err_msg_func, status, __func__);
+        FWK_LOG_CRIT(err_msg_func, status, __func__);
         return status;
     }
 
@@ -330,7 +328,7 @@ static int start_elements(struct fwk_module_ctx *module_ctx)
             status = module->start(
                 fwk_id_build_element_id(module_ctx->id, element_idx));
             if (!fwk_expect(status == FWK_SUCCESS)) {
-                FWK_HOST_PRINT(err_msg_func, status, __func__);
+                FWK_LOG_CRIT(err_msg_func, status, __func__);
                 return status;
             }
         }
@@ -352,7 +350,7 @@ static int start_module(struct fwk_module_ctx *module_ctx)
     if (module->start != NULL) {
         status = module->start(module_ctx->id);
         if (!fwk_expect(status == FWK_SUCCESS)) {
-            FWK_HOST_PRINT(err_msg_func, status, __func__);
+            FWK_LOG_CRIT(err_msg_func, status, __func__);
             return status;
         }
     }
@@ -388,7 +386,7 @@ int __fwk_module_init(void)
     unsigned int bind_round;
 
     if (ctx.initialized) {
-        FWK_HOST_PRINT(err_msg_func, FWK_E_STATE, __func__);
+        FWK_LOG_CRIT(err_msg_func, FWK_E_STATE, __func__);
         return FWK_E_STATE;
     }
 
@@ -651,7 +649,7 @@ int fwk_module_bind(fwk_id_t target_id, fwk_id_t api_id, const void *api)
     status = module_ctx->desc->process_bind_request(ctx.bind_id, target_id,
                                                     api_id, (const void **)api);
     if (!fwk_expect(status == FWK_SUCCESS)) {
-        FWK_HOST_PRINT(err_msg_line, status, __func__, __LINE__);
+        FWK_LOG_CRIT(err_msg_line, status, __func__, __LINE__);
         return status;
     }
 
@@ -664,6 +662,6 @@ int fwk_module_bind(fwk_id_t target_id, fwk_id_t api_id, const void *api)
 
 error:
     fwk_expect(false);
-    FWK_HOST_PRINT(err_msg_func, status, __func__);
+    FWK_LOG_CRIT(err_msg_func, status, __func__);
     return status;
 }
diff --git a/framework/src/fwk_multi_thread.c b/framework/src/fwk_multi_thread.c
index 85415297..257a64d9 100644
--- a/framework/src/fwk_multi_thread.c
+++ b/framework/src/fwk_multi_thread.c
@@ -16,10 +16,10 @@
 
 #include <fwk_assert.h>
 #include <fwk_event.h>
-#include <fwk_host.h>
 #include <fwk_id.h>
 #include <fwk_interrupt.h>
 #include <fwk_list.h>
+#include <fwk_log.h>
 #include <fwk_macros.h>
 #include <fwk_mm.h>
 #include <fwk_module.h>
@@ -38,19 +38,18 @@
 #endif
 
 #ifndef FIRMWARE_STACK_SIZE
-#    define FIRMWARE_STACK_SIZE (1 * FWK_KIB)
+#    define FIRMWARE_STACK_SIZE 1536
 #endif
 
 #define SIGNAL_ISR_EVENT 0x01
 #define SIGNAL_EVENT_TO_PROCESS 0x02
 #define SIGNAL_EVENT_PROCESSED 0x04
 #define SIGNAL_NO_READY_THREAD 0x08
+#define SIGNAL_CHECK_LOGS 0x10
 
 static struct __fwk_multi_thread_ctx ctx;
-#ifdef BUILD_HOST
-static const char err_msg_line[] = "[THR] Error %d @%d\n";
-static const char err_msg_func[] = "[THR] Error %d in %s\n";
-#endif
+static const char err_msg_line[] = "[FWK] Error %d @%d";
+static const char err_msg_func[] = "[FWK] Error %d in %s";
 
 /*
  * Static functions
@@ -123,7 +122,7 @@ static struct fwk_event *duplicate_event(struct fwk_event *event)
     }
 
     assert(false);
-    FWK_HOST_PRINT(err_msg_func, FWK_E_NOMEM, __func__);
+    FWK_LOG_CRIT(err_msg_func, FWK_E_NOMEM, __func__);
     return NULL;
 }
 
@@ -176,10 +175,6 @@ static int put_isr_event(struct fwk_event *event)
     if (allocated_event == NULL)
         return FWK_E_NOMEM;
 
-    FWK_HOST_PRINT("[THR] Add ISR event (%s,%s,%s)\n",
-                   FWK_ID_STR(event->source_id),
-                   FWK_ID_STR(event->target_id), FWK_ID_STR(event->id));
-
     /*
      * Assumption: there are no interrupt priorities, at least among interrupts
      * leading to the call of fwk_thread_put_event(). As a consequence the
@@ -192,7 +187,7 @@ static int put_isr_event(struct fwk_event *event)
         flags = osThreadFlagsSet(ctx.common_thread_ctx.os_thread_id,
                                  SIGNAL_ISR_EVENT);
         if ((int32_t)flags < 0) {
-            FWK_HOST_PRINT(err_msg_func, FWK_E_OS, __func__);
+            FWK_LOG_CRIT(err_msg_func, FWK_E_OS, __func__);
             return FWK_E_OS;
         }
         ctx.waiting_for_isr_event = false;
@@ -246,10 +241,6 @@ static int put_event(struct __fwk_thread_ctx *target_thread_ctx,
     struct fwk_event *allocated_event;
     bool is_empty;
 
-    FWK_HOST_PRINT("[THR] Add event to thread queue (%s,%s,%s)\n",
-                   FWK_ID_STR(event->source_id), FWK_ID_STR(event->target_id),
-                   FWK_ID_STR(event->id));
-
     event->is_thread_wakeup_event = is_thread_wakeup_event(
         target_thread_ctx, event);
 
@@ -294,7 +285,7 @@ static int put_event(struct __fwk_thread_ctx *target_thread_ctx,
     return FWK_SUCCESS;
 
 error:
-    FWK_HOST_PRINT(err_msg_func, status, __func__);
+    FWK_LOG_CRIT(err_msg_func, status, __func__);
     return status;
 }
 
@@ -327,7 +318,7 @@ static void process_event_requiring_response(struct fwk_event *event)
 
     status = process_event(event, &resp_event);
     if (status != FWK_SUCCESS)
-        FWK_HOST_PRINT(err_msg_line, status, __LINE__);
+        FWK_LOG_CRIT(err_msg_line, status, __LINE__);
 
     resp_event.is_response = true;
     resp_event.response_requested = false;
@@ -368,10 +359,6 @@ static void process_next_thread_event(struct __fwk_thread_ctx *thread_ctx)
                      struct fwk_event, slist_node);
     assert(event != NULL);
 
-    FWK_HOST_PRINT("[THR] Process thread event (%s,%s,%s)\n",
-                   FWK_ID_STR(event->source_id),
-                   FWK_ID_STR(event->target_id), FWK_ID_STR(event->id));
-
     if (event->response_requested)
         process_event_requiring_response(event);
     else {
@@ -381,7 +368,7 @@ static void process_next_thread_event(struct __fwk_thread_ctx *thread_ctx)
         else
             status = module->process_event(event, &async_resp_event);
         if (status != FWK_SUCCESS)
-            FWK_HOST_PRINT(err_msg_line, status, __LINE__);
+            FWK_LOG_CRIT(err_msg_line, status, __LINE__);
     }
 
     /* No event currently processed, no thread currently active. */
@@ -443,7 +430,7 @@ static struct __fwk_thread_ctx *launch_next_event_processing(
                 return next_thread_ctx;
         }
 
-        FWK_HOST_PRINT(err_msg_line, FWK_E_OS, __LINE__);
+        FWK_LOG_CRIT(err_msg_line, FWK_E_OS, __LINE__);
         event = FWK_LIST_GET(fwk_list_pop_head(&next_thread_ctx->event_queue),
                              struct fwk_event, slist_node);
         free_event(event);
@@ -479,7 +466,7 @@ static void thread_function(struct __fwk_thread_ctx *thread_ctx,
             flags = osThreadFlagsWait(signals, osFlagsWaitAny, osWaitForever);
             /* If there is more than one flag raised or not an expected one */
             if ((flags & (flags - 1)) || (!(flags & signals))) {
-                FWK_HOST_PRINT(err_msg_line, FWK_E_OS, __LINE__);
+                FWK_LOG_CRIT(err_msg_line, FWK_E_OS, __LINE__);
                 continue;
             }
             if (flags & SIGNAL_NO_READY_THREAD)
@@ -513,7 +500,12 @@ static void thread_function(struct __fwk_thread_ctx *thread_ctx,
         flags = osThreadFlagsSet(
             ctx.common_thread_ctx.os_thread_id, SIGNAL_NO_READY_THREAD);
         if ((int32_t)flags < 0)
-            FWK_HOST_PRINT(err_msg_line, FWK_E_OS, __LINE__);
+            FWK_LOG_CRIT(err_msg_line, FWK_E_OS, __LINE__);
+
+        /* Let the logging thread know we might have messages to process */
+        flags = osThreadFlagsSet(ctx.log_thread_id, SIGNAL_CHECK_LOGS);
+        if ((int32_t)flags < 0)
+            FWK_LOG_CRIT(err_msg_line, FWK_E_OS, __LINE__);
     }
 }
 
@@ -539,7 +531,7 @@ static void get_next_isr_event(void)
             flags = osThreadFlagsWait(
                 SIGNAL_ISR_EVENT, osFlagsWaitAll, osWaitForever);
             if (flags != SIGNAL_ISR_EVENT)
-                FWK_HOST_PRINT(err_msg_line, FWK_E_OS, __LINE__);
+                FWK_LOG_CRIT(err_msg_line, FWK_E_OS, __LINE__);
             continue;
         }
 
@@ -548,10 +540,12 @@ static void get_next_isr_event(void)
         fwk_interrupt_global_enable();
 
         assert(isr_event != NULL);
-        FWK_HOST_PRINT("[THR] Get ISR event (%s,%s,%s)\n",
-                       FWK_ID_STR(isr_event->source_id),
-                       FWK_ID_STR(isr_event->target_id),
-                       FWK_ID_STR(isr_event->id));
+
+        FWK_LOG_TRACE(
+            "[FWK] Get ISR event (%s: %s -> %s)\n",
+            FWK_ID_STR(isr_event->id),
+            FWK_ID_STR(isr_event->source_id),
+            FWK_ID_STR(isr_event->target_id));
 
         target_thread_ctx = thread_get_ctx(isr_event->target_id);
 
@@ -592,6 +586,32 @@ static void common_thread_function(void *arg)
     }
 }
 
+static void logging_thread(void *arg)
+{
+    while (true) {
+        int status;
+
+        (void)osThreadFlagsWait(
+            SIGNAL_CHECK_LOGS, osFlagsNoClear, osWaitForever);
+
+        /*
+         * At this point we've received a signal from one of the other threads
+         * that there might be log messages we need to process. Because logging
+         * is a low-priority task, we yield as soon as we've printed a character
+         * in order to maintain lower latencies elsewhere.
+         *
+         * We will only clear the signal once we have emptied out the log
+         * buffer (at which point we will enter an idle state).
+         */
+
+        status = fwk_log_unbuffer();
+        if (status == FWK_SUCCESS)
+            osThreadFlagsClear(SIGNAL_CHECK_LOGS);
+        else if (status != FWK_PENDING)
+            FWK_LOG_WARN("[FWK] Warning: unable to unbuffer logged message");
+    }
+}
+
 /*
  * Private interface functions
  */
@@ -632,12 +652,27 @@ int __fwk_thread_init(size_t event_count)
         goto error;
     }
 
+    /* Initialize the logging thread */
+
+    status = init_thread_attr(&thread_attr);
+    if (status != FWK_SUCCESS)
+        goto error;
+
+    thread_attr.priority = osPriorityLow;
+
+    ctx.log_thread_id = osThreadNew(logging_thread, NULL, &thread_attr);
+    if (ctx.log_thread_id == NULL) {
+        status = FWK_E_OS;
+
+        goto error;
+    }
+
     ctx.initialized = true;
 
     return FWK_SUCCESS;
 
 error:
-    FWK_HOST_PRINT(err_msg_func, status, __func__);
+    FWK_LOG_CRIT(err_msg_func, status, __func__);
     return status;
 }
 
@@ -674,7 +709,7 @@ int __fwk_thread_put_notification(struct fwk_event *event)
 
     /* Call from an ISR */
     if (!fwk_module_is_valid_entity_id(event->source_id)) {
-        FWK_HOST_PRINT(err_msg_func, FWK_E_PARAM, __func__);
+        FWK_LOG_CRIT(err_msg_func, FWK_E_PARAM, __func__);
         return FWK_E_PARAM;
     }
 
@@ -735,7 +770,7 @@ int fwk_thread_create(fwk_id_t id)
     return FWK_SUCCESS;
 
 error:
-    FWK_HOST_PRINT(err_msg_func, status, __func__);
+    FWK_LOG_CRIT(err_msg_func, status, __func__);
     return status;
 }
 
@@ -799,7 +834,7 @@ int fwk_thread_put_event(struct fwk_event *event)
     return put_isr_event(event);
 
 error:
-    FWK_HOST_PRINT(err_msg_func, status, __func__);
+    FWK_LOG_CRIT(err_msg_func, status, __func__);
     return status;
 }
 
@@ -880,6 +915,6 @@ int fwk_thread_put_event_and_wait(struct fwk_event *event,
     return FWK_SUCCESS;
 
 error:
-    FWK_HOST_PRINT(err_msg_func, status, __func__);
+    FWK_LOG_CRIT(err_msg_func, status, __func__);
     return status;
 }
diff --git a/framework/src/fwk_notification.c b/framework/src/fwk_notification.c
index cd80f6d4..3bc8de71 100644
--- a/framework/src/fwk_notification.c
+++ b/framework/src/fwk_notification.c
@@ -15,10 +15,10 @@
 #include <fwk_assert.h>
 #include <fwk_dlist.h>
 #include <fwk_event.h>
-#include <fwk_host.h>
 #include <fwk_id.h>
 #include <fwk_interrupt.h>
 #include <fwk_list.h>
+#include <fwk_log.h>
 #include <fwk_mm.h>
 #include <fwk_module.h>
 #include <fwk_notification.h>
@@ -42,9 +42,7 @@ struct notification_ctx {
 
 static struct notification_ctx ctx;
 
-#ifdef BUILD_HOST
-static const char err_msg_func[] = "[NOT] Error %d in %s\n";
-#endif
+static const char err_msg_func[] = "[NOT] Error %d in %s";
 
 /*
  * Static functions
@@ -238,7 +236,7 @@ int fwk_notification_subscribe(fwk_id_t notification_id, fwk_id_t source_id,
     return FWK_SUCCESS;
 
 error:
-    FWK_HOST_PRINT(err_msg_func, status, __func__);
+    FWK_LOG_CRIT(err_msg_func, status, __func__);
     return status;
 }
 
@@ -285,7 +283,7 @@ int fwk_notification_unsubscribe(fwk_id_t notification_id, fwk_id_t source_id,
     return FWK_SUCCESS;
 
 error:
-    FWK_HOST_PRINT(err_msg_func, status, __func__);
+    FWK_LOG_CRIT(err_msg_func, status, __func__);
     return status;
 }
 
@@ -335,6 +333,6 @@ int fwk_notification_notify(struct fwk_event *notification_event,
     return FWK_SUCCESS;
 
 error:
-    FWK_HOST_PRINT(err_msg_func, status, __func__);
+    FWK_LOG_CRIT(err_msg_func, status, __func__);
     return status;
 }
diff --git a/framework/src/fwk_thread.c b/framework/src/fwk_thread.c
index 6e6e741b..b0026195 100644
--- a/framework/src/fwk_thread.c
+++ b/framework/src/fwk_thread.c
@@ -15,10 +15,10 @@
 
 #include <fwk_assert.h>
 #include <fwk_event.h>
-#include <fwk_host.h>
 #include <fwk_id.h>
 #include <fwk_interrupt.h>
 #include <fwk_list.h>
+#include <fwk_log.h>
 #include <fwk_mm.h>
 #include <fwk_module.h>
 #include <fwk_noreturn.h>
@@ -31,10 +31,8 @@
 
 static struct __fwk_thread_ctx ctx;
 
-#ifdef BUILD_HOST
-static const char err_msg_line[] = "[THR] Error %d in %s @%d\n";
-static const char err_msg_func[] = "[THR] Error %d in %s\n";
-#endif
+static const char err_msg_line[] = "[FWK] Error %d in %s @%d";
+static const char err_msg_func[] = "[FWK] Error %d in %s";
 
 /*
  * Static functions
@@ -62,7 +60,7 @@ static struct fwk_event *duplicate_event(struct fwk_event *event)
     fwk_interrupt_global_enable();
 
     if (allocated_event == NULL) {
-        FWK_HOST_PRINT(err_msg_func, FWK_E_NOMEM, __func__);
+        FWK_LOG_CRIT(err_msg_func, FWK_E_NOMEM, __func__);
         fwk_assert(false);
     }
 
@@ -81,7 +79,7 @@ static int put_event(struct fwk_event *event)
         allocated_event = __fwk_thread_search_delayed_response(
             event->source_id, event->cookie);
         if (allocated_event == NULL) {
-            FWK_HOST_PRINT(err_msg_func, FWK_E_NOMEM, __func__);
+            FWK_LOG_CRIT(err_msg_func, FWK_E_NOMEM, __func__);
             return FWK_E_PARAM;
         }
 
@@ -121,9 +119,11 @@ static void process_next_event(void)
     ctx.current_event = event = FWK_LIST_GET(
         fwk_list_pop_head(&ctx.event_queue), struct fwk_event, slist_node);
 
-    FWK_HOST_PRINT("[THR] Get event (%s,%s,%s)\n",
-                   FWK_ID_STR(event->source_id), FWK_ID_STR(event->target_id),
-                   FWK_ID_STR(event->id));
+    FWK_LOG_TRACE(
+        "[FWK] Get event (%s: %s -> %s)\n",
+        FWK_ID_STR(event->id),
+        FWK_ID_STR(event->source_id),
+        FWK_ID_STR(event->target_id));
 
     module = __fwk_module_get_ctx(event->target_id)->desc;
     process_event = event->is_notification ? module->process_notification :
@@ -137,7 +137,7 @@ static void process_next_event(void)
 
         status = process_event(event, &async_response_event);
         if (status != FWK_SUCCESS)
-            FWK_HOST_PRINT(err_msg_line, status, __func__, __LINE__);
+            FWK_LOG_CRIT(err_msg_line, status, __func__, __LINE__);
 
         async_response_event.is_response = true;
         async_response_event.response_requested = false;
@@ -155,7 +155,7 @@ static void process_next_event(void)
     } else {
         status = process_event(event, &async_response_event);
         if (status != FWK_SUCCESS)
-            FWK_HOST_PRINT(err_msg_line, status, __func__, __LINE__);
+            FWK_LOG_CRIT(err_msg_line, status, __func__, __LINE__);
     }
 
     ctx.current_event = NULL;
@@ -176,10 +176,11 @@ static void process_isr(void)
                              struct fwk_event, slist_node);
     fwk_interrupt_global_enable();
 
-    FWK_HOST_PRINT("[THR] Get ISR event (%s,%s,%s)\n",
-                   FWK_ID_STR(isr_event->source_id),
-                   FWK_ID_STR(isr_event->target_id),
-                   FWK_ID_STR(isr_event->id));
+    FWK_LOG_TRACE(
+        "[FWK] Get ISR event (%s: %s -> %s)\n",
+        FWK_ID_STR(isr_event->id),
+        FWK_ID_STR(isr_event->source_id),
+        FWK_ID_STR(isr_event->target_id));
 
     fwk_list_push_tail(&ctx.event_queue, &isr_event->slist_node);
 }
@@ -215,8 +216,11 @@ noreturn void __fwk_thread_run(void)
         while (!fwk_list_is_empty(&ctx.event_queue))
             process_next_event();
 
-        while (fwk_list_is_empty(&ctx.isr_event_queue))
+        while (fwk_list_is_empty(&ctx.isr_event_queue)) {
+            fwk_log_unbuffer();
+
             continue;
+        }
 
         process_isr();
     }
@@ -286,6 +290,6 @@ int fwk_thread_put_event(struct fwk_event *event)
     return put_event(event);
 
 error:
-    FWK_HOST_PRINT(err_msg_func, status, __func__);
+    FWK_LOG_CRIT(err_msg_func, status, __func__);
     return status;
 }
diff --git a/framework/src/fwk_thread_delayed_resp.c b/framework/src/fwk_thread_delayed_resp.c
index 77bfe00c..d6fe5893 100644
--- a/framework/src/fwk_thread_delayed_resp.c
+++ b/framework/src/fwk_thread_delayed_resp.c
@@ -8,10 +8,10 @@
 #include <internal/fwk_module.h>
 
 #include <fwk_event.h>
-#include <fwk_host.h>
 #include <fwk_id.h>
 #include <fwk_interrupt.h>
 #include <fwk_list.h>
+#include <fwk_log.h>
 #include <fwk_module.h>
 #include <fwk_status.h>
 
@@ -19,9 +19,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#ifdef BUILD_HOST
-static const char err_msg_func[] = "[THR] Error %d in %s\n";
-#endif
+static const char err_msg_func[] = "[FWK] Error %d in %s";
 
 /*
  * Static functions
@@ -100,7 +98,7 @@ int fwk_thread_get_delayed_response(
     return FWK_SUCCESS;
 
 error:
-    FWK_HOST_PRINT(err_msg_func, status, __func__);
+    FWK_LOG_CRIT(err_msg_func, status, __func__);
     return status;
 }
 
@@ -124,7 +122,7 @@ int fwk_thread_is_delayed_response_list_empty(
     return FWK_SUCCESS;
 
 error:
-    FWK_HOST_PRINT(err_msg_func, status, __func__);
+    FWK_LOG_CRIT(err_msg_func, status, __func__);
     return status;
 }
 
@@ -152,6 +150,6 @@ int fwk_thread_get_first_delayed_response(
     return FWK_SUCCESS;
 
 error:
-    FWK_HOST_PRINT(err_msg_func, status, __func__);
+    FWK_LOG_CRIT(err_msg_func, status, __func__);
     return status;
 }
diff --git a/framework/test/Makefile b/framework/test/Makefile
index e3c58e7d..98a7cf27 100644
--- a/framework/test/Makefile
+++ b/framework/test/Makefile
@@ -43,6 +43,7 @@ COMMON_SRC += fwk_assert.c
 COMMON_SRC += fwk_dlist.c
 COMMON_SRC += fwk_id.c
 COMMON_SRC += fwk_interrupt.c
+COMMON_SRC += fwk_log.c
 COMMON_SRC += fwk_mm.c
 COMMON_SRC += fwk_module.c
 COMMON_SRC += fwk_ring.c
@@ -135,6 +136,7 @@ test_fwk_multi_thread_init_WRAP += fwk_module_is_valid_module_id
 test_fwk_multi_thread_init_WRAP += fwk_module_is_valid_notification_id
 test_fwk_multi_thread_init_WRAP += osKernelInitialize
 test_fwk_multi_thread_init_WRAP += osKernelStart
+test_fwk_multi_thread_init_WRAP += osThreadFlagsClear
 test_fwk_multi_thread_init_WRAP += osThreadFlagsSet
 test_fwk_multi_thread_init_WRAP += osThreadFlagsWait
 test_fwk_multi_thread_init_WRAP += osThreadNew
@@ -154,6 +156,7 @@ test_fwk_multi_thread_create_WRAP += fwk_module_is_valid_module_id
 test_fwk_multi_thread_create_WRAP += fwk_module_is_valid_notification_id
 test_fwk_multi_thread_create_WRAP += osKernelInitialize
 test_fwk_multi_thread_create_WRAP += osKernelStart
+test_fwk_multi_thread_create_WRAP += osThreadFlagsClear
 test_fwk_multi_thread_create_WRAP += osThreadFlagsSet
 test_fwk_multi_thread_create_WRAP += osThreadFlagsWait
 test_fwk_multi_thread_create_WRAP += osThreadNew
@@ -172,6 +175,7 @@ test_fwk_multi_thread_common_thread_WRAP += fwk_module_is_valid_module_id
 test_fwk_multi_thread_common_thread_WRAP += fwk_module_is_valid_notification_id
 test_fwk_multi_thread_common_thread_WRAP += osKernelInitialize
 test_fwk_multi_thread_common_thread_WRAP += osKernelStart
+test_fwk_multi_thread_common_thread_WRAP += osThreadFlagsClear
 test_fwk_multi_thread_common_thread_WRAP += osThreadFlagsSet
 test_fwk_multi_thread_common_thread_WRAP += osThreadFlagsWait
 test_fwk_multi_thread_common_thread_WRAP += osThreadNew
@@ -191,6 +195,7 @@ test_fwk_multi_thread_put_event_WRAP += fwk_module_is_valid_module_id
 test_fwk_multi_thread_put_event_WRAP += fwk_module_is_valid_notification_id
 test_fwk_multi_thread_put_event_WRAP += osKernelInitialize
 test_fwk_multi_thread_put_event_WRAP += osKernelStart
+test_fwk_multi_thread_put_event_WRAP += osThreadFlagsClear
 test_fwk_multi_thread_put_event_WRAP += osThreadFlagsSet
 test_fwk_multi_thread_put_event_WRAP += osThreadFlagsWait
 test_fwk_multi_thread_put_event_WRAP += osThreadNew
@@ -210,6 +215,7 @@ test_fwk_multi_thread_util_WRAP += fwk_module_is_valid_module_id
 test_fwk_multi_thread_util_WRAP += fwk_module_is_valid_notification_id
 test_fwk_multi_thread_util_WRAP += osKernelInitialize
 test_fwk_multi_thread_util_WRAP += osKernelStart
+test_fwk_multi_thread_util_WRAP += osThreadFlagsClear
 test_fwk_multi_thread_util_WRAP += osThreadFlagsSet
 test_fwk_multi_thread_util_WRAP += osThreadFlagsWait
 test_fwk_multi_thread_util_WRAP += osThreadNew
diff --git a/framework/test/test_fwk_multi_thread_common_thread.c b/framework/test/test_fwk_multi_thread_common_thread.c
index 62cb4093..9c0e95a9 100644
--- a/framework/test/test_fwk_multi_thread_common_thread.c
+++ b/framework/test/test_fwk_multi_thread_common_thread.c
@@ -139,13 +139,18 @@ uint32_t __wrap_osThreadFlagsSet(osThreadId_t thread_id, uint32_t flags)
     return osThreadFlagsSet_return_val[osThreadFlagsSet_call_count++];
 }
 
+uint32_t __wrap_osThreadFlagsClear(uint32_t flags)
+{
+    return osThreadFlagsSet_param_flags[osThreadFlagsSet_call_count];
+}
+
 static osThreadFunc_t common_thread_function;
 static osThreadFunc_t specific_thread_function;
 osThreadId_t __wrap_osThreadNew(osThreadFunc_t func, void *argument,
                                 const osThreadAttr_t *attr)
 {
     static unsigned int call_count = 0;
-    assert(call_count < 2);
+    assert(call_count < 3);
 
     (void) argument;
     (void) attr;
@@ -901,7 +906,7 @@ static void test_thread_function_4(void)
     assert(osThreadFlagsWait_param_flags[1] == SIGNAL_EVENT_TO_PROCESS);
     assert(osThreadFlagsWait_param_flags[2] == 0);
 
-    assert(osThreadFlagsSet_call_count == 1);
+    assert(osThreadFlagsSet_call_count == 2);
     assert(osThreadFlagsSet_param_flags[0] == SIGNAL_NO_READY_THREAD);
     assert(osThreadFlagsSet_param_thread_id[0] ==
         (osThreadId_t)COMMON_THREAD_ID);
@@ -1107,7 +1112,7 @@ static void test_thread_function_8(void)
     assert(osThreadFlagsWait_param_flags[1] == SIGNAL_EVENT_TO_PROCESS);
     assert(osThreadFlagsWait_param_flags[2] == 0);
 
-    assert(osThreadFlagsSet_call_count == 1);
+    assert(osThreadFlagsSet_call_count == 2);
     assert(osThreadFlagsSet_param_flags[0] == SIGNAL_NO_READY_THREAD);
     assert(osThreadFlagsSet_param_thread_id[0] ==
         (osThreadId_t)COMMON_THREAD_ID);
@@ -1197,7 +1202,7 @@ static void test_thread_function_10(void)
     assert(osThreadFlagsWait_param_flags[1] == SIGNAL_EVENT_TO_PROCESS);
     assert(osThreadFlagsWait_param_flags[2] == 0);
 
-    assert(osThreadFlagsSet_call_count == 1);
+    assert(osThreadFlagsSet_call_count == 2);
     assert(osThreadFlagsSet_param_flags[0] == SIGNAL_NO_READY_THREAD);
     assert(osThreadFlagsSet_param_thread_id[0] ==
         (osThreadId_t)COMMON_THREAD_ID);
@@ -1399,7 +1404,7 @@ static void test_process_next_thread_event_3(void)
     assert(osThreadFlagsWait_param_flags[1] == SIGNAL_EVENT_TO_PROCESS);
     assert(osThreadFlagsWait_param_flags[2] == 0);
 
-    assert(osThreadFlagsSet_call_count == 1);
+    assert(osThreadFlagsSet_call_count == 2);
     assert(osThreadFlagsSet_param_flags[0] == SIGNAL_NO_READY_THREAD);
     assert(osThreadFlagsSet_param_thread_id[0] ==
         (osThreadId_t)COMMON_THREAD_ID);
diff --git a/framework/test/test_fwk_multi_thread_create.c b/framework/test/test_fwk_multi_thread_create.c
index ca3f6f28..5fbf6948 100644
--- a/framework/test/test_fwk_multi_thread_create.c
+++ b/framework/test/test_fwk_multi_thread_create.c
@@ -62,6 +62,12 @@ uint32_t __wrap_osThreadFlagsWait(uint32_t flags, uint32_t options,
     return flags;
 }
 
+uint32_t __wrap_osThreadFlagsClear(uint32_t flags)
+{
+    (void)flags;
+    return 0;
+}
+
 uint32_t __wrap_osThreadFlagsSet(osThreadId_t thread_id, uint32_t flags)
 {
     (void) thread_id;
@@ -186,24 +192,12 @@ static void test_case_setup(void)
     fwk_module_is_valid_module_id_return_val = true;
 }
 
-static void check_osThreadNew_param(void)
-{
-    assert(strcmp(osThreadNew_param_attr->name, "") == 0);
-    assert(osThreadNew_param_attr->attr_bits == osThreadDetached);
-    assert(osThreadNew_param_attr->cb_mem != NULL);
-    assert(osThreadNew_param_attr->cb_size == osRtxThreadCbSize);
-    assert(osThreadNew_param_attr->stack_mem != NULL);
-    assert(osThreadNew_param_attr->stack_size == (256 * 4));
-    assert(osThreadNew_param_attr->priority == osPriorityNormal);
-}
-
 static void test_create_common_thread(void)
 {
     int result;
 
     result = __fwk_thread_init(16);
     assert(result == FWK_SUCCESS);
-    check_osThreadNew_param();
 }
 
 static void test_create_id_invalid(void)
@@ -261,7 +255,6 @@ static void test_create_thread_creation_failed(void)
     osThreadNew_return_val = NULL;
     status = fwk_thread_create(id);
     assert(status == FWK_E_OS);
-    check_osThreadNew_param();
 }
 
 static void test_create_element_thread(void)
@@ -273,7 +266,6 @@ static void test_create_element_thread(void)
     fwk_module_is_valid_element_id_return_val = true;
     status = fwk_thread_create(id);
     assert(status == FWK_SUCCESS);
-    check_osThreadNew_param();
     assert(fake_element_ctx.thread_ctx == fwk_mm_calloc_val);
 }
 
@@ -285,7 +277,6 @@ static void test_create_module_thread(void)
     /* Thread creation for a module */
     status = fwk_thread_create(id);
     assert(status == FWK_SUCCESS);
-    check_osThreadNew_param();
     assert(fake_module_ctx.thread_ctx == fwk_mm_calloc_val);
 }
 
diff --git a/framework/test/test_fwk_multi_thread_init.c b/framework/test/test_fwk_multi_thread_init.c
index c617f7e3..c825c010 100644
--- a/framework/test/test_fwk_multi_thread_init.c
+++ b/framework/test/test_fwk_multi_thread_init.c
@@ -56,6 +56,12 @@ uint32_t __wrap_osThreadFlagsSet(osThreadId_t thread_id, uint32_t flags)
     return 0;
 }
 
+uint32_t __wrap_osThreadFlagsClear(uint32_t flags)
+{
+    (void)flags;
+    return 0;
+}
+
 static osThreadId_t osThreadNew_return_val;
 osThreadId_t __wrap_osThreadNew(osThreadFunc_t func, void *argument,
                                 const osThreadAttr_t *attr)
diff --git a/framework/test/test_fwk_multi_thread_put_event.c b/framework/test/test_fwk_multi_thread_put_event.c
index 6015f774..ca395de4 100644
--- a/framework/test/test_fwk_multi_thread_put_event.c
+++ b/framework/test/test_fwk_multi_thread_put_event.c
@@ -94,6 +94,12 @@ uint32_t __wrap_osThreadFlagsWait(uint32_t flags, uint32_t options,
         return osThreadFlagsWait_return_val[osThreadFlagsWait_count_call++];
 }
 
+uint32_t __wrap_osThreadFlagsClear(uint32_t flags)
+{
+    (void)flags;
+    return 0;
+}
+
 static uint32_t osThreadFlagsSet_return_val;
 static osThreadId_t osThreadFlagsSet_param_thread_id[3];
 static uint32_t osThreadFlagsSet_param_flags[3];
@@ -860,11 +866,12 @@ static void test_put_event_and_wait_called_from_current_thread(void)
     assert(fwk_thread_put_event_and_wait_return_val == FWK_E_ACCESS);
     assert(osThreadFlagsWait_param_flags[0] == SIGNAL_EVENT_TO_PROCESS);
         assert(osThreadFlagsWait_param_options[0] == osFlagsWaitAny);
-    assert(osThreadFlagsSet_count_call == 1);
-    assert(osThreadFlagsSet_param_thread_id[0] ==
-        (osThreadId_t)COMMON_THREAD_ID);
-    assert(osThreadFlagsSet_param_flags[0] == SIGNAL_NO_READY_THREAD);
-    assert(ctx->event_cookie_counter == 0);
+        assert(osThreadFlagsSet_count_call == 2);
+        assert(
+            osThreadFlagsSet_param_thread_id[0] ==
+            (osThreadId_t)COMMON_THREAD_ID);
+        assert(osThreadFlagsSet_param_flags[0] == SIGNAL_NO_READY_THREAD);
+        assert(ctx->event_cookie_counter == 0);
 }
 
 static void test_put_event_and_wait_event_with_response(void)
diff --git a/framework/test/test_fwk_multi_thread_util.c b/framework/test/test_fwk_multi_thread_util.c
index a1d9dc0b..2458fa58 100644
--- a/framework/test/test_fwk_multi_thread_util.c
+++ b/framework/test/test_fwk_multi_thread_util.c
@@ -70,6 +70,11 @@ uint32_t __wrap_osThreadFlagsWait(uint32_t flags, uint32_t options,
     return 0;
 }
 
+uint32_t __wrap_osThreadFlagsClear(uint32_t flags)
+{
+    return 0;
+}
+
 uint32_t __wrap_osThreadFlagsSet(osThreadId_t thread_id, uint32_t flags)
 {
     return -1;
diff --git a/module/apcontext/src/mod_apcontext.c b/module/apcontext/src/mod_apcontext.c
index badc4783..413606f5 100644
--- a/module/apcontext/src/mod_apcontext.c
+++ b/module/apcontext/src/mod_apcontext.c
@@ -17,21 +17,20 @@
 #include <fwk_notification.h>
 #include <fwk_status.h>
 
+#include <inttypes.h>
 #include <string.h>
 
 #define MODULE_NAME "[APContext]"
 
-static const struct mod_log_api *log;
-
 static void apcontext_zero(void)
 {
     const struct mod_apcontext_config *config;
 
     config = fwk_module_get_data(fwk_module_id_apcontext);
 
-    FWK_LOG_TRACE(
-        log,
-        MODULE_NAME " Zeroing AP context area [0x%08x - 0x%08x]\n",
+    FWK_LOG_INFO(
+        MODULE_NAME " Zeroing AP context area [0x%" PRIxPTR " - 0x%" PRIxPTR
+                    "]",
         config->base,
         config->base + config->size);
 
@@ -60,21 +59,6 @@ static int apcontext_init(fwk_id_t module_id, unsigned int element_count,
     return FWK_SUCCESS;
 }
 
-static int apcontext_bind(fwk_id_t id, unsigned int round)
-{
-    int status;
-
-    /* Skip second round */
-    if (round > 0)
-        return FWK_SUCCESS;
-
-    status = fwk_module_bind(fwk_module_id_log, MOD_LOG_API_ID, &log);
-    if (status != FWK_SUCCESS)
-        return FWK_E_PANIC;
-
-    return FWK_SUCCESS;
-}
-
 static int apcontext_start(fwk_id_t id)
 {
     const struct mod_apcontext_config *config =
@@ -121,7 +105,6 @@ const struct fwk_module module_apcontext = {
     .name = "APContext",
     .type = FWK_MODULE_TYPE_SERVICE,
     .init = apcontext_init,
-    .bind = apcontext_bind,
     .start = apcontext_start,
     .process_notification = apcontext_process_notification,
 };
diff --git a/module/bootloader/src/mod_bootloader.c b/module/bootloader/src/mod_bootloader.c
index b69c641d..4d79775d 100644
--- a/module/bootloader/src/mod_bootloader.c
+++ b/module/bootloader/src/mod_bootloader.c
@@ -10,6 +10,7 @@
 
 #include <fwk_id.h>
 #include <fwk_interrupt.h>
+#include <fwk_log.h>
 #include <fwk_module.h>
 #include <fwk_module_idx.h>
 #include <fwk_noreturn.h>
@@ -110,6 +111,8 @@ static int load_image(void)
 
     fwk_interrupt_global_disable(); /* We are relocating the vector table */
 
+    FWK_LOG_FLUSH();
+
     mod_bootloader_boot(
         module_ctx.module_config->destination_base,
         image_base,
diff --git a/module/cmn600/include/internal/cmn600_ctx.h b/module/cmn600/include/internal/cmn600_ctx.h
index 46725d6a..67df8056 100644
--- a/module/cmn600/include/internal/cmn600_ctx.h
+++ b/module/cmn600/include/internal/cmn600_ctx.h
@@ -89,8 +89,6 @@ struct cmn600_ctx {
     /* CCIX host parameters to be sent to upper level firmware */
     struct mod_cmn600_ccix_host_node_config ccix_host_info;
 
-    struct mod_log_api *log_api;
-
     /* Timer module API */
     struct mod_timer_api *timer_api;
 
diff --git a/module/cmn600/src/cmn600_ccix.c b/module/cmn600/src/cmn600_ccix.c
index 5e8627f0..0475d435 100644
--- a/module/cmn600/src/cmn600_ccix.c
+++ b/module/cmn600/src/cmn600_ccix.c
@@ -20,6 +20,7 @@
 #include <fwk_module_idx.h>
 #include <fwk_status.h>
 
+#include <inttypes.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -103,11 +104,11 @@ static int enable_smp_mode(struct cmn600_ctx *ctx)
             ((ctx->cxg_ha_reg->CXG_HA_UNIT_INFO &
               CXG_HA_UNIT_INFO_SMP_MODE_RO_MASK) !=
              CXG_HA_UNIT_INFO_SMP_MODE_RO_MASK)) {
-            FWK_LOG_INFO(ctx->log_api, MOD_NAME "SMP Mode not supported\n");
+            FWK_LOG_INFO(MOD_NAME "SMP Mode not supported");
             return FWK_E_SUPPORT;
         }
 
-        FWK_LOG_INFO(ctx->log_api, MOD_NAME "SMP Mode supported\n");
+        FWK_LOG_INFO(MOD_NAME "SMP Mode supported");
         return FWK_SUCCESS;
     } else if (get_cmn600_revision(ctx->root) >= CMN600_PERIPH_ID_2_REV_R3_P0) {
         /*
@@ -120,7 +121,7 @@ static int enable_smp_mode(struct cmn600_ctx *ctx)
             (1 << CXG_HA_AUX_CTRL_SMP_MODE_RW_SHIFT_VAL);
         ctx->cxla_reg->CXLA_AUX_CTRL |=
             ((uint64_t)0x1 << CXLA_AUX_CTRL_SMP_MODE_SHIFT_VAL);
-        FWK_LOG_INFO(ctx->log_api, MOD_NAME "SMP MODE enabled\n");
+        FWK_LOG_INFO(MOD_NAME "SMP MODE enabled");
         return FWK_SUCCESS;
     }
 
@@ -357,12 +358,11 @@ static int enable_and_start_ccix_link_up_sequence(struct cmn600_ctx *ctx,
         val1 | ((uint64_t)CCIX_VENDER_ID <<
         CXLA_PCIE_HDR_VENDOR_ID_SHIFT_VAL);
 
-    FWK_LOG_TRACE(
-        ctx->log_api,
-        MOD_NAME "CXLA_PCIE_HDR_FIELDS: 0x%lx\n",
+    FWK_LOG_INFO(
+        MOD_NAME "CXLA_PCIE_HDR_FIELDS: 0x%" PRIx64,
         ctx->cxla_reg->CXLA_PCIE_HDR_FIELDS);
 
-    FWK_LOG_TRACE(ctx->log_api, MOD_NAME "Enabling CCIX link %d...", link_id);
+    FWK_LOG_INFO(MOD_NAME "Enabling CCIX link %d...", link_id);
     /* Set link enable bit to enable the CCIX link */
     ctx->cxg_ra_reg->LINK_REGS[link_id].CXG_PRTCL_LINK_CTRL =
         CXG_LINK_CTRL_EN_MASK;
@@ -376,12 +376,12 @@ static int enable_and_start_ccix_link_up_sequence(struct cmn600_ctx *ctx,
                                   cxg_link_wait_condition,
                                   &wait_data);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(ctx->log_api, "Failed\n");
+        FWK_LOG_INFO(MOD_NAME "Failed");
         return status;
     }
-    FWK_LOG_TRACE(ctx->log_api, "Done\n");
+    FWK_LOG_INFO(MOD_NAME "Done");
 
-    FWK_LOG_TRACE(ctx->log_api, MOD_NAME "Verifying link down status...");
+    FWK_LOG_INFO(MOD_NAME "Verifying link down status...");
     /* Wait till link up bits are cleared in control register */
     wait_data.cond = CXG_LINK_CTRL_UP_BIT_CLR;
     status = ctx->timer_api->wait(FWK_ID_ELEMENT(FWK_MODULE_IDX_TIMER, 0),
@@ -389,7 +389,7 @@ static int enable_and_start_ccix_link_up_sequence(struct cmn600_ctx *ctx,
                                   cxg_link_wait_condition,
                                   &wait_data);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(ctx->log_api, "Failed\n");
+        FWK_LOG_INFO(MOD_NAME "Failed");
         return status;
     }
 
@@ -400,7 +400,7 @@ static int enable_and_start_ccix_link_up_sequence(struct cmn600_ctx *ctx,
                                   cxg_link_wait_condition,
                                   &wait_data);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(ctx->log_api, "Failed\n");
+        FWK_LOG_INFO(MOD_NAME "Failed");
         return status;
     }
 
@@ -411,13 +411,13 @@ static int enable_and_start_ccix_link_up_sequence(struct cmn600_ctx *ctx,
                                    cxg_link_wait_condition,
                                    &wait_data);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(ctx->log_api, "Failed\n");
+        FWK_LOG_INFO(MOD_NAME "Failed");
         return status;
     }
 
-    FWK_LOG_TRACE(ctx->log_api, "Done\n");
+    FWK_LOG_INFO(MOD_NAME "Done");
 
-    FWK_LOG_TRACE(ctx->log_api, MOD_NAME "Bringing up link...");
+    FWK_LOG_INFO(MOD_NAME "Bringing up link...");
 
     /* Bring up link using link request bit */
     ctx->cxg_ra_reg->LINK_REGS[link_id].CXG_PRTCL_LINK_CTRL |=
@@ -432,7 +432,7 @@ static int enable_and_start_ccix_link_up_sequence(struct cmn600_ctx *ctx,
                                    cxg_link_wait_condition,
                                    &wait_data);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(ctx->log_api, "Failed\n");
+        FWK_LOG_INFO(MOD_NAME "Failed");
         return status;
     }
 
@@ -444,10 +444,10 @@ static int enable_and_start_ccix_link_up_sequence(struct cmn600_ctx *ctx,
                                    cxg_link_wait_condition,
                                    &wait_data);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(ctx->log_api, "Failed\n");
+        FWK_LOG_INFO(MOD_NAME "Failed");
         return status;
     }
-    FWK_LOG_TRACE(ctx->log_api, "Done\n");
+    FWK_LOG_INFO(MOD_NAME "Done");
     return FWK_SUCCESS;
 }
 
@@ -468,7 +468,7 @@ int ccix_setup(struct cmn600_ctx *ctx, void *remote_config)
     struct mod_cmn600_ccix_remote_node_config *ccix_remote_config =
         (struct mod_cmn600_ccix_remote_node_config *)remote_config;
 
-    FWK_LOG_TRACE(ctx->log_api, MOD_NAME "Programming CCIX gateway...\n");
+    FWK_LOG_INFO(MOD_NAME "Programming CCIX gateway...");
 
     /*
      *assert if outside the range as it next step value bein latched
@@ -589,16 +589,14 @@ int ccix_exchange_protocol_credit(struct cmn600_ctx *ctx, uint8_t link_id)
     if (link_id > 2)
         return FWK_E_PARAM;
 
-    FWK_LOG_TRACE(
-        ctx->log_api,
-        MOD_NAME "Exchanging protocol credits for link %d...",
-        link_id);
+    FWK_LOG_INFO(
+        MOD_NAME "Exchanging protocol credits for link %d...", link_id);
     /* Exchange protocol credits using link up bit */
     ctx->cxg_ra_reg->LINK_REGS[link_id].CXG_PRTCL_LINK_CTRL |=
         CXG_LINK_CTRL_UP_MASK;
     ctx->cxg_ha_reg->LINK_REGS[link_id].CXG_PRTCL_LINK_CTRL |=
         CXG_LINK_CTRL_UP_MASK;
-    FWK_LOG_TRACE(ctx->log_api, "Done\n");
+    FWK_LOG_INFO(MOD_NAME "Done");
     return FWK_SUCCESS;
 }
 
@@ -613,10 +611,7 @@ int ccix_enter_system_coherency(struct cmn600_ctx *ctx, uint8_t link_id)
     wait_data.ctx = ctx;
     wait_data.link_id = link_id;
 
-    FWK_LOG_TRACE(
-        ctx->log_api,
-        MOD_NAME "Entering system coherency for link %d...",
-        link_id);
+    FWK_LOG_INFO(MOD_NAME "Entering system coherency for link %d...", link_id);
     /* Enter system coherency by setting DVMDOMAIN request bit */
     ctx->cxg_ha_reg->LINK_REGS[link_id].CXG_PRTCL_LINK_CTRL |=
         CXG_LINK_CTRL_DVMDOMAIN_REQ_MASK;
@@ -628,11 +623,11 @@ int ccix_enter_system_coherency(struct cmn600_ctx *ctx, uint8_t link_id)
                                   cxg_link_wait_condition,
                                   &wait_data);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(ctx->log_api, "Failed\n");
+        FWK_LOG_INFO(MOD_NAME "Failed");
         return status;
     }
 
-    FWK_LOG_TRACE(ctx->log_api, "Done\n");
+    FWK_LOG_INFO(MOD_NAME "Done");
     return FWK_SUCCESS;
 }
 
@@ -647,8 +642,7 @@ int ccix_enter_dvm_domain(struct cmn600_ctx *ctx, uint8_t link_id)
     wait_data.ctx = ctx;
     wait_data.link_id = link_id;
 
-    FWK_LOG_TRACE(
-        ctx->log_api, MOD_NAME "Entering DVM domain for link %d...", link_id);
+    FWK_LOG_INFO(MOD_NAME "Entering DVM domain for link %d...", link_id);
     /* Enter system coherency by setting DVMDOMAIN request bit */
     ctx->cxg_ra_reg->LINK_REGS[link_id].CXG_PRTCL_LINK_CTRL |=
         CXG_LINK_CTRL_DVMDOMAIN_REQ_MASK;
@@ -660,11 +654,11 @@ int ccix_enter_dvm_domain(struct cmn600_ctx *ctx, uint8_t link_id)
                                   cxg_link_wait_condition,
                                   &wait_data);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(ctx->log_api, "Failed\n");
+        FWK_LOG_INFO(MOD_NAME "Failed");
         return status;
     }
 
-    FWK_LOG_TRACE(ctx->log_api, "Done\n");
+    FWK_LOG_INFO(MOD_NAME "Done");
     return FWK_SUCCESS;
 }
 
diff --git a/module/cmn600/src/mod_cmn600.c b/module/cmn600/src/mod_cmn600.c
index 52b9b41b..3704ab83 100644
--- a/module/cmn600/src/mod_cmn600.c
+++ b/module/cmn600/src/mod_cmn600.c
@@ -26,6 +26,7 @@
 #include <fwk_notification.h>
 #include <fwk_status.h>
 
+#include <inttypes.h>
 #include <stdbool.h>
 #include <string.h>
 
@@ -142,7 +143,7 @@ static int cmn600_discovery(void)
     struct node_header *node;
     const struct mod_cmn600_config *config = ctx->config;
 
-    FWK_LOG_TRACE(ctx->log_api, MOD_NAME "Starting discovery...\n");
+    FWK_LOG_INFO(MOD_NAME "Starting discovery...");
 
     assert(get_node_type(ctx->root) == NODE_TYPE_CFG);
 
@@ -153,10 +154,10 @@ static int cmn600_discovery(void)
         xp = get_child_node(config->base, ctx->root, xp_idx);
         assert(get_node_type(xp) == NODE_TYPE_XP);
 
-        FWK_LOG_TRACE(ctx->log_api, MOD_NAME "\n");
-        FWK_LOG_TRACE(
-            ctx->log_api,
-            MOD_NAME "XP (%d, %d) ID:%d, LID:%d\n",
+        FWK_LOG_INFO(MOD_NAME);
+
+        FWK_LOG_INFO(
+            MOD_NAME "XP (%d, %d) ID:%d, LID:%d",
             get_node_pos_x(xp),
             get_node_pos_y(xp),
             get_node_id(xp),
@@ -181,24 +182,21 @@ static int cmn600_discovery(void)
                     (get_device_type(xp, xp_port) == DEVICE_TYPE_CXHA) ||
                     (get_device_type(xp, xp_port) == DEVICE_TYPE_CXRA)) {
                     ctx->cxla_reg = (void *)node;
-                    FWK_LOG_TRACE(
-                        ctx->log_api,
-                        MOD_NAME "  Found CXLA at node ID: %d\n",
+                    FWK_LOG_INFO(
+                        MOD_NAME "  Found CXLA at node ID: %d",
                         get_child_node_id(xp, node_idx));
                 } else { /* External RN-SAM Node */
                     ctx->external_rnsam_count++;
-                    FWK_LOG_TRACE(
-                        ctx->log_api,
-                        MOD_NAME "  Found external node ID: %d\n",
+                    FWK_LOG_INFO(
+                        MOD_NAME "  Found external node ID: %d",
                         get_child_node_id(xp, node_idx));
                 }
             } else { /* Internal nodes */
                 switch (get_node_type(node)) {
                 case NODE_TYPE_HN_F:
                     if (ctx->hnf_count >= MAX_HNF_COUNT) {
-                        FWK_LOG_TRACE(
-                            ctx->log_api,
-                            MOD_NAME "  hnf count %d >= max limit (%d)\n",
+                        FWK_LOG_INFO(
+                            MOD_NAME "  hnf count %d >= max limit (%d)",
                             ctx->hnf_count,
                             MAX_HNF_COUNT);
                         return FWK_E_DATA;
@@ -212,9 +210,8 @@ static int cmn600_discovery(void)
 
                 case NODE_TYPE_RN_D:
                     if (ctx->rnd_count >= MAX_RND_COUNT) {
-                        FWK_LOG_TRACE(
-                            ctx->log_api,
-                            MOD_NAME "  rnd count %d >= max limit (%d)\n",
+                        FWK_LOG_INFO(
+                            MOD_NAME "  rnd count %d >= max limit (%d)",
                             ctx->rnd_count,
                             MAX_RND_COUNT);
                         return FWK_E_DATA;
@@ -224,9 +221,8 @@ static int cmn600_discovery(void)
 
                 case NODE_TYPE_RN_I:
                     if (ctx->rni_count >= MAX_RNI_COUNT) {
-                        FWK_LOG_TRACE(
-                            ctx->log_api,
-                            MOD_NAME "  rni count %d >= max limit (%d)\n",
+                        FWK_LOG_INFO(
+                            MOD_NAME "  rni count %d >= max limit (%d)",
                             ctx->rni_count,
                             MAX_RNI_COUNT);
                         return FWK_E_DATA;
@@ -248,9 +244,8 @@ static int cmn600_discovery(void)
                     break;
                 }
 
-                FWK_LOG_TRACE(
-                    ctx->log_api,
-                    MOD_NAME "  %s ID:%d, LID:%d\n",
+                FWK_LOG_INFO(
+                    MOD_NAME "  %s ID:%d, LID:%d",
                     get_node_type_name(get_node_type(node)),
                     get_node_id(node),
                     get_node_logical_id(node));
@@ -268,8 +263,7 @@ static int cmn600_discovery(void)
 
     if (ctx->rnf_count > MAX_RNF_COUNT) {
         FWK_LOG_ERR(
-            ctx->log_api,
-            MOD_NAME "rnf count %d > max limit (%d)\n",
+            MOD_NAME "rnf count %d > max limit (%d)",
             ctx->rnf_count,
             MAX_RNF_COUNT);
         return FWK_E_RANGE;
@@ -278,46 +272,30 @@ static int cmn600_discovery(void)
     /* When CAL is present, the number of HN-Fs must be even. */
     if ((ctx->hnf_count % 2 != 0) && (config->hnf_cal_mode == true)) {
         FWK_LOG_ERR(
-            ctx->log_api,
-            MOD_NAME "hnf count: %d should be even when CAL mode is set\n",
+            MOD_NAME "hnf count: %d should be even when CAL mode is set",
             ctx->hnf_count);
         return FWK_E_DATA;
     }
 
-    FWK_LOG_TRACE(
-        ctx->log_api,
-        MOD_NAME "Total internal RN-SAM nodes: %d\n",
-        ctx->internal_rnsam_count);
-    FWK_LOG_TRACE(
-        ctx->log_api,
-        MOD_NAME "Total external RN-SAM nodes: %d\n",
-        ctx->external_rnsam_count);
-    FWK_LOG_TRACE(
-        ctx->log_api, MOD_NAME "Total HN-F nodes: %d\n", ctx->hnf_count);
-    FWK_LOG_TRACE(
-        ctx->log_api, MOD_NAME "Total RN-D nodes: %d\n", ctx->rnd_count);
-    FWK_LOG_TRACE(
-        ctx->log_api, MOD_NAME "Total RN-F nodes: %d\n", ctx->rnf_count);
-    FWK_LOG_TRACE(
-        ctx->log_api, MOD_NAME "Total RN-I nodes: %d\n", ctx->rni_count);
+    FWK_LOG_INFO(
+        MOD_NAME "Total internal RN-SAM nodes: %d", ctx->internal_rnsam_count);
+    FWK_LOG_INFO(
+        MOD_NAME "Total external RN-SAM nodes: %d", ctx->external_rnsam_count);
+    FWK_LOG_INFO(MOD_NAME "Total HN-F nodes: %d", ctx->hnf_count);
+    FWK_LOG_INFO(MOD_NAME "Total RN-F nodes: %d", ctx->rnd_count);
+    FWK_LOG_INFO(MOD_NAME "Total RN-D nodes: %d", ctx->rnf_count);
+    FWK_LOG_INFO(MOD_NAME "Total RN-I nodes: %d", ctx->rni_count);
 
     if (ctx->cxla_reg) {
-        FWK_LOG_TRACE(
-            ctx->log_api,
-            MOD_NAME "CCIX CXLA node at: 0x%08x\n",
-            (uint32_t)ctx->cxla_reg);
+        FWK_LOG_INFO(MOD_NAME "CCIX CXLA node at: 0x%p", (void *)ctx->cxla_reg);
     }
     if (ctx->cxg_ra_reg) {
-        FWK_LOG_TRACE(
-            ctx->log_api,
-            MOD_NAME "CCIX CXRA node at: 0x%08x\n",
-            (uint32_t)ctx->cxg_ra_reg);
+        FWK_LOG_INFO(
+            MOD_NAME "CCIX CXRA node at: 0x%p", (void *)ctx->cxg_ra_reg);
     }
     if (ctx->cxg_ha_reg) {
-        FWK_LOG_TRACE(
-            ctx->log_api,
-            MOD_NAME "CCIX CXHA node at: 0x%08x\n",
-            (uint32_t)ctx->cxg_ha_reg);
+        FWK_LOG_INFO(
+            MOD_NAME "CCIX CXHA node at: 0x%p", (void *)ctx->cxg_ha_reg);
     }
     return FWK_SUCCESS;
 }
@@ -406,10 +384,7 @@ int cmn600_setup_sam(struct cmn600_rnsam_reg *rnsam)
     unsigned int scg_region = 0;
     unsigned int scg_regions_enabled[CMN600_MAX_NUM_SCG] = {0, 0, 0, 0};
 
-    FWK_LOG_TRACE(
-        ctx->log_api,
-        MOD_NAME "Configuring SAM for node %d\n",
-        get_node_id(rnsam));
+    FWK_LOG_INFO(MOD_NAME "Configuring SAM for node %d", get_node_id(rnsam));
 
     for (region_idx = 0; region_idx < config->mmap_count; region_idx++) {
         region = &config->mmap_table[region_idx];
@@ -426,9 +401,8 @@ int cmn600_setup_sam(struct cmn600_rnsam_reg *rnsam)
         } else
             base = region->base;
 
-        FWK_LOG_TRACE(
-            ctx->log_api,
-            MOD_NAME "  [0x%lx - 0x%lx] %s\n",
+        FWK_LOG_INFO(
+            MOD_NAME "  [0x%" PRIX64 " - 0x%" PRIX64 "] %s",
             base,
             base + region->size - 1,
             mmap_type_name[region->type]);
@@ -442,7 +416,6 @@ int cmn600_setup_sam(struct cmn600_rnsam_reg *rnsam)
             if (region_io_count >
                     CMN600_RNSAM_MAX_NON_HASH_MEM_REGION_ENTRIES) {
                 FWK_LOG_ERR(
-                    ctx->log_api,
                     MOD_NAME
                     "Non-Hashed Memory can have maximum of %d regions only",
                     CMN600_RNSAM_MAX_NON_HASH_MEM_REGION_ENTRIES);
@@ -485,7 +458,6 @@ int cmn600_setup_sam(struct cmn600_rnsam_reg *rnsam)
              */
             if (region_sys_count >= CMN600_RNSAM_MAX_HASH_MEM_REGION_ENTRIES) {
                 FWK_LOG_ERR(
-                    ctx->log_api,
                     MOD_NAME
                     "Hashed Memory can have maximum of %d regions only",
                     CMN600_RNSAM_MAX_HASH_MEM_REGION_ENTRIES);
@@ -626,7 +598,7 @@ static int cmn600_setup(void)
         }
     }
 
-    FWK_LOG_TRACE(ctx->log_api, MOD_NAME "Done\n");
+    FWK_LOG_INFO(MOD_NAME "Done");
 
     ctx->initialized = true;
 
@@ -768,14 +740,6 @@ static int cmn600_bind(fwk_id_t id, unsigned int round)
     /* Use second round only (round numbering is zero-indexed) */
     if (round == 1) {
 
-        /* Bind to the log component */
-        status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                                 FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-                                 &ctx->log_api);
-
-        if (status != FWK_SUCCESS)
-            return FWK_E_PANIC;
-
         /* Bind to the timer component */
         status = fwk_module_bind(FWK_ID_ELEMENT(FWK_MODULE_IDX_TIMER, 0),
                                  FWK_ID_API(FWK_MODULE_IDX_TIMER,
@@ -831,11 +795,8 @@ int cmn600_start(fwk_id_t id)
 
     ctx->chip_id = chip_id;
 
-    FWK_LOG_TRACE(
-        ctx->log_api,
-        MOD_NAME "Multichip mode: %d Chip ID: %d\n",
-        mc_mode,
-        chip_id);
+    FWK_LOG_INFO(MOD_NAME "Multichip mode: %s", mc_mode ? "yes" : "no");
+    FWK_LOG_INFO(MOD_NAME "Chip ID: %d", chip_id);
 
     /* Register the module for clock state notifications */
     return fwk_notification_subscribe(
diff --git a/module/cmn_rhodes/include/internal/cmn_rhodes_ctx.h b/module/cmn_rhodes/include/internal/cmn_rhodes_ctx.h
index 93d3781f..0b692dc8 100644
--- a/module/cmn_rhodes/include/internal/cmn_rhodes_ctx.h
+++ b/module/cmn_rhodes/include/internal/cmn_rhodes_ctx.h
@@ -43,8 +43,6 @@ static struct cmn_rhodes_ctx {
     unsigned int internal_rnsam_count;
     struct cmn_rhodes_rnsam_reg **internal_rnsam_table;
 
-    struct mod_log_api *log_api;
-
     bool initialized;
 } *ctx;
 
diff --git a/module/cmn_rhodes/src/mod_cmn_rhodes.c b/module/cmn_rhodes/src/mod_cmn_rhodes.c
index c8149366..f022fdd1 100644
--- a/module/cmn_rhodes/src/mod_cmn_rhodes.c
+++ b/module/cmn_rhodes/src/mod_cmn_rhodes.c
@@ -23,6 +23,8 @@
 #include <fwk_notification.h>
 #include <fwk_status.h>
 
+#include <inttypes.h>
+
 #define MOD_NAME "[CMN_RHODES] "
 
 static struct cmn_rhodes_ctx *ctx;
@@ -125,7 +127,7 @@ static int cmn_rhodes_discovery(void)
     struct node_header *node;
     const struct mod_cmn_rhodes_config *config = ctx->config;
 
-    FWK_LOG_TRACE(ctx->log_api, MOD_NAME "Starting discovery...\n");
+    FWK_LOG_INFO(MOD_NAME "Starting discovery...");
 
     assert(get_node_type(ctx->root) == NODE_TYPE_CFG);
 
@@ -135,10 +137,8 @@ static int cmn_rhodes_discovery(void)
         xp = get_child_node(config->base, ctx->root, xp_idx);
         assert(get_node_type(xp) == NODE_TYPE_XP);
 
-        FWK_LOG_TRACE(ctx->log_api, MOD_NAME "\n");
-        FWK_LOG_TRACE(
-            ctx->log_api,
-            MOD_NAME "XP (%d, %d) ID:%d, LID:%d\n",
+        FWK_LOG_INFO(
+            MOD_NAME "XP (%d, %d) ID:%d, LID:%d",
             get_node_pos_x(xp),
             get_node_pos_y(xp),
             get_node_id(xp),
@@ -159,24 +159,21 @@ static int cmn_rhodes_discovery(void)
                 if ((get_device_type(xp, xp_port) == DEVICE_TYPE_CXRH) ||
                     (get_device_type(xp, xp_port) == DEVICE_TYPE_CXHA) ||
                     (get_device_type(xp, xp_port) == DEVICE_TYPE_CXRA)) {
-                    FWK_LOG_TRACE(
-                        ctx->log_api,
-                        MOD_NAME "  Found CXLA at node ID: %d\n",
+                    FWK_LOG_INFO(
+                        MOD_NAME "  Found CXLA at node ID: %d",
                         get_child_node_id(xp, node_idx));
                 } else { /* External RN-SAM Node */
                     ctx->external_rnsam_count++;
-                    FWK_LOG_TRACE(
-                        ctx->log_api,
-                        MOD_NAME "  Found external node ID: %d\n",
+                    FWK_LOG_INFO(
+                        MOD_NAME "  Found external node ID: %d",
                         get_child_node_id(xp, node_idx));
                 }
             } else { /* Internal nodes */
                 switch (get_node_type(node)) {
                 case NODE_TYPE_HN_F:
                     if (ctx->hnf_count >= MAX_HNF_COUNT) {
-                        FWK_LOG_TRACE(
-                            ctx->log_api,
-                            MOD_NAME "  hnf count %d >= max limit (%d)\n",
+                        FWK_LOG_INFO(
+                            MOD_NAME "  hnf count %d >= max limit (%d)",
                             ctx->hnf_count,
                             MAX_HNF_COUNT);
                         return FWK_E_DATA;
@@ -193,9 +190,8 @@ static int cmn_rhodes_discovery(void)
                     break;
                 }
 
-                FWK_LOG_TRACE(
-                    ctx->log_api,
-                    MOD_NAME "  %s ID:%d, LID:%d\n",
+                FWK_LOG_INFO(
+                    MOD_NAME "  %s ID:%d, LID:%d",
                     get_node_type_name(get_node_type(node)),
                     get_node_id(node),
                     get_node_logical_id(node));
@@ -206,17 +202,15 @@ static int cmn_rhodes_discovery(void)
     /* When CAL is present, the number of HN-Fs must be even. */
     if ((ctx->hnf_count % 2 != 0) && (config->hnf_cal_mode == true)) {
         FWK_LOG_ERR(
-            ctx->log_api,
-            MOD_NAME "hnf count: %d should be even when CAL mode is set\n",
+            MOD_NAME "hnf count: %d should be even when CAL mode is set",
             ctx->hnf_count);
         return FWK_E_DATA;
     }
 
-    FWK_LOG_TRACE(
-        ctx->log_api,
-        MOD_NAME "Total internal RN-SAM nodes: %d\n" MOD_NAME
-                 "Total external RN-SAM nodes: %d\n" MOD_NAME
-                 "Total HN-F nodes: %d\n",
+    FWK_LOG_INFO(
+        MOD_NAME "Total internal RN-SAM nodes: %d" MOD_NAME
+                 "Total external RN-SAM nodes: %d" MOD_NAME
+                 "Total HN-F nodes: %d",
         ctx->internal_rnsam_count,
         ctx->external_rnsam_count,
         ctx->hnf_count);
@@ -302,17 +296,13 @@ static int cmn_rhodes_setup_sam(struct cmn_rhodes_rnsam_reg *rnsam)
     const struct mod_cmn_rhodes_mem_region_map *region;
     const struct mod_cmn_rhodes_config *config = ctx->config;
 
-    FWK_LOG_TRACE(
-        ctx->log_api,
-        MOD_NAME "Configuring SAM for node %d\n",
-        get_node_id(rnsam));
+    FWK_LOG_INFO(MOD_NAME "Configuring SAM for node %d", get_node_id(rnsam));
 
     for (region_idx = 0; region_idx < config->mmap_count; region_idx++) {
         region = &config->mmap_table[region_idx];
 
-        FWK_LOG_TRACE(
-            ctx->log_api,
-            MOD_NAME "  [0x%lx - 0x%lx] %s\n",
+        FWK_LOG_INFO(
+            MOD_NAME "  [0x%" PRIx64 " - 0x%" PRIx64 "] %s",
             region->base,
             region->base + region->size - 1,
             mmap_type_name[region->type]);
@@ -456,7 +446,7 @@ static int cmn_rhodes_setup(void)
     for (rnsam_idx = 0; rnsam_idx < ctx->internal_rnsam_count; rnsam_idx++)
         cmn_rhodes_setup_sam(ctx->internal_rnsam_table[rnsam_idx]);
 
-    FWK_LOG_TRACE(ctx->log_api, MOD_NAME "Done\n");
+    FWK_LOG_INFO(MOD_NAME "Done");
 
     ctx->initialized = true;
 
@@ -530,23 +520,6 @@ static int cmn_rhodes_init(fwk_id_t module_id, unsigned int element_count,
     return FWK_SUCCESS;
 }
 
-static int cmn_rhodes_bind(fwk_id_t id, unsigned int round)
-{
-    int status;
-
-    /* Use second round only (round numbering is zero-indexed) */
-    if (round == 1) {
-        /* Bind to the log component */
-        status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                                 FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-                                 &ctx->log_api);
-        if (status != FWK_SUCCESS)
-            return FWK_E_PANIC;
-    }
-
-    return FWK_SUCCESS;
-}
-
 static int cmn_rhodes_process_bind_request(fwk_id_t requester_id,
     fwk_id_t target_id, fwk_id_t api_id, const void **api)
 {
@@ -587,7 +560,6 @@ const struct fwk_module module_cmn_rhodes = {
     .type = FWK_MODULE_TYPE_DRIVER,
     .api_count = MOD_CMN_RHODES_API_COUNT,
     .init = cmn_rhodes_init,
-    .bind = cmn_rhodes_bind,
     .start = cmn_rhodes_start,
     .process_bind_request = cmn_rhodes_process_bind_request,
     .process_notification = cmn_rhodes_process_notification,
diff --git a/module/ddr_phy500/src/mod_ddr_phy500.c b/module/ddr_phy500/src/mod_ddr_phy500.c
index d35f4a73..7ecb158b 100644
--- a/module/ddr_phy500/src/mod_ddr_phy500.c
+++ b/module/ddr_phy500/src/mod_ddr_phy500.c
@@ -27,8 +27,6 @@
 
 #include <stddef.h>
 
-static struct mod_log_api *log_api;
-
 /*
  * Functions fulfilling this module's interface
  */
@@ -45,7 +43,7 @@ static int ddr_phy500_config(fwk_id_t element_id)
 
     ddr = (struct mod_ddr_phy500_reg *)element_config->ddr;
 
-    FWK_LOG_INFO(log_api, "[DDR] Initializing PHY at 0x%x\n", (uintptr_t)ddr);
+    FWK_LOG_INFO("[DDR] Initializing PHY at 0x%x", (uintptr_t)ddr);
 
     if (module_config->initialize_init_complete)
         ddr->INIT_COMPLETE = module_config->ddr_reg_val->INIT_COMPLETE;
@@ -95,8 +93,6 @@ static int ddr_phy500_element_init(fwk_id_t element_id, unsigned int unused,
 
 static int ddr_phy500_bind(fwk_id_t id, unsigned int round)
 {
-    int status;
-
     /* Skip the second round (rounds are zero-indexed) */
     if (round == 1)
         return FWK_SUCCESS;
@@ -105,12 +101,6 @@ static int ddr_phy500_bind(fwk_id_t id, unsigned int round)
     if (fwk_module_is_valid_element_id(id))
         return FWK_SUCCESS;
 
-    /* Bind to the log module and get a pointer to its API */
-    status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG), MOD_LOG_API_ID,
-        &log_api);
-    if (status != FWK_SUCCESS)
-        return FWK_E_HANDLER;
-
     return FWK_SUCCESS;
 }
 
diff --git a/module/dmc500/src/mod_dmc500.c b/module/dmc500/src/mod_dmc500.c
index e7049ee3..4a2e93fa 100644
--- a/module/dmc500/src/mod_dmc500.c
+++ b/module/dmc500/src/mod_dmc500.c
@@ -19,7 +19,6 @@
 
 #include <stddef.h>
 
-static struct mod_log_api *log_api;
 static struct mod_dmc_ddr_phy_api *ddr_phy_api;
 static struct mod_timer_api *timer_api;
 
@@ -56,11 +55,6 @@ static int mod_dmc500_bind(fwk_id_t id, unsigned int round)
     module_config = fwk_module_get_data(fwk_module_id_dmc500);
     assert(module_config != NULL);
 
-    status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                             MOD_LOG_API_ID, &log_api);
-    if (status != FWK_SUCCESS)
-        return status;
-
     status = fwk_module_bind(module_config->ddr_phy_module_id,
                              module_config->ddr_phy_api_id, &ddr_phy_api);
     if (status != FWK_SUCCESS)
@@ -113,8 +107,7 @@ static int dmc500_config(struct mod_dmc500_reg *dmc, fwk_id_t ddr_phy_id)
     module_config = fwk_module_get_data(fwk_module_id_dmc500);
     reg_val = module_config->reg_val;
 
-    FWK_LOG_TRACE(
-        log_api, "[DDR] Initialising DMC500 at 0x%x\n", (uintptr_t)dmc);
+    FWK_LOG_INFO("[DDR] Initialising DMC500 at 0x%x", (uintptr_t)dmc);
 
     dmc->ADDRESS_CONTROL      = reg_val->ADDRESS_CONTROL;
     dmc->RANK_REMAP_CONTROL   = reg_val->RANK_REMAP_CONTROL;
@@ -126,7 +119,7 @@ static int dmc500_config(struct mod_dmc500_reg *dmc, fwk_id_t ddr_phy_id)
     dmc->ODT_RD_CONTROL_31_00 = reg_val->ODT_RD_CONTROL_31_00;
     dmc->ODT_TIMING           = reg_val->ODT_TIMING;
 
-    FWK_LOG_TRACE(log_api, "[DDR] Setting timing settings\n");
+    FWK_LOG_INFO("[DDR] Setting timing settings");
 
     dmc->T_REFI          = reg_val->T_REFI;
     dmc->T_RFC           = reg_val->T_RFC;
@@ -149,11 +142,11 @@ static int dmc500_config(struct mod_dmc500_reg *dmc, fwk_id_t ddr_phy_id)
     dmc->T_ESR           = reg_val->T_ESR;
     dmc->T_XSR           = reg_val->T_XSR;
 
-    FWK_LOG_TRACE(log_api, "[DDR] Setting address map\n");
+    FWK_LOG_INFO("[DDR] Setting address map");
 
     dmc->ADDRESS_MAP = reg_val->ADDRESS_MAP;
 
-    FWK_LOG_TRACE(log_api, "[DDR] Setting PMU settings\n");
+    FWK_LOG_INFO("[DDR] Setting PMU settings");
 
     dmc->SI0_SI_INTERRUPT_CONTROL = reg_val->SI0_SI_INTERRUPT_CONTROL;
     dmc->SI0_PMU_REQ_CONTROL = reg_val->SI0_PMU_REQ_CONTROL;
@@ -261,7 +254,7 @@ static int dmc500_config(struct mod_dmc500_reg *dmc, fwk_id_t ddr_phy_id)
 
     dmc->ERR_RAMECC_CTLR = reg_val->ERR_RAMECC_CTLR;
 
-    FWK_LOG_TRACE(log_api, "[DDR] Setting PHY-related settings\n");
+    FWK_LOG_INFO("[DDR] Setting PHY-related settings");
 
     dmc->PHY_POWER_CONTROL = reg_val->PHY_POWER_CONTROL;
     dmc->T_PHY_TRAIN = reg_val->T_PHY_TRAIN;
@@ -279,13 +272,13 @@ static int dmc500_config(struct mod_dmc500_reg *dmc, fwk_id_t ddr_phy_id)
     dmc->PHY_CONFIG = 0x01000000;
     dmc->PHY_CONFIG = 0x00000003;
 
-    FWK_LOG_TRACE(log_api, "[DDR] Doing direct DDR commands\n");
+    FWK_LOG_INFO("[DDR] Doing direct DDR commands");
 
     module_config->direct_ddr_cmd(dmc);
 
     dmc->REFRESH_ENABLE = reg_val->REFRESH_ENABLE;
 
-    FWK_LOG_TRACE(log_api, "[DDR] Setting dmc in READY mode\n");
+    FWK_LOG_INFO("[DDR] Setting dmc in READY mode");
 
     status = timer_api->time_to_timestamp(module_config->timer_id,
                                           1000 * 1000, &timeout);
@@ -314,9 +307,7 @@ static int dmc500_config(struct mod_dmc500_reg *dmc, fwk_id_t ddr_phy_id)
     dmc->SI0_SI_STATE_CONTROL = reg_val->SI0_SI_STATE_CONTROL;
     dmc->SI1_SI_STATE_CONTROL = reg_val->SI1_SI_STATE_CONTROL;
 
-    FWK_LOG_TRACE(log_api, "[DDR] Waiting for Queue stall = 0...\n");
-    if (status != FWK_SUCCESS)
-        return status;
+    FWK_LOG_INFO("[DDR] Waiting for Queue stall = 0...");
 
     while ((dmc->QUEUE_STATUS & MOD_DMC500_QUEUE_STATUS_STALL_ACK) != 0) {
         status = timer_api->remaining(module_config->timer_id, timeout,
@@ -328,7 +319,7 @@ static int dmc500_config(struct mod_dmc500_reg *dmc, fwk_id_t ddr_phy_id)
             goto timeout;
     }
 
-    FWK_LOG_TRACE(log_api, "[DDR] Waiting for SI0 stall = 0...\n");
+    FWK_LOG_INFO("[DDR] Waiting for SI0 stall = 0...");
 
     while ((dmc->SI0_SI_STATUS & MOD_DMC500_SI_STATUS_STALL_ACK) != 0) {
         status = timer_api->remaining(module_config->timer_id, timeout,
@@ -340,7 +331,7 @@ static int dmc500_config(struct mod_dmc500_reg *dmc, fwk_id_t ddr_phy_id)
             goto timeout;
     }
 
-    FWK_LOG_TRACE(log_api, "[DDR] Waiting for SI1 stall = 0...\n");
+    FWK_LOG_INFO("[DDR] Waiting for SI1 stall = 0...");
 
     while ((dmc->SI1_SI_STATUS & MOD_DMC500_SI_STATUS_STALL_ACK) != 0) {
         status = timer_api->remaining(module_config->timer_id, timeout,
@@ -352,12 +343,12 @@ static int dmc500_config(struct mod_dmc500_reg *dmc, fwk_id_t ddr_phy_id)
             goto timeout;
     }
 
-    FWK_LOG_TRACE(log_api, "[DDR] DMC init done.\n");
+    FWK_LOG_INFO("[DDR] DMC init done.");
 
     return FWK_SUCCESS;
 
 timeout:
-    FWK_LOG_ERR(log_api, "[DDR] Timed out in DMC500 init.\n");
+    FWK_LOG_ERR("[DDR] Timed out in DMC500 init.");
 
     return FWK_E_TIMEOUT;
 }
diff --git a/module/dmc620/src/mod_dmc620.c b/module/dmc620/src/mod_dmc620.c
index d3563f8f..1adb71fb 100644
--- a/module/dmc620/src/mod_dmc620.c
+++ b/module/dmc620/src/mod_dmc620.c
@@ -23,7 +23,6 @@
 
 #include <stddef.h>
 
-static struct mod_log_api *log_api;
 static struct mod_dmc_ddr_phy_api *ddr_phy_api;
 
 static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id);
@@ -59,11 +58,6 @@ static int mod_dmc620_bind(fwk_id_t id, unsigned int round)
     module_config = fwk_module_get_data(fwk_module_id_dmc620);
     assert(module_config != NULL);
 
-    status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                             MOD_LOG_API_ID, &log_api);
-    if (status != FWK_SUCCESS)
-        return status;
-
     status = fwk_module_bind(module_config->ddr_module_id,
                              module_config->ddr_api_id, &ddr_phy_api);
     if (status != FWK_SUCCESS)
@@ -137,10 +131,9 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
     module_config = fwk_module_get_data(fwk_module_id_dmc620);
     reg_val = module_config->dmc_val;
 
-    FWK_LOG_INFO(
-        log_api, "[DDR] Initialising DMC620 at 0x%x\n", (uintptr_t)dmc);
+    FWK_LOG_INFO("[DDR] Initialising DMC620 at 0x%x", (uintptr_t)dmc);
 
-    FWK_LOG_INFO(log_api, "[DDR] Writing functional settings\n");
+    FWK_LOG_INFO("[DDR] Writing functional settings");
 
     dmc->ADDRESS_CONTROL_NEXT = reg_val->ADDRESS_CONTROL_NEXT;
 
@@ -207,7 +200,7 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
     dmc->MUX_CONTROL_NEXT = reg_val->MUX_CONTROL_NEXT;
 
     /* Timing Configuration */
-    FWK_LOG_INFO(log_api, "[DDR] Writing timing settings\n");
+    FWK_LOG_INFO("[DDR] Writing timing settings");
 
     dmc->T_REFI_NEXT = reg_val->T_REFI_NEXT;
     dmc->T_RFC_NEXT = reg_val->T_RFC_NEXT;
@@ -266,7 +259,7 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
     for (i = 0; i < 3; i++) /* ~200ns */
         __NOP();
 
-    FWK_LOG_INFO(log_api, "[DDR] Sending direct DDR commands\n");
+    FWK_LOG_INFO("[DDR] Sending direct DDR commands");
 
     module_config->direct_ddr_cmd(dmc);
 
@@ -274,7 +267,7 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
         __NOP();
 
     /* Switch to READY */
-    FWK_LOG_INFO(log_api, "[DDR] Setting DMC to READY mode\n");
+    FWK_LOG_INFO("[DDR] Setting DMC to READY mode");
 
     dmc->MEMC_CMD = MOD_DMC620_MEMC_CMD_GO;
     dmc->MEMC_CMD = MOD_DMC620_MEMC_CMD_EXECUTE;
@@ -282,7 +275,7 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
     while ((dmc->MEMC_STATUS & MOD_DMC620_MEMC_CMD) != MOD_DMC620_MEMC_CMD_GO)
         continue;
 
-    FWK_LOG_INFO(log_api, "[DDR] DMC init done.\n");
+    FWK_LOG_INFO("[DDR] DMC init done.");
 
     return FWK_SUCCESS;
 }
diff --git a/module/log/include/mod_log.h b/module/log/include/mod_log.h
index 85912fb0..2f3e01fc 100644
--- a/module/log/include/mod_log.h
+++ b/module/log/include/mod_log.h
@@ -30,45 +30,6 @@
  */
 
 /*!
- * \brief Log groups.
- *
- * \details Log groups are used for:
- *      * Categorizing a message during the \ref mod_log_api::log()
- *        call.
- *      * Selectively enabling or disabling certain message types.
- *
- * \note Log groups are not organized in a heirarchy and do not indicate any
- *      kind of priority.
- */
-enum mod_log_group {
-    /*! Used only to indicate all log groups are muted */
-    MOD_LOG_GROUP_NONE = 0,
-
-    /*! The debug log group */
-    MOD_LOG_GROUP_DEBUG = (1 << 0),
-
-    /*! The info log group */
-    MOD_LOG_GROUP_INFO = (1 << 1),
-
-    /*! The warning log group */
-    MOD_LOG_GROUP_WARNING = (1 << 2),
-
-    /*! The error log group */
-    MOD_LOG_GROUP_ERROR = (1 << 3),
-
-    /*! The critical log group */
-    MOD_LOG_GROUP_CRITICAl = (1 << 4),
-};
-
-/*!
- * \brief Log module API identifier.
- *
- * \details The log module only has a single API, which is identified by this
- *      identifier.
- */
-#define MOD_LOG_API_ID  FWK_ID_API(FWK_MODULE_IDX_LOG, 0)
-
-/*!
  * \brief Module configuration.
  */
 struct mod_log_config {
@@ -78,16 +39,12 @@ struct mod_log_config {
     /*! API identifier used to select the API provided by the I/O device */
     const fwk_id_t api_id;
 
-    /*! Default log groups. Value is a mask (see \ref mod_log_group) */
-    const unsigned int log_groups;
-
     /*!
      * \brief A string that will be written automatically after the module
      *      is initialized.
      *
      * \details Allows a firmware to provide a string that is written before any
-     *      other log messages. The banner uses the \ref MOD_LOG_GROUP_INFO log
-     *      group.
+     *      other log messages.
      *
      * \note May be NULL, in which case the banner functionality is not used.
      */
@@ -128,58 +85,6 @@ struct mod_log_driver_api {
 };
 
 /*!
- * \brief Module interface
- */
-struct mod_log_api {
-    /*!
-     * \brief Log formatted data.
-     *
-     * \details Log formatted data assigned to a log group. Only logs that are
-     *      assigned to enabled groups will be output. The module configuration
-     *      can be used to enable and disable log groups.
-     *
-     * \param group One of the log groups that the log is assigned to (\see
-     *      log_group).
-     *
-     * \param fmt String containing the formatted data to be printed out. The
-     *      following formats are supported:
-     *      * \%c - character format
-     *      * \%d and \%i - signed 32-bit decimal format
-     *      * \%lx and \%llx - 64-bit hexadecimal format
-     *      * \%s - string format
-     *      * \%u - unsigned 32-bit decimal format
-     *      * \%x - 32-bit hexadecimal format
-     *
-     *      Numeric formats also accept a padding flag '0\<width\>' between the
-     *      '\%' and the format specifier where the resulting string number will
-     *      be left padded with zeros. Examples:
-     *      * log("%04d", 1) results in "0001"
-     *      * log("%04d", 9999) results in "9999"
-     *      * __Note__: \<width\> must be a number between 0 and 9 inclusive.
-     *
-     * \retval FWK_SUCCESS Operation succeeded.
-     * \retval FWK_E_DATA Invalid format specifier(s).
-     * \retval FWK_E_DEVICE Internal device error.
-     * \retval FWK_E_PARAM Invalid group.
-     * \retval FWK_E_PARAM Invalid 'fmt' pointer.
-     * \retval FWK_E_STATE Log module is not ready.
-     */
-    int (*log)(enum mod_log_group group, const char *fmt, ...);
-
-    /*!
-     * \brief Function used to flush the log's buffer.
-     *
-     * \details When invoked, any buffered log data will be flushed out before
-     *      this function returns.
-     *
-     * \retval FWK_SUCCESS Operation succeeded.
-     * \retval FWK_E_DEVICE Internal device error.
-     * \retval FWK_E_STATE Log module is not ready.
-     */
-    int (*flush)(void);
-};
-
-/*!
  * @}
  */
 
diff --git a/module/log/src/mod_log.c b/module/log/src/mod_log.c
index 1ff64b16..c1716286 100644
--- a/module/log/src/mod_log.c
+++ b/module/log/src/mod_log.c
@@ -19,235 +19,25 @@
 #include <stdarg.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include <string.h>
 
 static const struct mod_log_config *log_config;
 static struct mod_log_driver_api *log_driver;
 
-#define ALL_GROUPS_MASK (MOD_LOG_GROUP_DEBUG | \
-                         MOD_LOG_GROUP_ERROR | \
-                         MOD_LOG_GROUP_INFO | \
-                         MOD_LOG_GROUP_WARNING)
-
-static int do_putchar(char c)
+static int log_backend_print(char ch)
 {
     int status;
 
-    /* Include a 'carriage return' before the new line */
-    if (c == '\n') {
-        status = do_putchar('\r');
-        if (status != FWK_SUCCESS)
-            return status;
-    }
-
-    status = log_driver->putchar(log_config->device_id, c);
+    status = log_driver->putchar(log_config->device_id, ch);
     if (status != FWK_SUCCESS)
         return FWK_E_DEVICE;
 
     return FWK_SUCCESS;
 }
 
-static int print_uint64(uint64_t value, unsigned int base, unsigned int fill)
-{
-    /* Just need enough space to store 64 bit decimal integer */
-    unsigned char str[20];
-    unsigned int i = 0;
-    int status;
-
-    /* Decimal or hexadecimal only */
-    assert((base == 10) || (base == 16));
-
-    do {
-        str[i++] = "0123456789abcdef"[value % base];
-    } while (value /= base);
-
-    while (fill-- > i) {
-        status = do_putchar('0');
-        if (status != FWK_SUCCESS)
-            return status;
-    }
-
-    while (i > 0) {
-        status = do_putchar(str[--i]);
-        if (status != FWK_SUCCESS)
-            return status;
-    }
-
-    return FWK_SUCCESS;
-}
-
-static int print_int32(int32_t num, unsigned int fill)
-{
-    int status;
-    uint64_t unum;
-
-    if (num < 0) {
-        status = do_putchar('-');
-        if (status != FWK_SUCCESS)
-            return status;
-        unum = (uint64_t)-num;
-    } else
-        unum = (uint64_t)num;
-
-    return print_uint64(unum, 10, fill);
-}
-
-static int print_string(const char *str)
-{
-    int status;
-
-    while (*str) {
-        status = do_putchar(*str++);
-        if (status != FWK_SUCCESS)
-            return status;
-    }
-
-    return FWK_SUCCESS;
-}
-
-static int do_print(const char *fmt, va_list *args)
-{
-    int status;
-    int bit64;
-    int64_t num;
-    uint64_t unum;
-    unsigned int fill;
-
-    while (*fmt) {
-
-        if (*fmt == '%') {
-            fmt++;
-            bit64 = 0;
-            fill = 0;
-
-next_symbol:
-            /* Check the format specifier */
-            switch (*fmt) {
-            case 'i': /* Fall through to next one */
-            case 'd':
-                if (bit64)
-                    return FWK_E_DATA;
-
-                num = va_arg(*args, int32_t);
-
-                status = print_int32(num, fill);
-                if (status != FWK_SUCCESS)
-                    return status;
-                break;
-
-            case 's':
-                status = print_string(va_arg(*args, const char *));
-                if (status != FWK_SUCCESS)
-                    return status;
-                break;
-
-            case 'c':
-                status = do_putchar(va_arg(*args, int));
-                if (status != FWK_SUCCESS)
-                    return status;
-                break;
-
-            case 'x':
-                if (bit64)
-                    unum = va_arg(*args, uint64_t);
-                else
-                    unum = va_arg(*args, uint32_t);
-                status = print_uint64(unum, 16, fill);
-                if (status != FWK_SUCCESS)
-                    return status;
-                break;
-
-            case 'l':
-                bit64 = 1;
-                fmt++;
-                goto next_symbol;
-
-            case 'u':
-                if (bit64)
-                    unum = va_arg(*args, uint64_t);
-                else
-                    unum = va_arg(*args, uint32_t);
-
-                status = print_uint64(unum, 10, fill);
-                if (status != FWK_SUCCESS)
-                    return status;
-                break;
-
-            case '0':
-                fmt++;
-                if (((*fmt) < '0') || ((*fmt) > '9'))
-                    return FWK_E_DATA;
-                fill = *(fmt++) - '0';
-                goto next_symbol;
-
-            default:
-                /* Exit on any other format specifier */
-                return FWK_E_DATA;
-            }
-            fmt++;
-            continue;
-        }
-        status = do_putchar(*fmt++);
-        if (status != FWK_SUCCESS)
-            return status;
-    }
-
-    return FWK_SUCCESS;
-}
-
-static bool is_valid_group(unsigned int group)
-{
-    /* Check if group is 'none' */
-    if (group == MOD_LOG_GROUP_NONE)
-        return false;
-
-    /* Check if group is within the limits of valid groups */
-    if (group & ~ALL_GROUPS_MASK)
-        return false;
-
-    /* Check if only one group was set */
-    return !(group & (group - 1));
-}
-
-/*
- * Module API
- */
-
-static int do_log(enum mod_log_group group, const char *fmt, ...)
+static int log_backend_flush(void)
 {
     int status;
-    va_list args;
-
-    /* API called too early */
-    if (log_driver == NULL)
-        return FWK_E_STATE;
-
-
-    if (!is_valid_group(group))
-        return FWK_E_PARAM;
-
-    if (fmt == NULL)
-        return FWK_E_PARAM;
-
-    if (group & log_config->log_groups) {
-        va_start(args, fmt);
-        status = do_print(fmt, &args);
-        va_end(args);
-
-        if (status != FWK_SUCCESS)
-            return status;
-    }
-
-    return FWK_SUCCESS;
-}
-
-static int do_flush(void)
-{
-    int status;
-
-    /* API called too early */
-    if (log_driver == NULL)
-        return FWK_E_STATE;
-
 
     status = log_driver->flush(log_config->device_id);
     if (status != FWK_SUCCESS)
@@ -256,14 +46,6 @@ static int do_flush(void)
     return FWK_SUCCESS;
 }
 
-static const struct mod_log_api module_api = {
-    .log = do_log,
-    .flush = do_flush,
-};
-
-/*
- * Framework handlers
- */
 static int log_init(fwk_id_t module_id, unsigned int element_count,
     const void *data)
 {
@@ -273,10 +55,6 @@ static int log_init(fwk_id_t module_id, unsigned int element_count,
     if (element_count > 0)
         return FWK_E_DATA;
 
-    /* Check for invalid groups in the 'log_groups' mask */
-    if (config->log_groups & ~ALL_GROUPS_MASK)
-        return FWK_E_PARAM;
-
     log_config = config;
 
     return FWK_SUCCESS;
@@ -287,6 +65,8 @@ static int log_bind(fwk_id_t id, unsigned int round)
     int status;
     struct mod_log_driver_api *driver = NULL;
 
+    const char *banner;
+
     /* Skip second round */
     if (round == 1)
         return FWK_SUCCESS;
@@ -306,28 +86,36 @@ static int log_bind(fwk_id_t id, unsigned int round)
 
     log_driver = driver;
 
-    if (log_config->banner) {
-        FWK_LOG_INFO(&module_api, log_config->banner);
-        FWK_LOG_FLUSH(&module_api);
+    banner = log_config->banner;
+
+    while (banner != NULL) {
+        FWK_LOG_INFO("%s", banner);
+
+        banner = strchr(banner, '\n');
+        if (banner != NULL)
+            banner += 1;
     }
 
     return FWK_SUCCESS;
 }
 
-static int log_process_bind_request(fwk_id_t requester_id, fwk_id_t id,
-    fwk_id_t api_id, const void **api)
+static int log_start(fwk_id_t id)
 {
-    *api = &module_api;
+    static const struct fwk_log_backend backend = {
+        .print = log_backend_print,
+        .flush = log_backend_flush,
+    };
 
-    return FWK_SUCCESS;
+    fwk_assert(fwk_id_is_type(id, FWK_ID_TYPE_MODULE));
+
+    return fwk_log_register(&backend);
 }
 
 /* Module descriptor */
 const struct fwk_module module_log = {
     .name = "Log",
     .type = FWK_MODULE_TYPE_HAL,
-    .api_count = 1,
     .init = log_init,
     .bind = log_bind,
-    .process_bind_request = log_process_bind_request,
+    .start = log_start,
 };
diff --git a/module/msys_rom/src/mod_msys_rom.c b/module/msys_rom/src/mod_msys_rom.c
index 6f00d9a7..d1fe41c9 100644
--- a/module/msys_rom/src/mod_msys_rom.c
+++ b/module/msys_rom/src/mod_msys_rom.c
@@ -29,7 +29,6 @@
 
 struct msys_rom_ctx {
     const struct msys_rom_config *rom_config;
-    struct mod_log_api *log_api;
     struct ppu_v1_boot_api *ppu_boot_api;
     struct mod_bootloader_api *bootloader_api;
     unsigned int notification_count; /* Notifications awaiting a response */
@@ -53,14 +52,11 @@ static int msys_deferred_setup(void)
     ctx.ppu_boot_api->power_mode_on(ctx.rom_config->id_primary_cluster);
     ctx.ppu_boot_api->power_mode_on(ctx.rom_config->id_primary_core);
 
-    FWK_LOG_INFO(ctx.log_api, "[SYSTEM] Primary CPU powered\n");
+    FWK_LOG_INFO("[SYSTEM] Primary CPU powered");
 
     status = ctx.bootloader_api->load_image();
 
-    FWK_LOG_ERR(
-        ctx.log_api,
-        "[SYSTEM] Failed to load RAM firmware image: %d\n",
-        status);
+    FWK_LOG_ERR("[SYSTEM] Failed to load RAM firmware image: %d", status);
 
     return FWK_E_DATA;
 }
@@ -88,14 +84,6 @@ static int msys_rom_bind(fwk_id_t id, unsigned int round)
     /* Use second round only (round numbering is zero-indexed) */
     if (round == 1) {
 
-        /* Bind to the log component */
-        status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                                 FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-                                 &ctx.log_api);
-
-        if (status != FWK_SUCCESS)
-            return FWK_E_PANIC;
-
         /* Bind to the PPU module */
         status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_PPU_V1),
                                  FWK_ID_API(FWK_MODULE_IDX_PPU_V1,
diff --git a/module/power_domain/src/mod_power_domain.c b/module/power_domain/src/mod_power_domain.c
index 31338630..aa23490e 100644
--- a/module/power_domain/src/mod_power_domain.c
+++ b/module/power_domain/src/mod_power_domain.c
@@ -23,6 +23,7 @@
 #include <fwk_status.h>
 #include <fwk_thread.h>
 
+#include <inttypes.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -184,9 +185,6 @@ struct mod_pd_ctx {
     /* Number of power domains */
     unsigned int pd_count;
 
-    /* Log module API */
-    const struct mod_log_api *log_api;
-
     /* Context of the system power domain */
     struct pd_ctx *system_pd_ctx;
 
@@ -284,7 +282,7 @@ static const unsigned int mod_pd_cs_level_state_shift[MOD_PD_LEVEL_COUNT] = {
  * Internal variables
  */
 static struct mod_pd_ctx mod_pd_ctx;
-static const char driver_error_msg[] = "[PD] Driver error %s (%d) in %s @%d\n";
+static const char driver_error_msg[] = "[PD] Driver error %s (%d) in %s @%d";
 
 static const char * const default_state_name_table[] = {
     "OFF", "ON", "SLEEP", "3", "4", "5", "6", "7",
@@ -484,8 +482,7 @@ static bool is_valid_composite_state(struct pd_ctx *target_pd,
 
 error:
     FWK_LOG_ERR(
-        mod_pd_ctx.log_api,
-        "[PD] Invalid composite state for %s: 0x%08x\n",
+        "[PD] Invalid composite state for %s: 0x%" PRIX32,
         fwk_module_get_name(target_pd->id),
         composite_state);
     return false;
@@ -694,19 +691,17 @@ static int initiate_power_state_transition(struct pd_ctx *pd)
     if ((pd->driver_api->deny != NULL) &&
         pd->driver_api->deny(pd->driver_id, state)) {
         FWK_LOG_WARN(
-            mod_pd_ctx.log_api,
-            "[PD] Transition of %s to state <%s>,\n",
+            "[PD] Transition of %s to state <%s>,",
             fwk_module_get_name(pd->id),
             get_state_name(pd, state));
-        FWK_LOG_WARN(mod_pd_ctx.log_api, "\tdenied by driver.\n");
+        FWK_LOG_WARN("\tdenied by driver.");
         return FWK_E_DEVICE;
     }
 
     status = pd->driver_api->set_state(pd->driver_id, state);
 
-    FWK_LOG_TRACE(
-        mod_pd_ctx.log_api,
-        "[PD] %s: %s->%s, %s (%d)\n",
+    FWK_LOG_INFO(
+        "[PD] %s: %s->%s, %s (%d)",
         fwk_module_get_name(pd->id),
         get_state_name(pd, pd->state_requested_to_driver),
         get_state_name(pd, state),
@@ -1213,10 +1208,7 @@ void perform_shutdown(
         pd_id = FWK_ID_ELEMENT(FWK_MODULE_IDX_POWER_DOMAIN, pd_idx);
         api = pd->driver_api;
 
-        FWK_LOG_TRACE(
-            mod_pd_ctx.log_api,
-            "[PD] Shutting down %s\n",
-            fwk_module_get_name(pd_id));
+        FWK_LOG_INFO("[PD] Shutting down %s", fwk_module_get_name(pd_id));
 
         if (api->shutdown != NULL) {
             status = pd->driver_api->shutdown(pd->driver_id, system_shutdown);
@@ -1237,16 +1229,12 @@ void perform_shutdown(
 
         if (status != FWK_SUCCESS)
             FWK_LOG_ERR(
-                mod_pd_ctx.log_api,
-                "[PD] Shutdown of %s returned %s (%d)\n",
+                "[PD] Shutdown of %s returned %s (%d)",
                 fwk_module_get_name(pd_id),
                 fwk_status_str(status),
                 status);
         else
-            FWK_LOG_TRACE(
-                mod_pd_ctx.log_api,
-                "[PD] %s shutdown\n",
-                fwk_module_get_name(pd_id));
+            FWK_LOG_INFO("[PD] %s shutdown", fwk_module_get_name(pd_id));
 
         pd->requested_state =
             pd->state_requested_to_driver =
@@ -1814,10 +1802,8 @@ static int pd_bind(fwk_id_t id, unsigned int round)
     if (round != 0)
         return FWK_SUCCESS;
 
-    if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE)) {
-        return fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-            FWK_ID_API(FWK_MODULE_IDX_LOG, 0), &mod_pd_ctx.log_api);
-    }
+    if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE))
+        return FWK_SUCCESS;
 
     pd = &mod_pd_ctx.pd_ctx_table[fwk_id_get_element_idx(id)];
     config = pd->config;
@@ -1870,7 +1856,6 @@ static int pd_start(fwk_id_t id)
         status = pd->driver_api->get_state(pd->driver_id, &state);
         if (status != FWK_SUCCESS) {
             FWK_LOG_ERR(
-                mod_pd_ctx.log_api,
                 driver_error_msg,
                 fwk_status_str(status),
                 status,
@@ -1991,9 +1976,7 @@ static int pd_process_event(const struct fwk_event *event,
 
     default:
         FWK_LOG_ERR(
-            mod_pd_ctx.log_api,
-            "[PD] Invalid power state request: <%d>.\n",
-            event->id);
+            "[PD] Invalid power state request: %s.", FWK_ID_STR(event->id));
 
         return FWK_E_PARAM;
     }
diff --git a/module/ppu_v0/src/mod_ppu_v0.c b/module/ppu_v0/src/mod_ppu_v0.c
index e5a04d26..be4b7d7b 100644
--- a/module/ppu_v0/src/mod_ppu_v0.c
+++ b/module/ppu_v0/src/mod_ppu_v0.c
@@ -48,9 +48,6 @@ struct ppu_v0_pd_ctx {
 struct ppu_v0_ctx {
     /* Table of the power domain contexts */
     struct ppu_v0_pd_ctx *pd_ctx_table;
-
-    /* Log API */
-   struct mod_log_api *log_api;
 };
 
 /*
@@ -89,8 +86,7 @@ static int get_state(struct ppu_v0_reg *ppu, unsigned int *state)
 
     *state = ppu_mode_to_power_state[ppu_mode];
     if (*state == MODE_UNSUPPORTED) {
-        FWK_LOG_ERR(
-            ppu_v0_ctx.log_api, "[PD] Unexpected PPU mode (%i).\n", ppu_mode);
+        FWK_LOG_ERR("[PD] Unexpected PPU mode (%i).", ppu_mode);
         return FWK_E_DEVICE;
     }
 
@@ -129,10 +125,7 @@ static int pd_set_state(fwk_id_t pd_id, unsigned int state)
         break;
 
     default:
-        FWK_LOG_ERR(
-            ppu_v0_ctx.log_api,
-            "[PD] Requested power state (%i) is not supported.\n",
-            state);
+        FWK_LOG_ERR("[PD] Requested power state (%i) is not supported.", state);
         return FWK_E_PARAM;
     }
 
@@ -223,12 +216,8 @@ static int ppu_v0_bind(fwk_id_t id, unsigned int round)
     if (round == 0)
         return FWK_SUCCESS;
 
-    /* In the case of the module, bind to the log component */
-    if (fwk_module_is_valid_module_id(id)) {
-        return fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                               FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-                               &ppu_v0_ctx.log_api);
-    }
+    if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE))
+        return FWK_SUCCESS;
 
     pd_ctx = ppu_v0_ctx.pd_ctx_table + fwk_id_get_element_idx(id);
 
diff --git a/module/ppu_v1/src/mod_ppu_v1.c b/module/ppu_v1/src/mod_ppu_v1.c
index 3aef94b8..a8a9106c 100644
--- a/module/ppu_v1/src/mod_ppu_v1.c
+++ b/module/ppu_v1/src/mod_ppu_v1.c
@@ -77,9 +77,6 @@ struct ppu_v1_ctx {
 
     /* Number of power domains */
     size_t pd_ctx_table_size;
-
-    /* Log API */
-    struct mod_log_api *log_api;
 };
 
 /*
@@ -124,8 +121,7 @@ static int get_state(struct ppu_v1_reg *ppu, unsigned int *state)
         *state = MOD_PD_STATE_SLEEP;
 
     if (*state == MODE_UNSUPPORTED) {
-        FWK_LOG_ERR(
-            ppu_v1_ctx.log_api, "[PPU_V1] Unexpected PPU mode (%i).\n", mode);
+        FWK_LOG_ERR("[PPU_V1] Unexpected PPU mode (%i).", mode);
         return FWK_E_DEVICE;
     }
 
@@ -155,10 +151,7 @@ static int ppu_v1_pd_set_state(fwk_id_t pd_id, unsigned int state)
         break;
 
     default:
-        FWK_LOG_ERR(
-            ppu_v1_ctx.log_api,
-            "[PD] Requested power state (%i) is not supported.\n",
-            state);
+        FWK_LOG_ERR("[PD] Requested power state (%i) is not supported.", state);
         return FWK_E_PARAM;
     }
 
@@ -281,9 +274,7 @@ static int ppu_v1_core_pd_set_state(fwk_id_t core_pd_id, unsigned int state)
 
     default:
         FWK_LOG_ERR(
-            ppu_v1_ctx.log_api,
-            "[PPU_V1] Requested CPU power state (%i) is not supported!\n",
-            state);
+            "[PPU_V1] Requested CPU power state (%i) is not supported!", state);
         return FWK_E_PARAM;
     }
 
@@ -535,9 +526,7 @@ static int ppu_v1_cluster_pd_set_state(fwk_id_t cluster_pd_id,
 
     default:
         FWK_LOG_ERR(
-            ppu_v1_ctx.log_api,
-            "[PPU_V1] Requested CPU power state (%i) is not supported!\n",
-            state);
+            "[PPU_V1] Requested CPU power state (%i) is not supported!", state);
         return FWK_E_PARAM;
     }
 }
@@ -752,13 +741,8 @@ static int ppu_v1_bind(fwk_id_t id, unsigned int round)
     if (round == 0)
         return FWK_SUCCESS;
 
-    /* In the case of the module, bind to the log component */
-    if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE)) {
-        status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                                 FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-                                 &ppu_v1_ctx.log_api);
-        return status;
-    }
+    if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE))
+        return FWK_SUCCESS;
 
     pd_ctx = ppu_v1_ctx.pd_ctx_table + fwk_id_get_element_idx(id);
 
diff --git a/module/scmi/src/mod_scmi.c b/module/scmi/src/mod_scmi.c
index d288504f..cd9d2f71 100644
--- a/module/scmi/src/mod_scmi.c
+++ b/module/scmi/src/mod_scmi.c
@@ -30,6 +30,7 @@
 #    include <fwk_multi_thread.h>
 #endif
 
+#include <inttypes.h>
 #include <string.h>
 
 struct scmi_protocol {
@@ -58,9 +59,6 @@ struct scmi_ctx {
 
     /* Table of service contexts */
     struct scmi_service_ctx *service_ctx_table;
-
-    /* Log module API */
-    struct mod_log_api *log_api;
 };
 
 /*
@@ -244,8 +242,8 @@ static void respond(fwk_id_t service_id, const void *payload, size_t size)
      */
     if ((payload != NULL) && (*((int32_t *)payload) < SCMI_SUCCESS)) {
         FWK_LOG_ERR(
-            scmi_ctx.log_api,
-            "[SCMI] %s: Message %u (0x%x:0x%x) returned with an error (%d)\n",
+            "[SCMI] %s: Message [%" PRIu16
+            " (0x%x:0x%x)] returned with an error (%d)",
             service_name,
             ctx->scmi_token,
             ctx->scmi_protocol_id,
@@ -253,8 +251,8 @@ static void respond(fwk_id_t service_id, const void *payload, size_t size)
             *((int *)payload));
     } else {
         FWK_LOG_TRACE(
-            scmi_ctx.log_api,
-            "[SCMI] %s: Message %u (0x%x:0x%x) returned successfully\n",
+            "[SCMI] %s: Message [%" PRIu16
+            " (0x%x:0x%x)] returned successfully",
             service_name,
             ctx->scmi_token,
             ctx->scmi_protocol_id,
@@ -264,8 +262,8 @@ static void respond(fwk_id_t service_id, const void *payload, size_t size)
     status = ctx->respond(ctx->transport_id, payload, size);
     if (status != FWK_SUCCESS) {
         FWK_LOG_ERR(
-            scmi_ctx.log_api,
-            "[SCMI] %s: Message %u (0x%x:0x%x) failed to respond (%s)\n",
+            "[SCMI] %s: Message [%" PRIu16
+            " (0x%x:0x%x)] failed to respond (%s)",
             service_name,
             ctx->scmi_token,
             ctx->scmi_protocol_id,
@@ -644,11 +642,8 @@ static int scmi_bind(fwk_id_t id, unsigned int round)
     uint8_t scmi_protocol_id;
 
     if (round == 0) {
-        if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE)) {
-            return fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                                   FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-                                   &scmi_ctx.log_api);
-        }
+        if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE))
+            return FWK_SUCCESS;
 
         ctx = &scmi_ctx.service_ctx_table[fwk_id_get_element_idx(id)];
         status = fwk_module_bind(ctx->config->transport_id,
@@ -764,19 +759,13 @@ static int scmi_process_event(const struct fwk_event *event,
 
     status = transport_api->get_message_header(transport_id, &message_header);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_ERR(
-            scmi_ctx.log_api,
-            "[SCMI] %s: Unable to read message header\n",
-            service_name);
+        FWK_LOG_ERR("[SCMI] %s: Unable to read message header", service_name);
         return status;
     }
 
     status = transport_api->get_payload(transport_id, &payload, &payload_size);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_ERR(
-            scmi_ctx.log_api,
-            "[SCMI] %s: Unable to read message payload\n",
-            service_name);
+        FWK_LOG_ERR("[SCMI] %s: Unable to read message payload", service_name);
         return status;
     }
 
@@ -785,8 +774,7 @@ static int scmi_process_event(const struct fwk_event *event,
     ctx->scmi_token = read_token(message_header);
 
     FWK_LOG_TRACE(
-        scmi_ctx.log_api,
-        "[SCMI] %s: Message %u (0x%x:0x%x) was received\n",
+        "[SCMI] %s: Message [%" PRIu16 " (0x%x:0x%x)] was received",
         service_name,
         ctx->scmi_token,
         ctx->scmi_protocol_id,
@@ -796,9 +784,9 @@ static int scmi_process_event(const struct fwk_event *event,
 
     if (protocol_idx == 0) {
         FWK_LOG_ERR(
-            scmi_ctx.log_api,
-            "[SCMI] %s: Message %u (0x%x:0x%x) requested an unsupported "
-            "protocol\n",
+            "[SCMI] %s: Message [%" PRIu16
+            " (0x%x:0x%x)] requested an "
+            "unsupported protocol",
             service_name,
             ctx->scmi_token,
             ctx->scmi_protocol_id,
@@ -814,8 +802,7 @@ static int scmi_process_event(const struct fwk_event *event,
 
     if (status != FWK_SUCCESS) {
         FWK_LOG_ERR(
-            scmi_ctx.log_api,
-            "[SCMI] %s: Message %u (0x%x:0x%x) encountered an error (%s)\n",
+            "[SCMI] %s: Message [%" PRIu16 " (0x%x:0x%x)] handler error (%s)",
             service_name,
             ctx->scmi_token,
             ctx->scmi_protocol_id,
diff --git a/module/scmi_power_domain/src/mod_scmi_power_domain.c b/module/scmi_power_domain/src/mod_scmi_power_domain.c
index f067b59b..beb9545d 100644
--- a/module/scmi_power_domain/src/mod_scmi_power_domain.c
+++ b/module/scmi_power_domain/src/mod_scmi_power_domain.c
@@ -46,9 +46,6 @@ struct scmi_pd_ctx {
     /* Number of power domains */
     unsigned int domain_count;
 
-    /* Log module API */
-    const struct mod_log_api *log_api;
-
     /* SCMI module API */
     const struct mod_scmi_from_protocol_api *scmi_api;
 
@@ -381,8 +378,7 @@ static int scmi_power_scp_set_core_state(fwk_id_t pd_id,
                                                            composite_state);
     if (status != FWK_SUCCESS) {
         FWK_LOG_ERR(
-            scmi_pd_ctx.log_api,
-            "[SCMI:power] Failed to send core set request (error %s (%d))\n",
+            "[SCMI:power] Failed to send core set request (error %s (%d))",
             fwk_status_str(status),
             status);
     }
@@ -736,11 +732,6 @@ static int scmi_pd_bind(fwk_id_t id, unsigned int round)
     if (round == 1)
         return FWK_SUCCESS;
 
-    status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-        FWK_ID_API(FWK_MODULE_IDX_LOG, 0), &scmi_pd_ctx.log_api);
-    if (status != FWK_SUCCESS)
-        return status;
-
     status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_SCMI),
         FWK_ID_API(FWK_MODULE_IDX_SCMI, MOD_SCMI_API_IDX_PROTOCOL),
         &scmi_pd_ctx.scmi_api);
diff --git a/module/smt/src/mod_smt.c b/module/smt/src/mod_smt.c
index 53a0fc73..77bc3572 100644
--- a/module/smt/src/mod_smt.c
+++ b/module/smt/src/mod_smt.c
@@ -59,9 +59,6 @@ struct smt_channel_ctx {
 };
 
 struct smt_ctx {
-    /* Log module API */
-    struct mod_log_api *log_api;
-
     /* Table of channel contexts */
     struct smt_channel_ctx *channel_ctx_table;
 
@@ -250,8 +247,7 @@ static int smt_slave_handler(struct smt_channel_ctx *channel_ctx)
     /* Check we have ownership of the mailbox */
     if (memory->status & MOD_SMT_MAILBOX_STATUS_FREE_MASK) {
         FWK_LOG_ERR(
-            smt_ctx.log_api,
-            "[SMT] Mailbox ownership error on channel %u\n",
+            "[SMT] Mailbox ownership error on channel %u",
             fwk_id_get_element_idx(channel_ctx->id));
 
         return FWK_E_STATE;
@@ -306,7 +302,7 @@ static int smt_signal_message(fwk_id_t channel_id)
 
     if (!channel_ctx->smt_mailbox_ready) {
         /* Discard any message in the mailbox when not ready */
-        FWK_LOG_ERR(smt_ctx.log_api, "[SMT] Message not valid\n");
+        FWK_LOG_ERR("[SMT] Message not valid");
 
         return FWK_SUCCESS;
     }
@@ -378,11 +374,8 @@ static int smt_bind(fwk_id_t id, unsigned int round)
     struct smt_channel_ctx *channel_ctx;
 
     if (round == 0) {
-        if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE)) {
-            return fwk_module_bind(fwk_module_id_log,
-                                   FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-                                   &smt_ctx.log_api);
-        }
+        if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE))
+            return FWK_SUCCESS;
 
         channel_ctx = &smt_ctx.channel_ctx_table[fwk_id_get_element_idx(id)];
         status = fwk_module_bind(channel_ctx->config->driver_id,
diff --git a/module/system_power/src/mod_system_power.c b/module/system_power/src/mod_system_power.c
index 8e25c64c..6bd15a82 100644
--- a/module/system_power/src/mod_system_power.c
+++ b/module/system_power/src/mod_system_power.c
@@ -42,9 +42,6 @@ struct system_power_dev_ctx {
 
 /* Module context */
 struct system_power_ctx {
-    /* Log API pointer */
-    const struct mod_log_api *log_api;
-
     /* System power element context table */
     struct system_power_dev_ctx *dev_ctx_table;
 
@@ -443,10 +440,6 @@ static int system_power_bind(fwk_id_t id, unsigned int round)
     }
 
     if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE)) {
-        status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-            FWK_ID_API(FWK_MODULE_IDX_LOG, 0), &system_power_ctx.log_api);
-        if (status != FWK_SUCCESS)
-            return status;
 
         config = system_power_ctx.config;
 
diff --git a/module/timer/src/mod_timer.c b/module/timer/src/mod_timer.c
index 2296b386..43bf47d8 100644
--- a/module/timer/src/mod_timer.c
+++ b/module/timer/src/mod_timer.c
@@ -65,9 +65,6 @@ struct alarm_ctx {
 /* Table of timer device context structures */
 static struct dev_ctx *ctx_table;
 
-/* Log API */
-static const struct mod_log_api *log_api;
-
 /*
  * Forward declarations
  */
@@ -514,9 +511,8 @@ static void timer_isr(uintptr_t ctx_ptr)
             _insert_alarm_ctx_into_active_queue(ctx, alarm);
         } else {
             FWK_LOG_ERR(
-                log_api,
                 "[Timer] Error: Periodic alarm could not be added "
-                "back into queue.\n");
+                "back into queue.");
         }
     }
 
@@ -563,12 +559,8 @@ static int timer_bind(fwk_id_t id, unsigned int round)
     if (round > 0)
         return FWK_SUCCESS;
 
-    /* Bind to log module */
-    if (fwk_module_is_valid_module_id(id)) {
-        return fwk_module_bind(fwk_module_id_log,
-                               FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-                               &log_api);
-    }
+    if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE))
+        return FWK_SUCCESS;
 
     ctx = ctx_table + fwk_id_get_element_idx(id);
     ctx->driver_dev_id = ctx->config->id;
diff --git a/product/host/fw/config_log.c b/product/host/fw/config_log.c
index 80da36bd..9d3a1f36 100644
--- a/product/host/fw/config_log.c
+++ b/product/host/fw/config_log.c
@@ -17,13 +17,7 @@
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_MODULE_INIT(FWK_MODULE_IDX_HOST_CONSOLE),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_HOST_CONSOLE, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_SCP
-              "Host Firmware\n"
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner = FWK_BANNER_SCP "Host Firmware" BUILD_VERSION_DESCRIBE_STRING,
 };
 
 const struct fwk_module_config config_log = {
diff --git a/product/juno/module/juno_dmc400/src/mod_juno_dmc400.c b/product/juno/module/juno_dmc400/src/mod_juno_dmc400.c
index 87612290..513b5692 100644
--- a/product/juno/module/juno_dmc400/src/mod_juno_dmc400.c
+++ b/product/juno/module/juno_dmc400/src/mod_juno_dmc400.c
@@ -39,7 +39,6 @@ struct juno_dmc400_ctx {
     const struct mod_juno_dmc400_ddr_phy_api *ddr_phy_api;
     const struct mod_timer_api *timer_api;
     unsigned int dmc_refclk_ratio;
-    const struct mod_log_api *log_api;
 };
 
 static struct juno_dmc400_ctx ctx;
@@ -614,7 +613,7 @@ static int ddr_training(fwk_id_t id)
     return FWK_SUCCESS;
 
 timeout:
-    FWK_LOG_WARN(ctx.log_api, "[DMC] Training time-out\n");
+    FWK_LOG_WARN("[DMC] Training time-out");
 
     return FWK_E_TIMEOUT;
 }
@@ -650,7 +649,7 @@ static int ddr_retraining(fwk_id_t id)
 
     fwk_interrupt_enable(PHY_TRAINING_IRQ);
 
-    FWK_LOG_TRACE(ctx.log_api, "[DMC] Re-training done\n");
+    FWK_LOG_INFO("[DMC] Re-training done");
 
     return FWK_SUCCESS;
 }
@@ -880,11 +879,6 @@ static int juno_dmc400_bind(fwk_id_t id, unsigned int round)
     module_config = fwk_module_get_data(fwk_module_id_juno_dmc400);
     fwk_assert(module_config != NULL);
 
-    status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                             MOD_LOG_API_ID, &ctx.log_api);
-    if (status != FWK_SUCCESS)
-        return status;
-
     status = fwk_module_bind(module_config->ddr_phy_module_id,
                              module_config->ddr_phy_api_id, &ctx.ddr_phy_api);
     if (status != FWK_SUCCESS)
@@ -910,8 +904,7 @@ static int juno_dmc400_start(fwk_id_t id)
         return FWK_SUCCESS;
 
     if (SCC->GPR0 & SCC_GPR0_DDR_DISABLE) {
-        FWK_LOG_TRACE(
-            ctx.log_api, "[DMC] GPR_0 disable flag set: skipping init");
+        FWK_LOG_INFO("[DMC] GPR_0 disable flag set: skipping init");
 
         return FWK_SUCCESS;
     }
@@ -927,8 +920,7 @@ static int juno_dmc400_start(fwk_id_t id)
     ctx.dmc_refclk_ratio = (DDR_FREQUENCY_MHZ * FWK_MHZ) / CLOCK_RATE_REFCLK;
     fwk_assert(ctx.dmc_refclk_ratio > 0);
 
-    FWK_LOG_TRACE(
-        ctx.log_api, "[DMC] Initializing DMC-400 at 0x%x\n", (uintptr_t)dmc);
+    FWK_LOG_INFO("[DMC] Initializing DMC-400 at 0x%x", (uintptr_t)dmc);
 
     status = ddr_clk_init(id);
     if (status != FWK_SUCCESS)
@@ -964,7 +956,7 @@ static int juno_dmc400_start(fwk_id_t id)
     dmc->INTEG_CFG = 0x00000000;
     dmc->INTEG_OUTPUTS = 0x00000000;
 
-    FWK_LOG_TRACE(ctx.log_api, "[DMC] DDR Ready\n");
+    FWK_LOG_INFO("[DMC] DDR Ready");
 
     /* Switch to READY */
     dmc->MEMC_CMD = DMC400_CMD_GO;
diff --git a/product/juno/module/juno_hdlcd/src/mod_juno_hdlcd.c b/product/juno/module/juno_hdlcd/src/mod_juno_hdlcd.c
index 109663ee..d720a197 100644
--- a/product/juno/module/juno_hdlcd/src/mod_juno_hdlcd.c
+++ b/product/juno/module/juno_hdlcd/src/mod_juno_hdlcd.c
@@ -12,15 +12,16 @@
 
 #include <mod_clock.h>
 #include <mod_juno_hdlcd.h>
-#include <mod_log.h>
 
 #include <fwk_assert.h>
 #include <fwk_id.h>
+#include <fwk_log.h>
 #include <fwk_mm.h>
 #include <fwk_module.h>
 #include <fwk_module_idx.h>
 #include <fwk_status.h>
 
+#include <inttypes.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ -45,7 +46,6 @@ struct juno_hdlcd_dev_ctx {
 
 struct juno_hdlcd_ctx {
     const struct mod_juno_hdlcd_config *config;
-    const struct mod_log_api *log_api;
 
     /* Shared PLL rate value */
     uint32_t current_pll_rate;
@@ -107,8 +107,8 @@ static int round_rate(struct juno_hdlcd_dev_ctx *ctx,
 
 static void enable_pll(fwk_id_t clock_id, struct juno_hdlcd_dev_ctx *ctx)
 {
-    module_ctx.log_api->log(MOD_LOG_GROUP_INFO,
-        "[HDLCD%u] Setting PLL R0:0x%08x R1:0x%08x\n",
+    FWK_LOG_INFO(
+        "[HDLCD%u] Setting PLL R0:0x%" PRIX32 " R1:0x%" PRIX32,
         fwk_id_get_element_idx(clock_id),
         ctx->config->lookup_table[ctx->index].pll.REG0,
         ctx->config->lookup_table[ctx->index].pll.REG1);
@@ -191,8 +191,9 @@ static int juno_hdlcd_set_rate(fwk_id_t clock_id, uint64_t rate,
         *ctx->config->scc_control &= ~SCC_HDLCD_CONTROL_PXLCLK_SEL;
         *ctx->config->scc_control |= SCC_HDLCD_CONTROL_PXLCLK_SEL_CLKIN;
 
-        module_ctx.log_api->log(MOD_LOG_GROUP_INFO,
-            "[HDLCD%u]: Request:%uHz\n", fwk_id_get_element_idx(clock_id),
+        FWK_LOG_INFO(
+            "[HDLCD%u]: Request:%" PRIu32 "Hz",
+            fwk_id_get_element_idx(clock_id),
             rounded_rate);
 
         return FWK_SUCCESS;
@@ -206,8 +207,9 @@ static int juno_hdlcd_set_rate(fwk_id_t clock_id, uint64_t rate,
         *ctx->config->scc_control &= ~SCC_HDLCD_CONTROL_PXLCLK_SEL;
         *ctx->config->scc_control |= SCC_HDLCD_CONTROL_PXLCLK_SEL_PLL;
 
-        module_ctx.log_api->log(MOD_LOG_GROUP_INFO,
-            "[HDLCD%u]: Request:%uHz\n", fwk_id_get_element_idx(clock_id),
+        FWK_LOG_INFO(
+            "[HDLCD%u]: Request:%" PRIu32 "Hz",
+            fwk_id_get_element_idx(clock_id),
             rounded_rate);
 
         return FWK_SUCCESS;
@@ -223,8 +225,10 @@ static int juno_hdlcd_set_rate(fwk_id_t clock_id, uint64_t rate,
         ((unsigned int)ctx->index >= ctx->config->lookup_table_count))
         return FWK_E_RANGE;
 
-    module_ctx.log_api->log(MOD_LOG_GROUP_INFO, "[HDLCD%u] Entry index:%d\n",
-        fwk_id_get_element_idx(clock_id), ctx->index);
+    FWK_LOG_INFO(
+        "[HDLCD%u] Entry index:%d",
+        fwk_id_get_element_idx(clock_id),
+        ctx->index);
 
     /* Hold PLL in reset during the configuration process */
     SCC->PLL[PLL_IDX_HDLCD].REG0 = (PLL_REG0_PLL_RESET | PLL_REG0_HARD_BYPASS);
@@ -235,8 +239,7 @@ static int juno_hdlcd_set_rate(fwk_id_t clock_id, uint64_t rate,
         status = ctx->driver_api->set_rate_from_index(ctx->config->driver_id,
             ctx->index);
         if ((status != FWK_PENDING) && (status != FWK_SUCCESS)) {
-            module_ctx.log_api->log(MOD_LOG_GROUP_ERROR,
-                "[HDLCD] Failed to set board clock\n");
+            FWK_LOG_ERR("[HDLCD] Failed to set board clock");
             return FWK_E_DEVICE;
         }
         if (status == FWK_PENDING)
@@ -365,15 +368,8 @@ static int juno_hdlcd_bind(fwk_id_t id, unsigned int round)
     if (round > 0)
         return FWK_SUCCESS;
 
-    if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE)) {
-        /* Bind to the log */
-        status = fwk_module_bind(fwk_module_id_log, MOD_LOG_API_ID,
-            &module_ctx.log_api);
-        if (status != FWK_SUCCESS)
-            return FWK_E_HANDLER;
-
+    if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE))
         return FWK_SUCCESS;
-    }
 
     ctx = ctx_table + fwk_id_get_element_idx(id);
 
diff --git a/product/juno/module/juno_ppu/src/juno_ppu.h b/product/juno/module/juno_ppu/src/juno_ppu.h
index 8ee65dcd..2a239e3e 100644
--- a/product/juno/module/juno_ppu/src/juno_ppu.h
+++ b/product/juno/module/juno_ppu/src/juno_ppu.h
@@ -54,9 +54,6 @@ struct module_ctx {
     /* Table of element context structures */
     struct ppu_ctx *ppu_ctx_table;
 
-    /* Log module API */
-    const struct mod_log_api *log_api;
-
     /* Timer alarm API */
     const struct mod_timer_alarm_api *alarm_api;
 
diff --git a/product/juno/module/juno_ppu/src/mod_juno_ppu.c b/product/juno/module/juno_ppu/src/mod_juno_ppu.c
index 92696c97..7db8d4ab 100644
--- a/product/juno/module/juno_ppu/src/mod_juno_ppu.c
+++ b/product/juno/module/juno_ppu/src/mod_juno_ppu.c
@@ -417,7 +417,7 @@ static int css_set_state(fwk_id_t ppu_id, unsigned int state)
         /* Fall through */
 
     case MOD_SYSTEM_POWER_POWER_STATE_SLEEP0:
-        juno_ppu_ctx.log_api->flush();
+        FWK_LOG_FLUSH();
 
         enable_scp_remap();
 
@@ -833,11 +833,6 @@ static int juno_ppu_bind(fwk_id_t id, unsigned int round)
         return FWK_SUCCESS;
 
     if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE)) {
-        status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                                 MOD_LOG_API_ID, &juno_ppu_ctx.log_api);
-        if (status != FWK_SUCCESS)
-            return FWK_E_HANDLER;
-
         #if BUILD_HAS_MOD_TIMER
         config = fwk_module_get_data(fwk_module_id_juno_ppu);
 
diff --git a/product/juno/module/juno_rom/src/mod_juno_rom.c b/product/juno/module/juno_rom/src/mod_juno_rom.c
index 62faae77..5ca0b6ef 100644
--- a/product/juno/module/juno_rom/src/mod_juno_rom.c
+++ b/product/juno/module/juno_rom/src/mod_juno_rom.c
@@ -51,7 +51,6 @@
 static struct {
     const struct mod_juno_rom_config *config;
     const struct mod_juno_ppu_rom_api *ppu_api;
-    struct mod_log_api *log_api;
     struct mod_bootloader_api *bootloader_api;
     unsigned int notification_count;
     unsigned int boot_map_little;
@@ -183,8 +182,7 @@ static int deferred_setup(void)
         FWK_ARRAY_SIZE(core_ppu_table_little));
 
     if (status != FWK_SUCCESS) {
-        FWK_LOG_ERR(
-            ctx.log_api, "[ROM] ERROR: Failed to turn on LITTLE cluster.\n");
+        FWK_LOG_ERR("[ROM] ERROR: Failed to turn on LITTLE cluster.");
         return FWK_E_DEVICE;
     }
 
@@ -195,8 +193,7 @@ static int deferred_setup(void)
         FWK_ARRAY_SIZE(core_ppu_table_big));
 
     if (status != FWK_SUCCESS) {
-        FWK_LOG_ERR(
-            ctx.log_api, "[ROM] ERROR: Failed to turn on big cluster.\n");
+        FWK_LOG_ERR("[ROM] ERROR: Failed to turn on big cluster.");
         return FWK_E_DEVICE;
     }
 
@@ -220,10 +217,7 @@ static int deferred_setup(void)
 
     status = ctx.bootloader_api->load_image();
 
-    FWK_LOG_ERR(
-        ctx.log_api,
-        "[ROM] ERROR: Failed to load RAM firmware image: %d\n",
-        status);
+    FWK_LOG_ERR("[ROM] ERROR: Failed to load RAM firmware image: %d", status);
 
     return FWK_E_DATA;
 }
@@ -262,10 +256,6 @@ static int juno_rom_bind(fwk_id_t id, unsigned int round)
     if (!fwk_expect(status == FWK_SUCCESS))
         return FWK_E_PANIC;
 
-    status = fwk_module_bind(fwk_module_id_log, MOD_LOG_API_ID, &ctx.log_api);
-    if (!fwk_expect(status == FWK_SUCCESS))
-        return FWK_E_PANIC;
-
     status = fwk_module_bind(
         fwk_module_id_bootloader,
         FWK_ID_API(FWK_MODULE_IDX_BOOTLOADER, 0),
@@ -349,9 +339,8 @@ static int juno_rom_process_event(
     if (SCC->APP_ALT_BOOT != 0) {
         if ((SCC->APP_ALT_BOOT & 0x3) != 0) {
             FWK_LOG_ERR(
-                ctx.log_api,
                 "[ROM] ERROR: Alternative AP ROM address does not have 4 byte "
-                "alignment\n");
+                "alignment");
             return FWK_E_ALIGN;
         }
 
diff --git a/product/juno/module/juno_thermal/src/mod_juno_thermal.c b/product/juno/module/juno_thermal/src/mod_juno_thermal.c
index 29e27a8d..3fad826b 100644
--- a/product/juno/module/juno_thermal/src/mod_juno_thermal.c
+++ b/product/juno/module/juno_thermal/src/mod_juno_thermal.c
@@ -34,7 +34,6 @@ enum mod_juno_thermal_event_idx {
     MOD_JUNO_THERMAL_EVENT_IDX_COUNT,
 };
 
-static const struct mod_log_api *log_api;
 static const struct mod_pd_restricted_api *pd_api;
 
 static const fwk_id_t systop_pd_id =
@@ -144,14 +143,8 @@ static int juno_thermal_bind(fwk_id_t id, unsigned int round)
 
     if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE)) {
         /* Bind to power domain - only binding to module is allowed */
-        status = fwk_module_bind(
-            fwk_module_id_power_domain,
-            mod_pd_api_id_restricted,
-            &pd_api);
-        if (status != FWK_SUCCESS)
-            return FWK_E_PANIC;
-
-        return fwk_module_bind(fwk_module_id_log, MOD_LOG_API_ID, &log_api);
+        return fwk_module_bind(
+            fwk_module_id_power_domain, mod_pd_api_id_restricted, &pd_api);
     }
 
     ctx = &ctx_table[fwk_id_get_element_idx(id)];
@@ -204,7 +197,7 @@ static int juno_thermal_start(fwk_id_t id)
 static int check_threshold_breach(uint64_t temperature, uint64_t threshold)
 {
     if (temperature > threshold) {
-        FWK_LOG_WARN(log_api, "[THERMAL] system shutdown\n");
+        FWK_LOG_WARN("[THERMAL] system shutdown");
 
         return pd_api->system_shutdown(MOD_PD_SYSTEM_FORCED_SHUTDOWN);
     }
diff --git a/product/juno/scp_ramfw/config_log.c b/product/juno/scp_ramfw/config_log.c
index 1a7da35d..8722ffe9 100644
--- a/product/juno/scp_ramfw/config_log.c
+++ b/product/juno/scp_ramfw/config_log.c
@@ -50,17 +50,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    #ifdef BUILD_MODE_DEBUG
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    #else
-    .log_groups = MOD_LOG_GROUP_ERROR,
-    #endif
-    .banner = FWK_BANNER_SCP
-              FWK_BANNER_RAM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_SCP FWK_BANNER_RAM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/juno/scp_romfw/config_log.c b/product/juno/scp_romfw/config_log.c
index c449fde3..eb645991 100644
--- a/product/juno/scp_romfw/config_log.c
+++ b/product/juno/scp_romfw/config_log.c
@@ -55,17 +55,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    #ifdef BUILD_MODE_DEBUG
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    #else
-    .log_groups = MOD_LOG_GROUP_ERROR,
-    #endif
-    .banner = FWK_BANNER_SCP
-              FWK_BANNER_ROM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_SCP FWK_BANNER_ROM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/juno/scp_romfw_bypass/config_log.c b/product/juno/scp_romfw_bypass/config_log.c
index c449fde3..eb645991 100644
--- a/product/juno/scp_romfw_bypass/config_log.c
+++ b/product/juno/scp_romfw_bypass/config_log.c
@@ -55,17 +55,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    #ifdef BUILD_MODE_DEBUG
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    #else
-    .log_groups = MOD_LOG_GROUP_ERROR,
-    #endif
-    .banner = FWK_BANNER_SCP
-              FWK_BANNER_ROM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_SCP FWK_BANNER_ROM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/n1sdp/mcp_ramfw/config_log.c b/product/n1sdp/mcp_ramfw/config_log.c
index fb3433ea..8e8f97f2 100644
--- a/product/n1sdp/mcp_ramfw/config_log.c
+++ b/product/n1sdp/mcp_ramfw/config_log.c
@@ -49,13 +49,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_MCP
-              FWK_BANNER_RAM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_MCP FWK_BANNER_RAM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/n1sdp/mcp_romfw/config_log.c b/product/n1sdp/mcp_romfw/config_log.c
index bf4412b0..cf000eda 100644
--- a/product/n1sdp/mcp_romfw/config_log.c
+++ b/product/n1sdp/mcp_romfw/config_log.c
@@ -20,7 +20,7 @@
 /*
  * N1SDP BYPASS ROM firmware banner string.
  */
-#define N1SDP_BANNER_ROM_FIRMWARE "Entered BYPASS ROM Firmware\n"
+#define N1SDP_BANNER_ROM_FIRMWARE "Entered BYPASS ROM Firmware"
 
 /*
  * PL011 module
@@ -54,13 +54,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_MCP
-              N1SDP_BANNER_ROM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_MCP N1SDP_BANNER_ROM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/n1sdp/module/n1sdp_c2c/src/mod_n1sdp_c2c_i2c.c b/product/n1sdp/module/n1sdp_c2c/src/mod_n1sdp_c2c_i2c.c
index 43521d81..15f56f18 100644
--- a/product/n1sdp/module/n1sdp_c2c/src/mod_n1sdp_c2c_i2c.c
+++ b/product/n1sdp/module/n1sdp_c2c/src/mod_n1sdp_c2c_i2c.c
@@ -87,9 +87,6 @@ struct n1sdp_c2c_ctx {
     /*  Pointer to module configuration */
     struct n1sdp_c2c_dev_config *config;
 
-    /* Log API pointer */
-    const struct mod_log_api *log_api;
-
     /* I2C Master API ID */
     struct mod_n1sdp_i2c_master_api_polled *master_api;
 
@@ -154,7 +151,7 @@ static int n1sdp_c2c_master_tx_command(uint8_t cmd)
 {
     int status;
 
-    FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "[C2C] %s in slave...", cmd_str[cmd]);
+    FWK_LOG_INFO("[C2C] %s in slave...", cmd_str[cmd]);
 
     n1sdp_c2c_ctx.master_tx_data[0] = cmd;
     status = n1sdp_c2c_ctx.master_api->write(
@@ -163,10 +160,10 @@ static int n1sdp_c2c_master_tx_command(uint8_t cmd)
         (char *)&n1sdp_c2c_ctx.master_tx_data[0],
         N1SDP_C2C_DATA_SIZE, true);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "Error!\n");
+        FWK_LOG_INFO("[C2C] Error!");
         return status;
     }
-    FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "Done\n");
+    FWK_LOG_INFO("Done");
 
     return FWK_SUCCESS;
 }
@@ -175,17 +172,16 @@ static int n1sdp_c2c_master_rx_response(void)
 {
     int status;
 
-    FWK_LOG_INFO(
-        n1sdp_c2c_ctx.log_api, "[C2C] Waiting for response from slave...");
+    FWK_LOG_INFO("[C2C] Waiting for response from slave...");
     status = n1sdp_c2c_ctx.master_api->read(
         n1sdp_c2c_ctx.config->i2c_id,
         n1sdp_c2c_ctx.config->slave_addr,
         (char *)&n1sdp_c2c_ctx.master_rx_data[0], N1SDP_C2C_DATA_SIZE);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "Error %d!\n", status);
+        FWK_LOG_INFO("[C2C] Error %d!", status);
         return status;
     }
-    FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "Received\n");
+    FWK_LOG_INFO("[C2C] Received");
 
     return FWK_SUCCESS;
 }
@@ -209,16 +205,14 @@ static int n1sdp_c2c_check_remote(void)
         }
 
         n1sdp_c2c_ctx.slave_alive = true;
-        FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "[C2C] Slave Alive!\n");
+        FWK_LOG_INFO("[C2C] Slave Alive!");
         return FWK_SUCCESS;
     } else {
         status = n1sdp_c2c_ctx.slave_api->read(
             n1sdp_c2c_ctx.config->i2c_id,
             &n1sdp_c2c_ctx.slave_rx_data[0], N1SDP_C2C_DATA_SIZE);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(
-                n1sdp_c2c_ctx.log_api,
-                "[C2C] Error setting up I2C for reception!\n");
+            FWK_LOG_INFO("[C2C] Error setting up I2C for reception!");
             return status;
         }
     }
@@ -237,15 +231,14 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
             return status;
     }
 
-    FWK_LOG_INFO(
-        n1sdp_c2c_ctx.log_api, "[C2C] %s in master...\n", cmd_str[cmd]);
+    FWK_LOG_INFO("[C2C] %s in master...", cmd_str[cmd]);
 
     switch (cmd) {
     case N1SDP_C2C_CMD_PCIE_POWER_ON:
         status = n1sdp_c2c_ctx.pcie_init_api->power_on(
             n1sdp_c2c_ctx.config->ccix_id);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "Error!\n");
+            FWK_LOG_INFO("[C2C] Error!");
             return status;
         }
         if (run_in_slave) {
@@ -253,8 +246,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
             if (status != FWK_SUCCESS)
                 return status;
             if (n1sdp_c2c_ctx.master_rx_data[0] != N1SDP_C2C_SUCCESS) {
-                FWK_LOG_INFO(
-                    n1sdp_c2c_ctx.log_api, "[C2C] Command failed in slave!\n");
+                FWK_LOG_INFO("[C2C] Command failed in slave!");
                 return FWK_E_STATE;
             }
         }
@@ -264,7 +256,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
         status = n1sdp_c2c_ctx.pcie_init_api->phy_init(
             n1sdp_c2c_ctx.config->ccix_id);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "Error!\n");
+            FWK_LOG_INFO("[C2C] Error!");
             return status;
         }
         if (run_in_slave) {
@@ -272,8 +264,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
             if (status != FWK_SUCCESS)
                 return status;
             if (n1sdp_c2c_ctx.master_rx_data[0] != N1SDP_C2C_SUCCESS) {
-                FWK_LOG_INFO(
-                    n1sdp_c2c_ctx.log_api, "[C2C] Command failed in slave!\n");
+                FWK_LOG_INFO("[C2C] Command failed in slave!");
                 return FWK_E_STATE;
             }
         }
@@ -283,7 +274,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
         status = n1sdp_c2c_ctx.pcie_init_api->controller_init(
             n1sdp_c2c_ctx.config->ccix_id, false);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "Error!\n");
+            FWK_LOG_INFO("[C2C] Error!");
             return status;
         }
         if (run_in_slave) {
@@ -291,8 +282,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
             if (status != FWK_SUCCESS)
                 return status;
             if (n1sdp_c2c_ctx.master_rx_data[0] != N1SDP_C2C_SUCCESS) {
-                FWK_LOG_INFO(
-                    n1sdp_c2c_ctx.log_api, "[C2C] Command failed in slave!\n");
+                FWK_LOG_INFO("[C2C] Command failed in slave!");
                 return FWK_E_STATE;
             }
         }
@@ -302,7 +292,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
         status = n1sdp_c2c_ctx.pcie_init_api->link_training(
             n1sdp_c2c_ctx.config->ccix_id, false);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "Error!\n");
+            FWK_LOG_INFO("[C2C] Error!");
             return status;
         }
         if (run_in_slave) {
@@ -310,8 +300,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
             if (status != FWK_SUCCESS)
                 return status;
             if (n1sdp_c2c_ctx.master_rx_data[0] != N1SDP_C2C_SUCCESS) {
-                FWK_LOG_INFO(
-                    n1sdp_c2c_ctx.log_api, "[C2C] Command failed in slave!\n");
+                FWK_LOG_INFO("[C2C] Command failed in slave!");
                 return FWK_E_STATE;
             }
         }
@@ -321,7 +310,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
         status = n1sdp_c2c_ctx.pcie_init_api->rc_setup(
             n1sdp_c2c_ctx.config->ccix_id);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "Error!\n");
+            FWK_LOG_INFO("[C2C] Error!");
             return status;
         }
         if (run_in_slave) {
@@ -329,8 +318,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
             if (status != FWK_SUCCESS)
                 return status;
             if (n1sdp_c2c_ctx.master_rx_data[0] != N1SDP_C2C_SUCCESS) {
-                FWK_LOG_INFO(
-                    n1sdp_c2c_ctx.log_api, "[C2C] Command failed in slave!\n");
+                FWK_LOG_INFO("[C2C] Command failed in slave!");
                 return FWK_E_STATE;
             }
         }
@@ -340,7 +328,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
         status = n1sdp_c2c_ctx.pcie_init_api->vc1_setup(
             n1sdp_c2c_ctx.config->ccix_id, CCIX_VC1_TC);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "Error!\n");
+            FWK_LOG_INFO("[C2C] Error!");
             return status;
         }
         if (run_in_slave) {
@@ -348,8 +336,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
             if (status != FWK_SUCCESS)
                 return status;
             if (n1sdp_c2c_ctx.master_rx_data[0] != N1SDP_C2C_SUCCESS) {
-                FWK_LOG_INFO(
-                    n1sdp_c2c_ctx.log_api, "[C2C] Command failed in slave!\n");
+                FWK_LOG_INFO("[C2C] Command failed in slave!");
                 return FWK_E_STATE;
             }
         }
@@ -359,7 +346,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
         status = n1sdp_c2c_ctx.ccix_config_api->enable_opt_tlp(
             CCIX_OPT_TLP_EN);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "Error!\n");
+            FWK_LOG_INFO("[C2C] Error!");
             return status;
         }
         if (run_in_slave) {
@@ -367,8 +354,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
             if (status != FWK_SUCCESS)
                 return status;
             if (n1sdp_c2c_ctx.master_rx_data[0] != N1SDP_C2C_SUCCESS) {
-                FWK_LOG_INFO(
-                    n1sdp_c2c_ctx.log_api, "[C2C] Command failed in slave!\n");
+                FWK_LOG_INFO("[C2C] Command failed in slave!");
                 return FWK_E_STATE;
             }
         }
@@ -392,7 +378,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
 
         status = n1sdp_c2c_ctx.cmn600_api->set_config(&remote_config);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "Error!\n");
+            FWK_LOG_INFO("[C2C] Error!");
             return status;
         }
         if (run_in_slave) {
@@ -400,8 +386,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
             if (status != FWK_SUCCESS)
                 return status;
             if (n1sdp_c2c_ctx.master_rx_data[0] != N1SDP_C2C_SUCCESS) {
-                FWK_LOG_INFO(
-                    n1sdp_c2c_ctx.log_api, "[C2C] Command failed in slave!\n");
+                FWK_LOG_INFO("[C2C] Command failed in slave!");
                 return FWK_E_STATE;
             }
         }
@@ -411,7 +396,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
         status = n1sdp_c2c_ctx.cmn600_api->exchange_protocol_credit(
             CMN600_CCIX_LINK_ID);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "Error!\n");
+            FWK_LOG_INFO("[C2C] Error!");
             return status;
         }
         if (run_in_slave) {
@@ -419,8 +404,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
             if (status != FWK_SUCCESS)
                 return status;
             if (n1sdp_c2c_ctx.master_rx_data[0] != N1SDP_C2C_SUCCESS) {
-                FWK_LOG_INFO(
-                    n1sdp_c2c_ctx.log_api, "[C2C] Command failed in slave!\n");
+                FWK_LOG_INFO("[C2C] Command failed in slave!");
                 return FWK_E_STATE;
             }
         }
@@ -430,7 +414,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
         status = n1sdp_c2c_ctx.cmn600_api->enter_system_coherency(
             CMN600_CCIX_LINK_ID);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "Error!\n");
+            FWK_LOG_INFO("[C2C] Error!");
             return status;
         }
         if (run_in_slave) {
@@ -438,8 +422,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
             if (status != FWK_SUCCESS)
                 return status;
             if (n1sdp_c2c_ctx.master_rx_data[0] != N1SDP_C2C_SUCCESS) {
-                FWK_LOG_INFO(
-                    n1sdp_c2c_ctx.log_api, "[C2C] Command failed in slave!\n");
+                FWK_LOG_INFO("[C2C] Command failed in slave!");
                 return FWK_E_STATE;
             }
         }
@@ -449,7 +432,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
         status = n1sdp_c2c_ctx.cmn600_api->enter_dvm_domain(
             CMN600_CCIX_LINK_ID);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "Error!\n");
+            FWK_LOG_INFO("[C2C] Error!");
             return status;
         }
         if (run_in_slave) {
@@ -457,8 +440,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
             if (status != FWK_SUCCESS)
                 return status;
             if (n1sdp_c2c_ctx.master_rx_data[0] != N1SDP_C2C_SUCCESS) {
-                FWK_LOG_INFO(
-                    n1sdp_c2c_ctx.log_api, "[C2C] Command failed in slave!\n");
+                FWK_LOG_INFO("[C2C] Command failed in slave!");
                 return FWK_E_STATE;
             }
         }
@@ -470,15 +452,12 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
             if (status != FWK_SUCCESS)
                 return status;
             if (n1sdp_c2c_ctx.master_rx_data[0] != N1SDP_C2C_SUCCESS) {
-                FWK_LOG_INFO(
-                    n1sdp_c2c_ctx.log_api, "[C2C] Command failed in slave!\n");
+                FWK_LOG_INFO("[C2C] Command failed in slave!");
                 return FWK_E_STATE;
             }
             n1sdp_c2c_ctx.slave_ddr_size_gb = n1sdp_c2c_ctx.master_rx_data[1];
             FWK_LOG_INFO(
-                n1sdp_c2c_ctx.log_api,
-                "[C2C] Slave DDR Size: %d GB\n",
-                n1sdp_c2c_ctx.slave_ddr_size_gb);
+                "[C2C] Slave DDR Size: %d GB", n1sdp_c2c_ctx.slave_ddr_size_gb);
         }
         break;
 
@@ -486,7 +465,7 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
         status = n1sdp_c2c_ctx.tsync_api->master_sync(
             FWK_ID_ELEMENT(FWK_MODULE_IDX_N1SDP_TIMER_SYNC, 0));
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "Error!\n");
+            FWK_LOG_INFO("[C2C] Error!");
             return status;
         }
         if (run_in_slave) {
@@ -494,15 +473,14 @@ static int n1sdp_c2c_multichip_run_command(uint8_t cmd, bool run_in_slave)
             if (status != FWK_SUCCESS)
                 return status;
             if (n1sdp_c2c_ctx.master_rx_data[0] != N1SDP_C2C_SUCCESS) {
-                FWK_LOG_INFO(
-                    n1sdp_c2c_ctx.log_api, "[C2C] Command failed in slave!\n");
+                FWK_LOG_INFO("[C2C] Command failed in slave!");
                 return FWK_E_STATE;
             }
         }
         break;
 
     default:
-        FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "[C2C] Unsupported command\n");
+        FWK_LOG_INFO("[C2C] Unsupported command");
         return FWK_E_DEVICE;
     }
 
@@ -592,8 +570,7 @@ static int n1sdp_c2c_wait_for_next_command(void)
                                            &n1sdp_c2c_ctx.slave_rx_data[0],
                                            N1SDP_C2C_DATA_SIZE);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(
-            n1sdp_c2c_ctx.log_api, "[C2C] Error setting up read transfer!\n");
+        FWK_LOG_INFO("[C2C] Error setting up read transfer!");
         return status;
     }
 
@@ -810,25 +787,21 @@ static int n1sdp_c2c_process_command(void)
          */
         switch (rx_data[1]) {
         case MOD_PD_SYSTEM_SHUTDOWN:
-            FWK_LOG_INFO(
-                n1sdp_c2c_ctx.log_api,
-                "[C2C] Request PCC for system shutdown\n");
+            FWK_LOG_INFO("[C2C] Request PCC for system shutdown");
             status = n1sdp_c2c_ctx.scp2pcc_api->send(NULL, 0,
                                                      SCP2PCC_TYPE_SHUTDOWN);
             fwk_assert(status == FWK_SUCCESS);
             break;
 
         case MOD_PD_SYSTEM_COLD_RESET:
-            FWK_LOG_INFO(
-                n1sdp_c2c_ctx.log_api, "[C2C] Request PCC for system reboot\n");
+            FWK_LOG_INFO("[C2C] Request PCC for system reboot");
             status = n1sdp_c2c_ctx.scp2pcc_api->send(NULL, 0,
                                                      SCP2PCC_TYPE_REBOOT);
             fwk_assert(status == FWK_SUCCESS);
             break;
 
         default:
-            FWK_LOG_INFO(
-                n1sdp_c2c_ctx.log_api, "[C2C] Unknown shutdown command!\n");
+            FWK_LOG_INFO("[C2C] Unknown shutdown command!");
             status = FWK_E_PARAM;
             break;
         }
@@ -836,8 +809,7 @@ static int n1sdp_c2c_process_command(void)
         break;
 
     default:
-        FWK_LOG_INFO(
-            n1sdp_c2c_ctx.log_api, "[C2C] Unsupported command %d\n", cmd);
+        FWK_LOG_INFO("[C2C] Unsupported command %d", cmd);
         status = FWK_E_SUPPORT;
     }
 
@@ -851,8 +823,7 @@ error:
         n1sdp_c2c_ctx.config->i2c_id,
         &n1sdp_c2c_ctx.slave_tx_data[0], N1SDP_C2C_DATA_SIZE);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(
-            n1sdp_c2c_ctx.log_api, "[C2C] Error setting up write transfer!\n");
+        FWK_LOG_INFO("[C2C] Error setting up write transfer!");
         return status;
     }
 
@@ -920,7 +891,7 @@ static int n1sdp_c2c_pd_set_state(enum n1sdp_c2c_cmd cmd, uint8_t pd_id,
         return status;
 
     if (n1sdp_c2c_ctx.master_rx_data[0] != N1SDP_C2C_SUCCESS) {
-        FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "[C2C] PD request failed!\n");
+        FWK_LOG_INFO("[C2C] PD request failed!");
         return FWK_E_STATE;
     }
 
@@ -963,7 +934,7 @@ static int n1sdp_c2c_pd_get_state(enum n1sdp_c2c_cmd cmd, uint8_t pd_id,
      * master_rx_data[1] contains the current PD state in target
      */
     if (n1sdp_c2c_ctx.master_rx_data[0] != N1SDP_C2C_SUCCESS) {
-        FWK_LOG_INFO(n1sdp_c2c_ctx.log_api, "[C2C] PD request failed!\n");
+        FWK_LOG_INFO("[C2C] PD request failed!");
         return FWK_E_STATE;
     }
 
@@ -1022,11 +993,6 @@ static int n1sdp_c2c_bind(fwk_id_t id, unsigned int round)
         return FWK_SUCCESS;
 
     if (round == 0) {
-        status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                                 MOD_LOG_API_ID, &n1sdp_c2c_ctx.log_api);
-        if (status != FWK_SUCCESS)
-            return status;
-
         status = fwk_module_bind(n1sdp_c2c_ctx.config->ccix_id,
                                  FWK_ID_API(FWK_MODULE_IDX_N1SDP_PCIE,
                                             N1SDP_PCIE_API_IDX_PCIE_INIT),
diff --git a/product/n1sdp/module/n1sdp_ddr_phy/src/mod_n1sdp_ddr_phy.c b/product/n1sdp/module/n1sdp_ddr_phy/src/mod_n1sdp_ddr_phy.c
index bc5c3e13..7b82ede5 100644
--- a/product/n1sdp/module/n1sdp_ddr_phy/src/mod_n1sdp_ddr_phy.c
+++ b/product/n1sdp/module/n1sdp_ddr_phy/src/mod_n1sdp_ddr_phy.c
@@ -22,6 +22,7 @@
 #include <fwk_module_idx.h>
 #include <fwk_status.h>
 
+#include <inttypes.h>
 #include <stdbool.h>
 #include <string.h>
 
@@ -77,8 +78,6 @@ uint32_t rd_data[DCI_FIFO_SIZE];
 uint8_t wrrd_passes[NUM_SLICES][NUM_BITS_PER_SLICE];
 uint16_t DEFAULT_DELAY = 0x240;
 
-static struct mod_log_api *log_api;
-
 /*
  * Functions fulfilling this module's interface
  */
@@ -96,9 +95,8 @@ static int n1sdp_ddr_phy_config(fwk_id_t element_id, struct dimm_info *info)
     ddr_phy = (struct mod_n1sdp_ddr_phy_reg *)element_config->ddr;
 
     FWK_LOG_INFO(
-        log_api,
-        "[DDR-PHY] Initializing PHY at 0x%x for %d MHz speed\n",
-        (uintptr_t)ddr_phy,
+        "[DDR-PHY] Initializing PHY at 0x%p for %" PRIu16 " MHz speed",
+        (const void *)ddr_phy,
         info->speed);
 
     switch (info->speed) {
@@ -112,7 +110,7 @@ static int n1sdp_ddr_phy_config(fwk_id_t element_id, struct dimm_info *info)
         ddr_phy_config_800(ddr_phy, info);
         break;
     default:
-        FWK_LOG_INFO(log_api, "[DDR-PHY] Unsupported frequency!\n");
+        FWK_LOG_INFO("[DDR-PHY] Unsupported frequency!");
         break;
     }
 
@@ -225,7 +223,7 @@ uint32_t dci_write_dram(struct mod_dmc620_reg *dmc, uint32_t *scp_address,
 
     // Confirm that DMC is in config state
     if ((dmc->MEMC_STATUS & 0x7) != 0x0) {
-        FWK_LOG_INFO(log_api, "DMC needs to be in config state\n");
+        FWK_LOG_INFO("DMC needs to be in config state");
         return FWK_E_STATE;
     }
 
@@ -279,7 +277,7 @@ uint32_t dci_read_dram(struct mod_dmc620_reg *dmc, uint32_t *scp_address,
 
     // Confirm that DMC is in config state
     if ((dmc->MEMC_STATUS & 0x7) != 0x0) {
-        FWK_LOG_INFO(log_api, "DMC needs to be in config state\n");
+        FWK_LOG_INFO("DMC needs to be in config state");
         return FWK_E_PARAM;
     }
 
@@ -711,8 +709,7 @@ static int write_eye_detect(fwk_id_t element_id, struct dimm_info *info,
     int status = FWK_SUCCESS;
 
     if (((int)rank_sel > (info->number_of_ranks - 1)) && (rank_sel != 0xF)) {
-        FWK_LOG_INFO(
-            log_api, "[DDR-PHY] Invalid rank parameter %d\n", rank_sel);
+        FWK_LOG_INFO("[DDR-PHY] Invalid rank parameter %" PRIu32, rank_sel);
         return FWK_E_PARAM;
     }
 
@@ -729,9 +726,7 @@ static int write_eye_detect(fwk_id_t element_id, struct dimm_info *info,
             delay_increment, vrefdq_increment, dbg_level);
         if (status != FWK_SUCCESS) {
             FWK_LOG_INFO(
-                log_api,
-                "[DDR-PHY] WET single rank failed with error %d\n",
-                status);
+                "[DDR-PHY] WET single rank failed with error %d", status);
             break;
         }
     }
@@ -762,8 +757,7 @@ static int n1sdp_ddr_phy_post_training_configure(fwk_id_t element_id,
     phy_addr = (uint32_t)element_config->ddr;
     rddata_valid_value = 0;
 
-    FWK_LOG_INFO(
-        log_api, "[DDR-PHY] Post training PHY setting at 0x%x\n", phy_addr);
+    FWK_LOG_INFO("[DDR-PHY] Post training PHY setting at 0x%" PRIX32, phy_addr);
 
     for (i = 0; i < 9; i++)  {
         value = *(uint32_t *)(phy_addr + (4 * (112 + (i * 256))));
@@ -827,13 +821,13 @@ static int n1sdp_ddr_phy_post_training_configure(fwk_id_t element_id,
         adjust_per_rank_rptr_update_value(phy_addr, info);
 
     if (info->speed >= 1333) {
-        FWK_LOG_INFO(log_api, "[DDR-PHY] Performing write eye training...");
+        FWK_LOG_INFO("[DDR-PHY] Performing write eye training...");
         status = write_eye_detect(element_id, info, 0xF, 0x4, 0x2, 0);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(log_api, "FAIL!\n");
+            FWK_LOG_INFO("[DDR-PHY] FAIL!");
             return status;
         }
-        FWK_LOG_INFO(log_api, "PASS!\n");
+        FWK_LOG_INFO("[DDR-PHY] PASS!");
     }
 
     for (h = 0; h < info->number_of_ranks; h++) {
@@ -885,10 +879,9 @@ static int n1sdp_verify_phy_status(fwk_id_t element_id,
                 if (((value1 >> 16) >= 0x0200) ||
                     ((value2 & 0x0000FFFF) >= 0x200)) {
                     FWK_LOG_INFO(
-                        log_api,
-                        "[DDR-PHY] PHY 0x%08x : Invalid Hard0/Hard 1 value "
-                        "found "
-                        "for slice %d\n",
+                        "[DDR-PHY] PHY 0x%" PRIX32
+                        " : Invalid Hard0/Hard 1 "
+                        "value found for slice %" PRIu32,
                         phy_base,
                         i);
                 }
@@ -906,9 +899,9 @@ static int n1sdp_verify_phy_status(fwk_id_t element_id,
                 if ((value1 != 0x003C) &&
                     ((info->dimm_mem_width == 4) && (value1 != 0x13C))) {
                     FWK_LOG_INFO(
-                        log_api,
-                        "[DDR-PHY] PHY 0x%08x : Final read gate training "
-                        "status != 0x003C for slice %d\n",
+                        "[DDR-PHY] PHY 0x%" PRIX32
+                        " : Final read gate training"
+                        " status != 0x003C for slice %" PRIu32,
                         phy_base,
                         i);
                 }
@@ -933,18 +926,18 @@ static int n1sdp_verify_phy_status(fwk_id_t element_id,
                     value1 = *(uint32_t *)(phy_base + (4 * (47 + (i * 256))));
                     if ((value1 & 0x0000FFFF) > 0x0180) {
                         FWK_LOG_INFO(
-                            log_api,
-                            "[DDR-PHY] PHY 0x%08x : slice %d "
-                            " phy_rdlvl_rddqs_dq_le_dly_obs_%d is > 0x180\n",
+                            "[DDR-PHY] PHY 0x%" PRIX32 " : slice %" PRIu32
+                            " phy_rdlvl_rddqs_dq_le_dly_obs_%" PRIu32
+                            " is > 0x180",
                             phy_base,
                             j,
                             i);
                     }
                     if ((value1 >> 16) > 0x0180) {
                         FWK_LOG_INFO(
-                            log_api,
-                            "[DDR-PHY] PHY 0x%08x : slice %d "
-                            "phy_rdlvl_rddqs_dq_te_dly_obs_%d is > 0x180\n",
+                            "[DDR-PHY] PHY 0x%" PRIX32 " : slice %" PRIu32
+                            " phy_rdlvl_rddqs_dq_te_dly_obs_%" PRIu32
+                            " is > 0x180",
                             phy_base,
                             j,
                             i);
@@ -952,10 +945,10 @@ static int n1sdp_verify_phy_status(fwk_id_t element_id,
                     value1 = *(uint32_t *)(phy_base + (4 * (49 + (i * 256))));
                     if ((value1 >> 16) != 0x0C00) {
                         FWK_LOG_INFO(
-                            log_api,
-                            "[DDR-PHY] PHY 0x%08x : Final read data eye "
+                            "[DDR-PHY] PHY 0x%" PRIX32
+                            " : Final read data eye "
                             "training "
-                            "status != 0x0C00 for slice %d\n",
+                            "status != 0x0C00 for slice %" PRIu32,
                             phy_base,
                             i);
                     }
@@ -1149,8 +1142,6 @@ static int n1sdp_ddr_phy_element_init(fwk_id_t element_id, unsigned int unused,
 
 static int n1sdp_ddr_phy_bind(fwk_id_t id, unsigned int round)
 {
-    int status;
-
     /* Skip the second round (rounds are zero-indexed) */
     if (round == 1)
         return FWK_SUCCESS;
@@ -1159,12 +1150,6 @@ static int n1sdp_ddr_phy_bind(fwk_id_t id, unsigned int round)
     if (fwk_module_is_valid_element_id(id))
         return FWK_SUCCESS;
 
-    /* Bind to the log module and get a pointer to its API */
-    status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG), MOD_LOG_API_ID,
-        &log_api);
-    if (status != FWK_SUCCESS)
-        return FWK_E_HANDLER;
-
     return FWK_SUCCESS;
 }
 
diff --git a/product/n1sdp/module/n1sdp_dmc620/src/dimm_spd.c b/product/n1sdp/module/n1sdp_dmc620/src/dimm_spd.c
index 5f98bb57..26577cdf 100644
--- a/product/n1sdp/module/n1sdp_dmc620/src/dimm_spd.c
+++ b/product/n1sdp/module/n1sdp_dmc620/src/dimm_spd.c
@@ -105,40 +105,33 @@ static int chk_ddr4_dimms(unsigned int speed,
     return FWK_SUCCESS;
 }
 
-static void dimm_device_data(uint8_t *spd_data,
-    struct mod_log_api *log_api, uint8_t dimm_id)
+static void dimm_device_data(uint8_t *spd_data, uint8_t dimm_id)
 {
     unsigned int i;
 
     if (spd_data[2] == 0x0C) {
-        FWK_LOG_INFO(log_api, "    DIMM %d information:\n", dimm_id);
+        FWK_LOG_INFO("    DIMM %d information:", dimm_id);
         FWK_LOG_INFO(
-            log_api,
-            "    Manufacturer ID = 0x%x 0x%x\n",
-            spd_data[320],
-            spd_data[321]);
-        FWK_LOG_INFO(log_api, "    Module part number = ");
+            "    Manufacturer ID = 0x%x 0x%x", spd_data[320], spd_data[321]);
+        FWK_LOG_INFO("    Module part number = ");
         for (i = 329; i <= 348; i++)
-            FWK_LOG_INFO(log_api, "%c", spd_data[i]);
-        FWK_LOG_INFO(log_api, "\n");
+            FWK_LOG_INFO("%c", spd_data[i]);
 
         FWK_LOG_INFO(
-            log_api,
-            "    Module serial number = 0x%x 0x%x 0x%x 0x%x\n",
+            "    Module serial number = 0x%x 0x%x 0x%x 0x%x",
             spd_data[325],
             spd_data[326],
             spd_data[327],
             spd_data[328]);
 
         FWK_LOG_INFO(
-            log_api,
-            "    Module manufacturing week %d%d year %d%d\n",
+            "    Module manufacturing week %d%d year %d%d",
             0xF & (spd_data[324] >> 4),
             0xF & spd_data[324],
             0xF & (spd_data[323] >> 4),
             0xF & spd_data[323]);
     } else {
-        FWK_LOG_INFO(log_api, "[DDR] ERROR! DDR4 SPD EEPROM Not Detected\n");
+        FWK_LOG_INFO("[DDR] ERROR! DDR4 SPD EEPROM Not Detected");
         fwk_assert(false);
     }
 }
@@ -462,12 +455,10 @@ int dimm_spd_init_check(struct mod_n1sdp_i2c_master_api_polled *i2c_api,
     return FWK_SUCCESS;
 }
 
-void dimm_spd_mem_info(struct mod_log_api *log_api)
+void dimm_spd_mem_info(void)
 {
-    fwk_assert(log_api != NULL);
-
-    dimm_device_data((uint8_t *)&ddr4_dimm0, log_api, 0);
-    dimm_device_data((uint8_t *)&ddr4_dimm1, log_api, 1);
+    dimm_device_data((uint8_t *)&ddr4_dimm0, 0);
+    dimm_device_data((uint8_t *)&ddr4_dimm1, 1);
 }
 
 int dimm_spd_address_control(uint32_t *temp_reg, struct dimm_info *ddr)
diff --git a/product/n1sdp/module/n1sdp_dmc620/src/dimm_spd.h b/product/n1sdp/module/n1sdp_dmc620/src/dimm_spd.h
index 85afa17c..c1e5449a 100644
--- a/product/n1sdp/module/n1sdp_dmc620/src/dimm_spd.h
+++ b/product/n1sdp/module/n1sdp_dmc620/src/dimm_spd.h
@@ -367,11 +367,9 @@ int dimm_spd_init_check(struct mod_n1sdp_i2c_master_api_polled *i2c_api,
 /*
  * Brief - Function to print the DIMM card information
  *
- * param - log_api - Pointer to log module APIs
- *
  * retval - NONE
  */
-void dimm_spd_mem_info(struct mod_log_api *log_api);
+void dimm_spd_mem_info(void);
 
 /*
  * Brief - Function to calculate DMC-620 ADDRESS_CONTROL register value
diff --git a/product/n1sdp/module/n1sdp_dmc620/src/mod_n1sdp_dmc620.c b/product/n1sdp/module/n1sdp_dmc620/src/mod_n1sdp_dmc620.c
index eab2157d..6c03bd95 100644
--- a/product/n1sdp/module/n1sdp_dmc620/src/mod_n1sdp_dmc620.c
+++ b/product/n1sdp/module/n1sdp_dmc620/src/mod_n1sdp_dmc620.c
@@ -28,13 +28,13 @@
 #include <fwk_notification.h>
 #include <fwk_status.h>
 
+#include <inttypes.h>
 #include <stdbool.h>
 #include <stddef.h>
 
 /* DMC-620 register specific definitions */
 #define DDR_TRAIN_TWO_RANKS          0
 
-static struct mod_log_api *log_api;
 static struct mod_dmc_ddr_phy_api *ddr_phy_api;
 static struct mod_timer_api *timer_api;
 static struct mod_n1sdp_i2c_master_api_polled *i2c_api;
@@ -53,8 +53,7 @@ void dmc620_abort_recover(struct mod_dmc620_reg *dmc)
     /* Make sure we don't run this from ABORT or RECOVERY states */
     if (current_state > 3) {
         FWK_LOG_INFO(
-            log_api,
-            "[DDR] DMC generated abortable error from abort/recovery state\n");
+            "[DDR] DMC generated abortable error from abort/recovery state");
         return;
     }
 
@@ -62,45 +61,43 @@ void dmc620_abort_recover(struct mod_dmc620_reg *dmc)
     dmc_abort = (uint32_t *)((uint32_t)dmc + 0x10000);
 
     /* Assert abort request */
-    FWK_LOG_INFO(log_api, "[DDR] Asserting abort request\n");
+    FWK_LOG_INFO("[DDR] Asserting abort request");
     *dmc_abort = 0x1;
 
     /* Wait for DMC to enter aborted state */
-    FWK_LOG_INFO(log_api, "[DDR] Waiting for DMC to enter abort state...");
+    FWK_LOG_INFO("[DDR] Waiting for DMC to enter abort state...");
     while ((dmc->MEMC_STATUS & 0x00000007) != 0x4)
         continue;
 
-    FWK_LOG_INFO(log_api, "DONE\n");
+    FWK_LOG_INFO("[DDR] DONE");
 
     /* Deassert abort request */
-    FWK_LOG_INFO(log_api, "[DDR] Deasserting abort request\n");
+    FWK_LOG_INFO("[DDR] Deasserting abort request");
     *dmc_abort = 0x0;
 
     /* Send ABORT_CLR command to change to recovery mode. */
-    FWK_LOG_INFO(log_api, "[DDR] Sending abort clear\n");
+    FWK_LOG_INFO("[DDR] Sending abort clear");
     dmc->MEMC_CMD = 0x00000006;
 
     /* Wait for state transition to complete */
-    FWK_LOG_INFO(log_api, "[DDR] Waiting for DMC state transition...");
+    FWK_LOG_INFO("[DDR] Waiting for DMC state transition...");
     while ((dmc->MEMC_STATUS & 0x00000007) != 0x5)
         continue;
 
-    FWK_LOG_INFO(log_api, "DONE\n");
+    FWK_LOG_INFO("[DDR] DONE");
 
     /* Go back to pre-error state */
-    FWK_LOG_INFO(
-        log_api, "[DDR] Initiating state transition back to normal world\n");
+    FWK_LOG_INFO("[DDR] Initiating state transition back to normal world");
     dmc->MEMC_CMD = current_state;
 
     /* Wait for state transition to complete */
-    FWK_LOG_INFO(log_api, "[DDR] Waiting for DMC state transition...");
+    FWK_LOG_INFO("[DDR] Waiting for DMC state transition...");
     while ((dmc->MEMC_STATUS & 0x00000007) != current_state)
         continue;
 
-    FWK_LOG_INFO(log_api, "DONE\n");
+    FWK_LOG_INFO("[DDR] DONE");
 
-    FWK_LOG_INFO(
-        log_api, "[DDR] Resuming operation in state %d\n", current_state);
+    FWK_LOG_INFO("[DDR] Resuming operation in state %" PRIu32, current_state);
 }
 
 void dmc620_handle_interrupt(int dmc_num)
@@ -118,98 +115,98 @@ void dmc620_handle_interrupt(int dmc_num)
 
 void dmc0_misc_oflow_handler(void)
 {
-    FWK_LOG_INFO(log_api, "[DDR] DMC0 MISC overflow interrupt!\n");
+    FWK_LOG_INFO("[DDR] DMC0 MISC overflow interrupt!");
     dmc620_handle_interrupt(0);
     fwk_interrupt_clear_pending(DMCS0_MISC_OFLOW_IRQ);
 }
 
 void dmc0_err_oflow_handler(void)
 {
-    FWK_LOG_INFO(log_api, "[DDR] DMC0 error overflow interrupt!\n");
+    FWK_LOG_INFO("[DDR] DMC0 error overflow interrupt!");
     dmc620_handle_interrupt(0);
     fwk_interrupt_clear_pending(DMCS0_ERR_OFLOW_IRQ);
 }
 
 void dmc0_ecc_err_handler(void)
 {
-    FWK_LOG_INFO(log_api, "[DDR] DMC0 ECC error interrupt!\n");
+    FWK_LOG_INFO("[DDR] DMC0 ECC error interrupt!");
     dmc620_handle_interrupt(0);
     fwk_interrupt_clear_pending(DMCS0_ECC_ERR_INT_IRQ);
 }
 
 void dmc0_misc_access_handler(void)
 {
-    FWK_LOG_INFO(log_api, "[DDR] DMC0 misc access interrupt!\n");
+    FWK_LOG_INFO("[DDR] DMC0 misc access interrupt!");
     dmc620_handle_interrupt(0);
     fwk_interrupt_clear_pending(DMCS0_MISC_ACCESS_INT_IRQ);
 }
 
 void dmc0_temp_event_handler(void)
 {
-    FWK_LOG_INFO(log_api, "[DDR] DMC0 temperature event interrupt!\n");
+    FWK_LOG_INFO("[DDR] DMC0 temperature event interrupt!");
     dmc620_handle_interrupt(0);
     fwk_interrupt_clear_pending(DMCS0_TEMPERATURE_EVENT_INT_IRQ);
 }
 
 void dmc0_failed_access_handler(void)
 {
-    FWK_LOG_INFO(log_api, "[DDR] DMC0 failed access interrupt!\n");
+    FWK_LOG_INFO("[DDR] DMC0 failed access interrupt!");
     dmc620_handle_interrupt(0);
     fwk_interrupt_clear_pending(DMCS0_FAILED_ACCESS_INT_IRQ);
 }
 
 void dmc0_mgr_handler(void)
 {
-    FWK_LOG_INFO(log_api, "[DDR] DMC0 mgr interrupt!\n");
+    FWK_LOG_INFO("[DDR] DMC0 mgr interrupt!");
     dmc620_handle_interrupt(0);
     fwk_interrupt_clear_pending(DMCS0_MGR_INT_IRQ);
 }
 
 void dmc1_misc_oflow_handler(void)
 {
-    FWK_LOG_INFO(log_api, "[DDR] DMC1 MISC overflow interrupt!\n");
+    FWK_LOG_INFO("[DDR] DMC1 MISC overflow interrupt!");
     dmc620_handle_interrupt(1);
     fwk_interrupt_clear_pending(DMCS1_MISC_OFLOW_IRQ);
 }
 
 void dmc1_err_oflow_handler(void)
 {
-    FWK_LOG_INFO(log_api, "[DDR] DMC1 error overflow interrupt!\n");
+    FWK_LOG_INFO("[DDR] DMC1 error overflow interrupt!");
     dmc620_handle_interrupt(1);
     fwk_interrupt_clear_pending(DMCS1_ERR_OFLOW_IRQ);
 }
 
 void dmc1_ecc_err_handler(void)
 {
-    FWK_LOG_INFO(log_api, "[DDR] DMC1 ECC error interrupt!\n");
+    FWK_LOG_INFO("[DDR] DMC1 ECC error interrupt!");
     dmc620_handle_interrupt(1);
     fwk_interrupt_clear_pending(DMCS1_ECC_ERR_INT_IRQ);
 }
 
 void dmc1_misc_access_handler(void)
 {
-    FWK_LOG_INFO(log_api, "[DDR] DMC1 misc access interrupt!\n");
+    FWK_LOG_INFO("[DDR] DMC1 misc access interrupt!");
     dmc620_handle_interrupt(1);
     fwk_interrupt_clear_pending(DMCS1_MISC_ACCESS_INT_IRQ);
 }
 
 void dmc1_temp_event_handler(void)
 {
-    FWK_LOG_INFO(log_api, "[DDR] DMC1 temperature event interrupt!\n");
+    FWK_LOG_INFO("[DDR] DMC1 temperature event interrupt!");
     dmc620_handle_interrupt(1);
     fwk_interrupt_clear_pending(DMCS1_TEMPERATURE_EVENT_INT_IRQ);
 }
 
 void dmc1_failed_access_handler(void)
 {
-    FWK_LOG_INFO(log_api, "[DDR] DMC1 failed access interrupt!\n");
+    FWK_LOG_INFO("[DDR] DMC1 failed access interrupt!");
     dmc620_handle_interrupt(1);
     fwk_interrupt_clear_pending(DMCS1_FAILED_ACCESS_INT_IRQ);
 }
 
 void dmc1_mgr_handler(void)
 {
-    FWK_LOG_INFO(log_api, "[DDR] DMC1 mgr interrupt!\n");
+    FWK_LOG_INFO("[DDR] DMC1 mgr interrupt!");
     dmc620_handle_interrupt(1);
     fwk_interrupt_clear_pending(DMCS1_MGR_INT_IRQ);
 }
@@ -219,7 +216,7 @@ static int dmc620_config_interrupt(fwk_id_t ddr_id)
     int id;
 
     id = fwk_id_get_element_idx(ddr_id);
-    FWK_LOG_INFO(log_api, "[DDR] Configuring interrupts for DMC%d\n", id);
+    FWK_LOG_INFO("[DDR] Configuring interrupts for DMC%d", id);
 
     if (id == 0) {
         fwk_interrupt_set_isr(DMCS0_MISC_OFLOW_IRQ, dmc0_misc_oflow_handler);
@@ -314,7 +311,7 @@ static int ddr_poll_training_status(struct mod_dmc620_reg *dmc)
                              dmc620_wait_condition,
                              &wait_data);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(log_api, "FAIL\n");
+        FWK_LOG_INFO("[DDR] FAIL");
         return status;
     }
 
@@ -324,11 +321,11 @@ static int ddr_poll_training_status(struct mod_dmc620_reg *dmc)
                              dmc620_wait_condition,
                              &wait_data);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(log_api, "FAIL\n");
+        FWK_LOG_INFO("[DDR] FAIL");
         return status;
     }
 
-    FWK_LOG_INFO(log_api, "PASS\n");
+    FWK_LOG_INFO("[DDR] PASS");
 
     return FWK_SUCCESS;
 }
@@ -353,10 +350,10 @@ static int ddr_training(struct mod_dmc620_reg *dmc,
     int j;
     int status;
 
-    FWK_LOG_INFO(log_api, "[DDR] Training DDR memories...\n");
+    FWK_LOG_INFO("[DDR] Training DDR memories...");
 
     for (i = 1; i <= ddr_info.number_of_ranks; i++) {
-        FWK_LOG_INFO(log_api, "[DDR] Write leveling rank %d... ", i);
+        FWK_LOG_INFO("[DDR] Write leveling rank %d... ", i);
 
         /* Clear interrupt status if any */
         if (dmc->INTERRUPT_STATUS != 0)
@@ -380,12 +377,12 @@ static int ddr_training(struct mod_dmc620_reg *dmc,
     }
     ddr_phy_api->verify_phy_status(ddr_id, DDR_ADDR_TRAIN_TYPE_WR_LVL, info);
 
-    FWK_LOG_INFO(log_api, "[DDR] Read gate training\n");
+    FWK_LOG_INFO("[DDR] Read gate training");
     /* Clear interrupt status if any */
     if (dmc->INTERRUPT_STATUS != 0)
         dmc->INTERRUPT_CLR = 0xFFFFFFFF;
 
-    FWK_LOG_INFO(log_api, "[DDR] A side...");
+    FWK_LOG_INFO("[DDR] A side...");
 
     /* Set read level control parameter */
     value = dmc->RDLVL_CONTROL_NEXT;
@@ -413,7 +410,7 @@ static int ddr_training(struct mod_dmc620_reg *dmc,
         dmc->INTERRUPT_CLR = 0xFFFFFFFF;
 
 #if DDR_TRAIN_TWO_RANKS
-    FWK_LOG_INFO(log_api, "[DDR] B side...");
+    FWK_LOG_INFO("[DDR] B side...");
 
     /* Set write leveling parameters */
     value = dmc->RDLVL_CONTROL_NEXT;
@@ -436,13 +433,13 @@ static int ddr_training(struct mod_dmc620_reg *dmc,
     for (j = 1; j <= ddr_info.number_of_ranks; j++)
         ddr_phy_api->read_gate_phy_obs_regs(ddr_id, j, info);
 
-    FWK_LOG_INFO(log_api, "[DDR] Read eye training\n");
+    FWK_LOG_INFO("[DDR] Read eye training");
 
     /* Clear interrupt status if any */
     if (dmc->INTERRUPT_STATUS != 0)
         dmc->INTERRUPT_CLR = 0xFFFFFFFF;
 
-    FWK_LOG_INFO(log_api, "[DDR] A side...");
+    FWK_LOG_INFO("[DDR] A side...");
 
     /* Set write leveling parameters */
     value = dmc->RDLVL_CONTROL_NEXT;
@@ -469,7 +466,7 @@ static int ddr_training(struct mod_dmc620_reg *dmc,
     if (dmc->INTERRUPT_STATUS != 0)
         dmc->INTERRUPT_CLR = 0xFFFFFFFF;
 
-    FWK_LOG_INFO(log_api, "[DDR] B side...");
+    FWK_LOG_INFO("[DDR] B side...");
 
     /* Set write leveling parameters */
     value = dmc->RDLVL_CONTROL_NEXT;
@@ -495,7 +492,7 @@ static int ddr_training(struct mod_dmc620_reg *dmc,
     if (dmc->INTERRUPT_STATUS != 0)
         dmc->INTERRUPT_CLR = 0xFFFFFFFF;
 
-    FWK_LOG_INFO(log_api, "[DDR] MC initiated update...");
+    FWK_LOG_INFO("[DDR] MC initiated update...");
 
     dmc->DIRECT_ADDR = 0;
     dmc->DIRECT_CMD  = ((ddr_info.ranks_to_train << 16) | 0x000A);
@@ -563,8 +560,7 @@ static void execute_ddr_cmd(struct mod_dmc620_reg *dmc,
     status = dmc620_poll_dmc_status(dmc);
     if (status != FWK_SUCCESS) {
         FWK_LOG_INFO(
-            log_api,
-            "[DDR] Execute command failed! ADDR: 0x%08x CMD: 0x%08x\n",
+            "[DDR] Execute command failed! ADDR: 0x%" PRIX32 " CMD: 0x%" PRIX32,
             addr,
             cmd);
     }
@@ -788,9 +784,7 @@ static int direct_ddr_cmd(struct mod_dmc620_reg *dmc)
     status = dimm_spd_t_wtr(&addr, &ddr_info);
     if (status != FWK_SUCCESS) {
         FWK_LOG_INFO(
-            log_api,
-            "[DDR] Error code %d getting t_WTR value from SPD\n",
-            status);
+            "[DDR] Error code %d getting t_WTR value from SPD", status);
         return status;
     }
     dmc->T_WTR_NEXT = addr;
@@ -820,19 +814,17 @@ static int dmc620_pre_init(void)
     int status;
 
     FWK_LOG_INFO(
-        log_api,
-        "[DDR] Starting DDR subsystem initialization at %d MHz\n",
+        "[DDR] Starting DDR subsystem initialization at %d MHz",
         ddr_info.speed);
 
-    FWK_LOG_INFO(log_api, "[DDR] Identifying connected DIMM cards...\n");
+    FWK_LOG_INFO("[DDR] Identifying connected DIMM cards...");
     status = dimm_spd_init_check(i2c_api, &ddr_info);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(
-            log_api, "[DDR] Error checking DIMM SPD data: %d\n", status);
+        FWK_LOG_INFO("[DDR] Error checking DIMM SPD data: %d", status);
         return status;
     }
 
-    dimm_spd_mem_info(log_api);
+    dimm_spd_mem_info();
 
     return FWK_SUCCESS;
 }
@@ -852,11 +844,11 @@ static int dmc620_post_init(void)
         id = FWK_ID_ELEMENT(FWK_MODULE_IDX_N1SDP_DMC620, i);
         element_config = fwk_module_get_data(id);
 
-        FWK_LOG_INFO(log_api, "[DDR] Verifying PHY status for DMC %d...", i);
+        FWK_LOG_INFO("[DDR] Verifying PHY status for DMC %d...", i);
         status = dmc620_verify_phy_status(element_config->ddr_id);
         if (status != FWK_SUCCESS)
             return status;
-        FWK_LOG_INFO(log_api, "Done\n");
+        FWK_LOG_INFO("[DDR] Done");
     }
 
     for (i = 0; i < count; i++) {
@@ -882,19 +874,17 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
             return status;
     }
 
-    FWK_LOG_INFO(
-        log_api, "[DDR] Initialising DMC620 at 0x%x\n", (uintptr_t)dmc);
+    FWK_LOG_INFO("[DDR] Initialising DMC620 at 0x%x", (uintptr_t)dmc);
 
     dmc620_config_interrupt(ddr_id);
 
-    FWK_LOG_INFO(log_api, "[DDR] Writing functional settings\n");
+    FWK_LOG_INFO("[DDR] Writing functional settings");
 
     value = 0;
     status = dimm_spd_address_control(&value, &ddr_info);
     if (status != FWK_SUCCESS) {
         FWK_LOG_INFO(
-            log_api,
-            "[DDR] Error code %d getting address control value from SPD\n",
+            "[DDR] Error code %d getting address control value from SPD",
             status);
         return status;
     }
@@ -905,8 +895,7 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
     status = dimm_spd_format_control(&value);
     if (status != FWK_SUCCESS) {
         FWK_LOG_INFO(
-            log_api,
-            "[DDR] Error code %d getting format control value from SPD\n",
+            "[DDR] Error code %d getting format control value from SPD",
             status);
         return status;
     }
@@ -937,9 +926,7 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
     status = dimm_spd_memory_type(&value, &ddr_info);
     if (status != FWK_SUCCESS) {
         FWK_LOG_INFO(
-            log_api,
-            "[DDR] Error code %d getting memory type value from SPD\n",
-            status);
+            "[DDR] Error code %d getting memory type value from SPD", status);
         return status;
     }
     dmc->MEMORY_TYPE_NEXT = value;
@@ -949,9 +936,7 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
     status = dimm_spd_t_refi(&value);
     if (status != FWK_SUCCESS) {
         FWK_LOG_INFO(
-            log_api,
-            "[DDR] Error code %d getting t_REFI value from SPD\n",
-            status);
+            "[DDR] Error code %d getting t_REFI value from SPD", status);
         return status;
     }
     dmc->T_REFI_NEXT = value;
@@ -960,9 +945,7 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
     status = dimm_spd_t_rfc(&value);
     if (status != FWK_SUCCESS) {
         FWK_LOG_INFO(
-            log_api,
-            "[DDR] Error code %d getting t_RFC value from SPD\n",
-            status);
+            "[DDR] Error code %d getting t_RFC value from SPD", status);
         return status;
     }
     dmc->T_RFC_NEXT = value;
@@ -973,9 +956,7 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
     status = dimm_spd_t_rcd(&value);
     if (status != FWK_SUCCESS) {
         FWK_LOG_INFO(
-            log_api,
-            "[DDR] Error code %d getting t_RCD value from SPD\n",
-            status);
+            "[DDR] Error code %d getting t_RCD value from SPD", status);
         return status;
     }
     dmc->T_RCD_NEXT = value;
@@ -984,9 +965,7 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
     status = dimm_spd_t_ras(&value);
     if (status != FWK_SUCCESS) {
         FWK_LOG_INFO(
-            log_api,
-            "[DDR] Error code %d getting t_RAS value from SPD\n",
-            status);
+            "[DDR] Error code %d getting t_RAS value from SPD", status);
         return status;
     }
     dmc->T_RAS_NEXT = value;
@@ -994,10 +973,7 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
     value = 0;
     status = dimm_spd_t_rp(&value);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(
-            log_api,
-            "[DDR] Error code %d getting t_RP value from SPD\n",
-            status);
+        FWK_LOG_INFO("[DDR] Error code %d getting t_RP value from SPD", status);
         return status;
     }
     dmc->T_RP_NEXT = value;
@@ -1007,9 +983,7 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
     status = dimm_spd_t_rrd(&value);
     if (status != FWK_SUCCESS) {
         FWK_LOG_INFO(
-            log_api,
-            "[DDR] Error code %d getting t_RRD value from SPD\n",
-            status);
+            "[DDR] Error code %d getting t_RRD value from SPD", status);
         return status;
     }
     dmc->T_RRD_NEXT = value;
@@ -1018,9 +992,7 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
     status = dimm_spd_t_act_window(&value);
     if (status != FWK_SUCCESS) {
         FWK_LOG_INFO(
-            log_api,
-            "[DDR] Error code %d getting t_ACT_WINDOW value from SPD\n",
-            status);
+            "[DDR] Error code %d getting t_ACT_WINDOW value from SPD", status);
         return status;
     }
     dmc->T_ACT_WINDOW_NEXT = value;
@@ -1153,7 +1125,7 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
            MOD_DMC620_MEMC_CMD_CONFIG)
         continue;
 
-    FWK_LOG_INFO(log_api, "[DDR] Sending direct DDR commands\n");
+    FWK_LOG_INFO("[DDR] Sending direct DDR commands");
 
     status = direct_ddr_cmd(dmc);
     if (status != FWK_SUCCESS)
@@ -1167,20 +1139,20 @@ static int dmc620_config(struct mod_dmc620_reg *dmc, fwk_id_t ddr_id)
     if (status != FWK_SUCCESS)
         return status;
 
-    FWK_LOG_INFO(log_api, "[DDR] Enable DIMM refresh...");
+    FWK_LOG_INFO("[DDR] Enable DIMM refresh...");
     status = enable_dimm_refresh(dmc);
     if (status != FWK_SUCCESS)
         return status;
 
     /* Switch to READY */
-    FWK_LOG_INFO(log_api, "[DDR] Setting DMC to READY mode\n");
+    FWK_LOG_INFO("[DDR] Setting DMC to READY mode");
 
     dmc->MEMC_CMD = MOD_DMC620_MEMC_CMD_GO;
 
     while ((dmc->MEMC_STATUS & MOD_DMC620_MEMC_CMD) != MOD_DMC620_MEMC_CMD_GO)
         continue;
 
-    FWK_LOG_INFO(log_api, "[DDR] DMC init done.\n");
+    FWK_LOG_INFO("[DDR] DMC init done.");
 
     if (dmc_id == 1) {
         status = dmc620_post_init();
@@ -1249,11 +1221,6 @@ static int mod_dmc620_bind(fwk_id_t id, unsigned int round)
     module_config = fwk_module_get_data(fwk_module_id_n1sdp_dmc620);
     fwk_assert(module_config != NULL);
 
-    status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                             MOD_LOG_API_ID, &log_api);
-    if (status != FWK_SUCCESS)
-        return status;
-
     status = fwk_module_bind(module_config->ddr_module_id,
                              module_config->ddr_api_id, &ddr_phy_api);
     if (status != FWK_SUCCESS)
diff --git a/product/n1sdp/module/n1sdp_i2c/src/mod_n1sdp_i2c.c b/product/n1sdp/module/n1sdp_i2c/src/mod_n1sdp_i2c.c
index 91f37d35..43ec75f8 100644
--- a/product/n1sdp/module/n1sdp_i2c/src/mod_n1sdp_i2c.c
+++ b/product/n1sdp/module/n1sdp_i2c/src/mod_n1sdp_i2c.c
@@ -18,7 +18,6 @@
 #include <fwk_event.h>
 #include <fwk_id.h>
 #include <fwk_interrupt.h>
-#include <fwk_log.h>
 #include <fwk_mm.h>
 #include <fwk_module.h>
 #include <fwk_module_idx.h>
@@ -82,9 +81,6 @@ struct n1sdp_i2c_dev_ctx {
 struct n1sdp_i2c_ctx {
     /* Table of device contexts */
     struct n1sdp_i2c_dev_ctx *device_ctx_table;
-
-    /* Log API pointer */
-    const struct mod_log_api *log_api;
 };
 
 static struct n1sdp_i2c_ctx i2c_ctx;
@@ -560,15 +556,6 @@ static int n1sdp_i2c_element_init(fwk_id_t element_id, unsigned int unused,
     return FWK_SUCCESS;
 }
 
-static int n1sdp_i2c_bind(fwk_id_t id, unsigned int round)
-{
-    if ((round == 0) && (fwk_id_get_type(id) == FWK_ID_TYPE_MODULE)) {
-        return fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-            MOD_LOG_API_ID, &i2c_ctx.log_api);
-    }
-    return FWK_SUCCESS;
-}
-
 static int n1sdp_i2c_process_bind_request(fwk_id_t requester_id,
     fwk_id_t target_id, fwk_id_t api_id, const void **api)
 {
@@ -632,7 +619,6 @@ const struct fwk_module module_n1sdp_i2c = {
     .notification_count = MOD_N1SDP_I2C_NOTIFICATION_COUNT,
     .init = n1sdp_i2c_init,
     .element_init = n1sdp_i2c_element_init,
-    .bind = n1sdp_i2c_bind,
     .process_bind_request = n1sdp_i2c_process_bind_request,
     .start = n1sdp_i2c_start,
 };
diff --git a/product/n1sdp/module/n1sdp_mcp_system/src/mod_n1sdp_mcp_system.c b/product/n1sdp/module/n1sdp_mcp_system/src/mod_n1sdp_mcp_system.c
index f715bf15..34c1a24b 100644
--- a/product/n1sdp/module/n1sdp_mcp_system/src/mod_n1sdp_mcp_system.c
+++ b/product/n1sdp/module/n1sdp_mcp_system/src/mod_n1sdp_mcp_system.c
@@ -24,14 +24,11 @@
 #include <fwk_status.h>
 #include <fwk_thread.h>
 
+#include <inttypes.h>
 #include <stdint.h>
 
 /* Module context */
 struct n1sdp_mcp_system_ctx {
-
-    /* Log API pointer */
-    const struct mod_log_api *log_api;
-
     /* SCMI agent API pointer */
     const struct mod_scmi_agent_api *scmi_api;
 
@@ -60,12 +57,6 @@ static int n1sdp_mcp_system_bind(fwk_id_t id, unsigned int round)
     int status;
 
     if (round == 0) {
-        status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                                 FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-                                 &n1sdp_mcp_system_ctx.log_api);
-        if (status != FWK_SUCCESS)
-            return status;
-
         status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_SCMI_AGENT),
                                  FWK_ID_API(FWK_MODULE_IDX_SCMI_AGENT, 0),
                                  &n1sdp_mcp_system_ctx.scmi_api);
@@ -115,10 +106,7 @@ static int n1sdp_mcp_system_process_event(const struct fwk_event *event,
     if (status != FWK_SUCCESS)
         return status;
 
-    FWK_LOG_TRACE(
-        n1sdp_mcp_system_ctx.log_api,
-        "[MCP SYSTEM] SCP clock status: 0x%x\n",
-        clock_status);
+    FWK_LOG_INFO("[MCP SYSTEM] SCP clock status: 0x%" PRIu32, clock_status);
 
     status = n1sdp_mcp_system_ctx.pik_coreclk_api->process_power_transition(
                  FWK_ID_ELEMENT(FWK_MODULE_IDX_PIK_CLOCK,
@@ -134,9 +122,7 @@ static int n1sdp_mcp_system_process_event(const struct fwk_event *event,
     if (status != FWK_SUCCESS)
         return FWK_SUCCESS;
 
-    FWK_LOG_TRACE(
-        n1sdp_mcp_system_ctx.log_api,
-        "[MCP SYSTEM] MCP PIK clocks configured\n");
+    FWK_LOG_INFO("[MCP SYSTEM] MCP PIK clocks configured");
 
     status = n1sdp_mcp_system_ctx.scmi_api->get_chipid_info(
                  FWK_ID_ELEMENT(FWK_MODULE_IDX_SCMI_AGENT, 0),
@@ -144,11 +130,7 @@ static int n1sdp_mcp_system_process_event(const struct fwk_event *event,
     if (status != FWK_SUCCESS)
         return status;
 
-    FWK_LOG_TRACE(
-        n1sdp_mcp_system_ctx.log_api,
-        "[MCP SYSTEM] MC Mode: 0x%x CHIPID: 0x%x\n",
-        mc_mode,
-        chipid);
+    FWK_LOG_INFO("[MCP SYSTEM] MC Mode: 0x%x CHIPID: 0x%x", mc_mode, chipid);
 
     return status;
 }
diff --git a/product/n1sdp/module/n1sdp_pcie/src/mod_n1sdp_pcie.c b/product/n1sdp/module/n1sdp_pcie/src/mod_n1sdp_pcie.c
index 816f8e8c..845737aa 100644
--- a/product/n1sdp/module/n1sdp_pcie/src/mod_n1sdp_pcie.c
+++ b/product/n1sdp/module/n1sdp_pcie/src/mod_n1sdp_pcie.c
@@ -29,6 +29,7 @@
 #include <fwk_notification.h>
 #include <fwk_status.h>
 
+#include <inttypes.h>
 #include <string.h>
 
 void pcie_bus_enumeration(struct n1sdp_pcie_dev_config *config);
@@ -82,9 +83,6 @@ struct n1sdp_pcie_dev_ctx {
  * Module context
  */
 struct n1sdp_pcie_ctx {
-    /* Log module API */
-    struct mod_log_api *log_api;
-
     /* Timer module API */
     struct mod_timer_api *timer_api;
 
@@ -130,7 +128,7 @@ static int n1sdp_pcie_ccix_enable_opt_tlp(bool enable)
     else
         value = (CCIX_CTRL_CAW | CCIX_VENDER_ID);
 
-    FWK_LOG_INFO(pcie_ctx.log_api, "[CCIX] CCIX_CONTROL: 0x%08x\n", value);
+    FWK_LOG_INFO("[CCIX] CCIX_CONTROL: 0x%" PRIX32, value);
 
     *(uint32_t *)(dev_ctx->lm_apb + PCIE_LM_RC_CCIX_CTRL_REG) = value;
 
@@ -159,8 +157,7 @@ static int n1sdp_pcie_power_on(fwk_id_t id)
     if (dev_ctx == NULL)
         return FWK_E_PARAM;
 
-    FWK_LOG_INFO(
-        pcie_ctx.log_api, "[%s] Powering ON controller...", pcie_type[did]);
+    FWK_LOG_INFO("[%s] Powering ON controller...", pcie_type[did]);
     wait_data.ctrl_apb = NULL;
     if (dev_ctx->config->ccix_capable) {
         SCC->AXI_OVRD_CCIX = AXI_OVRD_VAL_CCIX;
@@ -172,7 +169,7 @@ static int n1sdp_pcie_power_on(fwk_id_t id)
                                           pcie_wait_condition,
                                           &wait_data);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(pcie_ctx.log_api, "Timeout!\n");
+            FWK_LOG_INFO("[%s] Timeout!", pcie_type[did]);
             return status;
         }
         SCC->SYS_MAN_RESET &= ~(1 << SCC_SYS_MAN_RESET_CCIX_POS);
@@ -186,12 +183,12 @@ static int n1sdp_pcie_power_on(fwk_id_t id)
                                           pcie_wait_condition,
                                           &wait_data);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(pcie_ctx.log_api, "Timeout!\n");
+            FWK_LOG_INFO("[%s] Timeout!", pcie_type[did]);
             return status;
         }
         SCC->SYS_MAN_RESET &= ~(1 << SCC_SYS_MAN_RESET_PCIE_POS);
     }
-    FWK_LOG_INFO(pcie_ctx.log_api, "Done\n");
+    FWK_LOG_INFO("[%s] Done", pcie_type[did]);
 
     return FWK_SUCCESS;
 }
@@ -210,7 +207,7 @@ static int n1sdp_pcie_phy_init(fwk_id_t id)
 
     gen_speed = dev_ctx->config->ccix_capable ? PCIE_GEN_4 : PCIE_GEN_3;
 
-    FWK_LOG_INFO(pcie_ctx.log_api, "[%s] Initializing PHY...", pcie_type[did]);
+    FWK_LOG_INFO("[%s] Initializing PHY...", pcie_type[did]);
 
     pcie_phy_init(dev_ctx->phy_apb);
     status = pcie_init(dev_ctx->ctrl_apb,
@@ -218,10 +215,10 @@ static int n1sdp_pcie_phy_init(fwk_id_t id)
                        PCIE_INIT_STAGE_PHY,
                        gen_speed);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(pcie_ctx.log_api, "Timeout!\n");
+        FWK_LOG_INFO("[%s] Timeout!", pcie_type[did]);
         return status;
     }
-    FWK_LOG_INFO(pcie_ctx.log_api, "Done\n");
+    FWK_LOG_INFO("[%s] Done", pcie_type[did]);
 
     return FWK_SUCCESS;
 }
@@ -246,7 +243,6 @@ static int n1sdp_pcie_controller_init(fwk_id_t id, bool ep_mode)
     }
 
     FWK_LOG_INFO(
-        pcie_ctx.log_api,
         "[%s] Initializing controller in %s mode...",
         pcie_type[did],
         (ep_mode ? "endpoint" : "root port"));
@@ -255,10 +251,10 @@ static int n1sdp_pcie_controller_init(fwk_id_t id, bool ep_mode)
                        PCIE_INIT_STAGE_CTRL,
                        gen_speed);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(pcie_ctx.log_api, "Timeout!\n");
+        FWK_LOG_INFO("[%s] Timeout!", pcie_type[did]);
         return status;
     }
-    FWK_LOG_INFO(pcie_ctx.log_api, "Done\n");
+    FWK_LOG_INFO("[%s] Done", pcie_type[did]);
 
     return FWK_SUCCESS;
 }
@@ -281,7 +277,6 @@ static int n1sdp_pcie_link_training(fwk_id_t id, bool ep_mode)
 
     if (gen_speed >= PCIE_GEN_3 && !ep_mode) {
         FWK_LOG_INFO(
-            pcie_ctx.log_api,
             "[%s] Setting TX Preset for GEN%d...",
             pcie_type[did],
             gen_speed + 1);
@@ -289,48 +284,40 @@ static int n1sdp_pcie_link_training(fwk_id_t id, bool ep_mode)
                                         TX_PRESET_VALUE,
                                         gen_speed);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(pcie_ctx.log_api, "Error!\n");
+            FWK_LOG_INFO("[%s] Error!", pcie_type[did]);
             return status;
         }
-        FWK_LOG_INFO(pcie_ctx.log_api, "Done\n");
+        FWK_LOG_INFO("[%s] Done", pcie_type[did]);
     }
 
     /* Link training */
-    FWK_LOG_INFO(
-        pcie_ctx.log_api, "[%s] Starting link training...", pcie_type[did]);
+    FWK_LOG_INFO("[%s] Starting link training...", pcie_type[did]);
     status = pcie_init(dev_ctx->ctrl_apb,
                        pcie_ctx.timer_api,
                        PCIE_INIT_STAGE_LINK_TRNG,
                        gen_speed);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(pcie_ctx.log_api, "Timeout!\n");
+        FWK_LOG_INFO("[%s] Timeout!", pcie_type[did]);
         pcie_init_bdf_table(dev_ctx->config);
         return status;
     }
-    FWK_LOG_INFO(pcie_ctx.log_api, "Done\n");
+    FWK_LOG_INFO("[%s] Done", pcie_type[did]);
 
     neg_config = (dev_ctx->ctrl_apb->RP_CONFIG_OUT &
         RP_CONFIG_OUT_NEGOTIATED_SPD_MASK) >> RP_CONFIG_OUT_NEGOTIATED_SPD_POS;
     FWK_LOG_INFO(
-        pcie_ctx.log_api,
-        "[%s] Negotiated speed: GEN%d\n",
-        pcie_type[did],
-        neg_config + 1);
+        "[%s] Negotiated speed: GEN%d", pcie_type[did], neg_config + 1);
 
     neg_config = (dev_ctx->ctrl_apb->RP_CONFIG_OUT &
         RP_CONFIG_OUT_NEGOTIATED_LINK_WIDTH_MASK) >>
         RP_CONFIG_OUT_NEGOTIATED_LINK_WIDTH_POS;
     FWK_LOG_INFO(
-        pcie_ctx.log_api,
-        "[%s] Negotiated link width: x%d\n",
+        "[%s] Negotiated link width: x%d",
         pcie_type[did],
         fwk_math_pow2(neg_config));
 
     if (gen_speed == PCIE_GEN_4) {
-        FWK_LOG_INFO(
-            pcie_ctx.log_api,
-            "[%s] Re-training link to GEN4 speed...",
-            pcie_type[did]);
+        FWK_LOG_INFO("[%s] Re-training link to GEN4 speed...", pcie_type[did]);
         /* Set GEN4 as target speed */
         pcie_rp_ep_config_read_word(dev_ctx->rp_ep_config_apb,
                                     PCIE_LINK_CTRL_STATUS_2_OFFSET, &reg_val);
@@ -344,28 +331,22 @@ static int n1sdp_pcie_link_training(fwk_id_t id, bool ep_mode)
                                    dev_ctx->rp_ep_config_apb,
                                    pcie_ctx.timer_api);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(pcie_ctx.log_api, "TIMEOUT\n");
+            FWK_LOG_INFO("[%s] TIMEOUT", pcie_type[did]);
             return FWK_SUCCESS;
         }
-        FWK_LOG_INFO(pcie_ctx.log_api, "Done\n");
+        FWK_LOG_INFO("[%s] Done", pcie_type[did]);
 
         pcie_rp_ep_config_read_word(dev_ctx->rp_ep_config_apb,
                                     PCIE_LINK_CTRL_STATUS_OFFSET, &reg_val);
         neg_config = (reg_val >> PCIE_LINK_CTRL_NEG_SPEED_POS) &
                      PCIE_LINK_CTRL_NEG_SPEED_MASK;
         FWK_LOG_INFO(
-            pcie_ctx.log_api,
-            "[%s] Re-negotiated speed: GEN%d\n",
-            pcie_type[did],
-            neg_config);
+            "[%s] Re-negotiated speed: GEN%d", pcie_type[did], neg_config);
 
         neg_config = (reg_val >> PCIE_LINK_CTRL_NEG_WIDTH_POS) &
                      PCIE_LINK_CTRL_NEG_WIDTH_MASK;
         FWK_LOG_INFO(
-            pcie_ctx.log_api,
-            "[%s] Re-negotiated link width: x%d\n",
-            pcie_type[did],
-            neg_config);
+            "[%s] Re-negotiated link width: x%d", pcie_type[did], neg_config);
     }
 
     return FWK_SUCCESS;
@@ -383,8 +364,7 @@ static int n1sdp_pcie_rc_setup(fwk_id_t id)
     if (dev_ctx == NULL)
         return FWK_E_PARAM;
 
-    FWK_LOG_INFO(
-        pcie_ctx.log_api, "[%s] Setup Type0 configuration...", pcie_type[did]);
+    FWK_LOG_INFO("[%s] Setup Type0 configuration...", pcie_type[did]);
     if (dev_ctx->config->ccix_capable)
         ecam_base_addr = dev_ctx->config->axi_slave_base32 +
                          CCIX_AXI_ECAM_TYPE0_OFFSET;
@@ -396,13 +376,12 @@ static int n1sdp_pcie_rc_setup(fwk_id_t id)
                  __builtin_ctz(AXI_ECAM_TYPE0_SIZE),
                  TRANS_TYPE_0_CFG);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(pcie_ctx.log_api, "Error!\n");
+        FWK_LOG_INFO("[%s] Error!", pcie_type[did]);
         return status;
     }
-    FWK_LOG_INFO(pcie_ctx.log_api, "Done\n");
+    FWK_LOG_INFO("[%s] Done", pcie_type[did]);
 
-    FWK_LOG_INFO(
-        pcie_ctx.log_api, "[%s] Setup Type1 configuration...", pcie_type[did]);
+    FWK_LOG_INFO("[%s] Setup Type1 configuration...", pcie_type[did]);
     if (dev_ctx->config->ccix_capable)
         ecam_base_addr = dev_ctx->config->axi_slave_base32 +
                          CCIX_AXI_ECAM_TYPE1_OFFSET;
@@ -414,13 +393,12 @@ static int n1sdp_pcie_rc_setup(fwk_id_t id)
                  __builtin_ctz(AXI_ECAM_TYPE1_SIZE),
                  TRANS_TYPE_1_CFG);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(pcie_ctx.log_api, "Error!\n");
+        FWK_LOG_INFO("[%s] Error!", pcie_type[did]);
         return status;
     }
-    FWK_LOG_INFO(pcie_ctx.log_api, "Done\n");
+    FWK_LOG_INFO("[%s] Done", pcie_type[did]);
 
-    FWK_LOG_INFO(
-        pcie_ctx.log_api, "[%s] Setup MMIO32 configuration...", pcie_type[did]);
+    FWK_LOG_INFO("[%s] Setup MMIO32 configuration...", pcie_type[did]);
     if (dev_ctx->config->ccix_capable)
         ecam_base_addr = dev_ctx->config->axi_slave_base32 +
                              CCIX_AXI_MMIO32_OFFSET;
@@ -432,13 +410,12 @@ static int n1sdp_pcie_rc_setup(fwk_id_t id)
                  __builtin_ctz(AXI_MMIO32_SIZE),
                  TRANS_TYPE_MEM_IO);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(pcie_ctx.log_api, "Error!\n");
+        FWK_LOG_INFO("[%s] Error!", pcie_type[did]);
         return status;
     }
-    FWK_LOG_INFO(pcie_ctx.log_api, "Done\n");
+    FWK_LOG_INFO("[%s] Done", pcie_type[did]);
 
-    FWK_LOG_INFO(
-        pcie_ctx.log_api, "[%s] Setup IO configuration...", pcie_type[did]);
+    FWK_LOG_INFO("[%s] Setup IO configuration...", pcie_type[did]);
     if (dev_ctx->config->ccix_capable)
         ecam_base_addr = dev_ctx->config->axi_slave_base32 +
                              CCIX_AXI_IO_OFFSET;
@@ -450,72 +427,64 @@ static int n1sdp_pcie_rc_setup(fwk_id_t id)
                  __builtin_ctz(AXI_IO_SIZE),
                  TRANS_TYPE_IO);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(pcie_ctx.log_api, "Error!\n");
+        FWK_LOG_INFO("[%s] Error!", pcie_type[did]);
         return status;
     }
-    FWK_LOG_INFO(pcie_ctx.log_api, "Done\n");
+    FWK_LOG_INFO("[%s] Done", pcie_type[did]);
 
-    FWK_LOG_INFO(
-        pcie_ctx.log_api, "[%s] Setup MMIO64 configuration...", pcie_type[did]);
+    FWK_LOG_INFO("[CCIX] [%s] Setup MMIO64 configuration...", pcie_type[did]);
     status = axi_outbound_region_setup(dev_ctx->rc_axi_config_apb,
                  dev_ctx->config->axi_slave_base64,
                  __builtin_ctz(AXI_MMIO64_SIZE),
                  TRANS_TYPE_MEM_IO);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(pcie_ctx.log_api, "Error!\n");
+        FWK_LOG_INFO("[%s] Error!", pcie_type[did]);
         return status;
     }
-    FWK_LOG_INFO(pcie_ctx.log_api, "Done\n");
+    FWK_LOG_INFO("[%s] Done", pcie_type[did]);
 
-    FWK_LOG_INFO(
-        pcie_ctx.log_api, "[%s] Setup RP classcode...", pcie_type[did]);
+    FWK_LOG_INFO("[%s] Setup RP classcode...", pcie_type[did]);
     status = pcie_rp_ep_config_write_word(dev_ctx->rp_ep_config_apb,
                                           PCIE_CLASS_CODE_OFFSET,
                                           PCIE_CLASS_CODE_PCI_BRIDGE);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(pcie_ctx.log_api, "Error!\n");
+        FWK_LOG_INFO("Error!");
         return status;
     }
-    FWK_LOG_INFO(pcie_ctx.log_api, "Done\n");
+    FWK_LOG_INFO("Done");
 
     FWK_LOG_INFO(
-        pcie_ctx.log_api,
         "[%s] Enable inbound region in BAR 2...",
         pcie_type[did]);
     status = axi_inbound_region_setup(dev_ctx->rc_axi_config_apb,
                  AXI_IB_REGION_BASE,
                  AXI_IB_REGION_SIZE_MSB, 2);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(pcie_ctx.log_api, "Error!\n");
+        FWK_LOG_INFO("[%s] Error!", pcie_type[did]);
         return status;
     }
-    FWK_LOG_INFO(pcie_ctx.log_api, "Done\n");
+    FWK_LOG_INFO("[%s] Done", pcie_type[did]);
 
-    FWK_LOG_INFO(
-        pcie_ctx.log_api,
-        "[%s] Enable Type 1 I/O configuration\n",
-        pcie_type[did]);
+    FWK_LOG_INFO("[%s] Enable Type 1 I/O configuration", pcie_type[did]);
     *(uint32_t *)(dev_ctx->lm_apb + PCIE_LM_RC_BAR_CONFIG_REG) =
         (TYPE1_PREF_MEM_BAR_ENABLE_MASK |
          TYPE1_PREF_MEM_BAR_SIZE_64BIT_MASK |
          TYPE1_PREF_IO_BAR_ENABLE_MASK |
          TYPE1_PREF_IO_BAR_SIZE_32BIT_MASK);
 
-    FWK_LOG_INFO(
-        pcie_ctx.log_api, "[%s] Skipping ATS capability...", pcie_type[did]);
+    FWK_LOG_INFO("[%s] Skipping ATS capability...", pcie_type[did]);
     status = pcie_skip_ext_cap(dev_ctx->rp_ep_config_apb, EXT_CAP_ID_ATS);
     if (status != FWK_SUCCESS)
-        FWK_LOG_INFO(pcie_ctx.log_api, "Not found!\n");
+        FWK_LOG_INFO("[%s] Not found!", pcie_type[did]);
     else
-        FWK_LOG_INFO(pcie_ctx.log_api, "Done\n");
+        FWK_LOG_INFO("[%s] Done", pcie_type[did]);
 
-    FWK_LOG_INFO(
-        pcie_ctx.log_api, "[%s] Skipping PRI capability...", pcie_type[did]);
+    FWK_LOG_INFO("[%s] Skipping PRI capability...", pcie_type[did]);
     status = pcie_skip_ext_cap(dev_ctx->rp_ep_config_apb, EXT_CAP_ID_PRI);
     if (status != FWK_SUCCESS)
-        FWK_LOG_INFO(pcie_ctx.log_api, "Not found!\n");
+        FWK_LOG_INFO("[%s] Not found!", pcie_type[did]);
     else
-        FWK_LOG_INFO(pcie_ctx.log_api, "Done\n");
+        FWK_LOG_INFO("[%s] Done", pcie_type[did]);
 
     /*
      * Wait until devices connected in downstream ports
@@ -544,17 +513,15 @@ static int n1sdp_pcie_vc1_setup(fwk_id_t id, uint8_t vc1_tc)
 
     config_base_addr = dev_ctx->rp_ep_config_apb;
 
-    FWK_LOG_TRACE(
-        pcie_ctx.log_api,
-        "[CCIX] Enabling VC1 in RP 0x%08x...",
-        config_base_addr);
+    FWK_LOG_INFO(
+        "[CCIX] Enabling VC1 in RP 0x%" PRIX32 "...", config_base_addr);
 
     status = pcie_vc_setup(config_base_addr, vc1_tc);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_TRACE(pcie_ctx.log_api, "Error!\n");
+        FWK_LOG_ERR("[CCIX] Error!");
         return status;
     }
-    FWK_LOG_TRACE(pcie_ctx.log_api, "Done\n");
+    FWK_LOG_INFO("[CCIX] Done");
 
     /* Set max payload size to 512 */
     *(volatile uint32_t *)(config_base_addr + PCIE_DEV_CTRL_STATUS_OFFSET) |=
@@ -562,17 +529,15 @@ static int n1sdp_pcie_vc1_setup(fwk_id_t id, uint8_t vc1_tc)
 
     config_base_addr = dev_ctx->config->axi_slave_base32 + 0x100000;
 
-    FWK_LOG_TRACE(
-        pcie_ctx.log_api,
-        "[CCIX] Enabling VC1 in EP 0x%08x...",
-        config_base_addr);
+    FWK_LOG_INFO(
+        "[CCIX] Enabling VC1 in EP 0x%" PRIX32 "...", config_base_addr);
 
     status = pcie_vc_setup(config_base_addr, vc1_tc);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_TRACE(pcie_ctx.log_api, "Error!\n");
+        FWK_LOG_ERR("[CCIX] Error!");
         return status;
     }
-    FWK_LOG_TRACE(pcie_ctx.log_api, "Done\n");
+    FWK_LOG_INFO("[CCIX] Done");
 
     *(volatile uint32_t *)(config_base_addr + PCIE_DEV_CTRL_STATUS_OFFSET) |=
         (0x2 << PCIE_DEV_CTRL_MAX_PAYLOAD_SHIFT);
@@ -683,11 +648,6 @@ static int n1sdp_pcie_bind(fwk_id_t id, unsigned int round)
     int status;
 
     if (round == 0) {
-        status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-            FWK_ID_API(FWK_MODULE_IDX_LOG, 0), &pcie_ctx.log_api);
-        if (status != FWK_SUCCESS)
-            return status;
-
         status = fwk_module_bind(FWK_ID_ELEMENT(FWK_MODULE_IDX_TIMER, 0),
             FWK_ID_API(FWK_MODULE_IDX_TIMER, MOD_TIMER_API_IDX_TIMER),
             &pcie_ctx.timer_api);
diff --git a/product/n1sdp/module/n1sdp_remote_pd/src/mod_n1sdp_remote_pd.c b/product/n1sdp/module/n1sdp_remote_pd/src/mod_n1sdp_remote_pd.c
index 9f5bd422..6704b5cd 100644
--- a/product/n1sdp/module/n1sdp_remote_pd/src/mod_n1sdp_remote_pd.c
+++ b/product/n1sdp/module/n1sdp_remote_pd/src/mod_n1sdp_remote_pd.c
@@ -45,9 +45,6 @@ struct n1sdp_remote_pd_ctx {
     /* Total power domains */
     unsigned int pd_count;
 
-    /* Log API */
-    struct mod_log_api *log_api;
-
     /* C2C power domain API */
     struct n1sdp_c2c_pd_api *c2c_pd_api;
 
@@ -129,9 +126,7 @@ static int remote_pd_set_state(fwk_id_t pd_id, unsigned int state)
 
     default:
         FWK_LOG_ERR(
-            remote_pd_ctx.log_api,
-            "[C2C] Requested CPU power state (%i) is not supported!\n",
-            state);
+            "[C2C] Requested CPU power state (%i) is not supported!", state);
         return FWK_E_PARAM;
     }
 
@@ -215,11 +210,6 @@ static int remote_pd_bind(fwk_id_t id, unsigned int round)
         return FWK_SUCCESS;
 
     if ((round == 0) && fwk_id_is_type(id, FWK_ID_TYPE_MODULE)) {
-        status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                                 MOD_LOG_API_ID, &remote_pd_ctx.log_api);
-        if (status != FWK_SUCCESS)
-            return status;
-
         status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_N1SDP_C2C),
                                  FWK_ID_API(FWK_MODULE_IDX_N1SDP_C2C,
                                             N1SDP_C2C_API_IDX_PD),
diff --git a/product/n1sdp/module/n1sdp_rom/src/mod_n1sdp_rom.c b/product/n1sdp/module/n1sdp_rom/src/mod_n1sdp_rom.c
index ac1f424a..2cfee498 100644
--- a/product/n1sdp/module/n1sdp_rom/src/mod_n1sdp_rom.c
+++ b/product/n1sdp/module/n1sdp_rom/src/mod_n1sdp_rom.c
@@ -27,9 +27,6 @@ struct mod_n1sdp_rom_ctx {
     /* ROM configuration structure */
     const struct n1sdp_rom_config *rom_config;
 
-    /* Pointer to log API */
-    struct mod_log_api *log_api;
-
     /* Pointer to n1sdp_flash API */
     struct mod_n1sdp_flash_api *flash_api;
 };
@@ -82,14 +79,6 @@ static int n1sdp_rom_bind(fwk_id_t id, unsigned int round)
 
     /* Use second round only (round numbering is zero-indexed) */
     if (round == 1) {
-        /* Bind to the log component */
-        status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                                 FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-                                 &n1sdp_rom_ctx.log_api);
-
-        if (status != FWK_SUCCESS)
-            return FWK_E_PANIC;
-
         /* Bind to the n1sdp_flash component */
         status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_N1SDP_FLASH),
                                  FWK_ID_API(FWK_MODULE_IDX_N1SDP_FLASH, 0),
@@ -142,26 +131,20 @@ static int n1sdp_rom_process_event(const struct fwk_event *event,
 
         if (fip_desc->type == MOD_N1SDP_FIP_TYPE_MCP_BL2) {
             FWK_LOG_INFO(
-                n1sdp_rom_ctx.log_api,
                 "[ROM] Found MCP RAM Firmware at address: 0x%x,"
-                " size: %d bytes, flags: 0x%x\n",
+                " size: %d bytes, flags: 0x%x",
                 fip_desc->address,
                 fip_desc->size,
                 fip_desc->flags);
-            FWK_LOG_INFO(
-                n1sdp_rom_ctx.log_api,
-                "[ROM] Copying MCP RAM Firmware to ITCRAM...!\n");
+            FWK_LOG_INFO("[ROM] Copying MCP RAM Firmware to ITCRAM...!");
         } else {
             FWK_LOG_INFO(
-                n1sdp_rom_ctx.log_api,
                 "[ROM] Found SCP BL2 RAM Firmware at address: 0x%x,"
-                " size: %d bytes, flags: 0x%x\n",
+                " size: %d bytes, flags: 0x%x",
                 fip_desc->address,
                 fip_desc->size,
                 fip_desc->flags);
-            FWK_LOG_INFO(
-                n1sdp_rom_ctx.log_api,
-                "[ROM] Copying SCP RAM Firmware to ITCRAM...!\n");
+            FWK_LOG_INFO("[ROM] Copying SCP RAM Firmware to ITCRAM...!");
         }
         break;
     }
@@ -171,9 +154,9 @@ static int n1sdp_rom_process_event(const struct fwk_event *event,
 
     memcpy((void *)n1sdp_rom_ctx.rom_config->ramfw_base,
         (uint8_t *)fip_desc->address, fip_desc->size);
-    FWK_LOG_INFO(n1sdp_rom_ctx.log_api, "[ROM] Done!\n");
+    FWK_LOG_INFO("[ROM] Done!");
 
-    FWK_LOG_INFO(n1sdp_rom_ctx.log_api, "[ROM] Jumping to RAM Firmware\n");
+    FWK_LOG_INFO("[ROM] Jumping to RAM Firmware");
 
     jump_to_ramfw();
 
diff --git a/product/n1sdp/module/n1sdp_scp2pcc/src/mod_n1sdp_scp2pcc.c b/product/n1sdp/module/n1sdp_scp2pcc/src/mod_n1sdp_scp2pcc.c
index 9ae6ffa2..da02fad8 100644
--- a/product/n1sdp/module/n1sdp_scp2pcc/src/mod_n1sdp_scp2pcc.c
+++ b/product/n1sdp/module/n1sdp_scp2pcc/src/mod_n1sdp_scp2pcc.c
@@ -26,9 +26,6 @@ struct n1sdp_scp2pcc_ctx {
     /*  Pointer to module configuration */
     struct mem_msg_config_st *config;
 
-    /* Log API pointer */
-    const struct mod_log_api *log_api;
-
     /* Sequence variable */
     unsigned int sequence;
 };
@@ -76,12 +73,12 @@ static int mem_msg_send_message(void *data, uint16_t size, uint16_t type)
     struct mem_msg_packet_st *packet = NULL;
 
     if (type == SCP2PCC_TYPE_SHUTDOWN)
-        FWK_LOG_INFO(scp2pcc_ctx.log_api, "Shutdown request to PCC\n");
+        FWK_LOG_INFO("Shutdown request to PCC");
 
     /* Check parameters. */
     if ((size > MSG_PAYLOAD_SIZE) ||
         (type == MSG_UNUSED_MESSAGE_TYPE)) {
-        FWK_LOG_INFO(scp2pcc_ctx.log_api, "Invalid parameters\n");
+        FWK_LOG_INFO("Invalid parameters");
         return FWK_E_PARAM;
     }
 
@@ -144,16 +141,6 @@ static int n1sdp_scp2pcc_init(fwk_id_t module_id, unsigned int unused,
     return FWK_SUCCESS;
 }
 
-static int n1sdp_scp2pcc_bind(fwk_id_t id, unsigned int round)
-{
-    if (round == 0) {
-        return fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-            MOD_LOG_API_ID, &scp2pcc_ctx.log_api);
-    }
-
-    return FWK_SUCCESS;
-}
-
 static int n1sdp_scp2pcc_process_bind_request(fwk_id_t requester_id,
     fwk_id_t target_id, fwk_id_t api_id, const void **api)
 {
@@ -175,7 +162,6 @@ const struct fwk_module module_n1sdp_scp2pcc = {
     .api_count = 1,
     .type = FWK_MODULE_TYPE_PROTOCOL,
     .init = n1sdp_scp2pcc_init,
-    .bind = n1sdp_scp2pcc_bind,
     .process_bind_request = n1sdp_scp2pcc_process_bind_request,
     .start = n1sdp_scp2pcc_start,
 };
diff --git a/product/n1sdp/module/n1sdp_smt/src/mod_smt.c b/product/n1sdp/module/n1sdp_smt/src/mod_smt.c
index 199bed8f..81d04fe4 100644
--- a/product/n1sdp/module/n1sdp_smt/src/mod_smt.c
+++ b/product/n1sdp/module/n1sdp_smt/src/mod_smt.c
@@ -12,7 +12,6 @@
 #include <fwk_assert.h>
 #include <fwk_id.h>
 #include <fwk_interrupt.h>
-#include <fwk_log.h>
 #include <fwk_mm.h>
 #include <fwk_module.h>
 #include <fwk_module_idx.h>
@@ -48,9 +47,6 @@ struct smt_channel_ctx {
 };
 
 struct smt_ctx {
-    /* Log module API */
-    struct mod_log_api *log_api;
-
     /* Table of channel contexts */
     struct smt_channel_ctx *channel_ctx_table;
 
@@ -391,11 +387,8 @@ static int smt_bind(fwk_id_t id, unsigned int round)
     struct smt_channel_ctx *channel_ctx;
 
     if (round == 0) {
-        if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE)) {
-            return fwk_module_bind(fwk_module_id_log,
-                                   FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-                                   &smt_ctx.log_api);
-        }
+        if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE))
+            return FWK_SUCCESS;
 
         channel_ctx = &smt_ctx.channel_ctx_table[fwk_id_get_element_idx(id)];
         status = fwk_module_bind(channel_ctx->config->driver_id,
diff --git a/product/n1sdp/module/n1sdp_system/src/mod_n1sdp_system.c b/product/n1sdp/module/n1sdp_system/src/mod_n1sdp_system.c
index 722b1f41..417f8dc0 100644
--- a/product/n1sdp/module/n1sdp_system/src/mod_n1sdp_system.c
+++ b/product/n1sdp/module/n1sdp_system/src/mod_n1sdp_system.c
@@ -46,6 +46,7 @@
 
 #include <fmw_cmsis.h>
 
+#include <inttypes.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <string.h>
@@ -122,10 +123,6 @@ static fwk_id_t sds_bl33_info_id =
 
 /* Module context */
 struct n1sdp_system_ctx {
-
-    /* Log API pointer */
-    const struct mod_log_api *log_api;
-
     /* Pointer to the Interrupt Service Routine API of the PPU_V1 module */
     const struct ppu_v1_isr_api *ppu_v1_isr_api;
 
@@ -222,23 +219,17 @@ static int n1sdp_system_shutdown(
 
     switch (system_shutdown) {
     case MOD_PD_SYSTEM_SHUTDOWN:
-        FWK_LOG_INFO(
-            n1sdp_system_ctx.log_api,
-            "[N1SDP SYSTEM] Request PCC for system shutdown\n");
+        FWK_LOG_INFO("[N1SDP SYSTEM] Request PCC for system shutdown");
         n1sdp_system_ctx.scp2pcc_api->send(NULL, 0, SCP2PCC_TYPE_SHUTDOWN);
         break;
 
     case MOD_PD_SYSTEM_COLD_RESET:
-        FWK_LOG_INFO(
-            n1sdp_system_ctx.log_api,
-            "[N1SDP SYSTEM] Request PCC for system reboot\n");
+        FWK_LOG_INFO("[N1SDP SYSTEM] Request PCC for system reboot");
         n1sdp_system_ctx.scp2pcc_api->send(NULL, 0, SCP2PCC_TYPE_REBOOT);
         break;
 
     default:
-        FWK_LOG_INFO(
-            n1sdp_system_ctx.log_api,
-            "[N1SDP SYSTEM] Unknown shutdown command!\n");
+        FWK_LOG_INFO("[N1SDP SYSTEM] Unknown shutdown command!");
         break;
     }
 
@@ -300,26 +291,21 @@ static int n1sdp_system_copy_to_ap_sram(uint64_t sram_address,
 
     if (memcmp((void *)target_addr, (void *)spi_address, size) != 0) {
         FWK_LOG_INFO(
-            n1sdp_system_ctx.log_api,
-            "[N1SDP SYSTEM] Copy failed at destination address: 0x%08x\n",
+            "[N1SDP SYSTEM] Copy failed at destination address: 0x%" PRIX32,
             target_addr);
         return FWK_E_DATA;
     }
     FWK_LOG_INFO(
-        n1sdp_system_ctx.log_api,
-        "[N1SDP SYSTEM] Copied binary to SRAM address: 0x%08x\n",
+        "[N1SDP SYSTEM] Copied binary to SRAM address: 0x%" PRIX64,
         sram_address);
     return FWK_SUCCESS;
 }
 
 void cdbg_pwrupreq_handler(void)
 {
-    FWK_LOG_INFO(
-        n1sdp_system_ctx.log_api,
-        "[N1SDP SYSTEM] Received debug power up request interrupt\n");
+    FWK_LOG_INFO("[N1SDP SYSTEM] Received debug power up request interrupt");
 
-    FWK_LOG_INFO(
-        n1sdp_system_ctx.log_api, "[N1SDP SYSTEM] Power on Debug PIK\n");
+    FWK_LOG_INFO("[N1SDP SYSTEM] Power on Debug PIK");
 
     /* Clear interrupt */
     PIK_DEBUG->DEBUG_CTRL |= (0x1 << 1);
@@ -328,9 +314,7 @@ void cdbg_pwrupreq_handler(void)
 
 void csys_pwrupreq_handler(void)
 {
-    FWK_LOG_INFO(
-        n1sdp_system_ctx.log_api,
-        "[N1SDP SYSTEM] Received system power up request interrupt\n");
+    FWK_LOG_INFO("[N1SDP SYSTEM] Received system power up request interrupt");
 
     /* Clear interrupt */
     PIK_DEBUG->DEBUG_CTRL |= (0x1 << 2);
@@ -353,9 +337,7 @@ static int n1sdp_system_fill_platform_info(void)
 
     status = n1sdp_system_ctx.dmc620_api->get_mem_size_gb(&ddr_size_gb);
     if (status != FWK_SUCCESS) {
-        FWK_LOG_INFO(
-            n1sdp_system_ctx.log_api,
-            "Error calculating local DDR memory size!\n");
+        FWK_LOG_INFO("Error calculating local DDR memory size!");
         return status;
     }
 
@@ -370,16 +352,13 @@ static int n1sdp_system_fill_platform_info(void)
         status = n1sdp_system_ctx.c2c_api->get_ddr_size_gb
                                            (&sds_platform_info.remote_ddr_size);
         if (status != FWK_SUCCESS) {
-            FWK_LOG_INFO(
-                n1sdp_system_ctx.log_api,
-                "Error calculating Remote DDR memory size!\n");
+            FWK_LOG_INFO("Error calculating Remote DDR memory size!");
             return status;
         }
     }
 
     FWK_LOG_INFO(
-        n1sdp_system_ctx.log_api,
-        "    Total DDR Size: %d GB\n",
+        "    Total DDR Size: %d GB",
         sds_platform_info.local_ddr_size + sds_platform_info.remote_ddr_size);
 
     return n1sdp_system_ctx.sds_api->struct_write(sds_structure_desc->id,
@@ -414,8 +393,7 @@ static int n1sdp_system_init_primary_core(void)
     int fip_index_bl31 = -1;
 
     FWK_LOG_INFO(
-        n1sdp_system_ctx.log_api,
-        "[N1SDP SYSTEM] Setting AP Reset Address to 0x%08x\n",
+        "[N1SDP SYSTEM] Setting AP Reset Address to 0x%" PRIX64,
         AP_CORE_RESET_ADDR - AP_SCP_SRAM_OFFSET);
 
     cluster_count = n1sdp_core_get_cluster_count();
@@ -433,8 +411,7 @@ static int n1sdp_system_init_primary_core(void)
 
     if (n1sdp_get_chipid() == 0x0) {
         FWK_LOG_INFO(
-            n1sdp_system_ctx.log_api,
-            "[N1SDP SYSTEM] Looking for AP firmware in flash memory...\n");
+            "[N1SDP SYSTEM] Looking for AP firmware in flash memory...");
 
         status = n1sdp_system_ctx.flash_api->get_n1sdp_fip_descriptor_count(
             FWK_ID_MODULE(FWK_MODULE_IDX_N1SDP_SYSTEM), &fip_count);
@@ -449,9 +426,8 @@ static int n1sdp_system_init_primary_core(void)
         for (i = 0; i < fip_count; i++) {
             if (fip_desc_table[i].type == MOD_N1SDP_FIP_TYPE_TF_BL31) {
                 FWK_LOG_INFO(
-                    n1sdp_system_ctx.log_api,
                     "[N1SDP SYSTEM] Found BL31 at address: 0x%08x,"
-                    " size: %u, flags: 0x%x\n",
+                    " size: %u, flags: 0x%x",
                     fip_desc_table[i].address,
                     fip_desc_table[i].size,
                     fip_desc_table[i].flags);
@@ -462,15 +438,13 @@ static int n1sdp_system_init_primary_core(void)
 
         if (fip_index_bl31 < 0) {
             FWK_LOG_INFO(
-                n1sdp_system_ctx.log_api,
                 "[N1SDP SYSTEM] Error! "
-                "FIP does not have BL31 binary\n");
+                "FIP does not have BL31 binary");
             return FWK_E_PANIC;
         }
 
         FWK_LOG_INFO(
-            n1sdp_system_ctx.log_api,
-            "[N1SDP SYSTEM] Copying AP BL31 to address 0x%x...\n",
+            "[N1SDP SYSTEM] Copying AP BL31 to address 0x%" PRIX64 "...",
             AP_CORE_RESET_ADDR);
 
         status = n1sdp_system_copy_to_ap_sram(AP_CORE_RESET_ADDR,
@@ -480,33 +454,27 @@ static int n1sdp_system_init_primary_core(void)
             return FWK_E_PANIC;
 
         /* Fill BL33 image information structure */
-        FWK_LOG_INFO(
-            n1sdp_system_ctx.log_api,
-            "[N1SDP SYSTEM] Filling BL33 information...\n");
+        FWK_LOG_INFO("[N1SDP SYSTEM] Filling BL33 information...");
         status = n1sdp_system_fill_bl33_info();
         if (status != FWK_SUCCESS)
             return status;
 
         /* Fill Platform information structure */
-        FWK_LOG_INFO(
-            n1sdp_system_ctx.log_api,
-            "[N1SDP SYSTEM] Collecting Platform information...\n");
+        FWK_LOG_INFO("[N1SDP SYSTEM] Collecting Platform information...");
         status = n1sdp_system_fill_platform_info();
         if (status != FWK_SUCCESS)
             return status;
 
         /* Enable non-secure CoreSight debug access */
         FWK_LOG_INFO(
-            n1sdp_system_ctx.log_api,
-            "[N1SDP SYSTEM] Enabling CoreSight debug non-secure access\n");
+            "[N1SDP SYSTEM] Enabling CoreSight debug non-secure access");
         *(volatile uint32_t *)(AP_SCP_SRAM_OFFSET +
                                NIC_400_SEC_0_CSAPBM_OFFSET) = 0xFFFFFFFF;
 
         mod_pd_restricted_api = n1sdp_system_ctx.mod_pd_restricted_api;
 
-        FWK_LOG_TRACE(
-            n1sdp_system_ctx.log_api,
-            "[N1SDP SYSTEM] Booting primary core at %d MHz...\n",
+        FWK_LOG_INFO(
+            "[N1SDP SYSTEM] Booting primary core at %lu MHz...",
             PIK_CLK_RATE_CLUS0_CPU / FWK_MHZ);
 
         status = mod_pd_restricted_api->set_composite_state_async(
@@ -562,11 +530,6 @@ static int n1sdp_system_bind(fwk_id_t id, unsigned int round)
     if (round > 0)
         return FWK_SUCCESS;
 
-    status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-        FWK_ID_API(FWK_MODULE_IDX_LOG, 0), &n1sdp_system_ctx.log_api);
-    if (status != FWK_SUCCESS)
-        return status;
-
     status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_N1SDP_FLASH),
          FWK_ID_API(FWK_MODULE_IDX_N1SDP_FLASH, 0),
          &n1sdp_system_ctx.flash_api);
@@ -661,17 +624,11 @@ static int n1sdp_system_start(fwk_id_t id)
             CS_CNTCONTROL->CS_CNTCVLW = 0x00000000;
             CS_CNTCONTROL->CS_CNTCVUP = 0x0000FFFF;
         } else
-            FWK_LOG_TRACE(
-                n1sdp_system_ctx.log_api,
-                "[N1SDP SYSTEM] CSYS PWR UP REQ IRQ register failed\n");
+            FWK_LOG_ERR("[N1SDP SYSTEM] CSYS PWR UP REQ IRQ register failed");
     } else
-        FWK_LOG_TRACE(
-            n1sdp_system_ctx.log_api,
-            "[N1SDP SYSTEM] CDBG PWR UP REQ IRQ register failed\n");
+        FWK_LOG_ERR("[N1SDP SYSTEM] CDBG PWR UP REQ IRQ register failed");
 
-    FWK_LOG_TRACE(
-        n1sdp_system_ctx.log_api,
-        "[N1SDP SYSTEM] Requesting SYSTOP initialization...\n");
+    FWK_LOG_INFO("[N1SDP SYSTEM] Requesting SYSTOP initialization...");
 
     /*
      * Subscribe to these SCMI channels in order to know when they have all
diff --git a/product/n1sdp/module/n1sdp_timer_sync/src/mod_n1sdp_timer_sync.c b/product/n1sdp/module/n1sdp_timer_sync/src/mod_n1sdp_timer_sync.c
index b117698b..f711d644 100644
--- a/product/n1sdp/module/n1sdp_timer_sync/src/mod_n1sdp_timer_sync.c
+++ b/product/n1sdp/module/n1sdp_timer_sync/src/mod_n1sdp_timer_sync.c
@@ -17,7 +17,6 @@
 #include <mod_timer.h>
 
 #include <fwk_assert.h>
-#include <fwk_id.h>
 #include <fwk_interrupt.h>
 #include <fwk_log.h>
 #include <fwk_mm.h>
@@ -27,7 +26,6 @@
 
 #include <stdbool.h>
 #include <stddef.h>
-#include <stdint.h>
 
 #define COUNTER_DELTA_MAX      0x100
 #define INT_STATUS_TIMEOUT     UINT32_C(1000)
@@ -60,9 +58,6 @@ struct timer_sync_ctx {
     /* Table of device contexts */
     struct tsync_device_ctx *device_ctx_table;
 
-    /* Log module API */
-    struct mod_log_api *log_api;
-
     /* Windowed AP memory access API */
     struct mod_n1sdp_system_ap_memory_access_api *ap_mem_api;
 
@@ -140,13 +135,13 @@ static int n1sdp_sync_master_timer(fwk_id_t id)
                                    SYNC_CHECK_INTERVAL_US);
         retries--;
         if ((retries % 10) == 0)
-            FWK_LOG_INFO(tsync_ctx.log_api, ".");
+            FWK_LOG_INFO("[N1SDP_TIMER_SYNC] Retries: %u", retries);
     } while (retries != 0);
 
     if ((retries == 0) && (!is_timer_synced(device_ctx)))
-        FWK_LOG_INFO(tsync_ctx.log_api, "Timeout!\n");
+        FWK_LOG_INFO("[N1SDP_TIMER_SYNC] Timeout!");
     else
-        FWK_LOG_INFO(tsync_ctx.log_api, "Synced\n");
+        FWK_LOG_INFO("[N1SDP_TIMER_SYNC] Synced");
 
     return FWK_SUCCESS;
 }
@@ -223,11 +218,6 @@ static int n1sdp_timer_sync_bind(fwk_id_t id, unsigned int round)
     int status;
 
     if ((round == 0) && fwk_id_is_type(id, FWK_ID_TYPE_MODULE)) {
-        status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-            FWK_ID_API(FWK_MODULE_IDX_LOG, 0), &tsync_ctx.log_api);
-        if (status != FWK_SUCCESS)
-            return status;
-
         status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_N1SDP_SYSTEM),
             FWK_ID_API(FWK_MODULE_IDX_N1SDP_SYSTEM,
                        MOD_N1SDP_SYSTEM_API_IDX_AP_MEMORY_ACCESS),
diff --git a/product/n1sdp/module/scmi_agent/src/mod_scmi_agent.c b/product/n1sdp/module/scmi_agent/src/mod_scmi_agent.c
index fdd8c1db..f87c5481 100644
--- a/product/n1sdp/module/scmi_agent/src/mod_scmi_agent.c
+++ b/product/n1sdp/module/scmi_agent/src/mod_scmi_agent.c
@@ -20,6 +20,7 @@
 #include <fwk_status.h>
 #include <fwk_thread.h>
 
+#include <inttypes.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ -40,9 +41,6 @@ struct mod_scmi_agent_module_ctx {
     /* Pointer to agent configuration table */
     struct scmi_agent_ctx *agent_ctx_table;
 
-    /* Log API pointer */
-    const struct mod_log_api *log_api;
-
     /* SMT API pointer */
     const struct mod_scmi_agent_to_transport_api *smt_api;
 };
@@ -64,7 +62,7 @@ static int _scmi_agent_transact(fwk_id_t agent_id,
 
     /* Check if channel is free */
     if (!ctx.smt_api->is_channel_free(agent_ctx->config->transport_id)) {
-        FWK_LOG_TRACE(ctx.log_api, "[SCMI AGENT] Channel Busy!\n");
+        FWK_LOG_ERR("[SCMI AGENT] Channel Busy!");
         return FWK_E_BUSY;
     }
 
@@ -211,11 +209,9 @@ static int scmi_agent_bind(fwk_id_t id, unsigned int round)
     struct scmi_agent_ctx *agent_ctx;
 
     if (round == 0) {
-        if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE)) {
-            return fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                                   FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-                                   &ctx.log_api);
-        }
+        if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE))
+            return FWK_SUCCESS;
+
         agent_ctx = &ctx.agent_ctx_table[fwk_id_get_element_idx(id)];
         return fwk_module_bind(agent_ctx->config->transport_id,
                                agent_ctx->config->transport_api_id,
@@ -259,10 +255,8 @@ static int scmi_agent_process_event(const struct fwk_event *event,
     if (status != FWK_SUCCESS)
         return status;
 
-    FWK_LOG_TRACE(
-        ctx.log_api,
-        "[SCMI AGENT] Found management protocol version: 0x%x\n",
-        temp);
+    FWK_LOG_INFO(
+        "[SCMI AGENT] Found management protocol version: 0x%" PRIu32, temp);
 
     return status;
 }
diff --git a/product/n1sdp/module/scmi_ccix_config/src/mod_scmi_ccix_config.c b/product/n1sdp/module/scmi_ccix_config/src/mod_scmi_ccix_config.c
index 7c110288..a8d46cbc 100644
--- a/product/n1sdp/module/scmi_ccix_config/src/mod_scmi_ccix_config.c
+++ b/product/n1sdp/module/scmi_ccix_config/src/mod_scmi_ccix_config.c
@@ -35,9 +35,6 @@ struct scmi_ccix_config_ctx {
 
     /* PCIe CCIX config api */
     const struct n1sdp_pcie_ccix_config_api *pcie_ccix_config_api;
-
-    /* Log module API */
-    struct mod_log_api *log_api;
 };
 
 static struct scmi_ccix_config_ctx scmi_ccix_config_ctx;
@@ -179,10 +176,8 @@ static int scmi_ccix_config_protocol_get_handler(fwk_id_t service_id,
     if (sizeof(return_values) > max_payload_size) {
         return_values.status = SCMI_OUT_OF_RANGE;
         status = FWK_E_RANGE;
-        FWK_LOG_TRACE(
-            scmi_ccix_config_ctx.log_api,
-            "[SCMI CCIX CONFIG] max payload size is  %d\n",
-            max_payload_size);
+        FWK_LOG_INFO(
+            "[SCMI CCIX CONFIG] max payload size is  %d", max_payload_size);
         goto exit;
     }
 
@@ -269,10 +264,8 @@ static int scmi_ccix_config_protocol_set_handler(fwk_id_t service_id,
     if (sizeof(*params) > max_payload_size) {
         return_values.status = SCMI_OUT_OF_RANGE;
         status = FWK_E_RANGE;
-        FWK_LOG_TRACE(
-            scmi_ccix_config_ctx.log_api,
-            "[SCMI CCIX CONFIG] max payload size is  %d\n",
-            max_payload_size);
+        FWK_LOG_INFO(
+            "[SCMI CCIX CONFIG] max payload size is  %d", max_payload_size);
         goto exit;
     }
 
@@ -425,14 +418,6 @@ static int scmi_ccix_config_bind(fwk_id_t id, unsigned int round)
     if (round == 1)
         return FWK_SUCCESS;
 
-    status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-        FWK_ID_API(FWK_MODULE_IDX_LOG, 0), &scmi_ccix_config_ctx.log_api);
-    if (status != FWK_SUCCESS) {
-        /* Failed to bind to log module */
-        fwk_assert(false);
-        return status;
-    }
-
     status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_SCMI),
         FWK_ID_API(FWK_MODULE_IDX_SCMI, MOD_SCMI_API_IDX_PROTOCOL),
         &scmi_ccix_config_ctx.scmi_api);
diff --git a/product/n1sdp/scp_ramfw/config_log.c b/product/n1sdp/scp_ramfw/config_log.c
index 21cb3b6a..97e62c58 100644
--- a/product/n1sdp/scp_ramfw/config_log.c
+++ b/product/n1sdp/scp_ramfw/config_log.c
@@ -49,13 +49,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_SCP
-              FWK_BANNER_RAM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_SCP FWK_BANNER_RAM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/n1sdp/scp_romfw/config_log.c b/product/n1sdp/scp_romfw/config_log.c
index 757d5fbe..d8aace73 100644
--- a/product/n1sdp/scp_romfw/config_log.c
+++ b/product/n1sdp/scp_romfw/config_log.c
@@ -20,7 +20,7 @@
 /*
  * N1SDP BYPASS ROM firmware banner string.
  */
-#define N1SDP_BANNER_ROM_FIRMWARE "Entered BYPASS ROM Firmware\n"
+#define N1SDP_BANNER_ROM_FIRMWARE "Entered BYPASS ROM Firmware"
 
 /*
  * PL011 module
@@ -54,13 +54,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_SCP
-              N1SDP_BANNER_ROM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_SCP N1SDP_BANNER_ROM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/rddaniel/mcp_romfw/config_log.c b/product/rddaniel/mcp_romfw/config_log.c
index 1924abce..59704bef 100644
--- a/product/rddaniel/mcp_romfw/config_log.c
+++ b/product/rddaniel/mcp_romfw/config_log.c
@@ -48,13 +48,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_MCP
-              FWK_BANNER_ROM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_MCP FWK_BANNER_ROM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/rddaniel/module/mscp_rom/src/mod_mscp_rom.c b/product/rddaniel/module/mscp_rom/src/mod_mscp_rom.c
index e51fb232..554e9c88 100644
--- a/product/rddaniel/module/mscp_rom/src/mod_mscp_rom.c
+++ b/product/rddaniel/module/mscp_rom/src/mod_mscp_rom.c
@@ -20,7 +20,6 @@
 #include <string.h>
 
 static const struct mscp_rom_config *rom_config;
-static struct mod_log_api *log_api;
 
 enum rom_event {
     ROM_EVENT_RUN,
@@ -61,24 +60,6 @@ static int mscp_rom_init(fwk_id_t module_id, unsigned int element_count,
     return FWK_SUCCESS;
 }
 
-static int mscp_rom_bind(fwk_id_t id, unsigned int round)
-{
-    int status;
-
-    /* Use second round only (round numbering is zero-indexed) */
-    if (round == 1) {
-        /* Bind to the log component */
-        status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                                 FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-                                 &log_api);
-
-        if (status != FWK_SUCCESS)
-            return FWK_E_PANIC;
-    }
-
-    return FWK_SUCCESS;
-}
-
 static int mscp_rom_start(fwk_id_t id)
 {
     int status;
@@ -96,7 +77,7 @@ static int mscp_rom_start(fwk_id_t id)
 static int mscp_rom_process_event(const struct fwk_event *event,
                                       struct fwk_event *resp)
 {
-    FWK_LOG_INFO(log_api, "[ROM] Loading RAM firmware\n");
+    FWK_LOG_INFO("[ROM] Loading RAM firmware");
 
     if (rom_config->ramfw_flash_size != 0) {
         memcpy((void *)rom_config->ramfw_ram_base,
@@ -104,7 +85,7 @@ static int mscp_rom_process_event(const struct fwk_event *event,
             rom_config->ramfw_flash_size);
     }
 
-    FWK_LOG_INFO(log_api, "[ROM] Starting RAM firmware execution\n");
+    FWK_LOG_INFO("[ROM] Starting RAM firmware execution");
     jump_to_ramfw();
 
     return FWK_SUCCESS;
@@ -116,7 +97,6 @@ const struct fwk_module module_mscp_rom = {
     .type = FWK_MODULE_TYPE_SERVICE,
     .event_count = ROM_EVENT_COUNT,
     .init = mscp_rom_init,
-    .bind = mscp_rom_bind,
     .start = mscp_rom_start,
     .process_event = mscp_rom_process_event,
 };
diff --git a/product/rddaniel/module/rddaniel_system/src/mod_rddaniel_system.c b/product/rddaniel/module/rddaniel_system/src/mod_rddaniel_system.c
index dfffb0c4..01ea000d 100644
--- a/product/rddaniel/module/rddaniel_system/src/mod_rddaniel_system.c
+++ b/product/rddaniel/module/rddaniel_system/src/mod_rddaniel_system.c
@@ -50,9 +50,6 @@ struct rddaniel_system_ctx {
     /* Pointer to the SCP PIK registers */
     struct pik_scp_reg *pik_scp_reg;
 
-    /* Log API pointer */
-    const struct mod_log_api *log_api;
-
     /* Pointer to the Interrupt Service Routine API of the PPU_V1 module */
     const struct ppu_v1_isr_api *ppu_v1_isr_api;
 
@@ -219,11 +216,6 @@ static int rddaniel_system_bind(fwk_id_t id, unsigned int round)
     if (round > 0)
         return FWK_SUCCESS;
 
-    status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-        FWK_ID_API(FWK_MODULE_IDX_LOG, 0), &rddaniel_system_ctx.log_api);
-    if (status != FWK_SUCCESS)
-        return status;
-
     status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_POWER_DOMAIN),
         FWK_ID_API(FWK_MODULE_IDX_POWER_DOMAIN, MOD_PD_API_IDX_RESTRICTED),
         &rddaniel_system_ctx.mod_pd_restricted_api);
@@ -260,9 +252,7 @@ static int rddaniel_system_start(fwk_id_t id)
     if (status != FWK_SUCCESS)
         return status;
 
-    FWK_LOG_TRACE(
-        rddaniel_system_ctx.log_api,
-        "[RD-DANIEL SYSTEM] Requesting SYSTOP initialization...\n");
+    FWK_LOG_INFO("[RD-DANIEL SYSTEM] Requesting SYSTOP initialization...");
 
     /*
      * Subscribe to these SCMI channels in order to know when they have all
@@ -317,9 +307,7 @@ int rddaniel_system_process_notification(const struct fwk_event *event,
          * time only
          */
         if (params->new_state == MOD_CLOCK_STATE_RUNNING) {
-            FWK_LOG_TRACE(
-                rddaniel_system_ctx.log_api,
-                "[RD-DANIEL SYSTEM] Initializing the primary core...\n");
+            FWK_LOG_INFO("[RD-DANIEL SYSTEM] Initializing the primary core...");
 
             mod_pd_restricted_api = rddaniel_system_ctx.mod_pd_restricted_api;
 
diff --git a/product/rddaniel/scp_ramfw/config_log.c b/product/rddaniel/scp_ramfw/config_log.c
index 89d3575d..33a8b47e 100644
--- a/product/rddaniel/scp_ramfw/config_log.c
+++ b/product/rddaniel/scp_ramfw/config_log.c
@@ -18,13 +18,8 @@
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_SCP
-              FWK_BANNER_RAM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_SCP FWK_BANNER_RAM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/rddaniel/scp_romfw/config_log.c b/product/rddaniel/scp_romfw/config_log.c
index a6531f24..48317aca 100644
--- a/product/rddaniel/scp_romfw/config_log.c
+++ b/product/rddaniel/scp_romfw/config_log.c
@@ -15,13 +15,8 @@
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_SCP
-              FWK_BANNER_ROM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_SCP FWK_BANNER_ROM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/rdn1e1/mcp_romfw/config_log.c b/product/rdn1e1/mcp_romfw/config_log.c
index f332ccfd..d172915d 100644
--- a/product/rdn1e1/mcp_romfw/config_log.c
+++ b/product/rdn1e1/mcp_romfw/config_log.c
@@ -49,13 +49,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_MCP
-              FWK_BANNER_ROM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_MCP FWK_BANNER_ROM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/rdn1e1/module/rdn1e1_rom/src/mod_rdn1e1_rom.c b/product/rdn1e1/module/rdn1e1_rom/src/mod_rdn1e1_rom.c
index 318f4334..ec698a50 100644
--- a/product/rdn1e1/module/rdn1e1_rom/src/mod_rdn1e1_rom.c
+++ b/product/rdn1e1/module/rdn1e1_rom/src/mod_rdn1e1_rom.c
@@ -20,7 +20,6 @@
 #include <string.h>
 
 static const struct rdn1e1_rom_config *rom_config;
-static struct mod_log_api *log_api;
 
 enum rom_event {
     ROM_EVENT_RUN,
@@ -63,24 +62,6 @@ static int rdn1e1_rom_init(fwk_id_t module_id, unsigned int element_count,
     return FWK_SUCCESS;
 }
 
-static int rdn1e1_rom_bind(fwk_id_t id, unsigned int round)
-{
-    int status;
-
-    /* Use second round only (round numbering is zero-indexed) */
-    if (round == 1) {
-        /* Bind to the log component */
-        status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                                 FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-                                 &log_api);
-
-        if (status != FWK_SUCCESS)
-            return FWK_E_PANIC;
-    }
-
-    return FWK_SUCCESS;
-}
-
 static int rdn1e1_rom_start(fwk_id_t id)
 {
     int status;
@@ -98,7 +79,7 @@ static int rdn1e1_rom_start(fwk_id_t id)
 static int rdn1e1_rom_process_event(const struct fwk_event *event,
     struct fwk_event *resp)
 {
-    FWK_LOG_INFO(log_api, "[ROM] Launch RAM\n");
+    FWK_LOG_INFO("[ROM] Launch RAM");
 
     if (rom_config->load_ram_size != 0) {
         memcpy((void *)rom_config->ramfw_base,
@@ -116,7 +97,6 @@ const struct fwk_module module_rdn1e1_rom = {
     .type = FWK_MODULE_TYPE_SERVICE,
     .event_count = ROM_EVENT_COUNT,
     .init = rdn1e1_rom_init,
-    .bind = rdn1e1_rom_bind,
     .start = rdn1e1_rom_start,
     .process_event = rdn1e1_rom_process_event,
 };
diff --git a/product/rdn1e1/module/rdn1e1_system/src/mod_rdn1e1_system.c b/product/rdn1e1/module/rdn1e1_system/src/mod_rdn1e1_system.c
index 2273c014..30a1b73e 100644
--- a/product/rdn1e1/module/rdn1e1_system/src/mod_rdn1e1_system.c
+++ b/product/rdn1e1/module/rdn1e1_system/src/mod_rdn1e1_system.c
@@ -53,9 +53,6 @@ struct rdn1e1_system_ctx {
     /* Pointer to the SCP PIK registers */
     struct pik_scp_reg *pik_scp_reg;
 
-    /* Log API pointer */
-    const struct mod_log_api *log_api;
-
     /* Pointer to the Interrupt Service Routine API of the PPU_V1 module */
     const struct ppu_v1_isr_api *ppu_v1_isr_api;
 
@@ -228,11 +225,6 @@ static int rdn1e1_system_bind(fwk_id_t id, unsigned int round)
     if (round > 0)
         return FWK_SUCCESS;
 
-    status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-        FWK_ID_API(FWK_MODULE_IDX_LOG, 0), &rdn1e1_system_ctx.log_api);
-    if (status != FWK_SUCCESS)
-        return status;
-
     status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_POWER_DOMAIN),
         FWK_ID_API(FWK_MODULE_IDX_POWER_DOMAIN, MOD_PD_API_IDX_RESTRICTED),
         &rdn1e1_system_ctx.mod_pd_restricted_api);
@@ -283,9 +275,7 @@ static int rdn1e1_system_start(fwk_id_t id)
     if (status != FWK_SUCCESS)
         return status;
 
-    FWK_LOG_TRACE(
-        rdn1e1_system_ctx.log_api,
-        "[RDN1E1 SYSTEM] Requesting SYSTOP initialization...\n");
+    FWK_LOG_INFO("[RDN1E1 SYSTEM] Requesting SYSTOP initialization...");
 
     /*
      * Subscribe to these SCMI channels in order to know when they have all
@@ -367,10 +357,7 @@ int rdn1e1_system_process_notification(const struct fwk_event *event,
 
             status = rdn1e1_system_ctx.cmn600_api->set_config(&remote_config);
             if (status != FWK_SUCCESS) {
-                FWK_LOG_ERR(
-                    rdn1e1_system_ctx.log_api,
-                    "CCIX Setup Failed for Chip: %d!\n",
-                    chip_id);
+                FWK_LOG_ERR("CCIX Setup Failed for Chip: %d!", chip_id);
                 return status;
             }
             rdn1e1_system_ctx.cmn600_api->exchange_protocol_credit(0);
@@ -383,9 +370,7 @@ int rdn1e1_system_process_notification(const struct fwk_event *event,
          * time only
          */
         if (chip_id == 0) {
-            FWK_LOG_TRACE(
-                rdn1e1_system_ctx.log_api,
-                "[RDN1E1 SYSTEM] Initializing the primary core...\n");
+            FWK_LOG_INFO("[RDN1E1 SYSTEM] Initializing the primary core...");
 
             mod_pd_restricted_api = rdn1e1_system_ctx.mod_pd_restricted_api;
 
@@ -397,10 +382,9 @@ int rdn1e1_system_process_notification(const struct fwk_event *event,
             if (status != FWK_SUCCESS)
                 return status;
         } else {
-            FWK_LOG_TRACE(
-                rdn1e1_system_ctx.log_api,
+            FWK_LOG_INFO(
                 "[RDN1E1 SYSTEM] Detected as slave chip %d, "
-                "Waiting for SCMI command\n",
+                "Waiting for SCMI command",
                 chip_id);
         }
 
diff --git a/product/rdn1e1/scp_ramfw/config_log.c b/product/rdn1e1/scp_ramfw/config_log.c
index 981d1349..f0349a68 100644
--- a/product/rdn1e1/scp_ramfw/config_log.c
+++ b/product/rdn1e1/scp_ramfw/config_log.c
@@ -49,13 +49,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_SCP
-              FWK_BANNER_RAM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_SCP FWK_BANNER_RAM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/rdn1e1/scp_romfw/config_log.c b/product/rdn1e1/scp_romfw/config_log.c
index 80c24694..54a43be3 100644
--- a/product/rdn1e1/scp_romfw/config_log.c
+++ b/product/rdn1e1/scp_romfw/config_log.c
@@ -49,13 +49,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_SCP
-              FWK_BANNER_ROM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_SCP FWK_BANNER_ROM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/sgi575/mcp_romfw/config_log.c b/product/sgi575/mcp_romfw/config_log.c
index 1f9c2637..7b87a604 100644
--- a/product/sgi575/mcp_romfw/config_log.c
+++ b/product/sgi575/mcp_romfw/config_log.c
@@ -49,13 +49,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_MCP
-              FWK_BANNER_ROM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_MCP FWK_BANNER_ROM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/sgi575/module/sgi575_rom/src/mod_sgi575_rom.c b/product/sgi575/module/sgi575_rom/src/mod_sgi575_rom.c
index b9a23486..11da29f5 100644
--- a/product/sgi575/module/sgi575_rom/src/mod_sgi575_rom.c
+++ b/product/sgi575/module/sgi575_rom/src/mod_sgi575_rom.c
@@ -20,7 +20,6 @@
 #include <string.h>
 
 static const struct sgi575_rom_config *rom_config;
-static struct mod_log_api *log_api;
 
 enum rom_event {
     ROM_EVENT_RUN,
@@ -63,24 +62,6 @@ static int sgi575_rom_init(fwk_id_t module_id, unsigned int element_count,
     return FWK_SUCCESS;
 }
 
-static int sgi575_rom_bind(fwk_id_t id, unsigned int round)
-{
-    int status;
-
-    /* Use second round only (round numbering is zero-indexed) */
-    if (round == 1) {
-        /* Bind to the log component */
-        status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-                                 FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-                                 &log_api);
-
-        if (status != FWK_SUCCESS)
-            return FWK_E_PANIC;
-    }
-
-    return FWK_SUCCESS;
-}
-
 static int sgi575_rom_start(fwk_id_t id)
 {
     int status;
@@ -98,7 +79,8 @@ static int sgi575_rom_start(fwk_id_t id)
 static int sgi575_rom_process_event(const struct fwk_event *event,
     struct fwk_event *resp)
 {
-    FWK_LOG_INFO(log_api, "[ROM] Launch RAM\n");
+    FWK_LOG_INFO("[ROM] Launch RAM");
+    FWK_LOG_FLUSH();
 
     if (rom_config->load_ram_size != 0) {
         memcpy((void *)rom_config->ramfw_base,
@@ -116,7 +98,6 @@ const struct fwk_module module_sgi575_rom = {
     .type = FWK_MODULE_TYPE_SERVICE,
     .event_count = ROM_EVENT_COUNT,
     .init = sgi575_rom_init,
-    .bind = sgi575_rom_bind,
     .start = sgi575_rom_start,
     .process_event = sgi575_rom_process_event,
 };
diff --git a/product/sgi575/module/sgi575_system/src/mod_sgi575_system.c b/product/sgi575/module/sgi575_system/src/mod_sgi575_system.c
index b8f183fc..77ff8462 100644
--- a/product/sgi575/module/sgi575_system/src/mod_sgi575_system.c
+++ b/product/sgi575/module/sgi575_system/src/mod_sgi575_system.c
@@ -51,9 +51,6 @@ struct sgi575_system_ctx {
     /* Pointer to the SCP PIK registers */
     struct pik_scp_reg *pik_scp_reg;
 
-    /* Log API pointer */
-    const struct mod_log_api *log_api;
-
     /* Pointer to the Interrupt Service Routine API of the PPU_V1 module */
     const struct ppu_v1_isr_api *ppu_v1_isr_api;
 
@@ -216,11 +213,6 @@ static int sgi575_system_bind(fwk_id_t id, unsigned int round)
     if (round > 0)
         return FWK_SUCCESS;
 
-    status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-        FWK_ID_API(FWK_MODULE_IDX_LOG, 0), &sgi575_system_ctx.log_api);
-    if (status != FWK_SUCCESS)
-        return status;
-
     status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_POWER_DOMAIN),
         FWK_ID_API(FWK_MODULE_IDX_POWER_DOMAIN, MOD_PD_API_IDX_RESTRICTED),
         &sgi575_system_ctx.mod_pd_restricted_api);
@@ -257,9 +249,7 @@ static int sgi575_system_start(fwk_id_t id)
     if (status != FWK_SUCCESS)
         return status;
 
-    FWK_LOG_TRACE(
-        sgi575_system_ctx.log_api,
-        "[SGI575 SYSTEM] Requesting SYSTOP initialization...\n");
+    FWK_LOG_INFO("[SGI575 SYSTEM] Requesting SYSTOP initialization...");
 
     /*
      * Subscribe to these SCMI channels in order to know when they have all
@@ -314,9 +304,7 @@ int sgi575_system_process_notification(const struct fwk_event *event,
          * time only
          */
         if (params->new_state == MOD_CLOCK_STATE_RUNNING) {
-            FWK_LOG_TRACE(
-                sgi575_system_ctx.log_api,
-                "[SGI575 SYSTEM] Initializing the primary core...\n");
+            FWK_LOG_INFO("[SGI575 SYSTEM] Initializing the primary core...");
 
             mod_pd_restricted_api = sgi575_system_ctx.mod_pd_restricted_api;
 
diff --git a/product/sgi575/scp_ramfw/config_log.c b/product/sgi575/scp_ramfw/config_log.c
index 39c86f36..ff4761eb 100644
--- a/product/sgi575/scp_ramfw/config_log.c
+++ b/product/sgi575/scp_ramfw/config_log.c
@@ -49,13 +49,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_SCP
-              FWK_BANNER_RAM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_SCP FWK_BANNER_RAM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/sgi575/scp_romfw/config_log.c b/product/sgi575/scp_romfw/config_log.c
index e0732005..c5f89f05 100644
--- a/product/sgi575/scp_romfw/config_log.c
+++ b/product/sgi575/scp_romfw/config_log.c
@@ -49,13 +49,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_SCP
-              FWK_BANNER_ROM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_SCP FWK_BANNER_ROM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/sgm775/module/sgm775_ddr_phy500/src/mod_sgm775_ddr_phy500.c b/product/sgm775/module/sgm775_ddr_phy500/src/mod_sgm775_ddr_phy500.c
index d12e6de9..72e91142 100644
--- a/product/sgm775/module/sgm775_ddr_phy500/src/mod_sgm775_ddr_phy500.c
+++ b/product/sgm775/module/sgm775_ddr_phy500/src/mod_sgm775_ddr_phy500.c
@@ -20,8 +20,6 @@
 
 #include <stddef.h>
 
-static struct mod_log_api *log_api;
-
 /*
  * Functions fulfilling this module's interface
  */
@@ -34,7 +32,7 @@ static int sgm775_ddr_phy500_config(fwk_id_t element_id)
 
     ddr = (struct mod_sgm775_ddr_phy500_reg *)element_config->ddr;
 
-    FWK_LOG_TRACE(log_api, "[DDR] Initializing PHY at 0x%x\n", (uintptr_t)ddr);
+    FWK_LOG_INFO("[DDR] Initializing PHY at 0x%x", (uintptr_t)ddr);
 
     ddr->T_CTRL_DELAY   = 0x00000000;
     ddr->READ_DELAY     = 0x00000003;
@@ -72,27 +70,6 @@ static int sgm775_ddr_phy500_element_init(fwk_id_t element_id,
     return FWK_SUCCESS;
 }
 
-static int sgm775_ddr_phy500_bind(fwk_id_t id, unsigned int round)
-{
-    int status;
-
-    /* Skip the second round */
-    if (round == 1)
-        return FWK_SUCCESS;
-
-    /* Nothing to be done for element-level binding */
-    if (fwk_module_is_valid_element_id(id))
-        return FWK_SUCCESS;
-
-    /* Bind to the log module */
-    status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG), MOD_LOG_API_ID,
-        &log_api);
-    if (status != FWK_SUCCESS)
-        return status;
-
-    return FWK_SUCCESS;
-}
-
 static int sgm775_ddr_phy500_process_bind_request(fwk_id_t requester_id,
     fwk_id_t id, fwk_id_t api_id, const void **api)
 {
@@ -110,7 +87,6 @@ const struct fwk_module module_sgm775_ddr_phy500 = {
     .type = FWK_MODULE_TYPE_DRIVER,
     .init = sgm775_ddr_phy500_init,
     .element_init = sgm775_ddr_phy500_element_init,
-    .bind = sgm775_ddr_phy500_bind,
     .process_bind_request = sgm775_ddr_phy500_process_bind_request,
     .api_count = 1,
 };
diff --git a/product/sgm775/module/sgm775_dmc500/src/mod_sgm775_dmc500.c b/product/sgm775/module/sgm775_dmc500/src/mod_sgm775_dmc500.c
index 8a063372..2008b909 100644
--- a/product/sgm775/module/sgm775_dmc500/src/mod_sgm775_dmc500.c
+++ b/product/sgm775/module/sgm775_dmc500/src/mod_sgm775_dmc500.c
@@ -32,7 +32,6 @@
 /* Timeout in us */
 #define TIMEOUT_DMC_INIT_US (1000 * 1000)
 
-static struct mod_log_api *log_api;
 static struct mod_timer_api *timer_api;
 static struct mod_sgm775_dmc_ddr_phy_api *ddr_phy_api;
 
@@ -72,12 +71,6 @@ static int mod_sgm775_dmc500_bind(fwk_id_t id, unsigned int round)
         module_config = fwk_module_get_data(fwk_module_id_sgm775_dmc500);
         fwk_assert(module_config != NULL);
 
-        /* Bind to the log module */
-        status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-            MOD_LOG_API_ID, &log_api);
-        if (status != FWK_SUCCESS)
-            return status;
-
         /* Bind to the timer */
         status = fwk_module_bind(module_config->timer_id,
             FWK_ID_API(FWK_MODULE_IDX_TIMER, 0), &timer_api);
@@ -132,8 +125,7 @@ static int sgm775_dmc500_config(struct mod_sgm775_dmc500_reg *dmc,
 
     module_config = fwk_module_get_data(fwk_module_id_sgm775_dmc500);
 
-    FWK_LOG_TRACE(
-        log_api, "[DDR] Initialising DMC500 at 0x%x\n", (uintptr_t)dmc);
+    FWK_LOG_INFO("[DDR] Initialising DMC500 at 0x%x", (uintptr_t)dmc);
 
     dmc->ADDRESS_CONTROL = ((RANK_BITS << 24) |
                             (BANK_BITS << 16) |
@@ -150,7 +142,7 @@ static int sgm775_dmc500_config(struct mod_sgm775_dmc500_reg *dmc,
     dmc->ODT_RD_CONTROL_31_00 = 0x00000000;
     dmc->ODT_TIMING = 0x10001000;
 
-    FWK_LOG_TRACE(log_api, "[DDR] Setting timing settings\n");
+    FWK_LOG_INFO("[DDR] Setting timing settings");
 
     dmc->T_REFI = 0x0000030B;
     dmc->T_RFC = 0x000340D0;
@@ -173,11 +165,11 @@ static int sgm775_dmc500_config(struct mod_sgm775_dmc500_reg *dmc,
     dmc->T_ESR = 0x00000019;
     dmc->T_XSR = 0x00E100E1;
 
-    FWK_LOG_TRACE(log_api, "[DDR] Setting address map\n");
+    FWK_LOG_INFO("[DDR] Setting address map");
 
     dmc->ADDRESS_MAP = ((1 << 8) | (ADDR_SHUTTER));
 
-    FWK_LOG_TRACE(log_api, "[DDR] Setting PMU settings\n");
+    FWK_LOG_INFO("[DDR] Setting PMU settings");
 
     dmc->SI0_SI_INTERRUPT_CONTROL = 0x00000000;
     dmc->SI0_PMU_REQ_CONTROL = 0x00000B1A;
@@ -260,7 +252,7 @@ static int sgm775_dmc500_config(struct mod_sgm775_dmc500_reg *dmc,
     dmc->T_PHYWRLAT = 0x010F170E;
     dmc->ERR_RAMECC_CTLR = 0x00000000;
 
-    FWK_LOG_TRACE(log_api, "[DDR] Setting PHY-related settings\n");
+    FWK_LOG_INFO("[DDR] Setting PHY-related settings");
 
     dmc->PHY_POWER_CONTROL = 0x0000012A;
     dmc->T_PHY_TRAIN = 0x00F8000A;
@@ -277,7 +269,7 @@ static int sgm775_dmc500_config(struct mod_sgm775_dmc500_reg *dmc,
     dmc->PHY_CONFIG = 0x01000000;
     dmc->PHY_CONFIG = 0x00000003;
 
-    FWK_LOG_TRACE(log_api, "[DDR] Doing direct DDR commands\n");
+    FWK_LOG_INFO("[DDR] Doing direct DDR commands");
 
     dmc->DIRECT_CMD_SETTINGS = 0x00C80000;
     dmc->DIRECT_CMD = 0x00000000;
@@ -304,7 +296,7 @@ static int sgm775_dmc500_config(struct mod_sgm775_dmc500_reg *dmc,
     dmc->DIRECT_CMD = 0x00D60DE6;
     dmc->REFRESH_ENABLE = 0x00000001;
 
-    FWK_LOG_TRACE(log_api, "[DDR] Setting dmc in READY mode\n");
+    FWK_LOG_INFO("[DDR] Setting dmc in READY mode");
 
     status = timer_api->time_to_timestamp(module_config->timer_id,
                                           TIMEOUT_DMC_INIT_US, &timeout);
@@ -333,7 +325,7 @@ static int sgm775_dmc500_config(struct mod_sgm775_dmc500_reg *dmc,
     dmc->SI0_SI_STATE_CONTROL = 0x00000000;
     dmc->SI1_SI_STATE_CONTROL = 0x00000000;
 
-    FWK_LOG_TRACE(log_api, "[DDR] Waiting for Queue stall = 0...\n");
+    FWK_LOG_INFO("[DDR] Waiting for Queue stall = 0...");
 
     while ((dmc->QUEUE_STATUS & MOD_DMC500_QUEUE_STATUS_STALL_ACK) != 0) {
         status = timer_api->remaining(module_config->timer_id, timeout,
@@ -345,7 +337,7 @@ static int sgm775_dmc500_config(struct mod_sgm775_dmc500_reg *dmc,
             goto timeout;
     }
 
-    FWK_LOG_TRACE(log_api, "[DDR] Waiting for SI0 stall = 0...\n");
+    FWK_LOG_INFO("[DDR] Waiting for SI0 stall = 0...");
 
     while ((dmc->SI0_SI_STATUS & MOD_DMC500_SI_STATUS_STALL_ACK) != 0) {
         status = timer_api->remaining(module_config->timer_id, timeout,
@@ -357,7 +349,7 @@ static int sgm775_dmc500_config(struct mod_sgm775_dmc500_reg *dmc,
             goto timeout;
     }
 
-    FWK_LOG_TRACE(log_api, "[DDR] Waiting for SI1 stall = 0...\n");
+    FWK_LOG_INFO("[DDR] Waiting for SI1 stall = 0...");
 
     while ((dmc->SI1_SI_STATUS & MOD_DMC500_SI_STATUS_STALL_ACK) != 0) {
         status = timer_api->remaining(module_config->timer_id, timeout,
@@ -369,12 +361,12 @@ static int sgm775_dmc500_config(struct mod_sgm775_dmc500_reg *dmc,
             goto timeout;
     }
 
-    FWK_LOG_TRACE(log_api, "[DDR] DMC init done.\n");
+    FWK_LOG_INFO("[DDR] DMC init done.");
 
     return FWK_SUCCESS;
 
 timeout:
-    FWK_LOG_ERR(log_api, "[DDR] Timed out in DMC500 init.\n");
+    FWK_LOG_ERR("[DDR] Timed out in DMC500 init.");
 
     return FWK_E_TIMEOUT;
 }
diff --git a/product/sgm775/scp_ramfw/config_log.c b/product/sgm775/scp_ramfw/config_log.c
index 21f0db3a..b7ea216a 100644
--- a/product/sgm775/scp_ramfw/config_log.c
+++ b/product/sgm775/scp_ramfw/config_log.c
@@ -54,13 +54,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_SCP
-              FWK_BANNER_RAM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_SCP FWK_BANNER_RAM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/sgm775/scp_romfw/config_log.c b/product/sgm775/scp_romfw/config_log.c
index b29e352a..eaf1c80b 100644
--- a/product/sgm775/scp_romfw/config_log.c
+++ b/product/sgm775/scp_romfw/config_log.c
@@ -54,13 +54,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_SCP
-              FWK_BANNER_ROM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_SCP FWK_BANNER_ROM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/sgm776/scp_ramfw/config_log.c b/product/sgm776/scp_ramfw/config_log.c
index c9b92a68..c27e8769 100644
--- a/product/sgm776/scp_ramfw/config_log.c
+++ b/product/sgm776/scp_ramfw/config_log.c
@@ -54,13 +54,8 @@ const struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_SCP
-              FWK_BANNER_RAM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_SCP FWK_BANNER_ROM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 const struct fwk_module_config config_log = {
diff --git a/product/sgm776/scp_romfw/config_log.c b/product/sgm776/scp_romfw/config_log.c
index 2094d98c..9976dd5d 100644
--- a/product/sgm776/scp_romfw/config_log.c
+++ b/product/sgm776/scp_romfw/config_log.c
@@ -53,13 +53,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR |
-                  MOD_LOG_GROUP_INFO |
-                  MOD_LOG_GROUP_WARNING |
-                  MOD_LOG_GROUP_DEBUG,
-    .banner = FWK_BANNER_SCP
-              FWK_BANNER_ROM_FIRMWARE
-              BUILD_VERSION_DESCRIBE_STRING "\n",
+    .banner =
+        FWK_BANNER_SCP FWK_BANNER_ROM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/synquacer/module/ccn512/src/mod_ccn512.c b/product/synquacer/module/ccn512/src/mod_ccn512.c
index de67d421..fb69e0c9 100644
--- a/product/synquacer/module/ccn512/src/mod_ccn512.c
+++ b/product/synquacer/module/ccn512/src/mod_ccn512.c
@@ -23,8 +23,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-static struct mod_log_api *log_api;
-
 #define HNF_COUNT 8
 #define SNF_ID_DMC1 0x8ULL
 #define SNF_ID_DMC3 0x1AULL
@@ -143,7 +141,7 @@ void fw_ccn512_exit(void)
 
     ccn5xx_hnf_reg_t *hnf = &ccn512->HNF_ID_2;
 
-    FWK_LOG_TRACE(log_api, "[CCN512] CCN512 exit.\n");
+    FWK_LOG_INFO("[CCN512] CCN512 exit.");
 
     /* exit ALL CA53 CPU SNOOP */
     for (i = 0; i < HNF_COUNT; i++)
@@ -152,17 +150,16 @@ void fw_ccn512_exit(void)
     /* Wait for write operations to finish. */
     __DMB();
 
-    FWK_LOG_TRACE(log_api, "[CCN512] CCN512 exit end.\n");
+    FWK_LOG_INFO("[CCN512] CCN512 exit end.");
 }
 
 static int ccn512_config(ccn512_reg_t *ccn512)
 {
-    FWK_LOG_TRACE(
-        log_api, "[CCN512] Initialising ccn512 at 0x%x\n", (uintptr_t)ccn512);
+    FWK_LOG_INFO("[CCN512] Initialising ccn512 at 0x%x", (uintptr_t)ccn512);
 
     fw_ccn512_init(ccn512);
 
-    FWK_LOG_TRACE(log_api, "[CCN512] CCN512 init done.\n");
+    FWK_LOG_INFO("[CCN512] CCN512 init done.");
 
     return FWK_SUCCESS;
 }
@@ -192,8 +189,6 @@ static int mod_ccn512_element_init(
 
 static int mod_ccn512_bind(fwk_id_t id, unsigned int round)
 {
-    int status;
-
     /* Nothing to do in the second round of calls. */
     if (round == 1)
         return FWK_SUCCESS;
@@ -202,11 +197,6 @@ static int mod_ccn512_bind(fwk_id_t id, unsigned int round)
     if (fwk_module_is_valid_element_id(id))
         return FWK_SUCCESS;
 
-    status = fwk_module_bind(
-        FWK_ID_MODULE(FWK_MODULE_IDX_LOG), MOD_LOG_API_ID, &log_api);
-    if (status != FWK_SUCCESS)
-        return status;
-
     return FWK_SUCCESS;
 }
 
diff --git a/product/synquacer/module/f_i2c/src/i2c_depend.c b/product/synquacer/module/f_i2c/src/i2c_depend.c
index debec8da..dfe60d32 100644
--- a/product/synquacer/module/f_i2c/src/i2c_depend.c
+++ b/product/synquacer/module/f_i2c/src/i2c_depend.c
@@ -92,10 +92,7 @@ void i2c_construction(void)
             &i2c_params[i]);
         if (i2c_err != I2C_ERR_OK) {
             SCB_Error(i2c_err);
-            FWK_LOG_ERR(
-                synquacer_system_ctx.log_api,
-                "[I2C] I2C ch#%d  initialize error.\n",
-                i);
+            FWK_LOG_ERR("[I2C] I2C ch#%d  initialize error.", i);
         }
     }
 }
diff --git a/product/synquacer/module/hsspi/src/hsspi_api.c b/product/synquacer/module/hsspi/src/hsspi_api.c
index e5b2ade5..e5a869e2 100644
--- a/product/synquacer/module/hsspi/src/hsspi_api.c
+++ b/product/synquacer/module/hsspi/src/hsspi_api.c
@@ -43,9 +43,8 @@ void HSSPI_init(void)
     model_index = CONFIG_SCB_FORCE_HSSPI_RESOURCE_ALLOCATION_MODEL;
 
     FWK_LOG_INFO(
-        synquacer_system_ctx.log_api,
         "[HS-SPI] Configuring HS-SPI controller with "
-        "clk_sel=%d clk_div=%d syncon=%d use_hsspi_cs1_flag=%d msel=%d\n",
+        "clk_sel=%d clk_div=%d syncon=%d use_hsspi_cs1_flag=%d msel=%d",
         clk_config.clk_sel,
         clk_config.clk_div,
         clk_config.syncon,
diff --git a/product/synquacer/module/hsspi/src/hsspi_driver.c b/product/synquacer/module/hsspi/src/hsspi_driver.c
index 7f0cf99c..c95ccc21 100644
--- a/product/synquacer/module/hsspi/src/hsspi_driver.c
+++ b/product/synquacer/module/hsspi/src/hsspi_driver.c
@@ -544,8 +544,7 @@ void hsspi_command_switch(
     hsspi_read_jedec_id(reg_hsspi, mem_hsspi);
 
     FWK_LOG_INFO(
-        synquacer_system_ctx.log_api,
-        "[HS-SPI] CS#0: Manufacturer ID:%02x, DeviceID:%02x%02x\n",
+        "[HS-SPI] CS#0: Manufacturer ID:%02x, DeviceID:%02x%02x",
         m_abyJEDEC_ID[0],
         m_abyJEDEC_ID[1],
         m_abyJEDEC_ID[2]);
@@ -555,9 +554,8 @@ void hsspi_command_switch(
 
     if (known_jedec_id < 0) {
         FWK_LOG_INFO(
-            synquacer_system_ctx.log_api,
             "[HS-SPI] Unknown manufacturer ID:%02x,"
-            " default to Dual-Output-Fast-Read mode\n",
+            " default to Dual-Output-Fast-Read mode",
             m_abyJEDEC_ID[0]);
 
         hsspi_dual_output_fast_read(reg_hsspi);
@@ -566,9 +564,7 @@ void hsspi_command_switch(
         unCSCFG.bit.MBM = HSSPI_EN_CSCFG_MBM_DUAL;
         (*reg_hsspi).CSCFG.DATA = unCSCFG.DATA;
     } else {
-        FWK_LOG_INFO(
-            synquacer_system_ctx.log_api,
-            "[HS-SPI] Configuring Quad-Output-Fast-Read mode\n");
+        FWK_LOG_INFO("[HS-SPI] Configuring Quad-Output-Fast-Read mode");
 
         hsspi_quad_output_fast_read(reg_hsspi);
         unCSCFG.DATA = (*reg_hsspi).CSCFG.DATA;
diff --git a/product/synquacer/module/ppu_v0_synquacer/src/mod_ppu_v0.c b/product/synquacer/module/ppu_v0_synquacer/src/mod_ppu_v0.c
index 04eefb48..3156460f 100644
--- a/product/synquacer/module/ppu_v0_synquacer/src/mod_ppu_v0.c
+++ b/product/synquacer/module/ppu_v0_synquacer/src/mod_ppu_v0.c
@@ -47,9 +47,6 @@ struct ppu_v0_pd_ctx {
 struct ppu_v0_ctx {
     /* Table of the power domain contexts */
     struct ppu_v0_pd_ctx *pd_ctx_table;
-
-    /* Log API */
-    struct mod_log_api *log_api;
 };
 
 /*
@@ -89,15 +86,11 @@ static int get_state(struct ppu_v0_reg *ppu, unsigned int *state)
 
     *state = ppu_mode_to_power_state[ppu_mode];
     if (*state == MODE_UNSUPPORTED) {
-        FWK_LOG_ERR(
-            ppu_v0_ctx.log_api,
-            "[PPUV0] Unexpected PPU mode (%i).\n",
-            ppu_mode);
+        FWK_LOG_ERR("[PPUV0] Unexpected PPU mode (%i).", ppu_mode);
         return FWK_E_DEVICE;
     }
 
-    FWK_LOG_INFO(
-        ppu_v0_ctx.log_api, "[PPUV0] get state reg=0x%x (0x%x)\n", ppu, *state);
+    FWK_LOG_INFO("[PPUV0] get state reg=0x%p (0x%x)", (void *)ppu, *state);
 
     return FWK_SUCCESS;
 }
@@ -117,9 +110,8 @@ static int pd_set_state(fwk_id_t pd_id, unsigned int state)
     pd_ctx = ppu_v0_ctx.pd_ctx_table + fwk_id_get_element_idx(pd_id);
 
     FWK_LOG_INFO(
-        ppu_v0_ctx.log_api,
-        "[PPUV0] set_state start. reg=(0x%x) state=(0x%x)\n",
-        pd_ctx->ppu,
+        "[PPUV0] set_state start. reg=(0x%p) state=(0x%x)",
+        (void *)pd_ctx->ppu,
         state);
 
     switch (state) {
@@ -129,9 +121,8 @@ static int pd_set_state(fwk_id_t pd_id, unsigned int state)
             pd_ctx->bound_id, MOD_PD_STATE_ON);
 
         FWK_LOG_INFO(
-            ppu_v0_ctx.log_api,
-            "[PPUV0] set_state end. reg=(0x%x) state=(0x%x)\n",
-            pd_ctx->ppu,
+            "[PPUV0] set_state end. reg=(0x%p) state=(0x%x)",
+            (void *)pd_ctx->ppu,
             state);
 
         assert(status == FWK_SUCCESS);
@@ -140,8 +131,7 @@ static int pd_set_state(fwk_id_t pd_id, unsigned int state)
     case MOD_PD_STATE_OFF:
         if (pd_ctx->config->pd_type == MOD_PD_TYPE_SYSTEM) {
             FWK_LOG_INFO(
-                ppu_v0_ctx.log_api,
-                "[PPUV0] SYNQUACER SYSTEM module will shutdown the system\n");
+                "[PPUV0] SYNQUACER SYSTEM module will shutdown the system");
             break;
         }
 
@@ -159,9 +149,8 @@ static int pd_set_state(fwk_id_t pd_id, unsigned int state)
             pd_ctx->bound_id, MOD_PD_STATE_OFF);
 
         FWK_LOG_INFO(
-            ppu_v0_ctx.log_api,
-            "[PPUV0] set_state end. reg=(0x%x) state=(0x%x)\n",
-            pd_ctx->ppu,
+            "[PPUV0] set_state end. reg=(0x%p) state=(0x%x)",
+            (void *)pd_ctx->ppu,
             state);
 
         assert(status == FWK_SUCCESS);
@@ -169,9 +158,7 @@ static int pd_set_state(fwk_id_t pd_id, unsigned int state)
 
     default:
         FWK_LOG_ERR(
-            ppu_v0_ctx.log_api,
-            "[PPUV0] Requested power state (%i) is not supported.\n",
-            state);
+            "[PPUV0] Requested power state (%i) is not supported.", state);
         return FWK_E_PARAM;
     }
 
@@ -278,13 +265,8 @@ static int ppu_v0_bind(fwk_id_t id, unsigned int round)
     if (round == 0)
         return FWK_SUCCESS;
 
-    /* In the case of the module, bind to the log component */
-    if (fwk_module_is_valid_module_id(id)) {
-        return fwk_module_bind(
-            FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-            FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-            &ppu_v0_ctx.log_api);
-    }
+    if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE))
+        return FWK_SUCCESS;
 
     pd_ctx = ppu_v0_ctx.pd_ctx_table + fwk_id_get_element_idx(id);
 
diff --git a/product/synquacer/module/scmi_vendor_ext/src/mod_scmi_vendor_ext.c b/product/synquacer/module/scmi_vendor_ext/src/mod_scmi_vendor_ext.c
index 724526f5..6416c086 100644
--- a/product/synquacer/module/scmi_vendor_ext/src/mod_scmi_vendor_ext.c
+++ b/product/synquacer/module/scmi_vendor_ext/src/mod_scmi_vendor_ext.c
@@ -29,7 +29,6 @@
 struct scmi_vendor_ext_ctx {
     const struct mod_scmi_from_protocol_api *scmi_api;
     const struct mod_vendor_ext_api *vendor_ext_api;
-    const struct mod_log_api *log_api;
     uint32_t vendor_ext_count;
 };
 
@@ -200,9 +199,7 @@ static int scmi_vendor_ext_protocol_memory_info_get_handler(
 {
     memset(&resp, 0, sizeof(struct scmi_vendor_ext_memory_info_get_resp));
 
-    FWK_LOG_TRACE(
-        scmi_vendor_ext_ctx.log_api,
-        "[scmi_vendor_ext] memory info get handler.\n");
+    FWK_LOG_INFO("[scmi_vendor_ext] memory info get handler.");
 
     get_memory_info(&resp.meminfo);
 
@@ -233,8 +230,7 @@ static int scmi_vendor_ext_message_handler(
 {
     int32_t return_value;
 
-    FWK_LOG_TRACE(
-        scmi_vendor_ext_ctx.log_api, "[scmi_vendor_ext] message handler.\n");
+    FWK_LOG_INFO("[scmi_vendor_ext] message handler.");
 
     static_assert(
         FWK_ARRAY_SIZE(handler_table) == FWK_ARRAY_SIZE(payload_size_table),
@@ -290,13 +286,6 @@ static int scmi_vendor_ext_bind(fwk_id_t id, unsigned int round)
         return FWK_SUCCESS;
 
     status = fwk_module_bind(
-        FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-        FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-        &scmi_vendor_ext_ctx.log_api);
-    if (status != FWK_SUCCESS)
-        return status;
-
-    status = fwk_module_bind(
         FWK_ID_MODULE(FWK_MODULE_IDX_SCMI),
         FWK_ID_API(FWK_MODULE_IDX_SCMI, MOD_SCMI_API_IDX_PROTOCOL),
         &scmi_vendor_ext_ctx.scmi_api);
@@ -318,9 +307,7 @@ static int scmi_vendor_ext_process_bind_request(
     if (!fwk_id_is_equal(source_id, FWK_ID_MODULE(FWK_MODULE_IDX_SCMI)))
         return FWK_E_ACCESS;
 
-    FWK_LOG_TRACE(
-        scmi_vendor_ext_ctx.log_api,
-        "[scmi_vendor_ext] process bind request.\n");
+    FWK_LOG_INFO("[scmi_vendor_ext] process bind request.");
 
     *api = &scmi_vendor_ext_mod_scmi_to_protocol_api;
 
diff --git a/product/synquacer/module/synquacer_memc/include/ddr_init.h b/product/synquacer/module/synquacer_memc/include/ddr_init.h
index 2bb2fccf..3327541e 100644
--- a/product/synquacer/module/synquacer_memc/include/ddr_init.h
+++ b/product/synquacer/module/synquacer_memc/include/ddr_init.h
@@ -25,10 +25,8 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-#define printf(...) \
-    FWK_LOG_INFO(synquacer_system_ctx.log_api, "[DDR] " __VA_ARGS__)
-#define pr_err(...) \
-    FWK_LOG_ERR(synquacer_system_ctx.log_api, "[DDR] " __VA_ARGS__)
+#define printf(...) FWK_LOG_INFO("[DDR] " __VA_ARGS__)
+#define pr_err(...) FWK_LOG_ERR("[DDR] " __VA_ARGS__)
 
 #define dmb __DMB
 #define usleep(usec) osDelay((usec / 1000) + 2)
diff --git a/product/synquacer/module/synquacer_memc/src/ddr_init.c b/product/synquacer/module/synquacer_memc/src/ddr_init.c
index ff046014..6a8d5f44 100644
--- a/product/synquacer/module/synquacer_memc/src/ddr_init.c
+++ b/product/synquacer/module/synquacer_memc/src/ddr_init.c
@@ -121,13 +121,13 @@ int ddr_ch0_init_mp(void)
 
     g_DDR4_DMC520_INIT_CH = 0;
 
-    printf("Initializing DDR ch0\n");
+    FWK_LOG_INFO("[DDR] Initializing DDR ch0");
 
     ddr_init_mc0_mp(REG_DMC520_0);
 
     /* allocate 60MiB secure DRAM for OP-TEE */
     if (ddr_is_secure_dram_enabled()) {
-        printf("secure DRAM enabled\n");
+        FWK_LOG_INFO("[DDR] secure DRAM enabled");
         REG_DMC520_0->access_address_min0_31_00_next = 0xFC00000C;
         REG_DMC520_0->access_address_min0_43_32_next = 0x00000000;
         REG_DMC520_0->access_address_max0_31_00_next = 0xFFBF0000;
@@ -136,39 +136,39 @@ int ddr_ch0_init_mp(void)
 
     status = ddr_init_phy0_mp(REG_DDRPHY_CONFIG_0, 0);
     if (status != 0) {
-        pr_err("[DDR] ch0 initialize failed. ddr_init_phy0_mp()\n");
+        FWK_LOG_CRIT("[DDR] ch0 initialize failed. ddr_init_phy0_mp()");
         return status;
     }
     status = ddr_init_phy1_mp(REG_DDRPHY_CONFIG_0, 0);
     if (status != 0) {
-        pr_err("[DDR] ch0 initialize failed. ddr_init_phy1_mp()\n");
+        FWK_LOG_CRIT("[DDR] ch0 initialize failed. ddr_init_phy1_mp()");
         return status;
     }
 
     status = ddr_init_sdram_mp(REG_DDRPHY_CONFIG_0, 0);
     if (status != 0) {
-        pr_err("[DDR] ch0 initialize failed. ddr_init_sdram_mp()\n");
+        FWK_LOG_CRIT("[DDR] ch0 initialize failed. ddr_init_sdram_mp()");
         return status;
     }
 
     status = ddr_init_mc1_mp(REG_DMC520_0);
     if (status != 0) {
-        pr_err("[DDR] ch0 initialize failed. ddr_init_mc1_mp()\n");
+        FWK_LOG_CRIT("[DDR] ch0 initialize failed. ddr_init_mc1_mp()");
         return status;
     }
 
     status = ddr_init_train_mp(REG_DDRPHY_CONFIG_0, 0);
     if (status != 0) {
-        pr_err("[DDR] ch0 fatal error occurred.\n");
+        FWK_LOG_CRIT("[DDR] ch0 fatal error occurred.");
         return status;
     }
     status = ddr_init_mc2_mp(REG_DMC520_0);
     if (status != 0) {
-        pr_err("[DDR] ch0 initialize failed. ddr_init_mc1_mp()\n");
+        FWK_LOG_CRIT("[DDR] ch0 initialize failed. ddr_init_mc1_mp()");
         return status;
     }
 
-    printf("Finished initializing DDR ch0\n");
+    FWK_LOG_INFO("[DDR] Finished initializing DDR ch0");
 
     return 0;
 }
@@ -186,51 +186,51 @@ int ddr_ch1_init_mp(void)
 
     g_DDR4_DMC520_INIT_CH = 1;
 
-    printf("Initializing DDR ch1\n");
+    FWK_LOG_INFO("[DDR] Initializing DDR ch1");
 
     status = ddr_init_mc0_mp(REG_DMC520_1);
     if (status != 0) {
-        pr_err("[DDR] ch1 initialize failed. ddr_init_mc0_mp()\n");
+        FWK_LOG_CRIT("[DDR] ch1 initialize failed. ddr_init_mc0_mp()");
         return status;
     }
 
     status = ddr_init_phy0_mp(REG_DDRPHY_CONFIG_1, 0);
     if (status != 0) {
-        pr_err("[DDR] ch1 initialize failed. ddr_init_phy0_mp()\n");
+        FWK_LOG_CRIT("[DDR] ch1 initialize failed. ddr_init_phy0_mp()");
         return status;
     }
 
     status = ddr_init_phy1_mp(REG_DDRPHY_CONFIG_1, 0);
     if (status != 0) {
-        pr_err("[DDR] ch1 initialize failed. ddr_init_phy1_mp()\n");
+        FWK_LOG_CRIT("[DDR] ch1 initialize failed. ddr_init_phy1_mp()");
         return status;
     }
 
     status = ddr_init_sdram_mp(REG_DDRPHY_CONFIG_1, 0);
     if (status != 0) {
-        pr_err("[DDR] ch1 initialize failed. ddr_init_sdram_mp()\n");
+        FWK_LOG_CRIT("[DDR] ch1 initialize failed. ddr_init_sdram_mp()");
         return status;
     }
 
     status = ddr_init_mc1_mp(REG_DMC520_1);
     if (status != 0) {
-        pr_err("[DDR] ch1 initialize failed. ddr_init_mc1_mp()\n");
+        FWK_LOG_CRIT("[DDR] ch1 initialize failed. ddr_init_mc1_mp()");
         return status;
     }
 
     status = ddr_init_train_mp(REG_DDRPHY_CONFIG_1, 0);
     if (status != 0) {
-        pr_err("[DDR] ch1 fatal error occurred.\n");
+        FWK_LOG_CRIT("[DDR] ch1 fatal error occurred.");
         return status;
     }
 
     status = ddr_init_mc2_mp(REG_DMC520_1);
     if (status != 0) {
-        pr_err("[DDR] ch1 initialize failed. ddr_init_mc2_mp()\n");
+        FWK_LOG_CRIT("[DDR] ch1 initialize failed. ddr_init_mc2_mp()");
         return status;
     }
 
-    printf("Finished initializing DDR ch1\n");
+    FWK_LOG_INFO("[DDR] Finished initializing DDR ch1");
 
     return 0;
 }
@@ -1159,8 +1159,9 @@ int ddr_init_train_mp(
         0x3001);
 
     if ((REG_DDRPHY_CONFIG->PGSR0 & 0x4FF80000) != 0) {
-        printf(
-            "error : Write Leveling, Gate Training, Write Leveling Adjust\n");
+        FWK_LOG_CRIT(
+            "[DDR] error : Write Leveling, Gate Training, Write Leveling "
+            "Adjust");
         status = 0x3002;
         goto ERROR_END;
     }
@@ -1203,7 +1204,7 @@ int ddr_init_train_mp(
         0x3003);
 
     if ((REG_DDRPHY_CONFIG->PGSR0 & 0x4FF80000) != 0) {
-        printf("error : Data Bit Deskew, Data Eye, Static Read\n");
+        FWK_LOG_CRIT("[DDR] error : Data Bit Deskew, Data Eye, Static Read");
         status = 0x3004;
         goto ERROR_END;
     }
@@ -1231,7 +1232,7 @@ int ddr_init_train_mp(
             0x3005);
 
         if ((REG_DDRPHY_CONFIG->PGSR0 & 0x4FF80000) != 0) {
-            printf("error : VREF Training\n");
+            FWK_LOG_CRIT("[DDR] error : VREF Training");
             status = 0x3006;
             goto ERROR_END;
         }
@@ -1246,43 +1247,43 @@ ERROR_END:
     /////////////////////////////////////////////////////////////////////
     phy_status_0 = REG_DDRPHY_CONFIG->PGSR0;
     if (((phy_status_0 >> 19) & 0x1) == 0x1) {
-        pr_err("%s VREF Training Error\n", __func__);
+        FWK_LOG_CRIT("[DDR] %s VREF Training Error", __func__);
         status = 0x3010;
     }
     if (((phy_status_0 >> 20) & 0x1) == 0x1) {
-        pr_err("%s Impedance Calibration Error\n", __func__);
+        FWK_LOG_CRIT("[DDR] %s Impedance Calibration Error", __func__);
         status = 0x3011;
     }
     if (((phy_status_0 >> 21) & 0x1) == 0x1) {
-        pr_err("%s Write Leveling Error\n", __func__);
+        FWK_LOG_CRIT("[DDR] %s Write Leveling Error", __func__);
         status = 0x3012;
     }
     if (((phy_status_0 >> 22) & 0x1) == 0x1) {
-        pr_err("%s DQS Gate Training Error\n", __func__);
+        FWK_LOG_CRIT("[DDR] %s DQS Gate Training Error", __func__);
         status = 0x3013;
     }
     if (((phy_status_0 >> 23) & 0x1) == 0x1) {
-        pr_err("%s Write Leveling Adjustment Error\n", __func__);
+        FWK_LOG_CRIT("[DDR] %s Write Leveling Adjustment Error", __func__);
         status = 0x3014;
     }
     if (((phy_status_0 >> 24) & 0x1) == 0x1) {
-        pr_err("%s Read Bit Deskew Error\n", __func__);
+        FWK_LOG_CRIT("[DDR] %s Read Bit Deskew Error", __func__);
         status = 0x3015;
     }
     if (((phy_status_0 >> 25) & 0x1) == 0x1) {
-        pr_err("%s Write Bit Deskew Error\n", __func__);
+        FWK_LOG_CRIT("[DDR] %s Write Bit Deskew Error", __func__);
         status = 0x3016;
     }
     if (((phy_status_0 >> 26) & 0x1) == 0x1) {
-        pr_err("%s Read Eye Training Error\n", __func__);
+        FWK_LOG_CRIT("[DDR] %s Read Eye Training Error", __func__);
         status = 0x3017;
     }
     if (((phy_status_0 >> 27) & 0x1) == 0x1) {
-        pr_err("%s Write Eye Training Error\n", __func__);
+        FWK_LOG_CRIT("[DDR] %s Write Eye Training Error", __func__);
         status = 0x3018;
     }
     if (((phy_status_0 >> 30) & 0x1) == 0x1) {
-        pr_err("%s Static Read Error\n", __func__);
+        FWK_LOG_CRIT("[DDR] %s Static Read Error", __func__);
         status = 0x3019;
     }
 
diff --git a/product/synquacer/module/synquacer_memc/src/mod_synquacer_memc.c b/product/synquacer/module/synquacer_memc/src/mod_synquacer_memc.c
index 0345e863..5e8fbb09 100644
--- a/product/synquacer/module/synquacer_memc/src/mod_synquacer_memc.c
+++ b/product/synquacer/module/synquacer_memc/src/mod_synquacer_memc.c
@@ -16,7 +16,6 @@
 #include <fwk_status.h>
 
 const struct mod_f_i2c_api *f_i2c_api;
-static struct mod_log_api *log_api;
 static int synquacer_memc_config(void);
 
 /* Framework API */
@@ -49,11 +48,6 @@ static int mod_synquacer_memc_bind(fwk_id_t id, unsigned int round)
         return FWK_SUCCESS;
 
     status = fwk_module_bind(
-        FWK_ID_MODULE(FWK_MODULE_IDX_LOG), MOD_LOG_API_ID, &log_api);
-    if (status != FWK_SUCCESS)
-        return status;
-
-    status = fwk_module_bind(
         FWK_ID_MODULE(FWK_MODULE_IDX_F_I2C),
         FWK_ID_API(FWK_MODULE_IDX_F_I2C, 0),
         &f_i2c_api);
@@ -73,7 +67,7 @@ static int synquacer_memc_config(void)
 {
     fw_ddr_init();
 
-    FWK_LOG_INFO(log_api, "[SYNQUACER MEMC] DMC init done.\n");
+    FWK_LOG_INFO("[SYNQUACER MEMC] DMC init done.");
 
     return FWK_SUCCESS;
 }
diff --git a/product/synquacer/module/synquacer_memc/src/synquacer_ddr.c b/product/synquacer/module/synquacer_memc/src/synquacer_ddr.c
index 5aabfcfc..c59005b7 100644
--- a/product/synquacer/module/synquacer_memc/src/synquacer_ddr.c
+++ b/product/synquacer/module/synquacer_memc/src/synquacer_ddr.c
@@ -26,6 +26,7 @@
 #include <fwk_log.h>
 #include <fwk_status.h>
 
+#include <inttypes.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <string.h>
@@ -113,19 +114,16 @@ void fw_ddr_init(void)
     if (result != 0) {
         /* Tentative workaround. Need to implement retrying. */
         do {
-            FWK_LOG_ERR(
-                synquacer_system_ctx.log_api,
-                "DDR Initialize Failed.(0x%x)\n",
-                result);
+            FWK_LOG_ERR("DDR Initialize Failed.(0x%x)", result);
             osDelay(10000);
         } while (1);
     }
 
     if (fw_get_ddr4_sdram_ecc_available() && dram_ecc_is_enabled()) {
-        FWK_LOG_INFO(synquacer_system_ctx.log_api, "[DDR] DRAM ECC enabled\n");
+        FWK_LOG_INFO("[DDR] DRAM ECC enabled");
         dram_init_for_ecc();
     } else {
-        FWK_LOG_INFO(synquacer_system_ctx.log_api, "[DDR] DRAM ECC disabled\n");
+        FWK_LOG_INFO("[DDR] DRAM ECC disabled");
     }
 
     /*
@@ -143,28 +141,27 @@ static void fw_ddr_change_freq(ddr_freq_t freq)
 
     switch (freq) {
     case DDR_FREQ_1333:
-        FWK_LOG_INFO(synquacer_system_ctx.log_api, "[DDR] 1333MHz\n");
+        FWK_LOG_INFO("[DDR] 1333MHz");
         value = 0x00000027U; /* 1333MHz */
         break;
     case DDR_FREQ_1600:
-        FWK_LOG_INFO(synquacer_system_ctx.log_api, "[DDR] 1600MHz\n");
+        FWK_LOG_INFO("[DDR] 1600MHz");
         value = 0x0000002FU; /* 1600MHz */
         break;
     case DDR_FREQ_1800:
-        FWK_LOG_INFO(synquacer_system_ctx.log_api, "[DDR] 1800MHz\n");
+        FWK_LOG_INFO("[DDR] 1800MHz");
         value = 0x00000035U; /* 1800MHz */
         break;
     case DDR_FREQ_1866:
-        FWK_LOG_INFO(synquacer_system_ctx.log_api, "[DDR] 1866MHz\n");
+        FWK_LOG_INFO("[DDR] 1866MHz");
         value = 0x00000037U; /* 1866MHz */
         break;
     case DDR_FREQ_2133:
-        FWK_LOG_INFO(synquacer_system_ctx.log_api, "[DDR] 2133MHz\n");
+        FWK_LOG_INFO("[DDR] 2133MHz");
         value = 0x0000003FU; /* 2133MHz */
         break;
     default:
-        FWK_LOG_INFO(
-            synquacer_system_ctx.log_api, "[DDR] Invalid DDR frequency\n");
+        FWK_LOG_INFO("[DDR] Invalid DDR frequency");
         assert(false);
     }
 
@@ -235,17 +232,13 @@ static spd_read_err_code_t read_spd(
         i2c_err = f_i2c_api->recv_data(
             I2C_EN_CH0, i2c_slave_addr_read_spd, 0, dst, read_len);
         if (i2c_err == I2C_ERR_UNAVAILABLE) {
-            FWK_LOG_TRACE(
-                synquacer_system_ctx.log_api,
-                "[SYSTEM] slot DIMM%d: not detected\n",
-                slot);
+            FWK_LOG_INFO("[SYSTEM] slot DIMM%" PRIu32 ": not detected", slot);
             return SPD_READ_SLOT_NONE;
         }
         if (i2c_err != I2C_ERR_OK) {
             FWK_LOG_INFO(
-                synquacer_system_ctx.log_api,
                 "[SYSTEM] Error detected while reading the first byte of SPD. "
-                "slave_addr:0x%02x, errror code = %d\n",
+                "slave_addr:0x%02" PRIx32 ", errror code = %d",
                 i2c_slave_addr_read_spd,
                 i2c_err);
             return SPD_READ_ERROR;
@@ -294,8 +287,7 @@ bool fw_spd_ddr_info_get(spd_ddr_info_t *spd_ddr_info_p)
         if ((spd_ddr_info_p->base_module_type != 0) &&
             (spd_ddr_info_p->base_module_type != (buf[3] & 0x0F))) {
             /* error! mixed base module memory */
-            FWK_LOG_ERR(
-                synquacer_system_ctx.log_api, "[ERROR] use same sdram type!\n");
+            FWK_LOG_ERR("[ERROR] use same sdram type!");
             error_flag = true;
             return error_flag;
         } else {
@@ -327,9 +319,7 @@ bool fw_spd_ddr_info_get(spd_ddr_info_t *spd_ddr_info_p)
 
         /* DDR4 package Type check */
         if ((buf[6] & 0x3) == 0x02 || (buf[6] & 0x3) == 0x03) {
-            FWK_LOG_ERR(
-                synquacer_system_ctx.log_api,
-                "[ERROR] not support sdram type!\n");
+            FWK_LOG_ERR("[ERROR] not support sdram type!");
             error_flag = true;
             return error_flag;
         }
@@ -349,8 +339,7 @@ bool fw_spd_ddr_info_get(spd_ddr_info_t *spd_ddr_info_p)
             << 8;
         spd_ddr_info_p->slot_bitmap |= (1 << check_dimm_slot);
         FWK_LOG_INFO(
-            synquacer_system_ctx.log_api,
-            "[SYSTEM] slot DIMM%d: %dMB %s %s\n",
+            "[SYSTEM] slot DIMM%d: %" PRIu32 "MB %s %s",
             check_dimm_slot,
             spd_ddr_info_p->sdram_slot_total[check_dimm_slot],
             dimm_module_type[spd_ddr_info_p->base_module_type],
@@ -419,9 +408,7 @@ bool fw_spd_rdimm_support_check(spd_ddr_info_t *spd_ddr_info_p)
 
     /* non support dimm slot layout! */
     default:
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "[ERROR] read spd at sdram non support dimm slot layout!\n");
+        FWK_LOG_ERR("[ERROR] read spd at sdram non support dimm slot layout!");
         error_flag = true;
         return error_flag;
     }
@@ -443,9 +430,7 @@ bool fw_spd_udimm_support_check(spd_ddr_info_t *spd_ddr_info_p)
         break;
 
     default:
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "[ERROR] non support capability dimm!\n");
+        FWK_LOG_ERR("[ERROR] non support capability dimm!");
         error_flag = true;
         return error_flag;
     }
@@ -468,9 +453,7 @@ bool fw_spd_udimm_support_check(spd_ddr_info_t *spd_ddr_info_p)
 
     /* non support dimm slot layout! */
     default:
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "[ERROR] read spd at sdram non support dimm slot layout!\n");
+        FWK_LOG_ERR("[ERROR] read spd at sdram non support dimm slot layout!");
         error_flag = true;
         return error_flag;
     }
@@ -491,9 +474,7 @@ bool fw_spd_72bitsoudimm_support_check(spd_ddr_info_t *spd_ddr_info_p)
         break;
 
     default:
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "[ERROR] non support capability dimm!\n");
+        FWK_LOG_ERR("[ERROR] non support capability dimm!");
         error_flag = true;
         return error_flag;
     }
@@ -517,9 +498,7 @@ bool fw_spd_72bitsoudimm_support_check(spd_ddr_info_t *spd_ddr_info_p)
     /* non support dimm slot layout! */
     default:
         error_flag = true;
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "[ERROR] read spd at sdram non support dimm slot layout!\n");
+        FWK_LOG_ERR("[ERROR] read spd at sdram non support dimm slot layout!");
     }
 
     return error_flag;
@@ -538,9 +517,7 @@ bool fw_spd_read_dimm_capacity_check(spd_ddr_info_t *spd_ddr_info_p)
             if ((spd_ddr_info_p->per_slot_dimm_size != 0) &&
                 (spd_ddr_info_p->per_slot_dimm_size !=
                  spd_ddr_info_p->sdram_slot_total[i])) {
-                FWK_LOG_ERR(
-                    synquacer_system_ctx.log_api,
-                    "[ERROR] Please use same capacity DDR memory!\n");
+                FWK_LOG_ERR("[ERROR] Please use same capacity DDR memory!");
                 error_flag = true;
                 return error_flag;
             }
@@ -575,9 +552,7 @@ bool fw_spd_read_dimm_kinds_check(spd_ddr_info_t *spd_ddr_info_p)
 
     /* other type memory module */
     default:
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "[ERROR] sdram other type memory module\n");
+        FWK_LOG_ERR("[ERROR] sdram other type memory module");
         error_flag = true;
         return error_flag;
     }
@@ -592,8 +567,7 @@ bool fw_spd_read_dimm_kinds_check(spd_ddr_info_t *spd_ddr_info_p)
 
 int fw_ddr_spd_param_check(void)
 {
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api, "[SYSTEM] Starting check DRAM\n");
+    FWK_LOG_INFO("[SYSTEM] Starting check DRAM");
 
     if (fw_spd_ddr_info_get(&spd_ddr_info))
         return FWK_E_SUPPORT;
@@ -605,8 +579,7 @@ int fw_ddr_spd_param_check(void)
         return FWK_E_SUPPORT;
 
     FWK_LOG_INFO(
-        synquacer_system_ctx.log_api,
-        "[SYSTEM] Finished check DRAM memory total %dGB\n",
+        "[SYSTEM] Finished check DRAM memory total %" PRIu32 "GB",
         (config_ddr4_sdram_total_size / 1024));
 
     return FWK_SUCCESS;
@@ -688,8 +661,7 @@ static void dma330_zero_clear(
     REG_DMA330_S->INTEN = 0xffffffffU;
 
     while (REG_DMA330_S->DBGSTATUS != 0) {
-        FWK_LOG_INFO(
-            synquacer_system_ctx.log_api, "[SYSTEM] Wait DMA330 busy.\n");
+        FWK_LOG_INFO("[SYSTEM] Wait DMA330 busy.");
         osDelay(10);
     }
 
@@ -841,9 +813,7 @@ static void dram_init_for_ecc(void)
 
     dram_size = (uint64_t)config_ddr4_sdram_total_size * 1024 * 1024;
 
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api,
-        "[DDR] Initializing DRAM for ECC\nNow Initializing[");
+    FWK_LOG_INFO("[DDR] Initializing DRAM for ECC\nNow Initializing[");
 
     dma330_wrapper_init();
 
@@ -852,7 +822,7 @@ static void dram_init_for_ecc(void)
          (dst_ddr_addr < DRAM_AREA_1_END_ADDR) && (dram_size != 0);
          dma_dst_addr += DMA330_ERASE_BLOCK_SIZE) {
         if ((dst_ddr_addr & 0x3fffffffULL) == 0)
-            FWK_LOG_INFO(synquacer_system_ctx.log_api, "+");
+            FWK_LOG_INFO("[DDR] +");
 
         dma330_zero_clear(0xce000000U, dma_dst_addr);
         dst_ddr_addr += DMA330_ERASE_BLOCK_SIZE;
@@ -864,7 +834,7 @@ static void dram_init_for_ecc(void)
          (dst_ddr_addr < DRAM_AREA_2_END_ADDR) && (dram_size != 0);
          dma_dst_addr += DMA330_ERASE_BLOCK_SIZE) {
         if ((dst_ddr_addr & 0x3fffffffULL) == 0)
-            FWK_LOG_INFO(synquacer_system_ctx.log_api, "-");
+            FWK_LOG_INFO("[DDR] -");
 
         if ((dst_ddr_addr & 0x1fffffffULL) == 0) {
             dmab_mmu500_init(dst_ddr_addr);
@@ -881,7 +851,7 @@ static void dram_init_for_ecc(void)
          (dst_ddr_addr < DRAM_AREA_3_END_ADDR) && (dram_size != 0);
          dma_dst_addr += DMA330_ERASE_BLOCK_SIZE) {
         if ((dst_ddr_addr & 0x3fffffffULL) == 0)
-            FWK_LOG_INFO(synquacer_system_ctx.log_api, "x");
+            FWK_LOG_INFO("[DDR] x");
 
         if ((dst_ddr_addr & 0x1fffffffULL) == 0) {
             dmab_mmu500_init(dst_ddr_addr);
@@ -893,9 +863,7 @@ static void dram_init_for_ecc(void)
         dram_size -= DMA330_ERASE_BLOCK_SIZE;
     }
 
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api,
-        "]\n[DDR] Finished initializing DRAM for ECC\n");
+    FWK_LOG_INFO("[DDR] Finished initializing DRAM for ECC");
 
     (void)addr_trans(0x00800U, TEST_SIZE, false);
     (void)addr_trans(0x008ffU, TEST_SIZE, false);
diff --git a/product/synquacer/module/synquacer_rom/src/mod_synquacer_rom.c b/product/synquacer/module/synquacer_rom/src/mod_synquacer_rom.c
index 48104288..17e94ad4 100644
--- a/product/synquacer/module/synquacer_rom/src/mod_synquacer_rom.c
+++ b/product/synquacer/module/synquacer_rom/src/mod_synquacer_rom.c
@@ -22,7 +22,6 @@
 void synquacer_system_init(void);
 
 static const struct synquacer_rom_config *rom_config;
-static struct mod_log_api *log_api;
 
 enum rom_event { ROM_EVENT_RUN, ROM_EVENT_COUNT };
 
@@ -66,25 +65,6 @@ static int synquacer_rom_init(
     return FWK_SUCCESS;
 }
 
-static int synquacer_rom_bind(fwk_id_t id, unsigned int round)
-{
-    int status;
-
-    /* Use second round only (round numbering is zero-indexed) */
-    if (round == 1) {
-        /* Bind to the log component */
-        status = fwk_module_bind(
-            FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-            FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-            &log_api);
-
-        if (status != FWK_SUCCESS)
-            return FWK_E_PANIC;
-    }
-
-    return FWK_SUCCESS;
-}
-
 static int synquacer_rom_start(fwk_id_t id)
 {
     int status;
@@ -103,7 +83,7 @@ static int synquacer_rom_process_event(
     const struct fwk_event *event,
     struct fwk_event *resp)
 {
-    FWK_LOG_INFO(log_api, "[scp_romfw] Launch scp_ramfw\n");
+    FWK_LOG_INFO("[scp_romfw] Launch scp_ramfw");
 
     if (rom_config->load_ram_size != 0) {
         memcpy(
@@ -123,7 +103,6 @@ const struct fwk_module module_synquacer_rom = {
     .type = FWK_MODULE_TYPE_SERVICE,
     .event_count = ROM_EVENT_COUNT,
     .init = synquacer_rom_init,
-    .bind = synquacer_rom_bind,
     .start = synquacer_rom_start,
     .process_event = synquacer_rom_process_event,
 };
diff --git a/product/synquacer/module/synquacer_system/include/mod_synquacer_system.h b/product/synquacer/module/synquacer_system/include/mod_synquacer_system.h
index a9a36619..694c8a9f 100644
--- a/product/synquacer/module/synquacer_system/include/mod_synquacer_system.h
+++ b/product/synquacer/module/synquacer_system/include/mod_synquacer_system.h
@@ -59,9 +59,6 @@ enum mod_synquacer_system_api_idx {
  * \brief Module Context
  */
 struct synquacer_system_ctx {
-    /*! pointer to the log module. */
-    const struct mod_log_api *log_api;
-
     /*! pointer to the power domain module. */
     const struct mod_pd_restricted_api *mod_pd_restricted_api;
 
diff --git a/product/synquacer/module/synquacer_system/src/gpio.c b/product/synquacer/module/synquacer_system/src/gpio.c
index 6c496c0b..eb4a0ffd 100644
--- a/product/synquacer/module/synquacer_system/src/gpio.c
+++ b/product/synquacer/module/synquacer_system/src/gpio.c
@@ -17,6 +17,7 @@
 #include <fwk_log.h>
 #include <fwk_macros.h>
 
+#include <inttypes.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ -27,11 +28,7 @@ static const uint8_t gpio_function[] = CONFIG_SCB_GPIO_FUNCTION;
 void prmux_set_pingrp(void *prmux_base_addr, uint32_t idx, uint32_t pingrp)
 {
     if (idx > PRMUX_MAX_IDX) {
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "Error@%s idx(%d) too big\n",
-            __func__,
-            idx);
+        FWK_LOG_ERR("Error@%s idx(%" PRIu32 ") too big", __func__, idx);
         return;
     }
 
@@ -41,11 +38,7 @@ void prmux_set_pingrp(void *prmux_base_addr, uint32_t idx, uint32_t pingrp)
 void gpio_set_data(void *gpio_base_addr, uint32_t idx, uint8_t value)
 {
     if (idx > GPIO_MAX_IDX) {
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "Error@%s idx(%d) too big\n",
-            __func__,
-            idx);
+        FWK_LOG_ERR("Error@%s idx(%" PRIu32 ") too big", __func__, idx);
         return;
     }
 
@@ -55,11 +48,7 @@ void gpio_set_data(void *gpio_base_addr, uint32_t idx, uint8_t value)
 uint8_t gpio_get_data(void *gpio_base_addr, uint32_t idx)
 {
     if (idx > GPIO_MAX_IDX) {
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "Error@%s idx(%d) too big\n",
-            __func__,
-            idx);
+        FWK_LOG_ERR("Error@%s idx(%" PRIu32 ") too big", __func__, idx);
         return 0;
     }
 
@@ -69,11 +58,7 @@ uint8_t gpio_get_data(void *gpio_base_addr, uint32_t idx)
 void gpio_set_direction(void *gpio_base_addr, uint32_t idx, uint8_t value)
 {
     if (idx > GPIO_MAX_IDX) {
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "Error@%s idx(%d) too big\n",
-            __func__,
-            idx);
+        FWK_LOG_ERR("Error@%s idx(%" PRIu32 ") too big", __func__, idx);
         return;
     }
 
@@ -83,11 +68,7 @@ void gpio_set_direction(void *gpio_base_addr, uint32_t idx, uint8_t value)
 uint8_t gpio_get_direction(void *gpio_base_addr, uint32_t idx)
 {
     if (idx > GPIO_MAX_IDX) {
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "Error@%s idx(%d) too big\n",
-            __func__,
-            idx);
+        FWK_LOG_ERR("Error@%s idx(%" PRIu32 ") too big", __func__, idx);
         return 0;
     }
 
@@ -97,11 +78,7 @@ uint8_t gpio_get_direction(void *gpio_base_addr, uint32_t idx)
 void gpio_set_function(void *gpio_base_addr, uint32_t idx, uint8_t value)
 {
     if (idx > GPIO_MAX_IDX) {
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "Error@%s idx(%d) too big\n",
-            __func__,
-            idx);
+        FWK_LOG_ERR("Error@%s idx(%" PRIu32 ") too big", __func__, idx);
         return;
     }
 
@@ -111,11 +88,7 @@ void gpio_set_function(void *gpio_base_addr, uint32_t idx, uint8_t value)
 uint8_t gpio_get_function(void *gpio_base_addr, uint32_t idx)
 {
     if (idx > GPIO_MAX_IDX) {
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "Error@%s idx(%d) too big\n",
-            __func__,
-            idx);
+        FWK_LOG_ERR("Error@%s idx(%" PRIu32 ") too big", __func__, idx);
         return 0;
     }
 
@@ -130,15 +103,14 @@ void fw_gpio_init(void)
     uint32_t gpio_desc_num;
     const struct sysdef_option_gpio_desc *gpio_desc_p;
 
-    FWK_LOG_INFO(synquacer_system_ctx.log_api, "[SYSTEM] Setting up PRMUX\n");
+    FWK_LOG_INFO("[SYSTEM] Setting up PRMUX");
     for (i = 0; i < FWK_ARRAY_SIZE(prmux_pingrp); i++) {
         prmux_set_pingrp(
             (void *)CONFIG_SOC_PRMUX_BASE_ADDR, i, prmux_pingrp[i]);
     }
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api, "[SYSTEM] Finished setting up PRMUX\n");
+    FWK_LOG_INFO("[SYSTEM] Finished setting up PRMUX");
 
-    FWK_LOG_INFO(synquacer_system_ctx.log_api, "[SYSTEM] Setting up GPIO\n");
+    FWK_LOG_INFO("[SYSTEM] Setting up GPIO");
     for (i = 0; i < FWK_ARRAY_SIZE(gpio_function); i++)
         gpio_set_function((void *)CONFIG_SOC_AP_GPIO_BASE, i, gpio_function[i]);
 
@@ -146,8 +118,7 @@ void fw_gpio_init(void)
         gpio_set_direction(
             (void *)CONFIG_SOC_AP_GPIO_BASE, i, gpio_direction[i]);
 
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api, "[SYSTEM] Finished setting up GPIO\n");
+    FWK_LOG_INFO("[SYSTEM] Finished setting up GPIO");
 
     gpio_initial_values =
         (gpio_get_data((void *)CONFIG_SOC_AP_GPIO_BASE, 3) << 24) |
@@ -156,8 +127,7 @@ void fw_gpio_init(void)
         gpio_get_data((void *)CONFIG_SOC_AP_GPIO_BASE, 0);
 
     FWK_LOG_INFO(
-        synquacer_system_ctx.log_api,
-        "[SYSTEM] Initial GPIO input values = 0x%08x: ",
+        "[SYSTEM] Initial GPIO input values = 0x%08" PRIx32 ": ",
         gpio_initial_values);
 
     gpio_desc_num = sysdef_option_get_gpio_desc(&gpio_desc_p);
@@ -165,10 +135,8 @@ void fw_gpio_init(void)
         if (((gpio_initial_values >> gpio_desc_p->pin_no) & 0x1) ==
             (gpio_desc_p->inv ? 1 : 0)) {
             /* prepend "!" if the target signal is not asserted */
-            FWK_LOG_INFO(synquacer_system_ctx.log_api, "!");
+            FWK_LOG_INFO("!");
         }
-        FWK_LOG_INFO(synquacer_system_ctx.log_api, "%s ", gpio_desc_p->str);
+        FWK_LOG_INFO("%s ", gpio_desc_p->str);
     }
-
-    FWK_LOG_INFO(synquacer_system_ctx.log_api, "\n");
 }
diff --git a/product/synquacer/module/synquacer_system/src/load_secure_fw.c b/product/synquacer/module/synquacer_system/src/load_secure_fw.c
index 4eded931..54949044 100644
--- a/product/synquacer/module/synquacer_system/src/load_secure_fw.c
+++ b/product/synquacer/module/synquacer_system/src/load_secure_fw.c
@@ -13,6 +13,7 @@
 #include <fwk_log.h>
 #include <fwk_macros.h>
 
+#include <inttypes.h>
 #include <stdint.h>
 #include <string.h>
 
@@ -80,13 +81,11 @@ static void fw_fip_load_bl32(void)
             (void *)bl32_uuid,
             (void *)fip_package_p->fip_toc_entry[BL32_TOC_ENTRY_INDEX].uuid,
             sizeof(bl32_uuid)) != 0) {
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "[FIP] BL32 UUID is wrong, skip loading\n");
+        FWK_LOG_ERR("[FIP] BL32 UUID is wrong, skip loading");
         return;
     }
 
-    FWK_LOG_ERR(synquacer_system_ctx.log_api, "[FIP] load BL32\n");
+    FWK_LOG_ERR("[FIP] load BL32");
 
     /* enable DRAM access by configuring address trans register */
     trans_addr_39_20 =
@@ -105,7 +104,7 @@ static void fw_fip_load_bl32(void)
     *((volatile uint32_t *)(REG_ASH_SCP_POW_CTL + ADDR_TRANS_OFFSET)) =
         trans_addr_39_20;
 
-    FWK_LOG_ERR(synquacer_system_ctx.log_api, "[FIP] BL32 is loaded\n");
+    FWK_LOG_ERR("[FIP] BL32 is loaded");
 }
 
 void fw_fip_load_arm_tf(void)
@@ -128,27 +127,23 @@ void fw_fip_load_arm_tf(void)
         "sizeof(arm_tf_fip_package_t) is wrong");
 
     for (i = 0; i < FWK_ARRAY_SIZE(arm_tf_dst_addr); i++) {
-        FWK_LOG_TRACE(
-            synquacer_system_ctx.log_api,
-            "[FIP] fip_toc_entry[%d] offset_addr %lx\n",
+        FWK_LOG_INFO(
+            "[FIP] fip_toc_entry[%" PRIu32 "] offset_addr %" PRIx64,
             i,
             fip_package_p->fip_toc_entry[i].offset_addr);
 
-        FWK_LOG_TRACE(
-            synquacer_system_ctx.log_api,
-            "[FIP] fip_toc_entry[%d] size        %lu\n",
+        FWK_LOG_INFO(
+            "[FIP] fip_toc_entry[%" PRIu32 "] size        %" PRIu64,
             i,
             fip_package_p->fip_toc_entry[i].size);
 
-        FWK_LOG_TRACE(
-            synquacer_system_ctx.log_api,
-            "[FIP] dst addr[%d]                  %x\n",
+        FWK_LOG_INFO(
+            "[FIP] dst addr[%" PRIu32 "]                  %" PRIx32,
             i,
             arm_tf_dst_addr[i]);
 
-        FWK_LOG_TRACE(
-            synquacer_system_ctx.log_api,
-            "[FIP] src addr[%d]                  %x\n",
+        FWK_LOG_INFO(
+            "[FIP] src addr[%" PRIu32 "]                  %" PRIx32,
             i,
             ((uint32_t)fip_package_p +
              (uint32_t)fip_package_p->fip_toc_entry[i].offset_addr));
diff --git a/product/synquacer/module/synquacer_system/src/mmu500.c b/product/synquacer/module/synquacer_system/src/mmu500.c
index 4232fcfa..e612aba9 100644
--- a/product/synquacer/module/synquacer_system/src/mmu500.c
+++ b/product/synquacer/module/synquacer_system/src/mmu500.c
@@ -11,6 +11,8 @@
 
 #include <fwk_log.h>
 
+#include <inttypes.h>
+
 void SMMU_setup_PMU(MMU500_Type_t *SMMU)
 {
     volatile uint32_t *pmu_regs;
@@ -31,10 +33,10 @@ void SMMU_setup_PMU(MMU500_Type_t *SMMU)
     pmu_regs[0x0800 / 4] = 0x00000800U; /* PMCGCR0: enable=1, global_basis */
     pmu_regs[0x0e04 / 4] = 0x00000003U; /* PMCR: enable=1, reset=1 */
 
-    FWK_LOG_TRACE(
-        synquacer_system_ctx.log_api,
-        "[MMU500] setup PMU for MMU-500@0x%08x. page_size=%d."
-        "0x%08x(access), 0x%08x(read), 0x%08x(write).\n",
+    FWK_LOG_INFO(
+        "[MMU500] setup PMU for MMU-500@0x%08" PRIx32
+        ". page_size=%d. 0x%08" PRIx32 "(access), 0x%08" PRIx32
+        "(read), 0x%08" PRIx32 "(write).",
         (uint32_t)SMMU,
         page_size,
         (uint32_t)&pmu_regs[0],
diff --git a/product/synquacer/module/synquacer_system/src/mod_synquacer_system.c b/product/synquacer/module/synquacer_system/src/mod_synquacer_system.c
index 1d4b1f22..7591d772 100644
--- a/product/synquacer/module/synquacer_system/src/mod_synquacer_system.c
+++ b/product/synquacer/module/synquacer_system/src/mod_synquacer_system.c
@@ -40,9 +40,7 @@ int synquacer_main(void);
 static int synquacer_system_shutdown(
     enum mod_pd_system_shutdown system_shutdown)
 {
-    FWK_LOG_TRACE(
-        synquacer_system_ctx.log_api,
-        "[SYNQUACER SYSTEM] requesting synquacer system_shutdown\n");
+    FWK_LOG_INFO("[SYNQUACER SYSTEM] requesting synquacer system_shutdown");
 
     reboot_chip();
 
@@ -72,13 +70,6 @@ static int synquacer_system_bind(fwk_id_t id, unsigned int round)
 
     if (round == 0) {
         status = fwk_module_bind(
-            FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-            FWK_ID_API(FWK_MODULE_IDX_LOG, 0),
-            &synquacer_system_ctx.log_api);
-        if (status != FWK_SUCCESS)
-            return status;
-
-        status = fwk_module_bind(
             FWK_ID_MODULE(FWK_MODULE_IDX_CCN512),
             FWK_ID_API(FWK_MODULE_IDX_CCN512, 0),
             &synquacer_system_ctx.ccn512_api);
@@ -127,9 +118,7 @@ static int synquacer_system_start(fwk_id_t id)
 
     main_initialize();
 
-    FWK_LOG_TRACE(
-        synquacer_system_ctx.log_api,
-        "[SYNQUACER SYSTEM] Request system initialization.\n");
+    FWK_LOG_INFO("[SYNQUACER SYSTEM] Request system initialization.");
 
     status = fwk_thread_create(FWK_ID_MODULE(FWK_MODULE_IDX_SYNQUACER_SYSTEM));
     if (status != FWK_SUCCESS)
@@ -155,9 +144,7 @@ int synquacer_process_event(
     struct fwk_event *resp)
 {
     if (fwk_id_get_event_idx(event->id) == SYNQUACER_SYSTEM_EVENT_START) {
-        FWK_LOG_TRACE(
-            synquacer_system_ctx.log_api,
-            "[SYNQUACER SYSTEM] Process system start event.\n");
+        FWK_LOG_INFO("[SYNQUACER SYSTEM] Process system start event.");
         synquacer_main();
     }
 
diff --git a/product/synquacer/module/synquacer_system/src/nic400.c b/product/synquacer/module/synquacer_system/src/nic400.c
index d3d959c2..a982a8db 100644
--- a/product/synquacer/module/synquacer_system/src/nic400.c
+++ b/product/synquacer/module/synquacer_system/src/nic400.c
@@ -17,6 +17,7 @@
 #include <fwk_log.h>
 #include <fwk_macros.h>
 
+#include <inttypes.h>
 #include <stdint.h>
 
 #define NIC_TOP_ADDR_SEC_REG (0x00000008)
@@ -27,9 +28,8 @@ static void nic_sec_slave_security(
     uint32_t slave_index,
     uint32_t value)
 {
-    FWK_LOG_TRACE(
-        synquacer_system_ctx.log_api,
-        "%s addr 0x%08x value 0x%08x\n",
+    FWK_LOG_INFO(
+        "%s addr 0x%08" PRIx32 " value 0x%08" PRIx32,
         __func__,
         (nic_top_addr + NIC_TOP_ADDR_SEC_REG +
          NIC_SEC_REG_OFFSET * slave_index),
diff --git a/product/synquacer/module/synquacer_system/src/smmu_config.c b/product/synquacer/module/synquacer_system/src/smmu_config.c
index 3df6856d..6b91bba3 100644
--- a/product/synquacer/module/synquacer_system/src/smmu_config.c
+++ b/product/synquacer/module/synquacer_system/src/smmu_config.c
@@ -101,14 +101,12 @@ uint64_t smmu_convert_to_axi_addr(void *addr_cm3view)
 
 void smmu_wrapper_initialize(void)
 {
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api, "Configure System MMUs starts\n");
+    FWK_LOG_INFO("Configure System MMUs starts");
 
     /* Basic Configuration */
     smmu_wrapper_pcie();
 
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api, "Configure System MMUs finished\n");
+    FWK_LOG_INFO("Configure System MMUs finished");
 }
 
 void smmu_wrapper_pcie(void)
diff --git a/product/synquacer/module/synquacer_system/src/synquacer_main.c b/product/synquacer/module/synquacer_system/src/synquacer_main.c
index eb040c06..2fd768cb 100644
--- a/product/synquacer/module/synquacer_system/src/synquacer_main.c
+++ b/product/synquacer/module/synquacer_system/src/synquacer_main.c
@@ -268,11 +268,9 @@ static void fw_system_reset(void)
 
 int reboot_chip(void)
 {
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api, "[SYNQUACER SYSTEM] HSSPI exit start.\n");
+    FWK_LOG_INFO("[SYNQUACER SYSTEM] HSSPI exit start.");
     synquacer_system_ctx.hsspi_api->hsspi_exit();
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api, "[SYNQUACER SYSTEM] HSSPI exit end.\n");
+    FWK_LOG_INFO("[SYNQUACER SYSTEM] HSSPI exit end.");
 
     __disable_fault_irq();
 
@@ -304,8 +302,7 @@ void main_initialize(void)
     fw_clear_clkforce(sysdef_option_get_clear_clkforce());
 
     FWK_LOG_INFO(
-        synquacer_system_ctx.log_api,
-        "[SYNQUACER SYSTEM] chip version %s.\n",
+        "[SYNQUACER SYSTEM] chip version %s.",
         sysdef_option_get_chip_version());
 
     power_domain_coldboot();
@@ -336,15 +333,10 @@ static void fw_wakeup_ap(void)
     ap_dev_init();
 
     synquacer_system_ctx.hsspi_api->hsspi_init();
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api,
-        "[SYNQUACER SYSTEM] Finished initializing HS-SPI controller.\n");
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api,
-        "[SYNQUACER SYSTEM] Arm tf load start.\n");
+    FWK_LOG_INFO("[SYNQUACER SYSTEM] Finished initializing HS-SPI controller.");
+    FWK_LOG_INFO("[SYNQUACER SYSTEM] Arm tf load start.");
     fw_fip_load_arm_tf();
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api, "[SYNQUACER SYSTEM] Arm tf load end.\n");
+    FWK_LOG_INFO("[SYNQUACER SYSTEM] Arm tf load end.");
 }
 
 int synquacer_main(void)
@@ -355,8 +347,7 @@ int synquacer_main(void)
     pcie_wrapper_configure();
     fw_wakeup_ap();
 
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api, "[SYNQUACER SYSTEM] powering up AP\n");
+    FWK_LOG_INFO("[SYNQUACER SYSTEM] powering up AP");
     status =
         synquacer_system_ctx.mod_pd_restricted_api->set_composite_state_async(
             FWK_ID_ELEMENT(FWK_MODULE_IDX_POWER_DOMAIN, 0),
@@ -369,14 +360,10 @@ int synquacer_main(void)
                 MOD_PD_STATE_ON));
 
     if (status == FWK_SUCCESS)
-        FWK_LOG_INFO(
-            synquacer_system_ctx.log_api,
-            "[SYNQUACER SYSTEM] finished powering up AP\n");
+        FWK_LOG_INFO("[SYNQUACER SYSTEM] finished powering up AP");
     else
         FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "[SYNQUACER SYSTEM] failed to power up AP. status=%d\n",
-            status);
+            "[SYNQUACER SYSTEM] failed to power up AP. status=%d", status);
 
     return status;
 }
diff --git a/product/synquacer/module/synquacer_system/src/synquacer_pd_manage.c b/product/synquacer/module/synquacer_system/src/synquacer_pd_manage.c
index 0b521294..35a802c5 100644
--- a/product/synquacer/module/synquacer_system/src/synquacer_pd_manage.c
+++ b/product/synquacer/module/synquacer_system/src/synquacer_pd_manage.c
@@ -21,6 +21,7 @@
 #include <fwk_log.h>
 #include <fwk_macros.h>
 
+#include <inttypes.h>
 #include <stdbool.h>
 #include <stdint.h>
 
@@ -156,9 +157,7 @@ static void sni_power_domain_workaround_mp(void)
     uint32_t i, j;
     int r;
 
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api,
-        "[PowerDomain] Socionext-PPU initialize .\n");
+    FWK_LOG_INFO("[PowerDomain] Socionext-PPU initialize .");
 
     /* ppu off */
     for (i = 0; i < FWK_ARRAY_SIZE(sni_ppu_info); i++) {
@@ -169,8 +168,8 @@ static void sni_power_domain_workaround_mp(void)
             sni_ppu_info[i].no, PPU_PP_OFF, 0, hwcsysreqen, 0);
         if (r != 0) {
             FWK_LOG_ERR(
-                synquacer_system_ctx.log_api,
-                "[PPU] powerdomain workaround error. sni-ppu%d off-process.\n",
+                "[PPU] powerdomain workaround error. sni-ppu%" PRIu32
+                " off-process.",
                 sni_ppu_info[i].no);
         }
     }
@@ -186,9 +185,8 @@ static void sni_power_domain_workaround_mp(void)
         }
         if (j >= PD_TIMEOUT_COUNT) {
             FWK_LOG_ERR(
-                synquacer_system_ctx.log_api,
-                "[PPU] powerdomain workaround error. sni-ppu%d "
-                "status timeout\n",
+                "[PPU] powerdomain workaround error. sni-ppu%" PRIu32
+                "status timeout",
                 sni_ppu_info[i].no);
         }
     }
@@ -204,9 +202,7 @@ static void sni_power_domain_workaround_mp(void)
     lpcm_sysoc_reset(RST_TYPE_BUS, RST_PCIE_TOP);
     lpcm_sysoc_reset(RST_TYPE_BUS, RST_DMA);
 
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api,
-        "[PowerDomain] Socionext-PPU initialize end .\n");
+    FWK_LOG_INFO("[PowerDomain] Socionext-PPU initialize end .");
 }
 
 static void sni_power_domain_on_mp(uint32_t dev_bitmap)
@@ -215,9 +211,7 @@ static void sni_power_domain_on_mp(uint32_t dev_bitmap)
     uint32_t pmu_bitmap;
     uint32_t transw_reg_bitmap[TRANSW_REG_NUM] = { 0 };
 
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api,
-        "[PowerDomain] PowerDomain All-ON start.\n");
+    FWK_LOG_INFO("[PowerDomain] PowerDomain All-ON start.");
 
     /* pmu cycle time */
     FOR_EACH_PMU_INFO(i)
@@ -265,8 +259,8 @@ static void sni_power_domain_on_mp(uint32_t dev_bitmap)
     r = pmu_wait(pmu_bitmap, true);
     if (r != 0)
         FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "[PPU] sni-pmu timeout expected:(0x%08x) result: (0x%08x).\n",
+            "[PPU] sni-pmu timeout expected:(0x%08" PRIx32
+            ") result: (0x%08" PRIx32 ").",
             pmu_bitmap,
             pmu_read_pd_power_status());
 
@@ -296,31 +290,20 @@ static void sni_power_domain_on_mp(uint32_t dev_bitmap)
         lpcm_sysoc_reset_clear(RST_TYPE_ALL, RST_DDR);
 
     /* set TransactionSW */
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api,
-        "[PowerDomain] Opening transaction switch\n");
+    FWK_LOG_INFO("[PowerDomain] Opening transaction switch");
 
     FOR_EACH_TRANSW_REG(i)
     {
-        FWK_LOG_TRACE(
-            synquacer_system_ctx.log_api,
-            "[PowerDomain] Opening transaction switch + %d\n",
-            i);
+        FWK_LOG_INFO("[PowerDomain] Opening transaction switch + %" PRIu32, i);
 
         set_transactionsw_off(TRANSW_ADDR(i), transw_reg_bitmap[i]);
 
-        FWK_LOG_TRACE(
-            synquacer_system_ctx.log_api,
-            "[PowerDomain] Finished opening transaction switch + %d\n",
-            i);
+        FWK_LOG_INFO(
+            "[PowerDomain] Finished opening transaction switch + %" PRIu32, i);
     }
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api,
-        "[PowerDomain] Finished transaction switch\n");
+    FWK_LOG_INFO("[PowerDomain] Finished transaction switch");
 
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api,
-        "[PowerDomain] PowerDomain All-ON finished.\n");
+    FWK_LOG_INFO("[PowerDomain] PowerDomain All-ON finished.");
 
     /* sni-ppu all on */
     FOR_EACH_PPU_INFO(i)
@@ -331,8 +314,7 @@ static void sni_power_domain_on_mp(uint32_t dev_bitmap)
         r = change_power_state(sni_ppu_info[i].no, PPU_PP_ON, 1, 1, 0);
         if (r != 0) {
             FWK_LOG_ERR(
-                synquacer_system_ctx.log_api,
-                "[PPU] powerdomain error. sni-ppu%d on-process.\n",
+                "[PPU] powerdomain error. sni-ppu%" PRIu32 " on-process.",
                 sni_ppu_info[i].no);
         }
     }
@@ -352,8 +334,7 @@ static void sni_power_domain_on_mp(uint32_t dev_bitmap)
         }
         if (j >= PD_TIMEOUT_COUNT) {
             FWK_LOG_ERR(
-                synquacer_system_ctx.log_api,
-                "[PPU] powerdomain error. sni-ppu%d status timeout.\n",
+                "[PPU] powerdomain error. sni-ppu%" PRIu32 " status timeout.",
                 sni_ppu_info[i].no);
         }
     }
@@ -381,8 +362,7 @@ static void power_domain_on(uint32_t dev_bitmap)
 
 void power_domain_coldboot(void)
 {
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api, "[SYSTEM] Initializing power domain\n");
+    FWK_LOG_INFO("[SYSTEM] Initializing power domain");
     sni_power_domain_workaround_mp();
     power_domain_on(PD_PRESET_COLDBOOT);
 }
diff --git a/product/synquacer/module/synquacer_system/src/sysoc.c b/product/synquacer/module/synquacer_system/src/sysoc.c
index af41610c..75d34010 100644
--- a/product/synquacer/module/synquacer_system/src/sysoc.c
+++ b/product/synquacer/module/synquacer_system/src/sysoc.c
@@ -20,6 +20,7 @@
 #include <fwk_macros.h>
 #include <fwk_status.h>
 
+#include <inttypes.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -204,8 +205,7 @@ void lpcm_sysoc_reset(RST_TYPE_t type, RST_BLOCK block)
         }
         if (i == status_check_num) {
             FWK_LOG_ERR(
-                synquacer_system_ctx.log_api,
-                "[LPCM] Reset timeout.(%dms, %08x)\n",
+                "[LPCM] Reset timeout.(%dms, %08" PRIx32 ")",
                 RESET_TIMEOUT_MS,
                 reset_info[block].addr_lpcm);
         }
@@ -222,8 +222,7 @@ void lpcm_sysoc_reset(RST_TYPE_t type, RST_BLOCK block)
         }
         if (i == status_check_num) {
             FWK_LOG_ERR(
-                synquacer_system_ctx.log_api,
-                "[SYSOC] Reset timeout.(%dms, %08x)\n",
+                "[SYSOC] Reset timeout.(%dms, %08" PRIx32 ")",
                 RESET_TIMEOUT_MS,
                 reset_info[block].addr_sysoc_bus);
         }
@@ -240,8 +239,7 @@ void lpcm_sysoc_reset(RST_TYPE_t type, RST_BLOCK block)
         }
         if (i == status_check_num) {
             FWK_LOG_ERR(
-                synquacer_system_ctx.log_api,
-                "[SYSOC] Reset timeout.(%dms, %08x)\n",
+                "[SYSOC] Reset timeout.(%dms, %08" PRIx32 ")",
                 RESET_TIMEOUT_MS,
                 reset_info[block].addr_sysoc_blk);
         }
@@ -288,8 +286,7 @@ void lpcm_sysoc_reset_clear(RST_TYPE_t type, RST_BLOCK block)
         }
         if (i == status_check_num) {
             FWK_LOG_ERR(
-                synquacer_system_ctx.log_api,
-                "[SYSOC] Reset clear timeout.(%dms, %08x)\n",
+                "[SYSOC] Reset clear timeout.(%dms, %08" PRIx32 ")",
                 RESET_TIMEOUT_MS,
                 reset_info[block].addr_sysoc_blk);
         }
@@ -306,8 +303,7 @@ void lpcm_sysoc_reset_clear(RST_TYPE_t type, RST_BLOCK block)
         }
         if (i == status_check_num) {
             FWK_LOG_ERR(
-                synquacer_system_ctx.log_api,
-                "[SYSOC] Reset clear timeout.(%dms, %08x)\n",
+                "[SYSOC] Reset clear timeout.(%dms, %08" PRIx32 ")",
                 RESET_TIMEOUT_MS,
                 reset_info[block].addr_sysoc_bus);
         }
@@ -323,8 +319,7 @@ void lpcm_sysoc_reset_clear(RST_TYPE_t type, RST_BLOCK block)
         }
         if (i == status_check_num) {
             FWK_LOG_ERR(
-                synquacer_system_ctx.log_api,
-                "[LPCM] Reset clear timeout.(%dms, %08x)\n",
+                "[LPCM] Reset clear timeout.(%dms, %08" PRIx32 ")",
                 RESET_TIMEOUT_MS,
                 reset_info[block].addr_lpcm);
         }
diff --git a/product/synquacer/module/synquacer_system/src/thermal_sensor.c b/product/synquacer/module/synquacer_system/src/thermal_sensor.c
index 12aee5e0..ce788438 100644
--- a/product/synquacer/module/synquacer_system/src/thermal_sensor.c
+++ b/product/synquacer/module/synquacer_system/src/thermal_sensor.c
@@ -17,6 +17,7 @@
 #include <fwk_log.h>
 #include <fwk_status.h>
 
+#include <inttypes.h>
 #include <stdint.h>
 
 #define DELAY_COUNTER 10
@@ -26,8 +27,7 @@ int thermal_enable(void)
     int32_t sensor_num = sysdef_option_get_sensor_num();
     int32_t i = 0;
 
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api, "[THERMAL] Thermal enable start\n");
+    FWK_LOG_INFO("[THERMAL] Thermal enable start");
     writel(THERMAL_BASE_ADDRESS + THERMAL_ALLCONFIG_OFFSET, 0);
     for (i = 0; i < sensor_num; i++) {
         uint32_t sensor_offset = THERMAL_SENSOR_BASE(i);
@@ -35,18 +35,14 @@ int thermal_enable(void)
         writel(sensor_offset + THERMAL_TS_EN_OFFSET, THERMAL_ENABLE);
         if (readl(sensor_offset + THERMAL_TS_EN_OFFSET) == 0) {
             FWK_LOG_INFO(
-                synquacer_system_ctx.log_api,
-                "[THERMAL] Enable individual sensor #%x fail\n",
-                i);
+                "[THERMAL] Enable individual sensor #%" PRIx32 " fail", i);
             return FWK_E_DEVICE;
         }
 
         writel(sensor_offset + THERMAL_TS_RESET_OFFSET, THERMAL_ENABLE);
         if (readl(sensor_offset + THERMAL_TS_RESET_OFFSET) == 0) {
             FWK_LOG_INFO(
-                synquacer_system_ctx.log_api,
-                "[THERMAL] Reset individual sensor #%x fail\n",
-                i);
+                "[THERMAL] Reset individual sensor #%" PRIx32 " fail", i);
             return FWK_E_DEVICE;
         }
     }
@@ -63,7 +59,6 @@ int thermal_enable(void)
         }
     }
 
-    FWK_LOG_INFO(
-        synquacer_system_ctx.log_api, "[THERMAL] Thermal enable end\n");
+    FWK_LOG_INFO("[THERMAL] Thermal enable end");
     return FWK_SUCCESS;
 }
diff --git a/product/synquacer/module/synquacer_system/src/transaction_sw.c b/product/synquacer/module/synquacer_system/src/transaction_sw.c
index 9864be7c..2398b008 100644
--- a/product/synquacer/module/synquacer_system/src/transaction_sw.c
+++ b/product/synquacer/module/synquacer_system/src/transaction_sw.c
@@ -14,6 +14,7 @@
 
 #include <fwk_log.h>
 
+#include <inttypes.h>
 #include <stdint.h>
 
 #define STATUS_ADDR 4
@@ -25,10 +26,7 @@ void set_transactionsw_off(
     unsigned int intsts;
     uint32_t value;
 
-    FWK_LOG_TRACE(
-        synquacer_system_ctx.log_api,
-        "  traSW disable_bit =  %08x\n",
-        disable_bit);
+    FWK_LOG_INFO("  traSW disable_bit =  %08" PRIx32, disable_bit);
 
     DI(intsts);
 
@@ -53,10 +51,7 @@ void set_transactionsw_on(uint32_t transactionsw_reg_addr, uint32_t enable_bit)
     unsigned int intsts;
     uint32_t value;
 
-    FWK_LOG_TRACE(
-        synquacer_system_ctx.log_api,
-        "  traSW enable_bit =  %08x\n",
-        enable_bit);
+    FWK_LOG_INFO("  traSW enable_bit =  %08" PRIx32, enable_bit);
 
     DI(intsts);
 
diff --git a/product/synquacer/scp_ramfw/config_log_f_uart3.c b/product/synquacer/scp_ramfw/config_log_f_uart3.c
index 8e62dd32..24f70400 100644
--- a/product/synquacer/scp_ramfw/config_log_f_uart3.c
+++ b/product/synquacer/scp_ramfw/config_log_f_uart3.c
@@ -49,11 +49,8 @@ struct fwk_module_config config_f_uart3 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_F_UART3, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_F_UART3, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR | MOD_LOG_GROUP_INFO |
-        MOD_LOG_GROUP_WARNING | MOD_LOG_GROUP_DEBUG,
     .banner =
-        FWK_BANNER_SCP FWK_BANNER_RAM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING
-    "\n",
+        FWK_BANNER_SCP FWK_BANNER_RAM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/synquacer/scp_ramfw/config_log_pl011.c b/product/synquacer/scp_ramfw/config_log_pl011.c
index 81392a59..e072b3dc 100644
--- a/product/synquacer/scp_ramfw/config_log_pl011.c
+++ b/product/synquacer/scp_ramfw/config_log_pl011.c
@@ -7,6 +7,7 @@
 
 #include "synquacer_mmap.h"
 
+#include <mod_log.h>
 #include <mod_pl011.h>
 
 #include <fwk_banner.h>
@@ -47,11 +48,8 @@ struct fwk_module_config config_pl011 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_PL011, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_PL011, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR | MOD_LOG_GROUP_INFO |
-        MOD_LOG_GROUP_WARNING | MOD_LOG_GROUP_DEBUG,
     .banner =
-        FWK_BANNER_SCP FWK_BANNER_RAM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING
-    "\n",
+        FWK_BANNER_SCP FWK_BANNER_RAM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {
diff --git a/product/synquacer/scp_ramfw/rtx_config.c b/product/synquacer/scp_ramfw/rtx_config.c
index 21df4f08..cb7fc7bd 100644
--- a/product/synquacer/scp_ramfw/rtx_config.c
+++ b/product/synquacer/scp_ramfw/rtx_config.c
@@ -48,9 +48,7 @@ uint32_t osRtxErrorNotify(uint32_t code, void *object_id)
          * Stack underflow detected for thread
          * thread_id=object_id
          */
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "[SYSTEM] osRtxErrorStackUnderflow.\n");
+        FWK_LOG_ERR("[SYSTEM] osRtxErrorStackUnderflow.");
         break;
 
     case osRtxErrorISRQueueOverflow:
@@ -58,9 +56,7 @@ uint32_t osRtxErrorNotify(uint32_t code, void *object_id)
          * ISR Queue overflow detected when inserting object
          * object_id
          */
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "[SYSTEM] osRtxErrorISRQueueOverflow.\n");
+        FWK_LOG_ERR("[SYSTEM] osRtxErrorISRQueueOverflow.");
         break;
 
     case osRtxErrorTimerQueueOverflow:
@@ -68,9 +64,7 @@ uint32_t osRtxErrorNotify(uint32_t code, void *object_id)
          * User Timer Callback Queue overflow detected for timer
          * timer_id=object_id
          */
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api,
-            "[SYSTEM] osRtxErrorTimerQueueOverflow.\n");
+        FWK_LOG_ERR("[SYSTEM] osRtxErrorTimerQueueOverflow.");
         break;
 
     case osRtxErrorClibSpace:
@@ -78,16 +72,14 @@ uint32_t osRtxErrorNotify(uint32_t code, void *object_id)
          * Standard C/C++ library libspace not available:
          * increase OS_THREAD_LIBSPACE_NUM
          */
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api, "[SYSTEM] osRtxErrorClibSpace.\n");
+        FWK_LOG_ERR("[SYSTEM] osRtxErrorClibSpace.");
         break;
 
     case osRtxErrorClibMutex:
         /*
          * Standard C/C++ library mutex initialization failed
          */
-        FWK_LOG_ERR(
-            synquacer_system_ctx.log_api, "[SYSTEM] oosRtxErrorClibMutex.\n");
+        FWK_LOG_ERR("[SYSTEM] oosRtxErrorClibMutex.");
         break;
 
     default:
diff --git a/product/synquacer/scp_romfw/config_log_f_uart3.c b/product/synquacer/scp_romfw/config_log_f_uart3.c
index 95f00784..7aefe1b4 100644
--- a/product/synquacer/scp_romfw/config_log_f_uart3.c
+++ b/product/synquacer/scp_romfw/config_log_f_uart3.c
@@ -49,11 +49,8 @@ struct fwk_module_config config_f_uart3 = {
 static const struct mod_log_config log_data = {
     .device_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_F_UART3, 0),
     .api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_F_UART3, 0),
-    .log_groups = MOD_LOG_GROUP_ERROR | MOD_LOG_GROUP_INFO |
-        MOD_LOG_GROUP_WARNING | MOD_LOG_GROUP_DEBUG,
     .banner =
-        FWK_BANNER_SCP FWK_BANNER_ROM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING
-    "\n",
+        FWK_BANNER_SCP FWK_BANNER_ROM_FIRMWARE BUILD_VERSION_DESCRIBE_STRING,
 };
 
 struct fwk_module_config config_log = {