diff --git a/module/amu_smcf_drv/test/CMakeLists.txt b/module/amu_smcf_drv/test/CMakeLists.txt
index bcaa58683..342efb944 100644
--- a/module/amu_smcf_drv/test/CMakeLists.txt
+++ b/module/amu_smcf_drv/test/CMakeLists.txt
@@ -1,6 +1,6 @@
 #
 # Arm SCP/MCP Software
-# Copyright (c) 2023, Arm Limited and Contributors. All rights reserved.
+# Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved.
 #
 # SPDX-License-Identifier: BSD-3-Clause
 #
@@ -21,6 +21,7 @@ list(APPEND OTHER_MODULE_INC ${SCP_ROOT}/interface/amu)
 list(APPEND OTHER_MODULE_INC ${MODULE_ROOT}/smcf/include)
 list(APPEND OTHER_MODULE_INC ${MODULE_ROOT}/smcf/src)
 list(APPEND OTHER_MODULE_INC ${MODULE_ROOT}/smcf/test/mocks)
+list(APPEND OTHER_MODULE_INC ${MODULE_ROOT}/timer/include)
 set(MODULE_UT_SRC ${CMAKE_CURRENT_LIST_DIR})
 set(MODULE_UT_INC ${CMAKE_CURRENT_LIST_DIR})
 set(MODULE_UT_MOCK_SRC ${CMAKE_CURRENT_LIST_DIR}/mocks)
diff --git a/module/smcf/include/mod_smcf.h b/module/smcf/include/mod_smcf.h
index 115166e06..004948bb0 100644
--- a/module/smcf/include/mod_smcf.h
+++ b/module/smcf/include/mod_smcf.h
@@ -1,6 +1,6 @@
 /*
  * Arm SCP/MCP Software
- * Copyright (c) 2023, Arm Limited and Contributors. All rights reserved.
+ * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  *
@@ -31,6 +31,30 @@
 /*! Maximum number of mode entries as defined by the hardware spec. */
 #define SMCF_MODE_ENTRY_COUNT 4
 
+/*!
+ * \brief Timer for setting MODE_REQ register.
+ *
+ * \details This structure is required to be filled in SMCF config file only
+ *          when the timeout feature is required.
+ */
+struct mod_smcf_timer_config {
+    /*!
+     * \brief Timer identifier.
+     *
+     * \details Used for binding with the timer API and waiting for specified
+     *          delay after setting the MODE_REQ register.
+     */
+    fwk_id_t timer_id;
+
+    /*!
+     * \brief Timeout value.
+     *
+     * \details MODE_REQ state change wait delay in micro seconds. A valid
+     *          non-zero value has to be specified when using this feature.
+     */
+    uint32_t set_state_timeout_us;
+};
+
 /*!
  * \brief Configuration data of a domain driver
  */
@@ -46,6 +70,9 @@ struct mod_smcf_element_config {
 
     /*! Data location and header format */
     struct mod_smcf_data_config data_config;
+
+    /*! Timer descriptor */
+    struct mod_smcf_timer_config *timer_config;
 };
 
 /*!
diff --git a/module/smcf/src/mgi.c b/module/smcf/src/mgi.c
index 357175f4a..3228f9989 100644
--- a/module/smcf/src/mgi.c
+++ b/module/smcf/src/mgi.c
@@ -1,6 +1,6 @@
 /*
  * Arm SCP/MCP Software
- * Copyright (c) 2023, Arm Limited and Contributors. All rights reserved.
+ * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -10,6 +10,11 @@
 
 #include <stddef.h>
 
+struct mgi_set_monitor_mode_check {
+    uint32_t mode_idx;
+    struct smcf_mgi_reg *smcf_mgi;
+};
+
 /* Get the number of monitors supported by this MGI */
 uint32_t mgi_get_num_of_monitors(struct smcf_mgi_reg *smcf_mgi)
 {
@@ -166,20 +171,19 @@ int mgi_disable_program_mode(struct smcf_mgi_reg *smcf_mgi, uint32_t monitor)
     return FWK_SUCCESS;
 }
 
