From 61dccc081f38e4d643824fd26876982a4f757130 Mon Sep 17 00:00:00 2001 From: Khaled Ali Ahmed Date: Mon, 29 Jul 2024 14:17:15 +0100 Subject: [PATCH 1/2] module/pincrl: Implement pinctrl - Add initial implementation for the pinctrl module, by implementing all APIs that can manage the pin, groups, and functionalities of pins. - Define the interface with the HW pinctrl driver underneath. Signed-off-by: khaled ali ahmed --- module/CMakeLists.txt | 1 + module/pinctrl/CMakeLists.txt | 14 + module/pinctrl/Module.cmake | 9 + module/pinctrl/include/mod_pinctrl.h | 171 ++-- module/pinctrl/include/mod_pinctrl_drv.h | 138 +--- module/pinctrl/src/mod_pinctrl.c | 989 +++++++++++++++++++++++ 6 files changed, 1143 insertions(+), 179 deletions(-) create mode 100644 module/pinctrl/CMakeLists.txt create mode 100644 module/pinctrl/Module.cmake create mode 100644 module/pinctrl/src/mod_pinctrl.c diff --git a/module/CMakeLists.txt b/module/CMakeLists.txt index 992725351..7bf9460cf 100644 --- a/module/CMakeLists.txt +++ b/module/CMakeLists.txt @@ -59,6 +59,7 @@ list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/pcid") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/perf_controller") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/pid_controller") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/pik_clock") +list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/pinctrl") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/pl011") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/power_capping") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/power_distributor") diff --git a/module/pinctrl/CMakeLists.txt b/module/pinctrl/CMakeLists.txt new file mode 100644 index 000000000..9e224385e --- /dev/null +++ b/module/pinctrl/CMakeLists.txt @@ -0,0 +1,14 @@ +# +# Arm SCP/MCP Software +# Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +# + +add_library(${SCP_MODULE_TARGET} SCP_MODULE) + +target_include_directories(${SCP_MODULE_TARGET} + PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include") + +target_sources(${SCP_MODULE_TARGET} + PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src/mod_pinctrl.c") diff --git a/module/pinctrl/Module.cmake b/module/pinctrl/Module.cmake new file mode 100644 index 000000000..ecef4b7ca --- /dev/null +++ b/module/pinctrl/Module.cmake @@ -0,0 +1,9 @@ +# +# Arm SCP/MCP Software +# Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +# + +set(SCP_MODULE "pinctrl") +set(SCP_MODULE_TARGET "module-pinctrl") diff --git a/module/pinctrl/include/mod_pinctrl.h b/module/pinctrl/include/mod_pinctrl.h index 593f1dedf..dbf383afb 100644 --- a/module/pinctrl/include/mod_pinctrl.h +++ b/module/pinctrl/include/mod_pinctrl.h @@ -26,9 +26,9 @@ * \defgroup GroupModulePinctrl pinctrl * \{ */ - +#define NO_FUNCTION_SELECTED_ID UINT32_MAX /*! - * \brief Selector to differentiate between pin, group or functionality. + * \brief Selector to differentiate between pin, group or function. */ enum mod_pinctrl_selector { /*! Pin selector id */ @@ -37,21 +37,21 @@ enum mod_pinctrl_selector { /*! Group selector id */ MOD_PINCTRL_SELECTOR_GROUP, - /*! Functionality selector id */ + /*! function selector id */ MOD_PINCTRL_SELECTOR_FUNCTION, }; /*! * \brief Function type to define the functins table. */ -struct mod_pinctrl_functionality { - /*! Pointer to NULL terminated string for name of functionality */ +struct mod_pinctrl_function { + /*! Pointer to NULL terminated string for name of function */ char *name; - /*! Attribute to mark this functionality as GPIO */ + /*! Attribute to mark this function as GPIO */ bool is_gpio; - /*! Attribute to mark this functionality as used only for pins */ + /*! Attribute to mark this function as used only for pins */ bool is_pin_only; }; @@ -59,11 +59,14 @@ struct mod_pinctrl_functionality { * \brief Group type to define the Groups table. */ struct mod_pinctrl_group { - /*! Pointer to NULL terminated string for name of functionality */ + /*! Pointer to NULL terminated string for name of function */ char *name; - /*! Functionality associated to the group */ - uint16_t functionality_id; + /*! Allowed group functions to choose from */ + const uint16_t *allowed_functions; + + /*! Number of allowed group functions to choose from */ + const uint16_t num_allowed_functions; /*! Pointer to the pins associated to the group */ const uint16_t *pins; @@ -73,7 +76,33 @@ struct mod_pinctrl_group { }; /*! - * \brief Attributes type to define the pin, group or functionality + * \brief Pin type to define all pin characteristics and pins table. + */ +struct mod_pinctrl_pin { + /*! Pointer to a NULL terminated string for name of the pin */ + char *name; + + /*! Allowed pin functions to choose from */ + const uint16_t *allowed_functions; + + /*! Number of allowed pin functions to choose from */ + const uint16_t num_allowed_functions; + + /*! Table of pin configurations */ + const enum mod_pinctrl_drv_configuration_type *configuration; + + /*! Number of pin configurations */ + const uint8_t num_configuration; + + /*! Table of read only pin configurations */ + const enum mod_pinctrl_drv_configuration_type *read_only_configuration; + + /*! Number of read only pin configurations */ + const uint8_t num_of_read_only_configurations; +}; + +/*! + * \brief Attributes type to define the pin, group or function * characteristics to be returned to SCMI. */ struct mod_pinctrl_attributes { @@ -83,37 +112,54 @@ struct mod_pinctrl_attributes { /*! Number of elements to be returned to SCMI*/ uint16_t number_of_elements; - /*! Attribute to mark this functionality as used only for pins */ - bool is_pin_only_functionality; + /*! Attribute to mark this function as used only for pins */ + bool is_pin_only_function; - /*! Attribute to mark this functionality as GPIO */ - bool is_gpio_functionality; + /*! Attribute to mark this function as GPIO */ + bool is_gpio_function; }; /*! * \brief Attributes type to define the total numbers of pin, and groups and - * functionalities counts. + * functions counts. */ -struct mod_pinctrl_protocol_attributes { +struct mod_pinctrl_info { /*! Number of pinctrl pins */ uint16_t number_of_pins; /*! Number of pinctrl groups */ uint16_t number_of_groups; - /*! Number of pinctrl functionalities */ - uint16_t number_of_functionalities; + /*! Number of pinctrl functions */ + uint16_t number_of_functions; +}; + +/*! + * \brief Driver domain configuration. + */ +struct mod_pinctrl_domain_config { + /*! Driver identifier */ + fwk_id_t driver_id; + + /*! Driver API identifier */ + fwk_id_t driver_api_id; + + /*! Driver pin base IDs*/ + uint16_t pin_base_id; + + /*! Driver pin ranges IDs*/ + uint16_t pin_range; }; /*! * \brief Module configuration. */ struct mod_pinctrl_config { - /*! Pointer to the table of functionality descriptors. */ - struct mod_pinctrl_functionality *functionalities_table; + /*! Pointer to the table of function descriptors. */ + struct mod_pinctrl_function *functions_table; - /*! Number of functionalities */ - uint16_t functionality_table_count; + /*! Number of functions */ + uint16_t function_table_count; /*! Pointer to the table of group descriptors. */ struct mod_pinctrl_group *groups_table; @@ -121,11 +167,11 @@ struct mod_pinctrl_config { /*! Number of groups that will be associated to pins */ uint16_t group_table_count; - /*! Driver identifier */ - fwk_id_t driver_id; + /*! Pointer to the table of pins descriptors. */ + struct mod_pinctrl_pin *pins_table; - /*! Driver API identifier */ - fwk_id_t driver_api_id; + /*! Number of pins */ + uint16_t pin_table_count; }; /*! @@ -144,22 +190,22 @@ enum mod_pinctrl_api_idx { struct mod_pinctrl_api { /*! - * \brief Get attributes of pin, group or functionality. + * \brief Get attributes of pin, group or function. * - * \param[in] index Identifier for the pin, group, or functionality. + * \param[in] index Identifier for the pin, group, or function. * \param[in] flags Selector: Whether the identifier field selects - * a pin, a group, or a functionality. + * a pin, a group, or a function. * 0 - pin * 1 - group - * 2 - functionality + * 2 - function * \param[out] attributes respond to get attribute request * number_of_elements: total number of elements. - * is_pin_only_functionality: enum group_pin_serving_t. - * is_gpio_functionality: enum gpio_functionality_t. + * is_pin_only_function: enum group_pin_serving_t. + * is_gpio_function: enum gpio_function_t. * name: Null-terminated ASCII string. * \retval ::FWK_SUCCESS The operation succeeded. * \retval ::FWK_E_RANGE if the identifier field pertains to a - * non-existent pin, group, or functionality. + * non-existent pin, group, or function. */ int (*get_attributes)( uint16_t index, @@ -167,33 +213,32 @@ struct mod_pinctrl_api { struct mod_pinctrl_attributes *attributes); /*! - * \brief Get attributes of pin, group or functionality. + * \brief Get info of pin, group or function. * - * \param[out] protocol_attributes return protocol attributes + * \param[out] info return protocol attributes * Number of pin groups. * Number of pins. * Reserved, must be zero. - * Number of functionality. + * Number of function. * \retval ::FWK_SUCCESS The operation succeeded. */ - int (*get_protocol_attributes)( - struct mod_pinctrl_protocol_attributes *protocol_attributes); + int (*get_info)(struct mod_pinctrl_info *info); /*! * \brief Get pin associated with a group, or - * Get group which can enable a functionality, or - * Get pin which can enable a single-pin functionality. - * \param[in] index Identifier for the group, or functionality. + * Get group which can enable a function, or + * Get pin which can enable a single-pin function. + * \param[in] index Identifier for the group, or function. * \param[in] flags Selector: Whether the identifier field selects - * group, or functionality. + * group, or function. * 1 - group - * 2 - functionality + * 2 - function * \param[in] first_index the index of the object {pin, group} to be * returned * \param[out] object_id the returned object. * \retval ::FWK_SUCCESS The operation succeeded. * \retval ::FWK_E_RANGE index >= max number of pins associated with this - * functionality or group. + * function or group. * \retval ::FWK_E_PARAM the flags is pin. */ int (*get_list_associations)( @@ -204,11 +249,11 @@ struct mod_pinctrl_api { /*! * \brief Get the total number of associated pins or groups to index. - * \param[in] index Identifier for the group, or functionality. + * \param[in] index Identifier for the group, or function. * \param[in] flags Selector: Whether the identifier field selects - * group, or functionality. + * group, or function. * 1 - group - * 2 - functionality + * 2 - function * \param[in] total_count the total number of associations to the index * \retval ::FWK_SUCCESS The operation succeeded. * \retval ::FWK_E_PARAM index invalid index or flags == pin @@ -219,7 +264,7 @@ struct mod_pinctrl_api { uint16_t *total_count); /*! - * \brief Get pin or group specific Configuration. + * \brief Get pin or group specific configuration value. * \param[in] index Identifier for the pin, or group. * \param[in] flags Selector: Whether the identifier field selects * a pin or group. @@ -238,14 +283,14 @@ struct mod_pinctrl_api { uint32_t *config_value); /*! - * \brief Get pin or group specific Configuration. + * \brief Get pin or group configuration by configuration index. * \param[in] index Identifier for the pin, or group. * \param[in] flags Selector: Whether the identifier field selects * a pin or group. * 0 - pin * 1 - group - * \param[in] configration_index - * \param[out] config Configuration type to be retun its value. + * \param[in] configration_index configuration index + * \param[out] config configuration type and value for specific index. * \retval ::FWK_SUCCESS The operation succeeded. * \retval ::FWK_E_RANGE configration_index > total number of configurtions. * \retval ::FWK_E_PARAM the flags isn't pin or group. or index >= max @@ -275,23 +320,23 @@ struct mod_pinctrl_api { uint16_t *number_of_configurations); /*! - * \brief get current pin or group enabled functionality. + * \brief get current pin or group enabled function. * * \param[in] index pin or group identifier. * \param[in] flag Selector: Whether the identifier field selects * a pin or group. * 0 - pin * 1 - group - * \param[out] functionality_id current enabled functionality. + * \param[out] function_id current enabled function. * \retval ::FWK_SUCCESS The operation succeeded. * \retval ::FWK_E_RANGE pin_id >= max number of pins or the - * functionality_id is not allowed for this pin_id. + * function_id is not allowed for this pin_id. * \retval ::FWK_E_PARAM the flag isn't pin or group. */ - int (*get_current_associated_functionality)( + int (*get_current_associated_function)( uint16_t index, enum mod_pinctrl_selector flag, - uint16_t *functionality_id); + uint32_t *function_id); /*! * \brief set pin or group configuration. @@ -304,7 +349,7 @@ struct mod_pinctrl_api { * \param[in] config configuration to be set. * \retval ::FWK_SUCCESS The operation succeeded. * \retval ::FWK_E_RANGE pin_id >= max number of pins or the - * functionality_id is not allowed for this pin_id. + * function_id is not allowed for this pin_id. * \retval ::FWK_E_PARAM the flag isn't pin or group. */ int (*set_configuration)( @@ -313,23 +358,23 @@ struct mod_pinctrl_api { const struct mod_pinctrl_drv_pin_configuration *config); /*! - * \brief Set pin or group functionality. + * \brief Set pin or group function. * * \param[in] index pin or group identifier. * \param[in] flag Selector: Whether the identifier field selects * a pin or group. * 0 - pin * 1 - group - * \param[in] functionality_id the fucntionality to be set. + * \param[in] function_id the fucntionality to be set. * \retval ::FWK_SUCCESS The operation succeeded. * \retval ::FWK_E_RANGE pin_id >= max number of pins or the - * functionality_id is not allowed for this pin_id. + * function_id is not allowed for this pin_id. * \retval ::FWK_E_PARAM the flag isn't pin or group. */ - int (*set_functionality)( + int (*set_function)( uint16_t index, enum mod_pinctrl_selector flag, - uint16_t functionality_id); + uint32_t function_id); }; /*! diff --git a/module/pinctrl/include/mod_pinctrl_drv.h b/module/pinctrl/include/mod_pinctrl_drv.h index 0765ad20d..a4b5b6303 100644 --- a/module/pinctrl/include/mod_pinctrl_drv.h +++ b/module/pinctrl/include/mod_pinctrl_drv.h @@ -11,8 +11,6 @@ #ifndef MOD_PINCTRL_DRV_H #define MOD_PINCTRL_DRV_H -#include -#include #include /*! @@ -64,40 +62,6 @@ struct mod_pinctrl_drv_pin_configuration { uint32_t config_value; }; -/*! - * \brief Pin type to define all pin characteristics and pins table. - */ -struct mod_pinctrl_drv_pin { - /*! Pointer to NULL terminated string for name of pin */ - const char *name; - - /*! Current pin functionality */ - uint16_t functionality; - - /*! Allowed pin functionalities to choose from */ - const uint16_t *allowed_functionalities; - - /*! Number of allowed pin functionalities to choose from */ - const size_t num_allowed_functionalities; - - /*! Table of pin configurations */ - struct mod_pinctrl_drv_pin_configuration *configuration; - - /*! Number of pin configurations */ - const size_t num_configuration; -}; - -/*! - * \brief Module configuration. - */ -struct mod_pinctrl_drv_config { - /*! \brief Pointer to the table of pins descriptors. */ - struct mod_pinctrl_drv_pin *pins; - - /*! Number of pins */ - size_t pin_count; -}; - /*! * \brief mod pin control attributes APIs. * @@ -113,96 +77,31 @@ enum mod_pinctrl_drv_api_idx { struct mod_pinctrl_drv_api { /*! - * \brief Get the total number of pins that can support functionality_id. - * - * \param[in] functionality_id functionality identintifier. - * \param[out] number_of_pins total number of pins which can support - * functionality_id. - * \retval ::FWK_SUCCESS The operation succeeded. - * \retval ::FWK_E_PARAM Number of pins pointer is NULL. - */ - int (*get_number_pins_can_support_functionalityality)( - uint16_t functionality_id, - uint16_t *number_of_pins); - - /*! - * \brief Get pin name and name_type. - * - * \param[in] pin_id pin identintifier. - * \param[out] name_type name type may be normal or extended. - * \param[out] name name string terminated with null char \0. - * \retval ::FWK_SUCCESS The operation succeeded. - * \retval ::FWK_E_RANGE pin_id >= max number of pins. - */ - int (*get_pin_name)(uint16_t pin_id, char **pin_name, bool *name_type); - - /*! - * \brief get pin_id that can enable a single-pin functionality. - * - * \param[in] functionality_id functionality identintifier. - * \param[in] index Index of the pin to be described - * in the return pin_id. - * \param[out] pin_id pin id which can enable functionality_id. - * \retval ::FWK_SUCCESS The operation succeeded. - * \retval ::FWK_E_RANGE index >= max number of pins associated - * with this functionality. - */ - int (*get_pin_id_associated_with_functionality)( - uint16_t functionality_id, - uint16_t index, - uint16_t *pin_id); - - /*! - * \brief The current functionality selected to be enabled by the pin. - * - * \param[in] pin_id pin identintifier. - * \param[out] selected_functionality currently selected/enabled - * functionality. \retval ::FWK_SUCCESS The operation succeeded. - * \retval ::FWK_E_RANGE pin_id >= max number of pins. - */ - int (*get_pin_current_selected_functionality)( - uint16_t pin_id, - uint16_t *selected_functionality); - - /*! - * \brief get pin configuration. - * - * \param[in] pin_id pin identifier. - * \param[in] pin_config Configuration type and value. - * \retval ::FWK_SUCCESS The operation succeeded. - * \retval ::FWK_E_RANGE pin_id >= max number of pins. - * \retval ::FWK_E_PARAM invalid config_type. - */ - int (*get_pin_configuration)( - uint16_t pin_id, - const struct mod_pinctrl_drv_pin_configuration *pin_config); - - /*! - * \brief get pin functionality. + * \brief Get pin function. * * \param[in] pin_id pin identifier. - * \param[out] functionality_id functionality to be set. + * \param[in] function_id function to be Get. * \retval ::FWK_SUCCESS The operation succeeded. - * \retval ::FWK_E_RANGE pin_id >= max number of pins or the - * functionality_id is not allowed for this pin_id. + * \retval ::FWK_E_RANGE pin_id >= max number of pins or group. + * \retval ::FWK_E_PARAM function_id is not supported by the pin. is + * not allowed for this pin_id. */ - int (*get_pin_functionality)(uint16_t pin_id, uint16_t *functionality_id); + int (*get_pin_function)(uint16_t pin_id, uint32_t *function_id); /*! - * \brief set pin functionality. + * \brief Set pin function. * * \param[in] pin_id pin identifier. - * \param[in] functionality_id functionality to be set. + * \param[in] function_id function to be set. * \retval ::FWK_SUCCESS The operation succeeded. - * \retval ::FWK_E_RANGE pin_id >= max number of pins or the - * functionality_id - * \retval ::FWK_E_PARAM functionality_id is not supported by the pin. is + * \retval ::FWK_E_RANGE pin_id >= max number of pins or group. + * \retval ::FWK_E_PARAM function_id is not supported by the pin. is * not allowed for this pin_id. */ - int (*set_pin_functionality)(uint16_t pin_id, uint16_t functionality_id); + int (*set_pin_function)(uint16_t pin_id, uint32_t function_id); /*! - * \brief set pin configuration. + * \brief Set pin configuration. * * \param[in] pin_id pin identifier. * \param[in] pin_config Configuration type and value. @@ -216,11 +115,18 @@ struct mod_pinctrl_drv_api { const struct mod_pinctrl_drv_pin_configuration *pin_config); /*! - * \brief get the total number of pins. + * \brief Get pin configuration. * - * \retval ::total number of pins. + * \param[in] pin_id pin identifier. + * \param[in] pin_config Configuration type and value. + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_E_RANGE: if pin_id field does not point to a valid pin. + * \retval ::FWK_E_PARAM:: if the config_type specify incorrect or + * illegal values. */ - int (*get_total_number_of_pins)(int *number_of_pins); + int (*get_pin_configuration)( + uint16_t pin_id, + struct mod_pinctrl_drv_pin_configuration *pin_config); }; /*! diff --git a/module/pinctrl/src/mod_pinctrl.c b/module/pinctrl/src/mod_pinctrl.c new file mode 100644 index 000000000..6226bfc39 --- /dev/null +++ b/module/pinctrl/src/mod_pinctrl.c @@ -0,0 +1,989 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + * + * Description: + * SCMI pin control protocol support. + */ + +#include + +#include +#include +#include +#include +#include +#include + +#include + +struct mod_pinctrl_domain_ctx { + /*! Bound driver domain configurations */ + const struct mod_pinctrl_domain_config *drv_domain_config; + + /*! Bound Driver APIs */ + struct mod_pinctrl_drv_api *pinctrl_driver_api; +}; + +struct mod_pinctrl_ctx { + /*! Pin Control Module Configuration */ + struct mod_pinctrl_config *config; + + /*! Bound driver module ctx */ + struct mod_pinctrl_domain_ctx *pinctrl_drv_domain_ctx; + + /*! Driver module domain counts */ + unsigned int pinctrl_drv_domain_count; +}; + +static struct mod_pinctrl_ctx pinctrl_ctx; + +/* + * PINCTRL mapper function + */ + +static int get_drv_api_from_pin_id( + uint16_t pin_id, + struct mod_pinctrl_drv_api **pinctrl_driver_api) +{ + uint16_t pin_base_id; + uint16_t pin_range; + + for (uint32_t i = 0; i < pinctrl_ctx.pinctrl_drv_domain_count; ++i) { + pin_base_id = pinctrl_ctx.pinctrl_drv_domain_ctx[i] + .drv_domain_config->pin_base_id; + pin_range = + pinctrl_ctx.pinctrl_drv_domain_ctx[i].drv_domain_config->pin_range; + + if ((pin_id >= pin_base_id) && (pin_id < pin_range)) { + *pinctrl_driver_api = + pinctrl_ctx.pinctrl_drv_domain_ctx[i].pinctrl_driver_api; + return FWK_SUCCESS; + } + } + + return FWK_E_RANGE; +} + +/* + * PINCTRL_ATTRIBUTES + */ + +static int get_pin_attributes( + uint16_t pin_id, + struct mod_pinctrl_attributes *pinctrl_attributes) +{ + if (pin_id >= pinctrl_ctx.config->pin_table_count) { + return FWK_E_RANGE; + } + + pinctrl_attributes->name = pinctrl_ctx.config->pins_table[pin_id].name; + /* One to number_of_elements where we just returning one pin attributes */ + pinctrl_attributes->number_of_elements = 1; + + return FWK_SUCCESS; +} + +static int get_group_attributes( + uint16_t group_id, + struct mod_pinctrl_attributes *pinctrl_attributes) +{ + if (group_id >= pinctrl_ctx.config->group_table_count) { + return FWK_E_RANGE; + } + + const struct mod_pinctrl_group *group = + &pinctrl_ctx.config->groups_table[group_id]; + + pinctrl_attributes->name = group->name; + pinctrl_attributes->number_of_elements = group->num_pins; + + return FWK_SUCCESS; +} + +static int get_function_attributes( + uint16_t function_id, + struct mod_pinctrl_attributes *pinctrl_attributes) +{ + if (function_id >= (size_t)pinctrl_ctx.config->function_table_count) { + return FWK_E_RANGE; + } + + const struct mod_pinctrl_function *function = + &pinctrl_ctx.config->functions_table[function_id]; + + pinctrl_attributes->name = function->name; + + pinctrl_attributes->is_gpio_function = function->is_gpio; + pinctrl_attributes->is_pin_only_function = function->is_pin_only; + + pinctrl_attributes->number_of_elements = 0; + if (function->is_pin_only) { + struct mod_pinctrl_pin *pins = pinctrl_ctx.config->pins_table; + for (uint32_t index = 0; index < pinctrl_ctx.config->pin_table_count; + ++index) { + for (uint32_t i = 0; i < pins[index].num_allowed_functions; ++i) { + if (function_id == pins[index].allowed_functions[i]) { + pinctrl_attributes->number_of_elements++; + break; + } + } + } + } else { + struct mod_pinctrl_group *groups = pinctrl_ctx.config->groups_table; + for (uint32_t index = 0; index < pinctrl_ctx.config->group_table_count; + ++index) { + for (uint32_t i = 0; i < groups[index].num_allowed_functions; ++i) { + if (function_id == groups[index].allowed_functions[i]) { + pinctrl_attributes->number_of_elements++; + break; + } + } + } + } + + return FWK_SUCCESS; +} + +int get_attributes( + uint16_t index, + enum mod_pinctrl_selector flags, + struct mod_pinctrl_attributes *attributes) +{ + int status = FWK_SUCCESS; + + switch (flags) { + case MOD_PINCTRL_SELECTOR_PIN: + status = get_pin_attributes(index, attributes); + break; + case MOD_PINCTRL_SELECTOR_GROUP: + status = get_group_attributes(index, attributes); + break; + + case MOD_PINCTRL_SELECTOR_FUNCTION: + status = get_function_attributes(index, attributes); + break; + + default: + status = FWK_E_RANGE; + break; + } + + return status; +} + +/* + * INFO + */ + +int get_info(struct mod_pinctrl_info *info) +{ + if (info == NULL) { + return FWK_E_PARAM; + } + + info->number_of_pins = pinctrl_ctx.config->pin_table_count; + info->number_of_functions = pinctrl_ctx.config->function_table_count; + info->number_of_groups = pinctrl_ctx.config->group_table_count; + + return FWK_SUCCESS; +} + +/* + * PINCTRL_LIST_ASSOCIATIONS + */ + +static int get_pin_id_associated_with_group( + uint16_t group_id, + uint16_t index, + uint16_t *pin_id) +{ + if (index >= pinctrl_ctx.config->groups_table[group_id].num_pins) { + return FWK_E_RANGE; + } + + *pin_id = pinctrl_ctx.config->groups_table[group_id].pins[index]; + + return FWK_SUCCESS; +} + +static int get_group_id_associated_with_function( + uint16_t function_id, + uint16_t index, + uint16_t *group_id) +{ + uint16_t group_count = pinctrl_ctx.config->group_table_count; + uint16_t search_index = 0; + + if (index >= group_count) { + return FWK_E_RANGE; + } + + for (uint32_t group_index = 0; group_index < group_count; ++group_index) { + for (uint32_t func_index = 0; + func_index < pinctrl_ctx.config->groups_table[group_index] + .num_allowed_functions; + ++func_index) { + if ((function_id == + pinctrl_ctx.config->groups_table[group_index] + .allowed_functions[func_index]) && + (search_index == index)) { + *group_id = group_index; + return FWK_SUCCESS; + } else if ( + function_id == + pinctrl_ctx.config->groups_table[group_index] + .allowed_functions[func_index]) { + ++search_index; + break; + } + } + } + + return FWK_E_RANGE; +} + +static int get_pin_id_associated_with_function( + uint16_t function_id, + uint16_t index, + uint16_t *pin_id) +{ + uint16_t pin_count = pinctrl_ctx.config->pin_table_count; + uint16_t search_index = 0; + + if (index >= pin_count) { + return FWK_E_RANGE; + } + + for (uint32_t pin_index = 0; pin_index < pin_count; ++pin_index) { + for (uint32_t func_index = 0; func_index < + pinctrl_ctx.config->pins_table[pin_index].num_allowed_functions; + ++func_index) { + if ((function_id == + pinctrl_ctx.config->pins_table[pin_index] + .allowed_functions[func_index]) && + (search_index == index)) { + *pin_id = pin_index; + return FWK_SUCCESS; + } else if ( + function_id == + pinctrl_ctx.config->pins_table[pin_index] + .allowed_functions[func_index]) { + ++search_index; + break; + } + } + } + + return FWK_E_PARAM; +} + +int get_list_associations( + uint16_t id, + enum mod_pinctrl_selector flag, + uint16_t index, + uint16_t *element) +{ + int status = FWK_SUCCESS; + switch (flag) { + case MOD_PINCTRL_SELECTOR_GROUP: + status = get_pin_id_associated_with_group(id, index, element); + break; + case MOD_PINCTRL_SELECTOR_FUNCTION: + if (id >= pinctrl_ctx.config->function_table_count) { + return FWK_E_RANGE; + } + if (pinctrl_ctx.config->functions_table[id].is_pin_only) { + status = get_pin_id_associated_with_function(id, index, element); + } else { + status = get_group_id_associated_with_function(id, index, element); + } + break; + + default: + return FWK_E_PARAM; + break; + } + + return status; +} + +static void get_number_of_groups_can_support_function( + uint16_t function_id, + uint16_t *number_of_groups) +{ + *number_of_groups = 0; + for (uint32_t group_index = 0; + group_index < pinctrl_ctx.config->group_table_count; + ++group_index) { + for (uint32_t func_index = 0; + func_index < pinctrl_ctx.config->groups_table[group_index] + .num_allowed_functions; + ++func_index) { + if (pinctrl_ctx.config->groups_table[group_index] + .allowed_functions[func_index] == function_id) { + ++(*number_of_groups); + break; + } + } + } +} + +static void get_number_pins_can_support_function( + uint16_t function_id, + uint16_t *number_of_pins) +{ + *number_of_pins = 0; + for (uint32_t i = 0; i < pinctrl_ctx.config->pin_table_count; ++i) { + for (uint32_t j = 0; + j < pinctrl_ctx.config->pins_table[i].num_allowed_functions; + ++j) { + if (pinctrl_ctx.config->pins_table[i].allowed_functions[j] == + function_id) { + ++(*number_of_pins); + break; + } + } + } +} + +int get_total_number_of_associations( + uint16_t index, + enum mod_pinctrl_selector flags, + uint16_t *total_count) +{ + switch (flags) { + case MOD_PINCTRL_SELECTOR_GROUP: + if (index >= pinctrl_ctx.config->group_table_count) { + return FWK_E_RANGE; + } + *total_count = pinctrl_ctx.config->groups_table[index].num_pins; + return FWK_SUCCESS; + break; + + case MOD_PINCTRL_SELECTOR_FUNCTION: + if (index >= pinctrl_ctx.config->function_table_count) { + return FWK_E_RANGE; + } + + if (pinctrl_ctx.config->functions_table[index].is_pin_only) { + get_number_pins_can_support_function(index, total_count); + } else { + get_number_of_groups_can_support_function(index, total_count); + } + return FWK_SUCCESS; + break; + default: + return FWK_E_PARAM; + break; + } +} + +/* + * PINCTRL_SETTINGS_GET + */ + +static int get_pin_configuration_value_from_type( + uint16_t pin_index, + enum mod_pinctrl_drv_configuration_type config_type, + uint32_t *config_value) +{ + struct mod_pinctrl_drv_api *drv_api; + struct mod_pinctrl_drv_pin_configuration config; + int status; + + if (pin_index >= pinctrl_ctx.config->pin_table_count) { + return FWK_E_RANGE; + } + + status = get_drv_api_from_pin_id(pin_index, &drv_api); + if (status != FWK_SUCCESS) { + return status; + } + + struct mod_pinctrl_pin *pin = &pinctrl_ctx.config->pins_table[pin_index]; + for (uint32_t i = 0; i < pin->num_configuration; ++i) { + if (pin->configuration[i] == config_type) { + config.config_type = config_type; + + status = drv_api->get_pin_configuration(pin_index, &config); + if (status != FWK_SUCCESS) { + return status; + } + *config_value = config.config_value; + + return FWK_SUCCESS; + } + } + + return FWK_E_PARAM; +} + +static int get_group_configuration_by_value( + uint16_t group_id, + enum mod_pinctrl_drv_configuration_type config_type, + uint32_t *config_value) +{ + const int first_group_pin_index = 0; + uint16_t pin_id; + int status; + + if (group_id >= pinctrl_ctx.config->group_table_count) { + return FWK_E_RANGE; + } + + status = get_pin_id_associated_with_group( + group_id, first_group_pin_index, &pin_id); + if (status != FWK_SUCCESS) { + return status; + } + + status = get_pin_configuration_value_from_type( + pin_id, config_type, config_value); + + return status; +} + +int get_configuration_value_from_type( + uint16_t index, + enum mod_pinctrl_selector flag, + enum mod_pinctrl_drv_configuration_type config_type, + uint32_t *config_value) +{ + int status; + + switch (flag) { + case MOD_PINCTRL_SELECTOR_PIN: + status = get_pin_configuration_value_from_type( + index, config_type, config_value); + break; + + case MOD_PINCTRL_SELECTOR_GROUP: + status = + get_group_configuration_by_value(index, config_type, config_value); + break; + + default: + status = FWK_E_RANGE; + break; + } + + return status; +} + +static int get_pin_configuration_from_config_index( + uint16_t pin_index, + uint16_t config_index, + struct mod_pinctrl_drv_pin_configuration *pin_config) +{ + struct mod_pinctrl_drv_api *drv_api; + int status; + + if (pin_index >= pinctrl_ctx.config->pin_table_count) { + return FWK_E_RANGE; + } + + status = get_drv_api_from_pin_id(pin_index, &drv_api); + if (status != FWK_SUCCESS) { + return status; + } + + if (config_index >= + pinctrl_ctx.config->pins_table[pin_index].num_configuration) { + return FWK_E_RANGE; + } + + pin_config->config_type = + pinctrl_ctx.config->pins_table[pin_index].configuration[config_index]; + + status = drv_api->get_pin_configuration(pin_index, pin_config); + if (status != FWK_SUCCESS) { + return status; + } + + return FWK_SUCCESS; +} + +static int get_group_configuration_by_index( + uint16_t group_id, + uint16_t configration_index, + struct mod_pinctrl_drv_pin_configuration *config) +{ + const int first_group_pin_index = 0; + uint16_t pin_id; + int status; + + if (group_id >= pinctrl_ctx.config->group_table_count) { + return FWK_E_RANGE; + } + + status = get_pin_id_associated_with_group( + group_id, first_group_pin_index, &pin_id); + if (status != FWK_SUCCESS) { + return status; + } + + status = get_pin_configuration_from_config_index( + pin_id, configration_index, config); + + return status; +} + +int get_configuration( + uint16_t index, + enum mod_pinctrl_selector flag, + uint16_t configration_index, + struct mod_pinctrl_drv_pin_configuration *config) +{ + int status; + + switch (flag) { + case MOD_PINCTRL_SELECTOR_PIN: + status = get_pin_configuration_from_config_index( + index, configration_index, config); + break; + case MOD_PINCTRL_SELECTOR_GROUP: + status = + get_group_configuration_by_index(index, configration_index, config); + break; + default: + status = FWK_E_PARAM; + break; + } + + return status; +} + +static int get_pin_total_number_of_configurations( + uint16_t pin_index, + uint16_t *number_of_configurations) +{ + if ((pin_index >= pinctrl_ctx.config->pin_table_count)) { + return FWK_E_RANGE; + } + + *number_of_configurations = + pinctrl_ctx.config->pins_table[pin_index].num_configuration; + + return FWK_SUCCESS; +} + +static int get_number_of_group_configurations( + uint16_t group_id, + uint16_t *number_of_configurations) +{ + const int first_group_pin_index = 0; + uint16_t pin_id; + int status; + + if (number_of_configurations == NULL) { + return FWK_E_PARAM; + } + + if (group_id >= pinctrl_ctx.config->group_table_count) { + return FWK_E_RANGE; + } + + status = get_pin_id_associated_with_group( + group_id, first_group_pin_index, &pin_id); + if (status != FWK_SUCCESS) { + return status; + } + + status = get_pin_total_number_of_configurations( + pin_id, number_of_configurations); + + return status; +} + +int get_total_number_of_configurations( + uint16_t index, + enum mod_pinctrl_selector flag, + uint16_t *number_of_configurations) +{ + int status; + + switch (flag) { + case MOD_PINCTRL_SELECTOR_PIN: + status = get_pin_total_number_of_configurations( + index, number_of_configurations); + break; + case MOD_PINCTRL_SELECTOR_GROUP: + status = + get_number_of_group_configurations(index, number_of_configurations); + break; + default: + return FWK_E_PARAM; + break; + } + + return status; +} + +int get_current_associated_function( + uint16_t index, + enum mod_pinctrl_selector flag, + uint32_t *function_id) +{ + int status; + struct mod_pinctrl_drv_api *drv_api; + uint16_t first_pin_id; + + switch (flag) { + case MOD_PINCTRL_SELECTOR_PIN: + if (index >= pinctrl_ctx.config->pin_table_count) { + status = FWK_E_RANGE; + } else { + status = get_drv_api_from_pin_id(index, &drv_api); + if (status != FWK_SUCCESS) { + return status; + } + + status = drv_api->get_pin_function(index, function_id); + } + break; + + case MOD_PINCTRL_SELECTOR_GROUP: + if (index >= pinctrl_ctx.config->group_table_count) { + status = FWK_E_RANGE; + } else { + first_pin_id = pinctrl_ctx.config->groups_table[index].pins[0]; + + status = get_drv_api_from_pin_id(index, &drv_api); + if (status != FWK_SUCCESS) { + return status; + } + + status = drv_api->get_pin_function(first_pin_id, function_id); + } + break; + default: + status = FWK_E_PARAM; + break; + } + + return status; +} + +/* + * PINCTRL_SETTINGS_CONFIGURE + */ + +static bool is_config_read_only( + uint16_t pin_id, + const enum mod_pinctrl_drv_configuration_type config) +{ + const enum mod_pinctrl_drv_configuration_type *configs = + pinctrl_ctx.config->pins_table[pin_id].read_only_configuration; + const uint8_t num_of_config = + pinctrl_ctx.config->pins_table[pin_id].num_of_read_only_configurations; + + for (uint32_t i = 0; i < num_of_config; ++i) { + if (config == configs[i]) { + return true; + } + } + + return false; +} + +static bool is_configuration_allowed( + uint16_t pin_id, + const enum mod_pinctrl_drv_configuration_type config) +{ + const enum mod_pinctrl_drv_configuration_type *configs = + pinctrl_ctx.config->pins_table[pin_id].configuration; + const uint8_t num_of_config = + pinctrl_ctx.config->pins_table[pin_id].num_configuration; + + for (uint32_t i = 0; i < num_of_config; ++i) { + if (config == configs[i]) { + return true; + } + } + + return false; +} + +int set_configuration( + uint16_t index, + enum mod_pinctrl_selector flag, + const struct mod_pinctrl_drv_pin_configuration *config) +{ + int status; + + uint16_t pin_id; + uint16_t pin_count; + bool read_only_config = true; + struct mod_pinctrl_drv_api *drv_api; + + switch (flag) { + case MOD_PINCTRL_SELECTOR_PIN: + if (index >= pinctrl_ctx.config->pin_table_count) { + return FWK_E_RANGE; + } + + read_only_config = is_config_read_only(index, config->config_type); + if (read_only_config) { + return FWK_E_PARAM; + } + + if (!is_configuration_allowed(index, config->config_type)) { + return FWK_E_PARAM; + } + + status = get_drv_api_from_pin_id(index, &drv_api); + if (status != FWK_SUCCESS) { + return status; + } + + status = drv_api->set_pin_configuration(index, config); + if (status != FWK_SUCCESS) { + return status; + } + break; + + case MOD_PINCTRL_SELECTOR_GROUP: + if (index >= pinctrl_ctx.config->group_table_count) { + status = FWK_E_RANGE; + } else { + pin_count = pinctrl_ctx.config->groups_table[index].num_pins; + for (uint32_t i = 0; i < pin_count; ++i) { + pin_id = pinctrl_ctx.config->groups_table[index].pins[i]; + read_only_config = + is_config_read_only(pin_id, config->config_type); + if (read_only_config) { + return FWK_E_PARAM; + } + + if (!is_configuration_allowed(index, config->config_type)) { + return FWK_E_PARAM; + } + + status = get_drv_api_from_pin_id(pin_id, &drv_api); + if (status != FWK_SUCCESS) { + return status; + } + status = drv_api->set_pin_configuration(pin_id, config); + if (status != FWK_SUCCESS) { + return status; + } + } + } + break; + + default: + status = FWK_E_PARAM; + break; + } + + return status; +} + +static int is_pin_function_allowed(uint16_t pin_id, uint32_t function_id) +{ + if (pin_id >= pinctrl_ctx.config->pin_table_count) { + return FWK_E_RANGE; + } + + for (uint32_t i = 0; + i < pinctrl_ctx.config->pins_table[pin_id].num_allowed_functions; + ++i) { + if ((function_id == + pinctrl_ctx.config->pins_table[pin_id].allowed_functions[i]) || + (function_id == NO_FUNCTION_SELECTED_ID)) { + return FWK_SUCCESS; + } + } + + return FWK_E_PARAM; +} + +static int set_group_function(uint16_t group_index, uint32_t function) +{ + int status; + uint16_t group_pins_count = 0; + uint16_t pin_index; + struct mod_pinctrl_drv_api *drv_api; + + if (group_index >= pinctrl_ctx.config->group_table_count) { + return FWK_E_RANGE; + } + + group_pins_count = pinctrl_ctx.config->groups_table[group_index].num_pins; + + for (uint32_t i = 0; i < group_pins_count; ++i) { + pin_index = pinctrl_ctx.config->groups_table[group_index].pins[i]; + status = get_drv_api_from_pin_id(pin_index, &drv_api); + if (status != FWK_SUCCESS) { + return status; + } + + status = is_pin_function_allowed(pin_index, function); + if (status != FWK_SUCCESS) { + return status; + } + + status = drv_api->set_pin_function(pin_index, function); + if (status != FWK_SUCCESS) { + return status; + } + } + + return status; +} + +int set_function( + uint16_t index, + enum mod_pinctrl_selector flag, + uint32_t function_id) +{ + int status; + struct mod_pinctrl_drv_api *drv_api; + + if ((function_id >= pinctrl_ctx.config->function_table_count) && + (function_id != NO_FUNCTION_SELECTED_ID)) { + return FWK_E_RANGE; + } + + switch (flag) { + case MOD_PINCTRL_SELECTOR_PIN: + if (pinctrl_ctx.config->functions_table[function_id].is_pin_only) { + status = get_drv_api_from_pin_id(index, &drv_api); + if (status != FWK_SUCCESS) { + return status; + } + + status = is_pin_function_allowed(index, function_id); + if (status != FWK_SUCCESS) { + return status; + } + + status = drv_api->set_pin_function(index, function_id); + } else { + status = FWK_E_PARAM; + } + break; + + case MOD_PINCTRL_SELECTOR_GROUP: + if (pinctrl_ctx.config->functions_table[function_id].is_pin_only) { + status = FWK_E_PARAM; + } else { + status = set_group_function(index, function_id); + } + break; + + default: + return FWK_E_PARAM; + break; + } + + return status; +} + +struct mod_pinctrl_api mod_pinctrl_apis = { + .get_attributes = get_attributes, + .get_info = get_info, + .get_list_associations = get_list_associations, + .get_total_number_of_associations = get_total_number_of_associations, + .get_configuration_value_from_type = get_configuration_value_from_type, + .get_configuration = get_configuration, + .get_total_number_of_configurations = get_total_number_of_configurations, + .get_current_associated_function = get_current_associated_function, + .set_configuration = set_configuration, + .set_function = set_function, +}; + +/* + * Framework handlers + */ + +static int pinctrl_init( + fwk_id_t module_id, + unsigned int element_count, + const void *data) +{ + struct mod_pinctrl_config *config = (struct mod_pinctrl_config *)data; + + if (config == NULL) { + return FWK_E_PARAM; + } + + pinctrl_ctx.config = config; + + pinctrl_ctx.pinctrl_drv_domain_ctx->pinctrl_driver_api = + fwk_mm_alloc(element_count, sizeof(struct mod_pinctrl_drv_api *)); + + pinctrl_ctx.pinctrl_drv_domain_count = element_count; + + return FWK_SUCCESS; +} + +static int mod_pinctrl_bind(fwk_id_t id, unsigned int round) +{ + int status; + if (round > 0) + return FWK_SUCCESS; + + for (uint32_t i = 0; i < pinctrl_ctx.pinctrl_drv_domain_count; ++i) { + status = fwk_module_bind( + pinctrl_ctx.pinctrl_drv_domain_ctx[i].drv_domain_config->driver_id, + pinctrl_ctx.pinctrl_drv_domain_ctx[i] + .drv_domain_config->driver_api_id, + &pinctrl_ctx.pinctrl_drv_domain_ctx[i].pinctrl_driver_api); + + if (status != FWK_SUCCESS) { + return status; + } + } + + return FWK_SUCCESS; +} + +static int pinctrl_element_init( + fwk_id_t element_id, + unsigned int sub_element_count, + const void *data) +{ + if (data == NULL) { + return FWK_E_DATA; + } + + pinctrl_ctx.pinctrl_drv_domain_ctx[fwk_id_get_element_idx(element_id)] + .drv_domain_config = (struct mod_pinctrl_domain_config *)data; + + return FWK_SUCCESS; +} + +static int pinctrl_process_bind_request( + fwk_id_t source_id, + fwk_id_t target_id, + fwk_id_t api_id, + const void **api) +{ + enum mod_pinctrl_api_idx api_idx = + (enum mod_pinctrl_api_idx)fwk_id_get_api_idx(api_id); + + switch (api_idx) { + case MOD_PINCTRL_API_IDX: + *api = &mod_pinctrl_apis; + break; + + default: + return FWK_E_ACCESS; + break; + } + + return FWK_SUCCESS; +} + +const struct fwk_module module_pinctrl = { + .api_count = (unsigned int)MOD_PIN_CONTROL_API_COUNT, + .type = FWK_MODULE_TYPE_HAL, + .init = pinctrl_init, + .element_init = pinctrl_element_init, + .bind = mod_pinctrl_bind, + .process_bind_request = pinctrl_process_bind_request, +}; -- GitLab From 4023b883f4335b6affaa5c2933452d83c023a296 Mon Sep 17 00:00:00 2001 From: Khaled Ali Ahmed Date: Tue, 24 Dec 2024 16:46:45 +0000 Subject: [PATCH 2/2] module/scmi_pin_control: Align with pinctrl APIs updates - Fix the scmi_pin_control module and UT, after updating the pinctrl APIs. Signed-off-by: Khaled Ali Ahmed --- .../src/mod_scmi_pin_control.c | 26 +- .../test/mocks/Mockmod_pinctrl_extra.c | 522 +++++++++--------- .../test/mocks/Mockmod_pinctrl_extra.h | 124 ++--- .../scmi_pin_control/test/mod_pinctrl_extra.h | 71 ++- .../test/mod_scmi_pin_control_unit_test.c | 103 ++-- 5 files changed, 418 insertions(+), 428 deletions(-) diff --git a/module/scmi_pin_control/src/mod_scmi_pin_control.c b/module/scmi_pin_control/src/mod_scmi_pin_control.c index e87b34e0a..08e97ab37 100644 --- a/module/scmi_pin_control/src/mod_scmi_pin_control.c +++ b/module/scmi_pin_control/src/mod_scmi_pin_control.c @@ -193,18 +193,17 @@ static int scmi_pin_control_protocol_attributes_handler( .attributes_low = 0, .attributes_high = 0, }; - struct mod_pinctrl_protocol_attributes protocol_attributes; + struct mod_pinctrl_info protocol_attributes; - int status = scmi_pin_control_ctx.pinctrl_api->get_protocol_attributes( - &protocol_attributes); + int status = + scmi_pin_control_ctx.pinctrl_api->get_info(&protocol_attributes); if (status == FWK_SUCCESS) { return_values.status = (int32_t)SCMI_SUCCESS; return_values.attributes_low = protocol_attributes.number_of_pins; return_values.attributes_low |= (uint32_t)SHIFT_LEFT_BY_POS( protocol_attributes.number_of_groups, NUM_OF_PIN_GROUPS_POS); - return_values.attributes_high = - protocol_attributes.number_of_functionalities; + return_values.attributes_high = protocol_attributes.number_of_functions; } else { return_values.status = (int32_t)SCMI_GENERIC_ERROR; } @@ -275,11 +274,11 @@ static int scmi_pin_control_attributes_handler( return_values.attributes = pinctrl_attributes.number_of_elements; return_values.attributes |= (uint32_t)SHIFT_LEFT_BY_POS( - pinctrl_attributes.is_pin_only_functionality, + pinctrl_attributes.is_pin_only_function, SCMI_PIN_CONTROL_PIN_ONLY_FUNC_DESCRIPTOR_POS); return_values.attributes |= (uint32_t)SHIFT_LEFT_BY_POS( - pinctrl_attributes.is_gpio_functionality, + pinctrl_attributes.is_gpio_function, SCMI_PIN_CONTROL_GPIO_FUNC_ONLY_POS); name_length += strnlen( @@ -491,7 +490,7 @@ static int scmi_pin_control_settings_get_handler( { uint32_t payload_size; int16_t status; - uint16_t function_selected; + uint32_t function_selected; struct mod_pinctrl_drv_pin_configuration config_pair; const struct scmi_pin_control_settings_get_a2p *parameters; struct scmi_pin_control_setting_get_attributes attributes; @@ -544,13 +543,10 @@ static int scmi_pin_control_settings_get_handler( case SCMI_PIN_CONTROL_FUNCTION_SELECTED: status = - scmi_pin_control_ctx.pinctrl_api - ->get_current_associated_functionality( - mapped_identifier, attributes.selector, &function_selected); + scmi_pin_control_ctx.pinctrl_api->get_current_associated_function( + mapped_identifier, attributes.selector, &function_selected); - if (status == FWK_E_ACCESS) { - return_values.function_selected = NO_FUNCTION_IS_SELECTED; - } else if (status == FWK_SUCCESS) { + if (status == FWK_SUCCESS) { return_values.function_selected = function_selected; } else { goto exit; @@ -618,7 +614,7 @@ static int scmi_pin_control_settings_configure_handler( SCMI_PIN_CONTROL_SET_CONF_SELECTOR_POS_MSB); if (function_id_valid == SCMI_PIN_CONTROL_FUNCTION_ID_VALID) { - status = scmi_pin_control_ctx.pinctrl_api->set_functionality( + status = scmi_pin_control_ctx.pinctrl_api->set_function( mapped_identifier, selector, function_id); if (status != FWK_SUCCESS) { goto exit; diff --git a/module/scmi_pin_control/test/mocks/Mockmod_pinctrl_extra.c b/module/scmi_pin_control/test/mocks/Mockmod_pinctrl_extra.c index 58cf559b3..bb957cb85 100644 --- a/module/scmi_pin_control/test/mocks/Mockmod_pinctrl_extra.c +++ b/module/scmi_pin_control/test/mocks/Mockmod_pinctrl_extra.c @@ -13,21 +13,21 @@ static const char* CMockString_configration_index = "configration_index"; static const char* CMockString_first_index = "first_index"; static const char* CMockString_flag = "flag"; static const char* CMockString_flags = "flags"; -static const char* CMockString_functionality_id = "functionality_id"; +static const char* CMockString_function_id = "function_id"; static const char* CMockString_get_attributes = "get_attributes"; static const char* CMockString_get_configuration = "get_configuration"; static const char* CMockString_get_configuration_value_from_type = "get_configuration_value_from_type"; -static const char* CMockString_get_current_associated_functionality = "get_current_associated_functionality"; +static const char* CMockString_get_current_associated_function = "get_current_associated_function"; +static const char* CMockString_get_info = "get_info"; static const char* CMockString_get_list_associations = "get_list_associations"; -static const char* CMockString_get_protocol_attributes = "get_protocol_attributes"; static const char* CMockString_get_total_number_of_associations = "get_total_number_of_associations"; static const char* CMockString_get_total_number_of_configurations = "get_total_number_of_configurations"; static const char* CMockString_index = "index"; +static const char* CMockString_info = "info"; static const char* CMockString_number_of_configurations = "number_of_configurations"; static const char* CMockString_object_id = "object_id"; -static const char* CMockString_protocol_attributes = "protocol_attributes"; static const char* CMockString_set_configuration = "set_configuration"; -static const char* CMockString_set_functionality = "set_functionality"; +static const char* CMockString_set_function = "set_function"; static const char* CMockString_total_count = "total_count"; typedef struct _CMOCK_get_attributes_CALL_INSTANCE @@ -48,19 +48,19 @@ typedef struct _CMOCK_get_attributes_CALL_INSTANCE } CMOCK_get_attributes_CALL_INSTANCE; -typedef struct _CMOCK_get_protocol_attributes_CALL_INSTANCE +typedef struct _CMOCK_get_info_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; int ReturnVal; - struct mod_pinctrl_protocol_attributes* Expected_protocol_attributes; - int Expected_protocol_attributes_Depth; - char ReturnThruPtr_protocol_attributes_Used; - struct mod_pinctrl_protocol_attributes* ReturnThruPtr_protocol_attributes_Val; - size_t ReturnThruPtr_protocol_attributes_Size; - char IgnoreArg_protocol_attributes; + struct mod_pinctrl_info* Expected_info; + int Expected_info_Depth; + char ReturnThruPtr_info_Used; + struct mod_pinctrl_info* ReturnThruPtr_info_Val; + size_t ReturnThruPtr_info_Size; + char IgnoreArg_info; -} CMOCK_get_protocol_attributes_CALL_INSTANCE; +} CMOCK_get_info_CALL_INSTANCE; typedef struct _CMOCK_get_list_associations_CALL_INSTANCE { @@ -158,23 +158,23 @@ typedef struct _CMOCK_get_total_number_of_configurations_CALL_INSTANCE } CMOCK_get_total_number_of_configurations_CALL_INSTANCE; -typedef struct _CMOCK_get_current_associated_functionality_CALL_INSTANCE +typedef struct _CMOCK_get_current_associated_function_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; int ReturnVal; uint16_t Expected_index; enum mod_pinctrl_selector Expected_flag; - uint16_t* Expected_functionality_id; - int Expected_functionality_id_Depth; - char ReturnThruPtr_functionality_id_Used; - uint16_t* ReturnThruPtr_functionality_id_Val; - size_t ReturnThruPtr_functionality_id_Size; + uint32_t* Expected_function_id; + int Expected_function_id_Depth; + char ReturnThruPtr_function_id_Used; + uint32_t* ReturnThruPtr_function_id_Val; + size_t ReturnThruPtr_function_id_Size; char IgnoreArg_index; char IgnoreArg_flag; - char IgnoreArg_functionality_id; + char IgnoreArg_function_id; -} CMOCK_get_current_associated_functionality_CALL_INSTANCE; +} CMOCK_get_current_associated_function_CALL_INSTANCE; typedef struct _CMOCK_set_configuration_CALL_INSTANCE { @@ -191,19 +191,19 @@ typedef struct _CMOCK_set_configuration_CALL_INSTANCE } CMOCK_set_configuration_CALL_INSTANCE; -typedef struct _CMOCK_set_functionality_CALL_INSTANCE +typedef struct _CMOCK_set_function_CALL_INSTANCE { UNITY_LINE_TYPE LineNumber; char ExpectAnyArgsBool; int ReturnVal; uint16_t Expected_index; enum mod_pinctrl_selector Expected_flag; - uint16_t Expected_functionality_id; + uint32_t Expected_function_id; char IgnoreArg_index; char IgnoreArg_flag; - char IgnoreArg_functionality_id; + char IgnoreArg_function_id; -} CMOCK_set_functionality_CALL_INSTANCE; +} CMOCK_set_function_CALL_INSTANCE; static struct Mockmod_pinctrl_extraInstance { @@ -213,12 +213,12 @@ static struct Mockmod_pinctrl_extraInstance CMOCK_get_attributes_CALLBACK get_attributes_CallbackFunctionPointer; int get_attributes_CallbackCalls; CMOCK_MEM_INDEX_TYPE get_attributes_CallInstance; - char get_protocol_attributes_IgnoreBool; - int get_protocol_attributes_FinalReturn; - char get_protocol_attributes_CallbackBool; - CMOCK_get_protocol_attributes_CALLBACK get_protocol_attributes_CallbackFunctionPointer; - int get_protocol_attributes_CallbackCalls; - CMOCK_MEM_INDEX_TYPE get_protocol_attributes_CallInstance; + char get_info_IgnoreBool; + int get_info_FinalReturn; + char get_info_CallbackBool; + CMOCK_get_info_CALLBACK get_info_CallbackFunctionPointer; + int get_info_CallbackCalls; + CMOCK_MEM_INDEX_TYPE get_info_CallInstance; char get_list_associations_IgnoreBool; int get_list_associations_FinalReturn; char get_list_associations_CallbackBool; @@ -249,24 +249,24 @@ static struct Mockmod_pinctrl_extraInstance CMOCK_get_total_number_of_configurations_CALLBACK get_total_number_of_configurations_CallbackFunctionPointer; int get_total_number_of_configurations_CallbackCalls; CMOCK_MEM_INDEX_TYPE get_total_number_of_configurations_CallInstance; - char get_current_associated_functionality_IgnoreBool; - int get_current_associated_functionality_FinalReturn; - char get_current_associated_functionality_CallbackBool; - CMOCK_get_current_associated_functionality_CALLBACK get_current_associated_functionality_CallbackFunctionPointer; - int get_current_associated_functionality_CallbackCalls; - CMOCK_MEM_INDEX_TYPE get_current_associated_functionality_CallInstance; + char get_current_associated_function_IgnoreBool; + int get_current_associated_function_FinalReturn; + char get_current_associated_function_CallbackBool; + CMOCK_get_current_associated_function_CALLBACK get_current_associated_function_CallbackFunctionPointer; + int get_current_associated_function_CallbackCalls; + CMOCK_MEM_INDEX_TYPE get_current_associated_function_CallInstance; char set_configuration_IgnoreBool; int set_configuration_FinalReturn; char set_configuration_CallbackBool; CMOCK_set_configuration_CALLBACK set_configuration_CallbackFunctionPointer; int set_configuration_CallbackCalls; CMOCK_MEM_INDEX_TYPE set_configuration_CallInstance; - char set_functionality_IgnoreBool; - int set_functionality_FinalReturn; - char set_functionality_CallbackBool; - CMOCK_set_functionality_CALLBACK set_functionality_CallbackFunctionPointer; - int set_functionality_CallbackCalls; - CMOCK_MEM_INDEX_TYPE set_functionality_CallInstance; + char set_function_IgnoreBool; + int set_function_FinalReturn; + char set_function_CallbackBool; + CMOCK_set_function_CALLBACK set_function_CallbackFunctionPointer; + int set_function_CallbackCalls; + CMOCK_MEM_INDEX_TYPE set_function_CallInstance; } Mock; extern jmp_buf AbortFrame; @@ -288,15 +288,15 @@ void Mockmod_pinctrl_extra_Verify(void) call_instance = CMOCK_GUTS_NONE; (void)call_instance; } - call_instance = Mock.get_protocol_attributes_CallInstance; - if (Mock.get_protocol_attributes_IgnoreBool) + call_instance = Mock.get_info_CallInstance; + if (Mock.get_info_IgnoreBool) call_instance = CMOCK_GUTS_NONE; if (CMOCK_GUTS_NONE != call_instance) { - UNITY_SET_DETAIL(CMockString_get_protocol_attributes); + UNITY_SET_DETAIL(CMockString_get_info); UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); } - if (Mock.get_protocol_attributes_CallbackFunctionPointer != NULL) + if (Mock.get_info_CallbackFunctionPointer != NULL) { call_instance = CMOCK_GUTS_NONE; (void)call_instance; @@ -366,15 +366,15 @@ void Mockmod_pinctrl_extra_Verify(void) call_instance = CMOCK_GUTS_NONE; (void)call_instance; } - call_instance = Mock.get_current_associated_functionality_CallInstance; - if (Mock.get_current_associated_functionality_IgnoreBool) + call_instance = Mock.get_current_associated_function_CallInstance; + if (Mock.get_current_associated_function_IgnoreBool) call_instance = CMOCK_GUTS_NONE; if (CMOCK_GUTS_NONE != call_instance) { - UNITY_SET_DETAIL(CMockString_get_current_associated_functionality); + UNITY_SET_DETAIL(CMockString_get_current_associated_function); UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); } - if (Mock.get_current_associated_functionality_CallbackFunctionPointer != NULL) + if (Mock.get_current_associated_function_CallbackFunctionPointer != NULL) { call_instance = CMOCK_GUTS_NONE; (void)call_instance; @@ -392,15 +392,15 @@ void Mockmod_pinctrl_extra_Verify(void) call_instance = CMOCK_GUTS_NONE; (void)call_instance; } - call_instance = Mock.set_functionality_CallInstance; - if (Mock.set_functionality_IgnoreBool) + call_instance = Mock.set_function_CallInstance; + if (Mock.set_function_IgnoreBool) call_instance = CMOCK_GUTS_NONE; if (CMOCK_GUTS_NONE != call_instance) { - UNITY_SET_DETAIL(CMockString_set_functionality); + UNITY_SET_DETAIL(CMockString_set_function); UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); } - if (Mock.set_functionality_CallbackFunctionPointer != NULL) + if (Mock.set_function_CallbackFunctionPointer != NULL) { call_instance = CMOCK_GUTS_NONE; (void)call_instance; @@ -598,25 +598,25 @@ void get_attributes_CMockIgnoreArg_attributes(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_attributes = 1; } -int get_protocol_attributes(struct mod_pinctrl_protocol_attributes* protocol_attributes) +int get_info(struct mod_pinctrl_info* info) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_get_protocol_attributes_CALL_INSTANCE* cmock_call_instance; - UNITY_SET_DETAIL(CMockString_get_protocol_attributes); - cmock_call_instance = (CMOCK_get_protocol_attributes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_protocol_attributes_CallInstance); - Mock.get_protocol_attributes_CallInstance = CMock_Guts_MemNext(Mock.get_protocol_attributes_CallInstance); - if (Mock.get_protocol_attributes_IgnoreBool) + CMOCK_get_info_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_get_info); + cmock_call_instance = (CMOCK_get_info_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_info_CallInstance); + Mock.get_info_CallInstance = CMock_Guts_MemNext(Mock.get_info_CallInstance); + if (Mock.get_info_IgnoreBool) { UNITY_CLR_DETAILS(); if (cmock_call_instance == NULL) - return Mock.get_protocol_attributes_FinalReturn; - Mock.get_protocol_attributes_FinalReturn = cmock_call_instance->ReturnVal; + return Mock.get_info_FinalReturn; + Mock.get_info_FinalReturn = cmock_call_instance->ReturnVal; return cmock_call_instance->ReturnVal; } - if (!Mock.get_protocol_attributes_CallbackBool && - Mock.get_protocol_attributes_CallbackFunctionPointer != NULL) + if (!Mock.get_info_CallbackBool && + Mock.get_info_CallbackFunctionPointer != NULL) { - int cmock_cb_ret = Mock.get_protocol_attributes_CallbackFunctionPointer(protocol_attributes, Mock.get_protocol_attributes_CallbackCalls++); + int cmock_cb_ret = Mock.get_info_CallbackFunctionPointer(info, Mock.get_info_CallbackCalls++); UNITY_CLR_DETAILS(); return cmock_cb_ret; } @@ -624,129 +624,129 @@ int get_protocol_attributes(struct mod_pinctrl_protocol_attributes* protocol_att cmock_line = cmock_call_instance->LineNumber; if (!cmock_call_instance->ExpectAnyArgsBool) { - if (!cmock_call_instance->IgnoreArg_protocol_attributes) + if (!cmock_call_instance->IgnoreArg_info) { - UNITY_SET_DETAILS(CMockString_get_protocol_attributes,CMockString_protocol_attributes); - if (cmock_call_instance->Expected_protocol_attributes == NULL) - { UNITY_TEST_ASSERT_NULL(protocol_attributes, cmock_line, CMockStringExpNULL); } + UNITY_SET_DETAILS(CMockString_get_info,CMockString_info); + if (cmock_call_instance->Expected_info == NULL) + { UNITY_TEST_ASSERT_NULL(info, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_protocol_attributes), (void*)(protocol_attributes), sizeof(struct mod_pinctrl_protocol_attributes), cmock_call_instance->Expected_protocol_attributes_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_info), (void*)(info), sizeof(struct mod_pinctrl_info), cmock_call_instance->Expected_info_Depth, cmock_line, CMockStringMismatch); } } } - if (Mock.get_protocol_attributes_CallbackFunctionPointer != NULL) + if (Mock.get_info_CallbackFunctionPointer != NULL) { - cmock_call_instance->ReturnVal = Mock.get_protocol_attributes_CallbackFunctionPointer(protocol_attributes, Mock.get_protocol_attributes_CallbackCalls++); + cmock_call_instance->ReturnVal = Mock.get_info_CallbackFunctionPointer(info, Mock.get_info_CallbackCalls++); } - if (cmock_call_instance->ReturnThruPtr_protocol_attributes_Used) + if (cmock_call_instance->ReturnThruPtr_info_Used) { - UNITY_TEST_ASSERT_NOT_NULL(protocol_attributes, cmock_line, CMockStringPtrIsNULL); - memcpy((void*)protocol_attributes, (void*)cmock_call_instance->ReturnThruPtr_protocol_attributes_Val, - cmock_call_instance->ReturnThruPtr_protocol_attributes_Size); + UNITY_TEST_ASSERT_NOT_NULL(info, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)info, (void*)cmock_call_instance->ReturnThruPtr_info_Val, + cmock_call_instance->ReturnThruPtr_info_Size); } UNITY_CLR_DETAILS(); return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_get_protocol_attributes(CMOCK_get_protocol_attributes_CALL_INSTANCE* cmock_call_instance, struct mod_pinctrl_protocol_attributes* protocol_attributes, int protocol_attributes_Depth); -void CMockExpectParameters_get_protocol_attributes(CMOCK_get_protocol_attributes_CALL_INSTANCE* cmock_call_instance, struct mod_pinctrl_protocol_attributes* protocol_attributes, int protocol_attributes_Depth) +void CMockExpectParameters_get_info(CMOCK_get_info_CALL_INSTANCE* cmock_call_instance, struct mod_pinctrl_info* info, int info_Depth); +void CMockExpectParameters_get_info(CMOCK_get_info_CALL_INSTANCE* cmock_call_instance, struct mod_pinctrl_info* info, int info_Depth) { - cmock_call_instance->Expected_protocol_attributes = protocol_attributes; - cmock_call_instance->Expected_protocol_attributes_Depth = protocol_attributes_Depth; - cmock_call_instance->IgnoreArg_protocol_attributes = 0; - cmock_call_instance->ReturnThruPtr_protocol_attributes_Used = 0; + cmock_call_instance->Expected_info = info; + cmock_call_instance->Expected_info_Depth = info_Depth; + cmock_call_instance->IgnoreArg_info = 0; + cmock_call_instance->ReturnThruPtr_info_Used = 0; } -void get_protocol_attributes_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +void get_info_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_protocol_attributes_CALL_INSTANCE)); - CMOCK_get_protocol_attributes_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_protocol_attributes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_info_CALL_INSTANCE)); + CMOCK_get_info_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_info_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_protocol_attributes_CallInstance = CMock_Guts_MemChain(Mock.get_protocol_attributes_CallInstance, cmock_guts_index); - Mock.get_protocol_attributes_IgnoreBool = (char)0; + Mock.get_info_CallInstance = CMock_Guts_MemChain(Mock.get_info_CallInstance, cmock_guts_index); + Mock.get_info_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; cmock_call_instance->ReturnVal = cmock_to_return; - Mock.get_protocol_attributes_IgnoreBool = (char)1; + Mock.get_info_IgnoreBool = (char)1; } -void get_protocol_attributes_CMockStopIgnore(void) +void get_info_CMockStopIgnore(void) { - if(Mock.get_protocol_attributes_IgnoreBool) - Mock.get_protocol_attributes_CallInstance = CMock_Guts_MemNext(Mock.get_protocol_attributes_CallInstance); - Mock.get_protocol_attributes_IgnoreBool = (char)0; + if(Mock.get_info_IgnoreBool) + Mock.get_info_CallInstance = CMock_Guts_MemNext(Mock.get_info_CallInstance); + Mock.get_info_IgnoreBool = (char)0; } -void get_protocol_attributes_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +void get_info_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_protocol_attributes_CALL_INSTANCE)); - CMOCK_get_protocol_attributes_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_protocol_attributes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_info_CALL_INSTANCE)); + CMOCK_get_info_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_info_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_protocol_attributes_CallInstance = CMock_Guts_MemChain(Mock.get_protocol_attributes_CallInstance, cmock_guts_index); - Mock.get_protocol_attributes_IgnoreBool = (char)0; + Mock.get_info_CallInstance = CMock_Guts_MemChain(Mock.get_info_CallInstance, cmock_guts_index); + Mock.get_info_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; cmock_call_instance->ReturnVal = cmock_to_return; cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void get_protocol_attributes_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct mod_pinctrl_protocol_attributes* protocol_attributes, int cmock_to_return) +void get_info_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct mod_pinctrl_info* info, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_protocol_attributes_CALL_INSTANCE)); - CMOCK_get_protocol_attributes_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_protocol_attributes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_info_CALL_INSTANCE)); + CMOCK_get_info_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_info_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_protocol_attributes_CallInstance = CMock_Guts_MemChain(Mock.get_protocol_attributes_CallInstance, cmock_guts_index); - Mock.get_protocol_attributes_IgnoreBool = (char)0; + Mock.get_info_CallInstance = CMock_Guts_MemChain(Mock.get_info_CallInstance, cmock_guts_index); + Mock.get_info_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_get_protocol_attributes(cmock_call_instance, protocol_attributes, 1); + CMockExpectParameters_get_info(cmock_call_instance, info, 1); cmock_call_instance->ReturnVal = cmock_to_return; } -void get_protocol_attributes_AddCallback(CMOCK_get_protocol_attributes_CALLBACK Callback) +void get_info_AddCallback(CMOCK_get_info_CALLBACK Callback) { - Mock.get_protocol_attributes_IgnoreBool = (char)0; - Mock.get_protocol_attributes_CallbackBool = (char)1; - Mock.get_protocol_attributes_CallbackFunctionPointer = Callback; + Mock.get_info_IgnoreBool = (char)0; + Mock.get_info_CallbackBool = (char)1; + Mock.get_info_CallbackFunctionPointer = Callback; } -void get_protocol_attributes_Stub(CMOCK_get_protocol_attributes_CALLBACK Callback) +void get_info_Stub(CMOCK_get_info_CALLBACK Callback) { - Mock.get_protocol_attributes_IgnoreBool = (char)0; - Mock.get_protocol_attributes_CallbackBool = (char)0; - Mock.get_protocol_attributes_CallbackFunctionPointer = Callback; + Mock.get_info_IgnoreBool = (char)0; + Mock.get_info_CallbackBool = (char)0; + Mock.get_info_CallbackFunctionPointer = Callback; } -void get_protocol_attributes_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct mod_pinctrl_protocol_attributes* protocol_attributes, int protocol_attributes_Depth, int cmock_to_return) +void get_info_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct mod_pinctrl_info* info, int info_Depth, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_protocol_attributes_CALL_INSTANCE)); - CMOCK_get_protocol_attributes_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_protocol_attributes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_info_CALL_INSTANCE)); + CMOCK_get_info_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_info_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_protocol_attributes_CallInstance = CMock_Guts_MemChain(Mock.get_protocol_attributes_CallInstance, cmock_guts_index); - Mock.get_protocol_attributes_IgnoreBool = (char)0; + Mock.get_info_CallInstance = CMock_Guts_MemChain(Mock.get_info_CallInstance, cmock_guts_index); + Mock.get_info_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_get_protocol_attributes(cmock_call_instance, protocol_attributes, protocol_attributes_Depth); + CMockExpectParameters_get_info(cmock_call_instance, info, info_Depth); cmock_call_instance->ReturnVal = cmock_to_return; } -void get_protocol_attributes_CMockReturnMemThruPtr_protocol_attributes(UNITY_LINE_TYPE cmock_line, struct mod_pinctrl_protocol_attributes* protocol_attributes, size_t cmock_size) +void get_info_CMockReturnMemThruPtr_info(UNITY_LINE_TYPE cmock_line, struct mod_pinctrl_info* info, size_t cmock_size) { - CMOCK_get_protocol_attributes_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_protocol_attributes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_protocol_attributes_CallInstance)); + CMOCK_get_info_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_info_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_info_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); - cmock_call_instance->ReturnThruPtr_protocol_attributes_Used = 1; - cmock_call_instance->ReturnThruPtr_protocol_attributes_Val = protocol_attributes; - cmock_call_instance->ReturnThruPtr_protocol_attributes_Size = cmock_size; + cmock_call_instance->ReturnThruPtr_info_Used = 1; + cmock_call_instance->ReturnThruPtr_info_Val = info; + cmock_call_instance->ReturnThruPtr_info_Size = cmock_size; } -void get_protocol_attributes_CMockIgnoreArg_protocol_attributes(UNITY_LINE_TYPE cmock_line) +void get_info_CMockIgnoreArg_info(UNITY_LINE_TYPE cmock_line) { - CMOCK_get_protocol_attributes_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_protocol_attributes_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_protocol_attributes_CallInstance)); + CMOCK_get_info_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_info_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_info_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_protocol_attributes = 1; + cmock_call_instance->IgnoreArg_info = 1; } int get_list_associations(uint16_t index, enum mod_pinctrl_selector flags, uint16_t first_index, uint16_t* object_id) @@ -1692,25 +1692,25 @@ void get_total_number_of_configurations_CMockIgnoreArg_number_of_configurations( cmock_call_instance->IgnoreArg_number_of_configurations = 1; } -int get_current_associated_functionality(uint16_t index, enum mod_pinctrl_selector flag, uint16_t* functionality_id) +int get_current_associated_function(uint16_t index, enum mod_pinctrl_selector flag, uint32_t* function_id) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_get_current_associated_functionality_CALL_INSTANCE* cmock_call_instance; - UNITY_SET_DETAIL(CMockString_get_current_associated_functionality); - cmock_call_instance = (CMOCK_get_current_associated_functionality_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_current_associated_functionality_CallInstance); - Mock.get_current_associated_functionality_CallInstance = CMock_Guts_MemNext(Mock.get_current_associated_functionality_CallInstance); - if (Mock.get_current_associated_functionality_IgnoreBool) + CMOCK_get_current_associated_function_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_get_current_associated_function); + cmock_call_instance = (CMOCK_get_current_associated_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_current_associated_function_CallInstance); + Mock.get_current_associated_function_CallInstance = CMock_Guts_MemNext(Mock.get_current_associated_function_CallInstance); + if (Mock.get_current_associated_function_IgnoreBool) { UNITY_CLR_DETAILS(); if (cmock_call_instance == NULL) - return Mock.get_current_associated_functionality_FinalReturn; - Mock.get_current_associated_functionality_FinalReturn = cmock_call_instance->ReturnVal; + return Mock.get_current_associated_function_FinalReturn; + Mock.get_current_associated_function_FinalReturn = cmock_call_instance->ReturnVal; return cmock_call_instance->ReturnVal; } - if (!Mock.get_current_associated_functionality_CallbackBool && - Mock.get_current_associated_functionality_CallbackFunctionPointer != NULL) + if (!Mock.get_current_associated_function_CallbackBool && + Mock.get_current_associated_function_CallbackFunctionPointer != NULL) { - int cmock_cb_ret = Mock.get_current_associated_functionality_CallbackFunctionPointer(index, flag, functionality_id, Mock.get_current_associated_functionality_CallbackCalls++); + int cmock_cb_ret = Mock.get_current_associated_function_CallbackFunctionPointer(index, flag, function_id, Mock.get_current_associated_function_CallbackCalls++); UNITY_CLR_DETAILS(); return cmock_cb_ret; } @@ -1720,156 +1720,156 @@ int get_current_associated_functionality(uint16_t index, enum mod_pinctrl_select { if (!cmock_call_instance->IgnoreArg_index) { - UNITY_SET_DETAILS(CMockString_get_current_associated_functionality,CMockString_index); + UNITY_SET_DETAILS(CMockString_get_current_associated_function,CMockString_index); UNITY_TEST_ASSERT_EQUAL_HEX16(cmock_call_instance->Expected_index, index, cmock_line, CMockStringMismatch); } if (!cmock_call_instance->IgnoreArg_flag) { - UNITY_SET_DETAILS(CMockString_get_current_associated_functionality,CMockString_flag); + UNITY_SET_DETAILS(CMockString_get_current_associated_function,CMockString_flag); UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_flag), (void*)(&flag), sizeof(enum mod_pinctrl_selector), cmock_line, CMockStringMismatch); } - if (!cmock_call_instance->IgnoreArg_functionality_id) + if (!cmock_call_instance->IgnoreArg_function_id) { - UNITY_SET_DETAILS(CMockString_get_current_associated_functionality,CMockString_functionality_id); - if (cmock_call_instance->Expected_functionality_id == NULL) - { UNITY_TEST_ASSERT_NULL(functionality_id, cmock_line, CMockStringExpNULL); } + UNITY_SET_DETAILS(CMockString_get_current_associated_function,CMockString_function_id); + if (cmock_call_instance->Expected_function_id == NULL) + { UNITY_TEST_ASSERT_NULL(function_id, cmock_line, CMockStringExpNULL); } else - { UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(cmock_call_instance->Expected_functionality_id, functionality_id, cmock_call_instance->Expected_functionality_id_Depth, cmock_line, CMockStringMismatch); } + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_function_id, function_id, cmock_call_instance->Expected_function_id_Depth, cmock_line, CMockStringMismatch); } } } - if (Mock.get_current_associated_functionality_CallbackFunctionPointer != NULL) + if (Mock.get_current_associated_function_CallbackFunctionPointer != NULL) { - cmock_call_instance->ReturnVal = Mock.get_current_associated_functionality_CallbackFunctionPointer(index, flag, functionality_id, Mock.get_current_associated_functionality_CallbackCalls++); + cmock_call_instance->ReturnVal = Mock.get_current_associated_function_CallbackFunctionPointer(index, flag, function_id, Mock.get_current_associated_function_CallbackCalls++); } - if (cmock_call_instance->ReturnThruPtr_functionality_id_Used) + if (cmock_call_instance->ReturnThruPtr_function_id_Used) { - UNITY_TEST_ASSERT_NOT_NULL(functionality_id, cmock_line, CMockStringPtrIsNULL); - memcpy((void*)functionality_id, (void*)cmock_call_instance->ReturnThruPtr_functionality_id_Val, - cmock_call_instance->ReturnThruPtr_functionality_id_Size); + UNITY_TEST_ASSERT_NOT_NULL(function_id, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)function_id, (void*)cmock_call_instance->ReturnThruPtr_function_id_Val, + cmock_call_instance->ReturnThruPtr_function_id_Size); } UNITY_CLR_DETAILS(); return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_get_current_associated_functionality(CMOCK_get_current_associated_functionality_CALL_INSTANCE* cmock_call_instance, uint16_t index, enum mod_pinctrl_selector flag, uint16_t* functionality_id, int functionality_id_Depth); -void CMockExpectParameters_get_current_associated_functionality(CMOCK_get_current_associated_functionality_CALL_INSTANCE* cmock_call_instance, uint16_t index, enum mod_pinctrl_selector flag, uint16_t* functionality_id, int functionality_id_Depth) +void CMockExpectParameters_get_current_associated_function(CMOCK_get_current_associated_function_CALL_INSTANCE* cmock_call_instance, uint16_t index, enum mod_pinctrl_selector flag, uint32_t* function_id, int function_id_Depth); +void CMockExpectParameters_get_current_associated_function(CMOCK_get_current_associated_function_CALL_INSTANCE* cmock_call_instance, uint16_t index, enum mod_pinctrl_selector flag, uint32_t* function_id, int function_id_Depth) { cmock_call_instance->Expected_index = index; cmock_call_instance->IgnoreArg_index = 0; memcpy((void*)(&cmock_call_instance->Expected_flag), (void*)(&flag), sizeof(enum mod_pinctrl_selector[sizeof(flag) == sizeof(enum mod_pinctrl_selector) ? 1 : -1])); /* add enum mod_pinctrl_selector to :treat_as_array if this causes an error */ cmock_call_instance->IgnoreArg_flag = 0; - cmock_call_instance->Expected_functionality_id = functionality_id; - cmock_call_instance->Expected_functionality_id_Depth = functionality_id_Depth; - cmock_call_instance->IgnoreArg_functionality_id = 0; - cmock_call_instance->ReturnThruPtr_functionality_id_Used = 0; + cmock_call_instance->Expected_function_id = function_id; + cmock_call_instance->Expected_function_id_Depth = function_id_Depth; + cmock_call_instance->IgnoreArg_function_id = 0; + cmock_call_instance->ReturnThruPtr_function_id_Used = 0; } -void get_current_associated_functionality_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +void get_current_associated_function_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_current_associated_functionality_CALL_INSTANCE)); - CMOCK_get_current_associated_functionality_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_current_associated_functionality_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_current_associated_function_CALL_INSTANCE)); + CMOCK_get_current_associated_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_current_associated_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_current_associated_functionality_CallInstance = CMock_Guts_MemChain(Mock.get_current_associated_functionality_CallInstance, cmock_guts_index); - Mock.get_current_associated_functionality_IgnoreBool = (char)0; + Mock.get_current_associated_function_CallInstance = CMock_Guts_MemChain(Mock.get_current_associated_function_CallInstance, cmock_guts_index); + Mock.get_current_associated_function_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; cmock_call_instance->ReturnVal = cmock_to_return; - Mock.get_current_associated_functionality_IgnoreBool = (char)1; + Mock.get_current_associated_function_IgnoreBool = (char)1; } -void get_current_associated_functionality_CMockStopIgnore(void) +void get_current_associated_function_CMockStopIgnore(void) { - if(Mock.get_current_associated_functionality_IgnoreBool) - Mock.get_current_associated_functionality_CallInstance = CMock_Guts_MemNext(Mock.get_current_associated_functionality_CallInstance); - Mock.get_current_associated_functionality_IgnoreBool = (char)0; + if(Mock.get_current_associated_function_IgnoreBool) + Mock.get_current_associated_function_CallInstance = CMock_Guts_MemNext(Mock.get_current_associated_function_CallInstance); + Mock.get_current_associated_function_IgnoreBool = (char)0; } -void get_current_associated_functionality_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +void get_current_associated_function_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_current_associated_functionality_CALL_INSTANCE)); - CMOCK_get_current_associated_functionality_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_current_associated_functionality_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_current_associated_function_CALL_INSTANCE)); + CMOCK_get_current_associated_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_current_associated_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_current_associated_functionality_CallInstance = CMock_Guts_MemChain(Mock.get_current_associated_functionality_CallInstance, cmock_guts_index); - Mock.get_current_associated_functionality_IgnoreBool = (char)0; + Mock.get_current_associated_function_CallInstance = CMock_Guts_MemChain(Mock.get_current_associated_function_CallInstance, cmock_guts_index); + Mock.get_current_associated_function_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; cmock_call_instance->ReturnVal = cmock_to_return; cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void get_current_associated_functionality_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t index, enum mod_pinctrl_selector flag, uint16_t* functionality_id, int cmock_to_return) +void get_current_associated_function_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t index, enum mod_pinctrl_selector flag, uint32_t* function_id, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_current_associated_functionality_CALL_INSTANCE)); - CMOCK_get_current_associated_functionality_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_current_associated_functionality_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_current_associated_function_CALL_INSTANCE)); + CMOCK_get_current_associated_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_current_associated_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_current_associated_functionality_CallInstance = CMock_Guts_MemChain(Mock.get_current_associated_functionality_CallInstance, cmock_guts_index); - Mock.get_current_associated_functionality_IgnoreBool = (char)0; + Mock.get_current_associated_function_CallInstance = CMock_Guts_MemChain(Mock.get_current_associated_function_CallInstance, cmock_guts_index); + Mock.get_current_associated_function_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_get_current_associated_functionality(cmock_call_instance, index, flag, functionality_id, 1); + CMockExpectParameters_get_current_associated_function(cmock_call_instance, index, flag, function_id, 1); cmock_call_instance->ReturnVal = cmock_to_return; } -void get_current_associated_functionality_AddCallback(CMOCK_get_current_associated_functionality_CALLBACK Callback) +void get_current_associated_function_AddCallback(CMOCK_get_current_associated_function_CALLBACK Callback) { - Mock.get_current_associated_functionality_IgnoreBool = (char)0; - Mock.get_current_associated_functionality_CallbackBool = (char)1; - Mock.get_current_associated_functionality_CallbackFunctionPointer = Callback; + Mock.get_current_associated_function_IgnoreBool = (char)0; + Mock.get_current_associated_function_CallbackBool = (char)1; + Mock.get_current_associated_function_CallbackFunctionPointer = Callback; } -void get_current_associated_functionality_Stub(CMOCK_get_current_associated_functionality_CALLBACK Callback) +void get_current_associated_function_Stub(CMOCK_get_current_associated_function_CALLBACK Callback) { - Mock.get_current_associated_functionality_IgnoreBool = (char)0; - Mock.get_current_associated_functionality_CallbackBool = (char)0; - Mock.get_current_associated_functionality_CallbackFunctionPointer = Callback; + Mock.get_current_associated_function_IgnoreBool = (char)0; + Mock.get_current_associated_function_CallbackBool = (char)0; + Mock.get_current_associated_function_CallbackFunctionPointer = Callback; } -void get_current_associated_functionality_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t index, enum mod_pinctrl_selector flag, uint16_t* functionality_id, int functionality_id_Depth, int cmock_to_return) +void get_current_associated_function_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t index, enum mod_pinctrl_selector flag, uint32_t* function_id, int function_id_Depth, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_current_associated_functionality_CALL_INSTANCE)); - CMOCK_get_current_associated_functionality_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_current_associated_functionality_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_current_associated_function_CALL_INSTANCE)); + CMOCK_get_current_associated_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_current_associated_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.get_current_associated_functionality_CallInstance = CMock_Guts_MemChain(Mock.get_current_associated_functionality_CallInstance, cmock_guts_index); - Mock.get_current_associated_functionality_IgnoreBool = (char)0; + Mock.get_current_associated_function_CallInstance = CMock_Guts_MemChain(Mock.get_current_associated_function_CallInstance, cmock_guts_index); + Mock.get_current_associated_function_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_get_current_associated_functionality(cmock_call_instance, index, flag, functionality_id, functionality_id_Depth); + CMockExpectParameters_get_current_associated_function(cmock_call_instance, index, flag, function_id, function_id_Depth); cmock_call_instance->ReturnVal = cmock_to_return; } -void get_current_associated_functionality_CMockReturnMemThruPtr_functionality_id(UNITY_LINE_TYPE cmock_line, uint16_t* functionality_id, size_t cmock_size) +void get_current_associated_function_CMockReturnMemThruPtr_function_id(UNITY_LINE_TYPE cmock_line, uint32_t* function_id, size_t cmock_size) { - CMOCK_get_current_associated_functionality_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_current_associated_functionality_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_current_associated_functionality_CallInstance)); + CMOCK_get_current_associated_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_current_associated_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_current_associated_function_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); - cmock_call_instance->ReturnThruPtr_functionality_id_Used = 1; - cmock_call_instance->ReturnThruPtr_functionality_id_Val = functionality_id; - cmock_call_instance->ReturnThruPtr_functionality_id_Size = cmock_size; + cmock_call_instance->ReturnThruPtr_function_id_Used = 1; + cmock_call_instance->ReturnThruPtr_function_id_Val = function_id; + cmock_call_instance->ReturnThruPtr_function_id_Size = cmock_size; } -void get_current_associated_functionality_CMockIgnoreArg_index(UNITY_LINE_TYPE cmock_line) +void get_current_associated_function_CMockIgnoreArg_index(UNITY_LINE_TYPE cmock_line) { - CMOCK_get_current_associated_functionality_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_current_associated_functionality_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_current_associated_functionality_CallInstance)); + CMOCK_get_current_associated_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_current_associated_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_current_associated_function_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); cmock_call_instance->IgnoreArg_index = 1; } -void get_current_associated_functionality_CMockIgnoreArg_flag(UNITY_LINE_TYPE cmock_line) +void get_current_associated_function_CMockIgnoreArg_flag(UNITY_LINE_TYPE cmock_line) { - CMOCK_get_current_associated_functionality_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_current_associated_functionality_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_current_associated_functionality_CallInstance)); + CMOCK_get_current_associated_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_current_associated_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_current_associated_function_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); cmock_call_instance->IgnoreArg_flag = 1; } -void get_current_associated_functionality_CMockIgnoreArg_functionality_id(UNITY_LINE_TYPE cmock_line) +void get_current_associated_function_CMockIgnoreArg_function_id(UNITY_LINE_TYPE cmock_line) { - CMOCK_get_current_associated_functionality_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_current_associated_functionality_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_current_associated_functionality_CallInstance)); + CMOCK_get_current_associated_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_current_associated_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_current_associated_function_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_functionality_id = 1; + cmock_call_instance->IgnoreArg_function_id = 1; } int set_configuration(uint16_t index, enum mod_pinctrl_selector flag, const struct mod_pinctrl_drv_pin_configuration* config) @@ -2036,25 +2036,25 @@ void set_configuration_CMockIgnoreArg_config(UNITY_LINE_TYPE cmock_line) cmock_call_instance->IgnoreArg_config = 1; } -int set_functionality(uint16_t index, enum mod_pinctrl_selector flag, uint16_t functionality_id) +int set_function(uint16_t index, enum mod_pinctrl_selector flag, uint32_t function_id) { UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; - CMOCK_set_functionality_CALL_INSTANCE* cmock_call_instance; - UNITY_SET_DETAIL(CMockString_set_functionality); - cmock_call_instance = (CMOCK_set_functionality_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.set_functionality_CallInstance); - Mock.set_functionality_CallInstance = CMock_Guts_MemNext(Mock.set_functionality_CallInstance); - if (Mock.set_functionality_IgnoreBool) + CMOCK_set_function_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_set_function); + cmock_call_instance = (CMOCK_set_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.set_function_CallInstance); + Mock.set_function_CallInstance = CMock_Guts_MemNext(Mock.set_function_CallInstance); + if (Mock.set_function_IgnoreBool) { UNITY_CLR_DETAILS(); if (cmock_call_instance == NULL) - return Mock.set_functionality_FinalReturn; - Mock.set_functionality_FinalReturn = cmock_call_instance->ReturnVal; + return Mock.set_function_FinalReturn; + Mock.set_function_FinalReturn = cmock_call_instance->ReturnVal; return cmock_call_instance->ReturnVal; } - if (!Mock.set_functionality_CallbackBool && - Mock.set_functionality_CallbackFunctionPointer != NULL) + if (!Mock.set_function_CallbackBool && + Mock.set_function_CallbackFunctionPointer != NULL) { - int cmock_cb_ret = Mock.set_functionality_CallbackFunctionPointer(index, flag, functionality_id, Mock.set_functionality_CallbackCalls++); + int cmock_cb_ret = Mock.set_function_CallbackFunctionPointer(index, flag, function_id, Mock.set_function_CallbackCalls++); UNITY_CLR_DETAILS(); return cmock_cb_ret; } @@ -2064,121 +2064,121 @@ int set_functionality(uint16_t index, enum mod_pinctrl_selector flag, uint16_t f { if (!cmock_call_instance->IgnoreArg_index) { - UNITY_SET_DETAILS(CMockString_set_functionality,CMockString_index); + UNITY_SET_DETAILS(CMockString_set_function,CMockString_index); UNITY_TEST_ASSERT_EQUAL_HEX16(cmock_call_instance->Expected_index, index, cmock_line, CMockStringMismatch); } if (!cmock_call_instance->IgnoreArg_flag) { - UNITY_SET_DETAILS(CMockString_set_functionality,CMockString_flag); + UNITY_SET_DETAILS(CMockString_set_function,CMockString_flag); UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_flag), (void*)(&flag), sizeof(enum mod_pinctrl_selector), cmock_line, CMockStringMismatch); } - if (!cmock_call_instance->IgnoreArg_functionality_id) + if (!cmock_call_instance->IgnoreArg_function_id) { - UNITY_SET_DETAILS(CMockString_set_functionality,CMockString_functionality_id); - UNITY_TEST_ASSERT_EQUAL_HEX16(cmock_call_instance->Expected_functionality_id, functionality_id, cmock_line, CMockStringMismatch); + UNITY_SET_DETAILS(CMockString_set_function,CMockString_function_id); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_function_id, function_id, cmock_line, CMockStringMismatch); } } - if (Mock.set_functionality_CallbackFunctionPointer != NULL) + if (Mock.set_function_CallbackFunctionPointer != NULL) { - cmock_call_instance->ReturnVal = Mock.set_functionality_CallbackFunctionPointer(index, flag, functionality_id, Mock.set_functionality_CallbackCalls++); + cmock_call_instance->ReturnVal = Mock.set_function_CallbackFunctionPointer(index, flag, function_id, Mock.set_function_CallbackCalls++); } UNITY_CLR_DETAILS(); return cmock_call_instance->ReturnVal; } -void CMockExpectParameters_set_functionality(CMOCK_set_functionality_CALL_INSTANCE* cmock_call_instance, uint16_t index, enum mod_pinctrl_selector flag, uint16_t functionality_id); -void CMockExpectParameters_set_functionality(CMOCK_set_functionality_CALL_INSTANCE* cmock_call_instance, uint16_t index, enum mod_pinctrl_selector flag, uint16_t functionality_id) +void CMockExpectParameters_set_function(CMOCK_set_function_CALL_INSTANCE* cmock_call_instance, uint16_t index, enum mod_pinctrl_selector flag, uint32_t function_id); +void CMockExpectParameters_set_function(CMOCK_set_function_CALL_INSTANCE* cmock_call_instance, uint16_t index, enum mod_pinctrl_selector flag, uint32_t function_id) { cmock_call_instance->Expected_index = index; cmock_call_instance->IgnoreArg_index = 0; memcpy((void*)(&cmock_call_instance->Expected_flag), (void*)(&flag), sizeof(enum mod_pinctrl_selector[sizeof(flag) == sizeof(enum mod_pinctrl_selector) ? 1 : -1])); /* add enum mod_pinctrl_selector to :treat_as_array if this causes an error */ cmock_call_instance->IgnoreArg_flag = 0; - cmock_call_instance->Expected_functionality_id = functionality_id; - cmock_call_instance->IgnoreArg_functionality_id = 0; + cmock_call_instance->Expected_function_id = function_id; + cmock_call_instance->IgnoreArg_function_id = 0; } -void set_functionality_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +void set_function_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_functionality_CALL_INSTANCE)); - CMOCK_set_functionality_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_functionality_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_function_CALL_INSTANCE)); + CMOCK_set_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.set_functionality_CallInstance = CMock_Guts_MemChain(Mock.set_functionality_CallInstance, cmock_guts_index); - Mock.set_functionality_IgnoreBool = (char)0; + Mock.set_function_CallInstance = CMock_Guts_MemChain(Mock.set_function_CallInstance, cmock_guts_index); + Mock.set_function_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; cmock_call_instance->ReturnVal = cmock_to_return; - Mock.set_functionality_IgnoreBool = (char)1; + Mock.set_function_IgnoreBool = (char)1; } -void set_functionality_CMockStopIgnore(void) +void set_function_CMockStopIgnore(void) { - if(Mock.set_functionality_IgnoreBool) - Mock.set_functionality_CallInstance = CMock_Guts_MemNext(Mock.set_functionality_CallInstance); - Mock.set_functionality_IgnoreBool = (char)0; + if(Mock.set_function_IgnoreBool) + Mock.set_function_CallInstance = CMock_Guts_MemNext(Mock.set_function_CallInstance); + Mock.set_function_IgnoreBool = (char)0; } -void set_functionality_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +void set_function_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_functionality_CALL_INSTANCE)); - CMOCK_set_functionality_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_functionality_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_function_CALL_INSTANCE)); + CMOCK_set_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.set_functionality_CallInstance = CMock_Guts_MemChain(Mock.set_functionality_CallInstance, cmock_guts_index); - Mock.set_functionality_IgnoreBool = (char)0; + Mock.set_function_CallInstance = CMock_Guts_MemChain(Mock.set_function_CallInstance, cmock_guts_index); + Mock.set_function_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; cmock_call_instance->ReturnVal = cmock_to_return; cmock_call_instance->ExpectAnyArgsBool = (char)1; } -void set_functionality_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t index, enum mod_pinctrl_selector flag, uint16_t functionality_id, int cmock_to_return) +void set_function_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t index, enum mod_pinctrl_selector flag, uint32_t function_id, int cmock_to_return) { - CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_functionality_CALL_INSTANCE)); - CMOCK_set_functionality_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_functionality_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_function_CALL_INSTANCE)); + CMOCK_set_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory); memset(cmock_call_instance, 0, sizeof(*cmock_call_instance)); - Mock.set_functionality_CallInstance = CMock_Guts_MemChain(Mock.set_functionality_CallInstance, cmock_guts_index); - Mock.set_functionality_IgnoreBool = (char)0; + Mock.set_function_CallInstance = CMock_Guts_MemChain(Mock.set_function_CallInstance, cmock_guts_index); + Mock.set_function_IgnoreBool = (char)0; cmock_call_instance->LineNumber = cmock_line; cmock_call_instance->ExpectAnyArgsBool = (char)0; - CMockExpectParameters_set_functionality(cmock_call_instance, index, flag, functionality_id); + CMockExpectParameters_set_function(cmock_call_instance, index, flag, function_id); cmock_call_instance->ReturnVal = cmock_to_return; } -void set_functionality_AddCallback(CMOCK_set_functionality_CALLBACK Callback) +void set_function_AddCallback(CMOCK_set_function_CALLBACK Callback) { - Mock.set_functionality_IgnoreBool = (char)0; - Mock.set_functionality_CallbackBool = (char)1; - Mock.set_functionality_CallbackFunctionPointer = Callback; + Mock.set_function_IgnoreBool = (char)0; + Mock.set_function_CallbackBool = (char)1; + Mock.set_function_CallbackFunctionPointer = Callback; } -void set_functionality_Stub(CMOCK_set_functionality_CALLBACK Callback) +void set_function_Stub(CMOCK_set_function_CALLBACK Callback) { - Mock.set_functionality_IgnoreBool = (char)0; - Mock.set_functionality_CallbackBool = (char)0; - Mock.set_functionality_CallbackFunctionPointer = Callback; + Mock.set_function_IgnoreBool = (char)0; + Mock.set_function_CallbackBool = (char)0; + Mock.set_function_CallbackFunctionPointer = Callback; } -void set_functionality_CMockIgnoreArg_index(UNITY_LINE_TYPE cmock_line) +void set_function_CMockIgnoreArg_index(UNITY_LINE_TYPE cmock_line) { - CMOCK_set_functionality_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_functionality_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_functionality_CallInstance)); + CMOCK_set_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_function_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); cmock_call_instance->IgnoreArg_index = 1; } -void set_functionality_CMockIgnoreArg_flag(UNITY_LINE_TYPE cmock_line) +void set_function_CMockIgnoreArg_flag(UNITY_LINE_TYPE cmock_line) { - CMOCK_set_functionality_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_functionality_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_functionality_CallInstance)); + CMOCK_set_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_function_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); cmock_call_instance->IgnoreArg_flag = 1; } -void set_functionality_CMockIgnoreArg_functionality_id(UNITY_LINE_TYPE cmock_line) +void set_function_CMockIgnoreArg_function_id(UNITY_LINE_TYPE cmock_line) { - CMOCK_set_functionality_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_functionality_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_functionality_CallInstance)); + CMOCK_set_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_function_CallInstance)); UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); - cmock_call_instance->IgnoreArg_functionality_id = 1; + cmock_call_instance->IgnoreArg_function_id = 1; } diff --git a/module/scmi_pin_control/test/mocks/Mockmod_pinctrl_extra.h b/module/scmi_pin_control/test/mocks/Mockmod_pinctrl_extra.h index 3bf0913b6..fc7e00cab 100644 --- a/module/scmi_pin_control/test/mocks/Mockmod_pinctrl_extra.h +++ b/module/scmi_pin_control/test/mocks/Mockmod_pinctrl_extra.h @@ -48,26 +48,26 @@ void get_attributes_CMockIgnoreArg_index(UNITY_LINE_TYPE cmock_line); void get_attributes_CMockIgnoreArg_flags(UNITY_LINE_TYPE cmock_line); #define get_attributes_IgnoreArg_attributes() get_attributes_CMockIgnoreArg_attributes(__LINE__) void get_attributes_CMockIgnoreArg_attributes(UNITY_LINE_TYPE cmock_line); -#define get_protocol_attributes_IgnoreAndReturn(cmock_retval) get_protocol_attributes_CMockIgnoreAndReturn(__LINE__, cmock_retval) -void get_protocol_attributes_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define get_protocol_attributes_StopIgnore() get_protocol_attributes_CMockStopIgnore() -void get_protocol_attributes_CMockStopIgnore(void); -#define get_protocol_attributes_ExpectAnyArgsAndReturn(cmock_retval) get_protocol_attributes_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) -void get_protocol_attributes_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define get_protocol_attributes_ExpectAndReturn(protocol_attributes, cmock_retval) get_protocol_attributes_CMockExpectAndReturn(__LINE__, protocol_attributes, cmock_retval) -void get_protocol_attributes_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct mod_pinctrl_protocol_attributes* protocol_attributes, int cmock_to_return); -typedef int (* CMOCK_get_protocol_attributes_CALLBACK)(struct mod_pinctrl_protocol_attributes* protocol_attributes, int cmock_num_calls); -void get_protocol_attributes_AddCallback(CMOCK_get_protocol_attributes_CALLBACK Callback); -void get_protocol_attributes_Stub(CMOCK_get_protocol_attributes_CALLBACK Callback); -#define get_protocol_attributes_StubWithCallback get_protocol_attributes_Stub -#define get_protocol_attributes_ExpectWithArrayAndReturn(protocol_attributes, protocol_attributes_Depth, cmock_retval) get_protocol_attributes_CMockExpectWithArrayAndReturn(__LINE__, protocol_attributes, protocol_attributes_Depth, cmock_retval) -void get_protocol_attributes_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct mod_pinctrl_protocol_attributes* protocol_attributes, int protocol_attributes_Depth, int cmock_to_return); -#define get_protocol_attributes_ReturnThruPtr_protocol_attributes(protocol_attributes) get_protocol_attributes_CMockReturnMemThruPtr_protocol_attributes(__LINE__, protocol_attributes, sizeof(struct mod_pinctrl_protocol_attributes)) -#define get_protocol_attributes_ReturnArrayThruPtr_protocol_attributes(protocol_attributes, cmock_len) get_protocol_attributes_CMockReturnMemThruPtr_protocol_attributes(__LINE__, protocol_attributes, cmock_len * sizeof(*protocol_attributes)) -#define get_protocol_attributes_ReturnMemThruPtr_protocol_attributes(protocol_attributes, cmock_size) get_protocol_attributes_CMockReturnMemThruPtr_protocol_attributes(__LINE__, protocol_attributes, cmock_size) -void get_protocol_attributes_CMockReturnMemThruPtr_protocol_attributes(UNITY_LINE_TYPE cmock_line, struct mod_pinctrl_protocol_attributes* protocol_attributes, size_t cmock_size); -#define get_protocol_attributes_IgnoreArg_protocol_attributes() get_protocol_attributes_CMockIgnoreArg_protocol_attributes(__LINE__) -void get_protocol_attributes_CMockIgnoreArg_protocol_attributes(UNITY_LINE_TYPE cmock_line); +#define get_info_IgnoreAndReturn(cmock_retval) get_info_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void get_info_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_info_StopIgnore() get_info_CMockStopIgnore() +void get_info_CMockStopIgnore(void); +#define get_info_ExpectAnyArgsAndReturn(cmock_retval) get_info_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void get_info_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_info_ExpectAndReturn(info, cmock_retval) get_info_CMockExpectAndReturn(__LINE__, info, cmock_retval) +void get_info_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct mod_pinctrl_info* info, int cmock_to_return); +typedef int (* CMOCK_get_info_CALLBACK)(struct mod_pinctrl_info* info, int cmock_num_calls); +void get_info_AddCallback(CMOCK_get_info_CALLBACK Callback); +void get_info_Stub(CMOCK_get_info_CALLBACK Callback); +#define get_info_StubWithCallback get_info_Stub +#define get_info_ExpectWithArrayAndReturn(info, info_Depth, cmock_retval) get_info_CMockExpectWithArrayAndReturn(__LINE__, info, info_Depth, cmock_retval) +void get_info_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct mod_pinctrl_info* info, int info_Depth, int cmock_to_return); +#define get_info_ReturnThruPtr_info(info) get_info_CMockReturnMemThruPtr_info(__LINE__, info, sizeof(struct mod_pinctrl_info)) +#define get_info_ReturnArrayThruPtr_info(info, cmock_len) get_info_CMockReturnMemThruPtr_info(__LINE__, info, cmock_len * sizeof(*info)) +#define get_info_ReturnMemThruPtr_info(info, cmock_size) get_info_CMockReturnMemThruPtr_info(__LINE__, info, cmock_size) +void get_info_CMockReturnMemThruPtr_info(UNITY_LINE_TYPE cmock_line, struct mod_pinctrl_info* info, size_t cmock_size); +#define get_info_IgnoreArg_info() get_info_CMockIgnoreArg_info(__LINE__) +void get_info_CMockIgnoreArg_info(UNITY_LINE_TYPE cmock_line); #define get_list_associations_IgnoreAndReturn(cmock_retval) get_list_associations_CMockIgnoreAndReturn(__LINE__, cmock_retval) void get_list_associations_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); #define get_list_associations_StopIgnore() get_list_associations_CMockStopIgnore() @@ -194,30 +194,30 @@ void get_total_number_of_configurations_CMockIgnoreArg_index(UNITY_LINE_TYPE cmo void get_total_number_of_configurations_CMockIgnoreArg_flag(UNITY_LINE_TYPE cmock_line); #define get_total_number_of_configurations_IgnoreArg_number_of_configurations() get_total_number_of_configurations_CMockIgnoreArg_number_of_configurations(__LINE__) void get_total_number_of_configurations_CMockIgnoreArg_number_of_configurations(UNITY_LINE_TYPE cmock_line); -#define get_current_associated_functionality_IgnoreAndReturn(cmock_retval) get_current_associated_functionality_CMockIgnoreAndReturn(__LINE__, cmock_retval) -void get_current_associated_functionality_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define get_current_associated_functionality_StopIgnore() get_current_associated_functionality_CMockStopIgnore() -void get_current_associated_functionality_CMockStopIgnore(void); -#define get_current_associated_functionality_ExpectAnyArgsAndReturn(cmock_retval) get_current_associated_functionality_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) -void get_current_associated_functionality_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define get_current_associated_functionality_ExpectAndReturn(index, flag, functionality_id, cmock_retval) get_current_associated_functionality_CMockExpectAndReturn(__LINE__, index, flag, functionality_id, cmock_retval) -void get_current_associated_functionality_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t index, enum mod_pinctrl_selector flag, uint16_t* functionality_id, int cmock_to_return); -typedef int (* CMOCK_get_current_associated_functionality_CALLBACK)(uint16_t index, enum mod_pinctrl_selector flag, uint16_t* functionality_id, int cmock_num_calls); -void get_current_associated_functionality_AddCallback(CMOCK_get_current_associated_functionality_CALLBACK Callback); -void get_current_associated_functionality_Stub(CMOCK_get_current_associated_functionality_CALLBACK Callback); -#define get_current_associated_functionality_StubWithCallback get_current_associated_functionality_Stub -#define get_current_associated_functionality_ExpectWithArrayAndReturn(index, flag, functionality_id, functionality_id_Depth, cmock_retval) get_current_associated_functionality_CMockExpectWithArrayAndReturn(__LINE__, index, flag, functionality_id, functionality_id_Depth, cmock_retval) -void get_current_associated_functionality_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t index, enum mod_pinctrl_selector flag, uint16_t* functionality_id, int functionality_id_Depth, int cmock_to_return); -#define get_current_associated_functionality_ReturnThruPtr_functionality_id(functionality_id) get_current_associated_functionality_CMockReturnMemThruPtr_functionality_id(__LINE__, functionality_id, sizeof(uint16_t)) -#define get_current_associated_functionality_ReturnArrayThruPtr_functionality_id(functionality_id, cmock_len) get_current_associated_functionality_CMockReturnMemThruPtr_functionality_id(__LINE__, functionality_id, cmock_len * sizeof(*functionality_id)) -#define get_current_associated_functionality_ReturnMemThruPtr_functionality_id(functionality_id, cmock_size) get_current_associated_functionality_CMockReturnMemThruPtr_functionality_id(__LINE__, functionality_id, cmock_size) -void get_current_associated_functionality_CMockReturnMemThruPtr_functionality_id(UNITY_LINE_TYPE cmock_line, uint16_t* functionality_id, size_t cmock_size); -#define get_current_associated_functionality_IgnoreArg_index() get_current_associated_functionality_CMockIgnoreArg_index(__LINE__) -void get_current_associated_functionality_CMockIgnoreArg_index(UNITY_LINE_TYPE cmock_line); -#define get_current_associated_functionality_IgnoreArg_flag() get_current_associated_functionality_CMockIgnoreArg_flag(__LINE__) -void get_current_associated_functionality_CMockIgnoreArg_flag(UNITY_LINE_TYPE cmock_line); -#define get_current_associated_functionality_IgnoreArg_functionality_id() get_current_associated_functionality_CMockIgnoreArg_functionality_id(__LINE__) -void get_current_associated_functionality_CMockIgnoreArg_functionality_id(UNITY_LINE_TYPE cmock_line); +#define get_current_associated_function_IgnoreAndReturn(cmock_retval) get_current_associated_function_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void get_current_associated_function_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_current_associated_function_StopIgnore() get_current_associated_function_CMockStopIgnore() +void get_current_associated_function_CMockStopIgnore(void); +#define get_current_associated_function_ExpectAnyArgsAndReturn(cmock_retval) get_current_associated_function_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void get_current_associated_function_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_current_associated_function_ExpectAndReturn(index, flag, function_id, cmock_retval) get_current_associated_function_CMockExpectAndReturn(__LINE__, index, flag, function_id, cmock_retval) +void get_current_associated_function_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t index, enum mod_pinctrl_selector flag, uint32_t* function_id, int cmock_to_return); +typedef int (* CMOCK_get_current_associated_function_CALLBACK)(uint16_t index, enum mod_pinctrl_selector flag, uint32_t* function_id, int cmock_num_calls); +void get_current_associated_function_AddCallback(CMOCK_get_current_associated_function_CALLBACK Callback); +void get_current_associated_function_Stub(CMOCK_get_current_associated_function_CALLBACK Callback); +#define get_current_associated_function_StubWithCallback get_current_associated_function_Stub +#define get_current_associated_function_ExpectWithArrayAndReturn(index, flag, function_id, function_id_Depth, cmock_retval) get_current_associated_function_CMockExpectWithArrayAndReturn(__LINE__, index, flag, function_id, function_id_Depth, cmock_retval) +void get_current_associated_function_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t index, enum mod_pinctrl_selector flag, uint32_t* function_id, int function_id_Depth, int cmock_to_return); +#define get_current_associated_function_ReturnThruPtr_function_id(function_id) get_current_associated_function_CMockReturnMemThruPtr_function_id(__LINE__, function_id, sizeof(uint32_t)) +#define get_current_associated_function_ReturnArrayThruPtr_function_id(function_id, cmock_len) get_current_associated_function_CMockReturnMemThruPtr_function_id(__LINE__, function_id, cmock_len * sizeof(*function_id)) +#define get_current_associated_function_ReturnMemThruPtr_function_id(function_id, cmock_size) get_current_associated_function_CMockReturnMemThruPtr_function_id(__LINE__, function_id, cmock_size) +void get_current_associated_function_CMockReturnMemThruPtr_function_id(UNITY_LINE_TYPE cmock_line, uint32_t* function_id, size_t cmock_size); +#define get_current_associated_function_IgnoreArg_index() get_current_associated_function_CMockIgnoreArg_index(__LINE__) +void get_current_associated_function_CMockIgnoreArg_index(UNITY_LINE_TYPE cmock_line); +#define get_current_associated_function_IgnoreArg_flag() get_current_associated_function_CMockIgnoreArg_flag(__LINE__) +void get_current_associated_function_CMockIgnoreArg_flag(UNITY_LINE_TYPE cmock_line); +#define get_current_associated_function_IgnoreArg_function_id() get_current_associated_function_CMockIgnoreArg_function_id(__LINE__) +void get_current_associated_function_CMockIgnoreArg_function_id(UNITY_LINE_TYPE cmock_line); #define set_configuration_IgnoreAndReturn(cmock_retval) set_configuration_CMockIgnoreAndReturn(__LINE__, cmock_retval) void set_configuration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); #define set_configuration_StopIgnore() set_configuration_CMockStopIgnore() @@ -238,24 +238,24 @@ void set_configuration_CMockIgnoreArg_index(UNITY_LINE_TYPE cmock_line); void set_configuration_CMockIgnoreArg_flag(UNITY_LINE_TYPE cmock_line); #define set_configuration_IgnoreArg_config() set_configuration_CMockIgnoreArg_config(__LINE__) void set_configuration_CMockIgnoreArg_config(UNITY_LINE_TYPE cmock_line); -#define set_functionality_IgnoreAndReturn(cmock_retval) set_functionality_CMockIgnoreAndReturn(__LINE__, cmock_retval) -void set_functionality_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define set_functionality_StopIgnore() set_functionality_CMockStopIgnore() -void set_functionality_CMockStopIgnore(void); -#define set_functionality_ExpectAnyArgsAndReturn(cmock_retval) set_functionality_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) -void set_functionality_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); -#define set_functionality_ExpectAndReturn(index, flag, functionality_id, cmock_retval) set_functionality_CMockExpectAndReturn(__LINE__, index, flag, functionality_id, cmock_retval) -void set_functionality_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t index, enum mod_pinctrl_selector flag, uint16_t functionality_id, int cmock_to_return); -typedef int (* CMOCK_set_functionality_CALLBACK)(uint16_t index, enum mod_pinctrl_selector flag, uint16_t functionality_id, int cmock_num_calls); -void set_functionality_AddCallback(CMOCK_set_functionality_CALLBACK Callback); -void set_functionality_Stub(CMOCK_set_functionality_CALLBACK Callback); -#define set_functionality_StubWithCallback set_functionality_Stub -#define set_functionality_IgnoreArg_index() set_functionality_CMockIgnoreArg_index(__LINE__) -void set_functionality_CMockIgnoreArg_index(UNITY_LINE_TYPE cmock_line); -#define set_functionality_IgnoreArg_flag() set_functionality_CMockIgnoreArg_flag(__LINE__) -void set_functionality_CMockIgnoreArg_flag(UNITY_LINE_TYPE cmock_line); -#define set_functionality_IgnoreArg_functionality_id() set_functionality_CMockIgnoreArg_functionality_id(__LINE__) -void set_functionality_CMockIgnoreArg_functionality_id(UNITY_LINE_TYPE cmock_line); +#define set_function_IgnoreAndReturn(cmock_retval) set_function_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void set_function_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define set_function_StopIgnore() set_function_CMockStopIgnore() +void set_function_CMockStopIgnore(void); +#define set_function_ExpectAnyArgsAndReturn(cmock_retval) set_function_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void set_function_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define set_function_ExpectAndReturn(index, flag, function_id, cmock_retval) set_function_CMockExpectAndReturn(__LINE__, index, flag, function_id, cmock_retval) +void set_function_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t index, enum mod_pinctrl_selector flag, uint32_t function_id, int cmock_to_return); +typedef int (* CMOCK_set_function_CALLBACK)(uint16_t index, enum mod_pinctrl_selector flag, uint32_t function_id, int cmock_num_calls); +void set_function_AddCallback(CMOCK_set_function_CALLBACK Callback); +void set_function_Stub(CMOCK_set_function_CALLBACK Callback); +#define set_function_StubWithCallback set_function_Stub +#define set_function_IgnoreArg_index() set_function_CMockIgnoreArg_index(__LINE__) +void set_function_CMockIgnoreArg_index(UNITY_LINE_TYPE cmock_line); +#define set_function_IgnoreArg_flag() set_function_CMockIgnoreArg_flag(__LINE__) +void set_function_CMockIgnoreArg_flag(UNITY_LINE_TYPE cmock_line); +#define set_function_IgnoreArg_function_id() set_function_CMockIgnoreArg_function_id(__LINE__) +void set_function_CMockIgnoreArg_function_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))) diff --git a/module/scmi_pin_control/test/mod_pinctrl_extra.h b/module/scmi_pin_control/test/mod_pinctrl_extra.h index eeb874a49..792c305b9 100644 --- a/module/scmi_pin_control/test/mod_pinctrl_extra.h +++ b/module/scmi_pin_control/test/mod_pinctrl_extra.h @@ -12,54 +12,53 @@ #include /*! - * \brief Get attributes of pin, group or functionality. + * \brief Get attributes of pin, group or function. * - * \param[in] index Identifier for the pin, group, or functionality. + * \param[in] index Identifier for the pin, group, or function. * \param[in] flags Selector: Whether the identifier field selects - * a pin, a group, or a functionality. + * a pin, a group, or a function. * 0 - pin * 1 - group - * 2 - functionality + * 2 - function * \param[out] attributes respond to get attribute request * number_of_elements: total number of elements. - * is_pin_only_functionality: enum group_pin_serving_t. - * is_gpio_functionality: enum gpio_functionality_t. + * is_pin_only_function: enum group_pin_serving_t. + * is_gpio_function: enum gpio_function_t. * name: Null-terminated ASCII string. * \retval ::FWK_SUCCESS The operation succeeded. * \retval ::FWK_E_RANGE if the identifier field pertains to a - * non-existent pin, group, or functionality. + * non-existent pin, group, or function. */ int get_attributes( uint16_t index, enum mod_pinctrl_selector flags, struct mod_pinctrl_attributes *attributes); /*! - * \brief Get attributes of pin, group or functionality. + * \brief Get info of pin, group or function. * - * \param[out] protocol_attributes return protocol attributes + * \param[out] info return protocol attributes * Number of pin groups. * Number of pins. * Reserved, must be zero. - * Number of functionality. + * Number of function. * \retval ::FWK_SUCCESS The operation succeeded. */ -int get_protocol_attributes( - struct mod_pinctrl_protocol_attributes *protocol_attributes); +int get_info(struct mod_pinctrl_info *info); /*! * \brief Get pin associated with a group, or - * Get group which can enable a functionality, or - * Get pin which can enable a single-pin functionality. - * \param[in] index Identifier for the group, or functionality. + * Get group which can enable a function, or + * Get pin which can enable a single-pin function. + * \param[in] index Identifier for the group, or function. * \param[in] flags Selector: Whether the identifier field selects - * group, or functionality. + * group, or function. * 1 - group - * 2 - functionality + * 2 - function * \param[in] first_index the index of the object {pin, group} to be * returned * \param[out] object_id the returned object. * \retval ::FWK_SUCCESS The operation succeeded. * \retval ::FWK_E_RANGE index >= max number of pins associated with this - * functionality or group. + * function or group. * \retval ::FWK_E_PARAM the flags is pin. */ int get_list_associations( @@ -69,11 +68,11 @@ int get_list_associations( uint16_t *object_id); /*! * \brief Get the total number of associated pins or groups to index. - * \param[in] index Identifier for the group, or functionality. + * \param[in] index Identifier for the group, or function. * \param[in] flags Selector: Whether the identifier field selects - * group, or functionality. + * group, or function. * 1 - group - * 2 - functionality + * 2 - function * \param[in] total_count the total number of associations to the index * \retval ::FWK_SUCCESS The operation succeeded. * \retval ::FWK_E_PARAM index invalid index or flags == pin @@ -83,7 +82,7 @@ int get_total_number_of_associations( enum mod_pinctrl_selector flags, uint16_t *total_count); /*! - * \brief Get pin or group specific Configuration. + * \brief Get pin or group specific configuration value. * \param[in] index Identifier for the pin, or group. * \param[in] flags Selector: Whether the identifier field selects * a pin or group. @@ -101,14 +100,14 @@ int get_configuration_value_from_type( enum mod_pinctrl_drv_configuration_type config_type, uint32_t *config_value); /*! - * \brief Get pin or group specific Configuration. + * \brief Get pin or group configuration by configuration index. * \param[in] index Identifier for the pin, or group. * \param[in] flags Selector: Whether the identifier field selects * a pin or group. * 0 - pin * 1 - group - * \param[in] configration_index - * \param[out] config Configuration type to be retun its value. + * \param[in] configration_index configuration index + * \param[out] config configuration type and value for specific index. * \retval ::FWK_SUCCESS The operation succeeded. * \retval ::FWK_E_RANGE configration_index > total number of configurtions. * \retval ::FWK_E_PARAM the flags isn't pin or group. or index >= max @@ -136,23 +135,23 @@ int get_total_number_of_configurations( enum mod_pinctrl_selector flag, uint16_t *number_of_configurations); /*! - * \brief get current pin or group enabled functionality. + * \brief get current pin or group enabled function. * * \param[in] index pin or group identifier. * \param[in] flag Selector: Whether the identifier field selects * a pin or group. * 0 - pin * 1 - group - * \param[out] functionality_id current enabled functionality. + * \param[out] function_id current enabled function. * \retval ::FWK_SUCCESS The operation succeeded. * \retval ::FWK_E_RANGE pin_id >= max number of pins or the - * functionality_id is not allowed for this pin_id. + * function_id is not allowed for this pin_id. * \retval ::FWK_E_PARAM the flag isn't pin or group. */ -int get_current_associated_functionality( +int get_current_associated_function( uint16_t index, enum mod_pinctrl_selector flag, - uint16_t *functionality_id); + uint32_t *function_id); /*! * \brief set pin or group configuration. * @@ -164,7 +163,7 @@ int get_current_associated_functionality( * \param[in] config configuration to be set. * \retval ::FWK_SUCCESS The operation succeeded. * \retval ::FWK_E_RANGE pin_id >= max number of pins or the - * functionality_id is not allowed for this pin_id. + * function_id is not allowed for this pin_id. * \retval ::FWK_E_PARAM the flag isn't pin or group. */ int set_configuration( @@ -172,22 +171,22 @@ int set_configuration( enum mod_pinctrl_selector flag, const struct mod_pinctrl_drv_pin_configuration *config); /*! - * \brief Set pin or group functionality. + * \brief Set pin or group function. * * \param[in] index pin or group identifier. * \param[in] flag Selector: Whether the identifier field selects * a pin or group. * 0 - pin * 1 - group - * \param[in] functionality_id the fucntionality to be set. + * \param[in] the fucntionality to be set. * \retval ::FWK_SUCCESS The operation succeeded. * \retval ::FWK_E_RANGE pin_id >= max number of pins or the - * functionality_id is not allowed for this pin_id. + * function_id is not allowed for this pin_id. * \retval ::FWK_E_PARAM the flag isn't pin or group. */ -int set_functionality( +int set_function( uint16_t index, enum mod_pinctrl_selector flag, - uint16_t functionality_id); + uint32_t function_id); #endif /* MOD_PINCTRL_H */ diff --git a/module/scmi_pin_control/test/mod_scmi_pin_control_unit_test.c b/module/scmi_pin_control/test/mod_scmi_pin_control_unit_test.c index 5b1918868..5cc1b4bc9 100644 --- a/module/scmi_pin_control/test/mod_scmi_pin_control_unit_test.c +++ b/module/scmi_pin_control/test/mod_scmi_pin_control_unit_test.c @@ -83,16 +83,15 @@ static const struct mod_scmi_from_protocol_api scmi_api = { static const struct mod_pinctrl_api pinctrl_api = { .get_attributes = get_attributes, - .get_protocol_attributes = get_protocol_attributes, + .get_info = get_info, .get_list_associations = get_list_associations, .get_total_number_of_associations = get_total_number_of_associations, .get_configuration_value_from_type = get_configuration_value_from_type, .get_total_number_of_configurations = get_total_number_of_configurations, .get_configuration = get_configuration, - .get_current_associated_functionality = - get_current_associated_functionality, + .get_current_associated_function = get_current_associated_function, .set_configuration = set_configuration, - .set_functionality = set_functionality, + .set_function = set_function, }; void setUp(void) @@ -211,7 +210,7 @@ int protocol_attributes_respond_callback( const int number_of_pins = EXPECTED_NUMBER_OF_PINS; const int number_of_groups = SHIFT_LEFT_BY_POS(EXPECTED_NUMBER_OF_GROUPS, NUM_OF_PIN_GROUPS_POS); - const int number_of_functionalities = EXPECTED_NUMBER_OF_FUNC; + const int number_of_functions = EXPECTED_NUMBER_OF_FUNC; struct scmi_pin_control_protocol_attributes_p2a *return_values = (struct scmi_pin_control_protocol_attributes_p2a *)payload; @@ -224,7 +223,7 @@ int protocol_attributes_respond_callback( number_of_groups, GET_HIGH_BYTES_OF_32_BIT_NUMBER(return_values->attributes_low)); TEST_ASSERT_EQUAL( - number_of_functionalities, + number_of_functions, GET_LOW_BYTES_OF_32_BIT_NUMBER(return_values->attributes_high)); TEST_ASSERT_EQUAL(SCMI_SUCCESS, return_values->status); @@ -234,18 +233,17 @@ int protocol_attributes_respond_callback( void utest_protocol_attributes(void) { int status = SCMI_GENERIC_ERROR; - struct mod_pinctrl_protocol_attributes expected_protocol_attributes = { + struct mod_pinctrl_info expected_protocol_attributes = { .number_of_pins = EXPECTED_NUMBER_OF_PINS, .number_of_groups = EXPECTED_NUMBER_OF_GROUPS, - .number_of_functionalities = EXPECTED_NUMBER_OF_FUNC, + .number_of_functions = EXPECTED_NUMBER_OF_FUNC, }; mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); - get_protocol_attributes_ExpectAnyArgsAndReturn(FWK_SUCCESS); - get_protocol_attributes_ReturnThruPtr_protocol_attributes( - &expected_protocol_attributes); + get_info_ExpectAnyArgsAndReturn(FWK_SUCCESS); + get_info_ReturnThruPtr_info(&expected_protocol_attributes); respond_StubWithCallback(protocol_attributes_respond_callback); @@ -285,8 +283,8 @@ void utest_attributes_group(void) struct mod_pinctrl_attributes pinctrl_attributes = { .number_of_elements = 2, - .is_gpio_functionality = false, - .is_pin_only_functionality = false, + .is_gpio_function = false, + .is_pin_only_function = false, .name = name, }; @@ -352,8 +350,8 @@ void utest_attributes_function(void) struct mod_pinctrl_attributes pinctrl_attributes = { .number_of_elements = 2, - .is_gpio_functionality = true, - .is_pin_only_functionality = true, + .is_gpio_function = true, + .is_pin_only_function = true, .name = name, }; @@ -419,8 +417,8 @@ void utest_attributes_pin(void) struct mod_pinctrl_attributes pinctrl_attributes = { .number_of_elements = 1, - .is_gpio_functionality = false, - .is_pin_only_functionality = false, + .is_gpio_function = false, + .is_pin_only_function = false, .name = name, }; @@ -468,8 +466,8 @@ void utest_attributes_id_out_of_range(void) struct mod_pinctrl_attributes pinctrl_attributes = { .number_of_elements = 1, - .is_gpio_functionality = false, - .is_pin_only_functionality = false, + .is_gpio_function = false, + .is_pin_only_function = false, .name = name, }; @@ -913,33 +911,33 @@ void utest_setting_get_all_confgurations(void) TEST_ASSERT_EQUAL(FWK_SUCCESS, status); } -int setting_get_functionality_respond_callback( +int setting_get_function_respond_callback( fwk_id_t service_id, const void *payload, size_t size, int cmock_num_calls) { - const uint32_t functionality_id = 4; + const uint32_t function_id = 4; const uint32_t expected_respond_size = sizeof(struct scmi_pin_control_settings_get_p2a); struct scmi_pin_control_settings_get_p2a *respond = (struct scmi_pin_control_settings_get_p2a *)payload; TEST_ASSERT_EQUAL(SCMI_SUCCESS, respond->status); - TEST_ASSERT_EQUAL(functionality_id, respond->function_selected); + TEST_ASSERT_EQUAL(function_id, respond->function_selected); TEST_ASSERT_EQUAL(expected_respond_size, size); return FWK_SUCCESS; } -void utest_setting_get_functionality_selected(void) +void utest_setting_get_function_selected(void) { int status = SCMI_GENERIC_ERROR; uint32_t config_flag = SHIFT_LEFT_BY_POS( SCMI_PIN_CONTROL_FUNCTION_SELECTED, SETTING_GET_CONFIG_FLAG_POS); uint32_t selector_flag = MOD_PINCTRL_SELECTOR_PIN; /* Any chosen random value */ - uint16_t functionality_id = 4; + uint32_t function_id = 4; struct scmi_pin_control_settings_get_a2p payload = { /* Any random value can be chosen */ .identifier = 2, @@ -949,13 +947,12 @@ void utest_setting_get_functionality_selected(void) mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); - get_current_associated_functionality_ExpectAndReturn( - payload.identifier, selector_flag, &functionality_id, FWK_SUCCESS); - get_current_associated_functionality_IgnoreArg_functionality_id(); - get_current_associated_functionality_ReturnThruPtr_functionality_id( - &functionality_id); + get_current_associated_function_ExpectAndReturn( + payload.identifier, selector_flag, &function_id, FWK_SUCCESS); + get_current_associated_function_IgnoreArg_function_id(); + get_current_associated_function_ReturnThruPtr_function_id(&function_id); - respond_StubWithCallback(setting_get_functionality_respond_callback); + respond_StubWithCallback(setting_get_function_respond_callback); status = scmi_pin_control_message_handler( protocol_id, @@ -967,32 +964,32 @@ void utest_setting_get_functionality_selected(void) TEST_ASSERT_EQUAL(FWK_SUCCESS, status); } -int setting_get_no_functionality_selected_respond_callback( +int setting_get_no_function_selected_respond_callback( fwk_id_t service_id, const void *payload, size_t size, int cmock_num_calls) { - const uint32_t functionality_id = NO_FUNCTION_IS_SELECTED; + const uint32_t function_id = NO_FUNCTION_IS_SELECTED; const uint32_t expected_respond_size = sizeof(struct scmi_pin_control_settings_get_p2a); struct scmi_pin_control_settings_get_p2a *respond = (struct scmi_pin_control_settings_get_p2a *)payload; TEST_ASSERT_EQUAL(SCMI_SUCCESS, respond->status); - TEST_ASSERT_EQUAL(functionality_id, respond->function_selected); + TEST_ASSERT_EQUAL(function_id, respond->function_selected); TEST_ASSERT_EQUAL(expected_respond_size, size); return FWK_SUCCESS; } -void utest_setting_get_no_functionality_is_selected(void) +void utest_setting_get_no_function_is_selected(void) { int status = SCMI_GENERIC_ERROR; uint32_t config_flag = SHIFT_LEFT_BY_POS( SCMI_PIN_CONTROL_FUNCTION_SELECTED, SETTING_GET_CONFIG_FLAG_POS); uint32_t selector_flag = MOD_PINCTRL_SELECTOR_PIN; - uint16_t functionality_id = 4; + uint32_t function_id = 0xFFFFFFFF; struct scmi_pin_control_settings_get_a2p payload = { /* Any random value can be chosen */ .identifier = 2, @@ -1002,12 +999,12 @@ void utest_setting_get_no_functionality_is_selected(void) mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); - get_current_associated_functionality_ExpectAndReturn( - payload.identifier, selector_flag, &functionality_id, FWK_E_ACCESS); - get_current_associated_functionality_IgnoreArg_functionality_id(); + get_current_associated_function_ExpectAndReturn( + payload.identifier, selector_flag, &function_id, FWK_SUCCESS); + get_current_associated_function_IgnoreArg_function_id(); + get_current_associated_function_ReturnThruPtr_function_id(&function_id); - respond_StubWithCallback( - setting_get_no_functionality_selected_respond_callback); + respond_StubWithCallback(setting_get_no_function_selected_respond_callback); status = scmi_pin_control_message_handler( protocol_id, @@ -1091,10 +1088,10 @@ void utest_setting_configuration(void) TEST_ASSERT_EQUAL(FWK_SUCCESS, status); } -void utest_setting_functionality(void) +void utest_setting_function(void) { int status = SCMI_GENERIC_ERROR; - const uint32_t functionality_id = SHIFT_LEFT_BY_POS(1, SETTING_FUNC_POS); + const uint32_t function_id = SHIFT_LEFT_BY_POS(1, SETTING_FUNC_POS); const uint32_t number_of_config_to_set = SHIFT_LEFT_BY_POS(0, SETTING_NUMBER_OF_CONFIG_POS); const uint32_t selector_flag = SHIFT_LEFT_BY_POS(1, SETTING_FLAG_POS); @@ -1103,8 +1100,7 @@ void utest_setting_functionality(void) /* Any random value can be chosen */ .identifier = 2, .function_id = NO_FUNCTION_IS_SELECTED, - .attributes = - functionality_id | number_of_config_to_set | selector_flag, + .attributes = function_id | number_of_config_to_set | selector_flag, }; struct scmi_pin_control_settings_configure_p2a return_values = { @@ -1114,7 +1110,7 @@ void utest_setting_functionality(void) mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); - set_functionality_ExpectAndReturn( + set_function_ExpectAndReturn( payload.identifier, selector_flag, (uint16_t)payload.function_id, @@ -1137,10 +1133,10 @@ void utest_setting_functionality(void) TEST_ASSERT_EQUAL(FWK_SUCCESS, status); } -void utest_setting_configuration_and_functionality(void) +void utest_setting_configuration_and_function(void) { int status = SCMI_GENERIC_ERROR; - const uint32_t functionality_id = SHIFT_LEFT_BY_POS(1, SETTING_FUNC_POS); + const uint32_t function_id = SHIFT_LEFT_BY_POS(1, SETTING_FUNC_POS); const uint32_t number_of_config_to_set = SHIFT_LEFT_BY_POS(2, SETTING_NUMBER_OF_CONFIG_POS); const uint32_t selector_flag = SHIFT_LEFT_BY_POS(1, SETTING_FLAG_POS); @@ -1149,8 +1145,7 @@ void utest_setting_configuration_and_functionality(void) /* Any random value can be chosen */ .identifier = 2, .function_id = NO_FUNCTION_IS_SELECTED, - .attributes = - functionality_id | number_of_config_to_set | selector_flag, + .attributes = function_id | number_of_config_to_set | selector_flag, }; struct mod_pinctrl_drv_pin_configuration configs[] = { @@ -1178,7 +1173,7 @@ void utest_setting_configuration_and_functionality(void) mod_scmi_from_protocol_api_scmi_frame_validation_ExpectAnyArgsAndReturn( SCMI_SUCCESS); - set_functionality_ExpectAndReturn( + set_function_ExpectAndReturn( payload.identifier, selector_flag, (uint16_t)payload.function_id, @@ -1231,12 +1226,12 @@ int scmi_pin_control_protocol_test_main(void) RUN_TEST(utest_setting_get_specific_configuration_value); RUN_TEST(utest_setting_get_all_confgurations); - RUN_TEST(utest_setting_get_functionality_selected); - RUN_TEST(utest_setting_get_no_functionality_is_selected); + RUN_TEST(utest_setting_get_function_selected); + RUN_TEST(utest_setting_get_no_function_is_selected); RUN_TEST(utest_setting_configuration); - RUN_TEST(utest_setting_functionality); - RUN_TEST(utest_setting_configuration_and_functionality); + RUN_TEST(utest_setting_function); + RUN_TEST(utest_setting_configuration_and_function); return UNITY_END(); } -- GitLab