From 45d760d39430ca83c2d87e16b701021beda31b68 Mon Sep 17 00:00:00 2001 From: Md Golam Tanvir Zim Date: Wed, 20 Mar 2024 16:57:54 +0000 Subject: [PATCH 01/16] scmi_clock: Change Clock protocol version to v2.0 Change clock management protocol version from 1.0 to 2.0 according to SCMIv3.1 section 4.6.2.1. Signed-off-by: Md Golam Tanvir Zim Change-Id: Ibb57be98992c766d2f547cef3b6e909858f3238b --- module/scmi_clock/include/internal/scmi_clock.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/module/scmi_clock/include/internal/scmi_clock.h b/module/scmi_clock/include/internal/scmi_clock.h index 2abc569ec..266e5c136 100644 --- a/module/scmi_clock/include/internal/scmi_clock.h +++ b/module/scmi_clock/include/internal/scmi_clock.h @@ -13,7 +13,7 @@ #include -#define SCMI_PROTOCOL_VERSION_CLOCK UINT32_C(0x10000) +#define SCMI_PROTOCOL_VERSION_CLOCK UINT32_C(0x20000) /* * Identifiers for the type of request being processed -- GitLab From 0bcfa2287c7f285024473b82e794ba3e5747c52e Mon Sep 17 00:00:00 2001 From: Md Golam Tanvir Zim Date: Tue, 9 Apr 2024 15:11:24 +0100 Subject: [PATCH 02/16] scmi_clock: Add support for extended clock name This patch adds support for extended clock name in CLOCK_ATTRIBUTES command as per specified in SCMIv3.1. Signed-off-by: Md Golam Tanvir Zim Change-Id: Ie97b1d782d48c330a10ab1bc1390466780446a40 --- .../scmi_clock/include/internal/scmi_clock.h | 18 +++++++------ module/scmi_clock/include/mod_scmi_clock.h | 7 +++++- module/scmi_clock/src/mod_scmi_clock.c | 25 ++++++++++++++++++- 3 files changed, 41 insertions(+), 9 deletions(-) diff --git a/module/scmi_clock/include/internal/scmi_clock.h b/module/scmi_clock/include/internal/scmi_clock.h index 266e5c136..f765a1747 100644 --- a/module/scmi_clock/include/internal/scmi_clock.h +++ b/module/scmi_clock/include/internal/scmi_clock.h @@ -102,26 +102,30 @@ struct scmi_clock_generic_p2a { */ #define SCMI_CLOCK_ATTRIBUTES_ENABLED_POS 0 +#define SCMI_CLOCK_ATTRIBUTES_EXTENDED_CLOCK_NAME_POS 29 #define SCMI_CLOCK_ATTRIBUTES_ENABLED_MASK \ (UINT32_C(0x1) << SCMI_CLOCK_ATTRIBUTES_ENABLED_POS) -#define SCMI_CLOCK_ATTRIBUTES(ENABLED) \ - ( \ - (((ENABLED) << SCMI_CLOCK_ATTRIBUTES_ENABLED_POS) & \ - SCMI_CLOCK_ATTRIBUTES_ENABLED_MASK) \ - ) +#define SCMI_CLOCK_ATTRIBUTES_EXTENDED_CLOCK_NAME_MASK \ + (UINT32_C(0x1) << SCMI_CLOCK_ATTRIBUTES_EXTENDED_CLOCK_NAME_POS) + +#define SCMI_CLOCK_ATTRIBUTES(ENABLED, EXTENDED_CLOCK) \ + ((((ENABLED) << SCMI_CLOCK_ATTRIBUTES_ENABLED_POS) & \ + SCMI_CLOCK_ATTRIBUTES_ENABLED_MASK) | \ + (((EXTENDED_CLOCK) << SCMI_CLOCK_ATTRIBUTES_EXTENDED_CLOCK_NAME_POS) & \ + SCMI_CLOCK_ATTRIBUTES_EXTENDED_CLOCK_NAME_MASK)) struct scmi_clock_attributes_a2p { uint32_t clock_id; }; -#define SCMI_CLOCK_NAME_LENGTH_MAX 16 +#define SCMI_CLOCK_NAME_LENGTH 16 struct scmi_clock_attributes_p2a { int32_t status; uint32_t attributes; - char clock_name[SCMI_CLOCK_NAME_LENGTH_MAX]; + char clock_name[SCMI_CLOCK_NAME_LENGTH]; }; /* diff --git a/module/scmi_clock/include/mod_scmi_clock.h b/module/scmi_clock/include/mod_scmi_clock.h index 56cdc510a..9a75031e2 100644 --- a/module/scmi_clock/include/mod_scmi_clock.h +++ b/module/scmi_clock/include/mod_scmi_clock.h @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2015-2021, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2015-2024, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -78,6 +78,11 @@ struct mod_scmi_clock_device { * internal state map. */ bool starts_enabled; + + /*! + * \brief Flag indicating whether extended clock name is supported + */ + bool supports_extended_name; }; /*! diff --git a/module/scmi_clock/src/mod_scmi_clock.c b/module/scmi_clock/src/mod_scmi_clock.c index 7acd14ab0..cf3f920e3 100644 --- a/module/scmi_clock/src/mod_scmi_clock.c +++ b/module/scmi_clock/src/mod_scmi_clock.c @@ -484,6 +484,15 @@ static inline bool clock_ops_is_available(unsigned int clock_dev_idx) FWK_ID_NONE); } +static inline bool clock_has_extended_name( + unsigned int agent_id, + unsigned int clock_dev_idx) +{ + return scmi_clock_ctx.agent_table[agent_id] + .device_table[clock_dev_idx] + .supports_extended_name; +} + /* * Helper for the 'clock_attributes' response */ @@ -494,12 +503,26 @@ static void clock_attributes_respond( int status) { int respond_status; + bool has_extended_name = false; + unsigned int agent_id, clock_dev_idx; size_t response_size; + const struct mod_scmi_clock_agent *agent; struct scmi_clock_attributes_p2a return_values = { 0 }; if (status == FWK_SUCCESS) { + clock_dev_idx = fwk_id_get_element_idx(clock_dev_id); + status = scmi_clock_ctx.scmi_api->get_agent_id(service_id, &agent_id); + if (status != FWK_SUCCESS) { + FWK_LOG_DEBUG("[SCMI-CLK] %s @%d", __func__, __LINE__); + } else { + agent = &scmi_clock_ctx.agent_table[agent_id]; + has_extended_name = + agent->device_table[clock_dev_idx].supports_extended_name; + } + return_values.attributes = SCMI_CLOCK_ATTRIBUTES( - (uint32_t)(*clock_state == MOD_CLOCK_STATE_RUNNING)); + ((uint32_t)(*clock_state == MOD_CLOCK_STATE_RUNNING)), + ((uint32_t)has_extended_name)); fwk_str_strncpy( return_values.clock_name, -- GitLab From e2ddc2c02a7bf8e71211571abac585217c719bd4 Mon Sep 17 00:00:00 2001 From: Md Golam Tanvir Zim Date: Tue, 30 Apr 2024 20:20:18 +0100 Subject: [PATCH 03/16] scmi_clock: Add CLOCK_NAME_GET command This patch implements the CLOCK_NAME_GET command which returns the extended name of a specific clock device as per specified in SCMIv3.1. Signed-off-by: Md Golam Tanvir Zim Change-Id: I4cf0ff163028f027aec2d77cfc7ddd8c747b2c1a --- .../include/mod_resource_perms.h | 4 +- module/scmi/include/mod_scmi_std.h | 1 + .../scmi_clock/include/internal/scmi_clock.h | 15 +- module/scmi_clock/src/mod_scmi_clock.c | 136 +++++++++++++++++- .../test/mod_scmi_clock_unit_test.c | 7 +- 5 files changed, 152 insertions(+), 11 deletions(-) diff --git a/module/resource_perms/include/mod_resource_perms.h b/module/resource_perms/include/mod_resource_perms.h index 812681710..0c83fe8a3 100644 --- a/module/resource_perms/include/mod_resource_perms.h +++ b/module/resource_perms/include/mod_resource_perms.h @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2020-2023, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2020-2024, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -189,6 +189,8 @@ enum mod_res_clock_permissions_idx { MOD_SCMI_CLOCK_RATE_GET - MOD_RES_PERMS_CLOCK_PERMS_OFFSET, MOD_RES_PERMS_SCMI_CLOCK_CONFIG_SET_IDX = MOD_SCMI_CLOCK_CONFIG_SET - MOD_RES_PERMS_CLOCK_PERMS_OFFSET, + MOD_RES_PERMS_SCMI_CLOCK_NAME_GET_IDX = + MOD_SCMI_CLOCK_NAME_GET - MOD_RES_PERMS_CLOCK_PERMS_OFFSET, }; /*! diff --git a/module/scmi/include/mod_scmi_std.h b/module/scmi/include/mod_scmi_std.h index 3993cddf0..5ca4f41c9 100644 --- a/module/scmi/include/mod_scmi_std.h +++ b/module/scmi/include/mod_scmi_std.h @@ -166,6 +166,7 @@ enum scmi_clock_command_id { MOD_SCMI_CLOCK_RATE_SET = 0x005, MOD_SCMI_CLOCK_RATE_GET = 0x006, MOD_SCMI_CLOCK_CONFIG_SET = 0x007, + MOD_SCMI_CLOCK_NAME_GET = 0x008, MOD_SCMI_CLOCK_COMMAND_COUNT, }; diff --git a/module/scmi_clock/include/internal/scmi_clock.h b/module/scmi_clock/include/internal/scmi_clock.h index f765a1747..77dc542ff 100644 --- a/module/scmi_clock/include/internal/scmi_clock.h +++ b/module/scmi_clock/include/internal/scmi_clock.h @@ -23,6 +23,7 @@ enum scmi_clock_request_type { SCMI_CLOCK_REQUEST_GET_RATE, SCMI_CLOCK_REQUEST_SET_RATE, SCMI_CLOCK_REQUEST_SET_STATE, + SCMI_CLOCK_REQUEST_GET_NAME, SCMI_CLOCK_REQUEST_COUNT, }; @@ -34,6 +35,7 @@ enum scmi_clock_event_idx { SCMI_CLOCK_EVENT_IDX_GET_RATE, SCMI_CLOCK_EVENT_IDX_SET_RATE, SCMI_CLOCK_EVENT_IDX_SET_STATE, + SCMI_CLOCK_EVENT_IDX_GET_NAME, SCMI_CLOCK_EVENT_IDX_COUNT, }; @@ -120,7 +122,8 @@ struct scmi_clock_attributes_a2p { uint32_t clock_id; }; -#define SCMI_CLOCK_NAME_LENGTH 16 +#define SCMI_CLOCK_NAME_LENGTH 16 +#define SCMI_CLOCK_EXTENDED_NAME_LENGTH 64 struct scmi_clock_attributes_p2a { int32_t status; @@ -248,4 +251,14 @@ struct scmi_clock_describe_rates_p2a { struct scmi_clock_rate rates[]; }; +struct scmi_clock_name_get_a2p { + uint32_t clock_id; +}; + +struct scmi_clock_name_get_p2a { + int32_t status; + uint32_t flags; + char clock_extended_name[SCMI_CLOCK_EXTENDED_NAME_LENGTH]; +}; + #endif /* INTERNAL_SCMI_CLOCK_H */ diff --git a/module/scmi_clock/src/mod_scmi_clock.c b/module/scmi_clock/src/mod_scmi_clock.c index cf3f920e3..2cfce88cd 100644 --- a/module/scmi_clock/src/mod_scmi_clock.c +++ b/module/scmi_clock/src/mod_scmi_clock.c @@ -110,6 +110,9 @@ static const fwk_id_t mod_scmi_clock_event_id_set_state = FWK_ID_EVENT_INIT(FWK_MODULE_IDX_SCMI_CLOCK, SCMI_CLOCK_EVENT_IDX_SET_STATE); +static const fwk_id_t mod_scmi_clock_event_id_get_name = + FWK_ID_EVENT_INIT(FWK_MODULE_IDX_SCMI_CLOCK, SCMI_CLOCK_EVENT_IDX_GET_NAME); + /* * SCMI Clock Message Handlers */ @@ -129,6 +132,9 @@ static int scmi_clock_config_set_handler(fwk_id_t service_id, const uint32_t *payload); static int scmi_clock_describe_rates_handler(fwk_id_t service_id, const uint32_t *payload); +static int scmi_clock_name_get_handler( + fwk_id_t service_id, + const uint32_t *payload); /* * Internal variables. @@ -145,6 +151,7 @@ static handler_table_t handler_table[MOD_SCMI_CLOCK_COMMAND_COUNT] = { [MOD_SCMI_CLOCK_RATE_SET] = scmi_clock_rate_set_handler, [MOD_SCMI_CLOCK_CONFIG_SET] = scmi_clock_config_set_handler, [MOD_SCMI_CLOCK_DESCRIBE_RATES] = scmi_clock_describe_rates_handler, + [MOD_SCMI_CLOCK_NAME_GET] = scmi_clock_name_get_handler, }; static const size_t payload_size_table[MOD_SCMI_CLOCK_COMMAND_COUNT] = { @@ -162,6 +169,8 @@ static const size_t payload_size_table[MOD_SCMI_CLOCK_COMMAND_COUNT] = { (unsigned int)sizeof(struct scmi_clock_config_set_a2p), [MOD_SCMI_CLOCK_DESCRIBE_RATES] = (unsigned int)sizeof(struct scmi_clock_describe_rates_a2p), + [MOD_SCMI_CLOCK_NAME_GET] = + (unsigned int)sizeof(struct scmi_clock_name_get_a2p), }; /* @@ -574,6 +583,32 @@ static void get_rate_respond(fwk_id_t service_id, } } +/* + * Helper for the 'get_name' response + */ +static void get_name_respond(fwk_id_t clock_dev_id, fwk_id_t service_id) +{ + int respond_status; + size_t response_size; + struct scmi_clock_name_get_p2a return_values = { 0 }; + + const char *clock_name = fwk_module_get_element_name(clock_dev_id); + + fwk_str_strncpy( + return_values.clock_extended_name, + clock_name, + FWK_MIN(sizeof(return_values.clock_extended_name), strlen(clock_name))); + + return_values.status = (int32_t)SCMI_SUCCESS; + response_size = sizeof(return_values); + + respond_status = scmi_clock_ctx.scmi_api->respond( + service_id, &return_values, response_size); + if (respond_status != FWK_SUCCESS) { + FWK_LOG_DEBUG("[SCMI-CLK] %s @%d", __func__, __LINE__); + } +} + static void request_response(int response_status, fwk_id_t service_id) { @@ -773,8 +808,12 @@ static int create_event_request( event.id = mod_scmi_clock_event_id_set_state; break; - default: - return FWK_E_PARAM; + case SCMI_CLOCK_REQUEST_GET_NAME: + event.id = mod_scmi_clock_event_id_get_name; + break; + + default: + return FWK_E_PARAM; } params->clock_dev_id = clock_id; @@ -1402,6 +1441,85 @@ exit: return status; } +/* + * Clock Name Get + */ +static int scmi_clock_name_get_handler( + fwk_id_t service_id, + const uint32_t *payload) +{ + int status, respond_status; + unsigned int agent_id, clock_dev_idx; + const struct mod_scmi_clock_device *clock_device; + size_t response_size; + const struct scmi_clock_name_get_a2p *parameters; + struct scmi_clock_name_get_p2a return_values = { + .status = (int32_t)SCMI_GENERIC_ERROR + }; + + parameters = (const struct scmi_clock_name_get_a2p *)payload; + + status = scmi_clock_get_clock_device_entry( + service_id, parameters->clock_id, &clock_device); + if (status != FWK_SUCCESS) { + return_values.status = (int32_t)SCMI_NOT_FOUND; + goto exit; + } + +#ifdef BUILD_HAS_MOD_RESOURCE_PERMS + status = scmi_clock_permissions_handler( + parameters->clock_id, + service_id, + (unsigned int)MOD_SCMI_CLOCK_NAME_GET); + if (status != FWK_SUCCESS) { + return_values.status = (int32_t)SCMI_DENIED; + goto exit; + } +#endif + + status = scmi_clock_ctx.scmi_api->get_agent_id(service_id, &agent_id); + if (status != FWK_SUCCESS) { + return status; + } + + clock_dev_idx = + scmi_clock_get_clock_device_idx(agent_id, parameters->clock_id); + if (!clock_has_extended_name(agent_id, clock_dev_idx)) { + return_values.status = (int32_t)SCMI_NOT_SUPPORTED; + goto exit; + } + + status = create_event_request( + clock_device->element_id, + service_id, + SCMI_CLOCK_REQUEST_GET_NAME, + NULL, + parameters->clock_id); + if (status == FWK_E_BUSY) { + return_values.status = (int32_t)SCMI_BUSY; + status = FWK_SUCCESS; + goto exit; + } + + if (status != FWK_SUCCESS) { + goto exit; + } + + return FWK_SUCCESS; + +exit: + response_size = (return_values.status == SCMI_SUCCESS) ? + sizeof(return_values) : + sizeof(return_values.status); + respond_status = scmi_clock_ctx.scmi_api->respond( + service_id, &return_values, response_size); + if (respond_status != FWK_SUCCESS) { + FWK_LOG_DEBUG("[SCMI-CLK] %s @%d", __func__, __LINE__); + } + + return status; +} + /* * SCMI module -> SCMI clock module interface */ @@ -1548,13 +1666,13 @@ static int process_request_event(const struct fwk_event *event) event_id_type = (enum scmi_clock_event_idx)fwk_id_get_event_idx(event->id); + status = scmi_clock_ctx.scmi_api->get_agent_id(service_id, &agent_id); + if (status != FWK_SUCCESS) { + return status; + } + switch (event_id_type) { case SCMI_CLOCK_EVENT_IDX_CLOCK_ATTRIBUTES: - status = scmi_clock_ctx.scmi_api->get_agent_id(service_id, &agent_id); - if (status != FWK_SUCCESS) { - return status; - } - status = scmi_clock_ctx.clock_api->get_state( params->clock_dev_id, &clock_state); if (status != FWK_PENDING) { @@ -1603,6 +1721,10 @@ static int process_request_event(const struct fwk_event *event) } break; + case SCMI_CLOCK_EVENT_IDX_GET_NAME: + get_name_respond(params->clock_dev_id, service_id); + break; + default: return FWK_E_PARAM; } diff --git a/module/scmi_clock/test/mod_scmi_clock_unit_test.c b/module/scmi_clock/test/mod_scmi_clock_unit_test.c index 3c7161a09..8cb9ef3d5 100644 --- a/module/scmi_clock/test/mod_scmi_clock_unit_test.c +++ b/module/scmi_clock/test/mod_scmi_clock_unit_test.c @@ -789,17 +789,20 @@ void test_mod_scmi_clock_attributes_handler_get_state(void) mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn(FWK_SUCCESS); mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn(FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + fwk_module_get_element_name_ExpectAnyArgsAndReturn(""); mod_scmi_from_protocol_api_respond_Stub( clock_attributes_get_state_callback); #else - fwk_id_get_element_idx_ExpectAnyArgsAndReturn(CLOCK_DEV_IDX_FAKE0); fwk_id_is_equal_ExpectAnyArgsAndReturn(true); - __fwk_put_event_ExpectAnyArgsAndReturn(FWK_SUCCESS); #endif + fwk_id_get_element_idx_ExpectAnyArgsAndReturn(CLOCK_DEV_IDX_FAKE0); + status = scmi_clock_message_handler( (fwk_id_t)MOD_SCMI_PROTOCOL_ID_CLOCK, service_id, -- GitLab From 5850cd4b55d52507c696b7a7a991f339d3fd09a8 Mon Sep 17 00:00:00 2001 From: Md Golam Tanvir Zim Date: Thu, 2 May 2024 14:38:00 +0100 Subject: [PATCH 04/16] scmi_clock: Add SCMI notifications related with clock rate This patch implements the following as per specified in SCMIv3.1, Commands: - CLOCK_RATE_NOTIFY command which allows the agents to request notification when there is a change in clock rate on a clock device. - CLOCK_RATE_CHANGE_REQUESTED_NOTIFY command which allows the agents to request notification when there is a request for change in clock rate on a clock device from another agent or entity in the system. Notifications: - CLOCK_RATE_CHANGED notification which is sent to the subsribing agents when there is a change in clock rate. - CLOCK_RATE_CHANGE_REQUESTED notification which is sent to the subsribing agents when there is a request for change in clock rate. Update CLOCK_ATTRIBUTES command: - adds support for clock rate change notification - adds support for clock rate change requested notification - adds clock enable delay (currently unsupported) Signed-off-by: Md Golam Tanvir Zim Change-Id: I77b80371c92a3d6ead71ea0c116b7e4ef0d732b2 --- module/clock/include/mod_clock.h | 50 ++- module/clock/src/clock.h | 7 +- module/clock/src/mod_clock.c | 138 +++++++- module/dvfs/src/mod_dvfs.c | 12 +- .../include/mod_resource_perms.h | 5 + module/scmi/include/mod_scmi_std.h | 2 + .../scmi_clock/include/internal/scmi_clock.h | 48 ++- module/scmi_clock/include/mod_scmi_clock.h | 27 ++ module/scmi_clock/src/mod_scmi_clock.c | 314 +++++++++++++++++- 9 files changed, 574 insertions(+), 29 deletions(-) diff --git a/module/clock/include/mod_clock.h b/module/clock/include/mod_clock.h index e63514fae..b3aeb7f58 100644 --- a/module/clock/include/mod_clock.h +++ b/module/clock/include/mod_clock.h @@ -45,12 +45,18 @@ enum mod_clock_state { * \brief Clock notification indices. */ enum mod_clock_notification_idx { - /*! The running state of a clock changed */ + /*! The running state of a clock changed */ MOD_CLOCK_NOTIFICATION_IDX_STATE_CHANGED, - /*! The running state of a clock is about to change */ + /*! The running state of a clock is about to change */ MOD_CLOCK_NOTIFICATION_IDX_STATE_CHANGE_PENDING, + /*! The running rate of a clock changed */ + MOD_CLOCK_NOTIFICATION_IDX_RATE_CHANGED, + + /*! The rate of a clock has been requested to change */ + MOD_CLOCK_NOTIFICATION_IDX_RATE_CHANGE_REQUESTED, + /*! Number of defined notifications */ MOD_CLOCK_NOTIFICATION_IDX_COUNT }; @@ -75,6 +81,26 @@ static const fwk_id_t mod_clock_notification_id_state_change_pending = MOD_CLOCK_NOTIFICATION_IDX_STATE_CHANGE_PENDING); #endif +#ifdef BUILD_HAS_NOTIFICATION +/*! + * \brief Identifier for the ::MOD_CLOCK_NOTIFICATION_IDX_RATE_CHANGED + * notification. + */ +static const fwk_id_t mod_clock_notification_id_rate_changed = + FWK_ID_NOTIFICATION_INIT( + FWK_MODULE_IDX_CLOCK, + MOD_CLOCK_NOTIFICATION_IDX_RATE_CHANGED); + +/*! + * \brief Identifier for the ::MOD_CLOCK_NOTIFICATION_IDX_RATE_CHANGE_REQUESTED + * notification. + */ +static const fwk_id_t mod_clock_notification_id_rate_change_requested = + FWK_ID_NOTIFICATION_INIT( + FWK_MODULE_IDX_CLOCK, + MOD_CLOCK_NOTIFICATION_IDX_RATE_CHANGE_REQUESTED); +#endif + /*! * \brief Event parameters shared by the * ::MOD_CLOCK_NOTIFICATION_IDX_STATE_CHANGED and @@ -445,6 +471,8 @@ struct mod_clock_api { * \param round_mode The type of rounding to perform, if required, to * achieve the given rate. * + * \param requester_id The entity which requested the operation. + * * \retval ::FWK_SUCCESS The operation succeeded. * \retval ::FWK_PENDING The request is pending. The result for this * operation will be provided via a response event. @@ -453,8 +481,11 @@ struct mod_clock_api { * supported. * \return One of the standard framework error codes. */ - int (*set_rate)(fwk_id_t clock_id, uint64_t rate, - enum mod_clock_round_mode round_mode); + int (*set_rate)( + fwk_id_t clock_id, + uint64_t rate, + enum mod_clock_round_mode round_mode, + unsigned int requester_id); /*! * \brief Get the current rate of a clock in Hertz (Hz). @@ -595,6 +626,17 @@ struct mod_clock_resp_params { union mod_clock_resp_values value; }; +struct mod_clock_notification_params { + /*! ID of the entity who requested the operation */ + unsigned int requester_id; + + /*! Clock ID on which the operation is requested */ + fwk_id_t clock_id; + + /*! The clock rate in Hertz */ + uint64_t rate; +}; + /*! * \brief Define the event identifiers for deferred responses. */ diff --git a/module/clock/src/clock.h b/module/clock/src/clock.h index 100189b52..a2a26354a 100644 --- a/module/clock/src/clock.h +++ b/module/clock/src/clock.h @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2019-2023, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2019-2024, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ @@ -42,6 +42,11 @@ struct clock_dev_ctx { /* Cookie for the response event */ uint32_t cookie; + +#ifdef BUILD_HAS_NOTIFICATION + /*! ID of the entity who requested the operation */ + unsigned int requester_id; +#endif /* BUILD_HAS_NOTIFICATION */ } request; #ifdef BUILD_HAS_CLOCK_TREE_MGMT diff --git a/module/clock/src/mod_clock.c b/module/clock/src/mod_clock.c index bba7e1830..c829c34fc 100644 --- a/module/clock/src/mod_clock.c +++ b/module/clock/src/mod_clock.c @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2017-2023, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2017-2024, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ @@ -15,6 +15,7 @@ #include #include #include +#include #include #include #include @@ -31,11 +32,43 @@ static struct clock_ctx mod_clock_ctx; * Utility functions */ +#ifdef BUILD_HAS_NOTIFICATION +static void notify_rate( + unsigned int requester_id, + fwk_id_t clock_dev_id, + uint64_t rate, + fwk_id_t notification_id) +{ + int status; + unsigned int notification_count; + struct fwk_event notification_event = { + .source_id = FWK_ID_MODULE(FWK_MODULE_IDX_CLOCK), + .id = notification_id, + }; + + struct mod_clock_notification_params *params = + (struct mod_clock_notification_params *)notification_event.params; + + params->requester_id = requester_id; + params->clock_id = clock_dev_id; + params->rate = rate; + + status = fwk_notification_notify(¬ification_event, ¬ification_count); + if (status != FWK_SUCCESS) { + FWK_LOG_DEBUG("[CLOCK] %s @%d", __func__, __LINE__); + } +} +#endif + static int process_response_event(const struct fwk_event *event) { int status; struct fwk_event resp_event; struct clock_dev_ctx *ctx; +#ifdef BUILD_HAS_NOTIFICATION + unsigned int requester_id; +#endif + struct mod_clock_driver_resp_params *event_params = (struct mod_clock_driver_resp_params *)event->params; struct mod_clock_resp_params *resp_params = @@ -54,6 +87,21 @@ static int process_response_event(const struct fwk_event *event) resp_params->value = event_params->value; ctx->request.is_ongoing = false; +#ifdef BUILD_HAS_NOTIFICATION + requester_id = ctx->request.requester_id; + ctx->request.requester_id = 0; + + if (fwk_id_is_equal(resp_event.id, mod_clock_event_id_set_rate_request)) { + if (resp_params->status == FWK_SUCCESS) { + notify_rate( + requester_id, + resp_event.source_id, + resp_params->value.rate, + mod_clock_notification_id_rate_changed); + } + } +#endif + return fwk_put_event(&resp_event); } @@ -99,6 +147,38 @@ static int create_async_request( return FWK_PENDING; } +static int create_async_request_set_rate( + struct clock_dev_ctx *ctx, + fwk_id_t clock_id, + unsigned int requester_id) +{ + int status; + struct fwk_event request_event; + + request_event = (struct fwk_event){ + .target_id = clock_id, + .id = mod_clock_event_id_set_rate_request, + .response_requested = true, + }; + +#ifdef BUILD_HAS_NOTIFICATION + ctx->request.requester_id = requester_id; +#endif + + status = fwk_put_event(&request_event); + if (status != FWK_SUCCESS) { + return status; + } + + ctx->request.is_ongoing = true; + + /* + * Signal the result of the request is pending and will arrive later + * through an event. + */ + return FWK_PENDING; +} + void clock_get_ctx(fwk_id_t clock_id, struct clock_dev_ctx **ctx) { fwk_assert(fwk_module_is_valid_element_id(clock_id)); @@ -149,11 +229,17 @@ static struct mod_clock_driver_response_api clock_driver_response_api = { * Module API functions */ -static int clock_set_rate(fwk_id_t clock_id, uint64_t rate, - enum mod_clock_round_mode round_mode) +static int clock_set_rate( + fwk_id_t clock_id, + uint64_t rate, + enum mod_clock_round_mode round_mode, + unsigned int requester_id) { - int status; + int status = FWK_SUCCESS; struct clock_dev_ctx *ctx; +#ifdef BUILD_HAS_NOTIFICATION + uint64_t actual_rate; +#endif #ifdef BUILD_HAS_CLOCK_TREE_MGMT struct fwk_event event; @@ -171,8 +257,7 @@ static int clock_set_rate(fwk_id_t clock_id, uint64_t rate, status = ctx->api->set_rate(ctx->config->driver_id, rate, round_mode); if (status == FWK_PENDING) { - return create_async_request( - ctx, clock_id, mod_clock_event_id_set_rate_request); + return create_async_request_set_rate(ctx, clock_id, requester_id); } if (clock_is_single_node(ctx)) { return status; @@ -187,15 +272,46 @@ static int clock_set_rate(fwk_id_t clock_id, uint64_t rate, return fwk_put_event(&event); #else +# ifdef BUILD_HAS_NOTIFICATION + notify_rate( + requester_id, + clock_id, + rate, + mod_clock_notification_id_rate_change_requested); + if (status != FWK_SUCCESS) { + return status; + } +# endif status = ctx->api->set_rate(ctx->config->driver_id, rate, round_mode); +# ifdef BUILD_HAS_NOTIFICATION + if (status == FWK_SUCCESS) { + /* Now that we have set the rate, try to get the actual rate */ + status = ctx->api->get_rate(ctx->config->driver_id, &actual_rate); + if (status == FWK_SUCCESS) { + notify_rate( + requester_id, + clock_id, + actual_rate, + mod_clock_notification_id_rate_changed); + } + /* Try to get the rate through an event. + * This event id is set as a set rate event because getting the clock + * rate here is actually part of a set rate event. + */ + else if (status == FWK_PENDING) { + status = create_async_request_set_rate(ctx, clock_id, requester_id); + if (status != FWK_SUCCESS || status != FWK_PENDING) { + FWK_LOG_DEBUG("[CLOCK] %s @%d", __func__, __LINE__); + } + } + return FWK_SUCCESS; + } +# endif /* BUILD_HAS_NOTIFICATION */ if (status == FWK_PENDING) { - return create_async_request( - ctx, - clock_id, - mod_clock_event_id_set_rate_request); + return create_async_request_set_rate(ctx, clock_id, requester_id); } return status; -#endif +#endif /* BUILD_HAS_CLOCK_TREE_MGMT */ } static int clock_get_rate(fwk_id_t clock_id, uint64_t *rate) diff --git a/module/dvfs/src/mod_dvfs.c b/module/dvfs/src/mod_dvfs.c index 4ae525c31..e312b4bb2 100644 --- a/module/dvfs/src/mod_dvfs.c +++ b/module/dvfs/src/mod_dvfs.c @@ -757,7 +757,8 @@ static int dvfs_handle_set_opp( status = ctx->apis.clock->set_rate( ctx->config->clock_id, (uint64_t)ctx->request.new_opp.frequency * FWK_KHZ, - MOD_CLOCK_ROUND_MODE_NONE); + MOD_CLOCK_ROUND_MODE_NONE, + 0); if (status == FWK_PENDING) { ctx->state = DVFS_DOMAIN_SET_OPP_DONE; @@ -770,7 +771,8 @@ static int dvfs_handle_set_opp( status = ctx->apis.clock->set_rate( ctx->config->clock_id, (uint64_t)ctx->request.new_opp.frequency * FWK_KHZ, - MOD_CLOCK_ROUND_MODE_NONE); + MOD_CLOCK_ROUND_MODE_NONE, + 0); if (status == FWK_PENDING) { ctx->state = DVFS_DOMAIN_SET_VOLTAGE; @@ -800,7 +802,8 @@ static int dvfs_handle_set_opp( status = ctx->apis.clock->set_rate( ctx->config->clock_id, (uint64_t)ctx->request.new_opp.frequency * FWK_KHZ, - MOD_CLOCK_ROUND_MODE_NONE); + MOD_CLOCK_ROUND_MODE_NONE, + 0); if (status == FWK_PENDING) { ctx->state = DVFS_DOMAIN_SET_OPP_DONE; @@ -882,7 +885,8 @@ static int dvfs_handle_psu_set_voltage_resp( status = ctx->apis.clock->set_rate( ctx->config->clock_id, (uint64_t)ctx->request.new_opp.frequency * FWK_KHZ, - MOD_CLOCK_ROUND_MODE_NONE); + MOD_CLOCK_ROUND_MODE_NONE, + 0); if (status == FWK_PENDING) { ctx->state = DVFS_DOMAIN_SET_OPP_DONE; return status; diff --git a/module/resource_perms/include/mod_resource_perms.h b/module/resource_perms/include/mod_resource_perms.h index 0c83fe8a3..cd49c7bd9 100644 --- a/module/resource_perms/include/mod_resource_perms.h +++ b/module/resource_perms/include/mod_resource_perms.h @@ -191,6 +191,11 @@ enum mod_res_clock_permissions_idx { MOD_SCMI_CLOCK_CONFIG_SET - MOD_RES_PERMS_CLOCK_PERMS_OFFSET, MOD_RES_PERMS_SCMI_CLOCK_NAME_GET_IDX = MOD_SCMI_CLOCK_NAME_GET - MOD_RES_PERMS_CLOCK_PERMS_OFFSET, + MOD_RES_PERMS_SCMI_CLOCK_RATE_NOTIFY_IDX = + MOD_SCMI_CLOCK_RATE_NOTIFY - MOD_RES_PERMS_CLOCK_PERMS_OFFSET, + MOD_RES_PERMS_SCMI_CLOCK_RATE_CHANGE_REQUESTED_NOTIFY_IDX = + MOD_SCMI_CLOCK_RATE_CHANGE_REQUESTED_NOTIFY - + MOD_RES_PERMS_CLOCK_PERMS_OFFSET, }; /*! diff --git a/module/scmi/include/mod_scmi_std.h b/module/scmi/include/mod_scmi_std.h index 5ca4f41c9..88448c6fc 100644 --- a/module/scmi/include/mod_scmi_std.h +++ b/module/scmi/include/mod_scmi_std.h @@ -167,6 +167,8 @@ enum scmi_clock_command_id { MOD_SCMI_CLOCK_RATE_GET = 0x006, MOD_SCMI_CLOCK_CONFIG_SET = 0x007, MOD_SCMI_CLOCK_NAME_GET = 0x008, + MOD_SCMI_CLOCK_RATE_NOTIFY = 0x009, + MOD_SCMI_CLOCK_RATE_CHANGE_REQUESTED_NOTIFY = 0x00A, MOD_SCMI_CLOCK_COMMAND_COUNT, }; diff --git a/module/scmi_clock/include/internal/scmi_clock.h b/module/scmi_clock/include/internal/scmi_clock.h index 77dc542ff..93128cf4b 100644 --- a/module/scmi_clock/include/internal/scmi_clock.h +++ b/module/scmi_clock/include/internal/scmi_clock.h @@ -104,7 +104,9 @@ struct scmi_clock_generic_p2a { */ #define SCMI_CLOCK_ATTRIBUTES_ENABLED_POS 0 -#define SCMI_CLOCK_ATTRIBUTES_EXTENDED_CLOCK_NAME_POS 29 +#define SCMI_CLOCK_ATTRIBUTES_EXTENDED_CLOCK_NAME_POS 29 +#define SUPPORT_RATE_CHANGE_REQUESTED_NOTIFICATION_POS 30 +#define SUPPORT_RATE_CHANGED_NOTIFICATION_POS 31 #define SCMI_CLOCK_ATTRIBUTES_ENABLED_MASK \ (UINT32_C(0x1) << SCMI_CLOCK_ATTRIBUTES_ENABLED_POS) @@ -112,11 +114,27 @@ struct scmi_clock_generic_p2a { #define SCMI_CLOCK_ATTRIBUTES_EXTENDED_CLOCK_NAME_MASK \ (UINT32_C(0x1) << SCMI_CLOCK_ATTRIBUTES_EXTENDED_CLOCK_NAME_POS) -#define SCMI_CLOCK_ATTRIBUTES(ENABLED, EXTENDED_CLOCK) \ +#define SUPPORT_RATE_CHANGE_REQUESTED_NOTIFICATION_MASK \ + (UINT32_C(0x1) << SUPPORT_RATE_CHANGE_REQUESTED_NOTIFICATION_POS) + +#define SUPPORT_RATE_CHANGED_NOTIFICATION_MASK \ + (UINT32_C(0x1) << SUPPORT_RATE_CHANGED_NOTIFICATION_POS) + +#define SET_SCMI_CLOCK_ATTRIBUTES( \ + ENABLED, \ + EXTENDED_CLOCK, \ + SUPPORT_RATE_CHANGE_REQUESTED_NOTIFICATION, \ + SUPPORT_RATE_CHANGED_NOTIFICATION) \ ((((ENABLED) << SCMI_CLOCK_ATTRIBUTES_ENABLED_POS) & \ SCMI_CLOCK_ATTRIBUTES_ENABLED_MASK) | \ (((EXTENDED_CLOCK) << SCMI_CLOCK_ATTRIBUTES_EXTENDED_CLOCK_NAME_POS) & \ - SCMI_CLOCK_ATTRIBUTES_EXTENDED_CLOCK_NAME_MASK)) + SCMI_CLOCK_ATTRIBUTES_EXTENDED_CLOCK_NAME_MASK) | \ + (((SUPPORT_RATE_CHANGE_REQUESTED_NOTIFICATION) \ + << SUPPORT_RATE_CHANGE_REQUESTED_NOTIFICATION_POS) & \ + SUPPORT_RATE_CHANGE_REQUESTED_NOTIFICATION_MASK) | \ + (((SUPPORT_RATE_CHANGED_NOTIFICATION) \ + << SUPPORT_RATE_CHANGED_NOTIFICATION_POS) & \ + SUPPORT_RATE_CHANGED_NOTIFICATION_MASK)) struct scmi_clock_attributes_a2p { uint32_t clock_id; @@ -129,6 +147,7 @@ struct scmi_clock_attributes_p2a { int32_t status; uint32_t attributes; char clock_name[SCMI_CLOCK_NAME_LENGTH]; + uint32_t clock_enable_delay; }; /* @@ -261,4 +280,27 @@ struct scmi_clock_name_get_p2a { char clock_extended_name[SCMI_CLOCK_EXTENDED_NAME_LENGTH]; }; +/* + * Generic Data Structur for + * CLOCK_RATE_NOTIFY + * CLOCK_RATE_CHANGE_REQUESTED_NOTIFY + */ + +#define SCMI_CLOCK_RATE_NOTIFY_ENABLE_MASK UINT32_C(0x1) + +struct scmi_clock_rate_notify_a2p { + uint32_t clock_id; + uint32_t notify_enable; +}; + +struct scmi_clock_rate_notify_p2a { + int32_t status; +}; + +struct scmi_clock_rate_notification_message_p2a { + uint32_t agent_id; + uint32_t clock_id; + uint32_t rate[2]; +}; + #endif /* INTERNAL_SCMI_CLOCK_H */ diff --git a/module/scmi_clock/include/mod_scmi_clock.h b/module/scmi_clock/include/mod_scmi_clock.h index 9a75031e2..0df2e458d 100644 --- a/module/scmi_clock/include/mod_scmi_clock.h +++ b/module/scmi_clock/include/mod_scmi_clock.h @@ -83,6 +83,25 @@ struct mod_scmi_clock_device { * \brief Flag indicating whether extended clock name is supported */ bool supports_extended_name; + +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + /*! + * \brief Flag indicating support for clock rate change notification + * + * \details Set means this clock supports clock rate change notification, + * 0 means otherwise. + */ + bool notify_changed_rate; + + /*! + * \brief Flag indicating support for clock rate change requested + * notification + * + * \details Set means this clock supports clock rate change requested + * notification, 0 means otherwise. + */ + bool notify_requested_rate; +#endif /* BUILD_HAS_SCMI_NOTIFICATIONS */ }; /*! @@ -170,6 +189,14 @@ enum mod_scmi_clock_policy_commit { MOD_SCMI_CLOCK_POST_MESSAGE_HANDLER, }; +/*! + * \brief SCMI Clock Protocol Notifications message ids. + */ +enum scmi_clock_notification_id { + SCMI_CLOCK_RATE_CHANGED = 0x000, + SCMI_CLOCK_RATE_CHANGE_REQUESTED = 0x001, +}; + /*! * \brief SCMI Clock Set Rate command policy. * diff --git a/module/scmi_clock/src/mod_scmi_clock.c b/module/scmi_clock/src/mod_scmi_clock.c index 2cfce88cd..21f6603c5 100644 --- a/module/scmi_clock/src/mod_scmi_clock.c +++ b/module/scmi_clock/src/mod_scmi_clock.c @@ -24,6 +24,7 @@ #include #include #include +#include #include #include @@ -33,6 +34,8 @@ # include #endif +#define MOD_SCMI_CLOCK_NOTIFICATION_COUNT 2 + struct clock_operations { /* * Service identifier currently requesting operation from this clock. @@ -91,6 +94,12 @@ struct mod_scmi_clock_ctx { /* SCMI Resource Permissions API */ const struct mod_res_permissions_api *res_perms_api; #endif + +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + + /* SCMI notification API */ + const struct mod_scmi_notification_api *scmi_notification_api; +#endif }; static const fwk_id_t mod_scmi_clock_event_id_clock_attributes = @@ -135,6 +144,18 @@ static int scmi_clock_describe_rates_handler(fwk_id_t service_id, static int scmi_clock_name_get_handler( fwk_id_t service_id, const uint32_t *payload); +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS +static int scmi_clock_rate_notify_handler( + enum scmi_clock_command_id command_id, + fwk_id_t service_id, + const uint32_t *payload); +static int scmi_clock_rate_changed_notify_handler( + fwk_id_t service_id, + const uint32_t *payload); +static int scmi_clock_rate_change_requested_notify_handler( + fwk_id_t service_id, + const uint32_t *payload); +#endif /* * Internal variables. @@ -152,6 +173,11 @@ static handler_table_t handler_table[MOD_SCMI_CLOCK_COMMAND_COUNT] = { [MOD_SCMI_CLOCK_CONFIG_SET] = scmi_clock_config_set_handler, [MOD_SCMI_CLOCK_DESCRIBE_RATES] = scmi_clock_describe_rates_handler, [MOD_SCMI_CLOCK_NAME_GET] = scmi_clock_name_get_handler, +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + [MOD_SCMI_CLOCK_RATE_NOTIFY] = scmi_clock_rate_changed_notify_handler, + [MOD_SCMI_CLOCK_RATE_CHANGE_REQUESTED_NOTIFY] = + scmi_clock_rate_change_requested_notify_handler, +#endif }; static const size_t payload_size_table[MOD_SCMI_CLOCK_COMMAND_COUNT] = { @@ -171,6 +197,12 @@ static const size_t payload_size_table[MOD_SCMI_CLOCK_COMMAND_COUNT] = { (unsigned int)sizeof(struct scmi_clock_describe_rates_a2p), [MOD_SCMI_CLOCK_NAME_GET] = (unsigned int)sizeof(struct scmi_clock_name_get_a2p), +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + [MOD_SCMI_CLOCK_RATE_NOTIFY] = + (unsigned int)sizeof(struct scmi_clock_rate_notify_a2p), + [MOD_SCMI_CLOCK_RATE_CHANGE_REQUESTED_NOTIFY] = + (unsigned int)sizeof(struct scmi_clock_rate_notify_a2p), +#endif }; /* @@ -517,6 +549,8 @@ static void clock_attributes_respond( size_t response_size; const struct mod_scmi_clock_agent *agent; struct scmi_clock_attributes_p2a return_values = { 0 }; + bool supports_rate_changed_notification = false; + bool supports_rate_change_requested_notification = false; if (status == FWK_SUCCESS) { clock_dev_idx = fwk_id_get_element_idx(clock_dev_id); @@ -527,11 +561,19 @@ static void clock_attributes_respond( agent = &scmi_clock_ctx.agent_table[agent_id]; has_extended_name = agent->device_table[clock_dev_idx].supports_extended_name; +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + supports_rate_change_requested_notification = + agent->device_table[clock_dev_idx].notify_requested_rate; + supports_rate_changed_notification = + agent->device_table[clock_dev_idx].notify_changed_rate; +#endif } - return_values.attributes = SCMI_CLOCK_ATTRIBUTES( + return_values.attributes = SET_SCMI_CLOCK_ATTRIBUTES( ((uint32_t)(*clock_state == MOD_CLOCK_STATE_RUNNING)), - ((uint32_t)has_extended_name)); + ((uint32_t)has_extended_name), + ((uint32_t)supports_rate_change_requested_notification), + ((uint32_t)supports_rate_changed_notification)); fwk_str_strncpy( return_values.clock_name, @@ -539,6 +581,7 @@ static void clock_attributes_respond( sizeof(return_values.clock_name) - 1); return_values.status = (int32_t)SCMI_SUCCESS; + return_values.clock_enable_delay = 0; /* Unsupported */ response_size = sizeof(return_values); } else { return_values.status = (int32_t)SCMI_GENERIC_ERROR; @@ -1520,6 +1563,104 @@ exit: return status; } +/* + * Clock Rate Notify + */ +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS +static int scmi_clock_rate_notify_handler( + enum scmi_clock_command_id command_id, + fwk_id_t service_id, + const uint32_t *payload) +{ + int status, respond_status; + unsigned int agent_id; + const struct mod_scmi_clock_device *clock_device; + const struct scmi_clock_rate_notify_a2p *parameters; + struct scmi_clock_rate_notify_p2a return_values = { + .status = (int32_t)SCMI_GENERIC_ERROR + }; + + parameters = (const struct scmi_clock_rate_notify_a2p *)payload; + + status = scmi_clock_get_clock_device_entry( + service_id, parameters->clock_id, &clock_device); + if (status != FWK_SUCCESS) { + return_values.status = (int32_t)SCMI_NOT_FOUND; + goto exit; + } + + if ((parameters->notify_enable & ~SCMI_CLOCK_RATE_NOTIFY_ENABLE_MASK) != + 0x0) { + status = FWK_SUCCESS; + return_values.status = (int32_t)SCMI_INVALID_PARAMETERS; + goto exit; + } + +# ifdef BUILD_HAS_MOD_RESOURCE_PERMS + status = scmi_clock_permissions_handler( + parameters->clock_id, service_id, (unsigned int)command_id); + if (status != FWK_SUCCESS) { + return_values.status = (int32_t)SCMI_DENIED; + goto exit; + } +# endif + + status = scmi_clock_ctx.scmi_api->get_agent_id(service_id, &agent_id); + if (status != FWK_SUCCESS) { + return status; + } + + if (parameters->notify_enable) { + status = scmi_clock_ctx.scmi_notification_api + ->scmi_notification_add_subscriber( + MOD_SCMI_PROTOCOL_ID_CLOCK, + parameters->clock_id, + command_id, + service_id); + } else { + status = scmi_clock_ctx.scmi_notification_api + ->scmi_notification_remove_subscriber( + MOD_SCMI_PROTOCOL_ID_CLOCK, + agent_id, + parameters->clock_id, + command_id); + } + if (status != FWK_SUCCESS) { + goto exit; + } + + return_values.status = (int32_t)SCMI_SUCCESS; + +exit: + respond_status = scmi_clock_ctx.scmi_api->respond( + service_id, + &return_values, + (return_values.status == SCMI_SUCCESS) ? sizeof(return_values) : + sizeof(return_values.status)); + if (respond_status != FWK_SUCCESS) { + FWK_LOG_DEBUG("[SCMI-CLK] %s @%d", __func__, __LINE__); + } + + return status; +}; + +static int scmi_clock_rate_changed_notify_handler( + fwk_id_t service_id, + const uint32_t *payload) +{ + return scmi_clock_rate_notify_handler( + MOD_SCMI_CLOCK_RATE_NOTIFY, service_id, payload); +} + +static int scmi_clock_rate_change_requested_notify_handler( + fwk_id_t service_id, + const uint32_t *payload) +{ + return scmi_clock_rate_notify_handler( + MOD_SCMI_CLOCK_RATE_CHANGE_REQUESTED_NOTIFY, service_id, payload); +}; +#endif + /* * SCMI module -> SCMI clock module interface */ @@ -1606,6 +1747,58 @@ static int scmi_clock_init(fwk_id_t module_id, unsigned int element_count, return FWK_SUCCESS; } +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS +static int scmi_init_notifications(unsigned int clock_devices) +{ + int status; + + status = scmi_clock_ctx.scmi_api->get_agent_count( + (unsigned int *)&scmi_clock_ctx.config->agent_count); + if (status != FWK_SUCCESS) { + return status; + } + fwk_assert(scmi_clock_ctx.config->agent_count != 0u); + + status = scmi_clock_ctx.scmi_notification_api->scmi_notification_init( + MOD_SCMI_PROTOCOL_ID_CLOCK, + scmi_clock_ctx.config->agent_count, + clock_devices, + MOD_SCMI_CLOCK_NOTIFICATION_COUNT); + + if (status != FWK_SUCCESS) { + return status; + } + + return FWK_SUCCESS; +} +#endif + +static int scmi_clock_start(fwk_id_t id) +{ + int status = FWK_SUCCESS; +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + status = fwk_notification_subscribe( + mod_clock_notification_id_rate_changed, + FWK_ID_MODULE(FWK_MODULE_IDX_CLOCK), + id); + if (status != FWK_SUCCESS) { + return status; + } + + status = fwk_notification_subscribe( + mod_clock_notification_id_rate_change_requested, + FWK_ID_MODULE(FWK_MODULE_IDX_CLOCK), + id); + if (status != FWK_SUCCESS) { + return status; + } + + status = + scmi_init_notifications((unsigned int)scmi_clock_ctx.clock_devices); +#endif + return status; +} + static int scmi_clock_bind(fwk_id_t id, unsigned int round) { int status; @@ -1631,6 +1824,16 @@ static int scmi_clock_bind(fwk_id_t id, unsigned int round) } #endif +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + status = fwk_module_bind( + FWK_ID_MODULE(FWK_MODULE_IDX_SCMI), + FWK_ID_API(FWK_MODULE_IDX_SCMI, MOD_SCMI_API_IDX_NOTIFICATION), + &scmi_clock_ctx.scmi_notification_api); + if (status != FWK_SUCCESS) { + return status; + } +#endif + return fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_CLOCK), FWK_ID_API(FWK_MODULE_IDX_CLOCK, 0), &scmi_clock_ctx.clock_api); } @@ -1697,10 +1900,8 @@ static int process_request_event(const struct fwk_event *event) rate = (uint64_t)set_rate_data.rate[0] + (((uint64_t)set_rate_data.rate[1]) << 32); - status = - scmi_clock_ctx.clock_api->set_rate(params->clock_dev_id, - rate, - set_rate_data.round_mode); + status = scmi_clock_ctx.clock_api->set_rate( + params->clock_dev_id, rate, set_rate_data.round_mode, agent_id); if (status != FWK_PENDING) { /* Request completed */ set_request_respond(service_id, status); @@ -1816,13 +2017,114 @@ static int scmi_clock_process_event(const struct fwk_event *event, return FWK_E_PARAM; } +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + +static int find_agent_scmi_clock_idx( + unsigned int agent_id, + fwk_id_t clock_id, + unsigned int *clock_scmi_idx) +{ + unsigned int clock_dev_idx; + const struct mod_scmi_clock_agent *agent; + + clock_dev_idx = fwk_id_get_element_idx(clock_id); + agent = &scmi_clock_ctx.agent_table[agent_id]; + + /* Find the scmi clock index for the agent. */ + for (unsigned int idx = 0; idx < (unsigned int)agent->device_count; idx++) { + if (fwk_id_get_element_idx(agent->device_table[idx].element_id) == + clock_dev_idx) { + *clock_scmi_idx = idx; + return FWK_SUCCESS; + } + } + return FWK_E_DATA; +} + +static void scmi_clock_rate_change_notify( + enum scmi_clock_command_id command_id, + enum scmi_clock_notification_id notification_message_id, + unsigned int agent_id, + unsigned int scmi_clock_idx, + uint64_t clock_rate) +{ + int status; + + struct scmi_clock_rate_notification_message_p2a message; + + message.agent_id = agent_id; + message.clock_id = scmi_clock_idx; + message.rate[0] = (uint32_t)clock_rate; + message.rate[1] = (uint32_t)(clock_rate >> 32); + + status = scmi_clock_ctx.scmi_notification_api->scmi_notification_notify( + MOD_SCMI_PROTOCOL_ID_CLOCK, + command_id, + notification_message_id, + &message, + sizeof(message)); + if (status != FWK_SUCCESS) { + FWK_LOG_DEBUG("[SCMI-clk] %s @%d", __func__, __LINE__); + } +} + +static int scmi_clock_process_notification( + const struct fwk_event *notification_event, + struct fwk_event *resp_event) +{ + int status; + unsigned int notification_idx, agent_id, scmi_clock_idx; + enum scmi_clock_command_id command_id; + enum scmi_clock_notification_id message_id; + struct mod_clock_notification_params *notification_params = + ((struct mod_clock_notification_params *)notification_event->params); + + agent_id = notification_params->requester_id; + notification_idx = fwk_id_get_notification_idx(notification_event->id); + + switch (notification_idx) { + case (unsigned int)MOD_CLOCK_NOTIFICATION_IDX_RATE_CHANGED: + command_id = MOD_SCMI_CLOCK_RATE_NOTIFY; + message_id = SCMI_CLOCK_RATE_CHANGED; + break; + + case (unsigned int)MOD_CLOCK_NOTIFICATION_IDX_RATE_CHANGE_REQUESTED: + command_id = MOD_SCMI_CLOCK_RATE_CHANGE_REQUESTED_NOTIFY; + message_id = SCMI_CLOCK_RATE_CHANGE_REQUESTED; + break; + + default: + return FWK_E_PARAM; + } + + status = find_agent_scmi_clock_idx( + agent_id, notification_params->clock_id, &scmi_clock_idx); + if (status != FWK_SUCCESS) { + return status; + } + + scmi_clock_rate_change_notify( + command_id, + message_id, + agent_id, + scmi_clock_idx, + notification_params->rate); + + return FWK_SUCCESS; +} +#endif + /* SCMI Clock Management Protocol Definition */ const struct fwk_module module_scmi_clock = { .api_count = 1, .event_count = (unsigned int)SCMI_CLOCK_EVENT_IDX_COUNT, .type = FWK_MODULE_TYPE_PROTOCOL, .init = scmi_clock_init, + .start = scmi_clock_start, .bind = scmi_clock_bind, .process_bind_request = scmi_clock_process_bind_request, .process_event = scmi_clock_process_event, +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + .process_notification = scmi_clock_process_notification, +#endif }; -- GitLab From 6257447f392ad0c2d6e153a7c195c4954451e26f Mon Sep 17 00:00:00 2001 From: Md Golam Tanvir Zim Date: Wed, 12 Jun 2024 12:46:25 +0100 Subject: [PATCH 05/16] scmi_clock: Add Unit Test for PROTOCOL_VERSION command This patch implements a unit test case for PROTOCOL_VERSION command. Signed-off-by: Md Golam Tanvir Zim Change-Id: Id977938b73e8000d4b2ba454e7d0befb8addd33a --- .../test/mod_scmi_clock_unit_test.c | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/module/scmi_clock/test/mod_scmi_clock_unit_test.c b/module/scmi_clock/test/mod_scmi_clock_unit_test.c index 8cb9ef3d5..47930c26d 100644 --- a/module/scmi_clock/test/mod_scmi_clock_unit_test.c +++ b/module/scmi_clock/test/mod_scmi_clock_unit_test.c @@ -813,6 +813,43 @@ void test_mod_scmi_clock_attributes_handler_get_state(void) TEST_ASSERT_EQUAL(FWK_SUCCESS, status); } +int version_handler_respond_callback( + fwk_id_t service_id, + const void *payload, + size_t size, + int NumCalls) +{ + struct scmi_protocol_version_p2a *return_values; + return_values = (struct scmi_protocol_version_p2a *)payload; + + TEST_ASSERT_EQUAL((int32_t)SCMI_SUCCESS, return_values->status); + TEST_ASSERT_EQUAL(SCMI_PROTOCOL_VERSION_CLOCK, return_values->version); + + return FWK_SUCCESS; +} + +void test_mod_scmi_clock_protocol_version_handler(void) +{ + int status; + fwk_id_t service_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_IDX, FAKE_SCMI_AGENT_IDX_PSCI); + + uint32_t payload = 0; + + mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( + SCMI_SUCCESS); + mod_scmi_from_protocol_api_respond_Stub(version_handler_respond_callback); + + status = scmi_clock_message_handler( + (fwk_id_t)MOD_SCMI_PROTOCOL_ID_CLOCK, + service_id, + (const uint32_t *)&payload, + payload_size_table[MOD_SCMI_PROTOCOL_VERSION], + MOD_SCMI_PROTOCOL_VERSION); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + int scmi_test_main(void) { UNITY_BEGIN(); @@ -843,6 +880,8 @@ int scmi_test_main(void) RUN_TEST(test_mod_scmi_clock_attributes_handler_invalid_clock_id); RUN_TEST(test_mod_scmi_clock_attributes_handler_get_state); + RUN_TEST(test_mod_scmi_clock_protocol_version_handler); + #endif return UNITY_END(); } -- GitLab From f5c749767eefc57fb4ed13eed30b0b288d35d94c Mon Sep 17 00:00:00 2001 From: Md Golam Tanvir Zim Date: Wed, 12 Jun 2024 14:55:09 +0100 Subject: [PATCH 06/16] scmi_clock: Add Unit Test for PROTOCOL_ATTRIBUTES A Unit test case is added for PROTOCOL_ATTRIBUTES command for scmi clock module. Signed-off-by: Md Golam Tanvir Zim Change-Id: I0d67c49dd484826d5cb6d6c540e2da5642bb214b --- .../test/mod_scmi_clock_unit_test.c | 90 +++++++++++++++++++ 1 file changed, 90 insertions(+) diff --git a/module/scmi_clock/test/mod_scmi_clock_unit_test.c b/module/scmi_clock/test/mod_scmi_clock_unit_test.c index 47930c26d..1195b5dc6 100644 --- a/module/scmi_clock/test/mod_scmi_clock_unit_test.c +++ b/module/scmi_clock/test/mod_scmi_clock_unit_test.c @@ -850,6 +850,93 @@ void test_mod_scmi_clock_protocol_version_handler(void) TEST_ASSERT_EQUAL(FWK_SUCCESS, status); } +int protocol_attributes_handler_respond_callback( + fwk_id_t service_id, + const void *payload, + size_t size, + int NumCalls) +{ + struct scmi_protocol_attributes_p2a *return_values; + return_values = (struct scmi_protocol_attributes_p2a *)payload; + + TEST_ASSERT_EQUAL((int32_t)SCMI_SUCCESS, return_values->status); + TEST_ASSERT_EQUAL( + SCMI_CLOCK_PROTOCOL_ATTRIBUTES(scmi_clock_ctx.max_pending_transactions, + scmi_clock_ctx.clock_devices), + return_values->attributes); + + return FWK_SUCCESS; +} + +void test_mod_scmi_clock_protocol_attributes_handler(void) +{ + int status; + uint32_t agent_id = FAKE_SCMI_AGENT_IDX_OSPM1; + fwk_id_t service_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_IDX, agent_id); + scmi_clock_ctx.clock_devices = SCMI_CLOCK_OSPM1_COUNT; + + uint32_t payload = 0; + + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( + SCMI_SUCCESS); + mod_scmi_from_protocol_api_respond_Stub( + protocol_attributes_handler_respond_callback); + + status = scmi_clock_message_handler( + (fwk_id_t)MOD_SCMI_PROTOCOL_ID_CLOCK, + service_id, + (const uint32_t *)&payload, + payload_size_table[MOD_SCMI_PROTOCOL_ATTRIBUTES], + MOD_SCMI_PROTOCOL_ATTRIBUTES); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +int protocol_attributes_handler_respond_callback_invalid_agent_id( + fwk_id_t service_id, + const void *payload, + size_t size, + int NumCalls) +{ + struct scmi_protocol_attributes_p2a *return_values; + return_values = (struct scmi_protocol_attributes_p2a *)payload; + + TEST_ASSERT_EQUAL((int32_t)SCMI_GENERIC_ERROR, return_values->status); + + return FWK_SUCCESS; +} + +void test_mod_scmi_clock_protocol_attributes_handler_invalid_agent_id(void) +{ + int status; + uint32_t agent_id = FAKE_SCMI_AGENT_IDX_COUNT; + fwk_id_t service_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_IDX, agent_id); + + uint32_t payload = 0; + + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( + SCMI_SUCCESS); + mod_scmi_from_protocol_api_respond_Stub( + protocol_attributes_handler_respond_callback_invalid_agent_id); + + status = scmi_clock_message_handler( + (fwk_id_t)MOD_SCMI_PROTOCOL_ID_CLOCK, + service_id, + (const uint32_t *)&payload, + payload_size_table[MOD_SCMI_PROTOCOL_ATTRIBUTES], + MOD_SCMI_PROTOCOL_ATTRIBUTES); + + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + int scmi_test_main(void) { UNITY_BEGIN(); @@ -881,6 +968,9 @@ int scmi_test_main(void) RUN_TEST(test_mod_scmi_clock_attributes_handler_get_state); RUN_TEST(test_mod_scmi_clock_protocol_version_handler); + RUN_TEST(test_mod_scmi_clock_protocol_attributes_handler); + RUN_TEST( + test_mod_scmi_clock_protocol_attributes_handler_invalid_agent_id); #endif return UNITY_END(); -- GitLab From 5225dcd341d27c0f696655bf48ecb5d833fe0fa2 Mon Sep 17 00:00:00 2001 From: Md Golam Tanvir Zim Date: Wed, 12 Jun 2024 17:08:35 +0100 Subject: [PATCH 07/16] scmi_clock: Add Unit Test for PROTOCOL_MESSAGE_ATTRIBUTES This adds two unit test cases to test PROTOCOL_MESSAGE_ATTRIBUTES command, for CLOCK_RATE_NOTIFY and CLOCK_RATE_CHANGE_REQUESTED_NOTIFY commands. Signed-off-by: Md Golam Tanvir Zim Change-Id: I7986dac37c1bbd2099199232586384e39e59fe8d --- module/scmi_clock/test/CMakeLists.txt | 33 +++++++++ .../test/mod_scmi_clock_unit_test.c | 68 +++++++++++++++++++ 2 files changed, 101 insertions(+) diff --git a/module/scmi_clock/test/CMakeLists.txt b/module/scmi_clock/test/CMakeLists.txt index 155bc9e5c..b43f43c8a 100644 --- a/module/scmi_clock/test/CMakeLists.txt +++ b/module/scmi_clock/test/CMakeLists.txt @@ -92,3 +92,36 @@ list(APPEND MOCK_REPLACEMENTS fwk_core) include(${SCP_ROOT}/unit_test/module_common.cmake) target_compile_definitions(${UNIT_TEST_TARGET} PUBLIC "BUILD_HAS_AGENT_LOGICAL_DOMAIN") + +# BUILD_HAS_SCMI_NOTIFICATION target + +set(TEST_SRC mod_scmi_clock) +set(TEST_FILE mod_scmi_clock) + +if(TEST_ON_TARGET) + set(TEST_MODULE scmi_clock) + set(MODULE_ROOT ${CMAKE_SOURCE_DIR}/module) +else() + set(UNIT_TEST_TARGET mod_${TEST_MODULE}_unit_test_notification) +endif() + +set(MODULE_SRC ${MODULE_ROOT}/${TEST_MODULE}/src) +set(MODULE_INC ${MODULE_ROOT}/${TEST_MODULE}/include) +list(APPEND OTHER_MODULE_INC ${MODULE_ROOT}/clock/include) +list(APPEND OTHER_MODULE_INC ${MODULE_ROOT}/scmi/include) +list(APPEND OTHER_MODULE_INC ${MODULE_ROOT}/resource_perms/include) +set(MODULE_UT_SRC ${CMAKE_CURRENT_LIST_DIR}) +set(MODULE_UT_INC ${CMAKE_CURRENT_LIST_DIR}) +set(MODULE_UT_MOCK_SRC ${CMAKE_CURRENT_LIST_DIR}/mocks) + +list(APPEND MOCK_REPLACEMENTS fwk_mm) +list(APPEND MOCK_REPLACEMENTS fwk_module) +list(APPEND MOCK_REPLACEMENTS fwk_id) +list(APPEND MOCK_REPLACEMENTS fwk_core) +list(APPEND MOCK_REPLACEMENTS fwk_notification) + +include(${SCP_ROOT}/unit_test/module_common.cmake) + +target_compile_definitions(${UNIT_TEST_TARGET} PUBLIC + "BUILD_HAS_SCMI_NOTIFICATIONS" + "BUILD_HAS_NOTIFICATION") diff --git a/module/scmi_clock/test/mod_scmi_clock_unit_test.c b/module/scmi_clock/test/mod_scmi_clock_unit_test.c index 1195b5dc6..5c90c270b 100644 --- a/module/scmi_clock/test/mod_scmi_clock_unit_test.c +++ b/module/scmi_clock/test/mod_scmi_clock_unit_test.c @@ -937,6 +937,70 @@ void test_mod_scmi_clock_protocol_attributes_handler_invalid_agent_id(void) TEST_ASSERT_EQUAL(FWK_E_PARAM, status); } +int protocol_message_attributes_handler_respond_callback_notify_rate( + fwk_id_t service_id, + const void *payload, + size_t size, + int NumCalls) +{ + struct scmi_protocol_message_attributes_p2a *return_values; + return_values = (struct scmi_protocol_message_attributes_p2a *)payload; + +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + TEST_ASSERT_EQUAL((int32_t)SCMI_SUCCESS, return_values->status); +#else + TEST_ASSERT_EQUAL((int32_t)SCMI_NOT_FOUND, return_values->status); +#endif + + return FWK_SUCCESS; +} + +void test_protocol_message_attributes_handler_notify_rate(void) +{ + int status; + fwk_id_t service_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_IDX, FAKE_SCMI_AGENT_IDX_OSPM1); + + uint32_t payload = MOD_SCMI_CLOCK_RATE_NOTIFY; + + mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( + SCMI_SUCCESS); + mod_scmi_from_protocol_api_respond_Stub( + protocol_message_attributes_handler_respond_callback_notify_rate); + + status = scmi_clock_message_handler( + (fwk_id_t)MOD_SCMI_PROTOCOL_ID_CLOCK, + service_id, + (const uint32_t *)&payload, + payload_size_table[MOD_SCMI_PROTOCOL_MESSAGE_ATTRIBUTES], + MOD_SCMI_PROTOCOL_MESSAGE_ATTRIBUTES); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void test_protocol_message_attributes_handler_notify_rate_requested(void) +{ + int status; + fwk_id_t service_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_IDX, FAKE_SCMI_AGENT_IDX_OSPM1); + + uint32_t payload = MOD_SCMI_CLOCK_RATE_CHANGE_REQUESTED_NOTIFY; + + mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( + SCMI_SUCCESS); + mod_scmi_from_protocol_api_respond_Stub( + protocol_message_attributes_handler_respond_callback_notify_rate); + + status = scmi_clock_message_handler( + (fwk_id_t)MOD_SCMI_PROTOCOL_ID_CLOCK, + service_id, + (const uint32_t *)&payload, + payload_size_table[MOD_SCMI_PROTOCOL_MESSAGE_ATTRIBUTES], + MOD_SCMI_PROTOCOL_MESSAGE_ATTRIBUTES); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + int scmi_test_main(void) { UNITY_BEGIN(); @@ -971,6 +1035,10 @@ int scmi_test_main(void) RUN_TEST(test_mod_scmi_clock_protocol_attributes_handler); RUN_TEST( test_mod_scmi_clock_protocol_attributes_handler_invalid_agent_id); + RUN_TEST( + test_protocol_message_attributes_handler_notify_rate); + RUN_TEST( + test_protocol_message_attributes_handler_notify_rate_requested); #endif return UNITY_END(); -- GitLab From b0584a60d1fedd68575837f642171bb99817dfae Mon Sep 17 00:00:00 2001 From: Md Golam Tanvir Zim Date: Fri, 14 Jun 2024 10:43:58 +0100 Subject: [PATCH 08/16] scmi_clock: Add Unit Test for CLOCK_ATTRIBUTES command This patch implements unit test for the CLOCK_ATTRIBUTES command using the get state event. Signed-off-by: Md Golam Tanvir Zim Change-Id: I2a4e2666bbea40c76ffe4d3dae2848d7bede53d5 --- module/scmi_clock/test/config_scmi_clock.h | 7 +- .../test/mocks/Mockmod_scmi_clock_extra.c | 204 ++++++++++++++++++ .../test/mocks/Mockmod_scmi_clock_extra.h | 22 ++ module/scmi_clock/test/mod_scmi_clock_extra.h | 20 ++ .../test/mod_scmi_clock_unit_test.c | 76 +++++++ 5 files changed, 328 insertions(+), 1 deletion(-) diff --git a/module/scmi_clock/test/config_scmi_clock.h b/module/scmi_clock/test/config_scmi_clock.h index 4235edad2..e12d3c14e 100644 --- a/module/scmi_clock/test/config_scmi_clock.h +++ b/module/scmi_clock/test/config_scmi_clock.h @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2015-2023, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2015-2024, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ @@ -65,6 +65,11 @@ static const struct mod_scmi_clock_device agent_device_table_ospm0 .element_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_CLOCK, CLOCK_DEV_IDX_FAKE1), .starts_enabled = true, + .supports_extended_name = true, +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + .notify_changed_rate = true, + .notify_requested_rate = true, +#endif }, [SCMI_CLOCK_OSPM0_IDX2] = { /* FAKE2 */ diff --git a/module/scmi_clock/test/mocks/Mockmod_scmi_clock_extra.c b/module/scmi_clock/test/mocks/Mockmod_scmi_clock_extra.c index ef24acc3b..3789023fb 100644 --- a/module/scmi_clock/test/mocks/Mockmod_scmi_clock_extra.c +++ b/module/scmi_clock/test/mocks/Mockmod_scmi_clock_extra.c @@ -8,11 +8,13 @@ static const char* CMockString_agent_count = "agent_count"; static const char* CMockString_agent_id = "agent_id"; static const char* CMockString_agent_type = "agent_type"; +static const char* CMockString_clock_id = "clock_id"; static const char* CMockString_command_count = "command_count"; static const char* CMockString_device_id = "device_id"; static const char* CMockString_flags = "flags"; static const char* CMockString_handler_table = "handler_table"; static const char* CMockString_message_id = "message_id"; +static const char* CMockString_mod_clock_api_get_state = "mod_clock_api_get_state"; static const char* CMockString_mod_res_permissions_api_agent_has_message_permission = "mod_res_permissions_api_agent_has_message_permission"; static const char* CMockString_mod_res_permissions_api_agent_has_protocol_permission = "mod_res_permissions_api_agent_has_protocol_permission"; static const char* CMockString_mod_res_permissions_api_agent_has_resource_permission = "mod_res_permissions_api_agent_has_resource_permission"; @@ -40,6 +42,7 @@ static const char* CMockString_scmi_message_id = "scmi_message_id"; static const char* CMockString_scmi_protocol_id = "scmi_protocol_id"; static const char* CMockString_service_id = "service_id"; static const char* CMockString_size = "size"; +static const char* CMockString_state = "state"; static const char* CMockString_token = "token"; typedef struct _CMOCK_mod_scmi_from_protocol_api_get_agent_count_CALL_INSTANCE @@ -298,6 +301,22 @@ typedef struct _CMOCK_mod_res_permissions_api_agent_reset_config_CALL_INSTANCE } CMOCK_mod_res_permissions_api_agent_reset_config_CALL_INSTANCE; +typedef struct _CMOCK_mod_clock_api_get_state_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + fwk_id_t Expected_clock_id; + enum mod_clock_state* Expected_state; + int Expected_state_Depth; + char ReturnThruPtr_state_Used; + enum mod_clock_state* ReturnThruPtr_state_Val; + size_t ReturnThruPtr_state_Size; + char IgnoreArg_clock_id; + char IgnoreArg_state; + +} CMOCK_mod_clock_api_get_state_CALL_INSTANCE; + static struct Mockmod_scmi_clock_extraInstance { char mod_scmi_from_protocol_api_get_agent_count_IgnoreBool; @@ -395,6 +414,12 @@ static struct Mockmod_scmi_clock_extraInstance CMOCK_mod_res_permissions_api_agent_reset_config_CALLBACK mod_res_permissions_api_agent_reset_config_CallbackFunctionPointer; int mod_res_permissions_api_agent_reset_config_CallbackCalls; CMOCK_MEM_INDEX_TYPE mod_res_permissions_api_agent_reset_config_CallInstance; + char mod_clock_api_get_state_IgnoreBool; + int mod_clock_api_get_state_FinalReturn; + char mod_clock_api_get_state_CallbackBool; + CMOCK_mod_clock_api_get_state_CALLBACK mod_clock_api_get_state_CallbackFunctionPointer; + int mod_clock_api_get_state_CallbackCalls; + CMOCK_MEM_INDEX_TYPE mod_clock_api_get_state_CallInstance; } Mock; extern jmp_buf AbortFrame; @@ -611,6 +636,19 @@ void Mockmod_scmi_clock_extra_Verify(void) call_instance = CMOCK_GUTS_NONE; (void)call_instance; } + call_instance = Mock.mod_clock_api_get_state_CallInstance; + if (Mock.mod_clock_api_get_state_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_mod_clock_api_get_state); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.mod_clock_api_get_state_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } } void Mockmod_scmi_clock_extra_Init(void) @@ -3252,3 +3290,169 @@ void mod_res_permissions_api_agent_reset_config_CMockIgnoreArg_flags(UNITY_LINE_ cmock_call_instance->IgnoreArg_flags = 1; } +int mod_clock_api_get_state(fwk_id_t clock_id, enum mod_clock_state* state) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_mod_clock_api_get_state_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_mod_clock_api_get_state); + cmock_call_instance = (CMOCK_mod_clock_api_get_state_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.mod_clock_api_get_state_CallInstance); + Mock.mod_clock_api_get_state_CallInstance = CMock_Guts_MemNext(Mock.mod_clock_api_get_state_CallInstance); + if (Mock.mod_clock_api_get_state_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.mod_clock_api_get_state_FinalReturn; + Mock.mod_clock_api_get_state_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.mod_clock_api_get_state_CallbackBool && + Mock.mod_clock_api_get_state_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.mod_clock_api_get_state_CallbackFunctionPointer(clock_id, state, Mock.mod_clock_api_get_state_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_clock_id) + { + UNITY_SET_DETAILS(CMockString_mod_clock_api_get_state,CMockString_clock_id); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_clock_id), (void*)(&clock_id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_state) + { + UNITY_SET_DETAILS(CMockString_mod_clock_api_get_state,CMockString_state); + if (cmock_call_instance->Expected_state == NULL) + { UNITY_TEST_ASSERT_NULL(state, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_state), (void*)(state), sizeof(enum mod_clock_state), cmock_call_instance->Expected_state_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.mod_clock_api_get_state_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.mod_clock_api_get_state_CallbackFunctionPointer(clock_id, state, Mock.mod_clock_api_get_state_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_state_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(state, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)state, (void*)cmock_call_instance->ReturnThruPtr_state_Val, + cmock_call_instance->ReturnThruPtr_state_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_mod_clock_api_get_state(CMOCK_mod_clock_api_get_state_CALL_INSTANCE* cmock_call_instance, fwk_id_t clock_id, enum mod_clock_state* state, int state_Depth); +void CMockExpectParameters_mod_clock_api_get_state(CMOCK_mod_clock_api_get_state_CALL_INSTANCE* cmock_call_instance, fwk_id_t clock_id, enum mod_clock_state* state, int state_Depth) +{ + memcpy((void*)(&cmock_call_instance->Expected_clock_id), (void*)(&clock_id), + sizeof(fwk_id_t[sizeof(clock_id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_clock_id = 0; + cmock_call_instance->Expected_state = state; + cmock_call_instance->Expected_state_Depth = state_Depth; + cmock_call_instance->IgnoreArg_state = 0; + cmock_call_instance->ReturnThruPtr_state_Used = 0; +} + +void mod_clock_api_get_state_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mod_clock_api_get_state_CALL_INSTANCE)); + CMOCK_mod_clock_api_get_state_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_clock_api_get_state_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.mod_clock_api_get_state_CallInstance = CMock_Guts_MemChain(Mock.mod_clock_api_get_state_CallInstance, cmock_guts_index); + Mock.mod_clock_api_get_state_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.mod_clock_api_get_state_IgnoreBool = (char)1; +} + +void mod_clock_api_get_state_CMockStopIgnore(void) +{ + if(Mock.mod_clock_api_get_state_IgnoreBool) + Mock.mod_clock_api_get_state_CallInstance = CMock_Guts_MemNext(Mock.mod_clock_api_get_state_CallInstance); + Mock.mod_clock_api_get_state_IgnoreBool = (char)0; +} + +void mod_clock_api_get_state_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mod_clock_api_get_state_CALL_INSTANCE)); + CMOCK_mod_clock_api_get_state_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_clock_api_get_state_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.mod_clock_api_get_state_CallInstance = CMock_Guts_MemChain(Mock.mod_clock_api_get_state_CallInstance, cmock_guts_index); + Mock.mod_clock_api_get_state_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 mod_clock_api_get_state_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t clock_id, enum mod_clock_state* state, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mod_clock_api_get_state_CALL_INSTANCE)); + CMOCK_mod_clock_api_get_state_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_clock_api_get_state_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.mod_clock_api_get_state_CallInstance = CMock_Guts_MemChain(Mock.mod_clock_api_get_state_CallInstance, cmock_guts_index); + Mock.mod_clock_api_get_state_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_mod_clock_api_get_state(cmock_call_instance, clock_id, state, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void mod_clock_api_get_state_AddCallback(CMOCK_mod_clock_api_get_state_CALLBACK Callback) +{ + Mock.mod_clock_api_get_state_IgnoreBool = (char)0; + Mock.mod_clock_api_get_state_CallbackBool = (char)1; + Mock.mod_clock_api_get_state_CallbackFunctionPointer = Callback; +} + +void mod_clock_api_get_state_Stub(CMOCK_mod_clock_api_get_state_CALLBACK Callback) +{ + Mock.mod_clock_api_get_state_IgnoreBool = (char)0; + Mock.mod_clock_api_get_state_CallbackBool = (char)0; + Mock.mod_clock_api_get_state_CallbackFunctionPointer = Callback; +} + +void mod_clock_api_get_state_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t clock_id, enum mod_clock_state* state, int state_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mod_clock_api_get_state_CALL_INSTANCE)); + CMOCK_mod_clock_api_get_state_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_clock_api_get_state_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.mod_clock_api_get_state_CallInstance = CMock_Guts_MemChain(Mock.mod_clock_api_get_state_CallInstance, cmock_guts_index); + Mock.mod_clock_api_get_state_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_mod_clock_api_get_state(cmock_call_instance, clock_id, state, state_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void mod_clock_api_get_state_CMockReturnMemThruPtr_state(UNITY_LINE_TYPE cmock_line, enum mod_clock_state* state, size_t cmock_size) +{ + CMOCK_mod_clock_api_get_state_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_clock_api_get_state_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mod_clock_api_get_state_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_state_Used = 1; + cmock_call_instance->ReturnThruPtr_state_Val = state; + cmock_call_instance->ReturnThruPtr_state_Size = cmock_size; +} + +void mod_clock_api_get_state_CMockIgnoreArg_clock_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_mod_clock_api_get_state_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_clock_api_get_state_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mod_clock_api_get_state_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_clock_id = 1; +} + +void mod_clock_api_get_state_CMockIgnoreArg_state(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_mod_clock_api_get_state_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_clock_api_get_state_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mod_clock_api_get_state_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_state = 1; +} + diff --git a/module/scmi_clock/test/mocks/Mockmod_scmi_clock_extra.h b/module/scmi_clock/test/mocks/Mockmod_scmi_clock_extra.h index eb968b5c5..22521aa39 100644 --- a/module/scmi_clock/test/mocks/Mockmod_scmi_clock_extra.h +++ b/module/scmi_clock/test/mocks/Mockmod_scmi_clock_extra.h @@ -356,6 +356,28 @@ void mod_res_permissions_api_agent_reset_config_Stub(CMOCK_mod_res_permissions_a void mod_res_permissions_api_agent_reset_config_CMockIgnoreArg_agent_id(UNITY_LINE_TYPE cmock_line); #define mod_res_permissions_api_agent_reset_config_IgnoreArg_flags() mod_res_permissions_api_agent_reset_config_CMockIgnoreArg_flags(__LINE__) void mod_res_permissions_api_agent_reset_config_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line); +#define mod_clock_api_get_state_IgnoreAndReturn(cmock_retval) mod_clock_api_get_state_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void mod_clock_api_get_state_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define mod_clock_api_get_state_StopIgnore() mod_clock_api_get_state_CMockStopIgnore() +void mod_clock_api_get_state_CMockStopIgnore(void); +#define mod_clock_api_get_state_ExpectAnyArgsAndReturn(cmock_retval) mod_clock_api_get_state_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void mod_clock_api_get_state_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define mod_clock_api_get_state_ExpectAndReturn(clock_id, state, cmock_retval) mod_clock_api_get_state_CMockExpectAndReturn(__LINE__, clock_id, state, cmock_retval) +void mod_clock_api_get_state_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t clock_id, enum mod_clock_state* state, int cmock_to_return); +typedef int (* CMOCK_mod_clock_api_get_state_CALLBACK)(fwk_id_t clock_id, enum mod_clock_state* state, int cmock_num_calls); +void mod_clock_api_get_state_AddCallback(CMOCK_mod_clock_api_get_state_CALLBACK Callback); +void mod_clock_api_get_state_Stub(CMOCK_mod_clock_api_get_state_CALLBACK Callback); +#define mod_clock_api_get_state_StubWithCallback mod_clock_api_get_state_Stub +#define mod_clock_api_get_state_ExpectWithArrayAndReturn(clock_id, state, state_Depth, cmock_retval) mod_clock_api_get_state_CMockExpectWithArrayAndReturn(__LINE__, clock_id, state, state_Depth, cmock_retval) +void mod_clock_api_get_state_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t clock_id, enum mod_clock_state* state, int state_Depth, int cmock_to_return); +#define mod_clock_api_get_state_ReturnThruPtr_state(state) mod_clock_api_get_state_CMockReturnMemThruPtr_state(__LINE__, state, sizeof(enum mod_clock_state)) +#define mod_clock_api_get_state_ReturnArrayThruPtr_state(state, cmock_len) mod_clock_api_get_state_CMockReturnMemThruPtr_state(__LINE__, state, cmock_len * sizeof(*state)) +#define mod_clock_api_get_state_ReturnMemThruPtr_state(state, cmock_size) mod_clock_api_get_state_CMockReturnMemThruPtr_state(__LINE__, state, cmock_size) +void mod_clock_api_get_state_CMockReturnMemThruPtr_state(UNITY_LINE_TYPE cmock_line, enum mod_clock_state* state, size_t cmock_size); +#define mod_clock_api_get_state_IgnoreArg_clock_id() mod_clock_api_get_state_CMockIgnoreArg_clock_id(__LINE__) +void mod_clock_api_get_state_CMockIgnoreArg_clock_id(UNITY_LINE_TYPE cmock_line); +#define mod_clock_api_get_state_IgnoreArg_state() mod_clock_api_get_state_CMockIgnoreArg_state(__LINE__) +void mod_clock_api_get_state_CMockIgnoreArg_state(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_clock/test/mod_scmi_clock_extra.h b/module/scmi_clock/test/mod_scmi_clock_extra.h index c87ea1727..3eb68d519 100644 --- a/module/scmi_clock/test/mod_scmi_clock_extra.h +++ b/module/scmi_clock/test/mod_scmi_clock_extra.h @@ -7,6 +7,7 @@ * Description: * System Control and Management Interface (SCMI) unit test support. */ +#include #include #include @@ -270,3 +271,22 @@ int mod_res_permissions_api_agent_set_device_protocol_permission( * \retval ::FWK_E_PARAM Invalid flags. */ int mod_res_permissions_api_agent_reset_config(uint32_t agent_id, uint32_t flags); + +/*! + * \brief Get the running state of a clock. + * + * \param clock_id Clock device identifier. + * + * \param[out] state The current clock state. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_PENDING The request is pending. The requested state will be + * provided via a response event. + * \retval ::FWK_E_PARAM An invalid parameter was encountered: + * - The `clock_id` parameter was not a valid system entity identifier. + * - The `state` parameter was a null pointer value. + * \retval ::FWK_E_SUPPORT Deferred handling of asynchronous drivers is not + * supported. + * \return One of the standard framework error codes. + */ +int mod_clock_api_get_state(fwk_id_t clock_id, enum mod_clock_state *state); \ No newline at end of file diff --git a/module/scmi_clock/test/mod_scmi_clock_unit_test.c b/module/scmi_clock/test/mod_scmi_clock_unit_test.c index 5c90c270b..6c9fed761 100644 --- a/module/scmi_clock/test/mod_scmi_clock_unit_test.c +++ b/module/scmi_clock/test/mod_scmi_clock_unit_test.c @@ -45,6 +45,12 @@ struct mod_scmi_from_protocol_api from_protocol_api = { .notify = mod_scmi_from_protocol_api_notify, }; +struct mod_clock_api clock_api = { + .get_state = mod_clock_api_get_state, +}; + +static char *mock_clock_name = "TestClockDevice001"; + #if defined(BUILD_HAS_MOD_RESOURCE_PERMS) struct mod_res_permissions_api perm_api = { .agent_has_protocol_permission = mod_res_permissions_api_agent_has_protocol_permission, @@ -122,6 +128,7 @@ void setUp(void) } scmi_clock_ctx.scmi_api = &from_protocol_api; + scmi_clock_ctx.clock_api = &clock_api; #if defined(BUILD_HAS_MOD_RESOURCE_PERMS) scmi_clock_ctx.res_perms_api = &perm_api; #endif @@ -1001,6 +1008,74 @@ void test_protocol_message_attributes_handler_notify_rate_requested(void) TEST_ASSERT_EQUAL(FWK_SUCCESS, status); } +int get_state_callback_success( + fwk_id_t service_id, + const void *payload, + size_t size, + int NumCalls +) +{ + uint32_t expected_attributes; + struct scmi_clock_attributes_p2a *return_values; + return_values = (struct scmi_clock_attributes_p2a *)payload; + bool clock_enable, extended_name, notify_rate, notify_requested_rate; + + clock_enable = true; + extended_name = true; + + TEST_ASSERT_EQUAL((int32_t)SCMI_SUCCESS, return_values->status); + TEST_ASSERT_EQUAL_STRING_LEN(mock_clock_name, return_values->clock_name, + SCMI_CLOCK_NAME_LENGTH-1); + TEST_ASSERT_EQUAL(0, return_values->clock_enable_delay); + +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + notify_rate = true; + notify_requested_rate = true; +#else + notify_rate = false; + notify_requested_rate = false; +#endif + + expected_attributes = SET_SCMI_CLOCK_ATTRIBUTES(clock_enable, + extended_name, + notify_rate, + notify_requested_rate); + TEST_ASSERT_EQUAL(expected_attributes, return_values->attributes); + + return FWK_SUCCESS; +} + +void test_process_request_event_get_state(void) +{ + int status; + uint32_t agent_id = FAKE_SCMI_AGENT_IDX_OSPM0; + struct fwk_event event; + enum mod_clock_state expected_state = MOD_CLOCK_STATE_RUNNING; + + fwk_id_get_element_idx_ExpectAnyArgsAndReturn(SCMI_CLOCK_OSPM0_IDX1); + fwk_id_get_event_idx_ExpectAnyArgsAndReturn( + SCMI_CLOCK_EVENT_IDX_CLOCK_ATTRIBUTES); + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + + mod_clock_api_get_state_ExpectAnyArgsAndReturn(FWK_SUCCESS); + mod_clock_api_get_state_ReturnThruPtr_state(&expected_state); + + fwk_module_get_element_name_ExpectAnyArgsAndReturn(mock_clock_name); + + fwk_id_get_element_idx_ExpectAnyArgsAndReturn(SCMI_CLOCK_OSPM0_IDX1); + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + + mod_scmi_from_protocol_api_respond_Stub(get_state_callback_success); + + status = process_request_event(&event); + + TEST_ASSERT_EQUAL(status, FWK_SUCCESS); +} + int scmi_test_main(void) { UNITY_BEGIN(); @@ -1039,6 +1114,7 @@ int scmi_test_main(void) test_protocol_message_attributes_handler_notify_rate); RUN_TEST( test_protocol_message_attributes_handler_notify_rate_requested); + RUN_TEST(test_process_request_event_get_state); #endif return UNITY_END(); -- GitLab From 8e013374e169e7d162355071af9e1dbcd41b6620 Mon Sep 17 00:00:00 2001 From: Md Golam Tanvir Zim Date: Fri, 14 Jun 2024 15:25:10 +0100 Subject: [PATCH 09/16] scmi_clock: Add Unit Test for CLOCK_NAME_GET command This patch adds a unit test for CLOCK_NAME_GET command. Signed-off-by: Md Golam Tanvir Zim Change-Id: I28c27dc0833b0965858f678d9fcaae5fbebd74f3 --- .../test/mod_scmi_clock_unit_test.c | 134 ++++++++++++++++++ 1 file changed, 134 insertions(+) diff --git a/module/scmi_clock/test/mod_scmi_clock_unit_test.c b/module/scmi_clock/test/mod_scmi_clock_unit_test.c index 6c9fed761..0703d522b 100644 --- a/module/scmi_clock/test/mod_scmi_clock_unit_test.c +++ b/module/scmi_clock/test/mod_scmi_clock_unit_test.c @@ -1076,6 +1076,137 @@ void test_process_request_event_get_state(void) TEST_ASSERT_EQUAL(status, FWK_SUCCESS); } +int get_extended_name_callback_success( + fwk_id_t service_id, + const void *payload, + size_t size, + int NumCalls +) +{ + struct scmi_clock_name_get_p2a *return_values; + return_values = (struct scmi_clock_name_get_p2a *)payload; + + TEST_ASSERT_EQUAL((int32_t)SCMI_SUCCESS, return_values->status); + TEST_ASSERT_EQUAL(0, return_values->flags); + TEST_ASSERT_EQUAL_STRING_LEN(mock_clock_name, return_values->clock_extended_name, + SCMI_CLOCK_EXTENDED_NAME_LENGTH-1); + + return FWK_SUCCESS; +} + +void test_process_request_event_get_clock_extended_name(void) +{ + int status; + uint32_t agent_id = FAKE_SCMI_AGENT_IDX_OSPM0; + struct fwk_event event; + + fwk_id_get_element_idx_ExpectAnyArgsAndReturn(SCMI_CLOCK_OSPM0_IDX1); + fwk_id_get_event_idx_ExpectAnyArgsAndReturn(SCMI_CLOCK_EVENT_IDX_GET_NAME); + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + fwk_module_get_element_name_ExpectAnyArgsAndReturn(mock_clock_name); + + mod_scmi_from_protocol_api_respond_Stub( + get_extended_name_callback_success); + + status = process_request_event(&event); + + TEST_ASSERT_EQUAL(status, FWK_SUCCESS); +} + +void test_scmi_clock_name_get_handler_success(void) +{ + int status; + uint32_t agent_id = FAKE_SCMI_AGENT_IDX_OSPM0; + + fwk_id_t service_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_IDX, FAKE_SCMI_AGENT_IDX_OSPM0); + + struct scmi_clock_name_get_a2p payload = { + .clock_id = SCMI_CLOCK_OSPM0_IDX1, + }; + + mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn(FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + + fwk_module_is_valid_element_id_ExpectAnyArgsAndReturn(true); + + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn(FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + + fwk_id_get_element_idx_ExpectAnyArgsAndReturn(CLOCK_DEV_IDX_FAKE1); + + fwk_id_get_element_idx_ExpectAnyArgsAndReturn(CLOCK_DEV_IDX_FAKE1); + fwk_id_is_equal_ExpectAnyArgsAndReturn(true); + + __fwk_put_event_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + status = scmi_clock_message_handler( + (fwk_id_t)MOD_SCMI_PROTOCOL_ID_CLOCK, + service_id, + (const uint32_t *)&payload, + payload_size_table[MOD_SCMI_CLOCK_NAME_GET], + MOD_SCMI_CLOCK_NAME_GET); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +int clock_has_extended_name_callback( + fwk_id_t service_id, + const void *payload, + size_t size, + int NumCalls) +{ + struct scmi_clock_name_get_p2a *return_values; + return_values = (struct scmi_clock_name_get_p2a *)payload; + + TEST_ASSERT_EQUAL((int32_t)SCMI_NOT_SUPPORTED, return_values->status); + + return FWK_SUCCESS; +} + +void test_scmi_clock_name_get_handler_extended_name_not_supported(void) +{ + int status; + uint32_t agent_id = FAKE_SCMI_AGENT_IDX_OSPM0; + + fwk_id_t service_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_IDX, FAKE_SCMI_AGENT_IDX_OSPM0); + + struct scmi_clock_name_get_a2p payload = { + .clock_id = SCMI_CLOCK_OSPM0_IDX0, + }; + + mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn(FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + + fwk_module_is_valid_element_id_ExpectAnyArgsAndReturn(true); + + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn(FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + + fwk_id_get_element_idx_ExpectAnyArgsAndReturn(CLOCK_DEV_IDX_FAKE0); + + mod_scmi_from_protocol_api_respond_Stub( + clock_has_extended_name_callback); + + status = scmi_clock_message_handler( + (fwk_id_t)MOD_SCMI_PROTOCOL_ID_CLOCK, + service_id, + (const uint32_t *)&payload, + payload_size_table[MOD_SCMI_CLOCK_NAME_GET], + MOD_SCMI_CLOCK_NAME_GET); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + int scmi_test_main(void) { UNITY_BEGIN(); @@ -1115,6 +1246,9 @@ int scmi_test_main(void) RUN_TEST( test_protocol_message_attributes_handler_notify_rate_requested); RUN_TEST(test_process_request_event_get_state); + RUN_TEST(test_process_request_event_get_clock_extended_name); + RUN_TEST(test_scmi_clock_name_get_handler_success); + RUN_TEST(test_scmi_clock_name_get_handler_extended_name_not_supported); #endif return UNITY_END(); -- GitLab From 9f6ce868dda15d4b8f2476092d53eb6356f76a54 Mon Sep 17 00:00:00 2001 From: Md Golam Tanvir Zim Date: Mon, 17 Jun 2024 12:21:58 +0100 Subject: [PATCH 10/16] scmi_clock: Add Unit Test for CLOCK_RATE_NOTIFY command This patch adds unit test cases for CLOCK_RATE_NOTIFY command. Signed-off-by: Md Golam Tanvir Zim Change-Id: I06f667be95490cd3f69b79d548fbf66c24aeb8cb --- .../test/mocks/Mockmod_scmi_clock_extra.c | 842 ++++++++++++++++++ .../test/mocks/Mockmod_scmi_clock_extra.h | 89 ++ module/scmi_clock/test/mod_scmi_clock_extra.h | 27 +- .../test/mod_scmi_clock_unit_test.c | 209 +++++ 4 files changed, 1166 insertions(+), 1 deletion(-) diff --git a/module/scmi_clock/test/mocks/Mockmod_scmi_clock_extra.c b/module/scmi_clock/test/mocks/Mockmod_scmi_clock_extra.c index 3789023fb..80c5209f3 100644 --- a/module/scmi_clock/test/mocks/Mockmod_scmi_clock_extra.c +++ b/module/scmi_clock/test/mocks/Mockmod_scmi_clock_extra.c @@ -7,10 +7,13 @@ static const char* CMockString_agent_count = "agent_count"; static const char* CMockString_agent_id = "agent_id"; +static const char* CMockString_agent_idx = "agent_idx"; static const char* CMockString_agent_type = "agent_type"; static const char* CMockString_clock_id = "clock_id"; static const char* CMockString_command_count = "command_count"; static const char* CMockString_device_id = "device_id"; +static const char* CMockString_element_count = "element_count"; +static const char* CMockString_element_idx = "element_idx"; static const char* CMockString_flags = "flags"; static const char* CMockString_handler_table = "handler_table"; static const char* CMockString_message_id = "message_id"; @@ -32,14 +35,22 @@ static const char* CMockString_mod_scmi_from_protocol_api_scmi_frame_validation static const char* CMockString_mod_scmi_from_protocol_api_scmi_send_message = "mod_scmi_from_protocol_api_scmi_send_message"; static const char* CMockString_mod_scmi_from_protocol_api_write_payload = "mod_scmi_from_protocol_api_write_payload"; static const char* CMockString_offset = "offset"; +static const char* CMockString_operation_count = "operation_count"; +static const char* CMockString_operation_id = "operation_id"; static const char* CMockString_payload = "payload"; +static const char* CMockString_payload_p2a = "payload_p2a"; static const char* CMockString_payload_size = "payload_size"; static const char* CMockString_payload_size_table = "payload_size_table"; static const char* CMockString_protocol_id = "protocol_id"; static const char* CMockString_request_ack_by_interrupt = "request_ack_by_interrupt"; static const char* CMockString_resource_id = "resource_id"; static const char* CMockString_scmi_message_id = "scmi_message_id"; +static const char* CMockString_scmi_notification_add_subscriber = "scmi_notification_add_subscriber"; +static const char* CMockString_scmi_notification_init = "scmi_notification_init"; +static const char* CMockString_scmi_notification_notify = "scmi_notification_notify"; +static const char* CMockString_scmi_notification_remove_subscriber = "scmi_notification_remove_subscriber"; static const char* CMockString_scmi_protocol_id = "scmi_protocol_id"; +static const char* CMockString_scmi_response_message_id = "scmi_response_message_id"; static const char* CMockString_service_id = "service_id"; static const char* CMockString_size = "size"; static const char* CMockString_state = "state"; @@ -317,6 +328,76 @@ typedef struct _CMOCK_mod_clock_api_get_state_CALL_INSTANCE } CMOCK_mod_clock_api_get_state_CALL_INSTANCE; +typedef struct _CMOCK_scmi_notification_init_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + unsigned int Expected_protocol_id; + unsigned int Expected_agent_count; + unsigned int Expected_element_count; + unsigned int Expected_operation_count; + char IgnoreArg_protocol_id; + char IgnoreArg_agent_count; + char IgnoreArg_element_count; + char IgnoreArg_operation_count; + +} CMOCK_scmi_notification_init_CALL_INSTANCE; + +typedef struct _CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + unsigned int Expected_protocol_id; + unsigned int Expected_element_idx; + unsigned int Expected_operation_id; + fwk_id_t Expected_service_id; + char IgnoreArg_protocol_id; + char IgnoreArg_element_idx; + char IgnoreArg_operation_id; + char IgnoreArg_service_id; + +} CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE; + +typedef struct _CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + unsigned int Expected_protocol_id; + unsigned int Expected_agent_idx; + unsigned int Expected_element_idx; + unsigned int Expected_operation_id; + char IgnoreArg_protocol_id; + char IgnoreArg_agent_idx; + char IgnoreArg_element_idx; + char IgnoreArg_operation_id; + +} CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE; + +typedef struct _CMOCK_scmi_notification_notify_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + unsigned int Expected_protocol_id; + unsigned int Expected_operation_id; + unsigned int Expected_scmi_response_message_id; + void* Expected_payload_p2a; + size_t Expected_payload_size; + int Expected_payload_p2a_Depth; + char ReturnThruPtr_payload_p2a_Used; + void* ReturnThruPtr_payload_p2a_Val; + size_t ReturnThruPtr_payload_p2a_Size; + char IgnoreArg_protocol_id; + char IgnoreArg_operation_id; + char IgnoreArg_scmi_response_message_id; + char IgnoreArg_payload_p2a; + char IgnoreArg_payload_size; + +} CMOCK_scmi_notification_notify_CALL_INSTANCE; + static struct Mockmod_scmi_clock_extraInstance { char mod_scmi_from_protocol_api_get_agent_count_IgnoreBool; @@ -420,6 +501,30 @@ static struct Mockmod_scmi_clock_extraInstance CMOCK_mod_clock_api_get_state_CALLBACK mod_clock_api_get_state_CallbackFunctionPointer; int mod_clock_api_get_state_CallbackCalls; CMOCK_MEM_INDEX_TYPE mod_clock_api_get_state_CallInstance; + char scmi_notification_init_IgnoreBool; + int scmi_notification_init_FinalReturn; + char scmi_notification_init_CallbackBool; + CMOCK_scmi_notification_init_CALLBACK scmi_notification_init_CallbackFunctionPointer; + int scmi_notification_init_CallbackCalls; + CMOCK_MEM_INDEX_TYPE scmi_notification_init_CallInstance; + char scmi_notification_add_subscriber_IgnoreBool; + int scmi_notification_add_subscriber_FinalReturn; + char scmi_notification_add_subscriber_CallbackBool; + CMOCK_scmi_notification_add_subscriber_CALLBACK scmi_notification_add_subscriber_CallbackFunctionPointer; + int scmi_notification_add_subscriber_CallbackCalls; + CMOCK_MEM_INDEX_TYPE scmi_notification_add_subscriber_CallInstance; + char scmi_notification_remove_subscriber_IgnoreBool; + int scmi_notification_remove_subscriber_FinalReturn; + char scmi_notification_remove_subscriber_CallbackBool; + CMOCK_scmi_notification_remove_subscriber_CALLBACK scmi_notification_remove_subscriber_CallbackFunctionPointer; + int scmi_notification_remove_subscriber_CallbackCalls; + CMOCK_MEM_INDEX_TYPE scmi_notification_remove_subscriber_CallInstance; + char scmi_notification_notify_IgnoreBool; + int scmi_notification_notify_FinalReturn; + char scmi_notification_notify_CallbackBool; + CMOCK_scmi_notification_notify_CALLBACK scmi_notification_notify_CallbackFunctionPointer; + int scmi_notification_notify_CallbackCalls; + CMOCK_MEM_INDEX_TYPE scmi_notification_notify_CallInstance; } Mock; extern jmp_buf AbortFrame; @@ -645,6 +750,58 @@ void Mockmod_scmi_clock_extra_Verify(void) UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); } if (Mock.mod_clock_api_get_state_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.scmi_notification_init_CallInstance; + if (Mock.scmi_notification_init_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_scmi_notification_init); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.scmi_notification_init_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.scmi_notification_add_subscriber_CallInstance; + if (Mock.scmi_notification_add_subscriber_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_scmi_notification_add_subscriber); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.scmi_notification_add_subscriber_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.scmi_notification_remove_subscriber_CallInstance; + if (Mock.scmi_notification_remove_subscriber_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_scmi_notification_remove_subscriber); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.scmi_notification_remove_subscriber_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.scmi_notification_notify_CallInstance; + if (Mock.scmi_notification_notify_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_scmi_notification_notify); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.scmi_notification_notify_CallbackFunctionPointer != NULL) { call_instance = CMOCK_GUTS_NONE; (void)call_instance; @@ -3456,3 +3613,688 @@ void mod_clock_api_get_state_CMockIgnoreArg_state(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_state = 1; } +int scmi_notification_init(unsigned int protocol_id, unsigned int agent_count, unsigned int element_count, unsigned int operation_count) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_scmi_notification_init_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_scmi_notification_init); + cmock_call_instance = (CMOCK_scmi_notification_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.scmi_notification_init_CallInstance); + Mock.scmi_notification_init_CallInstance = CMock_Guts_MemNext(Mock.scmi_notification_init_CallInstance); + if (Mock.scmi_notification_init_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.scmi_notification_init_FinalReturn; + Mock.scmi_notification_init_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.scmi_notification_init_CallbackBool && + Mock.scmi_notification_init_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.scmi_notification_init_CallbackFunctionPointer(protocol_id, agent_count, element_count, operation_count, Mock.scmi_notification_init_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_protocol_id) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_init,CMockString_protocol_id); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_protocol_id, protocol_id, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_agent_count) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_init,CMockString_agent_count); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_agent_count, agent_count, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_element_count) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_init,CMockString_element_count); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_element_count, element_count, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_operation_count) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_init,CMockString_operation_count); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_operation_count, operation_count, cmock_line, CMockStringMismatch); + } + } + if (Mock.scmi_notification_init_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.scmi_notification_init_CallbackFunctionPointer(protocol_id, agent_count, element_count, operation_count, Mock.scmi_notification_init_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_scmi_notification_init(CMOCK_scmi_notification_init_CALL_INSTANCE* cmock_call_instance, unsigned int protocol_id, unsigned int agent_count, unsigned int element_count, unsigned int operation_count); +void CMockExpectParameters_scmi_notification_init(CMOCK_scmi_notification_init_CALL_INSTANCE* cmock_call_instance, unsigned int protocol_id, unsigned int agent_count, unsigned int element_count, unsigned int operation_count) +{ + cmock_call_instance->Expected_protocol_id = protocol_id; + cmock_call_instance->IgnoreArg_protocol_id = 0; + cmock_call_instance->Expected_agent_count = agent_count; + cmock_call_instance->IgnoreArg_agent_count = 0; + cmock_call_instance->Expected_element_count = element_count; + cmock_call_instance->IgnoreArg_element_count = 0; + cmock_call_instance->Expected_operation_count = operation_count; + cmock_call_instance->IgnoreArg_operation_count = 0; +} + +void scmi_notification_init_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_scmi_notification_init_CALL_INSTANCE)); + CMOCK_scmi_notification_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_init_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.scmi_notification_init_CallInstance = CMock_Guts_MemChain(Mock.scmi_notification_init_CallInstance, cmock_guts_index); + Mock.scmi_notification_init_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.scmi_notification_init_IgnoreBool = (char)1; +} + +void scmi_notification_init_CMockStopIgnore(void) +{ + if(Mock.scmi_notification_init_IgnoreBool) + Mock.scmi_notification_init_CallInstance = CMock_Guts_MemNext(Mock.scmi_notification_init_CallInstance); + Mock.scmi_notification_init_IgnoreBool = (char)0; +} + +void scmi_notification_init_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_scmi_notification_init_CALL_INSTANCE)); + CMOCK_scmi_notification_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_init_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.scmi_notification_init_CallInstance = CMock_Guts_MemChain(Mock.scmi_notification_init_CallInstance, cmock_guts_index); + Mock.scmi_notification_init_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 scmi_notification_init_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int protocol_id, unsigned int agent_count, unsigned int element_count, unsigned int operation_count, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_scmi_notification_init_CALL_INSTANCE)); + CMOCK_scmi_notification_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_init_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.scmi_notification_init_CallInstance = CMock_Guts_MemChain(Mock.scmi_notification_init_CallInstance, cmock_guts_index); + Mock.scmi_notification_init_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_scmi_notification_init(cmock_call_instance, protocol_id, agent_count, element_count, operation_count); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void scmi_notification_init_AddCallback(CMOCK_scmi_notification_init_CALLBACK Callback) +{ + Mock.scmi_notification_init_IgnoreBool = (char)0; + Mock.scmi_notification_init_CallbackBool = (char)1; + Mock.scmi_notification_init_CallbackFunctionPointer = Callback; +} + +void scmi_notification_init_Stub(CMOCK_scmi_notification_init_CALLBACK Callback) +{ + Mock.scmi_notification_init_IgnoreBool = (char)0; + Mock.scmi_notification_init_CallbackBool = (char)0; + Mock.scmi_notification_init_CallbackFunctionPointer = Callback; +} + +void scmi_notification_init_CMockIgnoreArg_protocol_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_init_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_protocol_id = 1; +} + +void scmi_notification_init_CMockIgnoreArg_agent_count(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_init_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_agent_count = 1; +} + +void scmi_notification_init_CMockIgnoreArg_element_count(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_init_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_element_count = 1; +} + +void scmi_notification_init_CMockIgnoreArg_operation_count(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_init_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_operation_count = 1; +} + +int scmi_notification_add_subscriber(unsigned int protocol_id, unsigned int element_idx, unsigned int operation_id, fwk_id_t service_id) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_scmi_notification_add_subscriber); + cmock_call_instance = (CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.scmi_notification_add_subscriber_CallInstance); + Mock.scmi_notification_add_subscriber_CallInstance = CMock_Guts_MemNext(Mock.scmi_notification_add_subscriber_CallInstance); + if (Mock.scmi_notification_add_subscriber_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.scmi_notification_add_subscriber_FinalReturn; + Mock.scmi_notification_add_subscriber_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.scmi_notification_add_subscriber_CallbackBool && + Mock.scmi_notification_add_subscriber_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.scmi_notification_add_subscriber_CallbackFunctionPointer(protocol_id, element_idx, operation_id, service_id, Mock.scmi_notification_add_subscriber_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_protocol_id) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_add_subscriber,CMockString_protocol_id); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_protocol_id, protocol_id, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_element_idx) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_add_subscriber,CMockString_element_idx); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_element_idx, element_idx, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_operation_id) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_add_subscriber,CMockString_operation_id); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_operation_id, operation_id, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_service_id) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_add_subscriber,CMockString_service_id); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_service_id), (void*)(&service_id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); + } + } + if (Mock.scmi_notification_add_subscriber_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.scmi_notification_add_subscriber_CallbackFunctionPointer(protocol_id, element_idx, operation_id, service_id, Mock.scmi_notification_add_subscriber_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_scmi_notification_add_subscriber(CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE* cmock_call_instance, unsigned int protocol_id, unsigned int element_idx, unsigned int operation_id, fwk_id_t service_id); +void CMockExpectParameters_scmi_notification_add_subscriber(CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE* cmock_call_instance, unsigned int protocol_id, unsigned int element_idx, unsigned int operation_id, fwk_id_t service_id) +{ + cmock_call_instance->Expected_protocol_id = protocol_id; + cmock_call_instance->IgnoreArg_protocol_id = 0; + cmock_call_instance->Expected_element_idx = element_idx; + cmock_call_instance->IgnoreArg_element_idx = 0; + cmock_call_instance->Expected_operation_id = operation_id; + cmock_call_instance->IgnoreArg_operation_id = 0; + memcpy((void*)(&cmock_call_instance->Expected_service_id), (void*)(&service_id), + sizeof(fwk_id_t[sizeof(service_id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_service_id = 0; +} + +void scmi_notification_add_subscriber_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE)); + CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_add_subscriber_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.scmi_notification_add_subscriber_CallInstance = CMock_Guts_MemChain(Mock.scmi_notification_add_subscriber_CallInstance, cmock_guts_index); + Mock.scmi_notification_add_subscriber_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.scmi_notification_add_subscriber_IgnoreBool = (char)1; +} + +void scmi_notification_add_subscriber_CMockStopIgnore(void) +{ + if(Mock.scmi_notification_add_subscriber_IgnoreBool) + Mock.scmi_notification_add_subscriber_CallInstance = CMock_Guts_MemNext(Mock.scmi_notification_add_subscriber_CallInstance); + Mock.scmi_notification_add_subscriber_IgnoreBool = (char)0; +} + +void scmi_notification_add_subscriber_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE)); + CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_add_subscriber_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.scmi_notification_add_subscriber_CallInstance = CMock_Guts_MemChain(Mock.scmi_notification_add_subscriber_CallInstance, cmock_guts_index); + Mock.scmi_notification_add_subscriber_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 scmi_notification_add_subscriber_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int protocol_id, unsigned int element_idx, unsigned int operation_id, fwk_id_t service_id, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE)); + CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_add_subscriber_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.scmi_notification_add_subscriber_CallInstance = CMock_Guts_MemChain(Mock.scmi_notification_add_subscriber_CallInstance, cmock_guts_index); + Mock.scmi_notification_add_subscriber_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_scmi_notification_add_subscriber(cmock_call_instance, protocol_id, element_idx, operation_id, service_id); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void scmi_notification_add_subscriber_AddCallback(CMOCK_scmi_notification_add_subscriber_CALLBACK Callback) +{ + Mock.scmi_notification_add_subscriber_IgnoreBool = (char)0; + Mock.scmi_notification_add_subscriber_CallbackBool = (char)1; + Mock.scmi_notification_add_subscriber_CallbackFunctionPointer = Callback; +} + +void scmi_notification_add_subscriber_Stub(CMOCK_scmi_notification_add_subscriber_CALLBACK Callback) +{ + Mock.scmi_notification_add_subscriber_IgnoreBool = (char)0; + Mock.scmi_notification_add_subscriber_CallbackBool = (char)0; + Mock.scmi_notification_add_subscriber_CallbackFunctionPointer = Callback; +} + +void scmi_notification_add_subscriber_CMockIgnoreArg_protocol_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_add_subscriber_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_protocol_id = 1; +} + +void scmi_notification_add_subscriber_CMockIgnoreArg_element_idx(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_add_subscriber_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_element_idx = 1; +} + +void scmi_notification_add_subscriber_CMockIgnoreArg_operation_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_add_subscriber_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_operation_id = 1; +} + +void scmi_notification_add_subscriber_CMockIgnoreArg_service_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_add_subscriber_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_add_subscriber_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_service_id = 1; +} + +int scmi_notification_remove_subscriber(unsigned int protocol_id, unsigned int agent_idx, unsigned int element_idx, unsigned int operation_id) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_scmi_notification_remove_subscriber); + cmock_call_instance = (CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.scmi_notification_remove_subscriber_CallInstance); + Mock.scmi_notification_remove_subscriber_CallInstance = CMock_Guts_MemNext(Mock.scmi_notification_remove_subscriber_CallInstance); + if (Mock.scmi_notification_remove_subscriber_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.scmi_notification_remove_subscriber_FinalReturn; + Mock.scmi_notification_remove_subscriber_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.scmi_notification_remove_subscriber_CallbackBool && + Mock.scmi_notification_remove_subscriber_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.scmi_notification_remove_subscriber_CallbackFunctionPointer(protocol_id, agent_idx, element_idx, operation_id, Mock.scmi_notification_remove_subscriber_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_protocol_id) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_remove_subscriber,CMockString_protocol_id); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_protocol_id, protocol_id, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_agent_idx) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_remove_subscriber,CMockString_agent_idx); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_agent_idx, agent_idx, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_element_idx) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_remove_subscriber,CMockString_element_idx); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_element_idx, element_idx, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_operation_id) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_remove_subscriber,CMockString_operation_id); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_operation_id, operation_id, cmock_line, CMockStringMismatch); + } + } + if (Mock.scmi_notification_remove_subscriber_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.scmi_notification_remove_subscriber_CallbackFunctionPointer(protocol_id, agent_idx, element_idx, operation_id, Mock.scmi_notification_remove_subscriber_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_scmi_notification_remove_subscriber(CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE* cmock_call_instance, unsigned int protocol_id, unsigned int agent_idx, unsigned int element_idx, unsigned int operation_id); +void CMockExpectParameters_scmi_notification_remove_subscriber(CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE* cmock_call_instance, unsigned int protocol_id, unsigned int agent_idx, unsigned int element_idx, unsigned int operation_id) +{ + cmock_call_instance->Expected_protocol_id = protocol_id; + cmock_call_instance->IgnoreArg_protocol_id = 0; + cmock_call_instance->Expected_agent_idx = agent_idx; + cmock_call_instance->IgnoreArg_agent_idx = 0; + cmock_call_instance->Expected_element_idx = element_idx; + cmock_call_instance->IgnoreArg_element_idx = 0; + cmock_call_instance->Expected_operation_id = operation_id; + cmock_call_instance->IgnoreArg_operation_id = 0; +} + +void scmi_notification_remove_subscriber_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE)); + CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_remove_subscriber_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.scmi_notification_remove_subscriber_CallInstance = CMock_Guts_MemChain(Mock.scmi_notification_remove_subscriber_CallInstance, cmock_guts_index); + Mock.scmi_notification_remove_subscriber_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.scmi_notification_remove_subscriber_IgnoreBool = (char)1; +} + +void scmi_notification_remove_subscriber_CMockStopIgnore(void) +{ + if(Mock.scmi_notification_remove_subscriber_IgnoreBool) + Mock.scmi_notification_remove_subscriber_CallInstance = CMock_Guts_MemNext(Mock.scmi_notification_remove_subscriber_CallInstance); + Mock.scmi_notification_remove_subscriber_IgnoreBool = (char)0; +} + +void scmi_notification_remove_subscriber_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE)); + CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_remove_subscriber_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.scmi_notification_remove_subscriber_CallInstance = CMock_Guts_MemChain(Mock.scmi_notification_remove_subscriber_CallInstance, cmock_guts_index); + Mock.scmi_notification_remove_subscriber_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 scmi_notification_remove_subscriber_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int protocol_id, unsigned int agent_idx, unsigned int element_idx, unsigned int operation_id, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE)); + CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_remove_subscriber_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.scmi_notification_remove_subscriber_CallInstance = CMock_Guts_MemChain(Mock.scmi_notification_remove_subscriber_CallInstance, cmock_guts_index); + Mock.scmi_notification_remove_subscriber_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_scmi_notification_remove_subscriber(cmock_call_instance, protocol_id, agent_idx, element_idx, operation_id); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void scmi_notification_remove_subscriber_AddCallback(CMOCK_scmi_notification_remove_subscriber_CALLBACK Callback) +{ + Mock.scmi_notification_remove_subscriber_IgnoreBool = (char)0; + Mock.scmi_notification_remove_subscriber_CallbackBool = (char)1; + Mock.scmi_notification_remove_subscriber_CallbackFunctionPointer = Callback; +} + +void scmi_notification_remove_subscriber_Stub(CMOCK_scmi_notification_remove_subscriber_CALLBACK Callback) +{ + Mock.scmi_notification_remove_subscriber_IgnoreBool = (char)0; + Mock.scmi_notification_remove_subscriber_CallbackBool = (char)0; + Mock.scmi_notification_remove_subscriber_CallbackFunctionPointer = Callback; +} + +void scmi_notification_remove_subscriber_CMockIgnoreArg_protocol_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_remove_subscriber_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_protocol_id = 1; +} + +void scmi_notification_remove_subscriber_CMockIgnoreArg_agent_idx(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_remove_subscriber_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_agent_idx = 1; +} + +void scmi_notification_remove_subscriber_CMockIgnoreArg_element_idx(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_remove_subscriber_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_element_idx = 1; +} + +void scmi_notification_remove_subscriber_CMockIgnoreArg_operation_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_remove_subscriber_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_remove_subscriber_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_operation_id = 1; +} + +int scmi_notification_notify(unsigned int protocol_id, unsigned int operation_id, unsigned int scmi_response_message_id, void* payload_p2a, size_t payload_size) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_scmi_notification_notify_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_scmi_notification_notify); + cmock_call_instance = (CMOCK_scmi_notification_notify_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.scmi_notification_notify_CallInstance); + Mock.scmi_notification_notify_CallInstance = CMock_Guts_MemNext(Mock.scmi_notification_notify_CallInstance); + if (Mock.scmi_notification_notify_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.scmi_notification_notify_FinalReturn; + Mock.scmi_notification_notify_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.scmi_notification_notify_CallbackBool && + Mock.scmi_notification_notify_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.scmi_notification_notify_CallbackFunctionPointer(protocol_id, operation_id, scmi_response_message_id, payload_p2a, payload_size, Mock.scmi_notification_notify_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_protocol_id) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_notify,CMockString_protocol_id); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_protocol_id, protocol_id, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_operation_id) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_notify,CMockString_operation_id); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_operation_id, operation_id, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_scmi_response_message_id) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_notify,CMockString_scmi_response_message_id); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_scmi_response_message_id, scmi_response_message_id, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_payload_p2a) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_notify,CMockString_payload_p2a); + if (cmock_call_instance->Expected_payload_p2a == NULL) + { UNITY_TEST_ASSERT_NULL(payload_p2a, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_payload_p2a, payload_p2a, cmock_call_instance->Expected_payload_p2a_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_payload_size) + { + UNITY_SET_DETAILS(CMockString_scmi_notification_notify,CMockString_payload_size); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_payload_size), (void*)(&payload_size), sizeof(size_t), cmock_line, CMockStringMismatch); + } + } + if (Mock.scmi_notification_notify_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.scmi_notification_notify_CallbackFunctionPointer(protocol_id, operation_id, scmi_response_message_id, payload_p2a, payload_size, Mock.scmi_notification_notify_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_payload_p2a_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(payload_p2a, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)payload_p2a, (void*)cmock_call_instance->ReturnThruPtr_payload_p2a_Val, + cmock_call_instance->ReturnThruPtr_payload_p2a_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_scmi_notification_notify(CMOCK_scmi_notification_notify_CALL_INSTANCE* cmock_call_instance, unsigned int protocol_id, unsigned int operation_id, unsigned int scmi_response_message_id, void* payload_p2a, int payload_p2a_Depth, size_t payload_size); +void CMockExpectParameters_scmi_notification_notify(CMOCK_scmi_notification_notify_CALL_INSTANCE* cmock_call_instance, unsigned int protocol_id, unsigned int operation_id, unsigned int scmi_response_message_id, void* payload_p2a, int payload_p2a_Depth, size_t payload_size) +{ + cmock_call_instance->Expected_protocol_id = protocol_id; + cmock_call_instance->IgnoreArg_protocol_id = 0; + cmock_call_instance->Expected_operation_id = operation_id; + cmock_call_instance->IgnoreArg_operation_id = 0; + cmock_call_instance->Expected_scmi_response_message_id = scmi_response_message_id; + cmock_call_instance->IgnoreArg_scmi_response_message_id = 0; + cmock_call_instance->Expected_payload_p2a = payload_p2a; + cmock_call_instance->Expected_payload_p2a_Depth = payload_p2a_Depth; + cmock_call_instance->IgnoreArg_payload_p2a = 0; + cmock_call_instance->ReturnThruPtr_payload_p2a_Used = 0; + memcpy((void*)(&cmock_call_instance->Expected_payload_size), (void*)(&payload_size), + sizeof(size_t[sizeof(payload_size) == sizeof(size_t) ? 1 : -1])); /* add size_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_payload_size = 0; +} + +void scmi_notification_notify_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_scmi_notification_notify_CALL_INSTANCE)); + CMOCK_scmi_notification_notify_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_notify_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.scmi_notification_notify_CallInstance = CMock_Guts_MemChain(Mock.scmi_notification_notify_CallInstance, cmock_guts_index); + Mock.scmi_notification_notify_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.scmi_notification_notify_IgnoreBool = (char)1; +} + +void scmi_notification_notify_CMockStopIgnore(void) +{ + if(Mock.scmi_notification_notify_IgnoreBool) + Mock.scmi_notification_notify_CallInstance = CMock_Guts_MemNext(Mock.scmi_notification_notify_CallInstance); + Mock.scmi_notification_notify_IgnoreBool = (char)0; +} + +void scmi_notification_notify_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_scmi_notification_notify_CALL_INSTANCE)); + CMOCK_scmi_notification_notify_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_notify_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.scmi_notification_notify_CallInstance = CMock_Guts_MemChain(Mock.scmi_notification_notify_CallInstance, cmock_guts_index); + Mock.scmi_notification_notify_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 scmi_notification_notify_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int protocol_id, unsigned int operation_id, unsigned int scmi_response_message_id, void* payload_p2a, size_t payload_size, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_scmi_notification_notify_CALL_INSTANCE)); + CMOCK_scmi_notification_notify_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_notify_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.scmi_notification_notify_CallInstance = CMock_Guts_MemChain(Mock.scmi_notification_notify_CallInstance, cmock_guts_index); + Mock.scmi_notification_notify_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_scmi_notification_notify(cmock_call_instance, protocol_id, operation_id, scmi_response_message_id, payload_p2a, payload_size, payload_size); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void scmi_notification_notify_AddCallback(CMOCK_scmi_notification_notify_CALLBACK Callback) +{ + Mock.scmi_notification_notify_IgnoreBool = (char)0; + Mock.scmi_notification_notify_CallbackBool = (char)1; + Mock.scmi_notification_notify_CallbackFunctionPointer = Callback; +} + +void scmi_notification_notify_Stub(CMOCK_scmi_notification_notify_CALLBACK Callback) +{ + Mock.scmi_notification_notify_IgnoreBool = (char)0; + Mock.scmi_notification_notify_CallbackBool = (char)0; + Mock.scmi_notification_notify_CallbackFunctionPointer = Callback; +} + +void scmi_notification_notify_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int protocol_id, unsigned int operation_id, unsigned int scmi_response_message_id, void* payload_p2a, int payload_p2a_Depth, size_t payload_size, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_scmi_notification_notify_CALL_INSTANCE)); + CMOCK_scmi_notification_notify_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_notify_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.scmi_notification_notify_CallInstance = CMock_Guts_MemChain(Mock.scmi_notification_notify_CallInstance, cmock_guts_index); + Mock.scmi_notification_notify_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_scmi_notification_notify(cmock_call_instance, protocol_id, operation_id, scmi_response_message_id, payload_p2a, payload_p2a_Depth, payload_size); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void scmi_notification_notify_CMockReturnMemThruPtr_payload_p2a(UNITY_LINE_TYPE cmock_line, void* payload_p2a, size_t cmock_size) +{ + CMOCK_scmi_notification_notify_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_notify_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_notify_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_payload_p2a_Used = 1; + cmock_call_instance->ReturnThruPtr_payload_p2a_Val = payload_p2a; + cmock_call_instance->ReturnThruPtr_payload_p2a_Size = cmock_size; +} + +void scmi_notification_notify_CMockIgnoreArg_protocol_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_notify_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_notify_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_notify_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_protocol_id = 1; +} + +void scmi_notification_notify_CMockIgnoreArg_operation_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_notify_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_notify_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_notify_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_operation_id = 1; +} + +void scmi_notification_notify_CMockIgnoreArg_scmi_response_message_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_notify_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_notify_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_notify_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_scmi_response_message_id = 1; +} + +void scmi_notification_notify_CMockIgnoreArg_payload_p2a(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_notify_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_notify_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_notify_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_payload_p2a = 1; +} + +void scmi_notification_notify_CMockIgnoreArg_payload_size(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_scmi_notification_notify_CALL_INSTANCE* cmock_call_instance = (CMOCK_scmi_notification_notify_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.scmi_notification_notify_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_payload_size = 1; +} diff --git a/module/scmi_clock/test/mocks/Mockmod_scmi_clock_extra.h b/module/scmi_clock/test/mocks/Mockmod_scmi_clock_extra.h index 22521aa39..103fb6779 100644 --- a/module/scmi_clock/test/mocks/Mockmod_scmi_clock_extra.h +++ b/module/scmi_clock/test/mocks/Mockmod_scmi_clock_extra.h @@ -379,6 +379,95 @@ void mod_clock_api_get_state_CMockIgnoreArg_clock_id(UNITY_LINE_TYPE cmock_line) #define mod_clock_api_get_state_IgnoreArg_state() mod_clock_api_get_state_CMockIgnoreArg_state(__LINE__) void mod_clock_api_get_state_CMockIgnoreArg_state(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_init_IgnoreAndReturn(cmock_retval) scmi_notification_init_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void scmi_notification_init_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define scmi_notification_init_StopIgnore() scmi_notification_init_CMockStopIgnore() +void scmi_notification_init_CMockStopIgnore(void); +#define scmi_notification_init_ExpectAnyArgsAndReturn(cmock_retval) scmi_notification_init_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void scmi_notification_init_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define scmi_notification_init_ExpectAndReturn(protocol_id, agent_count, element_count, operation_count, cmock_retval) scmi_notification_init_CMockExpectAndReturn(__LINE__, protocol_id, agent_count, element_count, operation_count, cmock_retval) +void scmi_notification_init_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int protocol_id, unsigned int agent_count, unsigned int element_count, unsigned int operation_count, int cmock_to_return); +typedef int (* CMOCK_scmi_notification_init_CALLBACK)(unsigned int protocol_id, unsigned int agent_count, unsigned int element_count, unsigned int operation_count, int cmock_num_calls); +void scmi_notification_init_AddCallback(CMOCK_scmi_notification_init_CALLBACK Callback); +void scmi_notification_init_Stub(CMOCK_scmi_notification_init_CALLBACK Callback); +#define scmi_notification_init_StubWithCallback scmi_notification_init_Stub +#define scmi_notification_init_IgnoreArg_protocol_id() scmi_notification_init_CMockIgnoreArg_protocol_id(__LINE__) +void scmi_notification_init_CMockIgnoreArg_protocol_id(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_init_IgnoreArg_agent_count() scmi_notification_init_CMockIgnoreArg_agent_count(__LINE__) +void scmi_notification_init_CMockIgnoreArg_agent_count(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_init_IgnoreArg_element_count() scmi_notification_init_CMockIgnoreArg_element_count(__LINE__) +void scmi_notification_init_CMockIgnoreArg_element_count(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_init_IgnoreArg_operation_count() scmi_notification_init_CMockIgnoreArg_operation_count(__LINE__) +void scmi_notification_init_CMockIgnoreArg_operation_count(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_add_subscriber_IgnoreAndReturn(cmock_retval) scmi_notification_add_subscriber_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void scmi_notification_add_subscriber_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define scmi_notification_add_subscriber_StopIgnore() scmi_notification_add_subscriber_CMockStopIgnore() +void scmi_notification_add_subscriber_CMockStopIgnore(void); +#define scmi_notification_add_subscriber_ExpectAnyArgsAndReturn(cmock_retval) scmi_notification_add_subscriber_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void scmi_notification_add_subscriber_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define scmi_notification_add_subscriber_ExpectAndReturn(protocol_id, element_idx, operation_id, service_id, cmock_retval) scmi_notification_add_subscriber_CMockExpectAndReturn(__LINE__, protocol_id, element_idx, operation_id, service_id, cmock_retval) +void scmi_notification_add_subscriber_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int protocol_id, unsigned int element_idx, unsigned int operation_id, fwk_id_t service_id, int cmock_to_return); +typedef int (* CMOCK_scmi_notification_add_subscriber_CALLBACK)(unsigned int protocol_id, unsigned int element_idx, unsigned int operation_id, fwk_id_t service_id, int cmock_num_calls); +void scmi_notification_add_subscriber_AddCallback(CMOCK_scmi_notification_add_subscriber_CALLBACK Callback); +void scmi_notification_add_subscriber_Stub(CMOCK_scmi_notification_add_subscriber_CALLBACK Callback); +#define scmi_notification_add_subscriber_StubWithCallback scmi_notification_add_subscriber_Stub +#define scmi_notification_add_subscriber_IgnoreArg_protocol_id() scmi_notification_add_subscriber_CMockIgnoreArg_protocol_id(__LINE__) +void scmi_notification_add_subscriber_CMockIgnoreArg_protocol_id(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_add_subscriber_IgnoreArg_element_idx() scmi_notification_add_subscriber_CMockIgnoreArg_element_idx(__LINE__) +void scmi_notification_add_subscriber_CMockIgnoreArg_element_idx(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_add_subscriber_IgnoreArg_operation_id() scmi_notification_add_subscriber_CMockIgnoreArg_operation_id(__LINE__) +void scmi_notification_add_subscriber_CMockIgnoreArg_operation_id(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_add_subscriber_IgnoreArg_service_id() scmi_notification_add_subscriber_CMockIgnoreArg_service_id(__LINE__) +void scmi_notification_add_subscriber_CMockIgnoreArg_service_id(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_remove_subscriber_IgnoreAndReturn(cmock_retval) scmi_notification_remove_subscriber_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void scmi_notification_remove_subscriber_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define scmi_notification_remove_subscriber_StopIgnore() scmi_notification_remove_subscriber_CMockStopIgnore() +void scmi_notification_remove_subscriber_CMockStopIgnore(void); +#define scmi_notification_remove_subscriber_ExpectAnyArgsAndReturn(cmock_retval) scmi_notification_remove_subscriber_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void scmi_notification_remove_subscriber_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define scmi_notification_remove_subscriber_ExpectAndReturn(protocol_id, agent_idx, element_idx, operation_id, cmock_retval) scmi_notification_remove_subscriber_CMockExpectAndReturn(__LINE__, protocol_id, agent_idx, element_idx, operation_id, cmock_retval) +void scmi_notification_remove_subscriber_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int protocol_id, unsigned int agent_idx, unsigned int element_idx, unsigned int operation_id, int cmock_to_return); +typedef int (* CMOCK_scmi_notification_remove_subscriber_CALLBACK)(unsigned int protocol_id, unsigned int agent_idx, unsigned int element_idx, unsigned int operation_id, int cmock_num_calls); +void scmi_notification_remove_subscriber_AddCallback(CMOCK_scmi_notification_remove_subscriber_CALLBACK Callback); +void scmi_notification_remove_subscriber_Stub(CMOCK_scmi_notification_remove_subscriber_CALLBACK Callback); +#define scmi_notification_remove_subscriber_StubWithCallback scmi_notification_remove_subscriber_Stub +#define scmi_notification_remove_subscriber_IgnoreArg_protocol_id() scmi_notification_remove_subscriber_CMockIgnoreArg_protocol_id(__LINE__) +void scmi_notification_remove_subscriber_CMockIgnoreArg_protocol_id(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_remove_subscriber_IgnoreArg_agent_idx() scmi_notification_remove_subscriber_CMockIgnoreArg_agent_idx(__LINE__) +void scmi_notification_remove_subscriber_CMockIgnoreArg_agent_idx(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_remove_subscriber_IgnoreArg_element_idx() scmi_notification_remove_subscriber_CMockIgnoreArg_element_idx(__LINE__) +void scmi_notification_remove_subscriber_CMockIgnoreArg_element_idx(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_remove_subscriber_IgnoreArg_operation_id() scmi_notification_remove_subscriber_CMockIgnoreArg_operation_id(__LINE__) +void scmi_notification_remove_subscriber_CMockIgnoreArg_operation_id(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_notify_IgnoreAndReturn(cmock_retval) scmi_notification_notify_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void scmi_notification_notify_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define scmi_notification_notify_StopIgnore() scmi_notification_notify_CMockStopIgnore() +void scmi_notification_notify_CMockStopIgnore(void); +#define scmi_notification_notify_ExpectAnyArgsAndReturn(cmock_retval) scmi_notification_notify_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void scmi_notification_notify_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define scmi_notification_notify_ExpectAndReturn(protocol_id, operation_id, scmi_response_message_id, payload_p2a, payload_size, cmock_retval) scmi_notification_notify_CMockExpectAndReturn(__LINE__, protocol_id, operation_id, scmi_response_message_id, payload_p2a, payload_size, cmock_retval) +void scmi_notification_notify_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int protocol_id, unsigned int operation_id, unsigned int scmi_response_message_id, void* payload_p2a, size_t payload_size, int cmock_to_return); +typedef int (* CMOCK_scmi_notification_notify_CALLBACK)(unsigned int protocol_id, unsigned int operation_id, unsigned int scmi_response_message_id, void* payload_p2a, size_t payload_size, int cmock_num_calls); +void scmi_notification_notify_AddCallback(CMOCK_scmi_notification_notify_CALLBACK Callback); +void scmi_notification_notify_Stub(CMOCK_scmi_notification_notify_CALLBACK Callback); +#define scmi_notification_notify_StubWithCallback scmi_notification_notify_Stub +#define scmi_notification_notify_ExpectWithArrayAndReturn(protocol_id, operation_id, scmi_response_message_id, payload_p2a, payload_p2a_Depth, payload_size, cmock_retval) scmi_notification_notify_CMockExpectWithArrayAndReturn(__LINE__, protocol_id, operation_id, scmi_response_message_id, payload_p2a, payload_p2a_Depth, payload_size, cmock_retval) +void scmi_notification_notify_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int protocol_id, unsigned int operation_id, unsigned int scmi_response_message_id, void* payload_p2a, int payload_p2a_Depth, size_t payload_size, int cmock_to_return); +#define scmi_notification_notify_ReturnThruPtr_payload_p2a(payload_p2a) scmi_notification_notify_CMockReturnMemThruPtr_payload_p2a(__LINE__, payload_p2a, sizeof(void)) +#define scmi_notification_notify_ReturnArrayThruPtr_payload_p2a(payload_p2a, cmock_len) scmi_notification_notify_CMockReturnMemThruPtr_payload_p2a(__LINE__, payload_p2a, cmock_len * sizeof(*payload_p2a)) +#define scmi_notification_notify_ReturnMemThruPtr_payload_p2a(payload_p2a, cmock_size) scmi_notification_notify_CMockReturnMemThruPtr_payload_p2a(__LINE__, payload_p2a, cmock_size) +void scmi_notification_notify_CMockReturnMemThruPtr_payload_p2a(UNITY_LINE_TYPE cmock_line, void* payload_p2a, size_t cmock_size); +#define scmi_notification_notify_IgnoreArg_protocol_id() scmi_notification_notify_CMockIgnoreArg_protocol_id(__LINE__) +void scmi_notification_notify_CMockIgnoreArg_protocol_id(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_notify_IgnoreArg_operation_id() scmi_notification_notify_CMockIgnoreArg_operation_id(__LINE__) +void scmi_notification_notify_CMockIgnoreArg_operation_id(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_notify_IgnoreArg_scmi_response_message_id() scmi_notification_notify_CMockIgnoreArg_scmi_response_message_id(__LINE__) +void scmi_notification_notify_CMockIgnoreArg_scmi_response_message_id(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_notify_IgnoreArg_payload_p2a() scmi_notification_notify_CMockIgnoreArg_payload_p2a(__LINE__) +void scmi_notification_notify_CMockIgnoreArg_payload_p2a(UNITY_LINE_TYPE cmock_line); +#define scmi_notification_notify_IgnoreArg_payload_size() scmi_notification_notify_CMockIgnoreArg_payload_size(__LINE__) +void scmi_notification_notify_CMockIgnoreArg_payload_size(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 diff --git a/module/scmi_clock/test/mod_scmi_clock_extra.h b/module/scmi_clock/test/mod_scmi_clock_extra.h index 3eb68d519..f7ec79de5 100644 --- a/module/scmi_clock/test/mod_scmi_clock_extra.h +++ b/module/scmi_clock/test/mod_scmi_clock_extra.h @@ -289,4 +289,29 @@ int mod_res_permissions_api_agent_reset_config(uint32_t agent_id, uint32_t flags * supported. * \return One of the standard framework error codes. */ -int mod_clock_api_get_state(fwk_id_t clock_id, enum mod_clock_state *state); \ No newline at end of file +int mod_clock_api_get_state(fwk_id_t clock_id, enum mod_clock_state *state); + +int scmi_notification_init( + unsigned int protocol_id, + unsigned int agent_count, + unsigned int element_count, + unsigned int operation_count); + +int scmi_notification_add_subscriber( + unsigned int protocol_id, + unsigned int element_idx, + unsigned int operation_id, + fwk_id_t service_id); + +int scmi_notification_remove_subscriber( + unsigned int protocol_id, + unsigned int agent_idx, + unsigned int element_idx, + unsigned int operation_id); + +int scmi_notification_notify( + unsigned int protocol_id, + unsigned int operation_id, + unsigned int scmi_response_message_id, + void *payload_p2a, + size_t payload_size); diff --git a/module/scmi_clock/test/mod_scmi_clock_unit_test.c b/module/scmi_clock/test/mod_scmi_clock_unit_test.c index 0703d522b..fe3848499 100644 --- a/module/scmi_clock/test/mod_scmi_clock_unit_test.c +++ b/module/scmi_clock/test/mod_scmi_clock_unit_test.c @@ -62,6 +62,13 @@ struct mod_res_permissions_api perm_api = { }; #endif +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS +static const struct mod_scmi_notification_api scmi_notification_api = { + .scmi_notification_add_subscriber = scmi_notification_add_subscriber, + .scmi_notification_remove_subscriber = scmi_notification_remove_subscriber, +}; +#endif + void assert_clock_state_and_ref_count_meets_expectations(void) { TEST_ASSERT_EQUAL_INT8_ARRAY( @@ -133,6 +140,10 @@ void setUp(void) scmi_clock_ctx.res_perms_api = &perm_api; #endif +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + scmi_clock_ctx.scmi_notification_api = &scmi_notification_api; +#endif + scmi_clock_ctx.dev_clock_ref_count_table = dev_clock_ref_count_table; scmi_clock_ctx.agent_clock_state_table = agent_clock_state_table; memcpy( @@ -156,6 +167,8 @@ void setUp(void) void tearDown(void) { + Mockmod_scmi_clock_extra_Verify(); + Mockmod_scmi_clock_extra_Destroy(); Mockfwk_core_internal_Verify(); Mockfwk_core_internal_Destroy(); } @@ -1207,6 +1220,196 @@ void test_scmi_clock_name_get_handler_extended_name_not_supported(void) TEST_ASSERT_EQUAL(FWK_SUCCESS, status); } +int rate_notify_invalid_param_callback( + fwk_id_t service_id, + const void *payload, + size_t size, + int NumCalls +) +{ + struct scmi_clock_rate_notify_p2a *return_values; + return_values = (struct scmi_clock_rate_notify_p2a *)payload; + + TEST_ASSERT_EQUAL((int32_t)SCMI_NOT_FOUND, return_values->status); + + return FWK_SUCCESS; +} + +void test_clock_rate_changed_notify_handler_invalid_agent_id(void) +{ + int status; + unsigned int agent_id = FAKE_SCMI_AGENT_IDX_COUNT; + fwk_id_t service_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_IDX, agent_id); + + struct scmi_clock_rate_notify_a2p payload = { + .clock_id = SCMI_CLOCK_OSPM0_IDX1, + .notify_enable = true, + }; + + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + + mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + + mod_scmi_from_protocol_api_respond_Stub(rate_notify_invalid_param_callback); + + status = scmi_clock_message_handler( + (fwk_id_t)MOD_SCMI_PROTOCOL_ID_CLOCK, + service_id, + (const uint32_t *)&payload, + payload_size_table[MOD_SCMI_CLOCK_RATE_NOTIFY], + MOD_SCMI_CLOCK_RATE_NOTIFY); + + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void test_clock_rate_changed_notify_handler_invalid_clock_id(void) +{ + int status; + unsigned int agent_id = FAKE_SCMI_AGENT_IDX_OSPM0; + fwk_id_t service_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_IDX, agent_id); + + struct scmi_clock_rate_notify_a2p payload = { + .clock_id = SCMI_CLOCK_OSPM0_COUNT, + .notify_enable = true, + }; + + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + + mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + + mod_scmi_from_protocol_api_respond_Stub(rate_notify_invalid_param_callback); + + status = scmi_clock_message_handler( + (fwk_id_t)MOD_SCMI_PROTOCOL_ID_CLOCK, + service_id, + (const uint32_t *)&payload, + payload_size_table[MOD_SCMI_CLOCK_RATE_NOTIFY], + MOD_SCMI_CLOCK_RATE_NOTIFY); + + TEST_ASSERT_EQUAL(FWK_E_RANGE, status); +} + +int scmi_notification_add_subscriber_rate_changed_callback( + unsigned int protocol_id, + unsigned int clock_id, + unsigned int command_id, + fwk_id_t service_id, + int NumCalls +) +{ + fwk_id_t expected_service_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_IDX, FAKE_SCMI_AGENT_IDX_OSPM0); + + TEST_ASSERT_EQUAL(MOD_SCMI_PROTOCOL_ID_CLOCK, protocol_id); + TEST_ASSERT_EQUAL(SCMI_CLOCK_OSPM0_IDX1, clock_id); + TEST_ASSERT_EQUAL(MOD_SCMI_CLOCK_RATE_NOTIFY, command_id); + TEST_ASSERT_EQUAL(expected_service_id.value, service_id.value); + + return FWK_SUCCESS; +} + +void test_clock_rate_changed_notify_handler_add_subscriber(void) +{ + int status; + unsigned int agent_id = FAKE_SCMI_AGENT_IDX_OSPM0; + fwk_id_t service_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_IDX, agent_id); + + struct scmi_clock_rate_notify_a2p payload = { + .clock_id = SCMI_CLOCK_OSPM0_IDX1, + .notify_enable = true, + }; + + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + fwk_module_is_valid_element_id_ExpectAnyArgsAndReturn(true); + fwk_id_get_element_idx_ExpectAnyArgsAndReturn(SCMI_CLOCK_OSPM0_IDX1); + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + + mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + + scmi_notification_add_subscriber_Stub( + scmi_notification_add_subscriber_rate_changed_callback); + + mod_scmi_from_protocol_api_respond_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + status = scmi_clock_message_handler( + (fwk_id_t)MOD_SCMI_PROTOCOL_ID_CLOCK, + service_id, + (const uint32_t *)&payload, + payload_size_table[MOD_SCMI_CLOCK_RATE_NOTIFY], + MOD_SCMI_CLOCK_RATE_NOTIFY); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +int scmi_notification_remove_subscriber_rate_changed_callback( + unsigned int protocol_id, + unsigned int agent_id, + unsigned int clock_id, + unsigned int command_id, + int NumCalls +) +{ + TEST_ASSERT_EQUAL(MOD_SCMI_PROTOCOL_ID_CLOCK, protocol_id); + TEST_ASSERT_EQUAL(FAKE_SCMI_AGENT_IDX_OSPM0, agent_id); + TEST_ASSERT_EQUAL(SCMI_CLOCK_OSPM0_IDX1, clock_id); + TEST_ASSERT_EQUAL(MOD_SCMI_CLOCK_RATE_NOTIFY, command_id); + + return FWK_SUCCESS; +} + +void test_clock_rate_changed_notify_handler_remove_subscriber(void) +{ + int status; + unsigned int agent_id = FAKE_SCMI_AGENT_IDX_OSPM0; + fwk_id_t service_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_IDX, agent_id); + + struct scmi_clock_rate_notify_a2p payload = { + .clock_id = SCMI_CLOCK_OSPM0_IDX1, + .notify_enable = false, + }; + + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + fwk_module_is_valid_element_id_ExpectAnyArgsAndReturn(true); + fwk_id_get_element_idx_ExpectAnyArgsAndReturn(SCMI_CLOCK_OSPM0_IDX1); + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + + mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + + scmi_notification_remove_subscriber_Stub( + scmi_notification_remove_subscriber_rate_changed_callback); + + mod_scmi_from_protocol_api_respond_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + status = scmi_clock_message_handler( + (fwk_id_t)MOD_SCMI_PROTOCOL_ID_CLOCK, + service_id, + (const uint32_t *)&payload, + payload_size_table[MOD_SCMI_CLOCK_RATE_NOTIFY], + MOD_SCMI_CLOCK_RATE_NOTIFY); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + int scmi_test_main(void) { UNITY_BEGIN(); @@ -1249,6 +1452,12 @@ int scmi_test_main(void) RUN_TEST(test_process_request_event_get_clock_extended_name); RUN_TEST(test_scmi_clock_name_get_handler_success); RUN_TEST(test_scmi_clock_name_get_handler_extended_name_not_supported); +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS + RUN_TEST(test_clock_rate_changed_notify_handler_invalid_agent_id); + RUN_TEST(test_clock_rate_changed_notify_handler_invalid_clock_id); + RUN_TEST(test_clock_rate_changed_notify_handler_add_subscriber); + RUN_TEST(test_clock_rate_changed_notify_handler_remove_subscriber); +#endif #endif return UNITY_END(); -- GitLab From 089885d1efe8ba8688e23e4ae77d2b7b968d8fda Mon Sep 17 00:00:00 2001 From: Md Golam Tanvir Zim Date: Tue, 18 Jun 2024 15:01:58 +0100 Subject: [PATCH 11/16] scmi_clock: Add Unit Test for CLOCK_RATE_CHANGE_REQUESTED_NOTIFY This adds unit test cases for CLOCK_RATE_CHANGE_REQUESTED_NOTIFY command. Signed-off-by: Md Golam Tanvir Zim Change-Id: I8db3c9710ef6d410bf1e2568838838dba4d0f7ed --- .../test/mod_scmi_clock_unit_test.c | 118 ++++++++++++++++++ 1 file changed, 118 insertions(+) diff --git a/module/scmi_clock/test/mod_scmi_clock_unit_test.c b/module/scmi_clock/test/mod_scmi_clock_unit_test.c index fe3848499..8ba0f868a 100644 --- a/module/scmi_clock/test/mod_scmi_clock_unit_test.c +++ b/module/scmi_clock/test/mod_scmi_clock_unit_test.c @@ -1410,6 +1410,119 @@ void test_clock_rate_changed_notify_handler_remove_subscriber(void) TEST_ASSERT_EQUAL(FWK_SUCCESS, status); } +int scmi_notification_add_subscriber_change_requested_callback( + unsigned int protocol_id, + unsigned int clock_id, + unsigned int command_id, + fwk_id_t service_id, + int NumCalls +) +{ + fwk_id_t expected_service_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_IDX, FAKE_SCMI_AGENT_IDX_OSPM0); + + TEST_ASSERT_EQUAL(MOD_SCMI_PROTOCOL_ID_CLOCK, protocol_id); + TEST_ASSERT_EQUAL(SCMI_CLOCK_OSPM0_IDX1, clock_id); + TEST_ASSERT_EQUAL(MOD_SCMI_CLOCK_RATE_CHANGE_REQUESTED_NOTIFY, command_id); + TEST_ASSERT_EQUAL(expected_service_id.value, service_id.value); + + return FWK_SUCCESS; +} + +void test_clock_rate_change_requested_notify_handler_add_subscriber(void) +{ + int status; + unsigned int agent_id = FAKE_SCMI_AGENT_IDX_OSPM0; + fwk_id_t service_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_IDX, agent_id); + + struct scmi_clock_rate_notify_a2p payload = { + .clock_id = SCMI_CLOCK_OSPM0_IDX1, + .notify_enable = true, + }; + + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + fwk_module_is_valid_element_id_ExpectAnyArgsAndReturn(true); + + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + + mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + + scmi_notification_add_subscriber_Stub( + scmi_notification_add_subscriber_change_requested_callback); + + mod_scmi_from_protocol_api_respond_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + status = scmi_clock_message_handler( + (fwk_id_t)MOD_SCMI_PROTOCOL_ID_CLOCK, + service_id, + (const uint32_t *)&payload, + payload_size_table[MOD_SCMI_CLOCK_RATE_CHANGE_REQUESTED_NOTIFY], + MOD_SCMI_CLOCK_RATE_CHANGE_REQUESTED_NOTIFY); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +int scmi_notification_remove_subscriber_change_requested_callback( + unsigned int protocol_id, + unsigned int agent_id, + unsigned int clock_id, + unsigned int command_id, + int NumCalls +) +{ + TEST_ASSERT_EQUAL(MOD_SCMI_PROTOCOL_ID_CLOCK, protocol_id); + TEST_ASSERT_EQUAL(FAKE_SCMI_AGENT_IDX_OSPM0, agent_id); + TEST_ASSERT_EQUAL(SCMI_CLOCK_OSPM0_IDX1, clock_id); + TEST_ASSERT_EQUAL(MOD_SCMI_CLOCK_RATE_CHANGE_REQUESTED_NOTIFY, command_id); + + return FWK_SUCCESS; +} + +void test_clock_rate_change_requested_notify_handler_remove_subscriber(void) +{ + int status; + unsigned int agent_id = FAKE_SCMI_AGENT_IDX_OSPM0; + fwk_id_t service_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_IDX, agent_id); + + struct scmi_clock_rate_notify_a2p payload = { + .clock_id = SCMI_CLOCK_OSPM0_IDX1, + .notify_enable = false, + }; + + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + fwk_module_is_valid_element_id_ExpectAnyArgsAndReturn(true); + + mod_scmi_from_protocol_api_get_agent_id_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + mod_scmi_from_protocol_api_get_agent_id_ReturnThruPtr_agent_id(&agent_id); + + mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( + FWK_SUCCESS); + + scmi_notification_remove_subscriber_Stub( + scmi_notification_remove_subscriber_change_requested_callback); + + mod_scmi_from_protocol_api_respond_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + status = scmi_clock_message_handler( + (fwk_id_t)MOD_SCMI_PROTOCOL_ID_CLOCK, + service_id, + (const uint32_t *)&payload, + payload_size_table[MOD_SCMI_CLOCK_RATE_CHANGE_REQUESTED_NOTIFY], + MOD_SCMI_CLOCK_RATE_CHANGE_REQUESTED_NOTIFY); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + int scmi_test_main(void) { UNITY_BEGIN(); @@ -1457,6 +1570,11 @@ int scmi_test_main(void) RUN_TEST(test_clock_rate_changed_notify_handler_invalid_clock_id); RUN_TEST(test_clock_rate_changed_notify_handler_add_subscriber); RUN_TEST(test_clock_rate_changed_notify_handler_remove_subscriber); + + RUN_TEST( + test_clock_rate_change_requested_notify_handler_add_subscriber); + RUN_TEST( + test_clock_rate_change_requested_notify_handler_remove_subscriber); #endif #endif -- GitLab From f44b09321ed2e6029b0a6e71105086c3aa972cc3 Mon Sep 17 00:00:00 2001 From: Md Golam Tanvir Zim Date: Wed, 19 Jun 2024 16:22:26 +0100 Subject: [PATCH 12/16] scmi_clock: Add Unit Test for CLOCK_RATE_CHANGED notification This patch adds a unit test case for CLOCK_RATE_CHANGED scmi notification. Signed-off-by: Md Golam Tanvir Zim Change-Id: I771f1b28d40aace2afe9055afab827021606f2ae --- .../test/mod_scmi_clock_unit_test.c | 72 +++++++++++++++++++ 1 file changed, 72 insertions(+) diff --git a/module/scmi_clock/test/mod_scmi_clock_unit_test.c b/module/scmi_clock/test/mod_scmi_clock_unit_test.c index 8ba0f868a..4ff3eb71d 100644 --- a/module/scmi_clock/test/mod_scmi_clock_unit_test.c +++ b/module/scmi_clock/test/mod_scmi_clock_unit_test.c @@ -66,6 +66,7 @@ struct mod_res_permissions_api perm_api = { static const struct mod_scmi_notification_api scmi_notification_api = { .scmi_notification_add_subscriber = scmi_notification_add_subscriber, .scmi_notification_remove_subscriber = scmi_notification_remove_subscriber, + .scmi_notification_notify = scmi_notification_notify, }; #endif @@ -1523,6 +1524,74 @@ void test_clock_rate_change_requested_notify_handler_remove_subscriber(void) TEST_ASSERT_EQUAL(FWK_SUCCESS, status); } +#ifdef BUILD_HAS_SCMI_NOTIFICATIONS +int scmi_notification_notify_rate_changed_callback( + unsigned int protocol_id, + unsigned int operation_id, + unsigned int scmi_response_id, + void *payload_p2a, + size_t payload_size, + int NumCalls +) +{ + struct scmi_clock_rate_notification_message_p2a *message = payload_p2a; + + TEST_ASSERT_EQUAL(MOD_SCMI_PROTOCOL_ID_CLOCK, protocol_id); + TEST_ASSERT_EQUAL(MOD_SCMI_CLOCK_RATE_NOTIFY, operation_id); + TEST_ASSERT_EQUAL(SCMI_CLOCK_RATE_CHANGED, scmi_response_id); + + TEST_ASSERT_EQUAL(FAKE_SCMI_AGENT_IDX_OSPM1, message->agent_id); + TEST_ASSERT_EQUAL(SCMI_CLOCK_OSPM1_IDX0, message->clock_id); + TEST_ASSERT_EQUAL(0x0000000A, message->rate[0]); + TEST_ASSERT_EQUAL(0x0000000B, message->rate[1]); + + return FWK_SUCCESS; +} + +unsigned int get_element_idx( + fwk_id_t clock_id +) +{ + return clock_id.element.element_idx; +} + +unsigned int get_element_idx_callback( + fwk_id_t clock_id, + int NumCalls) +{ + return get_element_idx(clock_id); +} + +void test_mod_scmi_clock_process_notification_rate_changed(void) +{ + int status; + unsigned int agent_id, clock_idx; + agent_id = FAKE_SCMI_AGENT_IDX_OSPM1; + clock_idx = CLOCK_DEV_IDX_FAKE3; + fwk_id_t clock_id = FWK_ID_ELEMENT(FWK_MODULE_IDX_CLOCK, clock_idx); + struct fwk_event notification_event, resp_event; + struct mod_clock_notification_params *notification_params = + ((struct mod_clock_notification_params *)notification_event.params); + + notification_event.id = FWK_ID_NOTIFICATION( + FWK_MODULE_IDX_CLOCK, MOD_CLOCK_NOTIFICATION_IDX_RATE_CHANGED); + notification_params->clock_id = clock_id; + notification_params->requester_id = agent_id; + notification_params->rate = (uint64_t) 0x0000000B0000000A; + + fwk_id_get_notification_idx_ExpectAnyArgsAndReturn( + MOD_CLOCK_NOTIFICATION_IDX_RATE_CHANGED); + fwk_id_get_element_idx_Stub(get_element_idx_callback); + + scmi_notification_notify_Stub( + scmi_notification_notify_rate_changed_callback); + + status = scmi_clock_process_notification(¬ification_event, &resp_event); + + TEST_ASSERT_EQUAL(status, FWK_SUCCESS); +} +#endif + int scmi_test_main(void) { UNITY_BEGIN(); @@ -1575,6 +1644,9 @@ int scmi_test_main(void) test_clock_rate_change_requested_notify_handler_add_subscriber); RUN_TEST( test_clock_rate_change_requested_notify_handler_remove_subscriber); + + RUN_TEST( + test_mod_scmi_clock_process_notification_rate_changed); #endif #endif -- GitLab From 01879ad698eeead99b8edbf9ba047f08bb23867b Mon Sep 17 00:00:00 2001 From: Md Golam Tanvir Zim Date: Wed, 19 Jun 2024 17:16:26 +0100 Subject: [PATCH 13/16] scmi_clock: Add UT for CLOCK_RATE_CHANGE_REQUESTED notification This patch adds a unit test case for CLOCK_RATE_CHANGE_REQUESTED notification. Signed-off-by: Md Golam Tanvir Zim Change-Id: Icb8c4dcc7af7e715dd21c03f09fcbc4bb543b637 --- .../test/mod_scmi_clock_unit_test.c | 56 +++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/module/scmi_clock/test/mod_scmi_clock_unit_test.c b/module/scmi_clock/test/mod_scmi_clock_unit_test.c index 4ff3eb71d..b98c25f48 100644 --- a/module/scmi_clock/test/mod_scmi_clock_unit_test.c +++ b/module/scmi_clock/test/mod_scmi_clock_unit_test.c @@ -1590,6 +1590,60 @@ void test_mod_scmi_clock_process_notification_rate_changed(void) TEST_ASSERT_EQUAL(status, FWK_SUCCESS); } + +int scmi_notification_notify_rate_change_requested_callback( + unsigned int protocol_id, + unsigned int operation_id, + unsigned int scmi_response_id, + void *payload_p2a, + size_t payload_size, + int NumCalls +) +{ + struct scmi_clock_rate_notification_message_p2a *message = payload_p2a; + + TEST_ASSERT_EQUAL(MOD_SCMI_PROTOCOL_ID_CLOCK, protocol_id); + TEST_ASSERT_EQUAL(MOD_SCMI_CLOCK_RATE_CHANGE_REQUESTED_NOTIFY, + operation_id); + TEST_ASSERT_EQUAL(SCMI_CLOCK_RATE_CHANGE_REQUESTED, scmi_response_id); + + TEST_ASSERT_EQUAL(FAKE_SCMI_AGENT_IDX_OSPM1, message->agent_id); + TEST_ASSERT_EQUAL(SCMI_CLOCK_OSPM1_IDX0, message->clock_id); + TEST_ASSERT_EQUAL(0x0000000C, message->rate[0]); + TEST_ASSERT_EQUAL(0x0000000D, message->rate[1]); + + return FWK_SUCCESS; +} + +void test_mod_scmi_clock_process_notification_rate_change_requested(void) +{ + int status; + unsigned int agent_id, clock_idx; + agent_id = FAKE_SCMI_AGENT_IDX_OSPM1; + clock_idx = CLOCK_DEV_IDX_FAKE3; + fwk_id_t clock_id = FWK_ID_ELEMENT(FWK_MODULE_IDX_CLOCK, clock_idx); + struct fwk_event notification_event, resp_event; + struct mod_clock_notification_params *notification_params = + ((struct mod_clock_notification_params *)notification_event.params); + + notification_event.id = FWK_ID_NOTIFICATION( + FWK_MODULE_IDX_CLOCK, + MOD_CLOCK_NOTIFICATION_IDX_RATE_CHANGE_REQUESTED); + notification_params->clock_id = clock_id; + notification_params->requester_id = agent_id; + notification_params->rate = (uint64_t) 0x0000000D0000000C; + + fwk_id_get_notification_idx_ExpectAnyArgsAndReturn( + MOD_CLOCK_NOTIFICATION_IDX_RATE_CHANGE_REQUESTED); + fwk_id_get_element_idx_Stub(get_element_idx_callback); + + scmi_notification_notify_Stub( + scmi_notification_notify_rate_change_requested_callback); + + status = scmi_clock_process_notification(¬ification_event, &resp_event); + + TEST_ASSERT_EQUAL(status, FWK_SUCCESS); +} #endif int scmi_test_main(void) @@ -1647,6 +1701,8 @@ int scmi_test_main(void) RUN_TEST( test_mod_scmi_clock_process_notification_rate_changed); + RUN_TEST( + test_mod_scmi_clock_process_notification_rate_change_requested); #endif #endif -- GitLab From bff0f8ecf696c2177247dd34b330e79b1fa6fab0 Mon Sep 17 00:00:00 2001 From: Md Golam Tanvir Zim Date: Fri, 2 Aug 2024 18:34:50 +0100 Subject: [PATCH 14/16] scmi_clock: Add Unit Test for scmi clock module functions This patch adds unit test cases for start and bind functions for scmi clock module. Signed-off-by: Md Golam Tanvir Zim Change-Id: Iddfc2d530d5402eb99a3ce604b830dacaf12310c --- .../test/mod_scmi_clock_unit_test.c | 77 +++++++++++++++++++ 1 file changed, 77 insertions(+) diff --git a/module/scmi_clock/test/mod_scmi_clock_unit_test.c b/module/scmi_clock/test/mod_scmi_clock_unit_test.c index b98c25f48..7dab13dec 100644 --- a/module/scmi_clock/test/mod_scmi_clock_unit_test.c +++ b/module/scmi_clock/test/mod_scmi_clock_unit_test.c @@ -15,6 +15,7 @@ # include # include # include +# include # include #endif #include @@ -64,6 +65,7 @@ struct mod_res_permissions_api perm_api = { #ifdef BUILD_HAS_SCMI_NOTIFICATIONS static const struct mod_scmi_notification_api scmi_notification_api = { + .scmi_notification_init = scmi_notification_init, .scmi_notification_add_subscriber = scmi_notification_add_subscriber, .scmi_notification_remove_subscriber = scmi_notification_remove_subscriber, .scmi_notification_notify = scmi_notification_notify, @@ -1644,6 +1646,78 @@ void test_mod_scmi_clock_process_notification_rate_change_requested(void) TEST_ASSERT_EQUAL(status, FWK_SUCCESS); } + +void test_mod_scmi_clock_start() +{ + int status; + fwk_id_t module_id = FWK_ID_MODULE_INIT(FWK_MODULE_IDX_SCMI_CLOCK); + + fwk_notification_subscribe_ExpectAndReturn( + mod_clock_notification_id_rate_changed, + FWK_ID_MODULE(FWK_MODULE_IDX_CLOCK), + module_id, + FWK_SUCCESS); + + fwk_notification_subscribe_ExpectAndReturn( + mod_clock_notification_id_rate_change_requested, + FWK_ID_MODULE(FWK_MODULE_IDX_CLOCK), + module_id, + FWK_SUCCESS); + + mod_scmi_from_protocol_api_get_agent_count_ExpectAndReturn( + (unsigned int *) &scmi_clock_ctx.config->agent_count, + FWK_SUCCESS); + + scmi_notification_init_ExpectAndReturn( + MOD_SCMI_PROTOCOL_ID_CLOCK, + scmi_clock_ctx.config->agent_count, + scmi_clock_ctx.clock_devices, + MOD_SCMI_CLOCK_NOTIFICATION_COUNT, + FWK_SUCCESS); + + status = scmi_clock_start(module_id); + + TEST_ASSERT_EQUAL(status, FWK_SUCCESS); +} + +void test_mod_scmi_clock_bind(void) +{ + int status; + fwk_id_t mod_scmi_clock_id = FWK_ID_MODULE_INIT(FWK_MODULE_IDX_SCMI_CLOCK); + fwk_id_t mod_scmi_id = FWK_ID_MODULE(FWK_MODULE_IDX_SCMI); + fwk_id_t mod_clock_id = FWK_ID_MODULE(FWK_MODULE_IDX_CLOCK); + + fwk_id_t mod_scmi_api_protocol = + FWK_ID_API(FWK_MODULE_IDX_SCMI, + MOD_SCMI_API_IDX_PROTOCOL); + + fwk_id_t mod_scmi_api_notification = + FWK_ID_API(FWK_MODULE_IDX_SCMI, + MOD_SCMI_API_IDX_NOTIFICATION); + + fwk_id_t mod_clock_api = + FWK_ID_API(FWK_MODULE_IDX_CLOCK, + 0); + + fwk_module_bind_ExpectAndReturn(mod_scmi_id, + mod_scmi_api_protocol, + &scmi_clock_ctx.scmi_api, + FWK_SUCCESS); + + fwk_module_bind_ExpectAndReturn(mod_scmi_id, + mod_scmi_api_notification, + &scmi_clock_ctx.scmi_notification_api, + FWK_SUCCESS); + + fwk_module_bind_ExpectAndReturn(mod_clock_id, + mod_clock_api, + &scmi_clock_ctx.clock_api, + FWK_SUCCESS); + + status = scmi_clock_bind(mod_scmi_clock_id, 0); + + TEST_ASSERT_EQUAL(status, FWK_SUCCESS); +} #endif int scmi_test_main(void) @@ -1703,6 +1777,9 @@ int scmi_test_main(void) test_mod_scmi_clock_process_notification_rate_changed); RUN_TEST( test_mod_scmi_clock_process_notification_rate_change_requested); + + RUN_TEST(test_mod_scmi_clock_start); + RUN_TEST(test_mod_scmi_clock_bind); #endif #endif -- GitLab From d2759e1dcaa470e127c0fd4c5590d4bb21c66d56 Mon Sep 17 00:00:00 2001 From: Md Golam Tanvir Zim Date: Tue, 6 Aug 2024 17:49:41 +0100 Subject: [PATCH 15/16] dvfs: Add Unit test for set rate functions This patch adds unit test cases for clock set rate functions. Signed-off-by: Md Golam Tanvir Zim Change-Id: I6b772525981826ed1e2278b1614fa03cd2811af0 --- module/dvfs/include/mod_dvfs.h | 94 +++++ module/dvfs/src/mod_dvfs.c | 94 ----- module/dvfs/test/mocks/.clang-format | 4 + module/dvfs/test/mocks/Mockmod_dvfs_extra.c | 399 ++++++++++++++++++++ module/dvfs/test/mocks/Mockmod_dvfs_extra.h | 70 ++++ module/dvfs/test/mod_dvfs_extra.h | 55 +++ module/dvfs/test/mod_dvfs_unit_test.c | 93 ++++- 7 files changed, 714 insertions(+), 95 deletions(-) create mode 100644 module/dvfs/test/mocks/.clang-format create mode 100644 module/dvfs/test/mocks/Mockmod_dvfs_extra.c create mode 100644 module/dvfs/test/mocks/Mockmod_dvfs_extra.h create mode 100644 module/dvfs/test/mod_dvfs_extra.h diff --git a/module/dvfs/include/mod_dvfs.h b/module/dvfs/include/mod_dvfs.h index d2ff518b2..cf2b78c45 100644 --- a/module/dvfs/include/mod_dvfs.h +++ b/module/dvfs/include/mod_dvfs.h @@ -15,6 +15,31 @@ #include #include +/*! + * \brief Domain states for GET_OPP/SET_OPP. + */ +enum mod_dvfs_domain_state { + DVFS_DOMAIN_STATE_IDLE = 0, + + /* Waiting for GET_OPP request */ + DVFS_DOMAIN_GET_OPP, + + /* Waiting for SET_OPP request */ + DVFS_DOMAIN_SET_OPP, + + /* set_rate() in progress, set_voltage() next */ + DVFS_DOMAIN_SET_VOLTAGE, + + /* set_voltage() in progress, set_frequency() next */ + DVFS_DOMAIN_SET_FREQUENCY, + + /* waiting for SET_OPP to complete */ + DVFS_DOMAIN_SET_OPP_DONE, + + /* waiting for alarm callback to start a retry */ + DVFS_DOMAIN_STATE_RETRY, +}; + /*! * \ingroup GroupModules * \defgroup GroupDvfs Dynamic Voltage and Frequency Scaling (DVFS) @@ -88,6 +113,75 @@ struct mod_dvfs_domain_config { struct mod_dvfs_opp *opps; }; +/*! + * \brief Request for SET_OPP. + */ +struct mod_dvfs_request { + /* New operating point data for the request */ + struct mod_dvfs_opp new_opp; + + /* Context-specific value */ + uintptr_t cookie; + + /* Response expected for this request */ + bool response_required; + + /* Retry the request on failure */ + bool retry_request; + + /* This request requires the event source_id to be set */ + bool set_source_id; + + /* Retry count */ + uint8_t num_retries; +}; + +/*! + * \brief Domain context. + */ +struct mod_dvfs_domain_ctx { + /* Context Domain ID */ + fwk_id_t domain_id; + + /* Bound ID of requester to this domain */ + fwk_id_t bound_id; + + /* Domain configuration */ + const struct mod_dvfs_domain_config *config; + + struct { + /* Power supply API */ + const struct mod_psu_device_api *psu; + + /* Clock API */ + const struct mod_clock_api *clock; + + /* Alarm API for pending requests */ + const struct mod_timer_alarm_api *alarm_api; + } apis; + + /* Number of operating points */ + size_t opp_count; + + /* Current operating point */ + struct mod_dvfs_opp current_opp; + + /* Current request details */ + struct mod_dvfs_request request; + + /* State */ + enum mod_dvfs_domain_state state; + + /* Cookie for deferred request response */ + uint32_t cookie; + + /* Pending request details */ + struct mod_dvfs_request pending_request; + + /* SET_OPP Request is pending for this domain */ + bool request_pending; +}; + /*! * \} */ diff --git a/module/dvfs/src/mod_dvfs.c b/module/dvfs/src/mod_dvfs.c index e312b4bb2..f3ac4208a 100644 --- a/module/dvfs/src/mod_dvfs.c +++ b/module/dvfs/src/mod_dvfs.c @@ -42,100 +42,6 @@ enum mod_dvfs_internal_event_idx { static const fwk_id_t mod_dvfs_event_id_retry = FWK_ID_EVENT_INIT(FWK_MODULE_IDX_DVFS, MOD_DVFS_INTERNAL_EVENT_IDX_RETRY); -/*! - * \brief Domain states for GET_OPP/SET_OPP. - */ -enum mod_dvfs_domain_state { - DVFS_DOMAIN_STATE_IDLE = 0, - - /* Waiting for GET_OPP request */ - DVFS_DOMAIN_GET_OPP, - - /* Waiting for SET_OPP request */ - DVFS_DOMAIN_SET_OPP, - - /* set_rate() in progress, set_voltage() next */ - DVFS_DOMAIN_SET_VOLTAGE, - - /* set_voltage() in progress, set_frequency() next */ - DVFS_DOMAIN_SET_FREQUENCY, - - /* waiting for SET_OPP to complete */ - DVFS_DOMAIN_SET_OPP_DONE, - - /* waiting for alarm callback to start a retry */ - DVFS_DOMAIN_STATE_RETRY, -}; - -/*! - * \brief Request for SET_OPP. - */ -struct mod_dvfs_request { - /* New operating point data for the request */ - struct mod_dvfs_opp new_opp; - - /* Context-specific value */ - uintptr_t cookie; - - /* Response expected for this request */ - bool response_required; - - /* Retry the request on failure */ - bool retry_request; - - /* This request requires the event source_id to be set */ - bool set_source_id; - - /* Retry count */ - uint8_t num_retries; -}; - -/*! - * \brief Domain context. - */ -struct mod_dvfs_domain_ctx { - /* Context Domain ID */ - fwk_id_t domain_id; - - /* Bound ID of requester to this domain */ - fwk_id_t bound_id; - - /* Domain configuration */ - const struct mod_dvfs_domain_config *config; - - struct { - /* Power supply API */ - const struct mod_psu_device_api *psu; - - /* Clock API */ - const struct mod_clock_api *clock; - - /* Alarm API for pending requests */ - const struct mod_timer_alarm_api *alarm_api; - } apis; - - /* Number of operating points */ - size_t opp_count; - - /* Current operating point */ - struct mod_dvfs_opp current_opp; - - /* Current request details */ - struct mod_dvfs_request request; - - /* State */ - enum mod_dvfs_domain_state state; - - /* Cookie for deferred request response */ - uint32_t cookie; - - /* Pending request details */ - struct mod_dvfs_request pending_request; - - /* SET_OPP Request is pending for this domain */ - bool request_pending; -}; - static struct mod_dvfs_ctx { /* Number of DVFS domains */ uint32_t dvfs_domain_element_count; diff --git a/module/dvfs/test/mocks/.clang-format b/module/dvfs/test/mocks/.clang-format new file mode 100644 index 000000000..eeca2395f --- /dev/null +++ b/module/dvfs/test/mocks/.clang-format @@ -0,0 +1,4 @@ +{ + "DisableFormat": true, + "SortIncludes": false, +} diff --git a/module/dvfs/test/mocks/Mockmod_dvfs_extra.c b/module/dvfs/test/mocks/Mockmod_dvfs_extra.c new file mode 100644 index 000000000..6eddaea5b --- /dev/null +++ b/module/dvfs/test/mocks/Mockmod_dvfs_extra.c @@ -0,0 +1,399 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ +#include +#include +#include +#include "cmock.h" +#include "Mockmod_dvfs_extra.h" + +static const char* CMockString_clock_id = "clock_id"; +static const char* CMockString_device_id = "device_id"; +static const char* CMockString_mod_clock_api_set_rate = "mod_clock_api_set_rate"; +static const char* CMockString_mod_psu_device_api_set_voltage = "mod_psu_device_api_set_voltage"; +static const char* CMockString_rate = "rate"; +static const char* CMockString_requester_id = "requester_id"; +static const char* CMockString_round_mode = "round_mode"; +static const char* CMockString_voltage = "voltage"; + +typedef struct _CMOCK_mod_psu_device_api_set_voltage_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + fwk_id_t Expected_device_id; + uint32_t Expected_voltage; + char IgnoreArg_device_id; + char IgnoreArg_voltage; + +} CMOCK_mod_psu_device_api_set_voltage_CALL_INSTANCE; + +typedef struct _CMOCK_mod_clock_api_set_rate_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + fwk_id_t Expected_clock_id; + uint64_t Expected_rate; + enum mod_clock_round_mode Expected_round_mode; + unsigned int Expected_requester_id; + char IgnoreArg_clock_id; + char IgnoreArg_rate; + char IgnoreArg_round_mode; + char IgnoreArg_requester_id; + +} CMOCK_mod_clock_api_set_rate_CALL_INSTANCE; + +static struct Mockmod_dvfs_extraInstance +{ + char mod_psu_device_api_set_voltage_IgnoreBool; + int mod_psu_device_api_set_voltage_FinalReturn; + char mod_psu_device_api_set_voltage_CallbackBool; + CMOCK_mod_psu_device_api_set_voltage_CALLBACK mod_psu_device_api_set_voltage_CallbackFunctionPointer; + int mod_psu_device_api_set_voltage_CallbackCalls; + CMOCK_MEM_INDEX_TYPE mod_psu_device_api_set_voltage_CallInstance; + char mod_clock_api_set_rate_IgnoreBool; + int mod_clock_api_set_rate_FinalReturn; + char mod_clock_api_set_rate_CallbackBool; + CMOCK_mod_clock_api_set_rate_CALLBACK mod_clock_api_set_rate_CallbackFunctionPointer; + int mod_clock_api_set_rate_CallbackCalls; + CMOCK_MEM_INDEX_TYPE mod_clock_api_set_rate_CallInstance; +} Mock; + +extern jmp_buf AbortFrame; + +void Mockmod_dvfs_extra_Verify(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_MEM_INDEX_TYPE call_instance; + call_instance = Mock.mod_psu_device_api_set_voltage_CallInstance; + if (Mock.mod_psu_device_api_set_voltage_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_mod_psu_device_api_set_voltage); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.mod_psu_device_api_set_voltage_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.mod_clock_api_set_rate_CallInstance; + if (Mock.mod_clock_api_set_rate_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_mod_clock_api_set_rate); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.mod_clock_api_set_rate_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } +} + +void Mockmod_dvfs_extra_Init(void) +{ + Mockmod_dvfs_extra_Destroy(); +} + +void Mockmod_dvfs_extra_Destroy(void) +{ + CMock_Guts_MemFreeAll(); + memset(&Mock, 0, sizeof(Mock)); +} + +int mod_psu_device_api_set_voltage(fwk_id_t device_id, uint32_t voltage) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_mod_psu_device_api_set_voltage_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_mod_psu_device_api_set_voltage); + cmock_call_instance = (CMOCK_mod_psu_device_api_set_voltage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.mod_psu_device_api_set_voltage_CallInstance); + Mock.mod_psu_device_api_set_voltage_CallInstance = CMock_Guts_MemNext(Mock.mod_psu_device_api_set_voltage_CallInstance); + if (Mock.mod_psu_device_api_set_voltage_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.mod_psu_device_api_set_voltage_FinalReturn; + Mock.mod_psu_device_api_set_voltage_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.mod_psu_device_api_set_voltage_CallbackBool && + Mock.mod_psu_device_api_set_voltage_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.mod_psu_device_api_set_voltage_CallbackFunctionPointer(device_id, voltage, Mock.mod_psu_device_api_set_voltage_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_device_id) + { + UNITY_SET_DETAILS(CMockString_mod_psu_device_api_set_voltage,CMockString_device_id); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_device_id), (void*)(&device_id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_voltage) + { + UNITY_SET_DETAILS(CMockString_mod_psu_device_api_set_voltage,CMockString_voltage); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_voltage, voltage, cmock_line, CMockStringMismatch); + } + } + if (Mock.mod_psu_device_api_set_voltage_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.mod_psu_device_api_set_voltage_CallbackFunctionPointer(device_id, voltage, Mock.mod_psu_device_api_set_voltage_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_mod_psu_device_api_set_voltage(CMOCK_mod_psu_device_api_set_voltage_CALL_INSTANCE* cmock_call_instance, fwk_id_t device_id, uint32_t voltage); +void CMockExpectParameters_mod_psu_device_api_set_voltage(CMOCK_mod_psu_device_api_set_voltage_CALL_INSTANCE* cmock_call_instance, fwk_id_t device_id, uint32_t voltage) +{ + memcpy((void*)(&cmock_call_instance->Expected_device_id), (void*)(&device_id), + sizeof(fwk_id_t[sizeof(device_id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_device_id = 0; + cmock_call_instance->Expected_voltage = voltage; + cmock_call_instance->IgnoreArg_voltage = 0; +} + +void mod_psu_device_api_set_voltage_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mod_psu_device_api_set_voltage_CALL_INSTANCE)); + CMOCK_mod_psu_device_api_set_voltage_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_psu_device_api_set_voltage_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.mod_psu_device_api_set_voltage_CallInstance = CMock_Guts_MemChain(Mock.mod_psu_device_api_set_voltage_CallInstance, cmock_guts_index); + Mock.mod_psu_device_api_set_voltage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.mod_psu_device_api_set_voltage_IgnoreBool = (char)1; +} + +void mod_psu_device_api_set_voltage_CMockStopIgnore(void) +{ + if(Mock.mod_psu_device_api_set_voltage_IgnoreBool) + Mock.mod_psu_device_api_set_voltage_CallInstance = CMock_Guts_MemNext(Mock.mod_psu_device_api_set_voltage_CallInstance); + Mock.mod_psu_device_api_set_voltage_IgnoreBool = (char)0; +} + +void mod_psu_device_api_set_voltage_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mod_psu_device_api_set_voltage_CALL_INSTANCE)); + CMOCK_mod_psu_device_api_set_voltage_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_psu_device_api_set_voltage_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.mod_psu_device_api_set_voltage_CallInstance = CMock_Guts_MemChain(Mock.mod_psu_device_api_set_voltage_CallInstance, cmock_guts_index); + Mock.mod_psu_device_api_set_voltage_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 mod_psu_device_api_set_voltage_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t device_id, uint32_t voltage, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mod_psu_device_api_set_voltage_CALL_INSTANCE)); + CMOCK_mod_psu_device_api_set_voltage_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_psu_device_api_set_voltage_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.mod_psu_device_api_set_voltage_CallInstance = CMock_Guts_MemChain(Mock.mod_psu_device_api_set_voltage_CallInstance, cmock_guts_index); + Mock.mod_psu_device_api_set_voltage_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_mod_psu_device_api_set_voltage(cmock_call_instance, device_id, voltage); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void mod_psu_device_api_set_voltage_AddCallback(CMOCK_mod_psu_device_api_set_voltage_CALLBACK Callback) +{ + Mock.mod_psu_device_api_set_voltage_IgnoreBool = (char)0; + Mock.mod_psu_device_api_set_voltage_CallbackBool = (char)1; + Mock.mod_psu_device_api_set_voltage_CallbackFunctionPointer = Callback; +} + +void mod_psu_device_api_set_voltage_Stub(CMOCK_mod_psu_device_api_set_voltage_CALLBACK Callback) +{ + Mock.mod_psu_device_api_set_voltage_IgnoreBool = (char)0; + Mock.mod_psu_device_api_set_voltage_CallbackBool = (char)0; + Mock.mod_psu_device_api_set_voltage_CallbackFunctionPointer = Callback; +} + +void mod_psu_device_api_set_voltage_CMockIgnoreArg_device_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_mod_psu_device_api_set_voltage_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_psu_device_api_set_voltage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mod_psu_device_api_set_voltage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_device_id = 1; +} + +void mod_psu_device_api_set_voltage_CMockIgnoreArg_voltage(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_mod_psu_device_api_set_voltage_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_psu_device_api_set_voltage_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mod_psu_device_api_set_voltage_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_voltage = 1; +} + +int mod_clock_api_set_rate(fwk_id_t clock_id, uint64_t rate, enum mod_clock_round_mode round_mode, unsigned int requester_id) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_mod_clock_api_set_rate_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_mod_clock_api_set_rate); + cmock_call_instance = (CMOCK_mod_clock_api_set_rate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.mod_clock_api_set_rate_CallInstance); + Mock.mod_clock_api_set_rate_CallInstance = CMock_Guts_MemNext(Mock.mod_clock_api_set_rate_CallInstance); + if (Mock.mod_clock_api_set_rate_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.mod_clock_api_set_rate_FinalReturn; + Mock.mod_clock_api_set_rate_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.mod_clock_api_set_rate_CallbackBool && + Mock.mod_clock_api_set_rate_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.mod_clock_api_set_rate_CallbackFunctionPointer(clock_id, rate, round_mode, requester_id, Mock.mod_clock_api_set_rate_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_clock_id) + { + UNITY_SET_DETAILS(CMockString_mod_clock_api_set_rate,CMockString_clock_id); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_clock_id), (void*)(&clock_id), sizeof(fwk_id_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_rate) + { + UNITY_SET_DETAILS(CMockString_mod_clock_api_set_rate,CMockString_rate); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_rate), (void*)(&rate), sizeof(uint64_t), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_round_mode) + { + UNITY_SET_DETAILS(CMockString_mod_clock_api_set_rate,CMockString_round_mode); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_round_mode), (void*)(&round_mode), sizeof(enum mod_clock_round_mode), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_requester_id) + { + UNITY_SET_DETAILS(CMockString_mod_clock_api_set_rate,CMockString_requester_id); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_requester_id, requester_id, cmock_line, CMockStringMismatch); + } + } + if (Mock.mod_clock_api_set_rate_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.mod_clock_api_set_rate_CallbackFunctionPointer(clock_id, rate, round_mode, requester_id, Mock.mod_clock_api_set_rate_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_mod_clock_api_set_rate(CMOCK_mod_clock_api_set_rate_CALL_INSTANCE* cmock_call_instance, fwk_id_t clock_id, uint64_t rate, enum mod_clock_round_mode round_mode, unsigned int requester_id); +void CMockExpectParameters_mod_clock_api_set_rate(CMOCK_mod_clock_api_set_rate_CALL_INSTANCE* cmock_call_instance, fwk_id_t clock_id, uint64_t rate, enum mod_clock_round_mode round_mode, unsigned int requester_id) +{ + memcpy((void*)(&cmock_call_instance->Expected_clock_id), (void*)(&clock_id), + sizeof(fwk_id_t[sizeof(clock_id) == sizeof(fwk_id_t) ? 1 : -1])); /* add fwk_id_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_clock_id = 0; + memcpy((void*)(&cmock_call_instance->Expected_rate), (void*)(&rate), + sizeof(uint64_t[sizeof(rate) == sizeof(uint64_t) ? 1 : -1])); /* add uint64_t to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_rate = 0; + memcpy((void*)(&cmock_call_instance->Expected_round_mode), (void*)(&round_mode), + sizeof(enum mod_clock_round_mode[sizeof(round_mode) == sizeof(enum mod_clock_round_mode) ? 1 : -1])); /* add enum mod_clock_round_mode to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_round_mode = 0; + cmock_call_instance->Expected_requester_id = requester_id; + cmock_call_instance->IgnoreArg_requester_id = 0; +} + +void mod_clock_api_set_rate_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mod_clock_api_set_rate_CALL_INSTANCE)); + CMOCK_mod_clock_api_set_rate_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_clock_api_set_rate_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.mod_clock_api_set_rate_CallInstance = CMock_Guts_MemChain(Mock.mod_clock_api_set_rate_CallInstance, cmock_guts_index); + Mock.mod_clock_api_set_rate_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.mod_clock_api_set_rate_IgnoreBool = (char)1; +} + +void mod_clock_api_set_rate_CMockStopIgnore(void) +{ + if(Mock.mod_clock_api_set_rate_IgnoreBool) + Mock.mod_clock_api_set_rate_CallInstance = CMock_Guts_MemNext(Mock.mod_clock_api_set_rate_CallInstance); + Mock.mod_clock_api_set_rate_IgnoreBool = (char)0; +} + +void mod_clock_api_set_rate_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mod_clock_api_set_rate_CALL_INSTANCE)); + CMOCK_mod_clock_api_set_rate_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_clock_api_set_rate_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.mod_clock_api_set_rate_CallInstance = CMock_Guts_MemChain(Mock.mod_clock_api_set_rate_CallInstance, cmock_guts_index); + Mock.mod_clock_api_set_rate_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 mod_clock_api_set_rate_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t clock_id, uint64_t rate, enum mod_clock_round_mode round_mode, unsigned int requester_id, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_mod_clock_api_set_rate_CALL_INSTANCE)); + CMOCK_mod_clock_api_set_rate_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_clock_api_set_rate_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.mod_clock_api_set_rate_CallInstance = CMock_Guts_MemChain(Mock.mod_clock_api_set_rate_CallInstance, cmock_guts_index); + Mock.mod_clock_api_set_rate_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_mod_clock_api_set_rate(cmock_call_instance, clock_id, rate, round_mode, requester_id); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void mod_clock_api_set_rate_AddCallback(CMOCK_mod_clock_api_set_rate_CALLBACK Callback) +{ + Mock.mod_clock_api_set_rate_IgnoreBool = (char)0; + Mock.mod_clock_api_set_rate_CallbackBool = (char)1; + Mock.mod_clock_api_set_rate_CallbackFunctionPointer = Callback; +} + +void mod_clock_api_set_rate_Stub(CMOCK_mod_clock_api_set_rate_CALLBACK Callback) +{ + Mock.mod_clock_api_set_rate_IgnoreBool = (char)0; + Mock.mod_clock_api_set_rate_CallbackBool = (char)0; + Mock.mod_clock_api_set_rate_CallbackFunctionPointer = Callback; +} + +void mod_clock_api_set_rate_CMockIgnoreArg_clock_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_mod_clock_api_set_rate_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_clock_api_set_rate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mod_clock_api_set_rate_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_clock_id = 1; +} + +void mod_clock_api_set_rate_CMockIgnoreArg_rate(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_mod_clock_api_set_rate_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_clock_api_set_rate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mod_clock_api_set_rate_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_rate = 1; +} + +void mod_clock_api_set_rate_CMockIgnoreArg_round_mode(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_mod_clock_api_set_rate_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_clock_api_set_rate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mod_clock_api_set_rate_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_round_mode = 1; +} + +void mod_clock_api_set_rate_CMockIgnoreArg_requester_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_mod_clock_api_set_rate_CALL_INSTANCE* cmock_call_instance = (CMOCK_mod_clock_api_set_rate_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.mod_clock_api_set_rate_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_requester_id = 1; +} + diff --git a/module/dvfs/test/mocks/Mockmod_dvfs_extra.h b/module/dvfs/test/mocks/Mockmod_dvfs_extra.h new file mode 100644 index 000000000..944f7ec4e --- /dev/null +++ b/module/dvfs/test/mocks/Mockmod_dvfs_extra.h @@ -0,0 +1,70 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ +#ifndef _MOCKMOD_DVFS_EXTRA_H +#define _MOCKMOD_DVFS_EXTRA_H + +#include "unity.h" +#include "mod_dvfs_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_dvfs_extra_Init(void); +void Mockmod_dvfs_extra_Destroy(void); +void Mockmod_dvfs_extra_Verify(void); + + + + +#define mod_psu_device_api_set_voltage_IgnoreAndReturn(cmock_retval) mod_psu_device_api_set_voltage_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void mod_psu_device_api_set_voltage_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define mod_psu_device_api_set_voltage_StopIgnore() mod_psu_device_api_set_voltage_CMockStopIgnore() +void mod_psu_device_api_set_voltage_CMockStopIgnore(void); +#define mod_psu_device_api_set_voltage_ExpectAnyArgsAndReturn(cmock_retval) mod_psu_device_api_set_voltage_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void mod_psu_device_api_set_voltage_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define mod_psu_device_api_set_voltage_ExpectAndReturn(device_id, voltage, cmock_retval) mod_psu_device_api_set_voltage_CMockExpectAndReturn(__LINE__, device_id, voltage, cmock_retval) +void mod_psu_device_api_set_voltage_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t device_id, uint32_t voltage, int cmock_to_return); +typedef int (* CMOCK_mod_psu_device_api_set_voltage_CALLBACK)(fwk_id_t device_id, uint32_t voltage, int cmock_num_calls); +void mod_psu_device_api_set_voltage_AddCallback(CMOCK_mod_psu_device_api_set_voltage_CALLBACK Callback); +void mod_psu_device_api_set_voltage_Stub(CMOCK_mod_psu_device_api_set_voltage_CALLBACK Callback); +#define mod_psu_device_api_set_voltage_StubWithCallback mod_psu_device_api_set_voltage_Stub +#define mod_psu_device_api_set_voltage_IgnoreArg_device_id() mod_psu_device_api_set_voltage_CMockIgnoreArg_device_id(__LINE__) +void mod_psu_device_api_set_voltage_CMockIgnoreArg_device_id(UNITY_LINE_TYPE cmock_line); +#define mod_psu_device_api_set_voltage_IgnoreArg_voltage() mod_psu_device_api_set_voltage_CMockIgnoreArg_voltage(__LINE__) +void mod_psu_device_api_set_voltage_CMockIgnoreArg_voltage(UNITY_LINE_TYPE cmock_line); +#define mod_clock_api_set_rate_IgnoreAndReturn(cmock_retval) mod_clock_api_set_rate_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void mod_clock_api_set_rate_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define mod_clock_api_set_rate_StopIgnore() mod_clock_api_set_rate_CMockStopIgnore() +void mod_clock_api_set_rate_CMockStopIgnore(void); +#define mod_clock_api_set_rate_ExpectAnyArgsAndReturn(cmock_retval) mod_clock_api_set_rate_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void mod_clock_api_set_rate_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define mod_clock_api_set_rate_ExpectAndReturn(clock_id, rate, round_mode, requester_id, cmock_retval) mod_clock_api_set_rate_CMockExpectAndReturn(__LINE__, clock_id, rate, round_mode, requester_id, cmock_retval) +void mod_clock_api_set_rate_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_id_t clock_id, uint64_t rate, enum mod_clock_round_mode round_mode, unsigned int requester_id, int cmock_to_return); +typedef int (* CMOCK_mod_clock_api_set_rate_CALLBACK)(fwk_id_t clock_id, uint64_t rate, enum mod_clock_round_mode round_mode, unsigned int requester_id, int cmock_num_calls); +void mod_clock_api_set_rate_AddCallback(CMOCK_mod_clock_api_set_rate_CALLBACK Callback); +void mod_clock_api_set_rate_Stub(CMOCK_mod_clock_api_set_rate_CALLBACK Callback); +#define mod_clock_api_set_rate_StubWithCallback mod_clock_api_set_rate_Stub +#define mod_clock_api_set_rate_IgnoreArg_clock_id() mod_clock_api_set_rate_CMockIgnoreArg_clock_id(__LINE__) +void mod_clock_api_set_rate_CMockIgnoreArg_clock_id(UNITY_LINE_TYPE cmock_line); +#define mod_clock_api_set_rate_IgnoreArg_rate() mod_clock_api_set_rate_CMockIgnoreArg_rate(__LINE__) +void mod_clock_api_set_rate_CMockIgnoreArg_rate(UNITY_LINE_TYPE cmock_line); +#define mod_clock_api_set_rate_IgnoreArg_round_mode() mod_clock_api_set_rate_CMockIgnoreArg_round_mode(__LINE__) +void mod_clock_api_set_rate_CMockIgnoreArg_round_mode(UNITY_LINE_TYPE cmock_line); +#define mod_clock_api_set_rate_IgnoreArg_requester_id() mod_clock_api_set_rate_CMockIgnoreArg_requester_id(__LINE__) +void mod_clock_api_set_rate_CMockIgnoreArg_requester_id(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/dvfs/test/mod_dvfs_extra.h b/module/dvfs/test/mod_dvfs_extra.h new file mode 100644 index 000000000..9d88d4ad8 --- /dev/null +++ b/module/dvfs/test/mod_dvfs_extra.h @@ -0,0 +1,55 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + * + * Description: + * System Control and Management Interface (SCMI) unit test support. + */ +#include +#include +#include + +#include + +/*! + * \brief Set the voltage of a device. + * + * \param[in] device_id Identifier of the device to set the voltage of. + * \param[in] voltage New voltage in millivolts (mV). + * + * \retval ::FWK_E_HANDLER An error occurred in the device driver. + * \retval ::FWK_E_PARAM One or more parameters were invalid. + * \retval ::FWK_E_STATE The device cannot currently accept the request. + * \retval ::FWK_SUCCESS The operation succeeded. + * + * \return Status code representing the result of the operation. + */ +int mod_psu_device_api_set_voltage(fwk_id_t device_id, uint32_t voltage); + +/*! + * \brief Set a new clock rate by providing a frequency in Hertz (Hz). + * + * \param clock_id Clock device identifier. + * + * \param rate The desired frequency in Hertz. + * + * \param round_mode The type of rounding to perform, if required, to + * achieve the given rate. + * + * \param requester_id The entity which requested the operation. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_PENDING The request is pending. The result for this + * operation will be provided via a response event. + * \retval ::FWK_E_PARAM The clock identifier was invalid. + * \retval ::FWK_E_SUPPORT Deferred handling of asynchronous drivers is not + * supported. + * \return One of the standard framework error codes. + */ +int mod_clock_api_set_rate( + fwk_id_t clock_id, + uint64_t rate, + enum mod_clock_round_mode round_mode, + unsigned int requester_id); diff --git a/module/dvfs/test/mod_dvfs_unit_test.c b/module/dvfs/test/mod_dvfs_unit_test.c index 012b9c332..fac7de0f3 100644 --- a/module/dvfs/test/mod_dvfs_unit_test.c +++ b/module/dvfs/test/mod_dvfs_unit_test.c @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2023, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2023-2024, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ @@ -18,6 +18,11 @@ # include #endif +#include + +#include +#include + #include #include @@ -31,6 +36,14 @@ void tearDown(void) { } +struct mod_psu_device_api psu_api = { + .set_voltage = mod_psu_device_api_set_voltage, +}; + +struct mod_clock_api clock_api = { + .set_rate = mod_clock_api_set_rate, +}; + void utest_dvfs_count_opps(void) { size_t expected_opps_elements = 1; @@ -578,6 +591,79 @@ void utest_dvfs_get_latency(void) TEST_ASSERT_EQUAL(3, latency); } +void utest_dvfs_handle_set_opp_set_rate_inc_voltage(void) +{ + int32_t status; + + struct mod_dvfs_domain_ctx dvfs_domain_ctx; + dvfs_domain_ctx.request.new_opp.voltage = 5; + dvfs_domain_ctx.apis.psu = &psu_api; + dvfs_domain_ctx.apis.clock = &clock_api; + uint32_t voltage = 2; + + mod_psu_device_api_set_voltage_ExpectAnyArgsAndReturn(FWK_SUCCESS); + mod_clock_api_set_rate_ExpectAnyArgsAndReturn(FWK_PENDING); + + status = dvfs_handle_set_opp(&dvfs_domain_ctx, voltage); + + TEST_ASSERT_EQUAL(FWK_PENDING, status); +} + +void utest_dvfs_handle_set_opp_set_rate_dec_voltage(void) +{ + int32_t status; + + struct mod_dvfs_domain_ctx dvfs_domain_ctx; + dvfs_domain_ctx.request.new_opp.voltage = 2; + dvfs_domain_ctx.apis.clock = &clock_api; + uint32_t voltage = 5; + + mod_clock_api_set_rate_ExpectAnyArgsAndReturn(FWK_PENDING); + + status = dvfs_handle_set_opp(&dvfs_domain_ctx, voltage); + + TEST_ASSERT_EQUAL(FWK_PENDING, status); +} + +void utest_dvfs_handle_set_opp_set_rate_startup(void) +{ + int32_t status; + + struct mod_dvfs_domain_ctx dvfs_domain_ctx; + dvfs_domain_ctx.request.new_opp.voltage = 0; + dvfs_domain_ctx.current_opp.frequency = 0; + dvfs_domain_ctx.apis.psu = &psu_api; + dvfs_domain_ctx.apis.clock = &clock_api; + uint32_t voltage = 0; + + mod_psu_device_api_set_voltage_ExpectAnyArgsAndReturn(FWK_SUCCESS); + mod_clock_api_set_rate_ExpectAnyArgsAndReturn(FWK_PENDING); + + status = dvfs_handle_set_opp(&dvfs_domain_ctx, voltage); + + TEST_ASSERT_EQUAL(FWK_PENDING, status); +} + +void utest_dvfs_handle_psu_set_voltage_resp_set_rate(void) +{ + int32_t status; + + struct mod_dvfs_domain_ctx dvfs_domain_ctx; + struct fwk_event event; + struct mod_psu_driver_response *psu_response; + psu_response = (struct mod_psu_driver_response *)&(event.params[0]); + psu_response->status = FWK_SUCCESS; + + dvfs_domain_ctx.state = DVFS_DOMAIN_SET_FREQUENCY; + dvfs_domain_ctx.apis.clock = &clock_api; + + mod_clock_api_set_rate_ExpectAnyArgsAndReturn(FWK_PENDING); + + status = dvfs_handle_psu_set_voltage_resp(&dvfs_domain_ctx, &event); + + TEST_ASSERT_EQUAL(FWK_PENDING, status); +} + int dvfs_test_main(void) { UNITY_BEGIN(); @@ -616,6 +702,11 @@ int dvfs_test_main(void) RUN_TEST(utest_dvfs_get_latency_invalid_dvfs_id); RUN_TEST(utest_dvfs_get_latency); + RUN_TEST(utest_dvfs_handle_set_opp_set_rate_inc_voltage); + RUN_TEST(utest_dvfs_handle_set_opp_set_rate_dec_voltage); + RUN_TEST(utest_dvfs_handle_set_opp_set_rate_startup); + RUN_TEST(utest_dvfs_handle_psu_set_voltage_resp_set_rate); + return UNITY_END(); } -- GitLab From 9141a344868c92dd41cbefda182df6c587989947 Mon Sep 17 00:00:00 2001 From: Md Golam Tanvir Zim Date: Thu, 8 Aug 2024 13:47:37 +0100 Subject: [PATCH 16/16] product/juno: Condtionally include clock header file The mod_clock.h is not required for juno rom bypass binary causing build error while building with flag BUILD_HAS_MOD_CLOCK, hence it is conditionally used. Signed-off-by: Md Golam Tanvir Zim Change-Id: I2011760d9ad8bcc325c5b641661063148402e53a --- module/gtimer/src/mod_gtimer.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/module/gtimer/src/mod_gtimer.c b/module/gtimer/src/mod_gtimer.c index 97390dcda..675b1af1e 100644 --- a/module/gtimer/src/mod_gtimer.c +++ b/module/gtimer/src/mod_gtimer.c @@ -7,7 +7,10 @@ #include "gtimer_reg.h" -#include +#ifdef BUILD_HAS_MOD_CLOCK +# include +#endif + #include #include -- GitLab