-/* Set MODE for individual MODE_REQ register */
-int mgi_set_monitor_mode(
-    struct smcf_mgi_reg *smcf_mgi,
-    uint32_t mode_idx,
-    uint32_t value)
+bool mgi_is_monitor_mode_updated(void *data)
 {
-    uint32_t mode_registers_num = mgi_get_number_of_mode_registers(smcf_mgi);
-    uint32_t mode_registers_bits =
-        mgi_get_number_of_bits_in_mode_registers(smcf_mgi);
-    uint32_t mode_mask = (1U << mode_registers_bits) - 1;
+    uint32_t mode_registers_num;
+    struct mgi_set_monitor_mode_check *params;
+    struct smcf_mgi_reg *smcf_mgi;
 
-    if (mode_idx > (mode_registers_num - 1)) {
-        return FWK_E_RANGE;
-    }
+    fwk_assert(data != NULL);
+    params = (struct mgi_set_monitor_mode_check *)data;
+    fwk_assert(params->smcf_mgi != NULL);
+    smcf_mgi = params->smcf_mgi;
+
+    mode_registers_num = mgi_get_number_of_mode_registers(smcf_mgi);
+    fwk_assert(params->mode_idx <= (mode_registers_num - 1));
 
     FWK_RW uint32_t *mode_req[SMCF_MGI_MAX_NUM_MODE_REG] = {
         &smcf_mgi->MODE_REQ0,
@@ -188,15 +192,32 @@ int mgi_set_monitor_mode(
         &smcf_mgi->MODE_REQ3
     };
 
-    *mode_req[mode_idx] = (value & mode_mask);
+    FWK_R uint32_t *mode_stat[SMCF_MGI_MAX_NUM_MODE_REG] = {
+        &smcf_mgi->MODE_STAT0,
+        &smcf_mgi->MODE_STAT1,
+        &smcf_mgi->MODE_STAT2,
+        &smcf_mgi->MODE_STAT3
+    };
 
-    return FWK_SUCCESS;
+    return (*mode_req[params->mode_idx] == *mode_stat[params->mode_idx]);
 }
 
-bool mgi_is_monitor_mode_updated(struct smcf_mgi_reg *smcf_mgi)
+/* Set MODE for individual MODE_REQ register */
+int mgi_set_monitor_mode(
+    struct smcf_mgi_reg *smcf_mgi,
+    struct smcf_mgi_timer_ctx *timer_ctx,
+    uint32_t mode_idx,
+    uint32_t value)
 {
-    uint32_t i;
     uint32_t mode_registers_num = mgi_get_number_of_mode_registers(smcf_mgi);
+    uint32_t mode_registers_bits =
+        mgi_get_number_of_bits_in_mode_registers(smcf_mgi);
+    uint32_t mode_mask = (1U << mode_registers_bits) - 1;
+    struct mgi_set_monitor_mode_check params;
+
+    if (mode_idx > (mode_registers_num - 1)) {
+        return FWK_E_RANGE;
+    }
 
     FWK_RW uint32_t *mode_req[SMCF_MGI_MAX_NUM_MODE_REG] = {
         &smcf_mgi->MODE_REQ0,
@@ -205,20 +226,28 @@ bool mgi_is_monitor_mode_updated(struct smcf_mgi_reg *smcf_mgi)
         &smcf_mgi->MODE_REQ3
     };
 
-    FWK_R uint32_t *mode_stat[SMCF_MGI_MAX_NUM_MODE_REG] = {
-        &smcf_mgi->MODE_STAT0,
-        &smcf_mgi->MODE_STAT1,
-        &smcf_mgi->MODE_STAT2,
-        &smcf_mgi->MODE_STAT3
-    };
+    *mode_req[mode_idx] = (value & mode_mask);
 
-    for (i = 0; i < mode_registers_num; i++) {
-        if (*mode_stat[i] != *mode_req[i]) {
-            return false;
-        }
+    if (timer_ctx == NULL) {
+        FWK_R uint32_t *mode_stat[SMCF_MGI_MAX_NUM_MODE_REG] = {
+            &smcf_mgi->MODE_STAT0,
+            &smcf_mgi->MODE_STAT1,
+            &smcf_mgi->MODE_STAT2,
+            &smcf_mgi->MODE_STAT3
+        };
+        while (*mode_req[mode_idx] != *mode_stat[mode_idx])
+            continue;
+    } else {
+        params.mode_idx = mode_idx;
+        params.smcf_mgi = smcf_mgi;
+        return timer_ctx->timer_api->wait(
+            timer_ctx->timer_id,
+            timer_ctx->delay_us,
+            mgi_is_monitor_mode_updated,
+            &params);
     }
 
-    return true;
+    return FWK_SUCCESS;
 }
 
 /*
diff --git a/module/smcf/src/mgi.h b/module/smcf/src/mgi.h
index 7ccbd4194..f27c947da 100644
--- a/module/smcf/src/mgi.h
+++ b/module/smcf/src/mgi.h
@@ -1,6 +1,6 @@
 /*
  * Arm SCP/MCP Software
- * Copyright (c) 2023, Arm Limited and Contributors. All rights reserved.
+ * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -12,7 +12,10 @@
  * \cond
  */
 
+#include <mod_timer.h>
+
 #include <fwk_attributes.h>
+#include <fwk_id.h>
 #include <fwk_macros.h>
 #include <fwk_status.h>
 
@@ -207,6 +210,15 @@ struct smcf_mgi_reg {
     FWK_R uint32_t AIDR;
 };
 
+/*
+ * Timer context for MODE_REQ timeout
+ */
+struct smcf_mgi_timer_ctx {
+    fwk_id_t timer_id;
+    struct mod_timer_api *timer_api;
+    uint32_t delay_us;
+};
+
 /*
  * Bit definitions for MGI_GRP_ID
  */
@@ -460,6 +472,7 @@ int mgi_enable__program_mode_multi(
 /* Set MODE for individual MODE_REQ reigester */
 int mgi_set_monitor_mode(
     struct smcf_mgi_reg *smcf_mgi,
+    struct smcf_mgi_timer_ctx *timer_ctx,
     uint32_t mode_idx,
     uint32_t value);
 
diff --git a/module/smcf/src/mod_smcf.c b/module/smcf/src/mod_smcf.c
index 914f17613..5a63c1851 100644
--- a/module/smcf/src/mod_smcf.c
+++ b/module/smcf/src/mod_smcf.c
@@ -49,6 +49,9 @@ struct smcf_element_ctx {
 
     /* Data attributes */
     struct smcf_data_attr data_attr;
+
+    /* Timer context*/
+    struct smcf_mgi_timer_ctx *timer_ctx;
 };
 
 /* Module context */
@@ -290,7 +293,8 @@ static int smcf_mli_config_mode_set(
         return status;
     }
 
-    status = mgi_set_monitor_mode(element_ctx->mgi, mode_index, mode_value);
+    status = mgi_set_monitor_mode(
+        element_ctx->mgi, element_ctx->timer_ctx, mode_index, mode_value);
     if (status != FWK_SUCCESS) {
         return status;
     }
@@ -347,6 +351,7 @@ static int smcf_mod_init(
         fwk_mm_calloc(mgi_count, sizeof(struct smcf_element_ctx));
 
     mod_ctx.element_ctx_table_size = mgi_count;
+
     return FWK_SUCCESS;
 }
 
@@ -447,6 +452,26 @@ static int smcf_element_init(
     }
     ctx->monitor_count = sub_element_count;
 
+#ifdef BUILD_HAS_MOD_TIMER
+    if (config->timer_config == NULL) {
+        ctx->timer_ctx = NULL;
+    } else {
+        ctx->timer_ctx = fwk_mm_calloc(1, sizeof(struct smcf_mgi_timer_ctx));
+        if (ctx->timer_ctx == NULL) {
+            return FWK_E_NOMEM;
+        }
+        /* Check for valid timeout value if timer ID is specified */
+        if (config->timer_config->set_state_timeout_us == 0) {
+            return FWK_E_PARAM;
+        }
+        /* Save the timer ID to context */
+        ctx->timer_ctx->timer_id = config->timer_config->timer_id;
+        ctx->timer_ctx->delay_us = config->timer_config->set_state_timeout_us;
+    }
+#else
+    ctx->timer_ctx = NULL;
+#endif
+
     status = smcf_element_init_config_sample_type(ctx);
     if (status != FWK_SUCCESS) {
         return status;
@@ -530,6 +555,35 @@ static int smcf_process_event(
     return status;
 }
 
+#ifdef BUILD_HAS_MOD_TIMER
+static int smcf_bind(fwk_id_t id, unsigned int round)
+{
+    int status = FWK_SUCCESS;
+    struct smcf_element_ctx *ctx = get_domain_ctx(id);
+
+    /* Only bind in first round of calls. */
+    if (round > 0) {
+        return FWK_SUCCESS;
+    }
+
+    if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE)) {
+        return FWK_SUCCESS;
+    }
+
+    if (ctx->timer_ctx != NULL &&
+        !fwk_id_is_equal(ctx->timer_ctx->timer_id, FWK_ID_NONE)) {
+        /* Bind to the timer */
+        status = fwk_module_bind(
+            ctx->timer_ctx->timer_id,
+            MOD_TIMER_API_ID_TIMER,
+            &ctx->timer_ctx->timer_api);
+        if (status != FWK_SUCCESS) {
+            return status;
+        }
+    }
+}
+#endif
+
 const struct fwk_module module_smcf = {
     .type = FWK_MODULE_TYPE_DRIVER,
     .api_count = (unsigned int)MOD_SMCF_API_IDX_COUNT,
@@ -541,4 +595,7 @@ const struct fwk_module module_smcf = {
     .element_init = smcf_element_init,
     .process_bind_request = smcf_process_bind_request,
     .process_event = smcf_process_event,
+#ifdef BUILD_HAS_MOD_TIMER
+    .bind = smcf_bind,
+#endif
 };
diff --git a/module/smcf/test/mgi/fwk_module_idx.h b/module/smcf/test/mgi/fwk_module_idx.h
index 373918b2f..488915453 100644
--- a/module/smcf/test/mgi/fwk_module_idx.h
+++ b/module/smcf/test/mgi/fwk_module_idx.h
@@ -1,6 +1,6 @@
 /*
  * Arm SCP/MCP Software
- * Copyright (c) 2023, Arm Limited and Contributors. All rights reserved.
+ * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -14,6 +14,7 @@ enum fwk_module_idx {
     FWK_MODULE_IDX_SMCF,
     FWK_MODULE_IDX_SENSOR,
     FWK_MODULE_IDX_COUNT,
+    FWK_MODULE_IDX_TIMER,
 };
 
 #endif /* TEST_FWK_MODULE_MODULE_IDX_H */
diff --git a/module/smcf/test/mgi/mgi_unit_test.c b/module/smcf/test/mgi/mgi_unit_test.c
index d59c9c8ef..72f7cabd3 100644
--- a/module/smcf/test/mgi/mgi_unit_test.c
+++ b/module/smcf/test/mgi/mgi_unit_test.c
@@ -1,6 +1,6 @@
 /*
  * Arm SCP/MCP Software
- * Copyright (c) 2023, Arm Limited and Contributors. All rights reserved.
+ * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -15,6 +15,23 @@
 
 #include "mgi_unit_test.h"
 
+int fake_wait(
+    fwk_id_t dev_id,
+    uint32_t microseconds,
+    bool (*cond)(void *),
+    void *data)
+{
+    if (cond(data)) {
+        return FWK_SUCCESS;
+    } else {
+        return FWK_E_TIMEOUT;
+    }
+}
+
+struct mod_timer_api timer_api = {
+    .wait = &fake_wait,
+};
+
 struct smcf_mgi_reg fake_smcf_mgi_reg = {
     .GRP_ID = MGI_GRP_ID,
     /* Set monitor 0,5,9
@@ -26,6 +43,12 @@ struct smcf_mgi_reg fake_smcf_mgi_reg = {
         (MGI_FEAT1_NUM_OF_BITS << SMCF_MGI_FEAT1_MODE_LEN_POS),
 };
 
+struct smcf_mgi_timer_ctx fake_smcf_mgi_timer_ctx = {
+    .timer_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_TIMER, 0),
+    .timer_api = &timer_api,
+    .delay_us = 10,
+};
+
 void setUp(void)
 {
     uint32_t *ptr_set_const_reg;
@@ -233,84 +256,145 @@ void utest_mgi_broadcast_mode_check_broadcast_mask(void)
 
 void utest_mgi_is_monitor_mode_updated_false(void)
 {
-    uint32_t mode = MODE_VALUE;
-    uint32_t mode_idx;
-    uint32_t *ptr_set_const_reg;
-    int status;
     bool updated;
+    uint32_t *ptr_set_const_reg;
+    struct mgi_set_monitor_mode_check param;
 
-    mode_idx = 0;
-    status = mgi_set_monitor_mode(&fake_smcf_mgi_reg, mode_idx, mode);
-    TEST_ASSERT_EQUAL(FWK_SUCCESS, status);
-
-    mode_idx = 1;
-    status = mgi_set_monitor_mode(&fake_smcf_mgi_reg, mode_idx, mode);
-    TEST_ASSERT_EQUAL(FWK_SUCCESS, status);
-
-    mode_idx = 2;
-    status = mgi_set_monitor_mode(&fake_smcf_mgi_reg, mode_idx, mode);
-    TEST_ASSERT_EQUAL(FWK_SUCCESS, status);
+    param.mode_idx = 0;
+    param.smcf_mgi = &fake_smcf_mgi_reg;
 
-    /*
-     * Only 3 REQ registers available. mode should written to REQ0,REQ1,REQ2
-     * but not REQ3
-     */
-    TEST_ASSERT_EQUAL(mode, fake_smcf_mgi_reg.MODE_REQ0);
-    TEST_ASSERT_EQUAL(mode, fake_smcf_mgi_reg.MODE_REQ1);
-    TEST_ASSERT_EQUAL(mode, fake_smcf_mgi_reg.MODE_REQ2);
-    TEST_ASSERT_NOT_EQUAL(mode, fake_smcf_mgi_reg.MODE_REQ3);
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_REQ0;
+    *ptr_set_const_reg = MODE_VALUE;
 
-    /* Only STAT0 and STAT1 forced in fake_smcf */
+    /* Set incorrect value */
     ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_STAT0;
-    *ptr_set_const_reg = mode;
-    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_STAT1;
-    *ptr_set_const_reg = mode;
+    *ptr_set_const_reg = 0;
 
-    updated = mgi_is_monitor_mode_updated(&fake_smcf_mgi_reg);
+    updated = mgi_is_monitor_mode_updated(&param);
     TEST_ASSERT_FALSE(updated);
 }
 
 void utest_mgi_is_monitor_mode_updated_true(void)
+{
+    bool updated;
+    uint32_t *ptr_set_const_reg;
+    struct mgi_set_monitor_mode_check param;
+
+    param.mode_idx = 0;
+    param.smcf_mgi = &fake_smcf_mgi_reg;
+
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_REQ0;
+    *ptr_set_const_reg = MODE_VALUE;
+
+    /* Set correct value */
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_STAT0;
+    *ptr_set_const_reg = MODE_VALUE;
+
+    updated = mgi_is_monitor_mode_updated(&param);
+    TEST_ASSERT_TRUE(updated);
+}
+
+void utest_mgi_set_monitor_mode_idx_out_of_range(void)
+{
+    uint32_t mode = MODE_VALUE;
+    uint32_t mode_idx = SMCF_MGI_MAX_NUM_MODE_REG;
+    int status;
+
+    status = mgi_set_monitor_mode(
+        &fake_smcf_mgi_reg, &fake_smcf_mgi_timer_ctx, mode_idx, mode);
+    TEST_ASSERT_EQUAL(FWK_E_RANGE, status);
+}
+
+void utest_mgi_set_monitor_mode_no_timer_success(void)
 {
     uint32_t mode = MODE_VALUE;
-    uint32_t mode_idx;
+    uint32_t mode_idx = 0;
     uint32_t *ptr_set_const_reg;
     int status;
-    bool updated;
 
-    mode_idx = 0;
-    status = mgi_set_monitor_mode(&fake_smcf_mgi_reg, mode_idx, mode);
-    TEST_ASSERT_EQUAL(FWK_SUCCESS, status);
+    /* Reset MODE_REQ*/
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_REQ0;
+    *ptr_set_const_reg = 0;
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_REQ1;
+    *ptr_set_const_reg = 0;
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_REQ2;
+    *ptr_set_const_reg = 0;
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_REQ3;
+    *ptr_set_const_reg = 0;
 
-    mode_idx = 1;
-    status = mgi_set_monitor_mode(&fake_smcf_mgi_reg, mode_idx, mode);
-    TEST_ASSERT_EQUAL(FWK_SUCCESS, status);
+    /* Set the expected mode value to MODE_STAT */
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_STAT0;
+    *ptr_set_const_reg = mode;
 
-    mode_idx = 2;
-    status = mgi_set_monitor_mode(&fake_smcf_mgi_reg, mode_idx, mode);
+    status = mgi_set_monitor_mode(&fake_smcf_mgi_reg, NULL, mode_idx, mode);
     TEST_ASSERT_EQUAL(FWK_SUCCESS, status);
-
-    /*
-     * Only 3 REQ registers available. mode should written to REQ0,REQ1,REQ2
-     * but not REQ3
-     */
+    /* Only the right MODE_REQ is set */
     TEST_ASSERT_EQUAL(mode, fake_smcf_mgi_reg.MODE_REQ0);
-    TEST_ASSERT_EQUAL(mode, fake_smcf_mgi_reg.MODE_REQ1);
-    TEST_ASSERT_EQUAL(mode, fake_smcf_mgi_reg.MODE_REQ2);
-    TEST_ASSERT_NOT_EQUAL(mode, fake_smcf_mgi_reg.MODE_REQ3);
+    TEST_ASSERT_EQUAL(0, fake_smcf_mgi_reg.MODE_REQ1);
+    TEST_ASSERT_EQUAL(0, fake_smcf_mgi_reg.MODE_REQ2);
+    TEST_ASSERT_EQUAL(0, fake_smcf_mgi_reg.MODE_REQ3);
+}
 
-    /* Only STAT0 and STAT1 forced in fake_smcf */
-    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_STAT0;
-    *ptr_set_const_reg = mode;
+void utest_mgi_set_monitor_mode_timer_success(void)
+{
+    uint32_t mode = MODE_VALUE;
+    uint32_t mode_idx = 1;
+    uint32_t *ptr_set_const_reg;
+    int status;
+
+    /* Reset MODE_REQ*/
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_REQ0;
+    *ptr_set_const_reg = 0;
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_REQ1;
+    *ptr_set_const_reg = 0;
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_REQ2;
+    *ptr_set_const_reg = 0;
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_REQ3;
+    *ptr_set_const_reg = 0;
+
+    /* Set the expected mode value to MODE_STAT */
     ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_STAT1;
     *ptr_set_const_reg = mode;
 
-    /* Now force set STAT2 value */
-    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_STAT2;
-    *ptr_set_const_reg = mode;
+    status = mgi_set_monitor_mode(
+        &fake_smcf_mgi_reg, &fake_smcf_mgi_timer_ctx, mode_idx, mode);
+    TEST_ASSERT_EQUAL(FWK_SUCCESS, status);
+    /* Only the right MODE_REQ is set */
+    TEST_ASSERT_EQUAL(0, fake_smcf_mgi_reg.MODE_REQ0);
+    TEST_ASSERT_EQUAL(mode, fake_smcf_mgi_reg.MODE_REQ1);
+    TEST_ASSERT_EQUAL(0, fake_smcf_mgi_reg.MODE_REQ2);
+    TEST_ASSERT_EQUAL(0, fake_smcf_mgi_reg.MODE_REQ3);
+}
 
-    updated = mgi_is_monitor_mode_updated(&fake_smcf_mgi_reg);
-    TEST_ASSERT_TRUE(updated);
+void utest_mgi_set_monitor_mode_timer_fail(void)
+{
+    uint32_t mode = MODE_VALUE;
+    uint32_t mode_idx = 2;
+    uint32_t *ptr_set_const_reg;
+    int status;
+
+    /* Reset MODE_REQ*/
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_REQ0;
+    *ptr_set_const_reg = 0;
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_REQ1;
+    *ptr_set_const_reg = 0;
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_REQ2;
+    *ptr_set_const_reg = 0;
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_REQ3;
+    *ptr_set_const_reg = 0;
+
+    /* Set false value to MODE_STAT */
+    ptr_set_const_reg = (uint32_t *)&fake_smcf_mgi_reg.MODE_STAT2;
+    *ptr_set_const_reg = mode + 1;
+
+    status = mgi_set_monitor_mode(
+        &fake_smcf_mgi_reg, &fake_smcf_mgi_timer_ctx, mode_idx, mode);
+    TEST_ASSERT_EQUAL(FWK_E_TIMEOUT, status);
+    /* Only the right MODE_REQ is set */
+    TEST_ASSERT_EQUAL(0, fake_smcf_mgi_reg.MODE_REQ0);
+    TEST_ASSERT_EQUAL(0, fake_smcf_mgi_reg.MODE_REQ1);
+    TEST_ASSERT_EQUAL(mode, fake_smcf_mgi_reg.MODE_REQ2);
+    TEST_ASSERT_EQUAL(0, fake_smcf_mgi_reg.MODE_REQ3);
 }
 
 void utest_mgi_set_sample_type_periodic(void)
@@ -809,6 +893,10 @@ int mgi_test_main(void)
     RUN_TEST(utest_mgi_broadcast_mode_check_broadcast_mask);
     RUN_TEST(utest_mgi_is_monitor_mode_updated_false);
     RUN_TEST(utest_mgi_is_monitor_mode_updated_true);
+    RUN_TEST(utest_mgi_set_monitor_mode_idx_out_of_range);
+    RUN_TEST(utest_mgi_set_monitor_mode_no_timer_success);
+    RUN_TEST(utest_mgi_set_monitor_mode_timer_success);
+    RUN_TEST(utest_mgi_set_monitor_mode_timer_fail);
     RUN_TEST(utest_mgi_set_sample_type_periodic);
     RUN_TEST(utest_mgi_set_sample_type_trigger_input);
     RUN_TEST(utest_mgi_set_sample_type_manual);
diff --git a/module/smcf/test/mgi/mod_smcf_mgi.cmake b/module/smcf/test/mgi/mod_smcf_mgi.cmake
index a4ba10115..8ee32cc59 100644
--- a/module/smcf/test/mgi/mod_smcf_mgi.cmake
+++ b/module/smcf/test/mgi/mod_smcf_mgi.cmake
@@ -1,6 +1,6 @@
 #
 # Arm SCP/MCP Software
-# Copyright (c) 2023, Arm Limited and Contributors. All rights reserved.
+# Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved.
 #
 # SPDX-License-Identifier: BSD-3-Clause
 #
@@ -18,6 +18,7 @@ endif()
 
 set(MODULE_SRC ${MODULE_ROOT}/${TEST_MODULE}/src)
 set(MODULE_INC ${MODULE_ROOT}/${TEST_MODULE}/include)
+list(APPEND OTHER_MODULE_INC ${MODULE_ROOT}/timer/include)
 set(MODULE_UT_SRC ${CMAKE_CURRENT_LIST_DIR})
 set(MODULE_UT_INC ${CMAKE_CURRENT_LIST_DIR})
 set(MODULE_UT_MOCK_SRC ${CMAKE_CURRENT_LIST_DIR}/../mocks)
diff --git a/module/smcf/test/mocks/Mockmgi.c b/module/smcf/test/mocks/Mockmgi.c
index 45365e1e9..d910a2033 100644
--- a/module/smcf/test/mocks/Mockmgi.c
+++ b/module/smcf/test/mocks/Mockmgi.c
@@ -57,6 +57,7 @@ static const char* CMockString_monitor = "monitor";
 static const char* CMockString_monitor_mask = "monitor_mask";
 static const char* CMockString_num_of_data = "num_of_data";
 static const char* CMockString_smcf_mgi = "smcf_mgi";
+static const char* CMockString_timer_ctx = "timer_ctx";
 static const char* CMockString_type = "type";
 static const char* CMockString_value = "value";
 
@@ -218,13 +219,19 @@ typedef struct _CMOCK_mgi_set_monitor_mode_CALL_INSTANCE
   char ExpectAnyArgsBool;
   int ReturnVal;
   struct smcf_mgi_reg* Expected_smcf_mgi;
+  struct smcf_mgi_timer_ctx* Expected_timer_ctx;
   uint32_t Expected_mode_idx;
   uint32_t Expected_value;
   int Expected_smcf_mgi_Depth;
+  int Expected_timer_ctx_Depth;
   char ReturnThruPtr_smcf_mgi_Used;
   struct smcf_mgi_reg* ReturnThruPtr_smcf_mgi_Val;
   size_t ReturnThruPtr_smcf_mgi_Size;
+  char ReturnThruPtr_timer_ctx_Used;
+  struct smcf_mgi_timer_ctx* ReturnThruPtr_timer_ctx_Val;
+  size_t ReturnThruPtr_timer_ctx_Size;
   char IgnoreArg_smcf_mgi;
+  char IgnoreArg_timer_ctx;
   char IgnoreArg_mode_idx;
   char IgnoreArg_value;
 
@@ -3018,7 +3025,7 @@ void mgi_enable__program_mode_multi_CMockIgnoreArg_monitor_mask(UNITY_LINE_TYPE
   cmock_call_instance->IgnoreArg_monitor_mask = 1;
 }
 
-int mgi_set_monitor_mode(struct smcf_mgi_reg* smcf_mgi, uint32_t mode_idx, uint32_t value)
+int mgi_set_monitor_mode(struct smcf_mgi_reg* smcf_mgi, struct smcf_mgi_timer_ctx* timer_ctx, uint32_t mode_idx, uint32_t value)
 {
   UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
   CMOCK_mgi_set_monitor_mode_CALL_INSTANCE* cmock_call_instance;
@@ -3036,7 +3043,7 @@ int mgi_set_monitor_mode(struct smcf_mgi_reg* smcf_mgi, uint32_t mode_idx, uint3
   if (!Mock.mgi_set_monitor_mode_CallbackBool &&
       Mock.mgi_set_monitor_mode_CallbackFunctionPointer != NULL)
   {
-    int cmock_cb_ret = Mock.mgi_set_monitor_mode_CallbackFunctionPointer(smcf_mgi, mode_idx, value, Mock.mgi_set_monitor_mode_CallbackCalls++);
+    int cmock_cb_ret = Mock.mgi_set_monitor_mode_CallbackFunctionPointer(smcf_mgi, timer_ctx, mode_idx, value, Mock.mgi_set_monitor_mode_CallbackCalls++);
     UNITY_CLR_DETAILS();
     return cmock_cb_ret;
   }
@@ -3052,6 +3059,14 @@ int mgi_set_monitor_mode(struct smcf_mgi_reg* smcf_mgi, uint32_t mode_idx, uint3
     else
       { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_smcf_mgi), (void*)(smcf_mgi), sizeof(struct smcf_mgi_reg), cmock_call_instance->Expected_smcf_mgi_Depth, cmock_line, CMockStringMismatch); }
   }
+  if (!cmock_call_instance->IgnoreArg_timer_ctx)
+  {
+    UNITY_SET_DETAILS(CMockString_mgi_set_monitor_mode,CMockString_timer_ctx);
+    if (cmock_call_instance->Expected_timer_ctx == NULL)
+      { UNITY_TEST_ASSERT_NULL(timer_ctx, cmock_line, CMockStringExpNULL); }
+    else
+      { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_timer_ctx), (void*)(timer_ctx), sizeof(struct smcf_mgi_timer_ctx), cmock_call_instance->Expected_timer_ctx_Depth, cmock_line, CMockStringMismatch); }
+  }
   if (!cmock_call_instance->IgnoreArg_mode_idx)
   {
     UNITY_SET_DETAILS(CMockString_mgi_set_monitor_mode,CMockString_mode_idx);
@@ -3065,7 +3080,7 @@ int mgi_set_monitor_mode(struct smcf_mgi_reg* smcf_mgi, uint32_t mode_idx, uint3
   }
   if (Mock.mgi_set_monitor_mode_CallbackFunctionPointer != NULL)
   {
-    cmock_call_instance->ReturnVal = Mock.mgi_set_monitor_mode_CallbackFunctionPointer(smcf_mgi, mode_idx, value, Mock.mgi_set_monitor_mode_CallbackCalls++);
+    cmock_call_instance->ReturnVal = Mock.mgi_set_monitor_mode_CallbackFunctionPointer(smcf_mgi, timer_ctx, mode_idx, value, Mock.mgi_set_monitor_mode_CallbackCalls++);
   }
   if (cmock_call_instance->ReturnThruPtr_smcf_mgi_Used)
   {
@@ -3073,17 +3088,27 @@ int mgi_set_monitor_mode(struct smcf_mgi_reg* smcf_mgi, uint32_t mode_idx, uint3
     memcpy((void*)smcf_mgi, (void*)cmock_call_instance->ReturnThruPtr_smcf_mgi_Val,
       cmock_call_instance->ReturnThruPtr_smcf_mgi_Size);
   }
+  if (cmock_call_instance->ReturnThruPtr_timer_ctx_Used)
+  {
+    UNITY_TEST_ASSERT_NOT_NULL(timer_ctx, cmock_line, CMockStringPtrIsNULL);
+    memcpy((void*)timer_ctx, (void*)cmock_call_instance->ReturnThruPtr_timer_ctx_Val,
+      cmock_call_instance->ReturnThruPtr_timer_ctx_Size);
+  }
   UNITY_CLR_DETAILS();
   return cmock_call_instance->ReturnVal;
 }
 
-void CMockExpectParameters_mgi_set_monitor_mode(CMOCK_mgi_set_monitor_mode_CALL_INSTANCE* cmock_call_instance, struct smcf_mgi_reg* smcf_mgi, int smcf_mgi_Depth, uint32_t mode_idx, uint32_t value);
-void CMockExpectParameters_mgi_set_monitor_mode(CMOCK_mgi_set_monitor_mode_CALL_INSTANCE* cmock_call_instance, struct smcf_mgi_reg* smcf_mgi, int smcf_mgi_Depth, uint32_t mode_idx, uint32_t value)
+void CMockExpectParameters_mgi_set_monitor_mode(CMOCK_mgi_set_monitor_mode_CALL_INSTANCE* cmock_call_instance, struct smcf_mgi_reg* smcf_mgi, int smcf_mgi_Depth, struct smcf_mgi_timer_ctx* timer_ctx, int timer_ctx_Depth, uint32_t mode_idx, uint32_t value);
+void CMockExpectParameters_mgi_set_monitor_mode(CMOCK_mgi_set_monitor_mode_CALL_INSTANCE* cmock_call_instance, struct smcf_mgi_reg* smcf_mgi, int smcf_mgi_Depth, struct smcf_mgi_timer_ctx* timer_ctx, int timer_ctx_Depth, uint32_t mode_idx, uint32_t value)
 {
   cmock_call_instance->Expected_smcf_mgi = smcf_mgi;
   cmock_call_instance->Expected_smcf_mgi_Depth = smcf_mgi_Depth;
   cmock_call_instance->IgnoreArg_smcf_mgi = 0;
   cmock_call_instance->ReturnThruPtr_smcf_mgi_Used = 0;
+  cmock_call_instance->Expected_timer_ctx = timer_ctx;
+  cmock_call_instance->Expected_timer_ctx_Depth = timer_ctx_Depth;
+  cmock_call_instance->IgnoreArg_timer_ctx = 0;
+  cmock_call_instance->ReturnThruPtr_timer_ctx_Used = 0;
   cmock_call_instance->Expected_mode_idx = mode_idx;
   cmock_call_instance->IgnoreArg_mode_idx = 0;
   cmock_call_instance->Expected_value = value;
@@ -3125,7 +3150,7 @@ void mgi_set_monitor_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line
   cmock_call_instance->ExpectAnyArgsBool = (char)1;
 }
 
-void mgi_set_monitor_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct smcf_mgi_reg* smcf_mgi, uint32_t mode_idx, uint32_t value, int cmock_to_return)
+void mgi_set_monitor_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct smcf_mgi_reg* smcf_mgi, struct smcf_mgi_timer_ctx* timer_ctx, uint32_t mode_idx, uint32_t value, int cmock_to_return)
 {
   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mgi_set_monitor_mode_CALL_INSTANCE));
   CMOCK_mgi_set_monitor_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_mgi_set_monitor_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
