From e46bb3aa7512bb0a0a1375ff387c86508729f859 Mon Sep 17 00:00:00 2001 From: Mahmoud Elsabbagh Date: Fri, 17 Jan 2025 11:46:15 +0000 Subject: [PATCH 1/2] mod/scmi_power_capping: Update SCMI power capping to use Power Capping HAL. Update SCMI Power Capping to use apis provided by Power Capping HAL for reporting power averaging interval and average consumed power. Signed-off-by: Mahmoud Elsabbagh --- module/power_capping/src/mod_power_capping.c | 5 + .../test/mocks/Mockmod_power_capping_extra.c | 1 - .../src/scmi_power_capping_protocol.c | 44 +- .../test/mocks/Mockmod_power_capping_extra.c | 1018 +++++++++++++++++ .../test/mocks/Mockmod_power_capping_extra.h | 110 ++ .../test/mod_power_capping_extra.h | 10 +- .../scmi_power_capping_protocol_unit_test.c | 86 +- 7 files changed, 1219 insertions(+), 55 deletions(-) diff --git a/module/power_capping/src/mod_power_capping.c b/module/power_capping/src/mod_power_capping.c index b56559ee6..d662e5110 100644 --- a/module/power_capping/src/mod_power_capping.c +++ b/module/power_capping/src/mod_power_capping.c @@ -246,6 +246,11 @@ static int mod_pcapping_get_power_limit( struct mod_power_capping_api pcapping_api = { .request_cap = mod_pcapping_request_cap, .get_applied_cap = mod_pcapping_get_applied_cap, + .get_average_power = mod_pcapping_get_average_power, + .get_averaging_interval = mod_pcapping_get_averaging_interval, + .get_averaging_interval_range = mod_pcapping_get_averaging_interval_range, + .get_averaging_interval_step = mod_pcapping_get_averaging_interval_step, + .set_averaging_interval = mod_pcapping_set_averaging_interval, }; struct interface_power_management_api power_management_api = { diff --git a/module/power_capping/test/mocks/Mockmod_power_capping_extra.c b/module/power_capping/test/mocks/Mockmod_power_capping_extra.c index 19ea351ec..968cf3af4 100644 --- a/module/power_capping/test/mocks/Mockmod_power_capping_extra.c +++ b/module/power_capping/test/mocks/Mockmod_power_capping_extra.c @@ -1700,4 +1700,3 @@ void set_point_CMockIgnoreArg_input(UNITY_LINE_TYPE cmock_line) UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); cmock_call_instance->IgnoreArg_input = 1; } - diff --git a/module/scmi_power_capping/src/scmi_power_capping_protocol.c b/module/scmi_power_capping/src/scmi_power_capping_protocol.c index bdf94a518..6fb74a2ab 100644 --- a/module/scmi_power_capping/src/scmi_power_capping_protocol.c +++ b/module/scmi_power_capping/src/scmi_power_capping_protocol.c @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -248,6 +248,7 @@ static inline void scmi_power_capping_populate_domain_attributes( { const struct mod_scmi_power_capping_domain_context *domain_ctx; const struct mod_scmi_power_capping_domain_config *config; + fwk_id_t domain_id; domain_ctx = get_domain_ctx(domain_idx); config = domain_ctx->config; @@ -256,9 +257,15 @@ static inline void scmi_power_capping_populate_domain_attributes( domain_ctx->cap_config_support, domain_ctx->pai_config_support, config->power_cap_unit); - return_values->min_pai = config->min_pai; - return_values->max_pai = config->max_pai; - return_values->pai_step = config->pai_step; + + domain_id = domain_ctx->config->power_capping_domain_id; + + pcapping_protocol_ctx.power_management_apis->power_capping_api + ->get_averaging_interval_step(domain_id, &return_values->pai_step); + + pcapping_protocol_ctx.power_management_apis->power_capping_api + ->get_averaging_interval_range( + domain_id, &return_values->min_pai, &return_values->max_pai); #ifdef BUILD_HAS_SCMI_POWER_CAPPING_FAST_CHANNELS_COMMANDS return_values->attributes |= SCMI_POWER_CAPPING_DOMAIN_FCH_SUPPORT( @@ -654,13 +661,15 @@ static int scmi_power_capping_pai_get_handler( struct mod_scmi_power_capping_domain_context *ctx; uint32_t pai; int status; + fwk_id_t domain_id; parameters = (const struct scmi_power_capping_pai_get_a2p *)payload; ctx = get_domain_ctx(parameters->domain_id); - status = pcapping_protocol_ctx.power_management_apis->power_coordinator_api - ->get_coordinator_period( - ctx->config->power_coordinator_domain_id, &pai); + domain_id = ctx->config->power_capping_domain_id; + + status = pcapping_protocol_ctx.power_management_apis->power_capping_api + ->get_averaging_interval(domain_id, &pai); if (status != FWK_SUCCESS) { return scmi_power_capping_respond_error(service_id, SCMI_GENERIC_ERROR); @@ -681,6 +690,7 @@ static int scmi_power_capping_pai_set_handler( struct scmi_power_capping_pai_set_p2a return_values; struct mod_scmi_power_capping_domain_context *ctx; int status; + fwk_id_t domain_id; parameters = (const struct scmi_power_capping_pai_set_a2p *)payload; ctx = get_domain_ctx(parameters->domain_id); @@ -707,9 +717,10 @@ static int scmi_power_capping_pai_set_handler( } #endif - status = pcapping_protocol_ctx.power_management_apis->power_coordinator_api - ->set_coordinator_period( - ctx->config->power_coordinator_domain_id, parameters->pai); + domain_id = ctx->config->power_capping_domain_id; + + status = pcapping_protocol_ctx.power_management_apis->power_capping_api + ->set_averaging_interval(domain_id, parameters->pai); if (status != FWK_SUCCESS) { return scmi_power_capping_respond_error(service_id, SCMI_GENERIC_ERROR); @@ -736,22 +747,23 @@ static int scmi_power_capping_measurements_get_handler( int status; uint32_t power; uint32_t period; + fwk_id_t domain_id; parameters = (const struct scmi_power_capping_measurements_get_a2p *)payload; ctx = get_domain_ctx(parameters->domain_id); - status = - pcapping_protocol_ctx.power_management_apis->power_meter_api->get_power( - ctx->config->power_meter_domain_id, &power); + domain_id = ctx->config->power_capping_domain_id; + + status = pcapping_protocol_ctx.power_management_apis->power_capping_api + ->get_average_power(domain_id, &power); if (status != FWK_SUCCESS) { return scmi_power_capping_respond_error(service_id, SCMI_GENERIC_ERROR); } - status = pcapping_protocol_ctx.power_management_apis->power_coordinator_api - ->get_coordinator_period( - ctx->config->power_coordinator_domain_id, &period); + status = pcapping_protocol_ctx.power_management_apis->power_capping_api + ->get_averaging_interval(domain_id, &period); if (status != FWK_SUCCESS) { return scmi_power_capping_respond_error(service_id, SCMI_GENERIC_ERROR); diff --git a/module/scmi_power_capping/test/mocks/Mockmod_power_capping_extra.c b/module/scmi_power_capping/test/mocks/Mockmod_power_capping_extra.c index 832d932fc..5ef51c615 100644 --- a/module/scmi_power_capping/test/mocks/Mockmod_power_capping_extra.c +++ b/module/scmi_power_capping/test/mocks/Mockmod_power_capping_extra.c @@ -8,7 +8,18 @@ static const char* CMockString_cap = "cap"; static const char* CMockString_domain_id = "domain_id"; static const char* CMockString_get_applied_cap = "get_applied_cap"; +static const char* CMockString_get_average_power = "get_average_power"; +static const char* CMockString_get_averaging_interval = "get_averaging_interval"; +static const char* CMockString_get_averaging_interval_range = "get_averaging_interval_range"; +static const char* CMockString_get_averaging_interval_step = "get_averaging_interval_step"; +static const char* CMockString_id = "id"; +static const char* CMockString_max_pai = "max_pai"; +static const char* CMockString_min_pai = "min_pai"; +static const char* CMockString_pai = "pai"; +static const char* CMockString_pai_step = "pai_step"; +static const char* CMockString_power = "power"; static const char* CMockString_request_cap = "request_cap"; +static const char* CMockString_set_averaging_interval = "set_averaging_interval"; typedef struct _CMOCK_get_applied_cap_CALL_INSTANCE { @@ -38,6 +49,88 @@ typedef struct _CMOCK_request_cap_CALL_INSTANCE } CMOCK_request_cap_CALL_INSTANCE; +typedef struct _CMOCK_get_average_power_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + fwk_id_t Expected_id; + uint32_t* Expected_power; + int Expected_power_Depth; + char ReturnThruPtr_power_Used; + uint32_t* ReturnThruPtr_power_Val; + size_t ReturnThruPtr_power_Size; + char IgnoreArg_id; + char IgnoreArg_power; + +} CMOCK_get_average_power_CALL_INSTANCE; + +typedef struct _CMOCK_set_averaging_interval_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + fwk_id_t Expected_id; + uint32_t Expected_pai; + char IgnoreArg_id; + char IgnoreArg_pai; + +} CMOCK_set_averaging_interval_CALL_INSTANCE; + +typedef struct _CMOCK_get_averaging_interval_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + fwk_id_t Expected_id; + uint32_t* Expected_pai; + int Expected_pai_Depth; + char ReturnThruPtr_pai_Used; + uint32_t* ReturnThruPtr_pai_Val; + size_t ReturnThruPtr_pai_Size; + char IgnoreArg_id; + char IgnoreArg_pai; + +} CMOCK_get_averaging_interval_CALL_INSTANCE; + +typedef struct _CMOCK_get_averaging_interval_step_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + fwk_id_t Expected_id; + uint32_t* Expected_pai_step; + int Expected_pai_step_Depth; + char ReturnThruPtr_pai_step_Used; + uint32_t* ReturnThruPtr_pai_step_Val; + size_t ReturnThruPtr_pai_step_Size; + char IgnoreArg_id; + char IgnoreArg_pai_step; + +} CMOCK_get_averaging_interval_step_CALL_INSTANCE; + +typedef struct _CMOCK_get_averaging_interval_range_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + fwk_id_t Expected_id; + uint32_t* Expected_min_pai; + uint32_t* Expected_max_pai; + int Expected_min_pai_Depth; + int Expected_max_pai_Depth; + char ReturnThruPtr_min_pai_Used; + uint32_t* ReturnThruPtr_min_pai_Val; + size_t ReturnThruPtr_min_pai_Size; + char ReturnThruPtr_max_pai_Used; + uint32_t* ReturnThruPtr_max_pai_Val; + size_t ReturnThruPtr_max_pai_Size; + char IgnoreArg_id; + char IgnoreArg_min_pai; + char IgnoreArg_max_pai; + +} CMOCK_get_averaging_interval_range_CALL_INSTANCE; + static struct Mockmod_power_capping_extraInstance { char get_applied_cap_IgnoreBool; @@ -52,6 +145,36 @@ static struct Mockmod_power_capping_extraInstance CMOCK_request_cap_CALLBACK request_cap_CallbackFunctionPointer; int request_cap_CallbackCalls; CMOCK_MEM_INDEX_TYPE request_cap_CallInstance; + char get_average_power_IgnoreBool; + int get_average_power_FinalReturn; + char get_average_power_CallbackBool; + CMOCK_get_average_power_CALLBACK get_average_power_CallbackFunctionPointer; + int get_average_power_CallbackCalls; + CMOCK_MEM_INDEX_TYPE get_average_power_CallInstance; + char set_averaging_interval_IgnoreBool; + int set_averaging_interval_FinalReturn; + char set_averaging_interval_CallbackBool; + CMOCK_set_averaging_interval_CALLBACK set_averaging_interval_CallbackFunctionPointer; + int set_averaging_interval_CallbackCalls; + CMOCK_MEM_INDEX_TYPE set_averaging_interval_CallInstance; + char get_averaging_interval_IgnoreBool; + int get_averaging_interval_FinalReturn; + char get_averaging_interval_CallbackBool; + CMOCK_get_averaging_interval_CALLBACK get_averaging_interval_CallbackFunctionPointer; + int get_averaging_interval_CallbackCalls; + CMOCK_MEM_INDEX_TYPE get_averaging_interval_CallInstance; + char get_averaging_interval_step_IgnoreBool; + int get_averaging_interval_step_FinalReturn; + char get_averaging_interval_step_CallbackBool; + CMOCK_get_averaging_interval_step_CALLBACK get_averaging_interval_step_CallbackFunctionPointer; + int get_averaging_interval_step_CallbackCalls; + CMOCK_MEM_INDEX_TYPE get_averaging_interval_step_CallInstance; + char get_averaging_interval_range_IgnoreBool; + int get_averaging_interval_range_FinalReturn; + char get_averaging_interval_range_CallbackBool; + CMOCK_get_averaging_interval_range_CALLBACK get_averaging_interval_range_CallbackFunctionPointer; + int get_averaging_interval_range_CallbackCalls; + CMOCK_MEM_INDEX_TYPE get_averaging_interval_range_CallInstance; } Mock; extern jmp_buf AbortFrame; @@ -86,6 +209,71 @@ void Mockmod_power_capping_extra_Verify(void) call_instance = CMOCK_GUTS_NONE; (void)call_instance; } + call_instance = Mock.get_average_power_CallInstance; + if (Mock.get_average_power_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_get_average_power); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.get_average_power_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.set_averaging_interval_CallInstance; + if (Mock.set_averaging_interval_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_set_averaging_interval); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.set_averaging_interval_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.get_averaging_interval_CallInstance; + if (Mock.get_averaging_interval_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_get_averaging_interval); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.get_averaging_interval_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.get_averaging_interval_step_CallInstance; + if (Mock.get_averaging_interval_step_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_get_averaging_interval_step); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.get_averaging_interval_step_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.get_averaging_interval_range_CallInstance; + if (Mock.get_averaging_interval_range_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_get_averaging_interval_range); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.get_averaging_interval_range_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } } void Mockmod_power_capping_extra_Init(void) @@ -397,3 +585,833 @@ void request_cap_CMockIgnoreArg_cap(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_cap = 1; } +int get_average_power(fwk_id_t id, uint32_t* power) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_get_average_power); + cmock_call_instance = (CMOCK_get_average_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_average_power_CallInstance); + Mock.get_average_power_CallInstance = CMock_Guts_MemNext(Mock.get_average_power_CallInstance); + if (Mock.get_average_power_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.get_average_power_FinalReturn; + Mock.get_average_power_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.get_average_power_CallbackBool && + Mock.get_average_power_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.get_average_power_CallbackFunctionPointer(id, power, Mock.get_average_power_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_id) + { + UNITY_SET_DETAILS(CMockString_get_average_power,CMockString_id); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_id), (void*)(&id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_power) + { + UNITY_SET_DETAILS(CMockString_get_average_power,CMockString_power); + if (cmock_call_instance->Expected_power == NULL) + { UNITY_TEST_ASSERT_NULL(power, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_power, power, cmock_call_instance->Expected_power_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.get_average_power_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.get_average_power_CallbackFunctionPointer(id, power, Mock.get_average_power_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_power_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(power, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)power, (void*)cmock_call_instance->ReturnThruPtr_power_Val, + cmock_call_instance->ReturnThruPtr_power_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_get_average_power(CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* power, int power_Depth); +void CMockExpectParameters_get_average_power(CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* power, int power_Depth) +{ + memcpy((void*)(&cmock_call_instance->Expected_id), (void*)(&id), + sizeof(fwk_id_t[sizeof(id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_id = 0; + cmock_call_instance->Expected_power = power; + cmock_call_instance->Expected_power_Depth = power_Depth; + cmock_call_instance->IgnoreArg_power = 0; + cmock_call_instance->ReturnThruPtr_power_Used = 0; +} + +void get_average_power_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_average_power_CALL_INSTANCE)); + CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_average_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_average_power_CallInstance = CMock_Guts_MemChain(Mock.get_average_power_CallInstance, cmock_guts_index); + Mock.get_average_power_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.get_average_power_IgnoreBool = (char)1; +} + +void get_average_power_CMockStopIgnore(void) +{ + if(Mock.get_average_power_IgnoreBool) + Mock.get_average_power_CallInstance = CMock_Guts_MemNext(Mock.get_average_power_CallInstance); + Mock.get_average_power_IgnoreBool = (char)0; +} + +void get_average_power_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_average_power_CALL_INSTANCE)); + CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_average_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_average_power_CallInstance = CMock_Guts_MemChain(Mock.get_average_power_CallInstance, cmock_guts_index); + Mock.get_average_power_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void get_average_power_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_average_power_CALL_INSTANCE)); + CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_average_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_average_power_CallInstance = CMock_Guts_MemChain(Mock.get_average_power_CallInstance, cmock_guts_index); + Mock.get_average_power_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_average_power(cmock_call_instance, id, power, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_average_power_AddCallback(CMOCK_get_average_power_CALLBACK Callback) +{ + Mock.get_average_power_IgnoreBool = (char)0; + Mock.get_average_power_CallbackBool = (char)1; + Mock.get_average_power_CallbackFunctionPointer = Callback; +} + +void get_average_power_Stub(CMOCK_get_average_power_CALLBACK Callback) +{ + Mock.get_average_power_IgnoreBool = (char)0; + Mock.get_average_power_CallbackBool = (char)0; + Mock.get_average_power_CallbackFunctionPointer = Callback; +} + +void get_average_power_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power, int power_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_average_power_CALL_INSTANCE)); + CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_average_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_average_power_CallInstance = CMock_Guts_MemChain(Mock.get_average_power_CallInstance, cmock_guts_index); + Mock.get_average_power_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_average_power(cmock_call_instance, id, power, power_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_average_power_CMockReturnMemThruPtr_power(UNITY_LINE_TYPE cmock_line, uint32_t* power, size_t cmock_size) +{ + CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_average_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_average_power_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_power_Used = 1; + cmock_call_instance->ReturnThruPtr_power_Val = power; + cmock_call_instance->ReturnThruPtr_power_Size = cmock_size; +} + +void get_average_power_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_average_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_average_power_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_id = 1; +} + +void get_average_power_CMockIgnoreArg_power(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_average_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_average_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_average_power_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_power = 1; +} + +int set_averaging_interval(fwk_id_t id, uint32_t pai) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_set_averaging_interval_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_set_averaging_interval); + cmock_call_instance = (CMOCK_set_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.set_averaging_interval_CallInstance); + Mock.set_averaging_interval_CallInstance = CMock_Guts_MemNext(Mock.set_averaging_interval_CallInstance); + if (Mock.set_averaging_interval_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.set_averaging_interval_FinalReturn; + Mock.set_averaging_interval_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.set_averaging_interval_CallbackBool && + Mock.set_averaging_interval_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.set_averaging_interval_CallbackFunctionPointer(id, pai, Mock.set_averaging_interval_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_id) + { + UNITY_SET_DETAILS(CMockString_set_averaging_interval,CMockString_id); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_id), (void*)(&id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pai) + { + UNITY_SET_DETAILS(CMockString_set_averaging_interval,CMockString_pai); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_pai, pai, cmock_line, CMockStringMismatch); + } + } + if (Mock.set_averaging_interval_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.set_averaging_interval_CallbackFunctionPointer(id, pai, Mock.set_averaging_interval_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_set_averaging_interval(CMOCK_set_averaging_interval_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t pai); +void CMockExpectParameters_set_averaging_interval(CMOCK_set_averaging_interval_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t pai) +{ + memcpy((void*)(&cmock_call_instance->Expected_id), (void*)(&id), + sizeof(fwk_id_t[sizeof(id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_id = 0; + cmock_call_instance->Expected_pai = pai; + cmock_call_instance->IgnoreArg_pai = 0; +} + +void set_averaging_interval_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_averaging_interval_CALL_INSTANCE)); + CMOCK_set_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.set_averaging_interval_CallInstance = CMock_Guts_MemChain(Mock.set_averaging_interval_CallInstance, cmock_guts_index); + Mock.set_averaging_interval_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.set_averaging_interval_IgnoreBool = (char)1; +} + +void set_averaging_interval_CMockStopIgnore(void) +{ + if(Mock.set_averaging_interval_IgnoreBool) + Mock.set_averaging_interval_CallInstance = CMock_Guts_MemNext(Mock.set_averaging_interval_CallInstance); + Mock.set_averaging_interval_IgnoreBool = (char)0; +} + +void set_averaging_interval_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_averaging_interval_CALL_INSTANCE)); + CMOCK_set_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.set_averaging_interval_CallInstance = CMock_Guts_MemChain(Mock.set_averaging_interval_CallInstance, cmock_guts_index); + Mock.set_averaging_interval_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void set_averaging_interval_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t pai, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_averaging_interval_CALL_INSTANCE)); + CMOCK_set_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.set_averaging_interval_CallInstance = CMock_Guts_MemChain(Mock.set_averaging_interval_CallInstance, cmock_guts_index); + Mock.set_averaging_interval_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_set_averaging_interval(cmock_call_instance, id, pai); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void set_averaging_interval_AddCallback(CMOCK_set_averaging_interval_CALLBACK Callback) +{ + Mock.set_averaging_interval_IgnoreBool = (char)0; + Mock.set_averaging_interval_CallbackBool = (char)1; + Mock.set_averaging_interval_CallbackFunctionPointer = Callback; +} + +void set_averaging_interval_Stub(CMOCK_set_averaging_interval_CALLBACK Callback) +{ + Mock.set_averaging_interval_IgnoreBool = (char)0; + Mock.set_averaging_interval_CallbackBool = (char)0; + Mock.set_averaging_interval_CallbackFunctionPointer = Callback; +} + +void set_averaging_interval_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_set_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_averaging_interval_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_id = 1; +} + +void set_averaging_interval_CMockIgnoreArg_pai(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_set_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_averaging_interval_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pai = 1; +} + +int get_averaging_interval(fwk_id_t id, uint32_t* pai) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_get_averaging_interval); + cmock_call_instance = (CMOCK_get_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_averaging_interval_CallInstance); + Mock.get_averaging_interval_CallInstance = CMock_Guts_MemNext(Mock.get_averaging_interval_CallInstance); + if (Mock.get_averaging_interval_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.get_averaging_interval_FinalReturn; + Mock.get_averaging_interval_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.get_averaging_interval_CallbackBool && + Mock.get_averaging_interval_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.get_averaging_interval_CallbackFunctionPointer(id, pai, Mock.get_averaging_interval_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_id) + { + UNITY_SET_DETAILS(CMockString_get_averaging_interval,CMockString_id); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_id), (void*)(&id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pai) + { + UNITY_SET_DETAILS(CMockString_get_averaging_interval,CMockString_pai); + if (cmock_call_instance->Expected_pai == NULL) + { UNITY_TEST_ASSERT_NULL(pai, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pai, pai, cmock_call_instance->Expected_pai_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.get_averaging_interval_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.get_averaging_interval_CallbackFunctionPointer(id, pai, Mock.get_averaging_interval_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pai_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pai, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pai, (void*)cmock_call_instance->ReturnThruPtr_pai_Val, + cmock_call_instance->ReturnThruPtr_pai_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_get_averaging_interval(CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* pai, int pai_Depth); +void CMockExpectParameters_get_averaging_interval(CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* pai, int pai_Depth) +{ + memcpy((void*)(&cmock_call_instance->Expected_id), (void*)(&id), + sizeof(fwk_id_t[sizeof(id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_id = 0; + cmock_call_instance->Expected_pai = pai; + cmock_call_instance->Expected_pai_Depth = pai_Depth; + cmock_call_instance->IgnoreArg_pai = 0; + cmock_call_instance->ReturnThruPtr_pai_Used = 0; +} + +void get_averaging_interval_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_CALL_INSTANCE)); + CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.get_averaging_interval_IgnoreBool = (char)1; +} + +void get_averaging_interval_CMockStopIgnore(void) +{ + if(Mock.get_averaging_interval_IgnoreBool) + Mock.get_averaging_interval_CallInstance = CMock_Guts_MemNext(Mock.get_averaging_interval_CallInstance); + Mock.get_averaging_interval_IgnoreBool = (char)0; +} + +void get_averaging_interval_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_CALL_INSTANCE)); + CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void get_averaging_interval_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* pai, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_CALL_INSTANCE)); + CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_averaging_interval(cmock_call_instance, id, pai, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_averaging_interval_AddCallback(CMOCK_get_averaging_interval_CALLBACK Callback) +{ + Mock.get_averaging_interval_IgnoreBool = (char)0; + Mock.get_averaging_interval_CallbackBool = (char)1; + Mock.get_averaging_interval_CallbackFunctionPointer = Callback; +} + +void get_averaging_interval_Stub(CMOCK_get_averaging_interval_CALLBACK Callback) +{ + Mock.get_averaging_interval_IgnoreBool = (char)0; + Mock.get_averaging_interval_CallbackBool = (char)0; + Mock.get_averaging_interval_CallbackFunctionPointer = Callback; +} + +void get_averaging_interval_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* pai, int pai_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_CALL_INSTANCE)); + CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_averaging_interval(cmock_call_instance, id, pai, pai_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_averaging_interval_CMockReturnMemThruPtr_pai(UNITY_LINE_TYPE cmock_line, uint32_t* pai, size_t cmock_size) +{ + CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pai_Used = 1; + cmock_call_instance->ReturnThruPtr_pai_Val = pai; + cmock_call_instance->ReturnThruPtr_pai_Size = cmock_size; +} + +void get_averaging_interval_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_id = 1; +} + +void get_averaging_interval_CMockIgnoreArg_pai(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_averaging_interval_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pai = 1; +} + +int get_averaging_interval_step(fwk_id_t id, uint32_t* pai_step) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_get_averaging_interval_step); + cmock_call_instance = (CMOCK_get_averaging_interval_step_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_averaging_interval_step_CallInstance); + Mock.get_averaging_interval_step_CallInstance = CMock_Guts_MemNext(Mock.get_averaging_interval_step_CallInstance); + if (Mock.get_averaging_interval_step_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.get_averaging_interval_step_FinalReturn; + Mock.get_averaging_interval_step_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.get_averaging_interval_step_CallbackBool && + Mock.get_averaging_interval_step_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.get_averaging_interval_step_CallbackFunctionPointer(id, pai_step, Mock.get_averaging_interval_step_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_id) + { + UNITY_SET_DETAILS(CMockString_get_averaging_interval_step,CMockString_id); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_id), (void*)(&id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pai_step) + { + UNITY_SET_DETAILS(CMockString_get_averaging_interval_step,CMockString_pai_step); + if (cmock_call_instance->Expected_pai_step == NULL) + { UNITY_TEST_ASSERT_NULL(pai_step, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_pai_step, pai_step, cmock_call_instance->Expected_pai_step_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.get_averaging_interval_step_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.get_averaging_interval_step_CallbackFunctionPointer(id, pai_step, Mock.get_averaging_interval_step_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pai_step_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pai_step, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pai_step, (void*)cmock_call_instance->ReturnThruPtr_pai_step_Val, + cmock_call_instance->ReturnThruPtr_pai_step_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_get_averaging_interval_step(CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* pai_step, int pai_step_Depth); +void CMockExpectParameters_get_averaging_interval_step(CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* pai_step, int pai_step_Depth) +{ + memcpy((void*)(&cmock_call_instance->Expected_id), (void*)(&id), + sizeof(fwk_id_t[sizeof(id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_id = 0; + cmock_call_instance->Expected_pai_step = pai_step; + cmock_call_instance->Expected_pai_step_Depth = pai_step_Depth; + cmock_call_instance->IgnoreArg_pai_step = 0; + cmock_call_instance->ReturnThruPtr_pai_step_Used = 0; +} + +void get_averaging_interval_step_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_step_CALL_INSTANCE)); + CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_step_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_step_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_step_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_step_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.get_averaging_interval_step_IgnoreBool = (char)1; +} + +void get_averaging_interval_step_CMockStopIgnore(void) +{ + if(Mock.get_averaging_interval_step_IgnoreBool) + Mock.get_averaging_interval_step_CallInstance = CMock_Guts_MemNext(Mock.get_averaging_interval_step_CallInstance); + Mock.get_averaging_interval_step_IgnoreBool = (char)0; +} + +void get_averaging_interval_step_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_step_CALL_INSTANCE)); + CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_step_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_step_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_step_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_step_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void get_averaging_interval_step_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* pai_step, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_step_CALL_INSTANCE)); + CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_step_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_step_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_step_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_step_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_averaging_interval_step(cmock_call_instance, id, pai_step, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_averaging_interval_step_AddCallback(CMOCK_get_averaging_interval_step_CALLBACK Callback) +{ + Mock.get_averaging_interval_step_IgnoreBool = (char)0; + Mock.get_averaging_interval_step_CallbackBool = (char)1; + Mock.get_averaging_interval_step_CallbackFunctionPointer = Callback; +} + +void get_averaging_interval_step_Stub(CMOCK_get_averaging_interval_step_CALLBACK Callback) +{ + Mock.get_averaging_interval_step_IgnoreBool = (char)0; + Mock.get_averaging_interval_step_CallbackBool = (char)0; + Mock.get_averaging_interval_step_CallbackFunctionPointer = Callback; +} + +void get_averaging_interval_step_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* pai_step, int pai_step_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_step_CALL_INSTANCE)); + CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_step_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_step_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_step_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_step_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_averaging_interval_step(cmock_call_instance, id, pai_step, pai_step_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_averaging_interval_step_CMockReturnMemThruPtr_pai_step(UNITY_LINE_TYPE cmock_line, uint32_t* pai_step, size_t cmock_size) +{ + CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_step_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_step_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pai_step_Used = 1; + cmock_call_instance->ReturnThruPtr_pai_step_Val = pai_step; + cmock_call_instance->ReturnThruPtr_pai_step_Size = cmock_size; +} + +void get_averaging_interval_step_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_step_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_step_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_id = 1; +} + +void get_averaging_interval_step_CMockIgnoreArg_pai_step(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_averaging_interval_step_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_step_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_step_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pai_step = 1; +} + +int get_averaging_interval_range(fwk_id_t id, uint32_t* min_pai, uint32_t* max_pai) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_get_averaging_interval_range); + cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_averaging_interval_range_CallInstance); + Mock.get_averaging_interval_range_CallInstance = CMock_Guts_MemNext(Mock.get_averaging_interval_range_CallInstance); + if (Mock.get_averaging_interval_range_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.get_averaging_interval_range_FinalReturn; + Mock.get_averaging_interval_range_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.get_averaging_interval_range_CallbackBool && + Mock.get_averaging_interval_range_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.get_averaging_interval_range_CallbackFunctionPointer(id, min_pai, max_pai, Mock.get_averaging_interval_range_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_id) + { + UNITY_SET_DETAILS(CMockString_get_averaging_interval_range,CMockString_id); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_id), (void*)(&id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_min_pai) + { + UNITY_SET_DETAILS(CMockString_get_averaging_interval_range,CMockString_min_pai); + if (cmock_call_instance->Expected_min_pai == NULL) + { UNITY_TEST_ASSERT_NULL(min_pai, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_min_pai, min_pai, cmock_call_instance->Expected_min_pai_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_max_pai) + { + UNITY_SET_DETAILS(CMockString_get_averaging_interval_range,CMockString_max_pai); + if (cmock_call_instance->Expected_max_pai == NULL) + { UNITY_TEST_ASSERT_NULL(max_pai, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_max_pai, max_pai, cmock_call_instance->Expected_max_pai_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.get_averaging_interval_range_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.get_averaging_interval_range_CallbackFunctionPointer(id, min_pai, max_pai, Mock.get_averaging_interval_range_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_min_pai_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(min_pai, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)min_pai, (void*)cmock_call_instance->ReturnThruPtr_min_pai_Val, + cmock_call_instance->ReturnThruPtr_min_pai_Size); + } + if (cmock_call_instance->ReturnThruPtr_max_pai_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(max_pai, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)max_pai, (void*)cmock_call_instance->ReturnThruPtr_max_pai_Val, + cmock_call_instance->ReturnThruPtr_max_pai_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_get_averaging_interval_range(CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* min_pai, int min_pai_Depth, uint32_t* max_pai, int max_pai_Depth); +void CMockExpectParameters_get_averaging_interval_range(CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t* min_pai, int min_pai_Depth, uint32_t* max_pai, int max_pai_Depth) +{ + memcpy((void*)(&cmock_call_instance->Expected_id), (void*)(&id), + sizeof(fwk_id_t[sizeof(id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_id = 0; + cmock_call_instance->Expected_min_pai = min_pai; + cmock_call_instance->Expected_min_pai_Depth = min_pai_Depth; + cmock_call_instance->IgnoreArg_min_pai = 0; + cmock_call_instance->ReturnThruPtr_min_pai_Used = 0; + cmock_call_instance->Expected_max_pai = max_pai; + cmock_call_instance->Expected_max_pai_Depth = max_pai_Depth; + cmock_call_instance->IgnoreArg_max_pai = 0; + cmock_call_instance->ReturnThruPtr_max_pai_Used = 0; +} + +void get_averaging_interval_range_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_range_CALL_INSTANCE)); + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_range_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_range_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_range_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.get_averaging_interval_range_IgnoreBool = (char)1; +} + +void get_averaging_interval_range_CMockStopIgnore(void) +{ + if(Mock.get_averaging_interval_range_IgnoreBool) + Mock.get_averaging_interval_range_CallInstance = CMock_Guts_MemNext(Mock.get_averaging_interval_range_CallInstance); + Mock.get_averaging_interval_range_IgnoreBool = (char)0; +} + +void get_averaging_interval_range_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_range_CALL_INSTANCE)); + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_range_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_range_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_range_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + cmock_call_instance->ExpectAnyArgsBool = (char)1; +} + +void get_averaging_interval_range_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* min_pai, uint32_t* max_pai, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_range_CALL_INSTANCE)); + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_range_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_range_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_range_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_averaging_interval_range(cmock_call_instance, id, min_pai, 1, max_pai, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_averaging_interval_range_AddCallback(CMOCK_get_averaging_interval_range_CALLBACK Callback) +{ + Mock.get_averaging_interval_range_IgnoreBool = (char)0; + Mock.get_averaging_interval_range_CallbackBool = (char)1; + Mock.get_averaging_interval_range_CallbackFunctionPointer = Callback; +} + +void get_averaging_interval_range_Stub(CMOCK_get_averaging_interval_range_CALLBACK Callback) +{ + Mock.get_averaging_interval_range_IgnoreBool = (char)0; + Mock.get_averaging_interval_range_CallbackBool = (char)0; + Mock.get_averaging_interval_range_CallbackFunctionPointer = Callback; +} + +void get_averaging_interval_range_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* min_pai, int min_pai_Depth, uint32_t* max_pai, int max_pai_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_averaging_interval_range_CALL_INSTANCE)); + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); + memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); + Mock.get_averaging_interval_range_CallInstance = CMock_Guts_MemChain(Mock.get_averaging_interval_range_CallInstance, cmock_guts_index); + Mock.get_averaging_interval_range_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_averaging_interval_range(cmock_call_instance, id, min_pai, min_pai_Depth, max_pai, max_pai_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_averaging_interval_range_CMockReturnMemThruPtr_min_pai(UNITY_LINE_TYPE cmock_line, uint32_t* min_pai, size_t cmock_size) +{ + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_range_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_min_pai_Used = 1; + cmock_call_instance->ReturnThruPtr_min_pai_Val = min_pai; + cmock_call_instance->ReturnThruPtr_min_pai_Size = cmock_size; +} + +void get_averaging_interval_range_CMockReturnMemThruPtr_max_pai(UNITY_LINE_TYPE cmock_line, uint32_t* max_pai, size_t cmock_size) +{ + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_range_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_max_pai_Used = 1; + cmock_call_instance->ReturnThruPtr_max_pai_Val = max_pai; + cmock_call_instance->ReturnThruPtr_max_pai_Size = cmock_size; +} + +void get_averaging_interval_range_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_range_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_id = 1; +} + +void get_averaging_interval_range_CMockIgnoreArg_min_pai(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_range_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_min_pai = 1; +} + +void get_averaging_interval_range_CMockIgnoreArg_max_pai(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_averaging_interval_range_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_averaging_interval_range_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_averaging_interval_range_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_max_pai = 1; +} + diff --git a/module/scmi_power_capping/test/mocks/Mockmod_power_capping_extra.h b/module/scmi_power_capping/test/mocks/Mockmod_power_capping_extra.h index 9ae843d16..71ea7b54b 100644 --- a/module/scmi_power_capping/test/mocks/Mockmod_power_capping_extra.h +++ b/module/scmi_power_capping/test/mocks/Mockmod_power_capping_extra.h @@ -62,6 +62,116 @@ void request_cap_Stub(CMOCK_request_cap_CALLBACK Callback); void request_cap_CMockIgnoreArg_domain_id(UNITY_LINE_TYPE cmock_line); #define request_cap_IgnoreArg_cap() request_cap_CMockIgnoreArg_cap(__LINE__) void request_cap_CMockIgnoreArg_cap(UNITY_LINE_TYPE cmock_line); +#define get_average_power_IgnoreAndReturn(cmock_retval) get_average_power_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void get_average_power_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_average_power_StopIgnore() get_average_power_CMockStopIgnore() +void get_average_power_CMockStopIgnore(void); +#define get_average_power_ExpectAnyArgsAndReturn(cmock_retval) get_average_power_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void get_average_power_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_average_power_ExpectAndReturn(id, power, cmock_retval) get_average_power_CMockExpectAndReturn(__LINE__, id, power, cmock_retval) +void get_average_power_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power, int cmock_to_return); +typedef int (* CMOCK_get_average_power_CALLBACK)(fwk_id_t id, uint32_t* power, int cmock_num_calls); +void get_average_power_AddCallback(CMOCK_get_average_power_CALLBACK Callback); +void get_average_power_Stub(CMOCK_get_average_power_CALLBACK Callback); +#define get_average_power_StubWithCallback get_average_power_Stub +#define get_average_power_ExpectWithArrayAndReturn(id, power, power_Depth, cmock_retval) get_average_power_CMockExpectWithArrayAndReturn(__LINE__, id, power, power_Depth, cmock_retval) +void get_average_power_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* power, int power_Depth, int cmock_to_return); +#define get_average_power_ReturnThruPtr_power(power) get_average_power_CMockReturnMemThruPtr_power(__LINE__, power, sizeof(uint32_t)) +#define get_average_power_ReturnArrayThruPtr_power(power, cmock_len) get_average_power_CMockReturnMemThruPtr_power(__LINE__, power, cmock_len * sizeof(*power)) +#define get_average_power_ReturnMemThruPtr_power(power, cmock_size) get_average_power_CMockReturnMemThruPtr_power(__LINE__, power, cmock_size) +void get_average_power_CMockReturnMemThruPtr_power(UNITY_LINE_TYPE cmock_line, uint32_t* power, size_t cmock_size); +#define get_average_power_IgnoreArg_id() get_average_power_CMockIgnoreArg_id(__LINE__) +void get_average_power_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); +#define get_average_power_IgnoreArg_power() get_average_power_CMockIgnoreArg_power(__LINE__) +void get_average_power_CMockIgnoreArg_power(UNITY_LINE_TYPE cmock_line); +#define set_averaging_interval_IgnoreAndReturn(cmock_retval) set_averaging_interval_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void set_averaging_interval_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define set_averaging_interval_StopIgnore() set_averaging_interval_CMockStopIgnore() +void set_averaging_interval_CMockStopIgnore(void); +#define set_averaging_interval_ExpectAnyArgsAndReturn(cmock_retval) set_averaging_interval_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void set_averaging_interval_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define set_averaging_interval_ExpectAndReturn(id, pai, cmock_retval) set_averaging_interval_CMockExpectAndReturn(__LINE__, id, pai, cmock_retval) +void set_averaging_interval_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t pai, int cmock_to_return); +typedef int (* CMOCK_set_averaging_interval_CALLBACK)(fwk_id_t id, uint32_t pai, int cmock_num_calls); +void set_averaging_interval_AddCallback(CMOCK_set_averaging_interval_CALLBACK Callback); +void set_averaging_interval_Stub(CMOCK_set_averaging_interval_CALLBACK Callback); +#define set_averaging_interval_StubWithCallback set_averaging_interval_Stub +#define set_averaging_interval_IgnoreArg_id() set_averaging_interval_CMockIgnoreArg_id(__LINE__) +void set_averaging_interval_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); +#define set_averaging_interval_IgnoreArg_pai() set_averaging_interval_CMockIgnoreArg_pai(__LINE__) +void set_averaging_interval_CMockIgnoreArg_pai(UNITY_LINE_TYPE cmock_line); +#define get_averaging_interval_IgnoreAndReturn(cmock_retval) get_averaging_interval_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void get_averaging_interval_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_averaging_interval_StopIgnore() get_averaging_interval_CMockStopIgnore() +void get_averaging_interval_CMockStopIgnore(void); +#define get_averaging_interval_ExpectAnyArgsAndReturn(cmock_retval) get_averaging_interval_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void get_averaging_interval_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_averaging_interval_ExpectAndReturn(id, pai, cmock_retval) get_averaging_interval_CMockExpectAndReturn(__LINE__, id, pai, cmock_retval) +void get_averaging_interval_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* pai, int cmock_to_return); +typedef int (* CMOCK_get_averaging_interval_CALLBACK)(fwk_id_t id, uint32_t* pai, int cmock_num_calls); +void get_averaging_interval_AddCallback(CMOCK_get_averaging_interval_CALLBACK Callback); +void get_averaging_interval_Stub(CMOCK_get_averaging_interval_CALLBACK Callback); +#define get_averaging_interval_StubWithCallback get_averaging_interval_Stub +#define get_averaging_interval_ExpectWithArrayAndReturn(id, pai, pai_Depth, cmock_retval) get_averaging_interval_CMockExpectWithArrayAndReturn(__LINE__, id, pai, pai_Depth, cmock_retval) +void get_averaging_interval_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* pai, int pai_Depth, int cmock_to_return); +#define get_averaging_interval_ReturnThruPtr_pai(pai) get_averaging_interval_CMockReturnMemThruPtr_pai(__LINE__, pai, sizeof(uint32_t)) +#define get_averaging_interval_ReturnArrayThruPtr_pai(pai, cmock_len) get_averaging_interval_CMockReturnMemThruPtr_pai(__LINE__, pai, cmock_len * sizeof(*pai)) +#define get_averaging_interval_ReturnMemThruPtr_pai(pai, cmock_size) get_averaging_interval_CMockReturnMemThruPtr_pai(__LINE__, pai, cmock_size) +void get_averaging_interval_CMockReturnMemThruPtr_pai(UNITY_LINE_TYPE cmock_line, uint32_t* pai, size_t cmock_size); +#define get_averaging_interval_IgnoreArg_id() get_averaging_interval_CMockIgnoreArg_id(__LINE__) +void get_averaging_interval_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); +#define get_averaging_interval_IgnoreArg_pai() get_averaging_interval_CMockIgnoreArg_pai(__LINE__) +void get_averaging_interval_CMockIgnoreArg_pai(UNITY_LINE_TYPE cmock_line); +#define get_averaging_interval_step_IgnoreAndReturn(cmock_retval) get_averaging_interval_step_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void get_averaging_interval_step_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_averaging_interval_step_StopIgnore() get_averaging_interval_step_CMockStopIgnore() +void get_averaging_interval_step_CMockStopIgnore(void); +#define get_averaging_interval_step_ExpectAnyArgsAndReturn(cmock_retval) get_averaging_interval_step_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void get_averaging_interval_step_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_averaging_interval_step_ExpectAndReturn(id, pai_step, cmock_retval) get_averaging_interval_step_CMockExpectAndReturn(__LINE__, id, pai_step, cmock_retval) +void get_averaging_interval_step_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* pai_step, int cmock_to_return); +typedef int (* CMOCK_get_averaging_interval_step_CALLBACK)(fwk_id_t id, uint32_t* pai_step, int cmock_num_calls); +void get_averaging_interval_step_AddCallback(CMOCK_get_averaging_interval_step_CALLBACK Callback); +void get_averaging_interval_step_Stub(CMOCK_get_averaging_interval_step_CALLBACK Callback); +#define get_averaging_interval_step_StubWithCallback get_averaging_interval_step_Stub +#define get_averaging_interval_step_ExpectWithArrayAndReturn(id, pai_step, pai_step_Depth, cmock_retval) get_averaging_interval_step_CMockExpectWithArrayAndReturn(__LINE__, id, pai_step, pai_step_Depth, cmock_retval) +void get_averaging_interval_step_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* pai_step, int pai_step_Depth, int cmock_to_return); +#define get_averaging_interval_step_ReturnThruPtr_pai_step(pai_step) get_averaging_interval_step_CMockReturnMemThruPtr_pai_step(__LINE__, pai_step, sizeof(uint32_t)) +#define get_averaging_interval_step_ReturnArrayThruPtr_pai_step(pai_step, cmock_len) get_averaging_interval_step_CMockReturnMemThruPtr_pai_step(__LINE__, pai_step, cmock_len * sizeof(*pai_step)) +#define get_averaging_interval_step_ReturnMemThruPtr_pai_step(pai_step, cmock_size) get_averaging_interval_step_CMockReturnMemThruPtr_pai_step(__LINE__, pai_step, cmock_size) +void get_averaging_interval_step_CMockReturnMemThruPtr_pai_step(UNITY_LINE_TYPE cmock_line, uint32_t* pai_step, size_t cmock_size); +#define get_averaging_interval_step_IgnoreArg_id() get_averaging_interval_step_CMockIgnoreArg_id(__LINE__) +void get_averaging_interval_step_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); +#define get_averaging_interval_step_IgnoreArg_pai_step() get_averaging_interval_step_CMockIgnoreArg_pai_step(__LINE__) +void get_averaging_interval_step_CMockIgnoreArg_pai_step(UNITY_LINE_TYPE cmock_line); +#define get_averaging_interval_range_IgnoreAndReturn(cmock_retval) get_averaging_interval_range_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void get_averaging_interval_range_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_averaging_interval_range_StopIgnore() get_averaging_interval_range_CMockStopIgnore() +void get_averaging_interval_range_CMockStopIgnore(void); +#define get_averaging_interval_range_ExpectAnyArgsAndReturn(cmock_retval) get_averaging_interval_range_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void get_averaging_interval_range_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_averaging_interval_range_ExpectAndReturn(id, min_pai, max_pai, cmock_retval) get_averaging_interval_range_CMockExpectAndReturn(__LINE__, id, min_pai, max_pai, cmock_retval) +void get_averaging_interval_range_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* min_pai, uint32_t* max_pai, int cmock_to_return); +typedef int (* CMOCK_get_averaging_interval_range_CALLBACK)(fwk_id_t id, uint32_t* min_pai, uint32_t* max_pai, int cmock_num_calls); +void get_averaging_interval_range_AddCallback(CMOCK_get_averaging_interval_range_CALLBACK Callback); +void get_averaging_interval_range_Stub(CMOCK_get_averaging_interval_range_CALLBACK Callback); +#define get_averaging_interval_range_StubWithCallback get_averaging_interval_range_Stub +#define get_averaging_interval_range_ExpectWithArrayAndReturn(id, min_pai, min_pai_Depth, max_pai, max_pai_Depth, cmock_retval) get_averaging_interval_range_CMockExpectWithArrayAndReturn(__LINE__, id, min_pai, min_pai_Depth, max_pai, max_pai_Depth, cmock_retval) +void get_averaging_interval_range_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t* min_pai, int min_pai_Depth, uint32_t* max_pai, int max_pai_Depth, int cmock_to_return); +#define get_averaging_interval_range_ReturnThruPtr_min_pai(min_pai) get_averaging_interval_range_CMockReturnMemThruPtr_min_pai(__LINE__, min_pai, sizeof(uint32_t)) +#define get_averaging_interval_range_ReturnArrayThruPtr_min_pai(min_pai, cmock_len) get_averaging_interval_range_CMockReturnMemThruPtr_min_pai(__LINE__, min_pai, cmock_len * sizeof(*min_pai)) +#define get_averaging_interval_range_ReturnMemThruPtr_min_pai(min_pai, cmock_size) get_averaging_interval_range_CMockReturnMemThruPtr_min_pai(__LINE__, min_pai, cmock_size) +void get_averaging_interval_range_CMockReturnMemThruPtr_min_pai(UNITY_LINE_TYPE cmock_line, uint32_t* min_pai, size_t cmock_size); +#define get_averaging_interval_range_ReturnThruPtr_max_pai(max_pai) get_averaging_interval_range_CMockReturnMemThruPtr_max_pai(__LINE__, max_pai, sizeof(uint32_t)) +#define get_averaging_interval_range_ReturnArrayThruPtr_max_pai(max_pai, cmock_len) get_averaging_interval_range_CMockReturnMemThruPtr_max_pai(__LINE__, max_pai, cmock_len * sizeof(*max_pai)) +#define get_averaging_interval_range_ReturnMemThruPtr_max_pai(max_pai, cmock_size) get_averaging_interval_range_CMockReturnMemThruPtr_max_pai(__LINE__, max_pai, cmock_size) +void get_averaging_interval_range_CMockReturnMemThruPtr_max_pai(UNITY_LINE_TYPE cmock_line, uint32_t* max_pai, size_t cmock_size); +#define get_averaging_interval_range_IgnoreArg_id() get_averaging_interval_range_CMockIgnoreArg_id(__LINE__) +void get_averaging_interval_range_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); +#define get_averaging_interval_range_IgnoreArg_min_pai() get_averaging_interval_range_CMockIgnoreArg_min_pai(__LINE__) +void get_averaging_interval_range_CMockIgnoreArg_min_pai(UNITY_LINE_TYPE cmock_line); +#define get_averaging_interval_range_IgnoreArg_max_pai() get_averaging_interval_range_CMockIgnoreArg_max_pai(__LINE__) +void get_averaging_interval_range_CMockIgnoreArg_max_pai(UNITY_LINE_TYPE cmock_line); #if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__) #if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0))) diff --git a/module/scmi_power_capping/test/mod_power_capping_extra.h b/module/scmi_power_capping/test/mod_power_capping_extra.h index 35e482272..85e38262c 100644 --- a/module/scmi_power_capping/test/mod_power_capping_extra.h +++ b/module/scmi_power_capping/test/mod_power_capping_extra.h @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ @@ -13,4 +13,12 @@ int get_applied_cap(fwk_id_t domain_id, uint32_t *cap); int request_cap(fwk_id_t domain_id, uint32_t cap); +int get_average_power(fwk_id_t id, uint32_t *power); +int set_averaging_interval(fwk_id_t id, uint32_t pai); +int get_averaging_interval(fwk_id_t id, uint32_t *pai); +int get_averaging_interval_step(fwk_id_t id, uint32_t *pai_step); +int get_averaging_interval_range( + fwk_id_t id, + uint32_t *min_pai, + uint32_t *max_pai); #endif /* MOD_POWER_CAPPING_EXTRA_H_ */ diff --git a/module/scmi_power_capping/test/scmi_power_capping_protocol_unit_test.c b/module/scmi_power_capping/test/scmi_power_capping_protocol_unit_test.c index 40509bf9e..5836f38a1 100644 --- a/module/scmi_power_capping/test/scmi_power_capping_protocol_unit_test.c +++ b/module/scmi_power_capping/test/scmi_power_capping_protocol_unit_test.c @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ @@ -88,6 +88,11 @@ static const struct mod_scmi_from_protocol_api scmi_api = { static const struct mod_power_capping_api power_capping_api = { .get_applied_cap = get_applied_cap, .request_cap = request_cap, + .get_average_power = get_average_power, + .get_averaging_interval = get_averaging_interval, + .get_averaging_interval_range = get_averaging_interval_range, + .get_averaging_interval_step = get_averaging_interval_step, + .set_averaging_interval = set_averaging_interval, }; static const struct mod_power_coordinator_api power_coordinator_api = { @@ -417,6 +422,22 @@ void utest_message_handler_domain_attributes_valid(void) .parent_id = config->parent_idx, }; + uint32_t expected_pai_step = config->pai_step; + uint32_t expected_min_pai = config->min_pai; + uint32_t expected_max_pai = config->max_pai; + + get_averaging_interval_step_ExpectAndReturn( + config->power_capping_domain_id, NULL, FWK_SUCCESS); + get_averaging_interval_step_IgnoreArg_pai_step(); + get_averaging_interval_step_ReturnThruPtr_pai_step(&expected_pai_step); + + get_averaging_interval_range_ExpectAndReturn( + config->power_capping_domain_id, NULL, NULL, FWK_SUCCESS); + get_averaging_interval_range_IgnoreArg_min_pai(); + get_averaging_interval_range_IgnoreArg_max_pai(); + get_averaging_interval_range_ReturnThruPtr_min_pai(&expected_min_pai); + get_averaging_interval_range_ReturnThruPtr_max_pai(&expected_max_pai); + #ifdef BUILD_HAS_SCMI_NOTIFICATIONS ret_payload.attributes |= config->cap_pai_change_notification_support << POWER_CAPPING_NOTIF_SUP_POS; @@ -726,13 +747,12 @@ void utest_message_handler_power_capping_get_pai_valid(void) .pai = pai, }; - get_coordinator_period_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, - &pai, - sizeof(pai), + get_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + NULL, FWK_SUCCESS); - get_coordinator_period_IgnoreArg_period(); - get_coordinator_period_ReturnMemThruPtr_period(&pai, sizeof(pai)); + get_averaging_interval_IgnoreArg_pai(); + get_averaging_interval_ReturnThruPtr_pai(&pai); mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); @@ -742,8 +762,6 @@ void utest_message_handler_power_capping_get_pai_valid(void) void utest_message_handler_power_capping_get_pai_failure(void) { - uint32_t pai = __LINE__; /* Arbitrary value */ - struct scmi_power_capping_pai_get_a2p cmd_payload = { .domain_id = FAKE_POWER_CAPPING_IDX_1 }; @@ -752,12 +770,11 @@ void utest_message_handler_power_capping_get_pai_failure(void) .status = SCMI_GENERIC_ERROR, }; - get_coordinator_period_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, - &pai, - sizeof(pai), + get_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + NULL, FWK_E_DEVICE); - get_coordinator_period_IgnoreArg_period(); + get_averaging_interval_IgnoreArg_pai(); mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); @@ -784,8 +801,8 @@ void utest_message_handler_power_capping_set_pai_valid(void) fwk_id_is_equal_ExpectAndReturn(FWK_ID_NONE, FWK_ID_NONE, true); #endif - set_coordinator_period_ExpectAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, + set_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, pai, FWK_SUCCESS); @@ -814,8 +831,8 @@ void utest_message_handler_power_capping_set_pai_failure(void) fwk_id_is_equal_ExpectAndReturn(FWK_ID_NONE, FWK_ID_NONE, true); #endif - set_coordinator_period_ExpectAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, + set_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, pai, FWK_E_DEVICE); @@ -879,21 +896,19 @@ void utest_message_handler_power_capping_get_power_measurement_valid(void) .pai = pai, }; - get_power_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_meter_domain_id, - &power, - sizeof(power), + get_average_power_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + NULL, FWK_SUCCESS); - get_power_IgnoreArg_power(); - get_power_ReturnMemThruPtr_power(&power, sizeof(power)); + get_average_power_IgnoreArg_power(); + get_average_power_ReturnThruPtr_power(&power); - get_coordinator_period_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, - &pai, - sizeof(pai), + get_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + NULL, FWK_SUCCESS); - get_coordinator_period_IgnoreArg_period(); - get_coordinator_period_ReturnMemThruPtr_period(&pai, sizeof(pai)); + get_averaging_interval_IgnoreArg_pai(); + get_averaging_interval_ReturnThruPtr_pai(&pai); mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); @@ -903,8 +918,6 @@ void utest_message_handler_power_capping_get_power_measurement_valid(void) void utest_message_handler_power_capping_get_power_measurement_failure(void) { - uint32_t power = __LINE__; /* Arbitrary value */ - struct scmi_power_capping_measurements_get_a2p cmd_payload = { .domain_id = FAKE_POWER_CAPPING_IDX_1, }; @@ -913,12 +926,11 @@ void utest_message_handler_power_capping_get_power_measurement_failure(void) .status = SCMI_GENERIC_ERROR, }; - get_power_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_meter_domain_id, - &power, - sizeof(power), + get_average_power_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + NULL, FWK_E_DEVICE); - get_power_IgnoreArg_power(); + get_average_power_IgnoreArg_power(); mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); -- GitLab From 9f888c299281a51a9e721ab8ef8b6b568b05bc48 Mon Sep 17 00:00:00 2001 From: Mahmoud Elsabbagh Date: Mon, 10 Feb 2025 11:20:11 +0000 Subject: [PATCH 2/2] scmi_power_capping: Remove Power Coordinator and Power Meter. Remove power_coordinator and power_meter files and all their dependecies in scmi_power_capping and replace the apis with the ones provided in power_capping_hal. Signed-off-by: Mahmoud Elsabbagh --- .../power_capping/include/mod_power_capping.h | 6 + .../include/mod_power_coordinator.h | 86 ---- module/power_meter/include/mod_power_meter.h | 122 ----- module/scmi_power_capping/CMakeLists.txt | 4 +- .../include/internal/scmi_power_capping.h | 15 +- .../internal/scmi_power_capping_protocol.h | 5 +- .../include/mod_scmi_power_capping.h | 31 +- .../src/mod_scmi_power_capping.c | 28 +- .../src/scmi_power_capping_fast_channels.c | 18 +- .../src/scmi_power_capping_protocol.c | 123 ++++-- module/scmi_power_capping/test/CMakeLists.txt | 14 +- .../mocks/Mockmod_power_coordinator_extra.c | 399 ----------------- .../mocks/Mockmod_power_coordinator_extra.h | 72 --- .../test/mocks/Mockmod_power_meter_extra.c | 418 ------------------ .../test/mocks/Mockmod_power_meter_extra.h | 74 ---- .../test/mod_power_coordinator_extra.h | 15 - .../test/mod_power_meter_extra.h | 19 - .../test/mod_scmi_power_capping_unit_test.c | 32 +- ...mi_power_capping_fast_channels_unit_test.c | 41 +- .../scmi_power_capping_protocol_unit_test.c | 98 ++-- 20 files changed, 169 insertions(+), 1451 deletions(-) delete mode 100644 module/power_coordinator/include/mod_power_coordinator.h delete mode 100644 module/power_meter/include/mod_power_meter.h delete mode 100644 module/scmi_power_capping/test/mocks/Mockmod_power_coordinator_extra.c delete mode 100644 module/scmi_power_capping/test/mocks/Mockmod_power_coordinator_extra.h delete mode 100644 module/scmi_power_capping/test/mocks/Mockmod_power_meter_extra.c delete mode 100644 module/scmi_power_capping/test/mocks/Mockmod_power_meter_extra.h delete mode 100644 module/scmi_power_capping/test/mod_power_coordinator_extra.h delete mode 100644 module/scmi_power_capping/test/mod_power_meter_extra.h diff --git a/module/power_capping/include/mod_power_capping.h b/module/power_capping/include/mod_power_capping.h index 8a893dc1f..3ce86f289 100644 --- a/module/power_capping/include/mod_power_capping.h +++ b/module/power_capping/include/mod_power_capping.h @@ -240,6 +240,12 @@ enum mod_power_capping_notification_idx { /*! Power cap change notification. */ MOD_POWER_CAPPING_NOTIFICATION_IDX_CAP_CHANGE, + /*! PAI changed notification. */ + MOD_POWER_CAPPING_NOTIFICATION_IDX_PAI_CHANGED, + + /*! Measurements changed notification. */ + MOD_POWER_CAPPING_NOTIFICATION_IDX_MEASUREMENTS_CHANGED, + /*! Number of defined notifications. */ MOD_POWER_CAPPING_NOTIFICATION_IDX_COUNT, }; diff --git a/module/power_coordinator/include/mod_power_coordinator.h b/module/power_coordinator/include/mod_power_coordinator.h deleted file mode 100644 index c0b7ac238..000000000 --- a/module/power_coordinator/include/mod_power_coordinator.h +++ /dev/null @@ -1,86 +0,0 @@ -/* - * Arm SCP/MCP Software - * Copyright (c) 2023, Arm Limited and Contributors. All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause - * - * Description: - * Power coordinator module header. - */ - -#ifndef MOD_POWER_COORDINATOR_H -#define MOD_POWER_COORDINATOR_H - -#include - -#include - -/*! - * \addtogroup GroupModules Modules - * \{ - */ - -/*! - * \defgroup GroupPowerCoordinator Power coordinator - * - * \details Responsible for coordinating the modules related to the power - * management. - * - * \{ - */ - -/*! - * \brief Power coordinator interface. - */ -struct mod_power_coordinator_api { - /*! - * \brief Get the coordinator period. - * - * \param id Coordinator ID. - * \param[out] period The coordinator period. - * - * \retval ::FWK_SUCCESS The coordinator period is returned successfully. - */ - int (*get_coordinator_period)(fwk_id_t id, uint32_t *period); - - /*! - * \brief Set the coordinator period. - * - * \param id Coordinator ID. - * \param period The coordinator period. - * - * \retval ::FWK_SUCCESS The coordinator period is set successfully. - */ - int (*set_coordinator_period)(fwk_id_t id, uint32_t period); -}; - -/*! - * \brief API indices. - */ -enum mod_power_coordinator_api_idx { - /*! Power Coordinator period. */ - MOD_POWER_COORDINATOR_API_IDX_PERIOD, - - /*! Number of defined APIs. */ - MOD_POWER_COORDINATOR_API_IDX_COUNT, -}; - -/*! - * \brief Power coordinator notification indices. - */ -enum mod_power_coordinator_notification_idx { - /*! Period changed notification. */ - MOD_POWER_COORDINATOR_NOTIFICATION_IDX_PERIOD_CHANGED, - - /*! Number of defined notifications. */ - MOD_POWER_COORDINATOR_NOTIFICATION_IDX_COUNT, -}; - -/*! - * \} - */ - -/*! - * \} - */ -#endif /* MOD_POWER_COORDINATOR_H */ diff --git a/module/power_meter/include/mod_power_meter.h b/module/power_meter/include/mod_power_meter.h deleted file mode 100644 index 82afe3a42..000000000 --- a/module/power_meter/include/mod_power_meter.h +++ /dev/null @@ -1,122 +0,0 @@ -/* - * Arm SCP/MCP Software - * Copyright (c) 2023, Arm Limited and Contributors. All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause - * - * Description: - * Power meter module header. - */ - -#ifndef MOD_POWER_METER_H -#define MOD_POWER_METER_H - -#include - -/*! - * \addtogroup GroupModules Modules - * \{ - */ - -/*! - * \defgroup GroupPowerMeter Power meter - * - * \details Responsible for power measurements - * - * \{ - */ - -/*! - * \brief Power meter device configuration. - */ -struct mod_power_meter_dev_config { - /*! - * \brief Module or element identifier of the driver - */ - fwk_id_t driver_id; - /*! - * \brief API identifier of the driver. - */ - fwk_id_t driver_api_id; -}; - -/*! - * \brief Power meter driver interface. - */ -struct mod_power_meter_driver_api { - /*! - * \brief Get the power measurement. - * - * \param id Specific power meter device ID. - * \param[out] power Power measured by the power meter device. - * - * \retval ::FWK_SUCCESS The cap is returned successfully. - */ - int (*get_power)(fwk_id_t id, uint32_t *power); -}; - -/*! - * \brief Power meter interface. - */ -struct mod_power_meter_api { - /*! - * \brief Get the power measurement. - * - * \param id Specific power meter device ID. - * \param[out] power Power measured by the power meter device. - * - * \retval ::FWK_SUCCESS The cap is returned successfully. - */ - int (*get_power)(fwk_id_t id, uint32_t *power); - - /*! - * \brief Set the power change notification hysteresis. - * - * \details The hysteresis is needed to avoid multiple unneeded - * notifications for a fluctuating power measurement. - * - * \param id Specific power meter device ID. - * \param threshold_low The lower threshold of the measured power to trigger - * a notification. - * - * \param threshold_high The higher threshold of the measured power to - * trigger a notification. - * - * \retval ::FWK_SUCCESS The threshold values are set successfully. - */ - int (*set_power_change_notif_thresholds)( - fwk_id_t id, - uint32_t threshold_low, - uint32_t threshold_high); -}; - -/*! - * \brief API indices. - */ -enum mod_power_meter_api_idx { - /*! Get power measurements */ - MOD_POWER_METER_API_IDX_MEASUREMENT, - - /*! Number of defined APIs. */ - MOD_POWER_METER_API_IDX_COUNT, -}; - -/*! - * \brief Power meter notification indices. - */ -enum mod_power_meter_notification_idx { - /*! Measured power changed notification. */ - MOD_POWER_METER_NOTIFICATION_IDX_MEASUREMENTS_CHANGED, - - /*! Number of defined notifications. */ - MOD_POWER_METER_NOTIFICATION_IDX_COUNT, -}; - -/*! - * \} - */ - -/*! - * \} - */ -#endif /* MOD_POWER_METER_H */ diff --git a/module/scmi_power_capping/CMakeLists.txt b/module/scmi_power_capping/CMakeLists.txt index 891d1879c..a5a25ca4b 100644 --- a/module/scmi_power_capping/CMakeLists.txt +++ b/module/scmi_power_capping/CMakeLists.txt @@ -1,6 +1,6 @@ # # Arm SCP/MCP Software -# Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. +# Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause # @@ -13,8 +13,6 @@ target_include_directories(${SCP_MODULE_TARGET} target_sources(${SCP_MODULE_TARGET} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src/mod_scmi_power_capping.c") -target_link_libraries(${SCP_MODULE_TARGET} PRIVATE module-power-meter) -target_link_libraries(${SCP_MODULE_TARGET} PRIVATE module-power-coordinator) target_link_libraries(${SCP_MODULE_TARGET} PRIVATE module-power-capping) if(SCP_EXCLUDE_SCMI_POWER_CAPPING_STD_COMMANDS AND diff --git a/module/scmi_power_capping/include/internal/scmi_power_capping.h b/module/scmi_power_capping/include/internal/scmi_power_capping.h index 2e55f1540..f0f8958a5 100644 --- a/module/scmi_power_capping/include/internal/scmi_power_capping.h +++ b/module/scmi_power_capping/include/internal/scmi_power_capping.h @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -12,8 +12,6 @@ #define INTERNAL_SCMI_POWER_CAPPING_H #include "mod_power_capping.h" -#include "mod_power_coordinator.h" -#include "mod_power_meter.h" #include "mod_scmi_power_capping.h" #include @@ -51,12 +49,6 @@ enum scmi_power_capping_event_idx { struct mod_scmi_power_capping_power_apis { /* Power capping API */ const struct mod_power_capping_api *power_capping_api; - - /* Power coordinator API */ - const struct mod_power_coordinator_api *power_coordinator_api; - - /* Power meter API */ - const struct mod_power_meter_api *power_meter_api; }; struct mod_scmi_power_capping_domain_context { @@ -100,11 +92,6 @@ struct mod_scmi_power_capping_domain_context { * \brief Power capping configuration support. */ bool cap_config_support; - - /*! - * \brief PAI configuration support. - */ - bool pai_config_support; }; struct mod_scmi_power_capping_context { diff --git a/module/scmi_power_capping/include/internal/scmi_power_capping_protocol.h b/module/scmi_power_capping/include/internal/scmi_power_capping_protocol.h index f0a1bc961..3fb190a6f 100644 --- a/module/scmi_power_capping/include/internal/scmi_power_capping_protocol.h +++ b/module/scmi_power_capping/include/internal/scmi_power_capping_protocol.h @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -95,6 +95,9 @@ enum scmi_power_capping_notification_id { #define SCMI_POWER_CAPPING_DISABLE_CAP_VALUE ((uint32_t)0) #define SCMI_POWER_CAPPING_PAI_RESERVED_FLAG 0u + +#define UNSUPPORTED_CONFIG_PAI_VALUE 1u + /* * Power capping Domain attributes */ diff --git a/module/scmi_power_capping/include/mod_scmi_power_capping.h b/module/scmi_power_capping/include/mod_scmi_power_capping.h index e10b130f0..4e4ec4dc1 100644 --- a/module/scmi_power_capping/include/mod_scmi_power_capping.h +++ b/module/scmi_power_capping/include/mod_scmi_power_capping.h @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -69,30 +69,6 @@ struct scmi_pcapping_fch_config { */ struct mod_scmi_power_capping_domain_config { #ifdef BUILD_HAS_SCMI_POWER_CAPPING_STD_COMMANDS - /*! - * \brief Minimum PAI. - * - * \details The minimum supported power averaging interval (PAI), - * expressed in microseconds, its value cannot be zero. - */ - uint32_t min_pai; - - /*! - * \brief Maximum PAI. - * - * \details The maximum supported power averaging interval (PAI), - * expressed in microseconds, its value cannot be zero. - */ - uint32_t max_pai; - - /*! - * \brief PAI step. - * - * \details The step size between two consecutive PAI supported by - * this power capping domain. This value cannot be zero if min_pai and - * max_pai have different values. - */ - uint32_t pai_step; /*! * \brief Minimum power cap. * @@ -126,6 +102,11 @@ struct mod_scmi_power_capping_domain_config { */ uint32_t max_sustainable_power; + /*! + * \brief PAI configuration support. + */ + bool pai_config_support; + /*! * \brief Parent id. * diff --git a/module/scmi_power_capping/src/mod_scmi_power_capping.c b/module/scmi_power_capping/src/mod_scmi_power_capping.c index 5aecea238..0e4de4484 100644 --- a/module/scmi_power_capping/src/mod_scmi_power_capping.c +++ b/module/scmi_power_capping/src/mod_scmi_power_capping.c @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -11,7 +11,6 @@ #include "fwk_module_idx.h" #include "internal/scmi_power_capping_protocol.h" #include "mod_power_capping.h" -#include "mod_power_meter.h" #ifdef BUILD_HAS_SCMI_POWER_CAPPING_FAST_CHANNELS_COMMANDS # include "internal/scmi_power_capping.h" @@ -32,33 +31,10 @@ static const fwk_id_t mod_scmi_power_capping_event_id_fch_callback = static int scmi_power_capping_power_api_bind( struct mod_scmi_power_capping_power_apis *power_apis) { - int status; - - status = fwk_module_bind( + return fwk_module_bind( FWK_ID_MODULE(FWK_MODULE_IDX_POWER_CAPPING), FWK_ID_API(FWK_MODULE_IDX_POWER_CAPPING, MOD_POWER_CAPPING_API_IDX_CAP), &(power_apis->power_capping_api)); - - if (status != FWK_SUCCESS) { - return status; - } - - status = fwk_module_bind( - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_COORDINATOR), - FWK_ID_API( - FWK_MODULE_IDX_POWER_COORDINATOR, - MOD_POWER_COORDINATOR_API_IDX_PERIOD), - &(power_apis->power_coordinator_api)); - - if (status != FWK_SUCCESS) { - return status; - } - - return fwk_module_bind( - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_METER), - FWK_ID_API( - FWK_MODULE_IDX_POWER_METER, MOD_POWER_METER_API_IDX_MEASUREMENT), - &(power_apis->power_meter_api)); } #ifdef BUILD_HAS_SCMI_NOTIFICATIONS diff --git a/module/scmi_power_capping/src/scmi_power_capping_fast_channels.c b/module/scmi_power_capping/src/scmi_power_capping_fast_channels.c index e8d6cc22c..253814438 100644 --- a/module/scmi_power_capping/src/scmi_power_capping_fast_channels.c +++ b/module/scmi_power_capping/src/scmi_power_capping_fast_channels.c @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -54,14 +54,6 @@ static fwk_id_t pcapping_fast_channel_get_power_capping_id(uint32_t domain_idx) .config->power_capping_domain_id; } -static fwk_id_t pcapping_fast_channel_get_power_coordinator_id( - uint32_t domain_idx) -{ - return pcapping_fast_channel_global_ctx - .power_capping_domain_ctx_table[domain_idx] - .config->power_coordinator_domain_id; -} - static void pcapping_fast_channel_callback(uintptr_t param) { int status; @@ -122,8 +114,8 @@ static void pcapping_fast_channel_get_pai( int status; status = pcapping_fast_channel_global_ctx.power_management_apis - ->power_coordinator_api->get_coordinator_period( - pcapping_fast_channel_get_power_coordinator_id(domain_idx), + ->power_capping_api->get_averaging_interval( + pcapping_fast_channel_get_power_capping_id(domain_idx), fch_addr); if (status != FWK_SUCCESS) { FWK_LOG_ERR("[SCMI-Power-Capping-Fast-Channel] Error getting PAI."); @@ -137,8 +129,8 @@ static void pcapping_fast_channel_set_pai( int status; status = pcapping_fast_channel_global_ctx.power_management_apis - ->power_coordinator_api->set_coordinator_period( - pcapping_fast_channel_get_power_coordinator_id(domain_idx), + ->power_capping_api->set_averaging_interval( + pcapping_fast_channel_get_power_capping_id(domain_idx), *fch_addr); if (status != FWK_SUCCESS) { FWK_LOG_ERR("[SCMI-Power-Capping-Fast-Channel] Error setting PAI."); diff --git a/module/scmi_power_capping/src/scmi_power_capping_protocol.c b/module/scmi_power_capping/src/scmi_power_capping_protocol.c index 6fb74a2ab..f75e1165f 100644 --- a/module/scmi_power_capping/src/scmi_power_capping_protocol.c +++ b/module/scmi_power_capping/src/scmi_power_capping_protocol.c @@ -10,8 +10,6 @@ #include "internal/scmi_power_capping.h" #include "internal/scmi_power_capping_fast_channels.h" #include "internal/scmi_power_capping_protocol.h" -#include "mod_power_coordinator.h" -#include "mod_power_meter.h" #include #ifdef BUILD_HAS_MOD_RESOURCE_PERMS @@ -117,12 +115,12 @@ static const fwk_id_t pcapping_protocol_cap_notification = #ifdef BUILD_HAS_SCMI_NOTIFICATIONS static const fwk_id_t pcapping_protocol_pai_notification = FWK_ID_NOTIFICATION_INIT( - FWK_MODULE_IDX_POWER_COORDINATOR, - MOD_POWER_COORDINATOR_NOTIFICATION_IDX_PERIOD_CHANGED); + FWK_MODULE_IDX_POWER_CAPPING, + MOD_POWER_CAPPING_NOTIFICATION_IDX_PAI_CHANGED); static const fwk_id_t pcapping_protocol_power_measurements_notification = FWK_ID_NOTIFICATION_INIT( - FWK_MODULE_IDX_POWER_METER, - MOD_POWER_METER_NOTIFICATION_IDX_MEASUREMENTS_CHANGED); + FWK_MODULE_IDX_POWER_CAPPING, + MOD_POWER_CAPPING_NOTIFICATION_IDX_MEASUREMENTS_CHANGED); #endif static handler_table_t handler_table[MOD_SCMI_POWER_CAPPING_COMMAND_COUNT] = { @@ -239,6 +237,19 @@ static struct mod_scmi_power_capping_domain_context *get_domain_ctx( return &(pcapping_protocol_ctx.power_capping_domain_ctx_table[domain_idx]); } +/* + * Static helper function to set disabled pai values + */ +static void pcapping_protocol_set_disabled_pai_values( + uint32_t *pai_step, + uint32_t *min_pai, + uint32_t *max_pai) +{ + *pai_step = 0u; + *min_pai = UNSUPPORTED_CONFIG_PAI_VALUE; + *max_pai = UNSUPPORTED_CONFIG_PAI_VALUE; +} + /* * Static helper function to populate domain attributes return values. */ @@ -248,25 +259,15 @@ static inline void scmi_power_capping_populate_domain_attributes( { const struct mod_scmi_power_capping_domain_context *domain_ctx; const struct mod_scmi_power_capping_domain_config *config; - fwk_id_t domain_id; domain_ctx = get_domain_ctx(domain_idx); config = domain_ctx->config; return_values->attributes = SCMI_POWER_CAPPING_DOMAIN_ATTRIBUTES( domain_ctx->cap_config_support, - domain_ctx->pai_config_support, + config->pai_config_support, config->power_cap_unit); - domain_id = domain_ctx->config->power_capping_domain_id; - - pcapping_protocol_ctx.power_management_apis->power_capping_api - ->get_averaging_interval_step(domain_id, &return_values->pai_step); - - pcapping_protocol_ctx.power_management_apis->power_capping_api - ->get_averaging_interval_range( - domain_id, &return_values->min_pai, &return_values->max_pai); - #ifdef BUILD_HAS_SCMI_POWER_CAPPING_FAST_CHANNELS_COMMANDS return_values->attributes |= SCMI_POWER_CAPPING_DOMAIN_FCH_SUPPORT( pcapping_fast_channel_get_domain_supp(domain_idx)); @@ -279,11 +280,6 @@ static inline void scmi_power_capping_populate_domain_attributes( SCMI_POWER_CAPPING_DOMAIN_MEASUREMENTS_NOTIF_SUPPORT( config->power_measurements_change_notification_support); #endif - return_values->min_power_cap = config->min_power_cap; - return_values->max_power_cap = config->max_power_cap; - return_values->power_cap_step = config->power_cap_step; - return_values->max_sustainable_power = config->max_sustainable_power; - return_values->parent_id = config->parent_idx; } /* @@ -305,17 +301,10 @@ static int pcapping_protocol_check_domain_configuration( const struct mod_scmi_power_capping_domain_config *config) { if ((config->min_power_cap == (uint32_t)0) || - (config->max_power_cap == (uint32_t)0) || - (config->min_pai == (uint32_t)0) || (config->max_pai == (uint32_t)0)) { + (config->max_power_cap == (uint32_t)0)) { return FWK_E_DATA; } - if (config->min_pai != config->max_pai) { - if (config->pai_step == (uint32_t)0) { - return FWK_E_DATA; - } - } - if (config->min_power_cap != config->max_power_cap) { if (config->power_cap_step == (uint32_t)0) { return FWK_E_DATA; @@ -331,8 +320,6 @@ static void pcapping_protocol_set_cap_config_support( { domain_ctx->cap_config_support = (config->min_power_cap != config->max_power_cap); - - domain_ctx->pai_config_support = (config->min_pai != config->max_pai); } /* @@ -519,6 +506,10 @@ static int scmi_power_capping_domain_attributes_handler( { const struct scmi_power_capping_domain_attributes_a2p *parameters; struct scmi_power_capping_domain_attributes_p2a return_values = { 0 }; + const struct mod_scmi_power_capping_domain_context *domain_ctx; + const struct mod_scmi_power_capping_domain_config *config; + fwk_id_t domain_id; + int status; parameters = (const struct scmi_power_capping_domain_attributes_a2p *)payload; @@ -526,6 +517,43 @@ static int scmi_power_capping_domain_attributes_handler( scmi_power_capping_populate_domain_attributes( &return_values, parameters->domain_id); + domain_ctx = get_domain_ctx(parameters->domain_id); + config = domain_ctx->config; + + domain_id = domain_ctx->config->power_capping_domain_id; + + if (config->pai_config_support == false) { + pcapping_protocol_set_disabled_pai_values( + &return_values.pai_step, + &return_values.min_pai, + &return_values.max_pai); + } else { + status = pcapping_protocol_ctx.power_management_apis->power_capping_api + ->get_averaging_interval_step( + domain_id, &return_values.pai_step); + + if (status != FWK_SUCCESS) { + return scmi_power_capping_respond_error( + service_id, SCMI_GENERIC_ERROR); + } + + status = + pcapping_protocol_ctx.power_management_apis->power_capping_api + ->get_averaging_interval_range( + domain_id, &return_values.min_pai, &return_values.max_pai); + + if (status != FWK_SUCCESS) { + return scmi_power_capping_respond_error( + service_id, SCMI_GENERIC_ERROR); + } + } + + return_values.min_power_cap = config->min_power_cap; + return_values.max_power_cap = config->max_power_cap; + return_values.power_cap_step = config->power_cap_step; + return_values.max_sustainable_power = config->max_sustainable_power; + return_values.parent_id = config->parent_idx; + fwk_str_strncpy( (char *)return_values.name, fwk_module_get_element_name(FWK_ID_ELEMENT( @@ -689,26 +717,23 @@ static int scmi_power_capping_pai_set_handler( const struct scmi_power_capping_pai_set_a2p *parameters; struct scmi_power_capping_pai_set_p2a return_values; struct mod_scmi_power_capping_domain_context *ctx; + const struct mod_scmi_power_capping_domain_config *config; int status; fwk_id_t domain_id; parameters = (const struct scmi_power_capping_pai_set_a2p *)payload; ctx = get_domain_ctx(parameters->domain_id); + config = ctx->config; if (parameters->flags != SCMI_POWER_CAPPING_PAI_RESERVED_FLAG) { return scmi_power_capping_respond_error( service_id, SCMI_INVALID_PARAMETERS); } - if (!ctx->pai_config_support) { + if (!config->pai_config_support) { return scmi_power_capping_respond_error(service_id, SCMI_NOT_SUPPORTED); } - if ((parameters->pai < ctx->config->min_pai) || - (parameters->pai > ctx->config->max_pai)) { - return scmi_power_capping_respond_error(service_id, SCMI_OUT_OF_RANGE); - } - #ifdef BUILD_HAS_SCMI_NOTIFICATIONS if (ctx->config->cap_pai_change_notification_support) { if (!fwk_id_is_equal(ctx->pai_notification_service_id, FWK_ID_NONE)) { @@ -722,7 +747,11 @@ static int scmi_power_capping_pai_set_handler( status = pcapping_protocol_ctx.power_management_apis->power_capping_api ->set_averaging_interval(domain_id, parameters->pai); - if (status != FWK_SUCCESS) { + if (status == FWK_E_RANGE) { + return scmi_power_capping_respond_error(service_id, SCMI_OUT_OF_RANGE); + } else if (status == FWK_E_SUPPORT) { + return scmi_power_capping_respond_error(service_id, SCMI_NOT_SUPPORTED); + } else if (status != FWK_SUCCESS) { return scmi_power_capping_respond_error(service_id, SCMI_GENERIC_ERROR); } #ifdef BUILD_HAS_SCMI_NOTIFICATIONS @@ -1077,7 +1106,7 @@ int pcapping_protocol_start(fwk_id_t id) status = fwk_notification_subscribe( pcapping_protocol_pai_notification, - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_COORDINATOR), + FWK_ID_MODULE(FWK_MODULE_IDX_POWER_CAPPING), id); if (status != FWK_SUCCESS) { @@ -1086,7 +1115,7 @@ int pcapping_protocol_start(fwk_id_t id) status = fwk_notification_subscribe( pcapping_protocol_power_measurements_notification, - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_METER), + FWK_ID_MODULE(FWK_MODULE_IDX_POWER_CAPPING), id); if (status != FWK_SUCCESS) { @@ -1187,9 +1216,9 @@ int pcapping_protocol_process_cap_pai_notify_event( return status; } - status = pcapping_protocol_ctx.power_management_apis->power_coordinator_api - ->get_coordinator_period( - ctx->config->power_coordinator_domain_id, &(payload.pai)); + status = pcapping_protocol_ctx.power_management_apis->power_capping_api + ->get_averaging_interval( + ctx->config->power_capping_domain_id, &(payload.pai)); if (status != FWK_SUCCESS) { return status; @@ -1220,9 +1249,9 @@ int pcapping_protocol_process_measurements_notify_event( ctx = get_domain_ctx(event_params->domain_idx); - status = - pcapping_protocol_ctx.power_management_apis->power_meter_api->get_power( - ctx->config->power_meter_domain_id, &(payload.power)); + status = pcapping_protocol_ctx.power_management_apis->power_capping_api + ->get_average_power( + ctx->config->power_capping_domain_id, &(payload.power)); if (status != FWK_SUCCESS) { return status; diff --git a/module/scmi_power_capping/test/CMakeLists.txt b/module/scmi_power_capping/test/CMakeLists.txt index fcf1fcca2..c1fe68f0b 100644 --- a/module/scmi_power_capping/test/CMakeLists.txt +++ b/module/scmi_power_capping/test/CMakeLists.txt @@ -1,6 +1,6 @@ # # Arm SCP/MCP Software -# Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. +# Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause # @@ -72,9 +72,7 @@ target_compile_definitions(${UNIT_TEST_TARGET} PUBLIC "BUILD_HAS_SCMI_POWER_CAPP target_sources(${UNIT_TEST_TARGET} PRIVATE ${MODULE_UT_MOCK_SRC}/Mockmod_scmi_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_capping_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_coordinator_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_meter_extra.c) + ${MODULE_UT_MOCK_SRC}/Mockmod_power_capping_extra.c) ################################################################################ # Test scmi_power_capping_protocol.c + resource permissions # @@ -108,8 +106,6 @@ target_sources(${UNIT_TEST_TARGET} PRIVATE ${MODULE_UT_MOCK_SRC}/Mockmod_scmi_extra.c ${MODULE_UT_MOCK_SRC}/Mockmod_power_capping_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_coordinator_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_meter_extra.c ${MODULE_UT_MOCK_SRC}/Mockmod_resource_perms_extra.c) ################################################################################ @@ -142,9 +138,7 @@ target_compile_definitions(${UNIT_TEST_TARGET} PUBLIC "BUILD_HAS_SCMI_NOTIFICATI target_sources(${UNIT_TEST_TARGET} PRIVATE ${MODULE_UT_MOCK_SRC}/Mockmod_scmi_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_capping_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_coordinator_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_meter_extra.c) + ${MODULE_UT_MOCK_SRC}/Mockmod_power_capping_extra.c) ################################################################################ # Test scmi_power_capping_fast_channels.c with standard protocol commands # @@ -177,7 +171,6 @@ target_compile_definitions(${UNIT_TEST_TARGET} PUBLIC "BUILD_HAS_SCMI_POWER_CAPP target_sources(${UNIT_TEST_TARGET} PRIVATE ${MODULE_UT_MOCK_SRC}/Mockmod_power_capping_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_coordinator_extra.c ${MODULE_UT_MOCK_SRC}/Mockmod_transport_extra.c) ################################################################################ @@ -210,5 +203,4 @@ target_compile_definitions(${UNIT_TEST_TARGET} PUBLIC "BUILD_HAS_SCMI_POWER_CAPP target_sources(${UNIT_TEST_TARGET} PRIVATE ${MODULE_UT_MOCK_SRC}/Mockmod_power_capping_extra.c - ${MODULE_UT_MOCK_SRC}/Mockmod_power_coordinator_extra.c ${MODULE_UT_MOCK_SRC}/Mockmod_transport_extra.c) diff --git a/module/scmi_power_capping/test/mocks/Mockmod_power_coordinator_extra.c b/module/scmi_power_capping/test/mocks/Mockmod_power_coordinator_extra.c deleted file mode 100644 index 56408a555..000000000 --- a/module/scmi_power_capping/test/mocks/Mockmod_power_coordinator_extra.c +++ /dev/null @@ -1,399 +0,0 @@ -/* AUTOGENERATED FILE. DO NOT EDIT. */ -#include -#include -#include -#include "cmock.h" -#include "Mockmod_power_coordinator_extra.h" - -static const char* CMockString_domain_id = "domain_id"; -static const char* CMockString_get_coordinator_period = "get_coordinator_period"; -static const char* CMockString_period = "period"; -static const char* CMockString_set_coordinator_period = "set_coordinator_period"; - -typedef struct _CMOCK_get_coordinator_period_CALL_INSTANCE -{ - UNITY_LINE_TYPE LineNumber; - char ExpectAnyArgsBool; - int ReturnVal; - fwk_id_t Expected_domain_id; - uint32_t* Expected_period; - int Expected_period_Depth; - char ReturnThruPtr_period_Used; - uint32_t* ReturnThruPtr_period_Val; - size_t ReturnThruPtr_period_Size; - char IgnoreArg_domain_id; - char IgnoreArg_period; - -} CMOCK_get_coordinator_period_CALL_INSTANCE; - -typedef struct _CMOCK_set_coordinator_period_CALL_INSTANCE -{ - UNITY_LINE_TYPE LineNumber; - char ExpectAnyArgsBool; - int ReturnVal; - fwk_id_t Expected_domain_id; - uint32_t Expected_period; - char IgnoreArg_domain_id; - char IgnoreArg_period; - -} CMOCK_set_coordinator_period_CALL_INSTANCE; - -static struct Mockmod_power_coordinator_extraInstance -{ - char get_coordinator_period_IgnoreBool; - int get_coordinator_period_FinalReturn; - char get_coordinator_period_CallbackBool; - CMOCK_get_coordinator_period_CALLBACK get_coordinator_period_CallbackFunctionPointer; - int get_coordinator_period_CallbackCalls; - CMOCK_MEM_INDEX_TYPE get_coordinator_period_CallInstance; - char set_coordinator_period_IgnoreBool; - int set_coordinator_period_FinalReturn; - char set_coordinator_period_CallbackBool; - CMOCK_set_coordinator_period_CALLBACK set_coordinator_period_CallbackFunctionPointer; - int set_coordinator_period_CallbackCalls; - CMOCK_MEM_INDEX_TYPE set_coordinator_period_CallInstance; -} Mock; - -extern jmp_buf AbortFrame; - -void Mockmod_power_coordinator_extra_Verify(void) -{ - UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_MEM_INDEX_TYPE call_instance; - call_instance = Mock.get_coordinator_period_CallInstance; - if (Mock.get_coordinator_period_IgnoreBool) - call_instance = CMOCK_GUTS_NONE; - if (CMOCK_GUTS_NONE != call_instance) - { - UNITY_SET_DETAIL(CMockString_get_coordinator_period); - UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); - } - if (Mock.get_coordinator_period_CallbackFunctionPointer != NULL) - { - call_instance = CMOCK_GUTS_NONE; - (void)call_instance; - } - call_instance = Mock.set_coordinator_period_CallInstance; - if (Mock.set_coordinator_period_IgnoreBool) - call_instance = CMOCK_GUTS_NONE; - if (CMOCK_GUTS_NONE != call_instance) - { - UNITY_SET_DETAIL(CMockString_set_coordinator_period); - UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); - } - if (Mock.set_coordinator_period_CallbackFunctionPointer != NULL) - { - call_instance = CMOCK_GUTS_NONE; - (void)call_instance; - } -} - -void Mockmod_power_coordinator_extra_Init(void) -{ - Mockmod_power_coordinator_extra_Destroy(); -} - -void Mockmod_power_coordinator_extra_Destroy(void) -{ - CMock_Guts_MemFreeAll(); - memset(&Mock, 0, sizeof(Mock)); -} - -int get_coordinator_period(fwk_id_t domain_id, uint32_t* period) -{ - UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance; - UNITY_SET_DETAIL(CMockString_get_coordinator_period); - cmock_call_instance = (CMOCK_get_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_coordinator_period_CallInstance); - Mock.get_coordinator_period_CallInstance = CMock_Guts_MemNext(Mock.get_coordinator_period_CallInstance); - if (Mock.get_coordinator_period_IgnoreBool) - { - UNITY_CLR_DETAILS(); - if (cmock_call_instance == NULL) - return Mock.get_coordinator_period_FinalReturn; - Mock.get_coordinator_period_FinalReturn = cmock_call_instance->ReturnVal; - return cmock_call_instance->ReturnVal; - } - if (!Mock.get_coordinator_period_CallbackBool && - Mock.get_coordinator_period_CallbackFunctionPointer != NULL) - { - int cmock_cb_ret = Mock.get_coordinator_period_CallbackFunctionPointer(domain_id, period, Mock.get_coordinator_period_CallbackCalls++); - UNITY_CLR_DETAILS(); - return cmock_cb_ret; - } - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); - cmock_line = cmock_call_instance->LineNumber; - if (!cmock_call_instance->ExpectAnyArgsBool) - { - if (!cmock_call_instance->IgnoreArg_domain_id) - { - UNITY_SET_DETAILS(CMockString_get_coordinator_period,CMockString_domain_id); - UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_domain_id), (void*)(&domain_id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); - } - if (!cmock_call_instance->IgnoreArg_period) - { - UNITY_SET_DETAILS(CMockString_get_coordinator_period,CMockString_period); - if (cmock_call_instance->Expected_period == NULL) - { UNITY_TEST_ASSERT_NULL(period, cmock_line, CMockStringExpNULL); } - else - { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_period, period, cmock_call_instance->Expected_period_Depth, cmock_line, CMockStringMismatch); } - } - } - if (Mock.get_coordinator_period_CallbackFunctionPointer != NULL) - { - cmock_call_instance->ReturnVal = Mock.get_coordinator_period_CallbackFunctionPointer(domain_id, period, Mock.get_coordinator_period_CallbackCalls++); - } - if (cmock_call_instance->ReturnThruPtr_period_Used) - { - UNITY_TEST_ASSERT_NOT_NULL(period, cmock_line, CMockStringPtrIsNULL); - memcpy((void*)period, (void*)cmock_call_instance->ReturnThruPtr_period_Val, - cmock_call_instance->ReturnThruPtr_period_Size); - } - UNITY_CLR_DETAILS(); - return cmock_call_instance->ReturnVal; -} - -void CMockExpectParameters_get_coordinator_period(CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance, fwk_id_t domain_id, uint32_t* period, int period_Depth); -void CMockExpectParameters_get_coordinator_period(CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance, fwk_id_t domain_id, uint32_t* period, int period_Depth) -{ - memcpy((void*)(&cmock_call_instance->Expected_domain_id), (void*)(&domain_id), - sizeof(fwk_id_t[sizeof(domain_id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ - cmock_call_instance->IgnoreArg_domain_id = 0; - cmock_call_instance->Expected_period = period; - cmock_call_instance->Expected_period_Depth = period_Depth; - cmock_call_instance->IgnoreArg_period = 0; - cmock_call_instance->ReturnThruPtr_period_Used = 0; -} - -void get_coordinator_period_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_coordinator_period_CALL_INSTANCE)); - CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_coordinator_period_CallInstance = CMock_Guts_MemChain(Mock.get_coordinator_period_CallInstance, cmock_guts_index); - Mock.get_coordinator_period_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - cmock_call_instance->ReturnVal = cmock_to_return; - Mock.get_coordinator_period_IgnoreBool = (char)1; -} - -void get_coordinator_period_CMockStopIgnore(void) -{ - if(Mock.get_coordinator_period_IgnoreBool) - Mock.get_coordinator_period_CallInstance = CMock_Guts_MemNext(Mock.get_coordinator_period_CallInstance); - Mock.get_coordinator_period_IgnoreBool = (char)0; -} - -void get_coordinator_period_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_coordinator_period_CALL_INSTANCE)); - CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_coordinator_period_CallInstance = CMock_Guts_MemChain(Mock.get_coordinator_period_CallInstance, cmock_guts_index); - Mock.get_coordinator_period_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - cmock_call_instance->ReturnVal = cmock_to_return; - cmock_call_instance->ExpectAnyArgsBool = (char)1; -} - -void get_coordinator_period_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t* period, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_coordinator_period_CALL_INSTANCE)); - CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_coordinator_period_CallInstance = CMock_Guts_MemChain(Mock.get_coordinator_period_CallInstance, cmock_guts_index); - Mock.get_coordinator_period_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_get_coordinator_period(cmock_call_instance, domain_id, period, 1); - cmock_call_instance->ReturnVal = cmock_to_return; -} - -void get_coordinator_period_AddCallback(CMOCK_get_coordinator_period_CALLBACK Callback) -{ - Mock.get_coordinator_period_IgnoreBool = (char)0; - Mock.get_coordinator_period_CallbackBool = (char)1; - Mock.get_coordinator_period_CallbackFunctionPointer = Callback; -} - -void get_coordinator_period_Stub(CMOCK_get_coordinator_period_CALLBACK Callback) -{ - Mock.get_coordinator_period_IgnoreBool = (char)0; - Mock.get_coordinator_period_CallbackBool = (char)0; - Mock.get_coordinator_period_CallbackFunctionPointer = Callback; -} - -void get_coordinator_period_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t* period, int period_Depth, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_coordinator_period_CALL_INSTANCE)); - CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_coordinator_period_CallInstance = CMock_Guts_MemChain(Mock.get_coordinator_period_CallInstance, cmock_guts_index); - Mock.get_coordinator_period_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_get_coordinator_period(cmock_call_instance, domain_id, period, period_Depth); - cmock_call_instance->ReturnVal = cmock_to_return; -} - -void get_coordinator_period_CMockReturnMemThruPtr_period(UNITY_LINE_TYPE cmock_line, uint32_t* period, size_t cmock_size) -{ - CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_coordinator_period_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); - cmock_call_instance->ReturnThruPtr_period_Used = 1; - cmock_call_instance->ReturnThruPtr_period_Val = period; - cmock_call_instance->ReturnThruPtr_period_Size = cmock_size; -} - -void get_coordinator_period_CMockIgnoreArg_domain_id(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_coordinator_period_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_domain_id = 1; -} - -void get_coordinator_period_CMockIgnoreArg_period(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_get_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_coordinator_period_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_period = 1; -} - -int set_coordinator_period(fwk_id_t domain_id, uint32_t period) -{ - UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_set_coordinator_period_CALL_INSTANCE* cmock_call_instance; - UNITY_SET_DETAIL(CMockString_set_coordinator_period); - cmock_call_instance = (CMOCK_set_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.set_coordinator_period_CallInstance); - Mock.set_coordinator_period_CallInstance = CMock_Guts_MemNext(Mock.set_coordinator_period_CallInstance); - if (Mock.set_coordinator_period_IgnoreBool) - { - UNITY_CLR_DETAILS(); - if (cmock_call_instance == NULL) - return Mock.set_coordinator_period_FinalReturn; - Mock.set_coordinator_period_FinalReturn = cmock_call_instance->ReturnVal; - return cmock_call_instance->ReturnVal; - } - if (!Mock.set_coordinator_period_CallbackBool && - Mock.set_coordinator_period_CallbackFunctionPointer != NULL) - { - int cmock_cb_ret = Mock.set_coordinator_period_CallbackFunctionPointer(domain_id, period, Mock.set_coordinator_period_CallbackCalls++); - UNITY_CLR_DETAILS(); - return cmock_cb_ret; - } - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); - cmock_line = cmock_call_instance->LineNumber; - if (!cmock_call_instance->ExpectAnyArgsBool) - { - if (!cmock_call_instance->IgnoreArg_domain_id) - { - UNITY_SET_DETAILS(CMockString_set_coordinator_period,CMockString_domain_id); - UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_domain_id), (void*)(&domain_id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); - } - if (!cmock_call_instance->IgnoreArg_period) - { - UNITY_SET_DETAILS(CMockString_set_coordinator_period,CMockString_period); - UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_period, period, cmock_line, CMockStringMismatch); - } - } - if (Mock.set_coordinator_period_CallbackFunctionPointer != NULL) - { - cmock_call_instance->ReturnVal = Mock.set_coordinator_period_CallbackFunctionPointer(domain_id, period, Mock.set_coordinator_period_CallbackCalls++); - } - UNITY_CLR_DETAILS(); - return cmock_call_instance->ReturnVal; -} - -void CMockExpectParameters_set_coordinator_period(CMOCK_set_coordinator_period_CALL_INSTANCE* cmock_call_instance, fwk_id_t domain_id, uint32_t period); -void CMockExpectParameters_set_coordinator_period(CMOCK_set_coordinator_period_CALL_INSTANCE* cmock_call_instance, fwk_id_t domain_id, uint32_t period) -{ - memcpy((void*)(&cmock_call_instance->Expected_domain_id), (void*)(&domain_id), - sizeof(fwk_id_t[sizeof(domain_id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ - cmock_call_instance->IgnoreArg_domain_id = 0; - cmock_call_instance->Expected_period = period; - cmock_call_instance->IgnoreArg_period = 0; -} - -void set_coordinator_period_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_coordinator_period_CALL_INSTANCE)); - CMOCK_set_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.set_coordinator_period_CallInstance = CMock_Guts_MemChain(Mock.set_coordinator_period_CallInstance, cmock_guts_index); - Mock.set_coordinator_period_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - cmock_call_instance->ReturnVal = cmock_to_return; - Mock.set_coordinator_period_IgnoreBool = (char)1; -} - -void set_coordinator_period_CMockStopIgnore(void) -{ - if(Mock.set_coordinator_period_IgnoreBool) - Mock.set_coordinator_period_CallInstance = CMock_Guts_MemNext(Mock.set_coordinator_period_CallInstance); - Mock.set_coordinator_period_IgnoreBool = (char)0; -} - -void set_coordinator_period_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_coordinator_period_CALL_INSTANCE)); - CMOCK_set_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.set_coordinator_period_CallInstance = CMock_Guts_MemChain(Mock.set_coordinator_period_CallInstance, cmock_guts_index); - Mock.set_coordinator_period_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - cmock_call_instance->ReturnVal = cmock_to_return; - cmock_call_instance->ExpectAnyArgsBool = (char)1; -} - -void set_coordinator_period_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t period, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_coordinator_period_CALL_INSTANCE)); - CMOCK_set_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.set_coordinator_period_CallInstance = CMock_Guts_MemChain(Mock.set_coordinator_period_CallInstance, cmock_guts_index); - Mock.set_coordinator_period_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_set_coordinator_period(cmock_call_instance, domain_id, period); - cmock_call_instance->ReturnVal = cmock_to_return; -} - -void set_coordinator_period_AddCallback(CMOCK_set_coordinator_period_CALLBACK Callback) -{ - Mock.set_coordinator_period_IgnoreBool = (char)0; - Mock.set_coordinator_period_CallbackBool = (char)1; - Mock.set_coordinator_period_CallbackFunctionPointer = Callback; -} - -void set_coordinator_period_Stub(CMOCK_set_coordinator_period_CALLBACK Callback) -{ - Mock.set_coordinator_period_IgnoreBool = (char)0; - Mock.set_coordinator_period_CallbackBool = (char)0; - Mock.set_coordinator_period_CallbackFunctionPointer = Callback; -} - -void set_coordinator_period_CMockIgnoreArg_domain_id(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_set_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_coordinator_period_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_domain_id = 1; -} - -void set_coordinator_period_CMockIgnoreArg_period(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_set_coordinator_period_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_coordinator_period_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_coordinator_period_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_period = 1; -} - diff --git a/module/scmi_power_capping/test/mocks/Mockmod_power_coordinator_extra.h b/module/scmi_power_capping/test/mocks/Mockmod_power_coordinator_extra.h deleted file mode 100644 index 7d73f6fe3..000000000 --- a/module/scmi_power_capping/test/mocks/Mockmod_power_coordinator_extra.h +++ /dev/null @@ -1,72 +0,0 @@ -/* AUTOGENERATED FILE. DO NOT EDIT. */ -#ifndef _MOCKMOD_POWER_COORDINATOR_EXTRA_H -#define _MOCKMOD_POWER_COORDINATOR_EXTRA_H - -#include "unity.h" -#include "mod_power_coordinator_extra.h" - -/* Ignore the following warnings, since we are copying code */ -#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__) -#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0))) -#pragma GCC diagnostic push -#endif -#if !defined(__clang__) -#pragma GCC diagnostic ignored "-Wpragmas" -#endif -#pragma GCC diagnostic ignored "-Wunknown-pragmas" -#pragma GCC diagnostic ignored "-Wduplicate-decl-specifier" -#endif - -void Mockmod_power_coordinator_extra_Init(void); -void Mockmod_power_coordinator_extra_Destroy(void); -void Mockmod_power_coordinator_extra_Verify(void); - - - - -#define get_coordinator_period_IgnoreAndReturn(cmock_retval) get_coordinator_period_CMockIgnoreAndReturn(__LINE__, cmock_retval) -void get_coordinator_period_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define get_coordinator_period_StopIgnore() get_coordinator_period_CMockStopIgnore() -void get_coordinator_period_CMockStopIgnore(void); -#define get_coordinator_period_ExpectAnyArgsAndReturn(cmock_retval) get_coordinator_period_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) -void get_coordinator_period_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define get_coordinator_period_ExpectAndReturn(domain_id, period, cmock_retval) get_coordinator_period_CMockExpectAndReturn(__LINE__, domain_id, period, cmock_retval) -void get_coordinator_period_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t* period, int cmock_to_return); -typedef int (* CMOCK_get_coordinator_period_CALLBACK)(fwk_id_t domain_id, uint32_t* period, int cmock_num_calls); -void get_coordinator_period_AddCallback(CMOCK_get_coordinator_period_CALLBACK Callback); -void get_coordinator_period_Stub(CMOCK_get_coordinator_period_CALLBACK Callback); -#define get_coordinator_period_StubWithCallback get_coordinator_period_Stub -#define get_coordinator_period_ExpectWithArrayAndReturn(domain_id, period, period_Depth, cmock_retval) get_coordinator_period_CMockExpectWithArrayAndReturn(__LINE__, domain_id, period, period_Depth, cmock_retval) -void get_coordinator_period_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t* period, int period_Depth, int cmock_to_return); -#define get_coordinator_period_ReturnThruPtr_period(period) get_coordinator_period_CMockReturnMemThruPtr_period(__LINE__, period, sizeof(uint32_t)) -#define get_coordinator_period_ReturnArrayThruPtr_period(period, cmock_len) get_coordinator_period_CMockReturnMemThruPtr_period(__LINE__, period, cmock_len * sizeof(*period)) -#define get_coordinator_period_ReturnMemThruPtr_period(period, cmock_size) get_coordinator_period_CMockReturnMemThruPtr_period(__LINE__, period, cmock_size) -void get_coordinator_period_CMockReturnMemThruPtr_period(UNITY_LINE_TYPE cmock_line, uint32_t* period, size_t cmock_size); -#define get_coordinator_period_IgnoreArg_domain_id() get_coordinator_period_CMockIgnoreArg_domain_id(__LINE__) -void get_coordinator_period_CMockIgnoreArg_domain_id(UNITY_LINE_TYPE cmock_line); -#define get_coordinator_period_IgnoreArg_period() get_coordinator_period_CMockIgnoreArg_period(__LINE__) -void get_coordinator_period_CMockIgnoreArg_period(UNITY_LINE_TYPE cmock_line); -#define set_coordinator_period_IgnoreAndReturn(cmock_retval) set_coordinator_period_CMockIgnoreAndReturn(__LINE__, cmock_retval) -void set_coordinator_period_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define set_coordinator_period_StopIgnore() set_coordinator_period_CMockStopIgnore() -void set_coordinator_period_CMockStopIgnore(void); -#define set_coordinator_period_ExpectAnyArgsAndReturn(cmock_retval) set_coordinator_period_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) -void set_coordinator_period_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define set_coordinator_period_ExpectAndReturn(domain_id, period, cmock_retval) set_coordinator_period_CMockExpectAndReturn(__LINE__, domain_id, period, cmock_retval) -void set_coordinator_period_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t period, int cmock_to_return); -typedef int (* CMOCK_set_coordinator_period_CALLBACK)(fwk_id_t domain_id, uint32_t period, int cmock_num_calls); -void set_coordinator_period_AddCallback(CMOCK_set_coordinator_period_CALLBACK Callback); -void set_coordinator_period_Stub(CMOCK_set_coordinator_period_CALLBACK Callback); -#define set_coordinator_period_StubWithCallback set_coordinator_period_Stub -#define set_coordinator_period_IgnoreArg_domain_id() set_coordinator_period_CMockIgnoreArg_domain_id(__LINE__) -void set_coordinator_period_CMockIgnoreArg_domain_id(UNITY_LINE_TYPE cmock_line); -#define set_coordinator_period_IgnoreArg_period() set_coordinator_period_CMockIgnoreArg_period(__LINE__) -void set_coordinator_period_CMockIgnoreArg_period(UNITY_LINE_TYPE cmock_line); - -#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__) -#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0))) -#pragma GCC diagnostic pop -#endif -#endif - -#endif diff --git a/module/scmi_power_capping/test/mocks/Mockmod_power_meter_extra.c b/module/scmi_power_capping/test/mocks/Mockmod_power_meter_extra.c deleted file mode 100644 index e1d69678d..000000000 --- a/module/scmi_power_capping/test/mocks/Mockmod_power_meter_extra.c +++ /dev/null @@ -1,418 +0,0 @@ -/* AUTOGENERATED FILE. DO NOT EDIT. */ -#include -#include -#include -#include "cmock.h" -#include "Mockmod_power_meter_extra.h" - -static const char* CMockString_domain_id = "domain_id"; -static const char* CMockString_get_power = "get_power"; -static const char* CMockString_id = "id"; -static const char* CMockString_power = "power"; -static const char* CMockString_set_power_change_notif_thresholds = "set_power_change_notif_thresholds"; -static const char* CMockString_threshold_high = "threshold_high"; -static const char* CMockString_threshold_low = "threshold_low"; - -typedef struct _CMOCK_get_power_CALL_INSTANCE -{ - UNITY_LINE_TYPE LineNumber; - char ExpectAnyArgsBool; - int ReturnVal; - fwk_id_t Expected_domain_id; - uint32_t* Expected_power; - int Expected_power_Depth; - char ReturnThruPtr_power_Used; - uint32_t* ReturnThruPtr_power_Val; - size_t ReturnThruPtr_power_Size; - char IgnoreArg_domain_id; - char IgnoreArg_power; - -} CMOCK_get_power_CALL_INSTANCE; - -typedef struct _CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE -{ - UNITY_LINE_TYPE LineNumber; - char ExpectAnyArgsBool; - int ReturnVal; - fwk_id_t Expected_id; - uint32_t Expected_threshold_low; - uint32_t Expected_threshold_high; - char IgnoreArg_id; - char IgnoreArg_threshold_low; - char IgnoreArg_threshold_high; - -} CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE; - -static struct Mockmod_power_meter_extraInstance -{ - char get_power_IgnoreBool; - int get_power_FinalReturn; - char get_power_CallbackBool; - CMOCK_get_power_CALLBACK get_power_CallbackFunctionPointer; - int get_power_CallbackCalls; - CMOCK_MEM_INDEX_TYPE get_power_CallInstance; - char set_power_change_notif_thresholds_IgnoreBool; - int set_power_change_notif_thresholds_FinalReturn; - char set_power_change_notif_thresholds_CallbackBool; - CMOCK_set_power_change_notif_thresholds_CALLBACK set_power_change_notif_thresholds_CallbackFunctionPointer; - int set_power_change_notif_thresholds_CallbackCalls; - CMOCK_MEM_INDEX_TYPE set_power_change_notif_thresholds_CallInstance; -} Mock; - -extern jmp_buf AbortFrame; - -void Mockmod_power_meter_extra_Verify(void) -{ - UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_MEM_INDEX_TYPE call_instance; - call_instance = Mock.get_power_CallInstance; - if (Mock.get_power_IgnoreBool) - call_instance = CMOCK_GUTS_NONE; - if (CMOCK_GUTS_NONE != call_instance) - { - UNITY_SET_DETAIL(CMockString_get_power); - UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); - } - if (Mock.get_power_CallbackFunctionPointer != NULL) - { - call_instance = CMOCK_GUTS_NONE; - (void)call_instance; - } - call_instance = Mock.set_power_change_notif_thresholds_CallInstance; - if (Mock.set_power_change_notif_thresholds_IgnoreBool) - call_instance = CMOCK_GUTS_NONE; - if (CMOCK_GUTS_NONE != call_instance) - { - UNITY_SET_DETAIL(CMockString_set_power_change_notif_thresholds); - UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); - } - if (Mock.set_power_change_notif_thresholds_CallbackFunctionPointer != NULL) - { - call_instance = CMOCK_GUTS_NONE; - (void)call_instance; - } -} - -void Mockmod_power_meter_extra_Init(void) -{ - Mockmod_power_meter_extra_Destroy(); -} - -void Mockmod_power_meter_extra_Destroy(void) -{ - CMock_Guts_MemFreeAll(); - memset(&Mock, 0, sizeof(Mock)); -} - -int get_power(fwk_id_t domain_id, uint32_t* power) -{ - UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_get_power_CALL_INSTANCE* cmock_call_instance; - UNITY_SET_DETAIL(CMockString_get_power); - cmock_call_instance = (CMOCK_get_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_power_CallInstance); - Mock.get_power_CallInstance = CMock_Guts_MemNext(Mock.get_power_CallInstance); - if (Mock.get_power_IgnoreBool) - { - UNITY_CLR_DETAILS(); - if (cmock_call_instance == NULL) - return Mock.get_power_FinalReturn; - Mock.get_power_FinalReturn = cmock_call_instance->ReturnVal; - return cmock_call_instance->ReturnVal; - } - if (!Mock.get_power_CallbackBool && - Mock.get_power_CallbackFunctionPointer != NULL) - { - int cmock_cb_ret = Mock.get_power_CallbackFunctionPointer(domain_id, power, Mock.get_power_CallbackCalls++); - UNITY_CLR_DETAILS(); - return cmock_cb_ret; - } - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); - cmock_line = cmock_call_instance->LineNumber; - if (!cmock_call_instance->ExpectAnyArgsBool) - { - if (!cmock_call_instance->IgnoreArg_domain_id) - { - UNITY_SET_DETAILS(CMockString_get_power,CMockString_domain_id); - UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_domain_id), (void*)(&domain_id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); - } - if (!cmock_call_instance->IgnoreArg_power) - { - UNITY_SET_DETAILS(CMockString_get_power,CMockString_power); - if (cmock_call_instance->Expected_power == NULL) - { UNITY_TEST_ASSERT_NULL(power, cmock_line, CMockStringExpNULL); } - else - { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_power, power, cmock_call_instance->Expected_power_Depth, cmock_line, CMockStringMismatch); } - } - } - if (Mock.get_power_CallbackFunctionPointer != NULL) - { - cmock_call_instance->ReturnVal = Mock.get_power_CallbackFunctionPointer(domain_id, power, Mock.get_power_CallbackCalls++); - } - if (cmock_call_instance->ReturnThruPtr_power_Used) - { - UNITY_TEST_ASSERT_NOT_NULL(power, cmock_line, CMockStringPtrIsNULL); - memcpy((void*)power, (void*)cmock_call_instance->ReturnThruPtr_power_Val, - cmock_call_instance->ReturnThruPtr_power_Size); - } - UNITY_CLR_DETAILS(); - return cmock_call_instance->ReturnVal; -} - -void CMockExpectParameters_get_power(CMOCK_get_power_CALL_INSTANCE* cmock_call_instance, fwk_id_t domain_id, uint32_t* power, int power_Depth); -void CMockExpectParameters_get_power(CMOCK_get_power_CALL_INSTANCE* cmock_call_instance, fwk_id_t domain_id, uint32_t* power, int power_Depth) -{ - memcpy((void*)(&cmock_call_instance->Expected_domain_id), (void*)(&domain_id), - sizeof(fwk_id_t[sizeof(domain_id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ - cmock_call_instance->IgnoreArg_domain_id = 0; - cmock_call_instance->Expected_power = power; - cmock_call_instance->Expected_power_Depth = power_Depth; - cmock_call_instance->IgnoreArg_power = 0; - cmock_call_instance->ReturnThruPtr_power_Used = 0; -} - -void get_power_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_power_CALL_INSTANCE)); - CMOCK_get_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_power_CallInstance = CMock_Guts_MemChain(Mock.get_power_CallInstance, cmock_guts_index); - Mock.get_power_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - cmock_call_instance->ReturnVal = cmock_to_return; - Mock.get_power_IgnoreBool = (char)1; -} - -void get_power_CMockStopIgnore(void) -{ - if(Mock.get_power_IgnoreBool) - Mock.get_power_CallInstance = CMock_Guts_MemNext(Mock.get_power_CallInstance); - Mock.get_power_IgnoreBool = (char)0; -} - -void get_power_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_power_CALL_INSTANCE)); - CMOCK_get_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_power_CallInstance = CMock_Guts_MemChain(Mock.get_power_CallInstance, cmock_guts_index); - Mock.get_power_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - cmock_call_instance->ReturnVal = cmock_to_return; - cmock_call_instance->ExpectAnyArgsBool = (char)1; -} - -void get_power_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t* power, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_power_CALL_INSTANCE)); - CMOCK_get_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_power_CallInstance = CMock_Guts_MemChain(Mock.get_power_CallInstance, cmock_guts_index); - Mock.get_power_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_get_power(cmock_call_instance, domain_id, power, 1); - cmock_call_instance->ReturnVal = cmock_to_return; -} - -void get_power_AddCallback(CMOCK_get_power_CALLBACK Callback) -{ - Mock.get_power_IgnoreBool = (char)0; - Mock.get_power_CallbackBool = (char)1; - Mock.get_power_CallbackFunctionPointer = Callback; -} - -void get_power_Stub(CMOCK_get_power_CALLBACK Callback) -{ - Mock.get_power_IgnoreBool = (char)0; - Mock.get_power_CallbackBool = (char)0; - Mock.get_power_CallbackFunctionPointer = Callback; -} - -void get_power_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t* power, int power_Depth, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_power_CALL_INSTANCE)); - CMOCK_get_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_power_CallInstance = CMock_Guts_MemChain(Mock.get_power_CallInstance, cmock_guts_index); - Mock.get_power_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_get_power(cmock_call_instance, domain_id, power, power_Depth); - cmock_call_instance->ReturnVal = cmock_to_return; -} - -void get_power_CMockReturnMemThruPtr_power(UNITY_LINE_TYPE cmock_line, uint32_t* power, size_t cmock_size) -{ - CMOCK_get_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_power_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); - cmock_call_instance->ReturnThruPtr_power_Used = 1; - cmock_call_instance->ReturnThruPtr_power_Val = power; - cmock_call_instance->ReturnThruPtr_power_Size = cmock_size; -} - -void get_power_CMockIgnoreArg_domain_id(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_get_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_power_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_domain_id = 1; -} - -void get_power_CMockIgnoreArg_power(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_get_power_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_power_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_power_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_power = 1; -} - -int set_power_change_notif_thresholds(fwk_id_t id, uint32_t threshold_low, uint32_t threshold_high) -{ - UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance; - UNITY_SET_DETAIL(CMockString_set_power_change_notif_thresholds); - cmock_call_instance = (CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.set_power_change_notif_thresholds_CallInstance); - Mock.set_power_change_notif_thresholds_CallInstance = CMock_Guts_MemNext(Mock.set_power_change_notif_thresholds_CallInstance); - if (Mock.set_power_change_notif_thresholds_IgnoreBool) - { - UNITY_CLR_DETAILS(); - if (cmock_call_instance == NULL) - return Mock.set_power_change_notif_thresholds_FinalReturn; - Mock.set_power_change_notif_thresholds_FinalReturn = cmock_call_instance->ReturnVal; - return cmock_call_instance->ReturnVal; - } - if (!Mock.set_power_change_notif_thresholds_CallbackBool && - Mock.set_power_change_notif_thresholds_CallbackFunctionPointer != NULL) - { - int cmock_cb_ret = Mock.set_power_change_notif_thresholds_CallbackFunctionPointer(id, threshold_low, threshold_high, Mock.set_power_change_notif_thresholds_CallbackCalls++); - UNITY_CLR_DETAILS(); - return cmock_cb_ret; - } - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); - cmock_line = cmock_call_instance->LineNumber; - if (!cmock_call_instance->ExpectAnyArgsBool) - { - if (!cmock_call_instance->IgnoreArg_id) - { - UNITY_SET_DETAILS(CMockString_set_power_change_notif_thresholds,CMockString_id); - UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_id), (void*)(&id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); - } - if (!cmock_call_instance->IgnoreArg_threshold_low) - { - UNITY_SET_DETAILS(CMockString_set_power_change_notif_thresholds,CMockString_threshold_low); - UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_threshold_low, threshold_low, cmock_line, CMockStringMismatch); - } - if (!cmock_call_instance->IgnoreArg_threshold_high) - { - UNITY_SET_DETAILS(CMockString_set_power_change_notif_thresholds,CMockString_threshold_high); - UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_threshold_high, threshold_high, cmock_line, CMockStringMismatch); - } - } - if (Mock.set_power_change_notif_thresholds_CallbackFunctionPointer != NULL) - { - cmock_call_instance->ReturnVal = Mock.set_power_change_notif_thresholds_CallbackFunctionPointer(id, threshold_low, threshold_high, Mock.set_power_change_notif_thresholds_CallbackCalls++); - } - UNITY_CLR_DETAILS(); - return cmock_call_instance->ReturnVal; -} - -void CMockExpectParameters_set_power_change_notif_thresholds(CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t threshold_low, uint32_t threshold_high); -void CMockExpectParameters_set_power_change_notif_thresholds(CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance, fwk_id_t id, uint32_t threshold_low, uint32_t threshold_high) -{ - memcpy((void*)(&cmock_call_instance->Expected_id), (void*)(&id), - sizeof(fwk_id_t[sizeof(id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ - cmock_call_instance->IgnoreArg_id = 0; - cmock_call_instance->Expected_threshold_low = threshold_low; - cmock_call_instance->IgnoreArg_threshold_low = 0; - cmock_call_instance->Expected_threshold_high = threshold_high; - cmock_call_instance->IgnoreArg_threshold_high = 0; -} - -void set_power_change_notif_thresholds_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE)); - CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.set_power_change_notif_thresholds_CallInstance = CMock_Guts_MemChain(Mock.set_power_change_notif_thresholds_CallInstance, cmock_guts_index); - Mock.set_power_change_notif_thresholds_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - cmock_call_instance->ReturnVal = cmock_to_return; - Mock.set_power_change_notif_thresholds_IgnoreBool = (char)1; -} - -void set_power_change_notif_thresholds_CMockStopIgnore(void) -{ - if(Mock.set_power_change_notif_thresholds_IgnoreBool) - Mock.set_power_change_notif_thresholds_CallInstance = CMock_Guts_MemNext(Mock.set_power_change_notif_thresholds_CallInstance); - Mock.set_power_change_notif_thresholds_IgnoreBool = (char)0; -} - -void set_power_change_notif_thresholds_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE)); - CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.set_power_change_notif_thresholds_CallInstance = CMock_Guts_MemChain(Mock.set_power_change_notif_thresholds_CallInstance, cmock_guts_index); - Mock.set_power_change_notif_thresholds_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - cmock_call_instance->ReturnVal = cmock_to_return; - cmock_call_instance->ExpectAnyArgsBool = (char)1; -} - -void set_power_change_notif_thresholds_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t threshold_low, uint32_t threshold_high, int cmock_to_return) -{ - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE)); - CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); - memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.set_power_change_notif_thresholds_CallInstance = CMock_Guts_MemChain(Mock.set_power_change_notif_thresholds_CallInstance, cmock_guts_index); - Mock.set_power_change_notif_thresholds_IgnoreBool = (char)0; - cmock_call_instance->LineNumber = cmock_line; - cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_set_power_change_notif_thresholds(cmock_call_instance, id, threshold_low, threshold_high); - cmock_call_instance->ReturnVal = cmock_to_return; -} - -void set_power_change_notif_thresholds_AddCallback(CMOCK_set_power_change_notif_thresholds_CALLBACK Callback) -{ - Mock.set_power_change_notif_thresholds_IgnoreBool = (char)0; - Mock.set_power_change_notif_thresholds_CallbackBool = (char)1; - Mock.set_power_change_notif_thresholds_CallbackFunctionPointer = Callback; -} - -void set_power_change_notif_thresholds_Stub(CMOCK_set_power_change_notif_thresholds_CALLBACK Callback) -{ - Mock.set_power_change_notif_thresholds_IgnoreBool = (char)0; - Mock.set_power_change_notif_thresholds_CallbackBool = (char)0; - Mock.set_power_change_notif_thresholds_CallbackFunctionPointer = Callback; -} - -void set_power_change_notif_thresholds_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_power_change_notif_thresholds_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_id = 1; -} - -void set_power_change_notif_thresholds_CMockIgnoreArg_threshold_low(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_power_change_notif_thresholds_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_threshold_low = 1; -} - -void set_power_change_notif_thresholds_CMockIgnoreArg_threshold_high(UNITY_LINE_TYPE cmock_line) -{ - CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_power_change_notif_thresholds_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_power_change_notif_thresholds_CallInstance)); - UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_threshold_high = 1; -} - diff --git a/module/scmi_power_capping/test/mocks/Mockmod_power_meter_extra.h b/module/scmi_power_capping/test/mocks/Mockmod_power_meter_extra.h deleted file mode 100644 index e9bd95214..000000000 --- a/module/scmi_power_capping/test/mocks/Mockmod_power_meter_extra.h +++ /dev/null @@ -1,74 +0,0 @@ -/* AUTOGENERATED FILE. DO NOT EDIT. */ -#ifndef _MOCKMOD_POWER_METER_EXTRA_H -#define _MOCKMOD_POWER_METER_EXTRA_H - -#include "unity.h" -#include "mod_power_meter_extra.h" - -/* Ignore the following warnings, since we are copying code */ -#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__) -#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0))) -#pragma GCC diagnostic push -#endif -#if !defined(__clang__) -#pragma GCC diagnostic ignored "-Wpragmas" -#endif -#pragma GCC diagnostic ignored "-Wunknown-pragmas" -#pragma GCC diagnostic ignored "-Wduplicate-decl-specifier" -#endif - -void Mockmod_power_meter_extra_Init(void); -void Mockmod_power_meter_extra_Destroy(void); -void Mockmod_power_meter_extra_Verify(void); - - - - -#define get_power_IgnoreAndReturn(cmock_retval) get_power_CMockIgnoreAndReturn(__LINE__, cmock_retval) -void get_power_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define get_power_StopIgnore() get_power_CMockStopIgnore() -void get_power_CMockStopIgnore(void); -#define get_power_ExpectAnyArgsAndReturn(cmock_retval) get_power_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) -void get_power_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define get_power_ExpectAndReturn(domain_id, power, cmock_retval) get_power_CMockExpectAndReturn(__LINE__, domain_id, power, cmock_retval) -void get_power_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t* power, int cmock_to_return); -typedef int (* CMOCK_get_power_CALLBACK)(fwk_id_t domain_id, uint32_t* power, int cmock_num_calls); -void get_power_AddCallback(CMOCK_get_power_CALLBACK Callback); -void get_power_Stub(CMOCK_get_power_CALLBACK Callback); -#define get_power_StubWithCallback get_power_Stub -#define get_power_ExpectWithArrayAndReturn(domain_id, power, power_Depth, cmock_retval) get_power_CMockExpectWithArrayAndReturn(__LINE__, domain_id, power, power_Depth, cmock_retval) -void get_power_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t domain_id, uint32_t* power, int power_Depth, int cmock_to_return); -#define get_power_ReturnThruPtr_power(power) get_power_CMockReturnMemThruPtr_power(__LINE__, power, sizeof(uint32_t)) -#define get_power_ReturnArrayThruPtr_power(power, cmock_len) get_power_CMockReturnMemThruPtr_power(__LINE__, power, cmock_len * sizeof(*power)) -#define get_power_ReturnMemThruPtr_power(power, cmock_size) get_power_CMockReturnMemThruPtr_power(__LINE__, power, cmock_size) -void get_power_CMockReturnMemThruPtr_power(UNITY_LINE_TYPE cmock_line, uint32_t* power, size_t cmock_size); -#define get_power_IgnoreArg_domain_id() get_power_CMockIgnoreArg_domain_id(__LINE__) -void get_power_CMockIgnoreArg_domain_id(UNITY_LINE_TYPE cmock_line); -#define get_power_IgnoreArg_power() get_power_CMockIgnoreArg_power(__LINE__) -void get_power_CMockIgnoreArg_power(UNITY_LINE_TYPE cmock_line); -#define set_power_change_notif_thresholds_IgnoreAndReturn(cmock_retval) set_power_change_notif_thresholds_CMockIgnoreAndReturn(__LINE__, cmock_retval) -void set_power_change_notif_thresholds_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define set_power_change_notif_thresholds_StopIgnore() set_power_change_notif_thresholds_CMockStopIgnore() -void set_power_change_notif_thresholds_CMockStopIgnore(void); -#define set_power_change_notif_thresholds_ExpectAnyArgsAndReturn(cmock_retval) set_power_change_notif_thresholds_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) -void set_power_change_notif_thresholds_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define set_power_change_notif_thresholds_ExpectAndReturn(id, threshold_low, threshold_high, cmock_retval) set_power_change_notif_thresholds_CMockExpectAndReturn(__LINE__, id, threshold_low, threshold_high, cmock_retval) -void set_power_change_notif_thresholds_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t id, uint32_t threshold_low, uint32_t threshold_high, int cmock_to_return); -typedef int (* CMOCK_set_power_change_notif_thresholds_CALLBACK)(fwk_id_t id, uint32_t threshold_low, uint32_t threshold_high, int cmock_num_calls); -void set_power_change_notif_thresholds_AddCallback(CMOCK_set_power_change_notif_thresholds_CALLBACK Callback); -void set_power_change_notif_thresholds_Stub(CMOCK_set_power_change_notif_thresholds_CALLBACK Callback); -#define set_power_change_notif_thresholds_StubWithCallback set_power_change_notif_thresholds_Stub -#define set_power_change_notif_thresholds_IgnoreArg_id() set_power_change_notif_thresholds_CMockIgnoreArg_id(__LINE__) -void set_power_change_notif_thresholds_CMockIgnoreArg_id(UNITY_LINE_TYPE cmock_line); -#define set_power_change_notif_thresholds_IgnoreArg_threshold_low() set_power_change_notif_thresholds_CMockIgnoreArg_threshold_low(__LINE__) -void set_power_change_notif_thresholds_CMockIgnoreArg_threshold_low(UNITY_LINE_TYPE cmock_line); -#define set_power_change_notif_thresholds_IgnoreArg_threshold_high() set_power_change_notif_thresholds_CMockIgnoreArg_threshold_high(__LINE__) -void set_power_change_notif_thresholds_CMockIgnoreArg_threshold_high(UNITY_LINE_TYPE cmock_line); - -#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__) -#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0))) -#pragma GCC diagnostic pop -#endif -#endif - -#endif diff --git a/module/scmi_power_capping/test/mod_power_coordinator_extra.h b/module/scmi_power_capping/test/mod_power_coordinator_extra.h deleted file mode 100644 index ed9259ae0..000000000 --- a/module/scmi_power_capping/test/mod_power_coordinator_extra.h +++ /dev/null @@ -1,15 +0,0 @@ -/* - * Arm SCP/MCP Software - * Copyright (c) 2023, Arm Limited and Contributors. All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause - */ - -#ifndef MOD_POWER_COORIDNATOR_EXTRA_H_ -# define MOD_POWER_COORDINATOR_EXTRA_H_ - -# include "mod_power_coordinator.h" - -int get_coordinator_period(fwk_id_t domain_id, uint32_t *period); -int set_coordinator_period(fwk_id_t domain_id, uint32_t period); -#endif /* MOD_POWER_COORDINATOR_EXTRA_H_ */ diff --git a/module/scmi_power_capping/test/mod_power_meter_extra.h b/module/scmi_power_capping/test/mod_power_meter_extra.h deleted file mode 100644 index d565b8d2c..000000000 --- a/module/scmi_power_capping/test/mod_power_meter_extra.h +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Arm SCP/MCP Software - * Copyright (c) 2023, Arm Limited and Contributors. All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause - */ - -#ifndef MOD_POWER_METER_EXTRA_H_ -#define MOD_POWER_METER_EXTRA_H_ - -#include "mod_power_meter.h" - -int get_power(fwk_id_t domain_id, uint32_t *power); - -int set_power_change_notif_thresholds( - fwk_id_t id, - uint32_t threshold_low, - uint32_t threshold_high); -#endif /* MOD_POWER_METER_EXTRA_H_ */ diff --git a/module/scmi_power_capping/test/mod_scmi_power_capping_unit_test.c b/module/scmi_power_capping/test/mod_scmi_power_capping_unit_test.c index 2164f148e..7692f95ef 100644 --- a/module/scmi_power_capping/test/mod_scmi_power_capping_unit_test.c +++ b/module/scmi_power_capping/test/mod_scmi_power_capping_unit_test.c @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ @@ -125,21 +125,6 @@ void utest_scmi_power_capping_bind_success(void) &(power_management_apis.power_capping_api), FWK_SUCCESS); - fwk_module_bind_ExpectAndReturn( - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_COORDINATOR), - FWK_ID_API( - FWK_MODULE_IDX_POWER_COORDINATOR, - MOD_POWER_COORDINATOR_API_IDX_PERIOD), - &(power_management_apis.power_coordinator_api), - FWK_SUCCESS); - - fwk_module_bind_ExpectAndReturn( - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_METER), - FWK_ID_API( - FWK_MODULE_IDX_POWER_METER, MOD_POWER_METER_API_IDX_MEASUREMENT), - &(power_management_apis.power_meter_api), - FWK_SUCCESS); - #ifdef BUILD_HAS_SCMI_POWER_CAPPING_STD_COMMANDS pcapping_protocol_bind_ExpectAndReturn(FWK_SUCCESS); pcapping_protocol_set_power_apis_Expect(&power_management_apis); @@ -166,21 +151,6 @@ void utest_scmi_power_capping_bind_failure(void) &(power_management_apis.power_capping_api), FWK_SUCCESS); - fwk_module_bind_ExpectAndReturn( - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_COORDINATOR), - FWK_ID_API( - FWK_MODULE_IDX_POWER_COORDINATOR, - MOD_POWER_COORDINATOR_API_IDX_PERIOD), - &(power_management_apis.power_coordinator_api), - FWK_SUCCESS); - - fwk_module_bind_ExpectAndReturn( - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_METER), - FWK_ID_API( - FWK_MODULE_IDX_POWER_METER, MOD_POWER_METER_API_IDX_MEASUREMENT), - &(power_management_apis.power_meter_api), - FWK_SUCCESS); - #ifdef BUILD_HAS_SCMI_POWER_CAPPING_STD_COMMANDS pcapping_protocol_bind_ExpectAndReturn(FWK_E_INIT); #endif diff --git a/module/scmi_power_capping/test/scmi_power_capping_fast_channels_unit_test.c b/module/scmi_power_capping/test/scmi_power_capping_fast_channels_unit_test.c index 3ba5d51ca..529d94fb2 100644 --- a/module/scmi_power_capping/test/scmi_power_capping_fast_channels_unit_test.c +++ b/module/scmi_power_capping/test/scmi_power_capping_fast_channels_unit_test.c @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ @@ -11,7 +11,6 @@ #include #include #include -#include #include #include @@ -87,16 +86,15 @@ static const struct mod_transport_fast_channels_api transport_fch_api = { static const struct mod_power_capping_api power_capping_api = { .get_applied_cap = get_applied_cap, .request_cap = request_cap, -}; - -static const struct mod_power_coordinator_api power_coordinator_api = { - .get_coordinator_period = get_coordinator_period, - .set_coordinator_period = set_coordinator_period, + .get_average_power = get_average_power, + .get_averaging_interval = get_averaging_interval, + .get_averaging_interval_range = get_averaging_interval_range, + .get_averaging_interval_step = get_averaging_interval_step, + .set_averaging_interval = set_averaging_interval, }; static const struct mod_scmi_power_capping_power_apis power_management_apis = { .power_capping_api = &power_capping_api, - .power_coordinator_api = &power_coordinator_api, }; static uint32_t local_fast_channel_memory_emulation; @@ -205,13 +203,12 @@ void utest_pcapping_fast_channel_process_command_pai_get(void) (FAKE_POWER_CAPPING_IDX_1 * MOD_SCMI_PCAPPING_FAST_CHANNEL_COUNT) + MOD_SCMI_PCAPPING_FAST_CHANNEL_PAI_GET; - get_coordinator_period_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, - &pai, - sizeof(pai), + get_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + NULL, FWK_SUCCESS); - get_coordinator_period_IgnoreArg_period(); - get_coordinator_period_ReturnMemThruPtr_period(&pai, sizeof(pai)); + get_averaging_interval_IgnoreArg_pai(); + get_averaging_interval_ReturnThruPtr_pai(&pai); pcapping_fast_channel_process_command(fch_idx); TEST_ASSERT_EQUAL(local_fast_channel_memory_emulation, pai); @@ -227,10 +224,11 @@ void utest_pcapping_fast_channel_process_command_pai_set(void) local_fast_channel_memory_emulation = __LINE__; - set_coordinator_period_ExpectAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, + set_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, local_fast_channel_memory_emulation, FWK_SUCCESS); + pcapping_fast_channel_process_command(fch_idx); } @@ -287,16 +285,15 @@ void utest_pcapping_fast_channel_process_event_timer_interrupt(void) FWK_SUCCESS); break; case MOD_SCMI_PCAPPING_FAST_CHANNEL_PAI_GET: - get_coordinator_period_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, + get_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, NULL, - 0, FWK_SUCCESS); - get_coordinator_period_IgnoreArg_period(); + get_averaging_interval_IgnoreArg_pai(); break; case MOD_SCMI_PCAPPING_FAST_CHANNEL_PAI_SET: - set_coordinator_period_ExpectAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, + set_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, local_fast_channel_memory_emulation, FWK_SUCCESS); break; diff --git a/module/scmi_power_capping/test/scmi_power_capping_protocol_unit_test.c b/module/scmi_power_capping/test/scmi_power_capping_protocol_unit_test.c index 5836f38a1..3b1462658 100644 --- a/module/scmi_power_capping/test/scmi_power_capping_protocol_unit_test.c +++ b/module/scmi_power_capping/test/scmi_power_capping_protocol_unit_test.c @@ -14,8 +14,6 @@ #include #include #include -#include -#include #include #include #include @@ -95,15 +93,6 @@ static const struct mod_power_capping_api power_capping_api = { .set_averaging_interval = set_averaging_interval, }; -static const struct mod_power_coordinator_api power_coordinator_api = { - .get_coordinator_period = get_coordinator_period, - .set_coordinator_period = set_coordinator_period, -}; - -static const struct mod_power_meter_api power_meter_api = { - .get_power = get_power, -}; - #ifdef BUILD_HAS_MOD_RESOURCE_PERMS static const struct mod_res_permissions_api res_perms_api = { .agent_has_protocol_permission = agent_has_protocol_permission, @@ -122,8 +111,6 @@ static const struct mod_scmi_notification_api scmi_notification_api = { static const struct mod_scmi_power_capping_power_apis power_management_apis = { .power_capping_api = &power_capping_api, - .power_coordinator_api = &power_coordinator_api, - .power_meter_api = &power_meter_api, }; static fwk_id_t service_id_1 = @@ -139,12 +126,10 @@ static const struct mod_scmi_power_capping_domain_config #ifdef BUILD_HAS_SCMI_NOTIFICATIONS .cap_pai_change_notification_support = true, #endif - .min_pai = MIN_DEFAULT_PAI, - .max_pai = MAX_DEFAULT_PAI, - .pai_step = 1, .min_power_cap = MIN_DEFAULT_POWER_CAP, .max_power_cap = MAX_DEFAULT_POWER_CAP, .power_cap_step = 1, + .pai_config_support = true, }; static const struct mod_scmi_power_capping_domain_config @@ -154,6 +139,7 @@ static const struct mod_scmi_power_capping_domain_config FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_POWER_CAPPING, __LINE__), .min_power_cap = MIN_DEFAULT_POWER_CAP, .max_power_cap = MIN_DEFAULT_POWER_CAP, + .pai_config_support = true, }; static struct mod_scmi_power_capping_domain_context @@ -190,12 +176,6 @@ static void test_request_cap_config_supported( domain_ctx_table[domain_idx].cap_config_support = cap_config_supported; } -static void test_set_pai_config_supported( - unsigned int domain_idx, - bool pai_config_supported) -{ - domain_ctx_table[domain_idx].pai_config_support = pai_config_supported; -} /* Test functions */ /* Initialize the tests */ static void test_init(void) @@ -235,8 +215,6 @@ void tearDown(void) { Mockmod_power_capping_extra_Verify(); Mockmod_scmi_extra_Verify(); - Mockmod_power_coordinator_extra_Verify(); - Mockmod_power_meter_extra_Verify(); Mockfwk_id_Verify(); #ifdef BUILD_HAS_MOD_RESOURCE_PERMS Mockmod_resource_perms_extra_Verify(); @@ -396,6 +374,10 @@ void utest_message_handler_domain_invalid(void) void utest_message_handler_domain_attributes_valid(void) { + uint32_t min_pai = MIN_DEFAULT_PAI; + uint32_t max_pai = MAX_DEFAULT_PAI; + uint32_t pai_step = 1; + struct mod_scmi_power_capping_domain_context *domain_ctx = &domain_ctx_table[FAKE_POWER_CAPPING_IDX_1]; const struct mod_scmi_power_capping_domain_config *config = @@ -409,12 +391,12 @@ void utest_message_handler_domain_attributes_valid(void) struct scmi_power_capping_domain_attributes_p2a ret_payload = { .status = SCMI_SUCCESS, - .attributes = 1u << POWER_CAP_CONF_SUP_POS | + .attributes = 1u << POWER_CAP_CONF_SUP_POS | 1u << PAI_CONF_SUP_POS | config->power_cap_unit << POWER_UNIT_POS, .name = "TestPowerCap", - .min_pai = config->min_pai, - .max_pai = config->max_pai, - .pai_step = config->pai_step, + .min_pai = min_pai, + .max_pai = max_pai, + .pai_step = pai_step, .min_power_cap = config->min_power_cap, .max_power_cap = config->max_power_cap, .power_cap_step = config->power_cap_step, @@ -422,9 +404,9 @@ void utest_message_handler_domain_attributes_valid(void) .parent_id = config->parent_idx, }; - uint32_t expected_pai_step = config->pai_step; - uint32_t expected_min_pai = config->min_pai; - uint32_t expected_max_pai = config->max_pai; + uint32_t expected_pai_step = pai_step; + uint32_t expected_min_pai = min_pai; + uint32_t expected_max_pai = max_pai; get_averaging_interval_step_ExpectAndReturn( config->power_capping_domain_id, NULL, FWK_SUCCESS); @@ -795,8 +777,6 @@ void utest_message_handler_power_capping_set_pai_valid(void) .status = SCMI_SUCCESS, }; - test_set_pai_config_supported(cmd_payload.domain_id, true); - #ifdef BUILD_HAS_SCMI_NOTIFICATIONS fwk_id_is_equal_ExpectAndReturn(FWK_ID_NONE, FWK_ID_NONE, true); #endif @@ -825,8 +805,6 @@ void utest_message_handler_power_capping_set_pai_failure(void) .status = SCMI_GENERIC_ERROR, }; - test_set_pai_config_supported(cmd_payload.domain_id, true); - #ifdef BUILD_HAS_SCMI_NOTIFICATIONS fwk_id_is_equal_ExpectAndReturn(FWK_ID_NONE, FWK_ID_NONE, true); #endif @@ -854,7 +832,14 @@ void utest_message_handler_power_capping_set_less_than_min_pai(void) .status = SCMI_OUT_OF_RANGE, }; - test_set_pai_config_supported(cmd_payload.domain_id, true); +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + fwk_id_is_equal_ExpectAndReturn(FWK_ID_NONE, FWK_ID_NONE, true); +#endif + + set_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + pai, + FWK_E_RANGE); mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); @@ -874,7 +859,15 @@ void utest_message_handler_power_capping_set_more_than_max_pai(void) .status = SCMI_OUT_OF_RANGE, }; - test_set_pai_config_supported(cmd_payload.domain_id, true); +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + fwk_id_is_equal_ExpectAndReturn(FWK_ID_NONE, FWK_ID_NONE, true); +#endif + + set_averaging_interval_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + pai, + FWK_E_RANGE); + mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); EXPECT_RESPONSE_ERROR(ret_payload); @@ -1086,13 +1079,13 @@ void utest_pcapping_protocol_process_cap_pai_notify_event_success(void) get_applied_cap_IgnoreArg_cap(); get_applied_cap_ReturnMemThruPtr_cap(&cap, sizeof(cap)); - get_coordinator_period_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_coordinator_domain_id, + get_averaging_interval_ExpectWithArrayAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, &pai, sizeof(pai), FWK_SUCCESS); - get_coordinator_period_IgnoreArg_period(); - get_coordinator_period_ReturnMemThruPtr_period(&pai, sizeof(pai)); + get_averaging_interval_IgnoreArg_pai(); + get_averaging_interval_ReturnThruPtr_pai(&pai); scmi_notification_notify_ExpectWithArrayAndReturn( MOD_SCMI_PROTOCOL_ID_POWER_CAPPING, @@ -1132,13 +1125,12 @@ void utest_pcapping_protocol_process_measurements_notify_event_success(void) *event_params_ptr = event_params; - get_power_ExpectWithArrayAndReturn( - scmi_power_capping_default_config.power_meter_domain_id, - &power, - sizeof(power), + get_average_power_ExpectAndReturn( + scmi_power_capping_default_config.power_capping_domain_id, + NULL, FWK_SUCCESS); - get_power_IgnoreArg_power(); - get_power_ReturnMemThruPtr_power(&power, sizeof(power)); + get_average_power_IgnoreArg_power(); + get_average_power_ReturnThruPtr_power(&power); scmi_notification_notify_ExpectWithArrayAndReturn( MOD_SCMI_PROTOCOL_ID_POWER_CAPPING, @@ -1325,17 +1317,17 @@ void utest_pcapping_protocol_start_element(void) fwk_notification_subscribe_ExpectAndReturn( FWK_ID_NOTIFICATION( - FWK_MODULE_IDX_POWER_COORDINATOR, - MOD_POWER_COORDINATOR_NOTIFICATION_IDX_PERIOD_CHANGED), - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_COORDINATOR), + FWK_MODULE_IDX_POWER_CAPPING, + MOD_POWER_CAPPING_NOTIFICATION_IDX_PAI_CHANGED), + FWK_ID_MODULE(FWK_MODULE_IDX_POWER_CAPPING), element_id, FWK_SUCCESS); fwk_notification_subscribe_ExpectAndReturn( FWK_ID_NOTIFICATION( - FWK_MODULE_IDX_POWER_METER, - MOD_POWER_METER_NOTIFICATION_IDX_MEASUREMENTS_CHANGED), - FWK_ID_MODULE(FWK_MODULE_IDX_POWER_METER), + FWK_MODULE_IDX_POWER_CAPPING, + MOD_POWER_CAPPING_NOTIFICATION_IDX_MEASUREMENTS_CHANGED), + FWK_ID_MODULE(FWK_MODULE_IDX_POWER_CAPPING), element_id, FWK_SUCCESS); -- GitLab