diff --git a/module/pinctrl/include/mod_pinctrl.h b/module/pinctrl/include/mod_pinctrl.h index dbf383afb7b9f888803afd5b2b7bbd749ba5754f..2573c70de4f18880c0831251aea3c99a16534409 100644 --- a/module/pinctrl/include/mod_pinctrl.h +++ b/module/pinctrl/include/mod_pinctrl.h @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2024-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -62,11 +62,11 @@ struct mod_pinctrl_group { /*! Pointer to NULL terminated string for name of function */ char *name; - /*! Allowed group functions to choose from */ - const uint16_t *allowed_functions; + /*! Attribute to mark this group as GPIO */ + bool is_gpio; - /*! Number of allowed group functions to choose from */ - const uint16_t num_allowed_functions; + /*! Group function */ + const uint16_t function; /*! Pointer to the pins associated to the group */ const uint16_t *pins; diff --git a/module/pinctrl/src/mod_pinctrl.c b/module/pinctrl/src/mod_pinctrl.c index 6226bfc39898d9896f599ca3a533af357e4ad503..de2e769a4da8546075f29ef0d08e923699832af6 100644 --- a/module/pinctrl/src/mod_pinctrl.c +++ b/module/pinctrl/src/mod_pinctrl.c @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2024-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -135,11 +135,8 @@ static int get_function_attributes( 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; - } + if (function_id == groups[index].function) { + pinctrl_attributes->number_of_elements++; } } } @@ -222,22 +219,13 @@ static int get_group_id_associated_with_function( } 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)) { + if (function_id == + pinctrl_ctx.config->groups_table[group_index].function) { + if (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]) { + } else { ++search_index; - break; } } } @@ -261,18 +249,16 @@ static int get_pin_id_associated_with_function( 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 == + if (function_id == pinctrl_ctx.config->pins_table[pin_index] .allowed_functions[func_index]) { - ++search_index; - break; + if (search_index == index) { + *pin_id = pin_index; + return FWK_SUCCESS; + } else { + ++search_index; + break; + } } } } @@ -318,15 +304,9 @@ static void get_number_of_groups_can_support_function( 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; - } + if (pinctrl_ctx.config->groups_table[group_index].function == + function_id) { + ++(*number_of_groups); } } } @@ -434,6 +414,11 @@ static int get_group_configuration_by_value( return FWK_E_RANGE; } + if ((pinctrl_ctx.config->groups_table[group_id].num_pins > 1) && + (pinctrl_ctx.config->groups_table[group_id].is_gpio == false)) { + return FWK_E_PARAM; + } + status = get_pin_id_associated_with_group( group_id, first_group_pin_index, &pin_id); if (status != FWK_SUCCESS) { @@ -519,6 +504,11 @@ static int get_group_configuration_by_index( return FWK_E_RANGE; } + if ((pinctrl_ctx.config->groups_table[group_id].num_pins > 1) && + (pinctrl_ctx.config->groups_table[group_id].is_gpio == false)) { + return FWK_E_PARAM; + } + status = get_pin_id_associated_with_group( group_id, first_group_pin_index, &pin_id); if (status != FWK_SUCCESS) { @@ -812,6 +802,10 @@ static int set_group_function(uint16_t group_index, uint32_t function) return FWK_E_RANGE; } + if (pinctrl_ctx.config->groups_table[group_index].function != function) { + return FWK_E_PARAM; + } + group_pins_count = pinctrl_ctx.config->groups_table[group_index].num_pins; for (uint32_t i = 0; i < group_pins_count; ++i) { diff --git a/module/pinctrl/test/CMakeLists.txt b/module/pinctrl/test/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..b70dc5246dbde736da1ae40bc8bc4aba9ae051b4 --- /dev/null +++ b/module/pinctrl/test/CMakeLists.txt @@ -0,0 +1,35 @@ +# +# Arm SCP/MCP Software +# Copyright (c) 2025, Arm Limited and Contributors. All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +# + +# Default flags target + +set(TEST_SRC mod_pinctrl) +set(TEST_FILE mod_pinctrl) + +if(TEST_ON_TARGET) + set(TEST_MODULE pinctrl) + set(MODULE_ROOT ${CMAKE_SOURCE_DIR}/module) +else() + set(UNIT_TEST_TARGET mod_${TEST_MODULE}_unit_test) +endif() + +set(MODULE_SRC ${MODULE_ROOT}/${TEST_MODULE}/src) +set(MODULE_INC ${MODULE_ROOT}/${TEST_MODULE}/include) +set(MODULE_UT_SRC ${CMAKE_CURRENT_LIST_DIR}) +set(MODULE_UT_INC ${CMAKE_CURRENT_LIST_DIR}) +set(MODULE_UT_MOCK_SRC ${CMAKE_CURRENT_LIST_DIR}/mocks) + +list(APPEND MOCK_REPLACEMENTS fwk_mm) +list(APPEND MOCK_REPLACEMENTS fwk_string) +list(APPEND MOCK_REPLACEMENTS fwk_module) +list(APPEND MOCK_REPLACEMENTS fwk_id) +list(APPEND MOCK_REPLACEMENTS fwk_core) + +include(${SCP_ROOT}/unit_test/module_common.cmake) + +target_sources(${UNIT_TEST_TARGET} PRIVATE + ${MODULE_UT_MOCK_SRC}/Mockmod_pinctrl_drv_extra.c) diff --git a/module/pinctrl/test/config_pinctrl.h b/module/pinctrl/test/config_pinctrl.h new file mode 100644 index 0000000000000000000000000000000000000000..d2c97fe7ac4f250e48615ccab1bdc2da595bda9e --- /dev/null +++ b/module/pinctrl/test/config_pinctrl.h @@ -0,0 +1,227 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2025, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef CONFIG_PINCTRL_H +#define CONFIG_PINCTRL_H + +#include + +#include + +#define DRIVE_OPEN_SOURCE_VALUE 7 +#define LOW_POWER_MODE_VALUE 1 +#define PIN_WITH_GPIO_FUNC (PIN_COUNT - 2) +#define ENABLE_VALUE 1 +#define DISABLE_VALUE 0 + +typedef enum { + PIN_0_IDX = 0, + PIN_1_IDX, + PIN_2_IDX, + PIN_3_IDX, + PIN_4_IDX, + PIN_5_IDX, + PIN_6_IDX, + PIN_COUNT, +} pin_idx; + +typedef enum { + GPIO_FUNC_IDX = 0, + UART_FUNC_IDX, + SPI_FUNC_IDX, + I2C_FUNC_IDX, + FUNC_COUNT, +} function_idx; + +typedef enum { + UART_GROUP_IDX = 0, + SPI_GROUP_IDX, + I2C_GROUP_IDX, + GPIO_GROUP_IDX, + UART_1_GROUP_IDX, + GROUP_COUNT, +} group_idx; + +const enum mod_pinctrl_drv_configuration_type pin_configuration[] = { + DRIVE_OPEN_SOURCE, + LOW_POWER_MODE, + INPUT_VALUE +}; + +const enum mod_pinctrl_drv_configuration_type read_only_pin_configuration[] = { + INPUT_VALUE +}; + +uint16_t pin_0_allowed_func[] = { GPIO_FUNC_IDX, UART_FUNC_IDX }; +uint16_t pin_1_allowed_func[] = { GPIO_FUNC_IDX, UART_FUNC_IDX }; +uint16_t pin_2_allowed_func[] = { GPIO_FUNC_IDX, SPI_FUNC_IDX }; +uint16_t pin_3_allowed_func[] = { GPIO_FUNC_IDX, SPI_FUNC_IDX }; +uint16_t pin_4_allowed_func[] = { GPIO_FUNC_IDX, SPI_FUNC_IDX }; +uint16_t pin_5_allowed_func[] = { UART_FUNC_IDX, I2C_FUNC_IDX }; +uint16_t pin_6_allowed_func[] = { UART_FUNC_IDX, I2C_FUNC_IDX }; + +struct mod_pinctrl_pin pins[] = +{ + [PIN_0_IDX] = + { + .name = "PIN_0", + .allowed_functions = pin_0_allowed_func, + .num_allowed_functions = FWK_ARRAY_SIZE(pin_0_allowed_func), + .configuration = pin_configuration, + .num_configuration = FWK_ARRAY_SIZE(pin_configuration), + .read_only_configuration = read_only_pin_configuration, + .num_of_read_only_configurations = FWK_ARRAY_SIZE(read_only_pin_configuration), + }, + [PIN_1_IDX] = + { + .name = "PIN_1", + .allowed_functions = pin_1_allowed_func, + .num_allowed_functions = FWK_ARRAY_SIZE(pin_1_allowed_func), + .configuration = pin_configuration, + .num_configuration = FWK_ARRAY_SIZE(pin_configuration), + .read_only_configuration = read_only_pin_configuration, + .num_of_read_only_configurations = FWK_ARRAY_SIZE(read_only_pin_configuration), + }, + [PIN_2_IDX] = + { + .name = "PIN_2", + .allowed_functions = pin_2_allowed_func, + .num_allowed_functions = FWK_ARRAY_SIZE(pin_2_allowed_func), + .configuration = pin_configuration, + .num_configuration = FWK_ARRAY_SIZE(pin_configuration), + }, + [PIN_3_IDX] = + { + .name = "PIN_3", + .allowed_functions = pin_3_allowed_func, + .num_allowed_functions = FWK_ARRAY_SIZE(pin_3_allowed_func), + .configuration = pin_configuration, + .num_configuration = FWK_ARRAY_SIZE(pin_configuration), + .read_only_configuration = read_only_pin_configuration, + .num_of_read_only_configurations = FWK_ARRAY_SIZE(read_only_pin_configuration), + }, + [PIN_4_IDX] = + { + .name = "PIN_4", + .allowed_functions = pin_4_allowed_func, + .num_allowed_functions = FWK_ARRAY_SIZE(pin_4_allowed_func), + .configuration = pin_configuration, + .num_configuration = FWK_ARRAY_SIZE(pin_configuration), + .read_only_configuration = read_only_pin_configuration, + .num_of_read_only_configurations = FWK_ARRAY_SIZE(read_only_pin_configuration), + }, + [PIN_5_IDX] = + { + .name = "PIN_5", + .allowed_functions = pin_5_allowed_func, + .num_allowed_functions = FWK_ARRAY_SIZE(pin_5_allowed_func), + .configuration = pin_configuration, + .num_configuration = FWK_ARRAY_SIZE(pin_configuration), + .read_only_configuration = read_only_pin_configuration, + .num_of_read_only_configurations = FWK_ARRAY_SIZE(read_only_pin_configuration), + }, + [PIN_6_IDX] = + { + .name = "PIN_6", + .allowed_functions = pin_6_allowed_func, + .num_allowed_functions = FWK_ARRAY_SIZE(pin_6_allowed_func), + .configuration = pin_configuration, + .num_configuration = FWK_ARRAY_SIZE(pin_configuration), + .read_only_configuration = read_only_pin_configuration, + .num_of_read_only_configurations = FWK_ARRAY_SIZE(read_only_pin_configuration), + }, +}; + +struct mod_pinctrl_function functions[] = +{ + [GPIO_FUNC_IDX] = + { + .name = "f_gpio_a", + .is_gpio = false, + .is_pin_only = true, + }, + [UART_FUNC_IDX] = + { + .name = "f_uart_a", + .is_gpio = false, + .is_pin_only = false, + }, + [SPI_FUNC_IDX] = + { + .name = "f_spi_a", + .is_gpio = false, + .is_pin_only = false, + }, + [I2C_FUNC_IDX] = + { + .name = "f_i2c_a", + .is_gpio = false, + .is_pin_only = false, + }, +}; + +const uint16_t grp_uart_pin_idx[] = { PIN_0_IDX, PIN_1_IDX }; +const uint16_t grp_uart_1_pin_idx[] = { PIN_5_IDX, PIN_6_IDX }; +const uint16_t grp_spi_pin_idx[] = { PIN_2_IDX, PIN_3_IDX, PIN_4_IDX }; +const uint16_t grp_i2c_pin_idx[] = { PIN_5_IDX, PIN_6_IDX }; +const uint16_t grp_gpio_pin_idx[] = { PIN_0_IDX, PIN_1_IDX, PIN_2_IDX, + PIN_3_IDX, PIN_4_IDX, PIN_5_IDX }; + +struct mod_pinctrl_group groups[] = +{ + [UART_GROUP_IDX] = + { + .name = "grp_uart_a", + .is_gpio = false, + .function = UART_FUNC_IDX, + .pins = grp_uart_pin_idx, + .num_pins = FWK_ARRAY_SIZE(grp_uart_pin_idx), + }, + [SPI_GROUP_IDX] = + { + .name = "grp_spi_a", + .is_gpio = false, + .function = SPI_FUNC_IDX, + .pins = grp_spi_pin_idx, + .num_pins = FWK_ARRAY_SIZE(grp_spi_pin_idx), + }, + [I2C_GROUP_IDX] = + { + .name = "grp_i2c_a", + .is_gpio = false, + .function = I2C_FUNC_IDX, + .pins = grp_i2c_pin_idx, + .num_pins = FWK_ARRAY_SIZE(grp_i2c_pin_idx), + }, + [GPIO_GROUP_IDX] = + { + .name = "grp_gpio", + .is_gpio = true, + .function = GPIO_FUNC_IDX, + .pins = grp_gpio_pin_idx, + .num_pins = FWK_ARRAY_SIZE(grp_gpio_pin_idx), + }, + [UART_1_GROUP_IDX] = + { + .name = "grp_uart_1", + .is_gpio = false, + .function = UART_FUNC_IDX, + .pins = grp_uart_1_pin_idx, + .num_pins = FWK_ARRAY_SIZE(grp_uart_1_pin_idx), + }, +}; + +struct mod_pinctrl_config config = { + .functions_table = functions, + .function_table_count = FWK_ARRAY_SIZE(functions), + .groups_table = groups, + .group_table_count = FWK_ARRAY_SIZE(groups), + .pins_table = pins, + .pin_table_count = FWK_ARRAY_SIZE(pins), +}; + +#endif /* CONFIG_PINCTRL_H */ diff --git a/module/pinctrl/test/fwk_module_idx.h b/module/pinctrl/test/fwk_module_idx.h new file mode 100644 index 0000000000000000000000000000000000000000..728d9a058e9e1c7a0ebf15fcc5f37e993ad76a9f --- /dev/null +++ b/module/pinctrl/test/fwk_module_idx.h @@ -0,0 +1,33 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2025, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef TEST_FWK_MODULE_IDX_H +#define TEST_FWK_MODULE_IDX_H + +#include + +enum fwk_module_idx { + FWK_MODULE_IDX_PINCTRL, + FWK_MODULE_IDX_PINCTRL_DRV, + FWK_MODULE_IDX_COUNT, +}; + +enum fwk_module_element_idx { + FWK_MODULE_PINCTRL_DRV_API, + FWK_MODULE_DRV_API_COUNT +}; + +static const fwk_id_t fwk_module_id_pinctrl = + FWK_ID_MODULE_INIT(FWK_MODULE_IDX_PINCTRL); + +static const fwk_id_t pinctrl_drv_id = + FWK_ID_MODULE(FWK_MODULE_IDX_PINCTRL_DRV); + +static const fwk_id_t pinctrl_drv_api_id = + FWK_ID_API(FWK_MODULE_IDX_PINCTRL_DRV, FWK_MODULE_PINCTRL_DRV_API); + +#endif /* TEST_FWK_MODULE_IDX_H */ diff --git a/module/pinctrl/test/mocks/.clang-format b/module/pinctrl/test/mocks/.clang-format new file mode 100644 index 0000000000000000000000000000000000000000..eeca2395f4c7551e2016f0d10a971844a3684994 --- /dev/null +++ b/module/pinctrl/test/mocks/.clang-format @@ -0,0 +1,4 @@ +{ + "DisableFormat": true, + "SortIncludes": false, +} diff --git a/module/pinctrl/test/mocks/Mockmod_pinctrl_drv_extra.c b/module/pinctrl/test/mocks/Mockmod_pinctrl_drv_extra.c new file mode 100644 index 0000000000000000000000000000000000000000..2062a440eed89ba8caea7d58e9727627cb7885b7 --- /dev/null +++ b/module/pinctrl/test/mocks/Mockmod_pinctrl_drv_extra.c @@ -0,0 +1,781 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ +#include +#include +#include +#include "cmock.h" +#include "Mockmod_pinctrl_drv_extra.h" + +static const char* CMockString_function_id = "function_id"; +static const char* CMockString_get_pin_configuration = "get_pin_configuration"; +static const char* CMockString_get_pin_function = "get_pin_function"; +static const char* CMockString_pin_config = "pin_config"; +static const char* CMockString_pin_id = "pin_id"; +static const char* CMockString_set_pin_configuration = "set_pin_configuration"; +static const char* CMockString_set_pin_function = "set_pin_function"; + +typedef struct _CMOCK_get_pin_function_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + uint16_t Expected_pin_id; + 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_pin_id; + char IgnoreArg_function_id; + +} CMOCK_get_pin_function_CALL_INSTANCE; + +typedef struct _CMOCK_set_pin_function_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + uint16_t Expected_pin_id; + uint32_t Expected_function_id; + char IgnoreArg_pin_id; + char IgnoreArg_function_id; + +} CMOCK_set_pin_function_CALL_INSTANCE; + +typedef struct _CMOCK_set_pin_configuration_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + uint16_t Expected_pin_id; + const struct mod_pinctrl_drv_pin_configuration* Expected_pin_config; + int Expected_pin_config_Depth; + char IgnoreArg_pin_id; + char IgnoreArg_pin_config; + +} CMOCK_set_pin_configuration_CALL_INSTANCE; + +typedef struct _CMOCK_get_pin_configuration_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + uint16_t Expected_pin_id; + struct mod_pinctrl_drv_pin_configuration* Expected_pin_config; + int Expected_pin_config_Depth; + char ReturnThruPtr_pin_config_Used; + struct mod_pinctrl_drv_pin_configuration* ReturnThruPtr_pin_config_Val; + size_t ReturnThruPtr_pin_config_Size; + char IgnoreArg_pin_id; + char IgnoreArg_pin_config; + +} CMOCK_get_pin_configuration_CALL_INSTANCE; + +static struct Mockmod_pinctrl_drv_extraInstance +{ + char get_pin_function_IgnoreBool; + int get_pin_function_FinalReturn; + char get_pin_function_CallbackBool; + CMOCK_get_pin_function_CALLBACK get_pin_function_CallbackFunctionPointer; + int get_pin_function_CallbackCalls; + CMOCK_MEM_INDEX_TYPE get_pin_function_CallInstance; + char set_pin_function_IgnoreBool; + int set_pin_function_FinalReturn; + char set_pin_function_CallbackBool; + CMOCK_set_pin_function_CALLBACK set_pin_function_CallbackFunctionPointer; + int set_pin_function_CallbackCalls; + CMOCK_MEM_INDEX_TYPE set_pin_function_CallInstance; + char set_pin_configuration_IgnoreBool; + int set_pin_configuration_FinalReturn; + char set_pin_configuration_CallbackBool; + CMOCK_set_pin_configuration_CALLBACK set_pin_configuration_CallbackFunctionPointer; + int set_pin_configuration_CallbackCalls; + CMOCK_MEM_INDEX_TYPE set_pin_configuration_CallInstance; + char get_pin_configuration_IgnoreBool; + int get_pin_configuration_FinalReturn; + char get_pin_configuration_CallbackBool; + CMOCK_get_pin_configuration_CALLBACK get_pin_configuration_CallbackFunctionPointer; + int get_pin_configuration_CallbackCalls; + CMOCK_MEM_INDEX_TYPE get_pin_configuration_CallInstance; +} Mock; + +extern jmp_buf AbortFrame; + +void Mockmod_pinctrl_drv_extra_Verify(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_MEM_INDEX_TYPE call_instance; + call_instance = Mock.get_pin_function_CallInstance; + if (Mock.get_pin_function_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_get_pin_function); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.get_pin_function_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.set_pin_function_CallInstance; + if (Mock.set_pin_function_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_set_pin_function); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.set_pin_function_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.set_pin_configuration_CallInstance; + if (Mock.set_pin_configuration_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_set_pin_configuration); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.set_pin_configuration_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.get_pin_configuration_CallInstance; + if (Mock.get_pin_configuration_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_get_pin_configuration); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.get_pin_configuration_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } +} + +void Mockmod_pinctrl_drv_extra_Init(void) +{ + Mockmod_pinctrl_drv_extra_Destroy(); +} + +void Mockmod_pinctrl_drv_extra_Destroy(void) +{ + CMock_Guts_MemFreeAll(); + memset(&Mock, 0, sizeof(Mock)); +} + +int get_pin_function(uint16_t pin_id, uint32_t* function_id) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_get_pin_function_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_get_pin_function); + cmock_call_instance = (CMOCK_get_pin_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_pin_function_CallInstance); + Mock.get_pin_function_CallInstance = CMock_Guts_MemNext(Mock.get_pin_function_CallInstance); + if (Mock.get_pin_function_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.get_pin_function_FinalReturn; + Mock.get_pin_function_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.get_pin_function_CallbackBool && + Mock.get_pin_function_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.get_pin_function_CallbackFunctionPointer(pin_id, function_id, Mock.get_pin_function_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_pin_id) + { + UNITY_SET_DETAILS(CMockString_get_pin_function,CMockString_pin_id); + UNITY_TEST_ASSERT_EQUAL_HEX16(cmock_call_instance->Expected_pin_id, pin_id, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_function_id) + { + UNITY_SET_DETAILS(CMockString_get_pin_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_HEX32_ARRAY(cmock_call_instance->Expected_function_id, function_id, cmock_call_instance->Expected_function_id_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.get_pin_function_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.get_pin_function_CallbackFunctionPointer(pin_id, function_id, Mock.get_pin_function_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_function_id_Used) + { + 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_pin_function(CMOCK_get_pin_function_CALL_INSTANCE* cmock_call_instance, uint16_t pin_id, uint32_t* function_id, int function_id_Depth); +void CMockExpectParameters_get_pin_function(CMOCK_get_pin_function_CALL_INSTANCE* cmock_call_instance, uint16_t pin_id, uint32_t* function_id, int function_id_Depth) +{ + cmock_call_instance->Expected_pin_id = pin_id; + cmock_call_instance->IgnoreArg_pin_id = 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_pin_function_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_pin_function_CALL_INSTANCE)); + CMOCK_get_pin_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_pin_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_pin_function_CallInstance = CMock_Guts_MemChain(Mock.get_pin_function_CallInstance, cmock_guts_index); + Mock.get_pin_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_pin_function_IgnoreBool = (char)1; +} + +void get_pin_function_CMockStopIgnore(void) +{ + if(Mock.get_pin_function_IgnoreBool) + Mock.get_pin_function_CallInstance = CMock_Guts_MemNext(Mock.get_pin_function_CallInstance); + Mock.get_pin_function_IgnoreBool = (char)0; +} + +void get_pin_function_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_pin_function_CALL_INSTANCE)); + CMOCK_get_pin_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_pin_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_pin_function_CallInstance = CMock_Guts_MemChain(Mock.get_pin_function_CallInstance, cmock_guts_index); + Mock.get_pin_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_pin_function_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t pin_id, uint32_t* function_id, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_pin_function_CALL_INSTANCE)); + CMOCK_get_pin_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_pin_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_pin_function_CallInstance = CMock_Guts_MemChain(Mock.get_pin_function_CallInstance, cmock_guts_index); + Mock.get_pin_function_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_pin_function(cmock_call_instance, pin_id, function_id, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_pin_function_AddCallback(CMOCK_get_pin_function_CALLBACK Callback) +{ + Mock.get_pin_function_IgnoreBool = (char)0; + Mock.get_pin_function_CallbackBool = (char)1; + Mock.get_pin_function_CallbackFunctionPointer = Callback; +} + +void get_pin_function_Stub(CMOCK_get_pin_function_CALLBACK Callback) +{ + Mock.get_pin_function_IgnoreBool = (char)0; + Mock.get_pin_function_CallbackBool = (char)0; + Mock.get_pin_function_CallbackFunctionPointer = Callback; +} + +void get_pin_function_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t pin_id, 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_pin_function_CALL_INSTANCE)); + CMOCK_get_pin_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_pin_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_pin_function_CallInstance = CMock_Guts_MemChain(Mock.get_pin_function_CallInstance, cmock_guts_index); + Mock.get_pin_function_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_pin_function(cmock_call_instance, pin_id, function_id, function_id_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_pin_function_CMockReturnMemThruPtr_function_id(UNITY_LINE_TYPE cmock_line, uint32_t* function_id, size_t cmock_size) +{ + CMOCK_get_pin_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_pin_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_pin_function_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + 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_pin_function_CMockIgnoreArg_pin_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_pin_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_pin_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_pin_function_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pin_id = 1; +} + +void get_pin_function_CMockIgnoreArg_function_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_pin_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_pin_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_pin_function_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_function_id = 1; +} + +int set_pin_function(uint16_t pin_id, uint32_t function_id) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_set_pin_function_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_set_pin_function); + cmock_call_instance = (CMOCK_set_pin_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.set_pin_function_CallInstance); + Mock.set_pin_function_CallInstance = CMock_Guts_MemNext(Mock.set_pin_function_CallInstance); + if (Mock.set_pin_function_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.set_pin_function_FinalReturn; + Mock.set_pin_function_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.set_pin_function_CallbackBool && + Mock.set_pin_function_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.set_pin_function_CallbackFunctionPointer(pin_id, function_id, Mock.set_pin_function_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_pin_id) + { + UNITY_SET_DETAILS(CMockString_set_pin_function,CMockString_pin_id); + UNITY_TEST_ASSERT_EQUAL_HEX16(cmock_call_instance->Expected_pin_id, pin_id, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_function_id) + { + UNITY_SET_DETAILS(CMockString_set_pin_function,CMockString_function_id); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_function_id, function_id, cmock_line, CMockStringMismatch); + } + } + if (Mock.set_pin_function_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.set_pin_function_CallbackFunctionPointer(pin_id, function_id, Mock.set_pin_function_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_set_pin_function(CMOCK_set_pin_function_CALL_INSTANCE* cmock_call_instance, uint16_t pin_id, uint32_t function_id); +void CMockExpectParameters_set_pin_function(CMOCK_set_pin_function_CALL_INSTANCE* cmock_call_instance, uint16_t pin_id, uint32_t function_id) +{ + cmock_call_instance->Expected_pin_id = pin_id; + cmock_call_instance->IgnoreArg_pin_id = 0; + cmock_call_instance->Expected_function_id = function_id; + cmock_call_instance->IgnoreArg_function_id = 0; +} + +void set_pin_function_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_pin_function_CALL_INSTANCE)); + CMOCK_set_pin_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_pin_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_pin_function_CallInstance = CMock_Guts_MemChain(Mock.set_pin_function_CallInstance, cmock_guts_index); + Mock.set_pin_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_pin_function_IgnoreBool = (char)1; +} + +void set_pin_function_CMockStopIgnore(void) +{ + if(Mock.set_pin_function_IgnoreBool) + Mock.set_pin_function_CallInstance = CMock_Guts_MemNext(Mock.set_pin_function_CallInstance); + Mock.set_pin_function_IgnoreBool = (char)0; +} + +void set_pin_function_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_pin_function_CALL_INSTANCE)); + CMOCK_set_pin_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_pin_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_pin_function_CallInstance = CMock_Guts_MemChain(Mock.set_pin_function_CallInstance, cmock_guts_index); + Mock.set_pin_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_pin_function_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t pin_id, uint32_t function_id, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_pin_function_CALL_INSTANCE)); + CMOCK_set_pin_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_pin_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_pin_function_CallInstance = CMock_Guts_MemChain(Mock.set_pin_function_CallInstance, cmock_guts_index); + Mock.set_pin_function_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_set_pin_function(cmock_call_instance, pin_id, function_id); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void set_pin_function_AddCallback(CMOCK_set_pin_function_CALLBACK Callback) +{ + Mock.set_pin_function_IgnoreBool = (char)0; + Mock.set_pin_function_CallbackBool = (char)1; + Mock.set_pin_function_CallbackFunctionPointer = Callback; +} + +void set_pin_function_Stub(CMOCK_set_pin_function_CALLBACK Callback) +{ + Mock.set_pin_function_IgnoreBool = (char)0; + Mock.set_pin_function_CallbackBool = (char)0; + Mock.set_pin_function_CallbackFunctionPointer = Callback; +} + +void set_pin_function_CMockIgnoreArg_pin_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_set_pin_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_pin_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_pin_function_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pin_id = 1; +} + +void set_pin_function_CMockIgnoreArg_function_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_set_pin_function_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_pin_function_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_pin_function_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_function_id = 1; +} + +int set_pin_configuration(uint16_t pin_id, const struct mod_pinctrl_drv_pin_configuration* pin_config) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_set_pin_configuration_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_set_pin_configuration); + cmock_call_instance = (CMOCK_set_pin_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.set_pin_configuration_CallInstance); + Mock.set_pin_configuration_CallInstance = CMock_Guts_MemNext(Mock.set_pin_configuration_CallInstance); + if (Mock.set_pin_configuration_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.set_pin_configuration_FinalReturn; + Mock.set_pin_configuration_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.set_pin_configuration_CallbackBool && + Mock.set_pin_configuration_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.set_pin_configuration_CallbackFunctionPointer(pin_id, pin_config, Mock.set_pin_configuration_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_pin_id) + { + UNITY_SET_DETAILS(CMockString_set_pin_configuration,CMockString_pin_id); + UNITY_TEST_ASSERT_EQUAL_HEX16(cmock_call_instance->Expected_pin_id, pin_id, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pin_config) + { + UNITY_SET_DETAILS(CMockString_set_pin_configuration,CMockString_pin_config); + if (cmock_call_instance->Expected_pin_config == NULL) + { UNITY_TEST_ASSERT_NULL(pin_config, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_pin_config), (void*)(pin_config), sizeof(const struct mod_pinctrl_drv_pin_configuration), cmock_call_instance->Expected_pin_config_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.set_pin_configuration_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.set_pin_configuration_CallbackFunctionPointer(pin_id, pin_config, Mock.set_pin_configuration_CallbackCalls++); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_set_pin_configuration(CMOCK_set_pin_configuration_CALL_INSTANCE* cmock_call_instance, uint16_t pin_id, const struct mod_pinctrl_drv_pin_configuration* pin_config, int pin_config_Depth); +void CMockExpectParameters_set_pin_configuration(CMOCK_set_pin_configuration_CALL_INSTANCE* cmock_call_instance, uint16_t pin_id, const struct mod_pinctrl_drv_pin_configuration* pin_config, int pin_config_Depth) +{ + cmock_call_instance->Expected_pin_id = pin_id; + cmock_call_instance->IgnoreArg_pin_id = 0; + cmock_call_instance->Expected_pin_config = pin_config; + cmock_call_instance->Expected_pin_config_Depth = pin_config_Depth; + cmock_call_instance->IgnoreArg_pin_config = 0; +} + +void set_pin_configuration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_pin_configuration_CALL_INSTANCE)); + CMOCK_set_pin_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_pin_configuration_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_pin_configuration_CallInstance = CMock_Guts_MemChain(Mock.set_pin_configuration_CallInstance, cmock_guts_index); + Mock.set_pin_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.set_pin_configuration_IgnoreBool = (char)1; +} + +void set_pin_configuration_CMockStopIgnore(void) +{ + if(Mock.set_pin_configuration_IgnoreBool) + Mock.set_pin_configuration_CallInstance = CMock_Guts_MemNext(Mock.set_pin_configuration_CallInstance); + Mock.set_pin_configuration_IgnoreBool = (char)0; +} + +void set_pin_configuration_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_pin_configuration_CALL_INSTANCE)); + CMOCK_set_pin_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_pin_configuration_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_pin_configuration_CallInstance = CMock_Guts_MemChain(Mock.set_pin_configuration_CallInstance, cmock_guts_index); + Mock.set_pin_configuration_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_pin_configuration_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t pin_id, const struct mod_pinctrl_drv_pin_configuration* pin_config, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_pin_configuration_CALL_INSTANCE)); + CMOCK_set_pin_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_pin_configuration_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_pin_configuration_CallInstance = CMock_Guts_MemChain(Mock.set_pin_configuration_CallInstance, cmock_guts_index); + Mock.set_pin_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_set_pin_configuration(cmock_call_instance, pin_id, pin_config, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void set_pin_configuration_AddCallback(CMOCK_set_pin_configuration_CALLBACK Callback) +{ + Mock.set_pin_configuration_IgnoreBool = (char)0; + Mock.set_pin_configuration_CallbackBool = (char)1; + Mock.set_pin_configuration_CallbackFunctionPointer = Callback; +} + +void set_pin_configuration_Stub(CMOCK_set_pin_configuration_CALLBACK Callback) +{ + Mock.set_pin_configuration_IgnoreBool = (char)0; + Mock.set_pin_configuration_CallbackBool = (char)0; + Mock.set_pin_configuration_CallbackFunctionPointer = Callback; +} + +void set_pin_configuration_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t pin_id, const struct mod_pinctrl_drv_pin_configuration* pin_config, int pin_config_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_set_pin_configuration_CALL_INSTANCE)); + CMOCK_set_pin_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_pin_configuration_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_pin_configuration_CallInstance = CMock_Guts_MemChain(Mock.set_pin_configuration_CallInstance, cmock_guts_index); + Mock.set_pin_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_set_pin_configuration(cmock_call_instance, pin_id, pin_config, pin_config_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void set_pin_configuration_CMockIgnoreArg_pin_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_set_pin_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_pin_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_pin_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pin_id = 1; +} + +void set_pin_configuration_CMockIgnoreArg_pin_config(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_set_pin_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_set_pin_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.set_pin_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pin_config = 1; +} + +int get_pin_configuration(uint16_t pin_id, struct mod_pinctrl_drv_pin_configuration* pin_config) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_get_pin_configuration_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_get_pin_configuration); + cmock_call_instance = (CMOCK_get_pin_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.get_pin_configuration_CallInstance); + Mock.get_pin_configuration_CallInstance = CMock_Guts_MemNext(Mock.get_pin_configuration_CallInstance); + if (Mock.get_pin_configuration_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.get_pin_configuration_FinalReturn; + Mock.get_pin_configuration_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.get_pin_configuration_CallbackBool && + Mock.get_pin_configuration_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.get_pin_configuration_CallbackFunctionPointer(pin_id, pin_config, Mock.get_pin_configuration_CallbackCalls++); + UNITY_CLR_DETAILS(); + return cmock_cb_ret; + } + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore); + cmock_line = cmock_call_instance->LineNumber; + if (!cmock_call_instance->ExpectAnyArgsBool) + { + if (!cmock_call_instance->IgnoreArg_pin_id) + { + UNITY_SET_DETAILS(CMockString_get_pin_configuration,CMockString_pin_id); + UNITY_TEST_ASSERT_EQUAL_HEX16(cmock_call_instance->Expected_pin_id, pin_id, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_pin_config) + { + UNITY_SET_DETAILS(CMockString_get_pin_configuration,CMockString_pin_config); + if (cmock_call_instance->Expected_pin_config == NULL) + { UNITY_TEST_ASSERT_NULL(pin_config, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_pin_config), (void*)(pin_config), sizeof(struct mod_pinctrl_drv_pin_configuration), cmock_call_instance->Expected_pin_config_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.get_pin_configuration_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.get_pin_configuration_CallbackFunctionPointer(pin_id, pin_config, Mock.get_pin_configuration_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_pin_config_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(pin_config, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)pin_config, (void*)cmock_call_instance->ReturnThruPtr_pin_config_Val, + cmock_call_instance->ReturnThruPtr_pin_config_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_get_pin_configuration(CMOCK_get_pin_configuration_CALL_INSTANCE* cmock_call_instance, uint16_t pin_id, struct mod_pinctrl_drv_pin_configuration* pin_config, int pin_config_Depth); +void CMockExpectParameters_get_pin_configuration(CMOCK_get_pin_configuration_CALL_INSTANCE* cmock_call_instance, uint16_t pin_id, struct mod_pinctrl_drv_pin_configuration* pin_config, int pin_config_Depth) +{ + cmock_call_instance->Expected_pin_id = pin_id; + cmock_call_instance->IgnoreArg_pin_id = 0; + cmock_call_instance->Expected_pin_config = pin_config; + cmock_call_instance->Expected_pin_config_Depth = pin_config_Depth; + cmock_call_instance->IgnoreArg_pin_config = 0; + cmock_call_instance->ReturnThruPtr_pin_config_Used = 0; +} + +void get_pin_configuration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_pin_configuration_CALL_INSTANCE)); + CMOCK_get_pin_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_pin_configuration_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_pin_configuration_CallInstance = CMock_Guts_MemChain(Mock.get_pin_configuration_CallInstance, cmock_guts_index); + Mock.get_pin_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.get_pin_configuration_IgnoreBool = (char)1; +} + +void get_pin_configuration_CMockStopIgnore(void) +{ + if(Mock.get_pin_configuration_IgnoreBool) + Mock.get_pin_configuration_CallInstance = CMock_Guts_MemNext(Mock.get_pin_configuration_CallInstance); + Mock.get_pin_configuration_IgnoreBool = (char)0; +} + +void get_pin_configuration_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_pin_configuration_CALL_INSTANCE)); + CMOCK_get_pin_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_pin_configuration_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_pin_configuration_CallInstance = CMock_Guts_MemChain(Mock.get_pin_configuration_CallInstance, cmock_guts_index); + Mock.get_pin_configuration_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_pin_configuration_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t pin_id, struct mod_pinctrl_drv_pin_configuration* pin_config, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_pin_configuration_CALL_INSTANCE)); + CMOCK_get_pin_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_pin_configuration_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_pin_configuration_CallInstance = CMock_Guts_MemChain(Mock.get_pin_configuration_CallInstance, cmock_guts_index); + Mock.get_pin_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_pin_configuration(cmock_call_instance, pin_id, pin_config, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_pin_configuration_AddCallback(CMOCK_get_pin_configuration_CALLBACK Callback) +{ + Mock.get_pin_configuration_IgnoreBool = (char)0; + Mock.get_pin_configuration_CallbackBool = (char)1; + Mock.get_pin_configuration_CallbackFunctionPointer = Callback; +} + +void get_pin_configuration_Stub(CMOCK_get_pin_configuration_CALLBACK Callback) +{ + Mock.get_pin_configuration_IgnoreBool = (char)0; + Mock.get_pin_configuration_CallbackBool = (char)0; + Mock.get_pin_configuration_CallbackFunctionPointer = Callback; +} + +void get_pin_configuration_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t pin_id, struct mod_pinctrl_drv_pin_configuration* pin_config, int pin_config_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_get_pin_configuration_CALL_INSTANCE)); + CMOCK_get_pin_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_pin_configuration_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_pin_configuration_CallInstance = CMock_Guts_MemChain(Mock.get_pin_configuration_CallInstance, cmock_guts_index); + Mock.get_pin_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_get_pin_configuration(cmock_call_instance, pin_id, pin_config, pin_config_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void get_pin_configuration_CMockReturnMemThruPtr_pin_config(UNITY_LINE_TYPE cmock_line, struct mod_pinctrl_drv_pin_configuration* pin_config, size_t cmock_size) +{ + CMOCK_get_pin_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_pin_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_pin_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_pin_config_Used = 1; + cmock_call_instance->ReturnThruPtr_pin_config_Val = pin_config; + cmock_call_instance->ReturnThruPtr_pin_config_Size = cmock_size; +} + +void get_pin_configuration_CMockIgnoreArg_pin_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_pin_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_pin_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_pin_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pin_id = 1; +} + +void get_pin_configuration_CMockIgnoreArg_pin_config(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_get_pin_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_get_pin_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.get_pin_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pin_config = 1; +} + diff --git a/module/pinctrl/test/mocks/Mockmod_pinctrl_drv_extra.h b/module/pinctrl/test/mocks/Mockmod_pinctrl_drv_extra.h new file mode 100644 index 0000000000000000000000000000000000000000..0c7e902f4ddee138de77e28a4fbd81aaba35cba5 --- /dev/null +++ b/module/pinctrl/test/mocks/Mockmod_pinctrl_drv_extra.h @@ -0,0 +1,112 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ +#ifndef _MOCKMOD_PINCTRL_DRV_EXTRA_H +#define _MOCKMOD_PINCTRL_DRV_EXTRA_H + +#include "unity.h" +#include "mod_pinctrl_drv_extra.h" + +/* Ignore the following warnings, since we are copying code */ +#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__) +#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0))) +#pragma GCC diagnostic push +#endif +#if !defined(__clang__) +#pragma GCC diagnostic ignored "-Wpragmas" +#endif +#pragma GCC diagnostic ignored "-Wunknown-pragmas" +#pragma GCC diagnostic ignored "-Wduplicate-decl-specifier" +#endif + +void Mockmod_pinctrl_drv_extra_Init(void); +void Mockmod_pinctrl_drv_extra_Destroy(void); +void Mockmod_pinctrl_drv_extra_Verify(void); + + + + +#define get_pin_function_IgnoreAndReturn(cmock_retval) get_pin_function_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void get_pin_function_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_pin_function_StopIgnore() get_pin_function_CMockStopIgnore() +void get_pin_function_CMockStopIgnore(void); +#define get_pin_function_ExpectAnyArgsAndReturn(cmock_retval) get_pin_function_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void get_pin_function_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_pin_function_ExpectAndReturn(pin_id, function_id, cmock_retval) get_pin_function_CMockExpectAndReturn(__LINE__, pin_id, function_id, cmock_retval) +void get_pin_function_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t pin_id, uint32_t* function_id, int cmock_to_return); +typedef int (* CMOCK_get_pin_function_CALLBACK)(uint16_t pin_id, uint32_t* function_id, int cmock_num_calls); +void get_pin_function_AddCallback(CMOCK_get_pin_function_CALLBACK Callback); +void get_pin_function_Stub(CMOCK_get_pin_function_CALLBACK Callback); +#define get_pin_function_StubWithCallback get_pin_function_Stub +#define get_pin_function_ExpectWithArrayAndReturn(pin_id, function_id, function_id_Depth, cmock_retval) get_pin_function_CMockExpectWithArrayAndReturn(__LINE__, pin_id, function_id, function_id_Depth, cmock_retval) +void get_pin_function_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t pin_id, uint32_t* function_id, int function_id_Depth, int cmock_to_return); +#define get_pin_function_ReturnThruPtr_function_id(function_id) get_pin_function_CMockReturnMemThruPtr_function_id(__LINE__, function_id, sizeof(uint32_t)) +#define get_pin_function_ReturnArrayThruPtr_function_id(function_id, cmock_len) get_pin_function_CMockReturnMemThruPtr_function_id(__LINE__, function_id, cmock_len * sizeof(*function_id)) +#define get_pin_function_ReturnMemThruPtr_function_id(function_id, cmock_size) get_pin_function_CMockReturnMemThruPtr_function_id(__LINE__, function_id, cmock_size) +void get_pin_function_CMockReturnMemThruPtr_function_id(UNITY_LINE_TYPE cmock_line, uint32_t* function_id, size_t cmock_size); +#define get_pin_function_IgnoreArg_pin_id() get_pin_function_CMockIgnoreArg_pin_id(__LINE__) +void get_pin_function_CMockIgnoreArg_pin_id(UNITY_LINE_TYPE cmock_line); +#define get_pin_function_IgnoreArg_function_id() get_pin_function_CMockIgnoreArg_function_id(__LINE__) +void get_pin_function_CMockIgnoreArg_function_id(UNITY_LINE_TYPE cmock_line); +#define set_pin_function_IgnoreAndReturn(cmock_retval) set_pin_function_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void set_pin_function_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define set_pin_function_StopIgnore() set_pin_function_CMockStopIgnore() +void set_pin_function_CMockStopIgnore(void); +#define set_pin_function_ExpectAnyArgsAndReturn(cmock_retval) set_pin_function_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void set_pin_function_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define set_pin_function_ExpectAndReturn(pin_id, function_id, cmock_retval) set_pin_function_CMockExpectAndReturn(__LINE__, pin_id, function_id, cmock_retval) +void set_pin_function_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t pin_id, uint32_t function_id, int cmock_to_return); +typedef int (* CMOCK_set_pin_function_CALLBACK)(uint16_t pin_id, uint32_t function_id, int cmock_num_calls); +void set_pin_function_AddCallback(CMOCK_set_pin_function_CALLBACK Callback); +void set_pin_function_Stub(CMOCK_set_pin_function_CALLBACK Callback); +#define set_pin_function_StubWithCallback set_pin_function_Stub +#define set_pin_function_IgnoreArg_pin_id() set_pin_function_CMockIgnoreArg_pin_id(__LINE__) +void set_pin_function_CMockIgnoreArg_pin_id(UNITY_LINE_TYPE cmock_line); +#define set_pin_function_IgnoreArg_function_id() set_pin_function_CMockIgnoreArg_function_id(__LINE__) +void set_pin_function_CMockIgnoreArg_function_id(UNITY_LINE_TYPE cmock_line); +#define set_pin_configuration_IgnoreAndReturn(cmock_retval) set_pin_configuration_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void set_pin_configuration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define set_pin_configuration_StopIgnore() set_pin_configuration_CMockStopIgnore() +void set_pin_configuration_CMockStopIgnore(void); +#define set_pin_configuration_ExpectAnyArgsAndReturn(cmock_retval) set_pin_configuration_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void set_pin_configuration_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define set_pin_configuration_ExpectAndReturn(pin_id, pin_config, cmock_retval) set_pin_configuration_CMockExpectAndReturn(__LINE__, pin_id, pin_config, cmock_retval) +void set_pin_configuration_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t pin_id, const struct mod_pinctrl_drv_pin_configuration* pin_config, int cmock_to_return); +typedef int (* CMOCK_set_pin_configuration_CALLBACK)(uint16_t pin_id, const struct mod_pinctrl_drv_pin_configuration* pin_config, int cmock_num_calls); +void set_pin_configuration_AddCallback(CMOCK_set_pin_configuration_CALLBACK Callback); +void set_pin_configuration_Stub(CMOCK_set_pin_configuration_CALLBACK Callback); +#define set_pin_configuration_StubWithCallback set_pin_configuration_Stub +#define set_pin_configuration_ExpectWithArrayAndReturn(pin_id, pin_config, pin_config_Depth, cmock_retval) set_pin_configuration_CMockExpectWithArrayAndReturn(__LINE__, pin_id, pin_config, pin_config_Depth, cmock_retval) +void set_pin_configuration_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t pin_id, const struct mod_pinctrl_drv_pin_configuration* pin_config, int pin_config_Depth, int cmock_to_return); +#define set_pin_configuration_IgnoreArg_pin_id() set_pin_configuration_CMockIgnoreArg_pin_id(__LINE__) +void set_pin_configuration_CMockIgnoreArg_pin_id(UNITY_LINE_TYPE cmock_line); +#define set_pin_configuration_IgnoreArg_pin_config() set_pin_configuration_CMockIgnoreArg_pin_config(__LINE__) +void set_pin_configuration_CMockIgnoreArg_pin_config(UNITY_LINE_TYPE cmock_line); +#define get_pin_configuration_IgnoreAndReturn(cmock_retval) get_pin_configuration_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void get_pin_configuration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_pin_configuration_StopIgnore() get_pin_configuration_CMockStopIgnore() +void get_pin_configuration_CMockStopIgnore(void); +#define get_pin_configuration_ExpectAnyArgsAndReturn(cmock_retval) get_pin_configuration_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void get_pin_configuration_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define get_pin_configuration_ExpectAndReturn(pin_id, pin_config, cmock_retval) get_pin_configuration_CMockExpectAndReturn(__LINE__, pin_id, pin_config, cmock_retval) +void get_pin_configuration_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t pin_id, struct mod_pinctrl_drv_pin_configuration* pin_config, int cmock_to_return); +typedef int (* CMOCK_get_pin_configuration_CALLBACK)(uint16_t pin_id, struct mod_pinctrl_drv_pin_configuration* pin_config, int cmock_num_calls); +void get_pin_configuration_AddCallback(CMOCK_get_pin_configuration_CALLBACK Callback); +void get_pin_configuration_Stub(CMOCK_get_pin_configuration_CALLBACK Callback); +#define get_pin_configuration_StubWithCallback get_pin_configuration_Stub +#define get_pin_configuration_ExpectWithArrayAndReturn(pin_id, pin_config, pin_config_Depth, cmock_retval) get_pin_configuration_CMockExpectWithArrayAndReturn(__LINE__, pin_id, pin_config, pin_config_Depth, cmock_retval) +void get_pin_configuration_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, uint16_t pin_id, struct mod_pinctrl_drv_pin_configuration* pin_config, int pin_config_Depth, int cmock_to_return); +#define get_pin_configuration_ReturnThruPtr_pin_config(pin_config) get_pin_configuration_CMockReturnMemThruPtr_pin_config(__LINE__, pin_config, sizeof(struct mod_pinctrl_drv_pin_configuration)) +#define get_pin_configuration_ReturnArrayThruPtr_pin_config(pin_config, cmock_len) get_pin_configuration_CMockReturnMemThruPtr_pin_config(__LINE__, pin_config, cmock_len * sizeof(*pin_config)) +#define get_pin_configuration_ReturnMemThruPtr_pin_config(pin_config, cmock_size) get_pin_configuration_CMockReturnMemThruPtr_pin_config(__LINE__, pin_config, cmock_size) +void get_pin_configuration_CMockReturnMemThruPtr_pin_config(UNITY_LINE_TYPE cmock_line, struct mod_pinctrl_drv_pin_configuration* pin_config, size_t cmock_size); +#define get_pin_configuration_IgnoreArg_pin_id() get_pin_configuration_CMockIgnoreArg_pin_id(__LINE__) +void get_pin_configuration_CMockIgnoreArg_pin_id(UNITY_LINE_TYPE cmock_line); +#define get_pin_configuration_IgnoreArg_pin_config() get_pin_configuration_CMockIgnoreArg_pin_config(__LINE__) +void get_pin_configuration_CMockIgnoreArg_pin_config(UNITY_LINE_TYPE cmock_line); + +#if defined(__GNUC__) && !defined(__ICC) && !defined(__TMS470__) +#if __GNUC__ > 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ > 6 || (__GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ > 0))) +#pragma GCC diagnostic pop +#endif +#endif + +#endif diff --git a/module/pinctrl/test/mod_pinctrl_drv_extra.h b/module/pinctrl/test/mod_pinctrl_drv_extra.h new file mode 100644 index 0000000000000000000000000000000000000000..b937f9553a6324d4d1dc234f306bc06c04f14e5d --- /dev/null +++ b/module/pinctrl/test/mod_pinctrl_drv_extra.h @@ -0,0 +1,65 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2025, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ +#ifndef MOD_PINCTRL_DRV_EXTRA_H +#define MOD_PINCTRL_DRV_EXTRA_H + +#include "mod_pinctrl_drv.h" + +#include + +/*! + * \brief Get pin function. + * + * \param[in] pin_id pin identifier. + * \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 group. + * \retval ::FWK_E_PARAM function_id is not supported by the pin. is + * not allowed for this pin_id. + */ +int get_pin_function(uint16_t pin_id, uint32_t *function_id); + +/*! + * \brief set pin function. + * + * \param[in] pin_id pin identifier. + * \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 group. + * \retval ::FWK_E_PARAM function_id is not supported by the pin. is + * not allowed for this pin_id. + */ +int set_pin_function(uint16_t pin_id, uint32_t function_id); +/*! + * \brief set 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: 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 set_pin_configuration( + uint16_t pin_id, + const struct mod_pinctrl_drv_pin_configuration *pin_config); + +/*! + * \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: 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_pin_configuration( + uint16_t pin_id, + struct mod_pinctrl_drv_pin_configuration *pin_config); + +#endif diff --git a/module/pinctrl/test/mod_pinctrl_unit_test.c b/module/pinctrl/test/mod_pinctrl_unit_test.c new file mode 100644 index 0000000000000000000000000000000000000000..04ac99cb8cf65c68baccde21d31d24e991fe4c72 --- /dev/null +++ b/module/pinctrl/test/mod_pinctrl_unit_test.c @@ -0,0 +1,869 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2025, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "config_pinctrl.h" +#include "fwk_module_idx.h" +#include "mod_pinctrl.h" +#include "scp_unity.h" +#include "unity.h" + +#include + +#include UNIT_TEST_SRC + +struct mod_pinctrl_drv_api pinctrl_driver_api[] = { + { + .set_pin_function = set_pin_function, + .set_pin_configuration = set_pin_configuration, + .get_pin_configuration = get_pin_configuration, + .get_pin_function = get_pin_function, + }, +}; + +struct mod_pinctrl_domain_config drv_domain_config[] = { + { + .driver_id = pinctrl_drv_id, + .driver_api_id = pinctrl_drv_api_id, + .pin_base_id = PIN_0_IDX, + .pin_range = PIN_COUNT, + }, +}; + +struct mod_pinctrl_domain_ctx pinctrl_drv_domain[] = { + { + .drv_domain_config = drv_domain_config, + .pinctrl_driver_api = pinctrl_driver_api, + }, +}; + +void setUp(void) +{ + pinctrl_ctx.config = &config; + pinctrl_ctx.pinctrl_drv_domain_count = FWK_ARRAY_SIZE(drv_domain_config); + pinctrl_ctx.pinctrl_drv_domain_ctx = pinctrl_drv_domain; +} +void tearDown(void) +{ +} + +void utest_pinctrl_get_group_attributes(void) +{ + int status = FWK_SUCCESS; + + uint16_t identifier = I2C_GROUP_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + struct mod_pinctrl_attributes pinctrl_attributes; + + status = get_attributes(identifier, flags, &pinctrl_attributes); + + TEST_ASSERT_EQUAL_STRING(groups[identifier].name, pinctrl_attributes.name); + TEST_ASSERT_EQUAL( + FWK_ARRAY_SIZE(grp_i2c_pin_idx), pinctrl_attributes.number_of_elements); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_pinctrl_get_function_attributes(void) +{ + int status = FWK_SUCCESS; + uint16_t identifier = UART_FUNC_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_FUNCTION; + struct mod_pinctrl_attributes pinctrl_attributes; + const uint16_t expected_number_of_groups = 2; + + status = get_attributes(identifier, flags, &pinctrl_attributes); + + TEST_ASSERT_EQUAL_STRING( + functions[identifier].name, pinctrl_attributes.name); + TEST_ASSERT_EQUAL( + expected_number_of_groups, pinctrl_attributes.number_of_elements); + TEST_ASSERT_EQUAL(false, pinctrl_attributes.is_gpio_function); + TEST_ASSERT_EQUAL(false, pinctrl_attributes.is_pin_only_function); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_pinctrl_get_pin_only_fucntion_attributes(void) +{ + int status = FWK_SUCCESS; + uint16_t identifier = GPIO_FUNC_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_FUNCTION; + struct mod_pinctrl_attributes pinctrl_attributes; + uint16_t expected_number_of_pins = 5; + + status = get_attributes(identifier, flags, &pinctrl_attributes); + + TEST_ASSERT_EQUAL_STRING( + functions[identifier].name, pinctrl_attributes.name); + TEST_ASSERT_EQUAL( + expected_number_of_pins, pinctrl_attributes.number_of_elements); + TEST_ASSERT_EQUAL(false, pinctrl_attributes.is_gpio_function); + TEST_ASSERT_EQUAL(true, pinctrl_attributes.is_pin_only_function); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_pinctrl_get_pin_attributes(void) +{ + int status = FWK_SUCCESS; + uint16_t identifier = PIN_3_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_PIN; + struct mod_pinctrl_attributes pinctrl_attributes; + const uint16_t expected_number_of_pins = 1; + char *expected_pin_name = "PIN_3"; + + status = get_attributes(identifier, flags, &pinctrl_attributes); + + TEST_ASSERT_EQUAL_STRING(expected_pin_name, pinctrl_attributes.name); + TEST_ASSERT_EQUAL( + expected_number_of_pins, pinctrl_attributes.number_of_elements); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_pinctrl_get_attribute_invalid_flags(void) +{ + int status = FWK_SUCCESS; + + uint16_t identifier = I2C_GROUP_IDX; + enum mod_pinctrl_selector flags = 3; + struct mod_pinctrl_attributes pinctrl_attributes; + + status = get_attributes(identifier, flags, &pinctrl_attributes); + + TEST_ASSERT_EQUAL(FWK_E_RANGE, status); +} + +void utest_pinctrl_get_attribute_invalid_group_id(void) +{ + int status = FWK_SUCCESS; + + uint16_t identifier = GROUP_COUNT; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + struct mod_pinctrl_attributes pinctrl_attributes; + + status = get_attributes(identifier, flags, &pinctrl_attributes); + + TEST_ASSERT_EQUAL(FWK_E_RANGE, status); +} + +void utest_pinctrl_get_attribute_invalid_function_id(void) +{ + int status = FWK_SUCCESS; + + uint16_t identifier = FUNC_COUNT; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_FUNCTION; + struct mod_pinctrl_attributes pinctrl_attributes; + + status = get_attributes(identifier, flags, &pinctrl_attributes); + + TEST_ASSERT_EQUAL(FWK_E_RANGE, status); +} + +void utest_pinctrl_get_attribute_invalid_pin_id(void) +{ + int status = FWK_SUCCESS; + uint16_t identifier = PIN_COUNT; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_PIN; + struct mod_pinctrl_attributes pinctrl_attributes; + + status = get_attributes(identifier, flags, &pinctrl_attributes); + + TEST_ASSERT_EQUAL(FWK_E_RANGE, status); +} + +void utest_get_info(void) +{ + int status = FWK_SUCCESS; + struct mod_pinctrl_info info; + + status = get_info(&info); + + TEST_ASSERT_EQUAL(PIN_COUNT, info.number_of_pins); + TEST_ASSERT_EQUAL(GROUP_COUNT, info.number_of_groups); + TEST_ASSERT_EQUAL(FUNC_COUNT, info.number_of_functions); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_list_pins_associated_with_group(void) +{ + int status = FWK_SUCCESS; + uint16_t pin_id; + + uint16_t group_index = SPI_GROUP_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + uint16_t index = 1; + + status = get_list_associations(group_index, flags, index, &pin_id); + + TEST_ASSERT_EQUAL(PIN_3_IDX, pin_id); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_list_pins_associated_with_group_out_of_range_indx(void) +{ + int status = FWK_SUCCESS; + uint16_t pin_id; + + uint16_t group_index = SPI_GROUP_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + /* Try pin index out of range while the SPI group have only 3 pins */ + uint16_t index = 3; + + status = get_list_associations(group_index, flags, index, &pin_id); + + TEST_ASSERT_EQUAL(FWK_E_RANGE, status); +} + +void utest_list_groups_associated_with_function(void) +{ + int status = FWK_SUCCESS; + uint16_t group_id; + + uint16_t function_index = SPI_FUNC_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_FUNCTION; + uint16_t index = 0; + + status = get_list_associations(function_index, flags, index, &group_id); + + TEST_ASSERT_EQUAL(SPI_GROUP_IDX, group_id); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_list_multiple_groups_associated_with_the_same_function(void) +{ + int status = FWK_SUCCESS; + /* array to contain the group_id's got from asking to list all groups + * associated with certain functionality which is 2 in out configuration */ + uint16_t group_id[2]; + + uint16_t function_index = UART_FUNC_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_FUNCTION; + uint16_t index = 0; + + uint16_t group_counts = 0; + status = + get_total_number_of_associations(function_index, flags, &group_counts); + + for (index = 0; index < group_counts; ++index) { + status = get_list_associations( + function_index, flags, index, &group_id[index]); + } + + TEST_ASSERT_EQUAL(UART_GROUP_IDX, group_id[0]); + TEST_ASSERT_EQUAL(UART_1_GROUP_IDX, group_id[1]); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_list_groups_associated_with_function_out_of_range_indx(void) +{ + int status = FWK_SUCCESS; + uint16_t group_id; + + uint16_t function_index = SPI_FUNC_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_FUNCTION; + /* Try index value out of range where we have only one group has SPI func */ + uint16_t index = 1; + + status = get_list_associations(function_index, flags, index, &group_id); + + TEST_ASSERT_EQUAL(FWK_E_RANGE, status); +} + +void utest_list_pins_associated_with_function(void) +{ + int status = FWK_SUCCESS; + uint16_t pin_id; + + uint16_t function_idx = GPIO_FUNC_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_FUNCTION; + /* Try index value in range where GPIO func has 5 pins */ + uint16_t index = 2; + + status = get_list_associations(function_idx, flags, index, &pin_id); + + TEST_ASSERT_EQUAL(PIN_2_IDX, pin_id); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_list_pins_associated_with_function_invalid_index(void) +{ + int status = FWK_SUCCESS; + uint16_t pin_id = PIN_3_IDX; + + uint16_t function_idx = GPIO_FUNC_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_FUNCTION; + /* Try out of range index where the GPIO func is only 5 pins */ + uint16_t index = 5; + + status = get_list_associations(function_idx, flags, index, &pin_id); + + TEST_ASSERT_EQUAL(PIN_3_IDX, pin_id); + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void utest_get_total_number_of_pins_associated_with_group(void) +{ + int status; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + uint16_t group_index = I2C_GROUP_IDX; + uint16_t expected_total_pins; + + status = get_total_number_of_associations( + group_index, flags, &expected_total_pins); + + TEST_ASSERT_EQUAL(FWK_ARRAY_SIZE(grp_i2c_pin_idx), expected_total_pins); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_get_total_number_of_groups_associated_with_function(void) +{ + int status; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_FUNCTION; + uint16_t function_idx = UART_FUNC_IDX; + uint16_t expected_total_count; + + status = get_total_number_of_associations( + function_idx, flags, &expected_total_count); + + /* Expected total number of groups associated with the UART_FUNC to be 2*/ + TEST_ASSERT_EQUAL(2, expected_total_count); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_get_total_number_of_pins_associated_with_function(void) +{ + int status; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_FUNCTION; + uint16_t function_idx = GPIO_FUNC_IDX; + uint16_t total_count; + + status = + get_total_number_of_associations(function_idx, flags, &total_count); + + TEST_ASSERT_EQUAL(PIN_WITH_GPIO_FUNC, total_count); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_get_pin_configuration_value_from_type(void) +{ + int status; + uint16_t pin_idx = PIN_6_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_PIN; + struct mod_pinctrl_drv_pin_configuration pin_config = { + .config_type = DRIVE_OPEN_SOURCE, + .config_value = DRIVE_OPEN_SOURCE_VALUE, + }; + + get_pin_configuration_ExpectAndReturn(PIN_6_IDX, &pin_config, FWK_SUCCESS); + get_pin_configuration_IgnoreArg_pin_config(); + get_pin_configuration_ReturnThruPtr_pin_config(&pin_config); + + status = get_configuration_value_from_type( + pin_idx, flags, pin_config.config_type, &pin_config.config_value); + + TEST_ASSERT_EQUAL(DRIVE_OPEN_SOURCE_VALUE, pin_config.config_value); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_get_group_configuration_value_from_type(void) +{ + int status; + uint16_t group_idx = GPIO_GROUP_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + + struct mod_pinctrl_drv_pin_configuration config = { + .config_type = LOW_POWER_MODE, + .config_value = LOW_POWER_MODE_VALUE, + }; + + get_pin_configuration_ExpectAndReturn(PIN_0_IDX, &config, FWK_SUCCESS); + get_pin_configuration_IgnoreArg_pin_config(); + get_pin_configuration_ReturnThruPtr_pin_config(&config); + + status = get_configuration_value_from_type( + group_idx, flags, config.config_type, &config.config_value); + + TEST_ASSERT_EQUAL(LOW_POWER_MODE_VALUE, config.config_value); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_get_configuration_value_from_type_invalid_flag(void) +{ + int status; + uint16_t group_idx = I2C_GROUP_IDX; + enum mod_pinctrl_selector flags = 3; + enum mod_pinctrl_drv_configuration_type config_type = INPUT_DEBOUNCE; + uint32_t config_value; + + status = get_configuration_value_from_type( + group_idx, flags, config_type, &config_value); + + TEST_ASSERT_EQUAL(FWK_E_RANGE, status); +} + +void utest_get_configuration_value_from_type_invalid_group_id(void) +{ + int status; + uint16_t group_idx = GROUP_COUNT; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + enum mod_pinctrl_drv_configuration_type config_type = INPUT_DEBOUNCE; + uint32_t config_value; + + status = get_configuration_value_from_type( + group_idx, flags, config_type, &config_value); + + TEST_ASSERT_EQUAL(FWK_E_RANGE, status); +} + +void utest_get_configuration_value_from_type_invalid_group_type(void) +{ + int status; + uint16_t group_idx = I2C_GROUP_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + enum mod_pinctrl_drv_configuration_type config_type = INPUT_DEBOUNCE; + uint32_t config_value; + + status = get_configuration_value_from_type( + group_idx, flags, config_type, &config_value); + + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void utest_get_group_configurations(void) +{ + int status; + + uint16_t group_idx = GPIO_GROUP_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + uint16_t configration_index = 1; + struct mod_pinctrl_drv_pin_configuration config = { + .config_type = LOW_POWER_MODE, + .config_value = LOW_POWER_MODE_VALUE, + }; + + get_pin_configuration_ExpectAndReturn(PIN_0_IDX, &config, FWK_SUCCESS); + get_pin_configuration_IgnoreArg_pin_config(); + get_pin_configuration_ReturnThruPtr_pin_config(&config); + + status = get_configuration(group_idx, flags, configration_index, &config); + + TEST_ASSERT_EQUAL(LOW_POWER_MODE, config.config_type); + TEST_ASSERT_EQUAL(LOW_POWER_MODE_VALUE, config.config_value); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_get_pin_configurations(void) +{ + int status; + + uint16_t pin_idx = PIN_4_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_PIN; + uint16_t configration_index = 0; + struct mod_pinctrl_drv_pin_configuration config = { + .config_type = DRIVE_OPEN_SOURCE, + .config_value = DRIVE_OPEN_SOURCE_VALUE, + }; + + get_pin_configuration_ExpectAndReturn(PIN_4_IDX, &config, FWK_SUCCESS); + get_pin_configuration_IgnoreArg_pin_config(); + get_pin_configuration_ReturnThruPtr_pin_config(&config); + + status = get_configuration(pin_idx, flags, configration_index, &config); + + TEST_ASSERT_EQUAL(DRIVE_OPEN_SOURCE, config.config_type); + TEST_ASSERT_EQUAL(DRIVE_OPEN_SOURCE_VALUE, config.config_value); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_get_configurations_invalid_flags(void) +{ + int status; + + uint16_t pin_idx = PIN_4_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_FUNCTION; + uint16_t configration_index = 4; + + struct mod_pinctrl_drv_pin_configuration config; + + status = get_configuration(pin_idx, flags, configration_index, &config); + + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void utest_get_total_number_of_group_configurations(void) +{ + int status; + + uint16_t group_idx = I2C_GROUP_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + uint16_t number_of_configurations; + uint16_t expected_number_of_configurations = 3; + + status = get_total_number_of_configurations( + group_idx, flags, &number_of_configurations); + + TEST_ASSERT_EQUAL( + expected_number_of_configurations, number_of_configurations); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_get_total_number_of_configurations_invalid_group_id(void) +{ + int status; + + uint16_t group_idx = GROUP_COUNT; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + uint16_t number_of_configurations; + + status = get_total_number_of_configurations( + group_idx, flags, &number_of_configurations); + + TEST_ASSERT_EQUAL(FWK_E_RANGE, status); +} + +void utest_get_total_number_of_pin_configurations(void) +{ + int status; + + uint16_t pin_idx = PIN_2_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_PIN; + uint16_t number_of_configurations; + uint16_t expected_number_of_configurations = 3; + + status = get_total_number_of_configurations( + pin_idx, flags, &number_of_configurations); + + TEST_ASSERT_EQUAL( + expected_number_of_configurations, number_of_configurations); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_get_total_number_of_configurations_invalid_flags(void) +{ + int status; + + uint16_t pin_idx = PIN_2_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_FUNCTION; + uint16_t number_of_configurations; + + status = get_total_number_of_configurations( + pin_idx, flags, &number_of_configurations); + + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void utest_get_pin_associated_function(void) +{ + int status; + + uint16_t pin_index = PIN_0_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_PIN; + uint32_t function_id = UART_FUNC_IDX; + uint32_t expected_function_id = GPIO_FUNC_IDX; + + get_pin_function_ExpectAndReturn( + PIN_0_IDX, &expected_function_id, FWK_SUCCESS); + get_pin_function_IgnoreArg_function_id(); + get_pin_function_ReturnThruPtr_function_id(&expected_function_id); + + status = get_current_associated_function(pin_index, flags, &function_id); + + TEST_ASSERT_EQUAL(expected_function_id, function_id); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_get_group_associated_function(void) +{ + int status; + + uint16_t group_index = SPI_GROUP_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + uint32_t function_id = SPI_FUNC_IDX; + uint32_t expected_function_id = I2C_FUNC_IDX; + + get_pin_function_ExpectAndReturn( + PIN_2_IDX, &expected_function_id, FWK_SUCCESS); + get_pin_function_IgnoreArg_function_id(); + get_pin_function_ReturnThruPtr_function_id(&expected_function_id); + + status = get_current_associated_function(group_index, flags, &function_id); + + TEST_ASSERT_EQUAL(expected_function_id, function_id); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_get_group_associated_function_invalid_flag(void) +{ + int status; + + uint16_t group_index = SPI_GROUP_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_FUNCTION; + uint32_t function_id; + + status = get_current_associated_function(group_index, flags, &function_id); + + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void utest_set_pin_configurations(void) +{ + int status; + + uint16_t pin_index = PIN_1_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_PIN; + const struct mod_pinctrl_drv_pin_configuration config = { + .config_type = LOW_POWER_MODE, + .config_value = 4, + }; + + set_pin_configuration_ExpectAndReturn(PIN_1_IDX, &config, FWK_SUCCESS); + + status = set_configuration(pin_index, flags, &config); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_set_group_configuration(void) +{ + int status; + + uint16_t group_id = I2C_GROUP_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + + const struct mod_pinctrl_drv_pin_configuration configs = { + .config_type = DRIVE_OPEN_SOURCE, + .config_value = 0, + }; + + set_pin_configuration_ExpectAndReturn(PIN_5_IDX, &configs, FWK_SUCCESS); + set_pin_configuration_ExpectAndReturn(PIN_6_IDX, &configs, FWK_SUCCESS); + + status = set_configuration(group_id, flags, &configs); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_set_group_configuration_group_id_invalid(void) +{ + int status; + + uint16_t group_id = GROUP_COUNT; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + + const struct mod_pinctrl_drv_pin_configuration configs = { + .config_type = BIAS_DISABLE, + .config_value = 1, + }; + + status = set_configuration(group_id, flags, &configs); + + TEST_ASSERT_EQUAL(FWK_E_RANGE, status); +} + +void utest_set_group_configuration_invalid_flag(void) +{ + int status; + + uint16_t group_id = I2C_GROUP_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_FUNCTION; + + const struct mod_pinctrl_drv_pin_configuration configs = { + .config_type = BIAS_BUS_HOLD, + .config_value = 1, + }; + + status = set_configuration(group_id, flags, &configs); + + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void utest_set_pin_read_only_configuration(void) +{ + int status; + + uint16_t pin_index = PIN_1_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_PIN; + const struct mod_pinctrl_drv_pin_configuration config = { + .config_type = INPUT_VALUE, + .config_value = DISABLE_VALUE, + }; + + status = set_configuration(pin_index, flags, &config); + + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void utest_set_group_read_only_configuration(void) +{ + int status; + + uint16_t group_id = I2C_GROUP_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + + const struct mod_pinctrl_drv_pin_configuration configs = { + .config_type = INPUT_VALUE, + .config_value = ENABLE_VALUE, + }; + + status = set_configuration(group_id, flags, &configs); + + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void utest_set_pin_function(void) +{ + int status; + + uint16_t pin_index = PIN_1_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_PIN; + uint16_t function_id = GPIO_FUNC_IDX; + + set_pin_function_ExpectAndReturn(PIN_1_IDX, GPIO_FUNC_IDX, FWK_SUCCESS); + + status = set_function(pin_index, flags, function_id); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_set_pin_function_is_not_pin_only_function(void) +{ + int status; + + uint16_t pin_index = PIN_1_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_PIN; + uint16_t function_id = I2C_FUNC_IDX; + + status = set_function(pin_index, flags, function_id); + + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void utest_set_group_function(void) +{ + int status; + + uint16_t group_index = I2C_GROUP_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + uint16_t function_id = I2C_FUNC_IDX; + + set_pin_function_ExpectAndReturn(PIN_5_IDX, function_id, FWK_SUCCESS); + set_pin_function_ExpectAndReturn(PIN_6_IDX, function_id, FWK_SUCCESS); + + status = set_function(group_index, flags, function_id); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void utest_set_group_function_pin_only_function_id(void) +{ + int status; + + uint16_t group_index = I2C_GROUP_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + uint16_t function_id = GPIO_FUNC_IDX; + + status = set_function(group_index, flags, function_id); + + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void utest_set_group_function_group_out_of_range(void) +{ + int status; + + uint16_t group_index = GROUP_COUNT; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_GROUP; + uint16_t function_id = I2C_FUNC_IDX; + + status = set_function(group_index, flags, function_id); + + TEST_ASSERT_EQUAL(FWK_E_RANGE, status); +} + +void utest_set_pin_function_with_not_allowed_function(void) +{ + int status; + + uint16_t pin_index = PIN_5_IDX; + enum mod_pinctrl_selector flags = MOD_PINCTRL_SELECTOR_PIN; + uint16_t function_id = GPIO_FUNC_IDX; + + status = set_function(pin_index, flags, function_id); + + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +int pinctrl_test_main(void) +{ + UNITY_BEGIN(); + + RUN_TEST(utest_pinctrl_get_group_attributes); + RUN_TEST(utest_pinctrl_get_function_attributes); + RUN_TEST(utest_pinctrl_get_pin_only_fucntion_attributes); + RUN_TEST(utest_pinctrl_get_pin_attributes); + RUN_TEST(utest_pinctrl_get_attribute_invalid_flags); + RUN_TEST(utest_pinctrl_get_attribute_invalid_group_id); + RUN_TEST(utest_pinctrl_get_attribute_invalid_function_id); + RUN_TEST(utest_pinctrl_get_attribute_invalid_pin_id); + + RUN_TEST(utest_get_info); + + RUN_TEST(utest_list_pins_associated_with_group); + RUN_TEST(utest_list_pins_associated_with_group_out_of_range_indx); + RUN_TEST(utest_list_groups_associated_with_function); + RUN_TEST(utest_list_multiple_groups_associated_with_the_same_function); + RUN_TEST(utest_list_groups_associated_with_function_out_of_range_indx); + RUN_TEST(utest_list_pins_associated_with_function); + RUN_TEST(utest_list_pins_associated_with_function_invalid_index); + + RUN_TEST(utest_get_total_number_of_pins_associated_with_group); + RUN_TEST(utest_get_total_number_of_groups_associated_with_function); + RUN_TEST(utest_get_total_number_of_pins_associated_with_function); + + RUN_TEST(utest_get_pin_configuration_value_from_type); + RUN_TEST(utest_get_group_configuration_value_from_type); + RUN_TEST(utest_get_configuration_value_from_type_invalid_flag); + RUN_TEST(utest_get_configuration_value_from_type_invalid_group_id); + RUN_TEST(utest_get_configuration_value_from_type_invalid_group_type); + + RUN_TEST(utest_get_group_configurations); + RUN_TEST(utest_get_pin_configurations); + RUN_TEST(utest_get_configurations_invalid_flags); + + RUN_TEST(utest_get_total_number_of_group_configurations); + RUN_TEST(utest_get_total_number_of_configurations_invalid_group_id); + RUN_TEST(utest_get_total_number_of_pin_configurations); + RUN_TEST(utest_get_total_number_of_configurations_invalid_flags); + + RUN_TEST(utest_get_pin_associated_function); + RUN_TEST(utest_get_group_associated_function); + RUN_TEST(utest_get_group_associated_function_invalid_flag); + + RUN_TEST(utest_set_pin_configurations); + RUN_TEST(utest_set_group_configuration); + RUN_TEST(utest_set_group_configuration_group_id_invalid); + RUN_TEST(utest_set_group_configuration_invalid_flag); + RUN_TEST(utest_set_pin_read_only_configuration); + RUN_TEST(utest_set_group_read_only_configuration); + + RUN_TEST(utest_set_pin_function); + RUN_TEST(utest_set_pin_function_is_not_pin_only_function); + RUN_TEST(utest_set_group_function); + RUN_TEST(utest_set_group_function_pin_only_function_id); + RUN_TEST(utest_set_group_function_group_out_of_range); + RUN_TEST(utest_set_pin_function_with_not_allowed_function); + + return UNITY_END(); +} + +#if !defined(TEST_ON_TARGET) +int main(void) +{ + return pinctrl_test_main(); +} +#endif diff --git a/unit_test/CMakeLists.txt b/unit_test/CMakeLists.txt index 99cb3b4cba8546ee89e3b8beaf1040c055546ca0..04208a2c8f9ffb197a38b1f3f24a18d35280e869 100644 --- a/unit_test/CMakeLists.txt +++ b/unit_test/CMakeLists.txt @@ -1,6 +1,6 @@ # # Arm SCP/MCP Software -# Copyright (c) 2022-2024, Arm Limited and Contributors. All rights reserved. +# Copyright (c) 2022-2025, Arm Limited and Contributors. All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause # @@ -122,6 +122,7 @@ list(APPEND UNIT_MODULE power_capping) list(APPEND UNIT_MODULE mpmm_v2) list(APPEND UNIT_MODULE perf_controller) list(APPEND UNIT_MODULE pid_controller) +list(APPEND UNIT_MODULE pinctrl) list(APPEND UNIT_MODULE pl011) list(APPEND UNIT_MODULE power_distributor) list(APPEND UNIT_MODULE power_domain)