@@ -3135,7 +3160,7 @@ void mgi_set_monitor_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struc
   Mock.mgi_set_monitor_mode_IgnoreBool = (char)0;
   cmock_call_instance->LineNumber = cmock_line;
   cmock_call_instance->ExpectAnyArgsBool = (char)0;
-  CMockExpectParameters_mgi_set_monitor_mode(cmock_call_instance, smcf_mgi, 1, mode_idx, value);
+  CMockExpectParameters_mgi_set_monitor_mode(cmock_call_instance, smcf_mgi, 1, timer_ctx, 1, mode_idx, value);
   cmock_call_instance->ReturnVal = cmock_to_return;
 }
 
@@ -3153,7 +3178,7 @@ void mgi_set_monitor_mode_Stub(CMOCK_mgi_set_monitor_mode_CALLBACK Callback)
   Mock.mgi_set_monitor_mode_CallbackFunctionPointer = Callback;
 }
 
-void mgi_set_monitor_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct smcf_mgi_reg* smcf_mgi, int smcf_mgi_Depth, uint32_t mode_idx, uint32_t value, int cmock_to_return)
+void mgi_set_monitor_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct smcf_mgi_reg* smcf_mgi, int smcf_mgi_Depth, struct smcf_mgi_timer_ctx* timer_ctx, int timer_ctx_Depth, uint32_t mode_idx, uint32_t value, int cmock_to_return)
 {
   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mgi_set_monitor_mode_CALL_INSTANCE));
   CMOCK_mgi_set_monitor_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_mgi_set_monitor_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
@@ -3163,7 +3188,7 @@ void mgi_set_monitor_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_li
   Mock.mgi_set_monitor_mode_IgnoreBool = (char)0;
   cmock_call_instance->LineNumber = cmock_line;
   cmock_call_instance->ExpectAnyArgsBool = (char)0;
-  CMockExpectParameters_mgi_set_monitor_mode(cmock_call_instance, smcf_mgi, smcf_mgi_Depth, mode_idx, value);
+  CMockExpectParameters_mgi_set_monitor_mode(cmock_call_instance, smcf_mgi, smcf_mgi_Depth, timer_ctx, timer_ctx_Depth, mode_idx, value);
   cmock_call_instance->ReturnVal = cmock_to_return;
 }
 
@@ -3176,6 +3201,15 @@ void mgi_set_monitor_mode_CMockReturnMemThruPtr_smcf_mgi(UNITY_LINE_TYPE cmock_l
   cmock_call_instance->ReturnThruPtr_smcf_mgi_Size = cmock_size;
 }
 
+void mgi_set_monitor_mode_CMockReturnMemThruPtr_timer_ctx(UNITY_LINE_TYPE cmock_line, struct smcf_mgi_timer_ctx* timer_ctx, size_t cmock_size)
+{
+  CMOCK_mgi_set_monitor_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_mgi_set_monitor_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mgi_set_monitor_mode_CallInstance));
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp);
+  cmock_call_instance->ReturnThruPtr_timer_ctx_Used = 1;
+  cmock_call_instance->ReturnThruPtr_timer_ctx_Val = timer_ctx;
+  cmock_call_instance->ReturnThruPtr_timer_ctx_Size = cmock_size;
+}
+
 void mgi_set_monitor_mode_CMockIgnoreArg_smcf_mgi(UNITY_LINE_TYPE cmock_line)
 {
   CMOCK_mgi_set_monitor_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_mgi_set_monitor_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mgi_set_monitor_mode_CallInstance));
@@ -3183,6 +3217,13 @@ void mgi_set_monitor_mode_CMockIgnoreArg_smcf_mgi(UNITY_LINE_TYPE cmock_line)
   cmock_call_instance->IgnoreArg_smcf_mgi = 1;
 }
 
+void mgi_set_monitor_mode_CMockIgnoreArg_timer_ctx(UNITY_LINE_TYPE cmock_line)
+{
+  CMOCK_mgi_set_monitor_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_mgi_set_monitor_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mgi_set_monitor_mode_CallInstance));
+  UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
+  cmock_call_instance->IgnoreArg_timer_ctx = 1;
+}
+
 void mgi_set_monitor_mode_CMockIgnoreArg_mode_idx(UNITY_LINE_TYPE cmock_line)
 {
   CMOCK_mgi_set_monitor_mode_CALL_INSTANCE* cmock_call_instance = (CMOCK_mgi_set_monitor_mode_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mgi_set_monitor_mode_CallInstance));
diff --git a/module/smcf/test/mocks/Mockmgi.h b/module/smcf/test/mocks/Mockmgi.h
index 077229aa4..bcb154bfe 100644
--- a/module/smcf/test/mocks/Mockmgi.h
+++ b/module/smcf/test/mocks/Mockmgi.h
@@ -242,20 +242,26 @@ void mgi_set_monitor_mode_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int c
 void mgi_set_monitor_mode_CMockStopIgnore(void);
 #define mgi_set_monitor_mode_ExpectAnyArgsAndReturn(cmock_retval) mgi_set_monitor_mode_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval)
 void mgi_set_monitor_mode_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return);
-#define mgi_set_monitor_mode_ExpectAndReturn(smcf_mgi, mode_idx, value, cmock_retval) mgi_set_monitor_mode_CMockExpectAndReturn(__LINE__, smcf_mgi, mode_idx, value, cmock_retval)
-void mgi_set_monitor_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct smcf_mgi_reg* smcf_mgi, uint32_t mode_idx, uint32_t value, int cmock_to_return);
-typedef int (* CMOCK_mgi_set_monitor_mode_CALLBACK)(struct smcf_mgi_reg* smcf_mgi, uint32_t mode_idx, uint32_t value, int cmock_num_calls);
+#define mgi_set_monitor_mode_ExpectAndReturn(smcf_mgi, timer_ctx, mode_idx, value, cmock_retval) mgi_set_monitor_mode_CMockExpectAndReturn(__LINE__, smcf_mgi, timer_ctx, mode_idx, value, cmock_retval)
+void mgi_set_monitor_mode_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct smcf_mgi_reg* smcf_mgi, struct smcf_mgi_timer_ctx* timer_ctx, uint32_t mode_idx, uint32_t value, int cmock_to_return);
+typedef int (* CMOCK_mgi_set_monitor_mode_CALLBACK)(struct smcf_mgi_reg* smcf_mgi, struct smcf_mgi_timer_ctx* timer_ctx, uint32_t mode_idx, uint32_t value, int cmock_num_calls);
 void mgi_set_monitor_mode_AddCallback(CMOCK_mgi_set_monitor_mode_CALLBACK Callback);
 void mgi_set_monitor_mode_Stub(CMOCK_mgi_set_monitor_mode_CALLBACK Callback);
 #define mgi_set_monitor_mode_StubWithCallback mgi_set_monitor_mode_Stub
-#define mgi_set_monitor_mode_ExpectWithArrayAndReturn(smcf_mgi, smcf_mgi_Depth, mode_idx, value, cmock_retval) mgi_set_monitor_mode_CMockExpectWithArrayAndReturn(__LINE__, smcf_mgi, smcf_mgi_Depth, mode_idx, value, cmock_retval)
-void mgi_set_monitor_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct smcf_mgi_reg* smcf_mgi, int smcf_mgi_Depth, uint32_t mode_idx, uint32_t value, int cmock_to_return);
+#define mgi_set_monitor_mode_ExpectWithArrayAndReturn(smcf_mgi, smcf_mgi_Depth, timer_ctx, timer_ctx_Depth, mode_idx, value, cmock_retval) mgi_set_monitor_mode_CMockExpectWithArrayAndReturn(__LINE__, smcf_mgi, smcf_mgi_Depth, timer_ctx, timer_ctx_Depth, mode_idx, value, cmock_retval)
+void mgi_set_monitor_mode_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct smcf_mgi_reg* smcf_mgi, int smcf_mgi_Depth, struct smcf_mgi_timer_ctx* timer_ctx, int timer_ctx_Depth, uint32_t mode_idx, uint32_t value, int cmock_to_return);
 #define mgi_set_monitor_mode_ReturnThruPtr_smcf_mgi(smcf_mgi) mgi_set_monitor_mode_CMockReturnMemThruPtr_smcf_mgi(__LINE__, smcf_mgi, sizeof(struct smcf_mgi_reg))
 #define mgi_set_monitor_mode_ReturnArrayThruPtr_smcf_mgi(smcf_mgi, cmock_len) mgi_set_monitor_mode_CMockReturnMemThruPtr_smcf_mgi(__LINE__, smcf_mgi, cmock_len * sizeof(*smcf_mgi))
 #define mgi_set_monitor_mode_ReturnMemThruPtr_smcf_mgi(smcf_mgi, cmock_size) mgi_set_monitor_mode_CMockReturnMemThruPtr_smcf_mgi(__LINE__, smcf_mgi, cmock_size)
 void mgi_set_monitor_mode_CMockReturnMemThruPtr_smcf_mgi(UNITY_LINE_TYPE cmock_line, struct smcf_mgi_reg* smcf_mgi, size_t cmock_size);
+#define mgi_set_monitor_mode_ReturnThruPtr_timer_ctx(timer_ctx) mgi_set_monitor_mode_CMockReturnMemThruPtr_timer_ctx(__LINE__, timer_ctx, sizeof(struct smcf_mgi_timer_ctx))
+#define mgi_set_monitor_mode_ReturnArrayThruPtr_timer_ctx(timer_ctx, cmock_len) mgi_set_monitor_mode_CMockReturnMemThruPtr_timer_ctx(__LINE__, timer_ctx, cmock_len * sizeof(*timer_ctx))
+#define mgi_set_monitor_mode_ReturnMemThruPtr_timer_ctx(timer_ctx, cmock_size) mgi_set_monitor_mode_CMockReturnMemThruPtr_timer_ctx(__LINE__, timer_ctx, cmock_size)
+void mgi_set_monitor_mode_CMockReturnMemThruPtr_timer_ctx(UNITY_LINE_TYPE cmock_line, struct smcf_mgi_timer_ctx* timer_ctx, size_t cmock_size);
 #define mgi_set_monitor_mode_IgnoreArg_smcf_mgi() mgi_set_monitor_mode_CMockIgnoreArg_smcf_mgi(__LINE__)
 void mgi_set_monitor_mode_CMockIgnoreArg_smcf_mgi(UNITY_LINE_TYPE cmock_line);
+#define mgi_set_monitor_mode_IgnoreArg_timer_ctx() mgi_set_monitor_mode_CMockIgnoreArg_timer_ctx(__LINE__)
+void mgi_set_monitor_mode_CMockIgnoreArg_timer_ctx(UNITY_LINE_TYPE cmock_line);
 #define mgi_set_monitor_mode_IgnoreArg_mode_idx() mgi_set_monitor_mode_CMockIgnoreArg_mode_idx(__LINE__)
 void mgi_set_monitor_mode_CMockIgnoreArg_mode_idx(UNITY_LINE_TYPE cmock_line);
 #define mgi_set_monitor_mode_IgnoreArg_value() mgi_set_monitor_mode_CMockIgnoreArg_value(__LINE__)