From c0d18d88153e12c01e9eb6c49f9b4b8b3faa0bc4 Mon Sep 17 00:00:00 2001 From: Ellie Lewis Date: Wed, 17 Jul 2024 14:48:46 +0100 Subject: [PATCH 1/4] module/ccsm: Add CCSM driver module Implements driver for Clock Control State Machine hardware. Adds Clock API implementation and internal driver functions for configuring DVFS, droop mitigation, and overcurrent/modulator features. Signed-off-by: Ellie Lewis --- module/CMakeLists.txt | 1 + module/ccsm/CMakeLists.txt | 20 + module/ccsm/Module.cmake | 9 + module/ccsm/include/mod_ccsm.h | 213 ++++++++ module/ccsm/src/ccsm_drv.c | 234 +++++++++ module/ccsm/src/ccsm_drv.h | 497 +++++++++++++++++++ module/ccsm/src/mod_ccsm.c | 874 +++++++++++++++++++++++++++++++++ 7 files changed, 1848 insertions(+) create mode 100644 module/ccsm/CMakeLists.txt create mode 100644 module/ccsm/Module.cmake create mode 100644 module/ccsm/include/mod_ccsm.h create mode 100644 module/ccsm/src/ccsm_drv.c create mode 100644 module/ccsm/src/ccsm_drv.h create mode 100644 module/ccsm/src/mod_ccsm.c diff --git a/module/CMakeLists.txt b/module/CMakeLists.txt index b46580d3d..988b58c28 100644 --- a/module/CMakeLists.txt +++ b/module/CMakeLists.txt @@ -24,6 +24,7 @@ list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/armv7m_mpu") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/armv8m_mpu") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/armv8r_mpu") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/bootloader") +list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/ccsm") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/clock") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/cmn600") list(APPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_SOURCE_DIR}/cmn_cyprus") diff --git a/module/ccsm/CMakeLists.txt b/module/ccsm/CMakeLists.txt new file mode 100644 index 000000000..644f9f628 --- /dev/null +++ b/module/ccsm/CMakeLists.txt @@ -0,0 +1,20 @@ +# +# Arm SCP/MCP Software +# Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +# + +add_library(${SCP_MODULE_TARGET} SCP_MODULE) + +target_include_directories(${SCP_MODULE_TARGET} + PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include") + +target_sources( + ${SCP_MODULE_TARGET} + PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src/mod_ccsm.c" + "${CMAKE_CURRENT_SOURCE_DIR}/src/ccsm_drv.c") + +target_link_libraries(${SCP_MODULE_TARGET} PRIVATE module-power-domain + module-clock + module-timer) diff --git a/module/ccsm/Module.cmake b/module/ccsm/Module.cmake new file mode 100644 index 000000000..802d009c1 --- /dev/null +++ b/module/ccsm/Module.cmake @@ -0,0 +1,9 @@ +# +# Arm SCP/MCP Software +# Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +# + +set(SCP_MODULE "ccsm") +set(SCP_MODULE_TARGET "module-ccsm") diff --git a/module/ccsm/include/mod_ccsm.h b/module/ccsm/include/mod_ccsm.h new file mode 100644 index 000000000..ca6abfd47 --- /dev/null +++ b/module/ccsm/include/mod_ccsm.h @@ -0,0 +1,213 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef MOD_CCSM_H +#define MOD_CCSM_H + +#include + +#include +#include +#include + +#include +#include + +/*! + * \ingroup GroupModules Modules + * \defgroup GroupSystemCCSM Module + * + * \details A driver for Clock Control State Machines. + * + * \{ + */ + +/*! Indexes of APIs that the module offers for binding. */ +enum mod_ccsm_api_types { + /*! Implementation of Clock API. */ + MOD_CCSM_CLOCK_API, + /*! Number of APIs available for binding. */ + MOD_CCSM_API_COUNT, +}; + +/*! Rate lookup table clock rates entry. */ +struct mod_ccsm_clock_rate { + /*! Rate of nominal clock in Hertz. */ + uint64_t nominal_clock_rate_hz; + + /* Rate of fallback clock in Hertz. */ + uint64_t fallback_clock_rate_hz; +}; + +/*! Rate register values lookup table entry. */ +struct mod_ccsm_clock_rate_reg_value { + /*! Rate of clock in Hertz. */ + uint64_t clock_rate_hz; + + /*! Value for PLL settings 0 register for rate. */ + uint32_t pll_settings_0; + + /*! Value for PLL settings 1 register for rate. */ + uint32_t pll_settings_1; +}; + +/*! Configuration values for droop mitigation strategy. */ +enum mod_ccsm_dm_strategy { + /*! Stop output clock on droop. */ + MOD_CCSM_DM_STOP_CLK = 0, + /*! Switch output from nominal to fallback clock on droop. */ + MOD_CCSM_DM_SW_FB = 1 << 16, + /*! Do not mitigate droops, always output nominal clock. */ + MOD_CCSM_DM_NOM_ONLY = 1 << 17, + /*! Do not stop the output clock during DVFS sequence. */ + MOD_CCSM_DM_CLK_ON_DVFS = 1 << 20 +}; + +/*! Configuration values for droop detector in use. */ +enum mod_ccsm_dm_dd { + /*! Use Arm Droop Detector for TRIG_DROOP. */ + MOD_CCSM_DM_ARM_DD = 0, + /*! Use an alternate droop input for TRIG_DROOP. */ + MOD_CCSM_DM_TPIP = 1 << 28 +}; + +/*! Configuration values for TRIG_SOFF input. */ +enum mod_ccsm_dm_dd_soff { + /*! Ignore TRIG_SOFF input. */ + MOD_CCSM_DM_SW_SOFF_IGNORE = 0, + /*! Pause the output clock on 0->1 transition of TRIG_SOFF. */ + MOD_CCSM_DM_SW_SOFF_STOP = 1 << 24, +}; + +/*! Droop mitigation configuration options. */ +struct mod_ccsm_dm_config { + /*! Strategy for mitigating droop events. */ + enum mod_ccsm_dm_strategy strategy; + + /*! Selector for droop detector in use. */ + enum mod_ccsm_dm_dd dd; + + /*! Configuration of TRIG_SOFF input handling. */ + enum mod_ccsm_dm_dd_soff soff; + + /*! Number of clock cycles to pause during nominal-fallback transition. */ + uint8_t transition_pause; + + /*! Minimum duration (number of clock cycles) of droop mitigation. */ + uint16_t mitigation_duration; +}; + +/*! Modulator configuration options. */ +struct mod_ccsm_mod_config { + /*! Value of the numerator on PMIC_OC warning. */ + uint8_t numerator_oc; + + /*! Value of the numerator in regular operation. */ + uint8_t numerator_regular; + + /*! Value of the denominator. */ + uint8_t denominator; +}; + +/*! PLL device configuration. */ +struct mod_ccsm_dev_config { + /*! Selects if a rate lookup table should be used (indexed clock). */ + bool rate_lookup_table_is_provided; + + /*! The minimum rate at which to enable the fallback clock. */ + uint64_t minimum_clock_rate_fallback_enable_hz; + + /*! Maximum percentage of nominal rate to set fallback clock to. */ + uint8_t fallback_clock_percentage; + + /*! + * \brief The slowest clock rate either PLL can be set to. + * + * \details This will represent the minimum clock rate in operation, and + * may differ from the hardware-imposed limit. + */ + uint64_t min_clock_rate_hz; + + /*! + * \brief The fastest rate either PLL can be set to. + * + * \details This will represent the maximum clock rate in operation, and + * may differ from the hardware-imposed limit. + */ + uint64_t max_clock_rate_hz; + + /*! + * \brief The minimum step size between clock rates when setting the PLL. + * + * \details This represents the precision that can be used when setting + * the PLL rates. Rates should be a multiple of this value. Step sizes + * may be greater than the hardware-imposed limit. + */ + uint64_t clock_rate_step_hz; + + /*! Base address of the CCSM device registers. */ + uintptr_t base_address; + + /*! + * \brief The static register value to set for PLL0. + * + * \details This value will be set during initialisation of the CCSM, and + * should not be changed during operation. + */ + uint32_t pll_0_static_reg_value; + + /*! + * \brief The static register value to set for PLL1. + * + * \details This value will be set during initialisation of the CCSM, and + * should not be changed during operation. + */ + uint32_t pll_1_static_reg_value; + + /*! The initial droop mitigation configuration. */ + const struct mod_ccsm_dm_config *droop_mitigation_default; + + /*! The initial modulator configuration. */ + const struct mod_ccsm_mod_config *modulator_default; + + /*! The number of modulators implemented in the CCSM instance. */ + uint8_t modulator_count; + + /*! The default clock rates for the CCSM PLLs. */ + const struct mod_ccsm_clock_rate *default_rates_table; + + /*! + * \brief Pointer to the clock rate lookup table for indexed clocks. + * + * \details Required for indexed clocks. Contains each pair of nominal and + * fallback clock rates the PLLs may be set to for a DVFS state. Rates + * must be ordered by nominal clock rate, from lowest to highest. + */ + struct mod_ccsm_clock_rate const *rate_table; + + /*! The number of rates in the rate lookup table. */ + uint32_t rate_count; + + /*! + * \brief Pointer to rate-register value lookup table. + * + * \details Contains entries with clock rates and corresponding register + * configuration values. For continuous clocks, an entry should be + * present for each clock rate step between the minimum and maximum + * clock rates. Rates must be ordered by nominal clock rate, from + * lowest to highest. + */ + struct mod_ccsm_clock_rate_reg_value const *register_rate_table; + + /*! Number of register-rate values in the lookup table. */ + uint32_t register_rate_count; + + /*! Element identifier for the timer device. */ + fwk_id_t timer_id; +}; + +#endif /* MOD_CCSM_H */ diff --git a/module/ccsm/src/ccsm_drv.c b/module/ccsm/src/ccsm_drv.c new file mode 100644 index 000000000..e2a0b7983 --- /dev/null +++ b/module/ccsm/src/ccsm_drv.c @@ -0,0 +1,234 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "ccsm_drv.h" + +#include +#include +#include +#include +#include + +#include +#include + +/* + * CCSM driver functions + */ +int ccsm_drv_get_pll_static_settings( + struct ccsm_reg *reg, + enum mod_ccsm_pll_static_select pll_select, + uint32_t *config) +{ + if (pll_select == MOD_CCSM_PLL_0) { + *config = reg->PLL_0_STATIC; + } else if (pll_select == MOD_CCSM_PLL_1) { + *config = reg->PLL_1_STATIC; + } else { + return FWK_E_PARAM; + } + + return FWK_SUCCESS; +} + +int ccsm_drv_get_pll_dynamic_settings( + struct ccsm_reg *reg, + enum mod_ccsm_pll_dynamic_select pll_select, + uint32_t *config0, + uint32_t *config1) +{ + if (pll_select == MOD_CCSM_PLL_NOMINAL) { + *config0 = reg->PLL_NOMINAL_SETTINGS_0; + *config1 = reg->PLL_NOMINAL_SETTINGS_1; + } else if (pll_select == MOD_CCSM_PLL_FALLBACK) { + *config0 = reg->PLL_FALLBACK_SETTINGS_0; + *config1 = reg->PLL_FALLBACK_SETTINGS_1; + } else { + return FWK_E_PARAM; + } + + return FWK_SUCCESS; +} + +int ccsm_drv_set_pll_static_settings( + struct ccsm_reg *reg, + enum mod_ccsm_pll_static_select pll_select, + uint32_t config) +{ + if (pll_select == MOD_CCSM_PLL_0) { + reg->PLL_0_STATIC = config; + } else if (pll_select == MOD_CCSM_PLL_1) { + reg->PLL_1_STATIC = config; + } else { + return FWK_E_PARAM; + } + + return FWK_SUCCESS; +} + +int ccsm_drv_set_pll_dynamic_settings( + struct ccsm_reg *reg, + enum mod_ccsm_pll_dynamic_select pll_select, + uint32_t config0, + uint32_t config1) +{ + if (pll_select == MOD_CCSM_PLL_NOMINAL) { + reg->PLL_NOMINAL_SETTINGS_0 = config0; + reg->PLL_NOMINAL_SETTINGS_1 = config1; + } else if (pll_select == MOD_CCSM_PLL_FALLBACK) { + reg->PLL_FALLBACK_SETTINGS_0 = config0; + reg->PLL_FALLBACK_SETTINGS_1 = config1; + } else { + return FWK_E_PARAM; + } + + return FWK_SUCCESS; +} + +int ccsm_drv_get_dm_configuration(struct ccsm_reg *reg, uint32_t *config) +{ + *config = reg->DROOP_MITIGATION_STRATEGY; + + return FWK_SUCCESS; +} + +int ccsm_drv_set_dm_configuration(struct ccsm_reg *reg, uint32_t config) +{ + reg->DROOP_MITIGATION_STRATEGY = config; + + return FWK_SUCCESS; +} + +int ccsm_drv_get_dm_telemetry( + struct ccsm_reg *reg, + uint32_t *telemetry1, + uint32_t *telemetry2, + uint32_t *telemetry3) +{ + *telemetry1 = reg->DROOP_MITIGATION_TELEMETRY1; + *telemetry2 = reg->DROOP_MITIGATION_TELEMETRY2; + *telemetry3 = reg->DROOP_MITIGATION_TELEMETRY3; + + return FWK_SUCCESS; +} + +int ccsm_drv_set_mod_configuration( + struct ccsm_reg *reg, + enum mod_ccsm_mod_select core_id, + uint32_t config) +{ + switch (core_id) { + case MOD_CCSM_MOD_CORE0: + reg->MODULATOR_SETTINGS_CORE0 = config; + break; + case MOD_CCSM_MOD_CORE1: + reg->MODULATOR_SETTINGS_CORE1 = config; + break; + case MOD_CCSM_MOD_CORE2: + reg->MODULATOR_SETTINGS_CORE2 = config; + break; + case MOD_CCSM_MOD_CORE3: + reg->MODULATOR_SETTINGS_CORE3 = config; + break; + default: + return FWK_E_PARAM; + } + + return FWK_SUCCESS; +} + +int ccsm_drv_get_mod_configuration( + struct ccsm_reg *reg, + enum mod_ccsm_mod_select core_id, + uint32_t *config) +{ + switch (core_id) { + case MOD_CCSM_MOD_CORE0: + *config = reg->INT_MODULATOR_SETTINGS_CORE0; + break; + case MOD_CCSM_MOD_CORE1: + *config = reg->INT_MODULATOR_SETTINGS_CORE1; + break; + case MOD_CCSM_MOD_CORE2: + *config = reg->INT_MODULATOR_SETTINGS_CORE2; + break; + case MOD_CCSM_MOD_CORE3: + *config = reg->INT_MODULATOR_SETTINGS_CORE3; + break; + default: + return FWK_E_PARAM; + } + + return FWK_SUCCESS; +} + +bool ccsm_drv_is_irq_error_clear(void *reg) +{ + return (((struct ccsm_reg *)reg)->IRQ_ERROR == 0); +} + +int ccsm_drv_get_clear_irq_error(struct ccsm_reg *reg, uint32_t *error) +{ + *error = reg->IRQ_ERROR; + + if (*error != 0) { + /* IRQ error is not already clear. */ + reg->IRQ_ERROR_CLEAR = *error; + } + + return FWK_SUCCESS; +} + +bool ccsm_drv_is_irq_status_clear(void *reg) +{ + return (((struct ccsm_reg *)reg)->IRQ_STATUS == 0); +} + +int ccsm_drv_get_clear_irq_status(struct ccsm_reg *reg, uint32_t *status) +{ + *status = reg->IRQ_STATUS; + + if (*status != 0) { + /* IRQ status is not already clear. */ + reg->IRQ_STATUS_CLEAR = *status; + } + + return FWK_SUCCESS; +} + +bool ccsm_drv_is_request_complete(void *reg) +{ + return ( + (((struct ccsm_reg *)reg)->REQUEST_STATUS & CCSM_REQUEST_STATUS_OG) == + 0); +} + +int ccsm_drv_set_request( + struct ccsm_reg *reg, + enum mod_ccsm_request_type req_type) +{ + if (reg->INT_REQUEST_TYPE != 0) { + return FWK_E_DEVICE; + } + + if ((reg->REQUEST_STATUS & CCSM_REQUEST_STATUS_OG) != 0) { + return FWK_E_BUSY; + } + + reg->REQUEST_TYPE = req_type; + reg->REQUEST_ENABLE = CCSM_REQUEST_ENABLE_SET; + + return FWK_SUCCESS; +} + +int ccsm_drv_clear_request(struct ccsm_reg *reg) +{ + reg->REQUEST_TYPE = CCSM_REQUEST_TYPE_CLR; + reg->REQUEST_ENABLE = CCSM_REQUEST_ENABLE_CLR; + + return FWK_SUCCESS; +} diff --git a/module/ccsm/src/ccsm_drv.h b/module/ccsm/src/ccsm_drv.h new file mode 100644 index 000000000..cfb194efb --- /dev/null +++ b/module/ccsm/src/ccsm_drv.h @@ -0,0 +1,497 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef CCSM_DRV_H +#define CCSM_DRV_H + +#include +#include +#include + +#include +#include + +/*! CCSM blocking timeout durations (microseconds). */ +#define MOD_CCSM_CLEAR_IRQ_TIMEOUT 100 +#define MOD_CCSM_COMMAND_WAIT_TIMEOUT 100 + +/*! CCSM Register Definitions */ +/* clang-format off */ +struct ccsm_reg { + FWK_RW uint32_t PLL_NOM_ARCH; /* 0x00 */ + FWK_RW uint32_t PLL_NOMINAL_SETTINGS_0; /* 0x04 */ + FWK_RW uint32_t PLL_NOMINAL_SETTINGS_1; /* 0x08 */ + uint32_t RESERVED1; + FWK_RW uint32_t PLL_FALLBACK_ARCH; /* 0x10 */ + FWK_RW uint32_t PLL_FALLBACK_SETTINGS_0; /* 0x14 */ + FWK_RW uint32_t PLL_FALLBACK_SETTINGS_1; /* 0x18 */ + uint32_t RESERVED2; + FWK_RW uint32_t PLL_0_STATIC; /* 0x20 */ + FWK_RW uint32_t PLL_1_STATIC; /* 0x24 */ + uint32_t RESERVED3[2]; + FWK_RW uint32_t RAM_EMA_CFG_rf_2p1r1rwddata; /* 0x30 */ + FWK_RW uint32_t RAM_EMA_CFG_rf_2p; /* 0x34 */ + FWK_RW uint32_t RAM_EMA_CFG_rf_sp; /* 0x38 */ + FWK_RW uint32_t RAM_EMA_CFG_sram_sp; /* 0x3C */ + FWK_RW uint32_t RAM_EMA_CFG_sram_2p; /* 0x40 */ + uint32_t RESERVED4[3]; + FWK_RW uint32_t PMIC_VOLTAGE_STABLE; /* 0x50 */ + uint32_t RESERVED5[3]; + FWK_RW uint32_t DROOP_MITIGATION_STRATEGY; /* 0x60 */ + uint32_t RESERVED6[3]; + FWK_RW uint32_t MODULATOR_SETTINGS_CORE0; /* 0x70 */ + FWK_RW uint32_t MODULATOR_SETTINGS_CORE1; /* 0x74 */ + FWK_RW uint32_t MODULATOR_SETTINGS_CORE2; /* 0x78 */ + FWK_RW uint32_t MODULATOR_SETTINGS_CORE3; /* 0x7C */ + uint32_t RESERVED7[4]; + FWK_RW uint32_t REQUEST_TYPE; /* 0x90 */ + uint32_t RESERVED8[3]; + FWK_W uint32_t REQUEST_ENABLE; /* 0xA0 */ + FWK_RW uint32_t IRQ_STATUS_MASK; /* 0xA4 */ + uint32_t RESERVED9[3]; + FWK_W uint32_t IRQ_STATUS_CLEAR; /* 0xB4 */ + FWK_W uint32_t IRQ_ERROR_CLEAR; /* 0xB8 */ + uint32_t RESERVED10[17]; + FWK_R uint32_t INT_PLL_NOM_ARCH; /* 0x100 */ + FWK_R uint32_t INT_PLL_NOMINAL_SETTINGS_0; /* 0x104 */ + FWK_R uint32_t INT_PLL_NOMINAL_SETTINGS_1; /* 0x108 */ + uint32_t RESERVED11; + FWK_R uint32_t INT_PLL_FALLBACK_ARCH; /* 0x110 */ + FWK_R uint32_t INT_PLL_FALLBACK_SETTINGS_0; /* 0x114 */ + FWK_R uint32_t INT_PLL_FALLBACK_SETTINGS_1; /* 0x118 */ + uint32_t RESERVED12; + FWK_R uint32_t INT_PLL_0_STATIC; /* 0x120 */ + FWK_R uint32_t INT_PLL_1_STATIC; /* 0x124 */ + uint32_t RESERVED13[2]; + FWK_R uint32_t INT_RAM_EMA_CFG_rf_2p1r1rwddata; /* 0x130 */ + FWK_R uint32_t INT_RAM_EMA_CFG_rf_2p; /* 0x134 */ + FWK_R uint32_t INT_RAM_EMA_CFG_rf_sp; /* 0x138 */ + FWK_R uint32_t INT_RAM_EMA_CFG_sram_sp; /* 0x13C */ + FWK_R uint32_t INT_RAM_EMA_CFG_sram_2p; /* 0x140 */ + uint32_t RESERVED14[3]; + FWK_R uint32_t INT_PMIC_VOLTAGE_STABLE; /* 0x150 */ + uint32_t RESERVED15[3]; + FWK_R uint32_t INT_DROOP_MITIGATION_STRATEGY; /* 0x160 */ + uint32_t RESERVED16[3]; + FWK_R uint32_t INT_MODULATOR_SETTINGS_CORE0; /* 0x170 */ + FWK_R uint32_t INT_MODULATOR_SETTINGS_CORE1; /* 0x174 */ + FWK_R uint32_t INT_MODULATOR_SETTINGS_CORE2; /* 0x178 */ + FWK_R uint32_t INT_MODULATOR_SETTINGS_CORE3; /* 0x17C */ + uint32_t RESERVED17[4]; + FWK_R uint32_t INT_REQUEST_TYPE; /* 0x190 */ + uint32_t RESERVED18[3]; + FWK_R uint32_t REQUEST_STATUS; /* 0x1A0 */ + FWK_R uint32_t IRQ_STATUS; /* 0x1A4 */ + FWK_R uint32_t IRQ_ERROR; /* 0x1A8 */ + uint32_t RESERVED19; + FWK_R uint32_t CONTROL_SM_STATE; /* 0x1B0 */ + FWK_R uint32_t DVFS_SM_STATE; /* 0x1B4 */ + FWK_R uint32_t DM_SM_STATE; /* 0x1B8 */ + FWK_R uint32_t OC_SM_STATE; /* 0x1BC */ + FWK_R uint32_t DROOP_MITIGATION_TELEMETRY1; /* 0x1C0 */ + FWK_R uint32_t DROOP_MITIGATION_TELEMETRY2; /* 0x1C4 */ + FWK_R uint32_t DROOP_MITIGATION_TELEMETRY3; /* 0x1C8 */ +}; +/* clang-format on */ + +/*! Static configuration PLL selection. */ +enum mod_ccsm_pll_static_select { MOD_CCSM_PLL_0, MOD_CCSM_PLL_1 }; + +/*! Dynamic configuration PLL selection. */ +enum mod_ccsm_pll_dynamic_select { + MOD_CCSM_PLL_NOMINAL, + MOD_CCSM_PLL_FALLBACK +}; + +/*! Modulator configuration selection. */ +enum mod_ccsm_mod_select { + MOD_CCSM_MOD_CORE0, + MOD_CCSM_MOD_CORE1, + MOD_CCSM_MOD_CORE2, + MOD_CCSM_MOD_CORE3, + MOD_CCSM_MOD_CORE_MAXCOUNT +}; + +/*! Values for request type register. */ +enum mod_ccsm_request_type { + /*! Clear any requests from the register. */ + CCSM_REQUEST_TYPE_CLR = 0, + /*! Request reconfiguration of DVFS state machine and registers. */ + CCSM_REQUEST_TYPE_SET_DVFS = 1 << 0, + /*! + * \brief Request first step of a DVFS GO_UP transition. + * + * \details Requests a DVFS transition to a higher voltage/frequency point. + * On successful completion a GO_UP2 request must be made. + */ + CCSM_REQUEST_TYPE_GO_UP = 1 << 1, + /*! + * \brief Request first step of a DVFS GO_DN transition. + * + * \details Requests a DVFS transition to a lower voltage/frequency point. + * On successful completion a GO_DN2 request must be made. + */ + CCSM_REQUEST_TYPE_GO_DN = 1 << 2, + /*! + * \brief Request second step of a DVFS GO_UP transition. + * + * \details Completes DVFS transition to a higher voltage/frequency point. + This request will also update droop mitigation configuration, if + changed. + */ + CCSM_REQUEST_TYPE_GO_UP2 = 1 << 3, + /*! + * \brief Request second step of a DVFS GO_DN transition. + * + * \details Completes DVFS transition to a lower voltage/frequency point. + This request will also update droop mitigation configuration, if + changed. + */ + CCSM_REQUEST_TYPE_GO_DN2 = 1 << 4, + /*! + * \brief Request reconfiguration of droop mitigation state machine. + */ + CCSM_REQUEST_TYPE_SET_DM = 1 << 8, + /*! + * \brief Put overcurrent state machine into idle state. + * + * \details Restores the overcurrent state machine to idle following a OC + PMIC warning. This will also clear the err_irq_oc register. + */ + CCSM_REQUEST_TYPE_CLR_MOD = 1 << 16, + /*! Request reconfiguration of modulator(s). */ + CCSM_REQUEST_TYPE_SET_MOD = 1 << 17, + /*! + * \brief Request telemetry information. + * + * \details Triggers a request to copy internal debug information to the + telemetry registers. This contains details on the types of droop + events that have occurrred since the last debug request. + */ + CCSM_REQUEST_TYPE_DBG = 1 << 24 +}; + +/*! Values for request enable register. */ +enum mod_ccsm_request_enable { + /*! Clear the register after a request. */ + CCSM_REQUEST_ENABLE_CLR = 0, + /*! Trigger the request enabled in the request type register. */ + CCSM_REQUEST_ENABLE_SET = 1 +}; + +/*! Values for request status register. */ +enum mod_ccsm_request_status { + /*! Ongoing bit. Set at beginning of task, cleared on completion. */ + CCSM_REQUEST_STATUS_OG = 1 +}; + +/*! Value offsets in droop mitigation register. */ +enum mod_ccsm_droop_mitigation_shift { + CCSM_DROOP_MITIGATION_STRATEGY_TRANSITION_PAUSE_POS = 0, + CCSM_DROOP_MITIGATION_STRATEGY_MITIGATION_DURATION_POS = 4 +}; + +/*! Value masks for droop mitigation register. */ +enum mod_ccsm_droop_mitigation_mask { + CCSM_DROOP_MITIGATION_STRATEGY_TRANSITION_PAUSE_MASK = 0x0F, + CCSM_DROOP_MITIGATION_STRATEGY_MITIGATION_DURATION_MASK = 0xFFF0 +}; + +/*! Value offsets in modulator registers. */ +enum mod_ccsm_modulator_shift { + CCSM_MODULATOR_SETTINGS_NUMERATOR_REGULAR_POS = 0, + CCSM_MODULATOR_SETTINGS_DENOMINATOR_POS = 8, + CCSM_MODULATOR_SETTINGS_NUMERATOR_PMIC_OC_POS = 16 +}; + +/*! Value masks for modulator registers. */ +enum mod_ccsm_modulator_mask { + CCSM_MODULATOR_SETTINGS_NUMERATOR_REGULAR_MASK = 0x0000FF, + CCSM_MODULATOR_SETTINGS_DENOMINATOR_MASK = 0x00FF00, + CCSM_MODULATOR_SETTINGS_NUMERATOR_PMIC_OC_MASK = 0xFF0000 +}; + +/*! Status values for control state machine. */ +enum mod_ccsm_control_sm_status_shift { + /*! Current state of the state machine. */ + CCSM_CONTROL_SM_CURRENT_STATE = 1 << 0, + /*! Previous state of the state machine. */ + CCSM_CONTROL_SM_PREV_STATE = 1 << 8, + /*! State before the previous state of the state machine. */ + CCSM_CONTROL_SM_BEFORE_PREV_STATE = 1 << 16, + /*! Lower bit of clksel_nom, selects PLL0 as output. */ + CCSM_CONTROL_SM_CLKSEL_NOM0 = 1 << 24, + /*! Upper bit of clksel_nom, selects PLL1 as output. */ + CCSM_CONTROL_SM_CLKSEL_NOM1 = 1 << 25, + /*! Lower bit of clksel_fb, selects PLL0 as output. */ + CCSM_CONTROL_SM_CLKSEL_FB0 = 1 << 26, + /*! Upper bit of clksel_fb, selects PLL1 as output. */ + CCSM_CONTROL_SM_CLKSEL_FB1 = 1 << 27, + /*! Current value of the PLL_SWAP signal. */ + CCSM_CONTROL_SM_PLL_SWAP = 1 << 28 +}; + +/*! Status values for DVFS state machine. */ +enum mod_ccsm_dvfs_sm_status_shift { + /*! Current state of the state machine. */ + CCSM_DVFS_SM_CURRENT_STATE = 1 << 0, + /*! Previous state of the state machine. */ + CCSM_DVFS_SM_PREV_STATE = 1 << 8, + /*! State before the previous state of the state machine. */ + CCSM_DVFS_SM_BEFORE_PREV_STATE = 1 << 16, + /*! Bit indicating if a second DVFS up step is expected. */ + CCSM_DVFS_GO_UP2_REQD = 1 << 24, + /*! Bit indicating if a second DVFS down step is expected. */ + CCSM_DVFS_GO_DN2_REQD = 1 << 25 +}; + +/*! + * \brief Status values for droop mitigation state machine. + */ +enum mod_ccsm_dm_sm_status_shift { + /*! Current state of the state machine. */ + CCSM_DM_SM_CURRENT_STATE = 1 << 0, + /*! 2-bit value of CLKSEL, selecting nominal or fallback. */ + CCSM_DM_SM_CLKSEL = 1 << 8, +}; + +/*! + * \brief Status values for overcurrent state machine. + */ +enum mod_ccsm_oc_sm_status_shift { + /*! Current state of the state machine. */ + CCSM_OC_SM_CURRENT_STATE = 1 << 0 +}; + +/*! CCSM driver functions */ + +/*! + * \brief Get PLL static configuration registers. + * + * \param reg Pointer to the CCSM register struct. + * + * \param pll_select Selector for physical PLL to read from. + * + * \param[out] config Current static configuration register value for the PLL. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_E_PARAM The `pll_select` parameter was an invalid value. + */ +int ccsm_drv_get_pll_static_settings( + struct ccsm_reg *reg, + enum mod_ccsm_pll_static_select pll_select, + uint32_t *config); + +/*! + * \brief Get PLL dynamic configuration registers. + * + * \param reg Pointer to the CCSM register struct. + * + * \param pll_select Selector for which PLL to read from, nominal or fallback. + * + * \param[out] config0 Current register value read for settings 0. + * + * \param[out] config1 Current register value read for settings 1. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_E_PARAM The `pll_select` parameter was an invalid value. + */ +int ccsm_drv_get_pll_dynamic_settings( + struct ccsm_reg *reg, + enum mod_ccsm_pll_dynamic_select pll_select, + uint32_t *config0, + uint32_t *config1); + +/*! + * \brief Set static config for a PLL. + * + * \param reg Pointer to the CCSM register struct. + * + * \param pll_select Selector for which physical PLL to update. + * + * \param config The register value to be set for static config of PLL. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_E_PARAM The `pll_select` parameter was an invalid value. + */ +int ccsm_drv_set_pll_static_settings( + struct ccsm_reg *reg, + enum mod_ccsm_pll_static_select pll_select, + uint32_t config); + +/*! + * \brief Set dynamic config for a PLL. + * + * \param reg Pointer to the CCSM register struct. + * + * \param pll_select Selector for which PLL to update, nominal or fallback. + * + * \param config0 The register value to be set for settings 0. + * + * \param config1 The register value to be set for settings 1. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_E_PARAM The `pll_select` parameter was an invalid value. + */ +int ccsm_drv_set_pll_dynamic_settings( + struct ccsm_reg *reg, + enum mod_ccsm_pll_dynamic_select pll_select, + uint32_t config0, + uint32_t config1); + +/*! + * \brief Get current droop mitigation config. + * + * \param reg Pointer to the CCSM register struct. + * + * \param[out] config Contents of current droop mitigation config register. + * + * \retval ::FWK_SUCCESS The operation succeeded. + */ +int ccsm_drv_get_dm_configuration(struct ccsm_reg *reg, uint32_t *config); + +/*! + * \brief Get droop mitigation telemetry. Requires debug to be enabled. + * + * \param reg Pointer to the CCSM register struct. + * + * \param[out] telemetry1 Contents of telemetry register 1. + * + * \param[out] telemetry2 Contents of telemetry register 2. + * + * \param[out] telemetry3 Contents of telemetry register 3. + * + * \retval ::FWK_SUCCESS The operation succeeded. + */ +int ccsm_drv_get_dm_telemetry( + struct ccsm_reg *reg, + uint32_t *telemetry1, + uint32_t *telemetry2, + uint32_t *telemetry3); + +/*! + * \brief Set target droop mitigation config, applied in next DVFS/DM command. + * + * \param reg Pointer to the CCSM register struct. + * + * \param[in] config The target droop mitigation config register value to set. + * + * \retval ::FWK_SUCCESS The operation succeeded. + */ +int ccsm_drv_set_dm_configuration(struct ccsm_reg *reg, uint32_t config); + +/*! + * \brief Get current modulator config for a core. + * + * \param reg Pointer to the CCSM register struct. + * + * \param core_id Identifier for the core. + * + * \param[out] config The current modulator config register value. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_E_PARAM The `core_id` parameter was an invalid value. + */ +int ccsm_drv_get_mod_configuration( + struct ccsm_reg *reg, + enum mod_ccsm_mod_select core_id, + uint32_t *config); + +/*! + * \brief Set modulator configuration, to be applied in next set_mod command. + * + * \param reg Pointer to the CCSM register struct. + * + * \param core_id Identifier for the core to be updated. + * + * \param config The target modulator config register value to set. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_E_PARAM The `core_id` parameter was an invalid value. + */ +int ccsm_drv_set_mod_configuration( + struct ccsm_reg *reg, + enum mod_ccsm_mod_select core_id, + uint32_t config); + +/*! + * \brief Check if IRQ error register is clear. + * + * \param reg Pointer to the CCSM register struct. + * + * \retval true The IRQ error register is clear. + * \retval false The IRQ error register is not clear. + */ +bool ccsm_drv_is_irq_error_clear(void *reg); + +/*! + * \brief Get IRQ error register and clear. + * + * \param reg Pointer to the CCSM register struct. + * + * \param[out] error The IRQ error register contents. + * + * \retval ::FWK_SUCCESS The operation succeeded. + */ +int ccsm_drv_get_clear_irq_error(struct ccsm_reg *reg, uint32_t *error); + +/*! + * \brief Check if IRQ status register is clear. + * + * \param reg Pointer to the CCSM register struct. + * + * \retval true The IRQ status register is clear. + * \retval false The IRQ status register is not clear. + */ +bool ccsm_drv_is_irq_status_clear(void *reg); + +/*! + * \brief Get IRQ status register and clear. + * + * \param reg Pointer to the CCSM register struct. + * + * \param[out] status The IRQ status register contents. + * + * \retval ::FWK_SUCCESS The operation succeeded. + */ +int ccsm_drv_get_clear_irq_status(struct ccsm_reg *reg, uint32_t *status); + +/*! + * \brief Check if current CCSM request is complete. + * + * \param reg Pointer to the CCSM register struct. + * + * \retval true The request is complete. + * \retval false The request is ongoing. + */ +bool ccsm_drv_is_request_complete(void *reg); + +/*! + * \brief Set request registers and trigger a CCSM request. + * + * \param reg Pointer to the CCSM register struct. + * + * \param req_type Type of request to be triggered. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_E_DEVICE A request has not been cleared from the device. + * \retval ::FWK_E_BUSY A request is still ongoing. + */ +int ccsm_drv_set_request( + struct ccsm_reg *reg, + enum mod_ccsm_request_type req_type); + +/*! + * \brief Clear request registers. + * + * \param reg Pointer to the CCSM register struct. + * + * \retval ::FWK_SUCCESS The operation succeeded. + */ +int ccsm_drv_clear_request(struct ccsm_reg *reg); + +#endif /* CCSM_DRV_H */ diff --git a/module/ccsm/src/mod_ccsm.c b/module/ccsm/src/mod_ccsm.c new file mode 100644 index 000000000..b07d70fad --- /dev/null +++ b/module/ccsm/src/mod_ccsm.c @@ -0,0 +1,874 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "ccsm_drv.h" + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include + +/* Device context */ +struct ccsm_dev_ctx { + bool initialized; + uint64_t current_nominal_clock_rate_hz; + uint64_t current_fallback_clock_rate_hz; + enum mod_clock_state current_state; + struct mod_timer_api *timer_api; + const struct mod_ccsm_dev_config *config; +}; + +/* Module context */ +struct ccsm_ctx { + struct ccsm_dev_ctx *dev_ctx_table; + unsigned int dev_count; +}; + +static struct ccsm_ctx module_ctx; + +/* + * Static helper functions + */ +static inline struct ccsm_dev_ctx *get_context_from_id(fwk_id_t id) +{ + return module_ctx.dev_ctx_table + fwk_id_get_element_idx(id); +} + +static int compare_rate_entry(const void *a, const void *b) +{ + struct mod_ccsm_clock_rate *key = (struct mod_ccsm_clock_rate *)a; + struct mod_ccsm_clock_rate *element = (struct mod_ccsm_clock_rate *)b; + + return (key->nominal_clock_rate_hz - element->nominal_clock_rate_hz); +} + +static int get_indexed_rates( + struct ccsm_dev_ctx *ctx, + uint64_t target_rate, + struct mod_ccsm_clock_rate *clock_rates) +{ + struct mod_ccsm_clock_rate *current_rate_entry; + + if (ctx == NULL) { + return FWK_E_PARAM; + } + + if (clock_rates == NULL) { + return FWK_E_PARAM; + } + + /* + * Perform a binary search to find the entry matching the requested rate. + * The table must be sorted in ascending order. + */ + current_rate_entry = (struct mod_ccsm_clock_rate *)bsearch( + &target_rate, + ctx->config->rate_table, + ctx->config->rate_count, + sizeof(struct mod_ccsm_clock_rate), + compare_rate_entry); + + if (current_rate_entry == NULL) { + return FWK_E_PARAM; + } + + clock_rates->nominal_clock_rate_hz = + current_rate_entry->nominal_clock_rate_hz; + clock_rates->fallback_clock_rate_hz = + current_rate_entry->fallback_clock_rate_hz; + + return FWK_SUCCESS; +} + +static int compare_register_rate_entry(const void *a, const void *b) +{ + struct mod_ccsm_clock_rate *key = (struct mod_ccsm_clock_rate *)a; + struct mod_ccsm_clock_rate *element = (struct mod_ccsm_clock_rate *)b; + + return (key->nominal_clock_rate_hz - element->nominal_clock_rate_hz); +} + +static int get_register_value_rate( + struct ccsm_dev_ctx *ctx, + uint64_t rate, + uint32_t *pll_settings_0, + uint32_t *pll_settings_1) +{ + struct mod_ccsm_clock_rate_reg_value *current_register_rate_entry; + + if (ctx == NULL) { + return FWK_E_PARAM; + } + + if (pll_settings_0 == NULL || pll_settings_1 == NULL) { + return FWK_E_PARAM; + } + + /* + * Perform a binary search to find the entry matching the requested rate. + * The table must be sorted in ascending order. + */ + current_register_rate_entry = + (struct mod_ccsm_clock_rate_reg_value *)bsearch( + &rate, + ctx->config->register_rate_table, + ctx->config->register_rate_count, + sizeof(struct mod_ccsm_clock_rate_reg_value), + compare_register_rate_entry); + + if (current_register_rate_entry == NULL) { + return FWK_E_PARAM; + } + + *pll_settings_0 = current_register_rate_entry->pll_settings_0; + *pll_settings_1 = current_register_rate_entry->pll_settings_1; + + return FWK_SUCCESS; +} + +static int get_clear_irq_status(struct ccsm_dev_ctx *ctx, uint32_t *status) +{ + int ret; + struct ccsm_reg *reg; + + reg = (struct ccsm_reg *)ctx->config->base_address; + + /* Get IRQ_STATUS from driver and clear register. */ + ret = ccsm_drv_get_clear_irq_status(reg, status); + + if (ret != FWK_SUCCESS) { + return ret; + } + + /* Wait for IRQ_STATUS to be clear. */ + return ctx->timer_api->wait( + ctx->config->timer_id, + MOD_CCSM_COMMAND_WAIT_TIMEOUT, + ccsm_drv_is_irq_status_clear, + (void *)reg); +} + +static int ccsm_send_await_request( + struct ccsm_dev_ctx *ctx, + enum mod_ccsm_request_type req_type) +{ + int ret; + uint32_t status; + struct ccsm_reg *reg; + + reg = (struct ccsm_reg *)ctx->config->base_address; + + /* Set request through the driver. */ + ret = ccsm_drv_set_request(reg, req_type); + + if (ret != FWK_SUCCESS) { + return ret; + } + + /* Await completion of the request. */ + ret = ctx->timer_api->wait( + ctx->config->timer_id, + MOD_CCSM_COMMAND_WAIT_TIMEOUT, + ccsm_drv_is_request_complete, + (void *)reg); + + if (ret != FWK_SUCCESS) { + return ret; + } + + /* Clear IRQ_STATUS on completion. */ + ret = get_clear_irq_status(ctx, &status); + + if (ret != FWK_SUCCESS) { + return ret; + } + + /* Clear request registers to allow subsequent requests. */ + return ccsm_drv_clear_request(reg); +} + +static int set_static_pll_settings(struct ccsm_dev_ctx *ctx) +{ + int status; + + status = ccsm_drv_set_pll_static_settings( + (struct ccsm_reg *)ctx->config->base_address, + MOD_CCSM_PLL_0, + ctx->config->pll_0_static_reg_value); + if (status != FWK_SUCCESS) { + return status; + } + + status = ccsm_drv_set_pll_static_settings( + (struct ccsm_reg *)ctx->config->base_address, + MOD_CCSM_PLL_1, + ctx->config->pll_1_static_reg_value); + + return status; +} + +static inline uint64_t clock_rate_round_nearest( + uint64_t rate, + uint64_t clock_rate_step) +{ + uint64_t rate_rounded, rate_rounded_alt; + + rate_rounded = FWK_ALIGN_PREVIOUS(rate, clock_rate_step); + rate_rounded_alt = FWK_ALIGN_NEXT(rate, clock_rate_step); + + /* Select the rounded rate that is closest to the given rate */ + if ((rate - rate_rounded) > (rate_rounded_alt - rate)) { + return rate_rounded_alt; + } else { + return rate_rounded; + } +} + +static inline int is_rate_entry_valid( + struct ccsm_dev_ctx *ctx, + struct mod_ccsm_clock_rate rate_entry) +{ + if (rate_entry.nominal_clock_rate_hz > ctx->config->max_clock_rate_hz) { + return FWK_E_SUPPORT; + } else if ( + rate_entry.nominal_clock_rate_hz < ctx->config->min_clock_rate_hz) { + return FWK_E_SUPPORT; + } else if ( + (rate_entry.fallback_clock_rate_hz > 0) && + (rate_entry.fallback_clock_rate_hz < ctx->config->min_clock_rate_hz)) { + return FWK_E_SUPPORT; + } else { + return FWK_SUCCESS; + } +} + +static int get_rounded_rate( + struct ccsm_dev_ctx *ctx, + uint64_t *rate, + enum mod_clock_round_mode round_mode) +{ + if ((*rate % ctx->config->clock_rate_step_hz) > 0) { + switch (round_mode) { + case MOD_CLOCK_ROUND_MODE_NONE: + return FWK_E_RANGE; + case MOD_CLOCK_ROUND_MODE_NEAREST: + *rate = clock_rate_round_nearest( + *rate, ctx->config->clock_rate_step_hz); + break; + case MOD_CLOCK_ROUND_MODE_DOWN: + *rate = FWK_ALIGN_PREVIOUS(*rate, ctx->config->clock_rate_step_hz); + break; + case MOD_CLOCK_ROUND_MODE_UP: + *rate = FWK_ALIGN_NEXT(*rate, ctx->config->clock_rate_step_hz); + break; + default: + return FWK_E_SUPPORT; + } + } + + return FWK_SUCCESS; +} + +static int ccsm_clock_select_rates( + struct ccsm_dev_ctx *ctx, + uint64_t rate, + enum mod_clock_round_mode round_mode, + struct mod_ccsm_clock_rate *clock_rates) +{ + int status; + + if (ctx->config->rate_lookup_table_is_provided) { + status = get_indexed_rates(ctx, rate, clock_rates); + if (status != FWK_SUCCESS) { + return status; + } + } else { + clock_rates->nominal_clock_rate_hz = rate; + } + + status = get_rounded_rate( + ctx, &(clock_rates->nominal_clock_rate_hz), round_mode); + if (status != FWK_SUCCESS) { + return status; + } + + if (!ctx->config->rate_lookup_table_is_provided) { + /* Set fallback as fraction of nominal frequency if above threshold. */ + if (clock_rates->nominal_clock_rate_hz >= + ctx->config->minimum_clock_rate_fallback_enable_hz) { + clock_rates->fallback_clock_rate_hz = + ctx->config->fallback_clock_percentage * + (clock_rates->nominal_clock_rate_hz / 100); + } else { + clock_rates->fallback_clock_rate_hz = 0; + } + } + + status = get_rounded_rate( + ctx, &(clock_rates->fallback_clock_rate_hz), MOD_CLOCK_ROUND_MODE_DOWN); + if (status != FWK_SUCCESS) { + return status; + } + + status = is_rate_entry_valid(ctx, *clock_rates); + + return status; +} + +static int ccsm_mod_set_configuration( + struct ccsm_dev_ctx *ctx, + enum mod_ccsm_mod_select mod_id, + const struct mod_ccsm_mod_config *config) +{ + uint32_t value; + + if (mod_id >= ctx->config->modulator_count) { + return FWK_E_RANGE; + } + + if ((config->numerator_regular < config->numerator_oc) | + (config->denominator < config->numerator_oc) | + (config->denominator < config->numerator_regular)) { + return FWK_E_PARAM; + } + + value = + (((config->numerator_regular + << CCSM_MODULATOR_SETTINGS_NUMERATOR_REGULAR_POS) & + CCSM_MODULATOR_SETTINGS_NUMERATOR_REGULAR_MASK) | + ((config->numerator_oc + << CCSM_MODULATOR_SETTINGS_NUMERATOR_PMIC_OC_POS) & + CCSM_MODULATOR_SETTINGS_NUMERATOR_PMIC_OC_MASK) | + ((config->denominator << CCSM_MODULATOR_SETTINGS_DENOMINATOR_POS) & + CCSM_MODULATOR_SETTINGS_DENOMINATOR_MASK)); + + return ccsm_drv_set_mod_configuration( + (struct ccsm_reg *)ctx->config->base_address, mod_id, value); +} + +static int ccsm_dm_set_configuration( + struct ccsm_dev_ctx *ctx, + const struct mod_ccsm_dm_config *config) +{ + uint32_t mitigation_duration; + uint32_t transition_pause; + uint32_t value; + + mitigation_duration = + ((config->mitigation_duration + << CCSM_DROOP_MITIGATION_STRATEGY_MITIGATION_DURATION_POS) & + CCSM_DROOP_MITIGATION_STRATEGY_MITIGATION_DURATION_MASK); + + transition_pause = + ((config->transition_pause + << CCSM_DROOP_MITIGATION_STRATEGY_TRANSITION_PAUSE_POS) & + CCSM_DROOP_MITIGATION_STRATEGY_TRANSITION_PAUSE_MASK); + + value = + (config->strategy | config->dd | config->soff | transition_pause | + mitigation_duration); + + return ccsm_drv_set_dm_configuration( + (struct ccsm_reg *)ctx->config->base_address, value); +} + +static int ccsm_dm_get_configuration( + struct ccsm_dev_ctx *ctx, + struct mod_ccsm_dm_config *config) +{ + int status; + uint32_t value; + + status = ccsm_drv_get_dm_configuration( + (struct ccsm_reg *)ctx->config->base_address, &value); + if (status != FWK_SUCCESS) { + return status; + } + + if (value & MOD_CCSM_DM_NOM_ONLY) { + config->strategy = MOD_CCSM_DM_NOM_ONLY; + } else if (value & MOD_CCSM_DM_SW_FB) { + config->strategy = MOD_CCSM_DM_SW_FB; + } else if (value & MOD_CCSM_DM_CLK_ON_DVFS) { + config->strategy = MOD_CCSM_DM_CLK_ON_DVFS; + } else { + config->strategy = MOD_CCSM_DM_STOP_CLK; + } + + if (value & MOD_CCSM_DM_TPIP) { + config->dd = MOD_CCSM_DM_TPIP; + } else { + config->dd = MOD_CCSM_DM_ARM_DD; + } + + if (value & MOD_CCSM_DM_SW_SOFF_STOP) { + config->soff = MOD_CCSM_DM_SW_SOFF_STOP; + } else { + config->soff = MOD_CCSM_DM_SW_SOFF_IGNORE; + } + + config->transition_pause = + ((value & CCSM_DROOP_MITIGATION_STRATEGY_TRANSITION_PAUSE_MASK) >> + CCSM_DROOP_MITIGATION_STRATEGY_TRANSITION_PAUSE_POS); + + config->mitigation_duration = + ((value & CCSM_DROOP_MITIGATION_STRATEGY_MITIGATION_DURATION_MASK) >> + CCSM_DROOP_MITIGATION_STRATEGY_MITIGATION_DURATION_POS); + + return FWK_SUCCESS; +} + +/*! Get register values from PLL driver and update CCSM. */ +static int ccsm_clock_update_registers( + struct ccsm_dev_ctx *ctx, + struct mod_ccsm_clock_rate *clock_rates) +{ + int status; + uint32_t settings_0_register_value; + uint32_t settings_1_register_value; + + if (!ctx->initialized) { + status = set_static_pll_settings(ctx); + if (status != FWK_SUCCESS) { + return status; + } + } + + status = get_register_value_rate( + ctx, + clock_rates->nominal_clock_rate_hz, + &settings_0_register_value, + &settings_1_register_value); + if (status != FWK_SUCCESS) { + return status; + } + + status = ccsm_drv_set_pll_dynamic_settings( + (struct ccsm_reg *)ctx->config->base_address, + MOD_CCSM_PLL_NOMINAL, + settings_0_register_value, + settings_1_register_value); + if (status != FWK_SUCCESS) { + return status; + } + + return status; +} + +/*! Handle CCSM initialization. */ +static int ccsm_device_setup(struct ccsm_dev_ctx *ctx, uint64_t rate) +{ + int status; + enum mod_ccsm_mod_select mod_n; + struct mod_ccsm_clock_rate clock_rates; + + /* Select appropriate rates for nominal and fallback */ + status = ccsm_clock_select_rates( + ctx, rate, MOD_CLOCK_ROUND_MODE_NEAREST, &clock_rates); + if (status != FWK_SUCCESS) { + return status; + } + + status = + ccsm_dm_set_configuration(ctx, ctx->config->droop_mitigation_default); + if (status != FWK_SUCCESS) { + return status; + } + + status = ccsm_send_await_request(ctx, CCSM_REQUEST_TYPE_SET_DM); + if (status != FWK_SUCCESS) { + return status; + } + + for (mod_n = MOD_CCSM_MOD_CORE0; mod_n < ctx->config->modulator_count; + mod_n++) { + status = ccsm_mod_set_configuration( + ctx, mod_n, ctx->config->modulator_default); + if (status != FWK_SUCCESS) { + return status; + } + } + + status = ccsm_send_await_request(ctx, CCSM_REQUEST_TYPE_SET_MOD); + if (status != FWK_SUCCESS) { + return status; + } + + status = ccsm_clock_update_registers(ctx, &clock_rates); + if (status != FWK_SUCCESS) { + return status; + } + + status = ccsm_send_await_request(ctx, CCSM_REQUEST_TYPE_SET_DVFS); + if (status != FWK_SUCCESS) { + return status; + } + + ctx->initialized = true; + ctx->current_nominal_clock_rate_hz = clock_rates.nominal_clock_rate_hz; + ctx->current_fallback_clock_rate_hz = clock_rates.fallback_clock_rate_hz; + + return FWK_SUCCESS; +} + +/* + * Clock driver API functions + */ + +static int ccsm_clock_set_rate( + fwk_id_t dev_id, + uint64_t rate, + enum mod_clock_round_mode round_mode) +{ + struct ccsm_dev_ctx *ctx; + struct mod_ccsm_clock_rate clock_rates; + int status; + + if (!fwk_module_is_valid_element_id(dev_id)) { + return FWK_E_PARAM; + } + + ctx = get_context_from_id(dev_id); + if (ctx->initialized == false) { + return ccsm_device_setup(ctx, rate); + } + + if (ctx->current_state == MOD_CLOCK_STATE_STOPPED) { + return FWK_E_PWRSTATE; + } + + /* Select appropriate rates for nominal and fallback */ + status = ccsm_clock_select_rates(ctx, rate, round_mode, &clock_rates); + if (status != FWK_SUCCESS) { + return status; + } + + if (clock_rates.nominal_clock_rate_hz == + ctx->current_nominal_clock_rate_hz) { + return FWK_SUCCESS; + } + + status = ccsm_clock_update_registers(ctx, &clock_rates); + if (status != FWK_SUCCESS) { + return status; + } + + /* Send DVFS command as required */ + if (clock_rates.nominal_clock_rate_hz > + ctx->current_nominal_clock_rate_hz) { + status = ccsm_send_await_request(ctx, CCSM_REQUEST_TYPE_GO_UP); + + if (status != FWK_SUCCESS) { + return status; + } + + status = ccsm_send_await_request(ctx, CCSM_REQUEST_TYPE_GO_UP2); + } else { + status = ccsm_send_await_request(ctx, CCSM_REQUEST_TYPE_GO_DN); + + if (status != FWK_SUCCESS) { + return status; + } + + status = ccsm_send_await_request(ctx, CCSM_REQUEST_TYPE_GO_DN2); + } + + if (status != FWK_SUCCESS) { + return status; + } + + ctx->current_nominal_clock_rate_hz = clock_rates.nominal_clock_rate_hz; + ctx->current_fallback_clock_rate_hz = clock_rates.fallback_clock_rate_hz; + + return FWK_SUCCESS; +} + +static int ccsm_clock_get_rate(fwk_id_t dev_id, uint64_t *rate) +{ + struct ccsm_dev_ctx *ctx; + + if (!fwk_module_is_valid_element_id(dev_id)) { + return FWK_E_PARAM; + } + + ctx = get_context_from_id(dev_id); + + *rate = ctx->current_nominal_clock_rate_hz; + + return FWK_SUCCESS; +} + +static int ccsm_clock_get_rate_from_index( + fwk_id_t dev_id, + unsigned int rate_index, + uint64_t *rate) +{ + struct ccsm_dev_ctx *ctx; + + if (!fwk_module_is_valid_element_id(dev_id)) { + return FWK_E_PARAM; + } + + if (rate == NULL) { + return FWK_E_PARAM; + } + + ctx = get_context_from_id(dev_id); + + if (ctx->config->rate_lookup_table_is_provided) { + if (rate_index >= ctx->config->rate_count) { + return FWK_E_PARAM; + } + + *rate = ctx->config->rate_table[rate_index].nominal_clock_rate_hz; + return FWK_SUCCESS; + } else { + /* Rate table is required to return rate from index. */ + return FWK_E_SUPPORT; + } +} + +static int ccsm_clock_set_state(fwk_id_t dev_id, enum mod_clock_state state) +{ + if (state == MOD_CLOCK_STATE_RUNNING) { + return FWK_SUCCESS; + } + + /* PLLs can only be stopped by a parent power domain state change. */ + return FWK_E_SUPPORT; +} + +static int ccsm_clock_get_state(fwk_id_t dev_id, enum mod_clock_state *state) +{ + struct ccsm_dev_ctx *ctx; + + if (!fwk_module_is_valid_element_id(dev_id)) { + return FWK_E_PARAM; + } + + if (state == NULL) { + return FWK_E_PARAM; + } + + ctx = get_context_from_id(dev_id); + *state = ctx->current_state; + + return FWK_SUCCESS; +} + +static int ccsm_clock_get_range(fwk_id_t dev_id, struct mod_clock_range *range) +{ + struct ccsm_dev_ctx *ctx; + + if (!fwk_module_is_valid_element_id(dev_id)) { + return FWK_E_PARAM; + } + + if (range == NULL) { + return FWK_E_PARAM; + } + + ctx = get_context_from_id(dev_id); + + if (ctx->config->rate_lookup_table_is_provided) { + range->rate_type = MOD_CLOCK_RATE_TYPE_DISCRETE; + range->min = ctx->config->rate_table[0].nominal_clock_rate_hz; + range->max = ctx->config->rate_table[ctx->config->rate_count - 1] + .nominal_clock_rate_hz; + range->rate_count = ctx->config->rate_count; + } else { + range->rate_type = MOD_CLOCK_RATE_TYPE_CONTINUOUS; + range->min = ctx->config->min_clock_rate_hz; + range->max = ctx->config->max_clock_rate_hz; + range->step = ctx->config->clock_rate_step_hz; + } + + return FWK_SUCCESS; +} + +static int ccsm_clock_power_state_change(fwk_id_t dev_id, unsigned int state) +{ + uint64_t rate; + struct ccsm_dev_ctx *ctx; + + ctx = get_context_from_id(dev_id); + + if (state != MOD_PD_STATE_ON) { + return FWK_SUCCESS; + } + + ctx->current_state = MOD_CLOCK_STATE_RUNNING; + + if (ctx->initialized) { + /* Restore the previous rate */ + rate = ctx->current_nominal_clock_rate_hz; + } else { + /* Initialize the PLL to its default rate */ + rate = ctx->config->default_rates_table->nominal_clock_rate_hz; + } + + return ccsm_device_setup(ctx, rate); +} + +static int ccsm_clock_power_state_pending_change( + fwk_id_t dev_id, + unsigned int current_state, + unsigned int next_state) +{ + struct ccsm_dev_ctx *ctx; + + ctx = get_context_from_id(dev_id); + + if (next_state == MOD_PD_STATE_OFF) { + /* Just mark the PLL as stopped */ + ctx->current_state = MOD_CLOCK_STATE_STOPPED; + } + + return FWK_SUCCESS; +} + +static const struct mod_clock_drv_api api_ccsm_clock = { + .set_rate = ccsm_clock_set_rate, + .get_rate = ccsm_clock_get_rate, + .get_rate_from_index = ccsm_clock_get_rate_from_index, + .set_state = ccsm_clock_set_state, + .get_state = ccsm_clock_get_state, + .get_range = ccsm_clock_get_range, + .process_power_transition = ccsm_clock_power_state_change, + .process_pending_power_transition = ccsm_clock_power_state_pending_change, +}; + +/* + * Framework handler functions + */ +static int ccsm_init( + fwk_id_t module_id, + unsigned int element_count, + const void *data) +{ + module_ctx.dev_count = element_count; + + if (element_count == 0) { + return FWK_SUCCESS; + } + + module_ctx.dev_ctx_table = + fwk_mm_calloc(element_count, sizeof(struct ccsm_dev_ctx)); + + return FWK_SUCCESS; +} + +static int ccsm_element_init( + fwk_id_t element_id, + unsigned int unused, + const void *data) +{ + int status; + struct ccsm_dev_ctx *ctx; + struct mod_ccsm_clock_rate rate_entry; + const struct mod_ccsm_dev_config *dev_config = data; + uint32_t element_idx = fwk_id_get_element_idx(element_id); + uint32_t rate_n; + uint64_t previous_nominal_rate_hz = 0; + + if (element_idx >= module_ctx.dev_count) { + return FWK_E_DATA; + } + + ctx = module_ctx.dev_ctx_table + element_idx; + + ctx->config = dev_config; + + for (rate_n = 0; rate_n < ctx->config->rate_count; rate_n++) { + rate_entry = ctx->config->rate_table[rate_n]; + if (rate_entry.fallback_clock_rate_hz > + rate_entry.nominal_clock_rate_hz) { + return FWK_E_DATA; + } + + if (rate_entry.nominal_clock_rate_hz < previous_nominal_rate_hz) { + return FWK_E_DATA; + } + + status = is_rate_entry_valid(ctx, rate_entry); + if (status != FWK_SUCCESS) { + return status; + } + + previous_nominal_rate_hz = rate_entry.nominal_clock_rate_hz; + } + + ctx->current_nominal_clock_rate_hz = + dev_config->default_rates_table->nominal_clock_rate_hz; + ctx->initialized = false; + ctx->current_state = MOD_CLOCK_STATE_STOPPED; + + return FWK_SUCCESS; +} + +static int ccsm_bind(fwk_id_t id, unsigned int round) +{ + int status; + struct ccsm_dev_ctx *ctx; + + if ((round == 1) && fwk_id_is_type(id, FWK_ID_TYPE_ELEMENT)) { + ctx = get_context_from_id(id); + + /* Bind to timer API */ + status = fwk_module_bind( + ctx->config->timer_id, + FWK_ID_API(FWK_MODULE_IDX_TIMER, MOD_TIMER_API_IDX_TIMER), + &ctx->timer_api); + + if (status != FWK_SUCCESS) { + return status; + } + + if (ctx->timer_api->wait == NULL) { + return FWK_E_DATA; + } + } + + return FWK_SUCCESS; +} + +static int ccsm_process_bind_request( + fwk_id_t requester_id, + fwk_id_t id, + fwk_id_t api_type, + const void **api) +{ + switch (fwk_id_get_api_idx(api_type)) { + case MOD_CCSM_CLOCK_API: + *api = &api_ccsm_clock; + break; + default: + return FWK_E_PARAM; + } + + return FWK_SUCCESS; +} + +const struct fwk_module module_ccsm = { + .type = FWK_MODULE_TYPE_DRIVER, + .api_count = (unsigned int)MOD_CCSM_API_COUNT, + .bind = ccsm_bind, + .event_count = 0, + .init = ccsm_init, + .element_init = ccsm_element_init, + .process_bind_request = ccsm_process_bind_request, +}; -- GitLab From ecfbe4fab99df225380bc4e31565353576a8687f Mon Sep 17 00:00:00 2001 From: Ellie Lewis Date: Wed, 17 Jul 2024 14:49:04 +0100 Subject: [PATCH 2/4] module/ccsm: Add unit tests for API functions Signed-off-by: Ellie Lewis --- module/ccsm/test/CMakeLists.txt | 25 + module/ccsm/test/fwk_module_idx.h | 26 + module/ccsm/test/mocks/.clang-format | 4 + module/ccsm/test/mocks/Mockmod_ccsm_extra.c | 3602 +++++++++++++++++++ module/ccsm/test/mocks/Mockmod_ccsm_extra.h | 438 +++ module/ccsm/test/mod_ccsm_extra.h | 237 ++ module/ccsm/test/mod_ccsm_unit_test.c | 1271 +++++++ unit_test/CMakeLists.txt | 1 + 8 files changed, 5604 insertions(+) create mode 100644 module/ccsm/test/CMakeLists.txt create mode 100644 module/ccsm/test/fwk_module_idx.h create mode 100644 module/ccsm/test/mocks/.clang-format create mode 100644 module/ccsm/test/mocks/Mockmod_ccsm_extra.c create mode 100644 module/ccsm/test/mocks/Mockmod_ccsm_extra.h create mode 100644 module/ccsm/test/mod_ccsm_extra.h create mode 100644 module/ccsm/test/mod_ccsm_unit_test.c diff --git a/module/ccsm/test/CMakeLists.txt b/module/ccsm/test/CMakeLists.txt new file mode 100644 index 000000000..1a1711d3c --- /dev/null +++ b/module/ccsm/test/CMakeLists.txt @@ -0,0 +1,25 @@ +# +# Arm SCP/MCP Software +# Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +# + +set(TEST_SRC mod_ccsm) +set(TEST_FILE mod_ccsm) + +set(UNIT_TEST_TARGET mod_${TEST_MODULE}_unit_test) + +set(MODULE_SRC ${MODULE_ROOT}/${TEST_MODULE}/src) +set(MODULE_INC ${MODULE_ROOT}/${TEST_MODULE}/include) +list(APPEND OTHER_MODULE_INC ${MODULE_ROOT}/clock/include) +list(APPEND OTHER_MODULE_INC ${MODULE_ROOT}/power_domain/include) +list(APPEND OTHER_MODULE_INC ${MODULE_ROOT}/timer/include) +set(MODULE_UT_SRC ${CMAKE_CURRENT_LIST_DIR}) +set(MODULE_UT_INC ${CMAKE_CURRENT_LIST_DIR}) +set(MODULE_UT_MOCK_SRC ${CMAKE_CURRENT_LIST_DIR}/mocks) + +list(APPEND MOCK_REPLACEMENTS fwk_module) +list(APPEND MOCK_REPLACEMENTS fwk_id) + +include(${SCP_ROOT}/unit_test/module_common.cmake) diff --git a/module/ccsm/test/fwk_module_idx.h b/module/ccsm/test/fwk_module_idx.h new file mode 100644 index 000000000..28953f008 --- /dev/null +++ b/module/ccsm/test/fwk_module_idx.h @@ -0,0 +1,26 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef TEST_FWK_MODULE_MODULE_IDX_H +#define TEST_FWK_MODULE_MODULE_IDX_H + +#include + +enum fwk_module_idx { + FWK_MODULE_IDX_CCSM, + FWK_MODULE_IDX_CLOCK, + FWK_MODULE_IDX_TIMER, + FWK_MODULE_IDX_COUNT, +}; + +static const fwk_id_t fwk_module_id_ccsm = + FWK_ID_MODULE_INIT(FWK_MODULE_IDX_CCSM); + +static const fwk_id_t fwk_module_id_clock = + FWK_ID_MODULE_INIT(FWK_MODULE_IDX_CLOCK); + +#endif /* TEST_FWK_MODULE_MODULE_IDX_H */ diff --git a/module/ccsm/test/mocks/.clang-format b/module/ccsm/test/mocks/.clang-format new file mode 100644 index 000000000..eeca2395f --- /dev/null +++ b/module/ccsm/test/mocks/.clang-format @@ -0,0 +1,4 @@ +{ + "DisableFormat": true, + "SortIncludes": false, +} diff --git a/module/ccsm/test/mocks/Mockmod_ccsm_extra.c b/module/ccsm/test/mocks/Mockmod_ccsm_extra.c new file mode 100644 index 000000000..484c72e1c --- /dev/null +++ b/module/ccsm/test/mocks/Mockmod_ccsm_extra.c @@ -0,0 +1,3602 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ +#include +#include +#include +#include "cmock.h" +#include "Mockmod_ccsm_extra.h" + +static const char* CMockString_ccsm_drv_clear_request = "ccsm_drv_clear_request"; +static const char* CMockString_ccsm_drv_get_clear_irq_error = "ccsm_drv_get_clear_irq_error"; +static const char* CMockString_ccsm_drv_get_clear_irq_status = "ccsm_drv_get_clear_irq_status"; +static const char* CMockString_ccsm_drv_get_dm_configuration = "ccsm_drv_get_dm_configuration"; +static const char* CMockString_ccsm_drv_get_dm_telemetry = "ccsm_drv_get_dm_telemetry"; +static const char* CMockString_ccsm_drv_get_mod_configuration = "ccsm_drv_get_mod_configuration"; +static const char* CMockString_ccsm_drv_get_pll_dynamic_settings = "ccsm_drv_get_pll_dynamic_settings"; +static const char* CMockString_ccsm_drv_get_pll_static_settings = "ccsm_drv_get_pll_static_settings"; +static const char* CMockString_ccsm_drv_is_irq_error_clear = "ccsm_drv_is_irq_error_clear"; +static const char* CMockString_ccsm_drv_is_irq_status_clear = "ccsm_drv_is_irq_status_clear"; +static const char* CMockString_ccsm_drv_is_request_complete = "ccsm_drv_is_request_complete"; +static const char* CMockString_ccsm_drv_set_dm_configuration = "ccsm_drv_set_dm_configuration"; +static const char* CMockString_ccsm_drv_set_mod_configuration = "ccsm_drv_set_mod_configuration"; +static const char* CMockString_ccsm_drv_set_pll_dynamic_settings = "ccsm_drv_set_pll_dynamic_settings"; +static const char* CMockString_ccsm_drv_set_pll_static_settings = "ccsm_drv_set_pll_static_settings"; +static const char* CMockString_ccsm_drv_set_request = "ccsm_drv_set_request"; +static const char* CMockString_config = "config"; +static const char* CMockString_config0 = "config0"; +static const char* CMockString_config1 = "config1"; +static const char* CMockString_core_id = "core_id"; +static const char* CMockString_error = "error"; +static const char* CMockString_pll_select = "pll_select"; +static const char* CMockString_reg = "reg"; +static const char* CMockString_req_type = "req_type"; +static const char* CMockString_status = "status"; +static const char* CMockString_telemetry1 = "telemetry1"; +static const char* CMockString_telemetry2 = "telemetry2"; +static const char* CMockString_telemetry3 = "telemetry3"; + +typedef struct _CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + struct ccsm_reg* Expected_reg; + enum mod_ccsm_pll_static_select Expected_pll_select; + uint32_t* Expected_config; + int Expected_reg_Depth; + int Expected_config_Depth; + char ReturnThruPtr_reg_Used; + struct ccsm_reg* ReturnThruPtr_reg_Val; + size_t ReturnThruPtr_reg_Size; + char ReturnThruPtr_config_Used; + uint32_t* ReturnThruPtr_config_Val; + size_t ReturnThruPtr_config_Size; + char IgnoreArg_reg; + char IgnoreArg_pll_select; + char IgnoreArg_config; + +} CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE; + +typedef struct _CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + struct ccsm_reg* Expected_reg; + enum mod_ccsm_pll_dynamic_select Expected_pll_select; + uint32_t* Expected_config0; + uint32_t* Expected_config1; + int Expected_reg_Depth; + int Expected_config0_Depth; + int Expected_config1_Depth; + char ReturnThruPtr_reg_Used; + struct ccsm_reg* ReturnThruPtr_reg_Val; + size_t ReturnThruPtr_reg_Size; + char ReturnThruPtr_config0_Used; + uint32_t* ReturnThruPtr_config0_Val; + size_t ReturnThruPtr_config0_Size; + char ReturnThruPtr_config1_Used; + uint32_t* ReturnThruPtr_config1_Val; + size_t ReturnThruPtr_config1_Size; + char IgnoreArg_reg; + char IgnoreArg_pll_select; + char IgnoreArg_config0; + char IgnoreArg_config1; + +} CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE; + +typedef struct _CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + struct ccsm_reg* Expected_reg; + enum mod_ccsm_pll_static_select Expected_pll_select; + uint32_t Expected_config; + int Expected_reg_Depth; + char ReturnThruPtr_reg_Used; + struct ccsm_reg* ReturnThruPtr_reg_Val; + size_t ReturnThruPtr_reg_Size; + char IgnoreArg_reg; + char IgnoreArg_pll_select; + char IgnoreArg_config; + +} CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE; + +typedef struct _CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + struct ccsm_reg* Expected_reg; + enum mod_ccsm_pll_dynamic_select Expected_pll_select; + uint32_t Expected_config0; + uint32_t Expected_config1; + int Expected_reg_Depth; + char ReturnThruPtr_reg_Used; + struct ccsm_reg* ReturnThruPtr_reg_Val; + size_t ReturnThruPtr_reg_Size; + char IgnoreArg_reg; + char IgnoreArg_pll_select; + char IgnoreArg_config0; + char IgnoreArg_config1; + +} CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE; + +typedef struct _CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + struct ccsm_reg* Expected_reg; + uint32_t* Expected_config; + int Expected_reg_Depth; + int Expected_config_Depth; + char ReturnThruPtr_reg_Used; + struct ccsm_reg* ReturnThruPtr_reg_Val; + size_t ReturnThruPtr_reg_Size; + char ReturnThruPtr_config_Used; + uint32_t* ReturnThruPtr_config_Val; + size_t ReturnThruPtr_config_Size; + char IgnoreArg_reg; + char IgnoreArg_config; + +} CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE; + +typedef struct _CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + struct ccsm_reg* Expected_reg; + uint32_t* Expected_telemetry1; + uint32_t* Expected_telemetry2; + uint32_t* Expected_telemetry3; + int Expected_reg_Depth; + int Expected_telemetry1_Depth; + int Expected_telemetry2_Depth; + int Expected_telemetry3_Depth; + char ReturnThruPtr_reg_Used; + struct ccsm_reg* ReturnThruPtr_reg_Val; + size_t ReturnThruPtr_reg_Size; + char ReturnThruPtr_telemetry1_Used; + uint32_t* ReturnThruPtr_telemetry1_Val; + size_t ReturnThruPtr_telemetry1_Size; + char ReturnThruPtr_telemetry2_Used; + uint32_t* ReturnThruPtr_telemetry2_Val; + size_t ReturnThruPtr_telemetry2_Size; + char ReturnThruPtr_telemetry3_Used; + uint32_t* ReturnThruPtr_telemetry3_Val; + size_t ReturnThruPtr_telemetry3_Size; + char IgnoreArg_reg; + char IgnoreArg_telemetry1; + char IgnoreArg_telemetry2; + char IgnoreArg_telemetry3; + +} CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE; + +typedef struct _CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + struct ccsm_reg* Expected_reg; + uint32_t Expected_config; + int Expected_reg_Depth; + char ReturnThruPtr_reg_Used; + struct ccsm_reg* ReturnThruPtr_reg_Val; + size_t ReturnThruPtr_reg_Size; + char IgnoreArg_reg; + char IgnoreArg_config; + +} CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE; + +typedef struct _CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + struct ccsm_reg* Expected_reg; + enum mod_ccsm_mod_select Expected_core_id; + uint32_t* Expected_config; + int Expected_reg_Depth; + int Expected_config_Depth; + char ReturnThruPtr_reg_Used; + struct ccsm_reg* ReturnThruPtr_reg_Val; + size_t ReturnThruPtr_reg_Size; + char ReturnThruPtr_config_Used; + uint32_t* ReturnThruPtr_config_Val; + size_t ReturnThruPtr_config_Size; + char IgnoreArg_reg; + char IgnoreArg_core_id; + char IgnoreArg_config; + +} CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE; + +typedef struct _CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + struct ccsm_reg* Expected_reg; + enum mod_ccsm_mod_select Expected_core_id; + uint32_t Expected_config; + int Expected_reg_Depth; + char ReturnThruPtr_reg_Used; + struct ccsm_reg* ReturnThruPtr_reg_Val; + size_t ReturnThruPtr_reg_Size; + char IgnoreArg_reg; + char IgnoreArg_core_id; + char IgnoreArg_config; + +} CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE; + +typedef struct _CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + bool ReturnVal; + void* Expected_reg; + int Expected_reg_Depth; + char ReturnThruPtr_reg_Used; + void* ReturnThruPtr_reg_Val; + size_t ReturnThruPtr_reg_Size; + char IgnoreArg_reg; + +} CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE; + +typedef struct _CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + struct ccsm_reg* Expected_reg; + uint32_t* Expected_error; + int Expected_reg_Depth; + int Expected_error_Depth; + char ReturnThruPtr_reg_Used; + struct ccsm_reg* ReturnThruPtr_reg_Val; + size_t ReturnThruPtr_reg_Size; + char ReturnThruPtr_error_Used; + uint32_t* ReturnThruPtr_error_Val; + size_t ReturnThruPtr_error_Size; + char IgnoreArg_reg; + char IgnoreArg_error; + +} CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE; + +typedef struct _CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + bool ReturnVal; + void* Expected_reg; + int Expected_reg_Depth; + char ReturnThruPtr_reg_Used; + void* ReturnThruPtr_reg_Val; + size_t ReturnThruPtr_reg_Size; + char IgnoreArg_reg; + +} CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE; + +typedef struct _CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + struct ccsm_reg* Expected_reg; + uint32_t* Expected_status; + int Expected_reg_Depth; + int Expected_status_Depth; + char ReturnThruPtr_reg_Used; + struct ccsm_reg* ReturnThruPtr_reg_Val; + size_t ReturnThruPtr_reg_Size; + char ReturnThruPtr_status_Used; + uint32_t* ReturnThruPtr_status_Val; + size_t ReturnThruPtr_status_Size; + char IgnoreArg_reg; + char IgnoreArg_status; + +} CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE; + +typedef struct _CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + bool ReturnVal; + void* Expected_reg; + int Expected_reg_Depth; + char ReturnThruPtr_reg_Used; + void* ReturnThruPtr_reg_Val; + size_t ReturnThruPtr_reg_Size; + char IgnoreArg_reg; + +} CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE; + +typedef struct _CMOCK_ccsm_drv_set_request_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + struct ccsm_reg* Expected_reg; + enum mod_ccsm_request_type Expected_req_type; + int Expected_reg_Depth; + char ReturnThruPtr_reg_Used; + struct ccsm_reg* ReturnThruPtr_reg_Val; + size_t ReturnThruPtr_reg_Size; + char IgnoreArg_reg; + char IgnoreArg_req_type; + +} CMOCK_ccsm_drv_set_request_CALL_INSTANCE; + +typedef struct _CMOCK_ccsm_drv_clear_request_CALL_INSTANCE +{ + UNITY_LINE_TYPE LineNumber; + char ExpectAnyArgsBool; + int ReturnVal; + struct ccsm_reg* Expected_reg; + int Expected_reg_Depth; + char ReturnThruPtr_reg_Used; + struct ccsm_reg* ReturnThruPtr_reg_Val; + size_t ReturnThruPtr_reg_Size; + char IgnoreArg_reg; + +} CMOCK_ccsm_drv_clear_request_CALL_INSTANCE; + +static struct Mockmod_ccsm_extraInstance +{ + char ccsm_drv_get_pll_static_settings_IgnoreBool; + int ccsm_drv_get_pll_static_settings_FinalReturn; + char ccsm_drv_get_pll_static_settings_CallbackBool; + CMOCK_ccsm_drv_get_pll_static_settings_CALLBACK ccsm_drv_get_pll_static_settings_CallbackFunctionPointer; + int ccsm_drv_get_pll_static_settings_CallbackCalls; + CMOCK_MEM_INDEX_TYPE ccsm_drv_get_pll_static_settings_CallInstance; + char ccsm_drv_get_pll_dynamic_settings_IgnoreBool; + int ccsm_drv_get_pll_dynamic_settings_FinalReturn; + char ccsm_drv_get_pll_dynamic_settings_CallbackBool; + CMOCK_ccsm_drv_get_pll_dynamic_settings_CALLBACK ccsm_drv_get_pll_dynamic_settings_CallbackFunctionPointer; + int ccsm_drv_get_pll_dynamic_settings_CallbackCalls; + CMOCK_MEM_INDEX_TYPE ccsm_drv_get_pll_dynamic_settings_CallInstance; + char ccsm_drv_set_pll_static_settings_IgnoreBool; + int ccsm_drv_set_pll_static_settings_FinalReturn; + char ccsm_drv_set_pll_static_settings_CallbackBool; + CMOCK_ccsm_drv_set_pll_static_settings_CALLBACK ccsm_drv_set_pll_static_settings_CallbackFunctionPointer; + int ccsm_drv_set_pll_static_settings_CallbackCalls; + CMOCK_MEM_INDEX_TYPE ccsm_drv_set_pll_static_settings_CallInstance; + char ccsm_drv_set_pll_dynamic_settings_IgnoreBool; + int ccsm_drv_set_pll_dynamic_settings_FinalReturn; + char ccsm_drv_set_pll_dynamic_settings_CallbackBool; + CMOCK_ccsm_drv_set_pll_dynamic_settings_CALLBACK ccsm_drv_set_pll_dynamic_settings_CallbackFunctionPointer; + int ccsm_drv_set_pll_dynamic_settings_CallbackCalls; + CMOCK_MEM_INDEX_TYPE ccsm_drv_set_pll_dynamic_settings_CallInstance; + char ccsm_drv_get_dm_configuration_IgnoreBool; + int ccsm_drv_get_dm_configuration_FinalReturn; + char ccsm_drv_get_dm_configuration_CallbackBool; + CMOCK_ccsm_drv_get_dm_configuration_CALLBACK ccsm_drv_get_dm_configuration_CallbackFunctionPointer; + int ccsm_drv_get_dm_configuration_CallbackCalls; + CMOCK_MEM_INDEX_TYPE ccsm_drv_get_dm_configuration_CallInstance; + char ccsm_drv_get_dm_telemetry_IgnoreBool; + int ccsm_drv_get_dm_telemetry_FinalReturn; + char ccsm_drv_get_dm_telemetry_CallbackBool; + CMOCK_ccsm_drv_get_dm_telemetry_CALLBACK ccsm_drv_get_dm_telemetry_CallbackFunctionPointer; + int ccsm_drv_get_dm_telemetry_CallbackCalls; + CMOCK_MEM_INDEX_TYPE ccsm_drv_get_dm_telemetry_CallInstance; + char ccsm_drv_set_dm_configuration_IgnoreBool; + int ccsm_drv_set_dm_configuration_FinalReturn; + char ccsm_drv_set_dm_configuration_CallbackBool; + CMOCK_ccsm_drv_set_dm_configuration_CALLBACK ccsm_drv_set_dm_configuration_CallbackFunctionPointer; + int ccsm_drv_set_dm_configuration_CallbackCalls; + CMOCK_MEM_INDEX_TYPE ccsm_drv_set_dm_configuration_CallInstance; + char ccsm_drv_get_mod_configuration_IgnoreBool; + int ccsm_drv_get_mod_configuration_FinalReturn; + char ccsm_drv_get_mod_configuration_CallbackBool; + CMOCK_ccsm_drv_get_mod_configuration_CALLBACK ccsm_drv_get_mod_configuration_CallbackFunctionPointer; + int ccsm_drv_get_mod_configuration_CallbackCalls; + CMOCK_MEM_INDEX_TYPE ccsm_drv_get_mod_configuration_CallInstance; + char ccsm_drv_set_mod_configuration_IgnoreBool; + int ccsm_drv_set_mod_configuration_FinalReturn; + char ccsm_drv_set_mod_configuration_CallbackBool; + CMOCK_ccsm_drv_set_mod_configuration_CALLBACK ccsm_drv_set_mod_configuration_CallbackFunctionPointer; + int ccsm_drv_set_mod_configuration_CallbackCalls; + CMOCK_MEM_INDEX_TYPE ccsm_drv_set_mod_configuration_CallInstance; + char ccsm_drv_is_irq_error_clear_IgnoreBool; + bool ccsm_drv_is_irq_error_clear_FinalReturn; + char ccsm_drv_is_irq_error_clear_CallbackBool; + CMOCK_ccsm_drv_is_irq_error_clear_CALLBACK ccsm_drv_is_irq_error_clear_CallbackFunctionPointer; + int ccsm_drv_is_irq_error_clear_CallbackCalls; + CMOCK_MEM_INDEX_TYPE ccsm_drv_is_irq_error_clear_CallInstance; + char ccsm_drv_get_clear_irq_error_IgnoreBool; + int ccsm_drv_get_clear_irq_error_FinalReturn; + char ccsm_drv_get_clear_irq_error_CallbackBool; + CMOCK_ccsm_drv_get_clear_irq_error_CALLBACK ccsm_drv_get_clear_irq_error_CallbackFunctionPointer; + int ccsm_drv_get_clear_irq_error_CallbackCalls; + CMOCK_MEM_INDEX_TYPE ccsm_drv_get_clear_irq_error_CallInstance; + char ccsm_drv_is_irq_status_clear_IgnoreBool; + bool ccsm_drv_is_irq_status_clear_FinalReturn; + char ccsm_drv_is_irq_status_clear_CallbackBool; + CMOCK_ccsm_drv_is_irq_status_clear_CALLBACK ccsm_drv_is_irq_status_clear_CallbackFunctionPointer; + int ccsm_drv_is_irq_status_clear_CallbackCalls; + CMOCK_MEM_INDEX_TYPE ccsm_drv_is_irq_status_clear_CallInstance; + char ccsm_drv_get_clear_irq_status_IgnoreBool; + int ccsm_drv_get_clear_irq_status_FinalReturn; + char ccsm_drv_get_clear_irq_status_CallbackBool; + CMOCK_ccsm_drv_get_clear_irq_status_CALLBACK ccsm_drv_get_clear_irq_status_CallbackFunctionPointer; + int ccsm_drv_get_clear_irq_status_CallbackCalls; + CMOCK_MEM_INDEX_TYPE ccsm_drv_get_clear_irq_status_CallInstance; + char ccsm_drv_is_request_complete_IgnoreBool; + bool ccsm_drv_is_request_complete_FinalReturn; + char ccsm_drv_is_request_complete_CallbackBool; + CMOCK_ccsm_drv_is_request_complete_CALLBACK ccsm_drv_is_request_complete_CallbackFunctionPointer; + int ccsm_drv_is_request_complete_CallbackCalls; + CMOCK_MEM_INDEX_TYPE ccsm_drv_is_request_complete_CallInstance; + char ccsm_drv_set_request_IgnoreBool; + int ccsm_drv_set_request_FinalReturn; + char ccsm_drv_set_request_CallbackBool; + CMOCK_ccsm_drv_set_request_CALLBACK ccsm_drv_set_request_CallbackFunctionPointer; + int ccsm_drv_set_request_CallbackCalls; + CMOCK_MEM_INDEX_TYPE ccsm_drv_set_request_CallInstance; + char ccsm_drv_clear_request_IgnoreBool; + int ccsm_drv_clear_request_FinalReturn; + char ccsm_drv_clear_request_CallbackBool; + CMOCK_ccsm_drv_clear_request_CALLBACK ccsm_drv_clear_request_CallbackFunctionPointer; + int ccsm_drv_clear_request_CallbackCalls; + CMOCK_MEM_INDEX_TYPE ccsm_drv_clear_request_CallInstance; +} Mock; + +extern jmp_buf AbortFrame; + +void Mockmod_ccsm_extra_Verify(void) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_MEM_INDEX_TYPE call_instance; + call_instance = Mock.ccsm_drv_get_pll_static_settings_CallInstance; + if (Mock.ccsm_drv_get_pll_static_settings_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_ccsm_drv_get_pll_static_settings); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.ccsm_drv_get_pll_static_settings_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance; + if (Mock.ccsm_drv_get_pll_dynamic_settings_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_ccsm_drv_get_pll_dynamic_settings); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.ccsm_drv_get_pll_dynamic_settings_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.ccsm_drv_set_pll_static_settings_CallInstance; + if (Mock.ccsm_drv_set_pll_static_settings_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_ccsm_drv_set_pll_static_settings); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.ccsm_drv_set_pll_static_settings_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.ccsm_drv_set_pll_dynamic_settings_CallInstance; + if (Mock.ccsm_drv_set_pll_dynamic_settings_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_ccsm_drv_set_pll_dynamic_settings); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.ccsm_drv_set_pll_dynamic_settings_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.ccsm_drv_get_dm_configuration_CallInstance; + if (Mock.ccsm_drv_get_dm_configuration_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_ccsm_drv_get_dm_configuration); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.ccsm_drv_get_dm_configuration_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.ccsm_drv_get_dm_telemetry_CallInstance; + if (Mock.ccsm_drv_get_dm_telemetry_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_ccsm_drv_get_dm_telemetry); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.ccsm_drv_get_dm_telemetry_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.ccsm_drv_set_dm_configuration_CallInstance; + if (Mock.ccsm_drv_set_dm_configuration_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_ccsm_drv_set_dm_configuration); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.ccsm_drv_set_dm_configuration_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.ccsm_drv_get_mod_configuration_CallInstance; + if (Mock.ccsm_drv_get_mod_configuration_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_ccsm_drv_get_mod_configuration); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.ccsm_drv_get_mod_configuration_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.ccsm_drv_set_mod_configuration_CallInstance; + if (Mock.ccsm_drv_set_mod_configuration_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_ccsm_drv_set_mod_configuration); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.ccsm_drv_set_mod_configuration_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.ccsm_drv_is_irq_error_clear_CallInstance; + if (Mock.ccsm_drv_is_irq_error_clear_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_ccsm_drv_is_irq_error_clear); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.ccsm_drv_is_irq_error_clear_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.ccsm_drv_get_clear_irq_error_CallInstance; + if (Mock.ccsm_drv_get_clear_irq_error_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_ccsm_drv_get_clear_irq_error); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.ccsm_drv_get_clear_irq_error_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.ccsm_drv_is_irq_status_clear_CallInstance; + if (Mock.ccsm_drv_is_irq_status_clear_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_ccsm_drv_is_irq_status_clear); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.ccsm_drv_is_irq_status_clear_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.ccsm_drv_get_clear_irq_status_CallInstance; + if (Mock.ccsm_drv_get_clear_irq_status_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_ccsm_drv_get_clear_irq_status); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.ccsm_drv_get_clear_irq_status_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.ccsm_drv_is_request_complete_CallInstance; + if (Mock.ccsm_drv_is_request_complete_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_ccsm_drv_is_request_complete); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.ccsm_drv_is_request_complete_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.ccsm_drv_set_request_CallInstance; + if (Mock.ccsm_drv_set_request_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_ccsm_drv_set_request); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.ccsm_drv_set_request_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } + call_instance = Mock.ccsm_drv_clear_request_CallInstance; + if (Mock.ccsm_drv_clear_request_IgnoreBool) + call_instance = CMOCK_GUTS_NONE; + if (CMOCK_GUTS_NONE != call_instance) + { + UNITY_SET_DETAIL(CMockString_ccsm_drv_clear_request); + UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess); + } + if (Mock.ccsm_drv_clear_request_CallbackFunctionPointer != NULL) + { + call_instance = CMOCK_GUTS_NONE; + (void)call_instance; + } +} + +void Mockmod_ccsm_extra_Init(void) +{ + Mockmod_ccsm_extra_Destroy(); +} + +void Mockmod_ccsm_extra_Destroy(void) +{ + CMock_Guts_MemFreeAll(); + memset(&Mock, 0, sizeof(Mock)); +} + +int ccsm_drv_get_pll_static_settings(struct ccsm_reg* reg, enum mod_ccsm_pll_static_select pll_select, uint32_t* config) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_ccsm_drv_get_pll_static_settings); + cmock_call_instance = (CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ccsm_drv_get_pll_static_settings_CallInstance); + Mock.ccsm_drv_get_pll_static_settings_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_get_pll_static_settings_CallInstance); + if (Mock.ccsm_drv_get_pll_static_settings_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.ccsm_drv_get_pll_static_settings_FinalReturn; + Mock.ccsm_drv_get_pll_static_settings_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.ccsm_drv_get_pll_static_settings_CallbackBool && + Mock.ccsm_drv_get_pll_static_settings_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.ccsm_drv_get_pll_static_settings_CallbackFunctionPointer(reg, pll_select, config, Mock.ccsm_drv_get_pll_static_settings_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_reg) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_pll_static_settings,CMockString_reg); + if (cmock_call_instance->Expected_reg == NULL) + { UNITY_TEST_ASSERT_NULL(reg, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_reg), (void*)(reg), sizeof(struct ccsm_reg), cmock_call_instance->Expected_reg_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pll_select) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_pll_static_settings,CMockString_pll_select); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pll_select), (void*)(&pll_select), sizeof(enum mod_ccsm_pll_static_select), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_config) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_pll_static_settings,CMockString_config); + if (cmock_call_instance->Expected_config == NULL) + { UNITY_TEST_ASSERT_NULL(config, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_config, config, cmock_call_instance->Expected_config_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.ccsm_drv_get_pll_static_settings_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.ccsm_drv_get_pll_static_settings_CallbackFunctionPointer(reg, pll_select, config, Mock.ccsm_drv_get_pll_static_settings_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_reg_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(reg, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)reg, (void*)cmock_call_instance->ReturnThruPtr_reg_Val, + cmock_call_instance->ReturnThruPtr_reg_Size); + } + if (cmock_call_instance->ReturnThruPtr_config_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(config, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)config, (void*)cmock_call_instance->ReturnThruPtr_config_Val, + cmock_call_instance->ReturnThruPtr_config_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_ccsm_drv_get_pll_static_settings(CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_pll_static_select pll_select, uint32_t* config, int config_Depth); +void CMockExpectParameters_ccsm_drv_get_pll_static_settings(CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_pll_static_select pll_select, uint32_t* config, int config_Depth) +{ + cmock_call_instance->Expected_reg = reg; + cmock_call_instance->Expected_reg_Depth = reg_Depth; + cmock_call_instance->IgnoreArg_reg = 0; + cmock_call_instance->ReturnThruPtr_reg_Used = 0; + memcpy((void*)(&cmock_call_instance->Expected_pll_select), (void*)(&pll_select), + sizeof(enum mod_ccsm_pll_static_select[sizeof(pll_select) == sizeof(enum mod_ccsm_pll_static_select) ? 1 : -1])); /* add enum mod_ccsm_pll_static_select to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pll_select = 0; + cmock_call_instance->Expected_config = config; + cmock_call_instance->Expected_config_Depth = config_Depth; + cmock_call_instance->IgnoreArg_config = 0; + cmock_call_instance->ReturnThruPtr_config_Used = 0; +} + +void ccsm_drv_get_pll_static_settings_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_static_settings_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.ccsm_drv_get_pll_static_settings_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_pll_static_settings_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_pll_static_settings_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.ccsm_drv_get_pll_static_settings_IgnoreBool = (char)1; +} + +void ccsm_drv_get_pll_static_settings_CMockStopIgnore(void) +{ + if(Mock.ccsm_drv_get_pll_static_settings_IgnoreBool) + Mock.ccsm_drv_get_pll_static_settings_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_get_pll_static_settings_CallInstance); + Mock.ccsm_drv_get_pll_static_settings_IgnoreBool = (char)0; +} + +void ccsm_drv_get_pll_static_settings_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_static_settings_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.ccsm_drv_get_pll_static_settings_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_pll_static_settings_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_pll_static_settings_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 ccsm_drv_get_pll_static_settings_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, enum mod_ccsm_pll_static_select pll_select, uint32_t* config, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_static_settings_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.ccsm_drv_get_pll_static_settings_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_pll_static_settings_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_pll_static_settings_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_get_pll_static_settings(cmock_call_instance, reg, 1, pll_select, config, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_get_pll_static_settings_AddCallback(CMOCK_ccsm_drv_get_pll_static_settings_CALLBACK Callback) +{ + Mock.ccsm_drv_get_pll_static_settings_IgnoreBool = (char)0; + Mock.ccsm_drv_get_pll_static_settings_CallbackBool = (char)1; + Mock.ccsm_drv_get_pll_static_settings_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_get_pll_static_settings_Stub(CMOCK_ccsm_drv_get_pll_static_settings_CALLBACK Callback) +{ + Mock.ccsm_drv_get_pll_static_settings_IgnoreBool = (char)0; + Mock.ccsm_drv_get_pll_static_settings_CallbackBool = (char)0; + Mock.ccsm_drv_get_pll_static_settings_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_get_pll_static_settings_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_pll_static_select pll_select, uint32_t* config, int config_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_static_settings_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.ccsm_drv_get_pll_static_settings_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_pll_static_settings_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_pll_static_settings_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_get_pll_static_settings(cmock_call_instance, reg, reg_Depth, pll_select, config, config_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_get_pll_static_settings_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_pll_static_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_reg_Used = 1; + cmock_call_instance->ReturnThruPtr_reg_Val = reg; + cmock_call_instance->ReturnThruPtr_reg_Size = cmock_size; +} + +void ccsm_drv_get_pll_static_settings_CMockReturnMemThruPtr_config(UNITY_LINE_TYPE cmock_line, uint32_t* config, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_pll_static_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_config_Used = 1; + cmock_call_instance->ReturnThruPtr_config_Val = config; + cmock_call_instance->ReturnThruPtr_config_Size = cmock_size; +} + +void ccsm_drv_get_pll_static_settings_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_pll_static_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reg = 1; +} + +void ccsm_drv_get_pll_static_settings_CMockIgnoreArg_pll_select(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_pll_static_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pll_select = 1; +} + +void ccsm_drv_get_pll_static_settings_CMockIgnoreArg_config(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_static_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_pll_static_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_config = 1; +} + +int ccsm_drv_get_pll_dynamic_settings(struct ccsm_reg* reg, enum mod_ccsm_pll_dynamic_select pll_select, uint32_t* config0, uint32_t* config1) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_ccsm_drv_get_pll_dynamic_settings); + cmock_call_instance = (CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance); + Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance); + if (Mock.ccsm_drv_get_pll_dynamic_settings_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.ccsm_drv_get_pll_dynamic_settings_FinalReturn; + Mock.ccsm_drv_get_pll_dynamic_settings_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.ccsm_drv_get_pll_dynamic_settings_CallbackBool && + Mock.ccsm_drv_get_pll_dynamic_settings_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.ccsm_drv_get_pll_dynamic_settings_CallbackFunctionPointer(reg, pll_select, config0, config1, Mock.ccsm_drv_get_pll_dynamic_settings_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_reg) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_pll_dynamic_settings,CMockString_reg); + if (cmock_call_instance->Expected_reg == NULL) + { UNITY_TEST_ASSERT_NULL(reg, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_reg), (void*)(reg), sizeof(struct ccsm_reg), cmock_call_instance->Expected_reg_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pll_select) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_pll_dynamic_settings,CMockString_pll_select); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pll_select), (void*)(&pll_select), sizeof(enum mod_ccsm_pll_dynamic_select), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_config0) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_pll_dynamic_settings,CMockString_config0); + if (cmock_call_instance->Expected_config0 == NULL) + { UNITY_TEST_ASSERT_NULL(config0, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_config0, config0, cmock_call_instance->Expected_config0_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_config1) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_pll_dynamic_settings,CMockString_config1); + if (cmock_call_instance->Expected_config1 == NULL) + { UNITY_TEST_ASSERT_NULL(config1, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_config1, config1, cmock_call_instance->Expected_config1_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.ccsm_drv_get_pll_dynamic_settings_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.ccsm_drv_get_pll_dynamic_settings_CallbackFunctionPointer(reg, pll_select, config0, config1, Mock.ccsm_drv_get_pll_dynamic_settings_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_reg_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(reg, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)reg, (void*)cmock_call_instance->ReturnThruPtr_reg_Val, + cmock_call_instance->ReturnThruPtr_reg_Size); + } + if (cmock_call_instance->ReturnThruPtr_config0_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(config0, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)config0, (void*)cmock_call_instance->ReturnThruPtr_config0_Val, + cmock_call_instance->ReturnThruPtr_config0_Size); + } + if (cmock_call_instance->ReturnThruPtr_config1_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(config1, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)config1, (void*)cmock_call_instance->ReturnThruPtr_config1_Val, + cmock_call_instance->ReturnThruPtr_config1_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_ccsm_drv_get_pll_dynamic_settings(CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_pll_dynamic_select pll_select, uint32_t* config0, int config0_Depth, uint32_t* config1, int config1_Depth); +void CMockExpectParameters_ccsm_drv_get_pll_dynamic_settings(CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_pll_dynamic_select pll_select, uint32_t* config0, int config0_Depth, uint32_t* config1, int config1_Depth) +{ + cmock_call_instance->Expected_reg = reg; + cmock_call_instance->Expected_reg_Depth = reg_Depth; + cmock_call_instance->IgnoreArg_reg = 0; + cmock_call_instance->ReturnThruPtr_reg_Used = 0; + memcpy((void*)(&cmock_call_instance->Expected_pll_select), (void*)(&pll_select), + sizeof(enum mod_ccsm_pll_dynamic_select[sizeof(pll_select) == sizeof(enum mod_ccsm_pll_dynamic_select) ? 1 : -1])); /* add enum mod_ccsm_pll_dynamic_select to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pll_select = 0; + cmock_call_instance->Expected_config0 = config0; + cmock_call_instance->Expected_config0_Depth = config0_Depth; + cmock_call_instance->IgnoreArg_config0 = 0; + cmock_call_instance->ReturnThruPtr_config0_Used = 0; + cmock_call_instance->Expected_config1 = config1; + cmock_call_instance->Expected_config1_Depth = config1_Depth; + cmock_call_instance->IgnoreArg_config1 = 0; + cmock_call_instance->ReturnThruPtr_config1_Used = 0; +} + +void ccsm_drv_get_pll_dynamic_settings_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_dynamic_settings_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.ccsm_drv_get_pll_dynamic_settings_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_pll_dynamic_settings_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.ccsm_drv_get_pll_dynamic_settings_IgnoreBool = (char)1; +} + +void ccsm_drv_get_pll_dynamic_settings_CMockStopIgnore(void) +{ + if(Mock.ccsm_drv_get_pll_dynamic_settings_IgnoreBool) + Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance); + Mock.ccsm_drv_get_pll_dynamic_settings_IgnoreBool = (char)0; +} + +void ccsm_drv_get_pll_dynamic_settings_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_dynamic_settings_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.ccsm_drv_get_pll_dynamic_settings_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_pll_dynamic_settings_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 ccsm_drv_get_pll_dynamic_settings_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, enum mod_ccsm_pll_dynamic_select pll_select, uint32_t* config0, uint32_t* config1, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_dynamic_settings_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.ccsm_drv_get_pll_dynamic_settings_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_pll_dynamic_settings_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_get_pll_dynamic_settings(cmock_call_instance, reg, 1, pll_select, config0, 1, config1, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_get_pll_dynamic_settings_AddCallback(CMOCK_ccsm_drv_get_pll_dynamic_settings_CALLBACK Callback) +{ + Mock.ccsm_drv_get_pll_dynamic_settings_IgnoreBool = (char)0; + Mock.ccsm_drv_get_pll_dynamic_settings_CallbackBool = (char)1; + Mock.ccsm_drv_get_pll_dynamic_settings_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_get_pll_dynamic_settings_Stub(CMOCK_ccsm_drv_get_pll_dynamic_settings_CALLBACK Callback) +{ + Mock.ccsm_drv_get_pll_dynamic_settings_IgnoreBool = (char)0; + Mock.ccsm_drv_get_pll_dynamic_settings_CallbackBool = (char)0; + Mock.ccsm_drv_get_pll_dynamic_settings_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_get_pll_dynamic_settings_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_pll_dynamic_select pll_select, uint32_t* config0, int config0_Depth, uint32_t* config1, int config1_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_dynamic_settings_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.ccsm_drv_get_pll_dynamic_settings_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_pll_dynamic_settings_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_get_pll_dynamic_settings(cmock_call_instance, reg, reg_Depth, pll_select, config0, config0_Depth, config1, config1_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_get_pll_dynamic_settings_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_reg_Used = 1; + cmock_call_instance->ReturnThruPtr_reg_Val = reg; + cmock_call_instance->ReturnThruPtr_reg_Size = cmock_size; +} + +void ccsm_drv_get_pll_dynamic_settings_CMockReturnMemThruPtr_config0(UNITY_LINE_TYPE cmock_line, uint32_t* config0, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_config0_Used = 1; + cmock_call_instance->ReturnThruPtr_config0_Val = config0; + cmock_call_instance->ReturnThruPtr_config0_Size = cmock_size; +} + +void ccsm_drv_get_pll_dynamic_settings_CMockReturnMemThruPtr_config1(UNITY_LINE_TYPE cmock_line, uint32_t* config1, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_config1_Used = 1; + cmock_call_instance->ReturnThruPtr_config1_Val = config1; + cmock_call_instance->ReturnThruPtr_config1_Size = cmock_size; +} + +void ccsm_drv_get_pll_dynamic_settings_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reg = 1; +} + +void ccsm_drv_get_pll_dynamic_settings_CMockIgnoreArg_pll_select(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pll_select = 1; +} + +void ccsm_drv_get_pll_dynamic_settings_CMockIgnoreArg_config0(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_config0 = 1; +} + +void ccsm_drv_get_pll_dynamic_settings_CMockIgnoreArg_config1(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_pll_dynamic_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_pll_dynamic_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_config1 = 1; +} + +int ccsm_drv_set_pll_static_settings(struct ccsm_reg* reg, enum mod_ccsm_pll_static_select pll_select, uint32_t config) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_ccsm_drv_set_pll_static_settings); + cmock_call_instance = (CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ccsm_drv_set_pll_static_settings_CallInstance); + Mock.ccsm_drv_set_pll_static_settings_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_set_pll_static_settings_CallInstance); + if (Mock.ccsm_drv_set_pll_static_settings_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.ccsm_drv_set_pll_static_settings_FinalReturn; + Mock.ccsm_drv_set_pll_static_settings_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.ccsm_drv_set_pll_static_settings_CallbackBool && + Mock.ccsm_drv_set_pll_static_settings_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.ccsm_drv_set_pll_static_settings_CallbackFunctionPointer(reg, pll_select, config, Mock.ccsm_drv_set_pll_static_settings_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_reg) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_set_pll_static_settings,CMockString_reg); + if (cmock_call_instance->Expected_reg == NULL) + { UNITY_TEST_ASSERT_NULL(reg, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_reg), (void*)(reg), sizeof(struct ccsm_reg), cmock_call_instance->Expected_reg_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pll_select) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_set_pll_static_settings,CMockString_pll_select); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pll_select), (void*)(&pll_select), sizeof(enum mod_ccsm_pll_static_select), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_config) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_set_pll_static_settings,CMockString_config); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_config, config, cmock_line, CMockStringMismatch); + } + } + if (Mock.ccsm_drv_set_pll_static_settings_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.ccsm_drv_set_pll_static_settings_CallbackFunctionPointer(reg, pll_select, config, Mock.ccsm_drv_set_pll_static_settings_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_reg_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(reg, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)reg, (void*)cmock_call_instance->ReturnThruPtr_reg_Val, + cmock_call_instance->ReturnThruPtr_reg_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_ccsm_drv_set_pll_static_settings(CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_pll_static_select pll_select, uint32_t config); +void CMockExpectParameters_ccsm_drv_set_pll_static_settings(CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_pll_static_select pll_select, uint32_t config) +{ + cmock_call_instance->Expected_reg = reg; + cmock_call_instance->Expected_reg_Depth = reg_Depth; + cmock_call_instance->IgnoreArg_reg = 0; + cmock_call_instance->ReturnThruPtr_reg_Used = 0; + memcpy((void*)(&cmock_call_instance->Expected_pll_select), (void*)(&pll_select), + sizeof(enum mod_ccsm_pll_static_select[sizeof(pll_select) == sizeof(enum mod_ccsm_pll_static_select) ? 1 : -1])); /* add enum mod_ccsm_pll_static_select to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pll_select = 0; + cmock_call_instance->Expected_config = config; + cmock_call_instance->IgnoreArg_config = 0; +} + +void ccsm_drv_set_pll_static_settings_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_static_settings_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.ccsm_drv_set_pll_static_settings_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_pll_static_settings_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_pll_static_settings_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.ccsm_drv_set_pll_static_settings_IgnoreBool = (char)1; +} + +void ccsm_drv_set_pll_static_settings_CMockStopIgnore(void) +{ + if(Mock.ccsm_drv_set_pll_static_settings_IgnoreBool) + Mock.ccsm_drv_set_pll_static_settings_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_set_pll_static_settings_CallInstance); + Mock.ccsm_drv_set_pll_static_settings_IgnoreBool = (char)0; +} + +void ccsm_drv_set_pll_static_settings_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_static_settings_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.ccsm_drv_set_pll_static_settings_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_pll_static_settings_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_pll_static_settings_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 ccsm_drv_set_pll_static_settings_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, enum mod_ccsm_pll_static_select pll_select, uint32_t config, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_static_settings_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.ccsm_drv_set_pll_static_settings_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_pll_static_settings_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_pll_static_settings_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_set_pll_static_settings(cmock_call_instance, reg, 1, pll_select, config); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_set_pll_static_settings_AddCallback(CMOCK_ccsm_drv_set_pll_static_settings_CALLBACK Callback) +{ + Mock.ccsm_drv_set_pll_static_settings_IgnoreBool = (char)0; + Mock.ccsm_drv_set_pll_static_settings_CallbackBool = (char)1; + Mock.ccsm_drv_set_pll_static_settings_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_set_pll_static_settings_Stub(CMOCK_ccsm_drv_set_pll_static_settings_CALLBACK Callback) +{ + Mock.ccsm_drv_set_pll_static_settings_IgnoreBool = (char)0; + Mock.ccsm_drv_set_pll_static_settings_CallbackBool = (char)0; + Mock.ccsm_drv_set_pll_static_settings_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_set_pll_static_settings_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_pll_static_select pll_select, uint32_t config, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_static_settings_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.ccsm_drv_set_pll_static_settings_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_pll_static_settings_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_pll_static_settings_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_set_pll_static_settings(cmock_call_instance, reg, reg_Depth, pll_select, config); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_set_pll_static_settings_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size) +{ + CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_pll_static_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_reg_Used = 1; + cmock_call_instance->ReturnThruPtr_reg_Val = reg; + cmock_call_instance->ReturnThruPtr_reg_Size = cmock_size; +} + +void ccsm_drv_set_pll_static_settings_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_pll_static_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reg = 1; +} + +void ccsm_drv_set_pll_static_settings_CMockIgnoreArg_pll_select(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_pll_static_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pll_select = 1; +} + +void ccsm_drv_set_pll_static_settings_CMockIgnoreArg_config(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_static_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_pll_static_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_config = 1; +} + +int ccsm_drv_set_pll_dynamic_settings(struct ccsm_reg* reg, enum mod_ccsm_pll_dynamic_select pll_select, uint32_t config0, uint32_t config1) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_ccsm_drv_set_pll_dynamic_settings); + cmock_call_instance = (CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ccsm_drv_set_pll_dynamic_settings_CallInstance); + Mock.ccsm_drv_set_pll_dynamic_settings_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_set_pll_dynamic_settings_CallInstance); + if (Mock.ccsm_drv_set_pll_dynamic_settings_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.ccsm_drv_set_pll_dynamic_settings_FinalReturn; + Mock.ccsm_drv_set_pll_dynamic_settings_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.ccsm_drv_set_pll_dynamic_settings_CallbackBool && + Mock.ccsm_drv_set_pll_dynamic_settings_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.ccsm_drv_set_pll_dynamic_settings_CallbackFunctionPointer(reg, pll_select, config0, config1, Mock.ccsm_drv_set_pll_dynamic_settings_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_reg) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_set_pll_dynamic_settings,CMockString_reg); + if (cmock_call_instance->Expected_reg == NULL) + { UNITY_TEST_ASSERT_NULL(reg, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_reg), (void*)(reg), sizeof(struct ccsm_reg), cmock_call_instance->Expected_reg_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_pll_select) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_set_pll_dynamic_settings,CMockString_pll_select); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_pll_select), (void*)(&pll_select), sizeof(enum mod_ccsm_pll_dynamic_select), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_config0) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_set_pll_dynamic_settings,CMockString_config0); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_config0, config0, cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_config1) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_set_pll_dynamic_settings,CMockString_config1); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_config1, config1, cmock_line, CMockStringMismatch); + } + } + if (Mock.ccsm_drv_set_pll_dynamic_settings_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.ccsm_drv_set_pll_dynamic_settings_CallbackFunctionPointer(reg, pll_select, config0, config1, Mock.ccsm_drv_set_pll_dynamic_settings_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_reg_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(reg, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)reg, (void*)cmock_call_instance->ReturnThruPtr_reg_Val, + cmock_call_instance->ReturnThruPtr_reg_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_ccsm_drv_set_pll_dynamic_settings(CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_pll_dynamic_select pll_select, uint32_t config0, uint32_t config1); +void CMockExpectParameters_ccsm_drv_set_pll_dynamic_settings(CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_pll_dynamic_select pll_select, uint32_t config0, uint32_t config1) +{ + cmock_call_instance->Expected_reg = reg; + cmock_call_instance->Expected_reg_Depth = reg_Depth; + cmock_call_instance->IgnoreArg_reg = 0; + cmock_call_instance->ReturnThruPtr_reg_Used = 0; + memcpy((void*)(&cmock_call_instance->Expected_pll_select), (void*)(&pll_select), + sizeof(enum mod_ccsm_pll_dynamic_select[sizeof(pll_select) == sizeof(enum mod_ccsm_pll_dynamic_select) ? 1 : -1])); /* add enum mod_ccsm_pll_dynamic_select to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_pll_select = 0; + cmock_call_instance->Expected_config0 = config0; + cmock_call_instance->IgnoreArg_config0 = 0; + cmock_call_instance->Expected_config1 = config1; + cmock_call_instance->IgnoreArg_config1 = 0; +} + +void ccsm_drv_set_pll_dynamic_settings_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_dynamic_settings_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.ccsm_drv_set_pll_dynamic_settings_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_pll_dynamic_settings_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_pll_dynamic_settings_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.ccsm_drv_set_pll_dynamic_settings_IgnoreBool = (char)1; +} + +void ccsm_drv_set_pll_dynamic_settings_CMockStopIgnore(void) +{ + if(Mock.ccsm_drv_set_pll_dynamic_settings_IgnoreBool) + Mock.ccsm_drv_set_pll_dynamic_settings_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_set_pll_dynamic_settings_CallInstance); + Mock.ccsm_drv_set_pll_dynamic_settings_IgnoreBool = (char)0; +} + +void ccsm_drv_set_pll_dynamic_settings_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_dynamic_settings_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.ccsm_drv_set_pll_dynamic_settings_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_pll_dynamic_settings_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_pll_dynamic_settings_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 ccsm_drv_set_pll_dynamic_settings_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, enum mod_ccsm_pll_dynamic_select pll_select, uint32_t config0, uint32_t config1, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_dynamic_settings_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.ccsm_drv_set_pll_dynamic_settings_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_pll_dynamic_settings_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_pll_dynamic_settings_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_set_pll_dynamic_settings(cmock_call_instance, reg, 1, pll_select, config0, config1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_set_pll_dynamic_settings_AddCallback(CMOCK_ccsm_drv_set_pll_dynamic_settings_CALLBACK Callback) +{ + Mock.ccsm_drv_set_pll_dynamic_settings_IgnoreBool = (char)0; + Mock.ccsm_drv_set_pll_dynamic_settings_CallbackBool = (char)1; + Mock.ccsm_drv_set_pll_dynamic_settings_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_set_pll_dynamic_settings_Stub(CMOCK_ccsm_drv_set_pll_dynamic_settings_CALLBACK Callback) +{ + Mock.ccsm_drv_set_pll_dynamic_settings_IgnoreBool = (char)0; + Mock.ccsm_drv_set_pll_dynamic_settings_CallbackBool = (char)0; + Mock.ccsm_drv_set_pll_dynamic_settings_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_set_pll_dynamic_settings_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_pll_dynamic_select pll_select, uint32_t config0, uint32_t config1, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_dynamic_settings_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.ccsm_drv_set_pll_dynamic_settings_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_pll_dynamic_settings_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_pll_dynamic_settings_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_set_pll_dynamic_settings(cmock_call_instance, reg, reg_Depth, pll_select, config0, config1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_set_pll_dynamic_settings_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size) +{ + CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_pll_dynamic_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_reg_Used = 1; + cmock_call_instance->ReturnThruPtr_reg_Val = reg; + cmock_call_instance->ReturnThruPtr_reg_Size = cmock_size; +} + +void ccsm_drv_set_pll_dynamic_settings_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_pll_dynamic_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reg = 1; +} + +void ccsm_drv_set_pll_dynamic_settings_CMockIgnoreArg_pll_select(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_pll_dynamic_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_pll_select = 1; +} + +void ccsm_drv_set_pll_dynamic_settings_CMockIgnoreArg_config0(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_pll_dynamic_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_config0 = 1; +} + +void ccsm_drv_set_pll_dynamic_settings_CMockIgnoreArg_config1(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_pll_dynamic_settings_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_pll_dynamic_settings_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_config1 = 1; +} + +int ccsm_drv_get_dm_configuration(struct ccsm_reg* reg, uint32_t* config) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_ccsm_drv_get_dm_configuration); + cmock_call_instance = (CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ccsm_drv_get_dm_configuration_CallInstance); + Mock.ccsm_drv_get_dm_configuration_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_get_dm_configuration_CallInstance); + if (Mock.ccsm_drv_get_dm_configuration_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.ccsm_drv_get_dm_configuration_FinalReturn; + Mock.ccsm_drv_get_dm_configuration_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.ccsm_drv_get_dm_configuration_CallbackBool && + Mock.ccsm_drv_get_dm_configuration_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.ccsm_drv_get_dm_configuration_CallbackFunctionPointer(reg, config, Mock.ccsm_drv_get_dm_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_reg) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_dm_configuration,CMockString_reg); + if (cmock_call_instance->Expected_reg == NULL) + { UNITY_TEST_ASSERT_NULL(reg, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_reg), (void*)(reg), sizeof(struct ccsm_reg), cmock_call_instance->Expected_reg_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_config) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_dm_configuration,CMockString_config); + if (cmock_call_instance->Expected_config == NULL) + { UNITY_TEST_ASSERT_NULL(config, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_config, config, cmock_call_instance->Expected_config_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.ccsm_drv_get_dm_configuration_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.ccsm_drv_get_dm_configuration_CallbackFunctionPointer(reg, config, Mock.ccsm_drv_get_dm_configuration_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_reg_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(reg, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)reg, (void*)cmock_call_instance->ReturnThruPtr_reg_Val, + cmock_call_instance->ReturnThruPtr_reg_Size); + } + if (cmock_call_instance->ReturnThruPtr_config_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(config, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)config, (void*)cmock_call_instance->ReturnThruPtr_config_Val, + cmock_call_instance->ReturnThruPtr_config_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_ccsm_drv_get_dm_configuration(CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, uint32_t* config, int config_Depth); +void CMockExpectParameters_ccsm_drv_get_dm_configuration(CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, uint32_t* config, int config_Depth) +{ + cmock_call_instance->Expected_reg = reg; + cmock_call_instance->Expected_reg_Depth = reg_Depth; + cmock_call_instance->IgnoreArg_reg = 0; + cmock_call_instance->ReturnThruPtr_reg_Used = 0; + cmock_call_instance->Expected_config = config; + cmock_call_instance->Expected_config_Depth = config_Depth; + cmock_call_instance->IgnoreArg_config = 0; + cmock_call_instance->ReturnThruPtr_config_Used = 0; +} + +void ccsm_drv_get_dm_configuration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_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.ccsm_drv_get_dm_configuration_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_dm_configuration_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_dm_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.ccsm_drv_get_dm_configuration_IgnoreBool = (char)1; +} + +void ccsm_drv_get_dm_configuration_CMockStopIgnore(void) +{ + if(Mock.ccsm_drv_get_dm_configuration_IgnoreBool) + Mock.ccsm_drv_get_dm_configuration_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_get_dm_configuration_CallInstance); + Mock.ccsm_drv_get_dm_configuration_IgnoreBool = (char)0; +} + +void ccsm_drv_get_dm_configuration_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_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.ccsm_drv_get_dm_configuration_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_dm_configuration_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_dm_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 ccsm_drv_get_dm_configuration_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, uint32_t* config, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_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.ccsm_drv_get_dm_configuration_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_dm_configuration_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_dm_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_get_dm_configuration(cmock_call_instance, reg, 1, config, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_get_dm_configuration_AddCallback(CMOCK_ccsm_drv_get_dm_configuration_CALLBACK Callback) +{ + Mock.ccsm_drv_get_dm_configuration_IgnoreBool = (char)0; + Mock.ccsm_drv_get_dm_configuration_CallbackBool = (char)1; + Mock.ccsm_drv_get_dm_configuration_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_get_dm_configuration_Stub(CMOCK_ccsm_drv_get_dm_configuration_CALLBACK Callback) +{ + Mock.ccsm_drv_get_dm_configuration_IgnoreBool = (char)0; + Mock.ccsm_drv_get_dm_configuration_CallbackBool = (char)0; + Mock.ccsm_drv_get_dm_configuration_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_get_dm_configuration_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, uint32_t* config, int config_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_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.ccsm_drv_get_dm_configuration_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_dm_configuration_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_dm_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_get_dm_configuration(cmock_call_instance, reg, reg_Depth, config, config_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_get_dm_configuration_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_dm_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_reg_Used = 1; + cmock_call_instance->ReturnThruPtr_reg_Val = reg; + cmock_call_instance->ReturnThruPtr_reg_Size = cmock_size; +} + +void ccsm_drv_get_dm_configuration_CMockReturnMemThruPtr_config(UNITY_LINE_TYPE cmock_line, uint32_t* config, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_dm_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_config_Used = 1; + cmock_call_instance->ReturnThruPtr_config_Val = config; + cmock_call_instance->ReturnThruPtr_config_Size = cmock_size; +} + +void ccsm_drv_get_dm_configuration_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_dm_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reg = 1; +} + +void ccsm_drv_get_dm_configuration_CMockIgnoreArg_config(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_dm_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_config = 1; +} + +int ccsm_drv_get_dm_telemetry(struct ccsm_reg* reg, uint32_t* telemetry1, uint32_t* telemetry2, uint32_t* telemetry3) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_ccsm_drv_get_dm_telemetry); + cmock_call_instance = (CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ccsm_drv_get_dm_telemetry_CallInstance); + Mock.ccsm_drv_get_dm_telemetry_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_get_dm_telemetry_CallInstance); + if (Mock.ccsm_drv_get_dm_telemetry_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.ccsm_drv_get_dm_telemetry_FinalReturn; + Mock.ccsm_drv_get_dm_telemetry_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.ccsm_drv_get_dm_telemetry_CallbackBool && + Mock.ccsm_drv_get_dm_telemetry_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.ccsm_drv_get_dm_telemetry_CallbackFunctionPointer(reg, telemetry1, telemetry2, telemetry3, Mock.ccsm_drv_get_dm_telemetry_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_reg) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_dm_telemetry,CMockString_reg); + if (cmock_call_instance->Expected_reg == NULL) + { UNITY_TEST_ASSERT_NULL(reg, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_reg), (void*)(reg), sizeof(struct ccsm_reg), cmock_call_instance->Expected_reg_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_telemetry1) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_dm_telemetry,CMockString_telemetry1); + if (cmock_call_instance->Expected_telemetry1 == NULL) + { UNITY_TEST_ASSERT_NULL(telemetry1, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_telemetry1, telemetry1, cmock_call_instance->Expected_telemetry1_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_telemetry2) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_dm_telemetry,CMockString_telemetry2); + if (cmock_call_instance->Expected_telemetry2 == NULL) + { UNITY_TEST_ASSERT_NULL(telemetry2, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_telemetry2, telemetry2, cmock_call_instance->Expected_telemetry2_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_telemetry3) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_dm_telemetry,CMockString_telemetry3); + if (cmock_call_instance->Expected_telemetry3 == NULL) + { UNITY_TEST_ASSERT_NULL(telemetry3, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_telemetry3, telemetry3, cmock_call_instance->Expected_telemetry3_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.ccsm_drv_get_dm_telemetry_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.ccsm_drv_get_dm_telemetry_CallbackFunctionPointer(reg, telemetry1, telemetry2, telemetry3, Mock.ccsm_drv_get_dm_telemetry_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_reg_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(reg, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)reg, (void*)cmock_call_instance->ReturnThruPtr_reg_Val, + cmock_call_instance->ReturnThruPtr_reg_Size); + } + if (cmock_call_instance->ReturnThruPtr_telemetry1_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(telemetry1, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)telemetry1, (void*)cmock_call_instance->ReturnThruPtr_telemetry1_Val, + cmock_call_instance->ReturnThruPtr_telemetry1_Size); + } + if (cmock_call_instance->ReturnThruPtr_telemetry2_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(telemetry2, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)telemetry2, (void*)cmock_call_instance->ReturnThruPtr_telemetry2_Val, + cmock_call_instance->ReturnThruPtr_telemetry2_Size); + } + if (cmock_call_instance->ReturnThruPtr_telemetry3_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(telemetry3, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)telemetry3, (void*)cmock_call_instance->ReturnThruPtr_telemetry3_Val, + cmock_call_instance->ReturnThruPtr_telemetry3_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_ccsm_drv_get_dm_telemetry(CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, uint32_t* telemetry1, int telemetry1_Depth, uint32_t* telemetry2, int telemetry2_Depth, uint32_t* telemetry3, int telemetry3_Depth); +void CMockExpectParameters_ccsm_drv_get_dm_telemetry(CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, uint32_t* telemetry1, int telemetry1_Depth, uint32_t* telemetry2, int telemetry2_Depth, uint32_t* telemetry3, int telemetry3_Depth) +{ + cmock_call_instance->Expected_reg = reg; + cmock_call_instance->Expected_reg_Depth = reg_Depth; + cmock_call_instance->IgnoreArg_reg = 0; + cmock_call_instance->ReturnThruPtr_reg_Used = 0; + cmock_call_instance->Expected_telemetry1 = telemetry1; + cmock_call_instance->Expected_telemetry1_Depth = telemetry1_Depth; + cmock_call_instance->IgnoreArg_telemetry1 = 0; + cmock_call_instance->ReturnThruPtr_telemetry1_Used = 0; + cmock_call_instance->Expected_telemetry2 = telemetry2; + cmock_call_instance->Expected_telemetry2_Depth = telemetry2_Depth; + cmock_call_instance->IgnoreArg_telemetry2 = 0; + cmock_call_instance->ReturnThruPtr_telemetry2_Used = 0; + cmock_call_instance->Expected_telemetry3 = telemetry3; + cmock_call_instance->Expected_telemetry3_Depth = telemetry3_Depth; + cmock_call_instance->IgnoreArg_telemetry3 = 0; + cmock_call_instance->ReturnThruPtr_telemetry3_Used = 0; +} + +void ccsm_drv_get_dm_telemetry_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_telemetry_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.ccsm_drv_get_dm_telemetry_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_dm_telemetry_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_dm_telemetry_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.ccsm_drv_get_dm_telemetry_IgnoreBool = (char)1; +} + +void ccsm_drv_get_dm_telemetry_CMockStopIgnore(void) +{ + if(Mock.ccsm_drv_get_dm_telemetry_IgnoreBool) + Mock.ccsm_drv_get_dm_telemetry_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_get_dm_telemetry_CallInstance); + Mock.ccsm_drv_get_dm_telemetry_IgnoreBool = (char)0; +} + +void ccsm_drv_get_dm_telemetry_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_telemetry_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.ccsm_drv_get_dm_telemetry_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_dm_telemetry_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_dm_telemetry_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 ccsm_drv_get_dm_telemetry_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, uint32_t* telemetry1, uint32_t* telemetry2, uint32_t* telemetry3, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_telemetry_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.ccsm_drv_get_dm_telemetry_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_dm_telemetry_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_dm_telemetry_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_get_dm_telemetry(cmock_call_instance, reg, 1, telemetry1, 1, telemetry2, 1, telemetry3, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_get_dm_telemetry_AddCallback(CMOCK_ccsm_drv_get_dm_telemetry_CALLBACK Callback) +{ + Mock.ccsm_drv_get_dm_telemetry_IgnoreBool = (char)0; + Mock.ccsm_drv_get_dm_telemetry_CallbackBool = (char)1; + Mock.ccsm_drv_get_dm_telemetry_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_get_dm_telemetry_Stub(CMOCK_ccsm_drv_get_dm_telemetry_CALLBACK Callback) +{ + Mock.ccsm_drv_get_dm_telemetry_IgnoreBool = (char)0; + Mock.ccsm_drv_get_dm_telemetry_CallbackBool = (char)0; + Mock.ccsm_drv_get_dm_telemetry_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_get_dm_telemetry_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, uint32_t* telemetry1, int telemetry1_Depth, uint32_t* telemetry2, int telemetry2_Depth, uint32_t* telemetry3, int telemetry3_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_telemetry_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.ccsm_drv_get_dm_telemetry_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_dm_telemetry_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_dm_telemetry_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_get_dm_telemetry(cmock_call_instance, reg, reg_Depth, telemetry1, telemetry1_Depth, telemetry2, telemetry2_Depth, telemetry3, telemetry3_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_dm_telemetry_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_reg_Used = 1; + cmock_call_instance->ReturnThruPtr_reg_Val = reg; + cmock_call_instance->ReturnThruPtr_reg_Size = cmock_size; +} + +void ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_telemetry1(UNITY_LINE_TYPE cmock_line, uint32_t* telemetry1, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_dm_telemetry_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_telemetry1_Used = 1; + cmock_call_instance->ReturnThruPtr_telemetry1_Val = telemetry1; + cmock_call_instance->ReturnThruPtr_telemetry1_Size = cmock_size; +} + +void ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_telemetry2(UNITY_LINE_TYPE cmock_line, uint32_t* telemetry2, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_dm_telemetry_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_telemetry2_Used = 1; + cmock_call_instance->ReturnThruPtr_telemetry2_Val = telemetry2; + cmock_call_instance->ReturnThruPtr_telemetry2_Size = cmock_size; +} + +void ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_telemetry3(UNITY_LINE_TYPE cmock_line, uint32_t* telemetry3, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_dm_telemetry_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_telemetry3_Used = 1; + cmock_call_instance->ReturnThruPtr_telemetry3_Val = telemetry3; + cmock_call_instance->ReturnThruPtr_telemetry3_Size = cmock_size; +} + +void ccsm_drv_get_dm_telemetry_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_dm_telemetry_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reg = 1; +} + +void ccsm_drv_get_dm_telemetry_CMockIgnoreArg_telemetry1(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_dm_telemetry_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_telemetry1 = 1; +} + +void ccsm_drv_get_dm_telemetry_CMockIgnoreArg_telemetry2(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_dm_telemetry_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_telemetry2 = 1; +} + +void ccsm_drv_get_dm_telemetry_CMockIgnoreArg_telemetry3(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_dm_telemetry_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_dm_telemetry_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_telemetry3 = 1; +} + +int ccsm_drv_set_dm_configuration(struct ccsm_reg* reg, uint32_t config) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_ccsm_drv_set_dm_configuration); + cmock_call_instance = (CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ccsm_drv_set_dm_configuration_CallInstance); + Mock.ccsm_drv_set_dm_configuration_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_set_dm_configuration_CallInstance); + if (Mock.ccsm_drv_set_dm_configuration_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.ccsm_drv_set_dm_configuration_FinalReturn; + Mock.ccsm_drv_set_dm_configuration_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.ccsm_drv_set_dm_configuration_CallbackBool && + Mock.ccsm_drv_set_dm_configuration_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.ccsm_drv_set_dm_configuration_CallbackFunctionPointer(reg, config, Mock.ccsm_drv_set_dm_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_reg) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_set_dm_configuration,CMockString_reg); + if (cmock_call_instance->Expected_reg == NULL) + { UNITY_TEST_ASSERT_NULL(reg, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_reg), (void*)(reg), sizeof(struct ccsm_reg), cmock_call_instance->Expected_reg_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_config) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_set_dm_configuration,CMockString_config); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_config, config, cmock_line, CMockStringMismatch); + } + } + if (Mock.ccsm_drv_set_dm_configuration_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.ccsm_drv_set_dm_configuration_CallbackFunctionPointer(reg, config, Mock.ccsm_drv_set_dm_configuration_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_reg_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(reg, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)reg, (void*)cmock_call_instance->ReturnThruPtr_reg_Val, + cmock_call_instance->ReturnThruPtr_reg_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_ccsm_drv_set_dm_configuration(CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, uint32_t config); +void CMockExpectParameters_ccsm_drv_set_dm_configuration(CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, uint32_t config) +{ + cmock_call_instance->Expected_reg = reg; + cmock_call_instance->Expected_reg_Depth = reg_Depth; + cmock_call_instance->IgnoreArg_reg = 0; + cmock_call_instance->ReturnThruPtr_reg_Used = 0; + cmock_call_instance->Expected_config = config; + cmock_call_instance->IgnoreArg_config = 0; +} + +void ccsm_drv_set_dm_configuration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_dm_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.ccsm_drv_set_dm_configuration_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_dm_configuration_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_dm_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.ccsm_drv_set_dm_configuration_IgnoreBool = (char)1; +} + +void ccsm_drv_set_dm_configuration_CMockStopIgnore(void) +{ + if(Mock.ccsm_drv_set_dm_configuration_IgnoreBool) + Mock.ccsm_drv_set_dm_configuration_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_set_dm_configuration_CallInstance); + Mock.ccsm_drv_set_dm_configuration_IgnoreBool = (char)0; +} + +void ccsm_drv_set_dm_configuration_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_dm_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.ccsm_drv_set_dm_configuration_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_dm_configuration_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_dm_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 ccsm_drv_set_dm_configuration_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, uint32_t config, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_dm_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.ccsm_drv_set_dm_configuration_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_dm_configuration_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_dm_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_set_dm_configuration(cmock_call_instance, reg, 1, config); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_set_dm_configuration_AddCallback(CMOCK_ccsm_drv_set_dm_configuration_CALLBACK Callback) +{ + Mock.ccsm_drv_set_dm_configuration_IgnoreBool = (char)0; + Mock.ccsm_drv_set_dm_configuration_CallbackBool = (char)1; + Mock.ccsm_drv_set_dm_configuration_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_set_dm_configuration_Stub(CMOCK_ccsm_drv_set_dm_configuration_CALLBACK Callback) +{ + Mock.ccsm_drv_set_dm_configuration_IgnoreBool = (char)0; + Mock.ccsm_drv_set_dm_configuration_CallbackBool = (char)0; + Mock.ccsm_drv_set_dm_configuration_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_set_dm_configuration_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, uint32_t config, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_dm_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.ccsm_drv_set_dm_configuration_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_dm_configuration_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_dm_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_set_dm_configuration(cmock_call_instance, reg, reg_Depth, config); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_set_dm_configuration_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size) +{ + CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_dm_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_reg_Used = 1; + cmock_call_instance->ReturnThruPtr_reg_Val = reg; + cmock_call_instance->ReturnThruPtr_reg_Size = cmock_size; +} + +void ccsm_drv_set_dm_configuration_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_dm_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reg = 1; +} + +void ccsm_drv_set_dm_configuration_CMockIgnoreArg_config(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_dm_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_dm_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_config = 1; +} + +int ccsm_drv_get_mod_configuration(struct ccsm_reg* reg, enum mod_ccsm_mod_select core_id, uint32_t* config) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_ccsm_drv_get_mod_configuration); + cmock_call_instance = (CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ccsm_drv_get_mod_configuration_CallInstance); + Mock.ccsm_drv_get_mod_configuration_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_get_mod_configuration_CallInstance); + if (Mock.ccsm_drv_get_mod_configuration_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.ccsm_drv_get_mod_configuration_FinalReturn; + Mock.ccsm_drv_get_mod_configuration_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.ccsm_drv_get_mod_configuration_CallbackBool && + Mock.ccsm_drv_get_mod_configuration_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.ccsm_drv_get_mod_configuration_CallbackFunctionPointer(reg, core_id, config, Mock.ccsm_drv_get_mod_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_reg) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_mod_configuration,CMockString_reg); + if (cmock_call_instance->Expected_reg == NULL) + { UNITY_TEST_ASSERT_NULL(reg, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_reg), (void*)(reg), sizeof(struct ccsm_reg), cmock_call_instance->Expected_reg_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_core_id) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_mod_configuration,CMockString_core_id); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_core_id), (void*)(&core_id), sizeof(enum mod_ccsm_mod_select), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_config) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_mod_configuration,CMockString_config); + if (cmock_call_instance->Expected_config == NULL) + { UNITY_TEST_ASSERT_NULL(config, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_config, config, cmock_call_instance->Expected_config_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.ccsm_drv_get_mod_configuration_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.ccsm_drv_get_mod_configuration_CallbackFunctionPointer(reg, core_id, config, Mock.ccsm_drv_get_mod_configuration_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_reg_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(reg, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)reg, (void*)cmock_call_instance->ReturnThruPtr_reg_Val, + cmock_call_instance->ReturnThruPtr_reg_Size); + } + if (cmock_call_instance->ReturnThruPtr_config_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(config, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)config, (void*)cmock_call_instance->ReturnThruPtr_config_Val, + cmock_call_instance->ReturnThruPtr_config_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_ccsm_drv_get_mod_configuration(CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_mod_select core_id, uint32_t* config, int config_Depth); +void CMockExpectParameters_ccsm_drv_get_mod_configuration(CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_mod_select core_id, uint32_t* config, int config_Depth) +{ + cmock_call_instance->Expected_reg = reg; + cmock_call_instance->Expected_reg_Depth = reg_Depth; + cmock_call_instance->IgnoreArg_reg = 0; + cmock_call_instance->ReturnThruPtr_reg_Used = 0; + memcpy((void*)(&cmock_call_instance->Expected_core_id), (void*)(&core_id), + sizeof(enum mod_ccsm_mod_select[sizeof(core_id) == sizeof(enum mod_ccsm_mod_select) ? 1 : -1])); /* add enum mod_ccsm_mod_select to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_core_id = 0; + cmock_call_instance->Expected_config = config; + cmock_call_instance->Expected_config_Depth = config_Depth; + cmock_call_instance->IgnoreArg_config = 0; + cmock_call_instance->ReturnThruPtr_config_Used = 0; +} + +void ccsm_drv_get_mod_configuration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_mod_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.ccsm_drv_get_mod_configuration_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_mod_configuration_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_mod_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.ccsm_drv_get_mod_configuration_IgnoreBool = (char)1; +} + +void ccsm_drv_get_mod_configuration_CMockStopIgnore(void) +{ + if(Mock.ccsm_drv_get_mod_configuration_IgnoreBool) + Mock.ccsm_drv_get_mod_configuration_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_get_mod_configuration_CallInstance); + Mock.ccsm_drv_get_mod_configuration_IgnoreBool = (char)0; +} + +void ccsm_drv_get_mod_configuration_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_mod_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.ccsm_drv_get_mod_configuration_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_mod_configuration_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_mod_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 ccsm_drv_get_mod_configuration_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, enum mod_ccsm_mod_select core_id, uint32_t* config, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_mod_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.ccsm_drv_get_mod_configuration_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_mod_configuration_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_mod_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_get_mod_configuration(cmock_call_instance, reg, 1, core_id, config, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_get_mod_configuration_AddCallback(CMOCK_ccsm_drv_get_mod_configuration_CALLBACK Callback) +{ + Mock.ccsm_drv_get_mod_configuration_IgnoreBool = (char)0; + Mock.ccsm_drv_get_mod_configuration_CallbackBool = (char)1; + Mock.ccsm_drv_get_mod_configuration_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_get_mod_configuration_Stub(CMOCK_ccsm_drv_get_mod_configuration_CALLBACK Callback) +{ + Mock.ccsm_drv_get_mod_configuration_IgnoreBool = (char)0; + Mock.ccsm_drv_get_mod_configuration_CallbackBool = (char)0; + Mock.ccsm_drv_get_mod_configuration_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_get_mod_configuration_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_mod_select core_id, uint32_t* config, int config_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_mod_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.ccsm_drv_get_mod_configuration_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_mod_configuration_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_mod_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_get_mod_configuration(cmock_call_instance, reg, reg_Depth, core_id, config, config_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_get_mod_configuration_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_mod_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_reg_Used = 1; + cmock_call_instance->ReturnThruPtr_reg_Val = reg; + cmock_call_instance->ReturnThruPtr_reg_Size = cmock_size; +} + +void ccsm_drv_get_mod_configuration_CMockReturnMemThruPtr_config(UNITY_LINE_TYPE cmock_line, uint32_t* config, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_mod_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_config_Used = 1; + cmock_call_instance->ReturnThruPtr_config_Val = config; + cmock_call_instance->ReturnThruPtr_config_Size = cmock_size; +} + +void ccsm_drv_get_mod_configuration_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_mod_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reg = 1; +} + +void ccsm_drv_get_mod_configuration_CMockIgnoreArg_core_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_mod_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_core_id = 1; +} + +void ccsm_drv_get_mod_configuration_CMockIgnoreArg_config(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_mod_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_mod_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_config = 1; +} + +int ccsm_drv_set_mod_configuration(struct ccsm_reg* reg, enum mod_ccsm_mod_select core_id, uint32_t config) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_ccsm_drv_set_mod_configuration); + cmock_call_instance = (CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ccsm_drv_set_mod_configuration_CallInstance); + Mock.ccsm_drv_set_mod_configuration_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_set_mod_configuration_CallInstance); + if (Mock.ccsm_drv_set_mod_configuration_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.ccsm_drv_set_mod_configuration_FinalReturn; + Mock.ccsm_drv_set_mod_configuration_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.ccsm_drv_set_mod_configuration_CallbackBool && + Mock.ccsm_drv_set_mod_configuration_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.ccsm_drv_set_mod_configuration_CallbackFunctionPointer(reg, core_id, config, Mock.ccsm_drv_set_mod_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_reg) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_set_mod_configuration,CMockString_reg); + if (cmock_call_instance->Expected_reg == NULL) + { UNITY_TEST_ASSERT_NULL(reg, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_reg), (void*)(reg), sizeof(struct ccsm_reg), cmock_call_instance->Expected_reg_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_core_id) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_set_mod_configuration,CMockString_core_id); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_core_id), (void*)(&core_id), sizeof(enum mod_ccsm_mod_select), cmock_line, CMockStringMismatch); + } + if (!cmock_call_instance->IgnoreArg_config) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_set_mod_configuration,CMockString_config); + UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_config, config, cmock_line, CMockStringMismatch); + } + } + if (Mock.ccsm_drv_set_mod_configuration_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.ccsm_drv_set_mod_configuration_CallbackFunctionPointer(reg, core_id, config, Mock.ccsm_drv_set_mod_configuration_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_reg_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(reg, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)reg, (void*)cmock_call_instance->ReturnThruPtr_reg_Val, + cmock_call_instance->ReturnThruPtr_reg_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_ccsm_drv_set_mod_configuration(CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_mod_select core_id, uint32_t config); +void CMockExpectParameters_ccsm_drv_set_mod_configuration(CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_mod_select core_id, uint32_t config) +{ + cmock_call_instance->Expected_reg = reg; + cmock_call_instance->Expected_reg_Depth = reg_Depth; + cmock_call_instance->IgnoreArg_reg = 0; + cmock_call_instance->ReturnThruPtr_reg_Used = 0; + memcpy((void*)(&cmock_call_instance->Expected_core_id), (void*)(&core_id), + sizeof(enum mod_ccsm_mod_select[sizeof(core_id) == sizeof(enum mod_ccsm_mod_select) ? 1 : -1])); /* add enum mod_ccsm_mod_select to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_core_id = 0; + cmock_call_instance->Expected_config = config; + cmock_call_instance->IgnoreArg_config = 0; +} + +void ccsm_drv_set_mod_configuration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_mod_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.ccsm_drv_set_mod_configuration_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_mod_configuration_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_mod_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.ccsm_drv_set_mod_configuration_IgnoreBool = (char)1; +} + +void ccsm_drv_set_mod_configuration_CMockStopIgnore(void) +{ + if(Mock.ccsm_drv_set_mod_configuration_IgnoreBool) + Mock.ccsm_drv_set_mod_configuration_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_set_mod_configuration_CallInstance); + Mock.ccsm_drv_set_mod_configuration_IgnoreBool = (char)0; +} + +void ccsm_drv_set_mod_configuration_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_mod_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.ccsm_drv_set_mod_configuration_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_mod_configuration_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_mod_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 ccsm_drv_set_mod_configuration_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, enum mod_ccsm_mod_select core_id, uint32_t config, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_mod_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.ccsm_drv_set_mod_configuration_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_mod_configuration_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_mod_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_set_mod_configuration(cmock_call_instance, reg, 1, core_id, config); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_set_mod_configuration_AddCallback(CMOCK_ccsm_drv_set_mod_configuration_CALLBACK Callback) +{ + Mock.ccsm_drv_set_mod_configuration_IgnoreBool = (char)0; + Mock.ccsm_drv_set_mod_configuration_CallbackBool = (char)1; + Mock.ccsm_drv_set_mod_configuration_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_set_mod_configuration_Stub(CMOCK_ccsm_drv_set_mod_configuration_CALLBACK Callback) +{ + Mock.ccsm_drv_set_mod_configuration_IgnoreBool = (char)0; + Mock.ccsm_drv_set_mod_configuration_CallbackBool = (char)0; + Mock.ccsm_drv_set_mod_configuration_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_set_mod_configuration_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_mod_select core_id, uint32_t config, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_mod_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.ccsm_drv_set_mod_configuration_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_mod_configuration_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_mod_configuration_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_set_mod_configuration(cmock_call_instance, reg, reg_Depth, core_id, config); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_set_mod_configuration_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size) +{ + CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_mod_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_reg_Used = 1; + cmock_call_instance->ReturnThruPtr_reg_Val = reg; + cmock_call_instance->ReturnThruPtr_reg_Size = cmock_size; +} + +void ccsm_drv_set_mod_configuration_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_mod_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reg = 1; +} + +void ccsm_drv_set_mod_configuration_CMockIgnoreArg_core_id(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_mod_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_core_id = 1; +} + +void ccsm_drv_set_mod_configuration_CMockIgnoreArg_config(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_mod_configuration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_mod_configuration_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_config = 1; +} + +bool ccsm_drv_is_irq_error_clear(void* reg) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_ccsm_drv_is_irq_error_clear); + cmock_call_instance = (CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ccsm_drv_is_irq_error_clear_CallInstance); + Mock.ccsm_drv_is_irq_error_clear_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_is_irq_error_clear_CallInstance); + if (Mock.ccsm_drv_is_irq_error_clear_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.ccsm_drv_is_irq_error_clear_FinalReturn; + Mock.ccsm_drv_is_irq_error_clear_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.ccsm_drv_is_irq_error_clear_CallbackBool && + Mock.ccsm_drv_is_irq_error_clear_CallbackFunctionPointer != NULL) + { + bool cmock_cb_ret = Mock.ccsm_drv_is_irq_error_clear_CallbackFunctionPointer(reg, Mock.ccsm_drv_is_irq_error_clear_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_reg) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_is_irq_error_clear,CMockString_reg); + if (cmock_call_instance->Expected_reg == NULL) + { UNITY_TEST_ASSERT_NULL(reg, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_reg, reg, cmock_call_instance->Expected_reg_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.ccsm_drv_is_irq_error_clear_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.ccsm_drv_is_irq_error_clear_CallbackFunctionPointer(reg, Mock.ccsm_drv_is_irq_error_clear_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_reg_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(reg, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)reg, (void*)cmock_call_instance->ReturnThruPtr_reg_Val, + cmock_call_instance->ReturnThruPtr_reg_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_ccsm_drv_is_irq_error_clear(CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE* cmock_call_instance, void* reg, int reg_Depth); +void CMockExpectParameters_ccsm_drv_is_irq_error_clear(CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE* cmock_call_instance, void* reg, int reg_Depth) +{ + cmock_call_instance->Expected_reg = reg; + cmock_call_instance->Expected_reg_Depth = reg_Depth; + cmock_call_instance->IgnoreArg_reg = 0; + cmock_call_instance->ReturnThruPtr_reg_Used = 0; +} + +void ccsm_drv_is_irq_error_clear_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE)); + CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_irq_error_clear_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.ccsm_drv_is_irq_error_clear_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_is_irq_error_clear_CallInstance, cmock_guts_index); + Mock.ccsm_drv_is_irq_error_clear_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.ccsm_drv_is_irq_error_clear_IgnoreBool = (char)1; +} + +void ccsm_drv_is_irq_error_clear_CMockStopIgnore(void) +{ + if(Mock.ccsm_drv_is_irq_error_clear_IgnoreBool) + Mock.ccsm_drv_is_irq_error_clear_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_is_irq_error_clear_CallInstance); + Mock.ccsm_drv_is_irq_error_clear_IgnoreBool = (char)0; +} + +void ccsm_drv_is_irq_error_clear_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE)); + CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_irq_error_clear_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.ccsm_drv_is_irq_error_clear_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_is_irq_error_clear_CallInstance, cmock_guts_index); + Mock.ccsm_drv_is_irq_error_clear_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 ccsm_drv_is_irq_error_clear_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, void* reg, bool cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE)); + CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_irq_error_clear_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.ccsm_drv_is_irq_error_clear_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_is_irq_error_clear_CallInstance, cmock_guts_index); + Mock.ccsm_drv_is_irq_error_clear_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_is_irq_error_clear(cmock_call_instance, reg, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_is_irq_error_clear_AddCallback(CMOCK_ccsm_drv_is_irq_error_clear_CALLBACK Callback) +{ + Mock.ccsm_drv_is_irq_error_clear_IgnoreBool = (char)0; + Mock.ccsm_drv_is_irq_error_clear_CallbackBool = (char)1; + Mock.ccsm_drv_is_irq_error_clear_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_is_irq_error_clear_Stub(CMOCK_ccsm_drv_is_irq_error_clear_CALLBACK Callback) +{ + Mock.ccsm_drv_is_irq_error_clear_IgnoreBool = (char)0; + Mock.ccsm_drv_is_irq_error_clear_CallbackBool = (char)0; + Mock.ccsm_drv_is_irq_error_clear_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_is_irq_error_clear_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, void* reg, int reg_Depth, bool cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE)); + CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_irq_error_clear_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.ccsm_drv_is_irq_error_clear_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_is_irq_error_clear_CallInstance, cmock_guts_index); + Mock.ccsm_drv_is_irq_error_clear_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_is_irq_error_clear(cmock_call_instance, reg, reg_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_is_irq_error_clear_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, void* reg, size_t cmock_size) +{ + CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_is_irq_error_clear_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_reg_Used = 1; + cmock_call_instance->ReturnThruPtr_reg_Val = reg; + cmock_call_instance->ReturnThruPtr_reg_Size = cmock_size; +} + +void ccsm_drv_is_irq_error_clear_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_irq_error_clear_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_is_irq_error_clear_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reg = 1; +} + +int ccsm_drv_get_clear_irq_error(struct ccsm_reg* reg, uint32_t* error) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_ccsm_drv_get_clear_irq_error); + cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ccsm_drv_get_clear_irq_error_CallInstance); + Mock.ccsm_drv_get_clear_irq_error_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_get_clear_irq_error_CallInstance); + if (Mock.ccsm_drv_get_clear_irq_error_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.ccsm_drv_get_clear_irq_error_FinalReturn; + Mock.ccsm_drv_get_clear_irq_error_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.ccsm_drv_get_clear_irq_error_CallbackBool && + Mock.ccsm_drv_get_clear_irq_error_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.ccsm_drv_get_clear_irq_error_CallbackFunctionPointer(reg, error, Mock.ccsm_drv_get_clear_irq_error_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_reg) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_clear_irq_error,CMockString_reg); + if (cmock_call_instance->Expected_reg == NULL) + { UNITY_TEST_ASSERT_NULL(reg, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_reg), (void*)(reg), sizeof(struct ccsm_reg), cmock_call_instance->Expected_reg_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_error) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_clear_irq_error,CMockString_error); + if (cmock_call_instance->Expected_error == NULL) + { UNITY_TEST_ASSERT_NULL(error, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_error, error, cmock_call_instance->Expected_error_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.ccsm_drv_get_clear_irq_error_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.ccsm_drv_get_clear_irq_error_CallbackFunctionPointer(reg, error, Mock.ccsm_drv_get_clear_irq_error_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_reg_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(reg, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)reg, (void*)cmock_call_instance->ReturnThruPtr_reg_Val, + cmock_call_instance->ReturnThruPtr_reg_Size); + } + if (cmock_call_instance->ReturnThruPtr_error_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(error, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)error, (void*)cmock_call_instance->ReturnThruPtr_error_Val, + cmock_call_instance->ReturnThruPtr_error_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_ccsm_drv_get_clear_irq_error(CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, uint32_t* error, int error_Depth); +void CMockExpectParameters_ccsm_drv_get_clear_irq_error(CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, uint32_t* error, int error_Depth) +{ + cmock_call_instance->Expected_reg = reg; + cmock_call_instance->Expected_reg_Depth = reg_Depth; + cmock_call_instance->IgnoreArg_reg = 0; + cmock_call_instance->ReturnThruPtr_reg_Used = 0; + cmock_call_instance->Expected_error = error; + cmock_call_instance->Expected_error_Depth = error_Depth; + cmock_call_instance->IgnoreArg_error = 0; + cmock_call_instance->ReturnThruPtr_error_Used = 0; +} + +void ccsm_drv_get_clear_irq_error_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_error_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.ccsm_drv_get_clear_irq_error_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_clear_irq_error_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_clear_irq_error_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.ccsm_drv_get_clear_irq_error_IgnoreBool = (char)1; +} + +void ccsm_drv_get_clear_irq_error_CMockStopIgnore(void) +{ + if(Mock.ccsm_drv_get_clear_irq_error_IgnoreBool) + Mock.ccsm_drv_get_clear_irq_error_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_get_clear_irq_error_CallInstance); + Mock.ccsm_drv_get_clear_irq_error_IgnoreBool = (char)0; +} + +void ccsm_drv_get_clear_irq_error_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_error_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.ccsm_drv_get_clear_irq_error_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_clear_irq_error_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_clear_irq_error_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 ccsm_drv_get_clear_irq_error_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, uint32_t* error, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_error_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.ccsm_drv_get_clear_irq_error_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_clear_irq_error_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_clear_irq_error_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_get_clear_irq_error(cmock_call_instance, reg, 1, error, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_get_clear_irq_error_AddCallback(CMOCK_ccsm_drv_get_clear_irq_error_CALLBACK Callback) +{ + Mock.ccsm_drv_get_clear_irq_error_IgnoreBool = (char)0; + Mock.ccsm_drv_get_clear_irq_error_CallbackBool = (char)1; + Mock.ccsm_drv_get_clear_irq_error_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_get_clear_irq_error_Stub(CMOCK_ccsm_drv_get_clear_irq_error_CALLBACK Callback) +{ + Mock.ccsm_drv_get_clear_irq_error_IgnoreBool = (char)0; + Mock.ccsm_drv_get_clear_irq_error_CallbackBool = (char)0; + Mock.ccsm_drv_get_clear_irq_error_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_get_clear_irq_error_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, uint32_t* error, int error_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_error_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.ccsm_drv_get_clear_irq_error_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_clear_irq_error_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_clear_irq_error_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_get_clear_irq_error(cmock_call_instance, reg, reg_Depth, error, error_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_get_clear_irq_error_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_clear_irq_error_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_reg_Used = 1; + cmock_call_instance->ReturnThruPtr_reg_Val = reg; + cmock_call_instance->ReturnThruPtr_reg_Size = cmock_size; +} + +void ccsm_drv_get_clear_irq_error_CMockReturnMemThruPtr_error(UNITY_LINE_TYPE cmock_line, uint32_t* error, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_clear_irq_error_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_error_Used = 1; + cmock_call_instance->ReturnThruPtr_error_Val = error; + cmock_call_instance->ReturnThruPtr_error_Size = cmock_size; +} + +void ccsm_drv_get_clear_irq_error_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_clear_irq_error_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reg = 1; +} + +void ccsm_drv_get_clear_irq_error_CMockIgnoreArg_error(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_error_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_clear_irq_error_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_error = 1; +} + +bool ccsm_drv_is_irq_status_clear(void* reg) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_ccsm_drv_is_irq_status_clear); + cmock_call_instance = (CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ccsm_drv_is_irq_status_clear_CallInstance); + Mock.ccsm_drv_is_irq_status_clear_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_is_irq_status_clear_CallInstance); + if (Mock.ccsm_drv_is_irq_status_clear_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.ccsm_drv_is_irq_status_clear_FinalReturn; + Mock.ccsm_drv_is_irq_status_clear_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.ccsm_drv_is_irq_status_clear_CallbackBool && + Mock.ccsm_drv_is_irq_status_clear_CallbackFunctionPointer != NULL) + { + bool cmock_cb_ret = Mock.ccsm_drv_is_irq_status_clear_CallbackFunctionPointer(reg, Mock.ccsm_drv_is_irq_status_clear_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_reg) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_is_irq_status_clear,CMockString_reg); + if (cmock_call_instance->Expected_reg == NULL) + { UNITY_TEST_ASSERT_NULL(reg, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_reg, reg, cmock_call_instance->Expected_reg_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.ccsm_drv_is_irq_status_clear_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.ccsm_drv_is_irq_status_clear_CallbackFunctionPointer(reg, Mock.ccsm_drv_is_irq_status_clear_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_reg_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(reg, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)reg, (void*)cmock_call_instance->ReturnThruPtr_reg_Val, + cmock_call_instance->ReturnThruPtr_reg_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_ccsm_drv_is_irq_status_clear(CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE* cmock_call_instance, void* reg, int reg_Depth); +void CMockExpectParameters_ccsm_drv_is_irq_status_clear(CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE* cmock_call_instance, void* reg, int reg_Depth) +{ + cmock_call_instance->Expected_reg = reg; + cmock_call_instance->Expected_reg_Depth = reg_Depth; + cmock_call_instance->IgnoreArg_reg = 0; + cmock_call_instance->ReturnThruPtr_reg_Used = 0; +} + +void ccsm_drv_is_irq_status_clear_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE)); + CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_irq_status_clear_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.ccsm_drv_is_irq_status_clear_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_is_irq_status_clear_CallInstance, cmock_guts_index); + Mock.ccsm_drv_is_irq_status_clear_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.ccsm_drv_is_irq_status_clear_IgnoreBool = (char)1; +} + +void ccsm_drv_is_irq_status_clear_CMockStopIgnore(void) +{ + if(Mock.ccsm_drv_is_irq_status_clear_IgnoreBool) + Mock.ccsm_drv_is_irq_status_clear_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_is_irq_status_clear_CallInstance); + Mock.ccsm_drv_is_irq_status_clear_IgnoreBool = (char)0; +} + +void ccsm_drv_is_irq_status_clear_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE)); + CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_irq_status_clear_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.ccsm_drv_is_irq_status_clear_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_is_irq_status_clear_CallInstance, cmock_guts_index); + Mock.ccsm_drv_is_irq_status_clear_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 ccsm_drv_is_irq_status_clear_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, void* reg, bool cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE)); + CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_irq_status_clear_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.ccsm_drv_is_irq_status_clear_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_is_irq_status_clear_CallInstance, cmock_guts_index); + Mock.ccsm_drv_is_irq_status_clear_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_is_irq_status_clear(cmock_call_instance, reg, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_is_irq_status_clear_AddCallback(CMOCK_ccsm_drv_is_irq_status_clear_CALLBACK Callback) +{ + Mock.ccsm_drv_is_irq_status_clear_IgnoreBool = (char)0; + Mock.ccsm_drv_is_irq_status_clear_CallbackBool = (char)1; + Mock.ccsm_drv_is_irq_status_clear_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_is_irq_status_clear_Stub(CMOCK_ccsm_drv_is_irq_status_clear_CALLBACK Callback) +{ + Mock.ccsm_drv_is_irq_status_clear_IgnoreBool = (char)0; + Mock.ccsm_drv_is_irq_status_clear_CallbackBool = (char)0; + Mock.ccsm_drv_is_irq_status_clear_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_is_irq_status_clear_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, void* reg, int reg_Depth, bool cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE)); + CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_irq_status_clear_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.ccsm_drv_is_irq_status_clear_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_is_irq_status_clear_CallInstance, cmock_guts_index); + Mock.ccsm_drv_is_irq_status_clear_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_is_irq_status_clear(cmock_call_instance, reg, reg_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_is_irq_status_clear_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, void* reg, size_t cmock_size) +{ + CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_is_irq_status_clear_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_reg_Used = 1; + cmock_call_instance->ReturnThruPtr_reg_Val = reg; + cmock_call_instance->ReturnThruPtr_reg_Size = cmock_size; +} + +void ccsm_drv_is_irq_status_clear_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_irq_status_clear_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_is_irq_status_clear_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reg = 1; +} + +int ccsm_drv_get_clear_irq_status(struct ccsm_reg* reg, uint32_t* status) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_ccsm_drv_get_clear_irq_status); + cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ccsm_drv_get_clear_irq_status_CallInstance); + Mock.ccsm_drv_get_clear_irq_status_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_get_clear_irq_status_CallInstance); + if (Mock.ccsm_drv_get_clear_irq_status_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.ccsm_drv_get_clear_irq_status_FinalReturn; + Mock.ccsm_drv_get_clear_irq_status_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.ccsm_drv_get_clear_irq_status_CallbackBool && + Mock.ccsm_drv_get_clear_irq_status_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.ccsm_drv_get_clear_irq_status_CallbackFunctionPointer(reg, status, Mock.ccsm_drv_get_clear_irq_status_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_reg) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_clear_irq_status,CMockString_reg); + if (cmock_call_instance->Expected_reg == NULL) + { UNITY_TEST_ASSERT_NULL(reg, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_reg), (void*)(reg), sizeof(struct ccsm_reg), cmock_call_instance->Expected_reg_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_status) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_get_clear_irq_status,CMockString_status); + if (cmock_call_instance->Expected_status == NULL) + { UNITY_TEST_ASSERT_NULL(status, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_status, status, cmock_call_instance->Expected_status_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.ccsm_drv_get_clear_irq_status_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.ccsm_drv_get_clear_irq_status_CallbackFunctionPointer(reg, status, Mock.ccsm_drv_get_clear_irq_status_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_reg_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(reg, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)reg, (void*)cmock_call_instance->ReturnThruPtr_reg_Val, + cmock_call_instance->ReturnThruPtr_reg_Size); + } + if (cmock_call_instance->ReturnThruPtr_status_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(status, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)status, (void*)cmock_call_instance->ReturnThruPtr_status_Val, + cmock_call_instance->ReturnThruPtr_status_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_ccsm_drv_get_clear_irq_status(CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, uint32_t* status, int status_Depth); +void CMockExpectParameters_ccsm_drv_get_clear_irq_status(CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, uint32_t* status, int status_Depth) +{ + cmock_call_instance->Expected_reg = reg; + cmock_call_instance->Expected_reg_Depth = reg_Depth; + cmock_call_instance->IgnoreArg_reg = 0; + cmock_call_instance->ReturnThruPtr_reg_Used = 0; + cmock_call_instance->Expected_status = status; + cmock_call_instance->Expected_status_Depth = status_Depth; + cmock_call_instance->IgnoreArg_status = 0; + cmock_call_instance->ReturnThruPtr_status_Used = 0; +} + +void ccsm_drv_get_clear_irq_status_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_status_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.ccsm_drv_get_clear_irq_status_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_clear_irq_status_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_clear_irq_status_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.ccsm_drv_get_clear_irq_status_IgnoreBool = (char)1; +} + +void ccsm_drv_get_clear_irq_status_CMockStopIgnore(void) +{ + if(Mock.ccsm_drv_get_clear_irq_status_IgnoreBool) + Mock.ccsm_drv_get_clear_irq_status_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_get_clear_irq_status_CallInstance); + Mock.ccsm_drv_get_clear_irq_status_IgnoreBool = (char)0; +} + +void ccsm_drv_get_clear_irq_status_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_status_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.ccsm_drv_get_clear_irq_status_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_clear_irq_status_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_clear_irq_status_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 ccsm_drv_get_clear_irq_status_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, uint32_t* status, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_status_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.ccsm_drv_get_clear_irq_status_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_clear_irq_status_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_clear_irq_status_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_get_clear_irq_status(cmock_call_instance, reg, 1, status, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_get_clear_irq_status_AddCallback(CMOCK_ccsm_drv_get_clear_irq_status_CALLBACK Callback) +{ + Mock.ccsm_drv_get_clear_irq_status_IgnoreBool = (char)0; + Mock.ccsm_drv_get_clear_irq_status_CallbackBool = (char)1; + Mock.ccsm_drv_get_clear_irq_status_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_get_clear_irq_status_Stub(CMOCK_ccsm_drv_get_clear_irq_status_CALLBACK Callback) +{ + Mock.ccsm_drv_get_clear_irq_status_IgnoreBool = (char)0; + Mock.ccsm_drv_get_clear_irq_status_CallbackBool = (char)0; + Mock.ccsm_drv_get_clear_irq_status_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_get_clear_irq_status_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, uint32_t* status, int status_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE)); + CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_status_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.ccsm_drv_get_clear_irq_status_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_get_clear_irq_status_CallInstance, cmock_guts_index); + Mock.ccsm_drv_get_clear_irq_status_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_get_clear_irq_status(cmock_call_instance, reg, reg_Depth, status, status_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_get_clear_irq_status_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_clear_irq_status_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_reg_Used = 1; + cmock_call_instance->ReturnThruPtr_reg_Val = reg; + cmock_call_instance->ReturnThruPtr_reg_Size = cmock_size; +} + +void ccsm_drv_get_clear_irq_status_CMockReturnMemThruPtr_status(UNITY_LINE_TYPE cmock_line, uint32_t* status, size_t cmock_size) +{ + CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_clear_irq_status_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_status_Used = 1; + cmock_call_instance->ReturnThruPtr_status_Val = status; + cmock_call_instance->ReturnThruPtr_status_Size = cmock_size; +} + +void ccsm_drv_get_clear_irq_status_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_clear_irq_status_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reg = 1; +} + +void ccsm_drv_get_clear_irq_status_CMockIgnoreArg_status(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_get_clear_irq_status_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_get_clear_irq_status_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_status = 1; +} + +bool ccsm_drv_is_request_complete(void* reg) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_ccsm_drv_is_request_complete); + cmock_call_instance = (CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ccsm_drv_is_request_complete_CallInstance); + Mock.ccsm_drv_is_request_complete_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_is_request_complete_CallInstance); + if (Mock.ccsm_drv_is_request_complete_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.ccsm_drv_is_request_complete_FinalReturn; + Mock.ccsm_drv_is_request_complete_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.ccsm_drv_is_request_complete_CallbackBool && + Mock.ccsm_drv_is_request_complete_CallbackFunctionPointer != NULL) + { + bool cmock_cb_ret = Mock.ccsm_drv_is_request_complete_CallbackFunctionPointer(reg, Mock.ccsm_drv_is_request_complete_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_reg) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_is_request_complete,CMockString_reg); + if (cmock_call_instance->Expected_reg == NULL) + { UNITY_TEST_ASSERT_NULL(reg, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(cmock_call_instance->Expected_reg, reg, cmock_call_instance->Expected_reg_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.ccsm_drv_is_request_complete_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.ccsm_drv_is_request_complete_CallbackFunctionPointer(reg, Mock.ccsm_drv_is_request_complete_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_reg_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(reg, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)reg, (void*)cmock_call_instance->ReturnThruPtr_reg_Val, + cmock_call_instance->ReturnThruPtr_reg_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_ccsm_drv_is_request_complete(CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE* cmock_call_instance, void* reg, int reg_Depth); +void CMockExpectParameters_ccsm_drv_is_request_complete(CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE* cmock_call_instance, void* reg, int reg_Depth) +{ + cmock_call_instance->Expected_reg = reg; + cmock_call_instance->Expected_reg_Depth = reg_Depth; + cmock_call_instance->IgnoreArg_reg = 0; + cmock_call_instance->ReturnThruPtr_reg_Used = 0; +} + +void ccsm_drv_is_request_complete_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE)); + CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_request_complete_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.ccsm_drv_is_request_complete_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_is_request_complete_CallInstance, cmock_guts_index); + Mock.ccsm_drv_is_request_complete_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.ccsm_drv_is_request_complete_IgnoreBool = (char)1; +} + +void ccsm_drv_is_request_complete_CMockStopIgnore(void) +{ + if(Mock.ccsm_drv_is_request_complete_IgnoreBool) + Mock.ccsm_drv_is_request_complete_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_is_request_complete_CallInstance); + Mock.ccsm_drv_is_request_complete_IgnoreBool = (char)0; +} + +void ccsm_drv_is_request_complete_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE)); + CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_request_complete_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.ccsm_drv_is_request_complete_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_is_request_complete_CallInstance, cmock_guts_index); + Mock.ccsm_drv_is_request_complete_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 ccsm_drv_is_request_complete_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, void* reg, bool cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE)); + CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_request_complete_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.ccsm_drv_is_request_complete_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_is_request_complete_CallInstance, cmock_guts_index); + Mock.ccsm_drv_is_request_complete_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_is_request_complete(cmock_call_instance, reg, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_is_request_complete_AddCallback(CMOCK_ccsm_drv_is_request_complete_CALLBACK Callback) +{ + Mock.ccsm_drv_is_request_complete_IgnoreBool = (char)0; + Mock.ccsm_drv_is_request_complete_CallbackBool = (char)1; + Mock.ccsm_drv_is_request_complete_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_is_request_complete_Stub(CMOCK_ccsm_drv_is_request_complete_CALLBACK Callback) +{ + Mock.ccsm_drv_is_request_complete_IgnoreBool = (char)0; + Mock.ccsm_drv_is_request_complete_CallbackBool = (char)0; + Mock.ccsm_drv_is_request_complete_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_is_request_complete_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, void* reg, int reg_Depth, bool cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE)); + CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_request_complete_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.ccsm_drv_is_request_complete_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_is_request_complete_CallInstance, cmock_guts_index); + Mock.ccsm_drv_is_request_complete_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_is_request_complete(cmock_call_instance, reg, reg_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_is_request_complete_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, void* reg, size_t cmock_size) +{ + CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_is_request_complete_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_reg_Used = 1; + cmock_call_instance->ReturnThruPtr_reg_Val = reg; + cmock_call_instance->ReturnThruPtr_reg_Size = cmock_size; +} + +void ccsm_drv_is_request_complete_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_is_request_complete_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_is_request_complete_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reg = 1; +} + +int ccsm_drv_set_request(struct ccsm_reg* reg, enum mod_ccsm_request_type req_type) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_ccsm_drv_set_request_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_ccsm_drv_set_request); + cmock_call_instance = (CMOCK_ccsm_drv_set_request_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ccsm_drv_set_request_CallInstance); + Mock.ccsm_drv_set_request_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_set_request_CallInstance); + if (Mock.ccsm_drv_set_request_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.ccsm_drv_set_request_FinalReturn; + Mock.ccsm_drv_set_request_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.ccsm_drv_set_request_CallbackBool && + Mock.ccsm_drv_set_request_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.ccsm_drv_set_request_CallbackFunctionPointer(reg, req_type, Mock.ccsm_drv_set_request_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_reg) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_set_request,CMockString_reg); + if (cmock_call_instance->Expected_reg == NULL) + { UNITY_TEST_ASSERT_NULL(reg, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_reg), (void*)(reg), sizeof(struct ccsm_reg), cmock_call_instance->Expected_reg_Depth, cmock_line, CMockStringMismatch); } + } + if (!cmock_call_instance->IgnoreArg_req_type) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_set_request,CMockString_req_type); + UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_req_type), (void*)(&req_type), sizeof(enum mod_ccsm_request_type), cmock_line, CMockStringMismatch); + } + } + if (Mock.ccsm_drv_set_request_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.ccsm_drv_set_request_CallbackFunctionPointer(reg, req_type, Mock.ccsm_drv_set_request_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_reg_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(reg, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)reg, (void*)cmock_call_instance->ReturnThruPtr_reg_Val, + cmock_call_instance->ReturnThruPtr_reg_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_ccsm_drv_set_request(CMOCK_ccsm_drv_set_request_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_request_type req_type); +void CMockExpectParameters_ccsm_drv_set_request(CMOCK_ccsm_drv_set_request_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_request_type req_type) +{ + cmock_call_instance->Expected_reg = reg; + cmock_call_instance->Expected_reg_Depth = reg_Depth; + cmock_call_instance->IgnoreArg_reg = 0; + cmock_call_instance->ReturnThruPtr_reg_Used = 0; + memcpy((void*)(&cmock_call_instance->Expected_req_type), (void*)(&req_type), + sizeof(enum mod_ccsm_request_type[sizeof(req_type) == sizeof(enum mod_ccsm_request_type) ? 1 : -1])); /* add enum mod_ccsm_request_type to :treat_as_array if this causes an error */ + cmock_call_instance->IgnoreArg_req_type = 0; +} + +void ccsm_drv_set_request_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_request_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_request_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_request_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.ccsm_drv_set_request_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_request_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_request_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.ccsm_drv_set_request_IgnoreBool = (char)1; +} + +void ccsm_drv_set_request_CMockStopIgnore(void) +{ + if(Mock.ccsm_drv_set_request_IgnoreBool) + Mock.ccsm_drv_set_request_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_set_request_CallInstance); + Mock.ccsm_drv_set_request_IgnoreBool = (char)0; +} + +void ccsm_drv_set_request_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_request_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_request_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_request_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.ccsm_drv_set_request_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_request_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_request_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 ccsm_drv_set_request_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, enum mod_ccsm_request_type req_type, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_request_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_request_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_request_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.ccsm_drv_set_request_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_request_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_request_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_set_request(cmock_call_instance, reg, 1, req_type); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_set_request_AddCallback(CMOCK_ccsm_drv_set_request_CALLBACK Callback) +{ + Mock.ccsm_drv_set_request_IgnoreBool = (char)0; + Mock.ccsm_drv_set_request_CallbackBool = (char)1; + Mock.ccsm_drv_set_request_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_set_request_Stub(CMOCK_ccsm_drv_set_request_CALLBACK Callback) +{ + Mock.ccsm_drv_set_request_IgnoreBool = (char)0; + Mock.ccsm_drv_set_request_CallbackBool = (char)0; + Mock.ccsm_drv_set_request_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_set_request_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_request_type req_type, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_set_request_CALL_INSTANCE)); + CMOCK_ccsm_drv_set_request_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_request_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.ccsm_drv_set_request_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_set_request_CallInstance, cmock_guts_index); + Mock.ccsm_drv_set_request_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_set_request(cmock_call_instance, reg, reg_Depth, req_type); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_set_request_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size) +{ + CMOCK_ccsm_drv_set_request_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_request_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_request_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_reg_Used = 1; + cmock_call_instance->ReturnThruPtr_reg_Val = reg; + cmock_call_instance->ReturnThruPtr_reg_Size = cmock_size; +} + +void ccsm_drv_set_request_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_set_request_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_request_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_request_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reg = 1; +} + +void ccsm_drv_set_request_CMockIgnoreArg_req_type(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_set_request_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_set_request_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_set_request_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_req_type = 1; +} + +int ccsm_drv_clear_request(struct ccsm_reg* reg) +{ + UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM; + CMOCK_ccsm_drv_clear_request_CALL_INSTANCE* cmock_call_instance; + UNITY_SET_DETAIL(CMockString_ccsm_drv_clear_request); + cmock_call_instance = (CMOCK_ccsm_drv_clear_request_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.ccsm_drv_clear_request_CallInstance); + Mock.ccsm_drv_clear_request_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_clear_request_CallInstance); + if (Mock.ccsm_drv_clear_request_IgnoreBool) + { + UNITY_CLR_DETAILS(); + if (cmock_call_instance == NULL) + return Mock.ccsm_drv_clear_request_FinalReturn; + Mock.ccsm_drv_clear_request_FinalReturn = cmock_call_instance->ReturnVal; + return cmock_call_instance->ReturnVal; + } + if (!Mock.ccsm_drv_clear_request_CallbackBool && + Mock.ccsm_drv_clear_request_CallbackFunctionPointer != NULL) + { + int cmock_cb_ret = Mock.ccsm_drv_clear_request_CallbackFunctionPointer(reg, Mock.ccsm_drv_clear_request_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_reg) + { + UNITY_SET_DETAILS(CMockString_ccsm_drv_clear_request,CMockString_reg); + if (cmock_call_instance->Expected_reg == NULL) + { UNITY_TEST_ASSERT_NULL(reg, cmock_line, CMockStringExpNULL); } + else + { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_reg), (void*)(reg), sizeof(struct ccsm_reg), cmock_call_instance->Expected_reg_Depth, cmock_line, CMockStringMismatch); } + } + } + if (Mock.ccsm_drv_clear_request_CallbackFunctionPointer != NULL) + { + cmock_call_instance->ReturnVal = Mock.ccsm_drv_clear_request_CallbackFunctionPointer(reg, Mock.ccsm_drv_clear_request_CallbackCalls++); + } + if (cmock_call_instance->ReturnThruPtr_reg_Used) + { + UNITY_TEST_ASSERT_NOT_NULL(reg, cmock_line, CMockStringPtrIsNULL); + memcpy((void*)reg, (void*)cmock_call_instance->ReturnThruPtr_reg_Val, + cmock_call_instance->ReturnThruPtr_reg_Size); + } + UNITY_CLR_DETAILS(); + return cmock_call_instance->ReturnVal; +} + +void CMockExpectParameters_ccsm_drv_clear_request(CMOCK_ccsm_drv_clear_request_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth); +void CMockExpectParameters_ccsm_drv_clear_request(CMOCK_ccsm_drv_clear_request_CALL_INSTANCE* cmock_call_instance, struct ccsm_reg* reg, int reg_Depth) +{ + cmock_call_instance->Expected_reg = reg; + cmock_call_instance->Expected_reg_Depth = reg_Depth; + cmock_call_instance->IgnoreArg_reg = 0; + cmock_call_instance->ReturnThruPtr_reg_Used = 0; +} + +void ccsm_drv_clear_request_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_clear_request_CALL_INSTANCE)); + CMOCK_ccsm_drv_clear_request_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_clear_request_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.ccsm_drv_clear_request_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_clear_request_CallInstance, cmock_guts_index); + Mock.ccsm_drv_clear_request_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + cmock_call_instance->ReturnVal = cmock_to_return; + Mock.ccsm_drv_clear_request_IgnoreBool = (char)1; +} + +void ccsm_drv_clear_request_CMockStopIgnore(void) +{ + if(Mock.ccsm_drv_clear_request_IgnoreBool) + Mock.ccsm_drv_clear_request_CallInstance = CMock_Guts_MemNext(Mock.ccsm_drv_clear_request_CallInstance); + Mock.ccsm_drv_clear_request_IgnoreBool = (char)0; +} + +void ccsm_drv_clear_request_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_clear_request_CALL_INSTANCE)); + CMOCK_ccsm_drv_clear_request_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_clear_request_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.ccsm_drv_clear_request_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_clear_request_CallInstance, cmock_guts_index); + Mock.ccsm_drv_clear_request_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 ccsm_drv_clear_request_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_clear_request_CALL_INSTANCE)); + CMOCK_ccsm_drv_clear_request_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_clear_request_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.ccsm_drv_clear_request_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_clear_request_CallInstance, cmock_guts_index); + Mock.ccsm_drv_clear_request_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_clear_request(cmock_call_instance, reg, 1); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_clear_request_AddCallback(CMOCK_ccsm_drv_clear_request_CALLBACK Callback) +{ + Mock.ccsm_drv_clear_request_IgnoreBool = (char)0; + Mock.ccsm_drv_clear_request_CallbackBool = (char)1; + Mock.ccsm_drv_clear_request_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_clear_request_Stub(CMOCK_ccsm_drv_clear_request_CALLBACK Callback) +{ + Mock.ccsm_drv_clear_request_IgnoreBool = (char)0; + Mock.ccsm_drv_clear_request_CallbackBool = (char)0; + Mock.ccsm_drv_clear_request_CallbackFunctionPointer = Callback; +} + +void ccsm_drv_clear_request_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, int cmock_to_return) +{ + CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_ccsm_drv_clear_request_CALL_INSTANCE)); + CMOCK_ccsm_drv_clear_request_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_clear_request_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.ccsm_drv_clear_request_CallInstance = CMock_Guts_MemChain(Mock.ccsm_drv_clear_request_CallInstance, cmock_guts_index); + Mock.ccsm_drv_clear_request_IgnoreBool = (char)0; + cmock_call_instance->LineNumber = cmock_line; + cmock_call_instance->ExpectAnyArgsBool = (char)0; + CMockExpectParameters_ccsm_drv_clear_request(cmock_call_instance, reg, reg_Depth); + cmock_call_instance->ReturnVal = cmock_to_return; +} + +void ccsm_drv_clear_request_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size) +{ + CMOCK_ccsm_drv_clear_request_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_clear_request_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_clear_request_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp); + cmock_call_instance->ReturnThruPtr_reg_Used = 1; + cmock_call_instance->ReturnThruPtr_reg_Val = reg; + cmock_call_instance->ReturnThruPtr_reg_Size = cmock_size; +} + +void ccsm_drv_clear_request_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line) +{ + CMOCK_ccsm_drv_clear_request_CALL_INSTANCE* cmock_call_instance = (CMOCK_ccsm_drv_clear_request_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.ccsm_drv_clear_request_CallInstance)); + UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp); + cmock_call_instance->IgnoreArg_reg = 1; +} + diff --git a/module/ccsm/test/mocks/Mockmod_ccsm_extra.h b/module/ccsm/test/mocks/Mockmod_ccsm_extra.h new file mode 100644 index 000000000..60535b44b --- /dev/null +++ b/module/ccsm/test/mocks/Mockmod_ccsm_extra.h @@ -0,0 +1,438 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ +#ifndef _MOCKMOD_CCSM_EXTRA_H +#define _MOCKMOD_CCSM_EXTRA_H + +#include "unity.h" +#include "mod_ccsm_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_ccsm_extra_Init(void); +void Mockmod_ccsm_extra_Destroy(void); +void Mockmod_ccsm_extra_Verify(void); + + + + +#define ccsm_drv_get_pll_static_settings_IgnoreAndReturn(cmock_retval) ccsm_drv_get_pll_static_settings_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void ccsm_drv_get_pll_static_settings_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_get_pll_static_settings_StopIgnore() ccsm_drv_get_pll_static_settings_CMockStopIgnore() +void ccsm_drv_get_pll_static_settings_CMockStopIgnore(void); +#define ccsm_drv_get_pll_static_settings_ExpectAnyArgsAndReturn(cmock_retval) ccsm_drv_get_pll_static_settings_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void ccsm_drv_get_pll_static_settings_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_get_pll_static_settings_ExpectAndReturn(reg, pll_select, config, cmock_retval) ccsm_drv_get_pll_static_settings_CMockExpectAndReturn(__LINE__, reg, pll_select, config, cmock_retval) +void ccsm_drv_get_pll_static_settings_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, enum mod_ccsm_pll_static_select pll_select, uint32_t* config, int cmock_to_return); +typedef int (* CMOCK_ccsm_drv_get_pll_static_settings_CALLBACK)(struct ccsm_reg* reg, enum mod_ccsm_pll_static_select pll_select, uint32_t* config, int cmock_num_calls); +void ccsm_drv_get_pll_static_settings_AddCallback(CMOCK_ccsm_drv_get_pll_static_settings_CALLBACK Callback); +void ccsm_drv_get_pll_static_settings_Stub(CMOCK_ccsm_drv_get_pll_static_settings_CALLBACK Callback); +#define ccsm_drv_get_pll_static_settings_StubWithCallback ccsm_drv_get_pll_static_settings_Stub +#define ccsm_drv_get_pll_static_settings_ExpectWithArrayAndReturn(reg, reg_Depth, pll_select, config, config_Depth, cmock_retval) ccsm_drv_get_pll_static_settings_CMockExpectWithArrayAndReturn(__LINE__, reg, reg_Depth, pll_select, config, config_Depth, cmock_retval) +void ccsm_drv_get_pll_static_settings_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_pll_static_select pll_select, uint32_t* config, int config_Depth, int cmock_to_return); +#define ccsm_drv_get_pll_static_settings_ReturnThruPtr_reg(reg) ccsm_drv_get_pll_static_settings_CMockReturnMemThruPtr_reg(__LINE__, reg, sizeof(struct ccsm_reg)) +#define ccsm_drv_get_pll_static_settings_ReturnArrayThruPtr_reg(reg, cmock_len) ccsm_drv_get_pll_static_settings_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_len * sizeof(*reg)) +#define ccsm_drv_get_pll_static_settings_ReturnMemThruPtr_reg(reg, cmock_size) ccsm_drv_get_pll_static_settings_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_size) +void ccsm_drv_get_pll_static_settings_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size); +#define ccsm_drv_get_pll_static_settings_ReturnThruPtr_config(config) ccsm_drv_get_pll_static_settings_CMockReturnMemThruPtr_config(__LINE__, config, sizeof(uint32_t)) +#define ccsm_drv_get_pll_static_settings_ReturnArrayThruPtr_config(config, cmock_len) ccsm_drv_get_pll_static_settings_CMockReturnMemThruPtr_config(__LINE__, config, cmock_len * sizeof(*config)) +#define ccsm_drv_get_pll_static_settings_ReturnMemThruPtr_config(config, cmock_size) ccsm_drv_get_pll_static_settings_CMockReturnMemThruPtr_config(__LINE__, config, cmock_size) +void ccsm_drv_get_pll_static_settings_CMockReturnMemThruPtr_config(UNITY_LINE_TYPE cmock_line, uint32_t* config, size_t cmock_size); +#define ccsm_drv_get_pll_static_settings_IgnoreArg_reg() ccsm_drv_get_pll_static_settings_CMockIgnoreArg_reg(__LINE__) +void ccsm_drv_get_pll_static_settings_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_pll_static_settings_IgnoreArg_pll_select() ccsm_drv_get_pll_static_settings_CMockIgnoreArg_pll_select(__LINE__) +void ccsm_drv_get_pll_static_settings_CMockIgnoreArg_pll_select(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_pll_static_settings_IgnoreArg_config() ccsm_drv_get_pll_static_settings_CMockIgnoreArg_config(__LINE__) +void ccsm_drv_get_pll_static_settings_CMockIgnoreArg_config(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_pll_dynamic_settings_IgnoreAndReturn(cmock_retval) ccsm_drv_get_pll_dynamic_settings_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void ccsm_drv_get_pll_dynamic_settings_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_get_pll_dynamic_settings_StopIgnore() ccsm_drv_get_pll_dynamic_settings_CMockStopIgnore() +void ccsm_drv_get_pll_dynamic_settings_CMockStopIgnore(void); +#define ccsm_drv_get_pll_dynamic_settings_ExpectAnyArgsAndReturn(cmock_retval) ccsm_drv_get_pll_dynamic_settings_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void ccsm_drv_get_pll_dynamic_settings_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_get_pll_dynamic_settings_ExpectAndReturn(reg, pll_select, config0, config1, cmock_retval) ccsm_drv_get_pll_dynamic_settings_CMockExpectAndReturn(__LINE__, reg, pll_select, config0, config1, cmock_retval) +void ccsm_drv_get_pll_dynamic_settings_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, enum mod_ccsm_pll_dynamic_select pll_select, uint32_t* config0, uint32_t* config1, int cmock_to_return); +typedef int (* CMOCK_ccsm_drv_get_pll_dynamic_settings_CALLBACK)(struct ccsm_reg* reg, enum mod_ccsm_pll_dynamic_select pll_select, uint32_t* config0, uint32_t* config1, int cmock_num_calls); +void ccsm_drv_get_pll_dynamic_settings_AddCallback(CMOCK_ccsm_drv_get_pll_dynamic_settings_CALLBACK Callback); +void ccsm_drv_get_pll_dynamic_settings_Stub(CMOCK_ccsm_drv_get_pll_dynamic_settings_CALLBACK Callback); +#define ccsm_drv_get_pll_dynamic_settings_StubWithCallback ccsm_drv_get_pll_dynamic_settings_Stub +#define ccsm_drv_get_pll_dynamic_settings_ExpectWithArrayAndReturn(reg, reg_Depth, pll_select, config0, config0_Depth, config1, config1_Depth, cmock_retval) ccsm_drv_get_pll_dynamic_settings_CMockExpectWithArrayAndReturn(__LINE__, reg, reg_Depth, pll_select, config0, config0_Depth, config1, config1_Depth, cmock_retval) +void ccsm_drv_get_pll_dynamic_settings_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_pll_dynamic_select pll_select, uint32_t* config0, int config0_Depth, uint32_t* config1, int config1_Depth, int cmock_to_return); +#define ccsm_drv_get_pll_dynamic_settings_ReturnThruPtr_reg(reg) ccsm_drv_get_pll_dynamic_settings_CMockReturnMemThruPtr_reg(__LINE__, reg, sizeof(struct ccsm_reg)) +#define ccsm_drv_get_pll_dynamic_settings_ReturnArrayThruPtr_reg(reg, cmock_len) ccsm_drv_get_pll_dynamic_settings_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_len * sizeof(*reg)) +#define ccsm_drv_get_pll_dynamic_settings_ReturnMemThruPtr_reg(reg, cmock_size) ccsm_drv_get_pll_dynamic_settings_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_size) +void ccsm_drv_get_pll_dynamic_settings_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size); +#define ccsm_drv_get_pll_dynamic_settings_ReturnThruPtr_config0(config0) ccsm_drv_get_pll_dynamic_settings_CMockReturnMemThruPtr_config0(__LINE__, config0, sizeof(uint32_t)) +#define ccsm_drv_get_pll_dynamic_settings_ReturnArrayThruPtr_config0(config0, cmock_len) ccsm_drv_get_pll_dynamic_settings_CMockReturnMemThruPtr_config0(__LINE__, config0, cmock_len * sizeof(*config0)) +#define ccsm_drv_get_pll_dynamic_settings_ReturnMemThruPtr_config0(config0, cmock_size) ccsm_drv_get_pll_dynamic_settings_CMockReturnMemThruPtr_config0(__LINE__, config0, cmock_size) +void ccsm_drv_get_pll_dynamic_settings_CMockReturnMemThruPtr_config0(UNITY_LINE_TYPE cmock_line, uint32_t* config0, size_t cmock_size); +#define ccsm_drv_get_pll_dynamic_settings_ReturnThruPtr_config1(config1) ccsm_drv_get_pll_dynamic_settings_CMockReturnMemThruPtr_config1(__LINE__, config1, sizeof(uint32_t)) +#define ccsm_drv_get_pll_dynamic_settings_ReturnArrayThruPtr_config1(config1, cmock_len) ccsm_drv_get_pll_dynamic_settings_CMockReturnMemThruPtr_config1(__LINE__, config1, cmock_len * sizeof(*config1)) +#define ccsm_drv_get_pll_dynamic_settings_ReturnMemThruPtr_config1(config1, cmock_size) ccsm_drv_get_pll_dynamic_settings_CMockReturnMemThruPtr_config1(__LINE__, config1, cmock_size) +void ccsm_drv_get_pll_dynamic_settings_CMockReturnMemThruPtr_config1(UNITY_LINE_TYPE cmock_line, uint32_t* config1, size_t cmock_size); +#define ccsm_drv_get_pll_dynamic_settings_IgnoreArg_reg() ccsm_drv_get_pll_dynamic_settings_CMockIgnoreArg_reg(__LINE__) +void ccsm_drv_get_pll_dynamic_settings_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_pll_dynamic_settings_IgnoreArg_pll_select() ccsm_drv_get_pll_dynamic_settings_CMockIgnoreArg_pll_select(__LINE__) +void ccsm_drv_get_pll_dynamic_settings_CMockIgnoreArg_pll_select(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_pll_dynamic_settings_IgnoreArg_config0() ccsm_drv_get_pll_dynamic_settings_CMockIgnoreArg_config0(__LINE__) +void ccsm_drv_get_pll_dynamic_settings_CMockIgnoreArg_config0(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_pll_dynamic_settings_IgnoreArg_config1() ccsm_drv_get_pll_dynamic_settings_CMockIgnoreArg_config1(__LINE__) +void ccsm_drv_get_pll_dynamic_settings_CMockIgnoreArg_config1(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_set_pll_static_settings_IgnoreAndReturn(cmock_retval) ccsm_drv_set_pll_static_settings_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void ccsm_drv_set_pll_static_settings_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_set_pll_static_settings_StopIgnore() ccsm_drv_set_pll_static_settings_CMockStopIgnore() +void ccsm_drv_set_pll_static_settings_CMockStopIgnore(void); +#define ccsm_drv_set_pll_static_settings_ExpectAnyArgsAndReturn(cmock_retval) ccsm_drv_set_pll_static_settings_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void ccsm_drv_set_pll_static_settings_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_set_pll_static_settings_ExpectAndReturn(reg, pll_select, config, cmock_retval) ccsm_drv_set_pll_static_settings_CMockExpectAndReturn(__LINE__, reg, pll_select, config, cmock_retval) +void ccsm_drv_set_pll_static_settings_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, enum mod_ccsm_pll_static_select pll_select, uint32_t config, int cmock_to_return); +typedef int (* CMOCK_ccsm_drv_set_pll_static_settings_CALLBACK)(struct ccsm_reg* reg, enum mod_ccsm_pll_static_select pll_select, uint32_t config, int cmock_num_calls); +void ccsm_drv_set_pll_static_settings_AddCallback(CMOCK_ccsm_drv_set_pll_static_settings_CALLBACK Callback); +void ccsm_drv_set_pll_static_settings_Stub(CMOCK_ccsm_drv_set_pll_static_settings_CALLBACK Callback); +#define ccsm_drv_set_pll_static_settings_StubWithCallback ccsm_drv_set_pll_static_settings_Stub +#define ccsm_drv_set_pll_static_settings_ExpectWithArrayAndReturn(reg, reg_Depth, pll_select, config, cmock_retval) ccsm_drv_set_pll_static_settings_CMockExpectWithArrayAndReturn(__LINE__, reg, reg_Depth, pll_select, config, cmock_retval) +void ccsm_drv_set_pll_static_settings_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_pll_static_select pll_select, uint32_t config, int cmock_to_return); +#define ccsm_drv_set_pll_static_settings_ReturnThruPtr_reg(reg) ccsm_drv_set_pll_static_settings_CMockReturnMemThruPtr_reg(__LINE__, reg, sizeof(struct ccsm_reg)) +#define ccsm_drv_set_pll_static_settings_ReturnArrayThruPtr_reg(reg, cmock_len) ccsm_drv_set_pll_static_settings_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_len * sizeof(*reg)) +#define ccsm_drv_set_pll_static_settings_ReturnMemThruPtr_reg(reg, cmock_size) ccsm_drv_set_pll_static_settings_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_size) +void ccsm_drv_set_pll_static_settings_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size); +#define ccsm_drv_set_pll_static_settings_IgnoreArg_reg() ccsm_drv_set_pll_static_settings_CMockIgnoreArg_reg(__LINE__) +void ccsm_drv_set_pll_static_settings_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_set_pll_static_settings_IgnoreArg_pll_select() ccsm_drv_set_pll_static_settings_CMockIgnoreArg_pll_select(__LINE__) +void ccsm_drv_set_pll_static_settings_CMockIgnoreArg_pll_select(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_set_pll_static_settings_IgnoreArg_config() ccsm_drv_set_pll_static_settings_CMockIgnoreArg_config(__LINE__) +void ccsm_drv_set_pll_static_settings_CMockIgnoreArg_config(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_set_pll_dynamic_settings_IgnoreAndReturn(cmock_retval) ccsm_drv_set_pll_dynamic_settings_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void ccsm_drv_set_pll_dynamic_settings_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_set_pll_dynamic_settings_StopIgnore() ccsm_drv_set_pll_dynamic_settings_CMockStopIgnore() +void ccsm_drv_set_pll_dynamic_settings_CMockStopIgnore(void); +#define ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(cmock_retval) ccsm_drv_set_pll_dynamic_settings_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void ccsm_drv_set_pll_dynamic_settings_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_set_pll_dynamic_settings_ExpectAndReturn(reg, pll_select, config0, config1, cmock_retval) ccsm_drv_set_pll_dynamic_settings_CMockExpectAndReturn(__LINE__, reg, pll_select, config0, config1, cmock_retval) +void ccsm_drv_set_pll_dynamic_settings_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, enum mod_ccsm_pll_dynamic_select pll_select, uint32_t config0, uint32_t config1, int cmock_to_return); +typedef int (* CMOCK_ccsm_drv_set_pll_dynamic_settings_CALLBACK)(struct ccsm_reg* reg, enum mod_ccsm_pll_dynamic_select pll_select, uint32_t config0, uint32_t config1, int cmock_num_calls); +void ccsm_drv_set_pll_dynamic_settings_AddCallback(CMOCK_ccsm_drv_set_pll_dynamic_settings_CALLBACK Callback); +void ccsm_drv_set_pll_dynamic_settings_Stub(CMOCK_ccsm_drv_set_pll_dynamic_settings_CALLBACK Callback); +#define ccsm_drv_set_pll_dynamic_settings_StubWithCallback ccsm_drv_set_pll_dynamic_settings_Stub +#define ccsm_drv_set_pll_dynamic_settings_ExpectWithArrayAndReturn(reg, reg_Depth, pll_select, config0, config1, cmock_retval) ccsm_drv_set_pll_dynamic_settings_CMockExpectWithArrayAndReturn(__LINE__, reg, reg_Depth, pll_select, config0, config1, cmock_retval) +void ccsm_drv_set_pll_dynamic_settings_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_pll_dynamic_select pll_select, uint32_t config0, uint32_t config1, int cmock_to_return); +#define ccsm_drv_set_pll_dynamic_settings_ReturnThruPtr_reg(reg) ccsm_drv_set_pll_dynamic_settings_CMockReturnMemThruPtr_reg(__LINE__, reg, sizeof(struct ccsm_reg)) +#define ccsm_drv_set_pll_dynamic_settings_ReturnArrayThruPtr_reg(reg, cmock_len) ccsm_drv_set_pll_dynamic_settings_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_len * sizeof(*reg)) +#define ccsm_drv_set_pll_dynamic_settings_ReturnMemThruPtr_reg(reg, cmock_size) ccsm_drv_set_pll_dynamic_settings_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_size) +void ccsm_drv_set_pll_dynamic_settings_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size); +#define ccsm_drv_set_pll_dynamic_settings_IgnoreArg_reg() ccsm_drv_set_pll_dynamic_settings_CMockIgnoreArg_reg(__LINE__) +void ccsm_drv_set_pll_dynamic_settings_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_set_pll_dynamic_settings_IgnoreArg_pll_select() ccsm_drv_set_pll_dynamic_settings_CMockIgnoreArg_pll_select(__LINE__) +void ccsm_drv_set_pll_dynamic_settings_CMockIgnoreArg_pll_select(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_set_pll_dynamic_settings_IgnoreArg_config0() ccsm_drv_set_pll_dynamic_settings_CMockIgnoreArg_config0(__LINE__) +void ccsm_drv_set_pll_dynamic_settings_CMockIgnoreArg_config0(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_set_pll_dynamic_settings_IgnoreArg_config1() ccsm_drv_set_pll_dynamic_settings_CMockIgnoreArg_config1(__LINE__) +void ccsm_drv_set_pll_dynamic_settings_CMockIgnoreArg_config1(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_dm_configuration_IgnoreAndReturn(cmock_retval) ccsm_drv_get_dm_configuration_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void ccsm_drv_get_dm_configuration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_get_dm_configuration_StopIgnore() ccsm_drv_get_dm_configuration_CMockStopIgnore() +void ccsm_drv_get_dm_configuration_CMockStopIgnore(void); +#define ccsm_drv_get_dm_configuration_ExpectAnyArgsAndReturn(cmock_retval) ccsm_drv_get_dm_configuration_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void ccsm_drv_get_dm_configuration_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_get_dm_configuration_ExpectAndReturn(reg, config, cmock_retval) ccsm_drv_get_dm_configuration_CMockExpectAndReturn(__LINE__, reg, config, cmock_retval) +void ccsm_drv_get_dm_configuration_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, uint32_t* config, int cmock_to_return); +typedef int (* CMOCK_ccsm_drv_get_dm_configuration_CALLBACK)(struct ccsm_reg* reg, uint32_t* config, int cmock_num_calls); +void ccsm_drv_get_dm_configuration_AddCallback(CMOCK_ccsm_drv_get_dm_configuration_CALLBACK Callback); +void ccsm_drv_get_dm_configuration_Stub(CMOCK_ccsm_drv_get_dm_configuration_CALLBACK Callback); +#define ccsm_drv_get_dm_configuration_StubWithCallback ccsm_drv_get_dm_configuration_Stub +#define ccsm_drv_get_dm_configuration_ExpectWithArrayAndReturn(reg, reg_Depth, config, config_Depth, cmock_retval) ccsm_drv_get_dm_configuration_CMockExpectWithArrayAndReturn(__LINE__, reg, reg_Depth, config, config_Depth, cmock_retval) +void ccsm_drv_get_dm_configuration_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, uint32_t* config, int config_Depth, int cmock_to_return); +#define ccsm_drv_get_dm_configuration_ReturnThruPtr_reg(reg) ccsm_drv_get_dm_configuration_CMockReturnMemThruPtr_reg(__LINE__, reg, sizeof(struct ccsm_reg)) +#define ccsm_drv_get_dm_configuration_ReturnArrayThruPtr_reg(reg, cmock_len) ccsm_drv_get_dm_configuration_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_len * sizeof(*reg)) +#define ccsm_drv_get_dm_configuration_ReturnMemThruPtr_reg(reg, cmock_size) ccsm_drv_get_dm_configuration_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_size) +void ccsm_drv_get_dm_configuration_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size); +#define ccsm_drv_get_dm_configuration_ReturnThruPtr_config(config) ccsm_drv_get_dm_configuration_CMockReturnMemThruPtr_config(__LINE__, config, sizeof(uint32_t)) +#define ccsm_drv_get_dm_configuration_ReturnArrayThruPtr_config(config, cmock_len) ccsm_drv_get_dm_configuration_CMockReturnMemThruPtr_config(__LINE__, config, cmock_len * sizeof(*config)) +#define ccsm_drv_get_dm_configuration_ReturnMemThruPtr_config(config, cmock_size) ccsm_drv_get_dm_configuration_CMockReturnMemThruPtr_config(__LINE__, config, cmock_size) +void ccsm_drv_get_dm_configuration_CMockReturnMemThruPtr_config(UNITY_LINE_TYPE cmock_line, uint32_t* config, size_t cmock_size); +#define ccsm_drv_get_dm_configuration_IgnoreArg_reg() ccsm_drv_get_dm_configuration_CMockIgnoreArg_reg(__LINE__) +void ccsm_drv_get_dm_configuration_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_dm_configuration_IgnoreArg_config() ccsm_drv_get_dm_configuration_CMockIgnoreArg_config(__LINE__) +void ccsm_drv_get_dm_configuration_CMockIgnoreArg_config(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_dm_telemetry_IgnoreAndReturn(cmock_retval) ccsm_drv_get_dm_telemetry_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void ccsm_drv_get_dm_telemetry_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_get_dm_telemetry_StopIgnore() ccsm_drv_get_dm_telemetry_CMockStopIgnore() +void ccsm_drv_get_dm_telemetry_CMockStopIgnore(void); +#define ccsm_drv_get_dm_telemetry_ExpectAnyArgsAndReturn(cmock_retval) ccsm_drv_get_dm_telemetry_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void ccsm_drv_get_dm_telemetry_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_get_dm_telemetry_ExpectAndReturn(reg, telemetry1, telemetry2, telemetry3, cmock_retval) ccsm_drv_get_dm_telemetry_CMockExpectAndReturn(__LINE__, reg, telemetry1, telemetry2, telemetry3, cmock_retval) +void ccsm_drv_get_dm_telemetry_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, uint32_t* telemetry1, uint32_t* telemetry2, uint32_t* telemetry3, int cmock_to_return); +typedef int (* CMOCK_ccsm_drv_get_dm_telemetry_CALLBACK)(struct ccsm_reg* reg, uint32_t* telemetry1, uint32_t* telemetry2, uint32_t* telemetry3, int cmock_num_calls); +void ccsm_drv_get_dm_telemetry_AddCallback(CMOCK_ccsm_drv_get_dm_telemetry_CALLBACK Callback); +void ccsm_drv_get_dm_telemetry_Stub(CMOCK_ccsm_drv_get_dm_telemetry_CALLBACK Callback); +#define ccsm_drv_get_dm_telemetry_StubWithCallback ccsm_drv_get_dm_telemetry_Stub +#define ccsm_drv_get_dm_telemetry_ExpectWithArrayAndReturn(reg, reg_Depth, telemetry1, telemetry1_Depth, telemetry2, telemetry2_Depth, telemetry3, telemetry3_Depth, cmock_retval) ccsm_drv_get_dm_telemetry_CMockExpectWithArrayAndReturn(__LINE__, reg, reg_Depth, telemetry1, telemetry1_Depth, telemetry2, telemetry2_Depth, telemetry3, telemetry3_Depth, cmock_retval) +void ccsm_drv_get_dm_telemetry_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, uint32_t* telemetry1, int telemetry1_Depth, uint32_t* telemetry2, int telemetry2_Depth, uint32_t* telemetry3, int telemetry3_Depth, int cmock_to_return); +#define ccsm_drv_get_dm_telemetry_ReturnThruPtr_reg(reg) ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_reg(__LINE__, reg, sizeof(struct ccsm_reg)) +#define ccsm_drv_get_dm_telemetry_ReturnArrayThruPtr_reg(reg, cmock_len) ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_len * sizeof(*reg)) +#define ccsm_drv_get_dm_telemetry_ReturnMemThruPtr_reg(reg, cmock_size) ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_size) +void ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size); +#define ccsm_drv_get_dm_telemetry_ReturnThruPtr_telemetry1(telemetry1) ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_telemetry1(__LINE__, telemetry1, sizeof(uint32_t)) +#define ccsm_drv_get_dm_telemetry_ReturnArrayThruPtr_telemetry1(telemetry1, cmock_len) ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_telemetry1(__LINE__, telemetry1, cmock_len * sizeof(*telemetry1)) +#define ccsm_drv_get_dm_telemetry_ReturnMemThruPtr_telemetry1(telemetry1, cmock_size) ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_telemetry1(__LINE__, telemetry1, cmock_size) +void ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_telemetry1(UNITY_LINE_TYPE cmock_line, uint32_t* telemetry1, size_t cmock_size); +#define ccsm_drv_get_dm_telemetry_ReturnThruPtr_telemetry2(telemetry2) ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_telemetry2(__LINE__, telemetry2, sizeof(uint32_t)) +#define ccsm_drv_get_dm_telemetry_ReturnArrayThruPtr_telemetry2(telemetry2, cmock_len) ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_telemetry2(__LINE__, telemetry2, cmock_len * sizeof(*telemetry2)) +#define ccsm_drv_get_dm_telemetry_ReturnMemThruPtr_telemetry2(telemetry2, cmock_size) ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_telemetry2(__LINE__, telemetry2, cmock_size) +void ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_telemetry2(UNITY_LINE_TYPE cmock_line, uint32_t* telemetry2, size_t cmock_size); +#define ccsm_drv_get_dm_telemetry_ReturnThruPtr_telemetry3(telemetry3) ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_telemetry3(__LINE__, telemetry3, sizeof(uint32_t)) +#define ccsm_drv_get_dm_telemetry_ReturnArrayThruPtr_telemetry3(telemetry3, cmock_len) ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_telemetry3(__LINE__, telemetry3, cmock_len * sizeof(*telemetry3)) +#define ccsm_drv_get_dm_telemetry_ReturnMemThruPtr_telemetry3(telemetry3, cmock_size) ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_telemetry3(__LINE__, telemetry3, cmock_size) +void ccsm_drv_get_dm_telemetry_CMockReturnMemThruPtr_telemetry3(UNITY_LINE_TYPE cmock_line, uint32_t* telemetry3, size_t cmock_size); +#define ccsm_drv_get_dm_telemetry_IgnoreArg_reg() ccsm_drv_get_dm_telemetry_CMockIgnoreArg_reg(__LINE__) +void ccsm_drv_get_dm_telemetry_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_dm_telemetry_IgnoreArg_telemetry1() ccsm_drv_get_dm_telemetry_CMockIgnoreArg_telemetry1(__LINE__) +void ccsm_drv_get_dm_telemetry_CMockIgnoreArg_telemetry1(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_dm_telemetry_IgnoreArg_telemetry2() ccsm_drv_get_dm_telemetry_CMockIgnoreArg_telemetry2(__LINE__) +void ccsm_drv_get_dm_telemetry_CMockIgnoreArg_telemetry2(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_dm_telemetry_IgnoreArg_telemetry3() ccsm_drv_get_dm_telemetry_CMockIgnoreArg_telemetry3(__LINE__) +void ccsm_drv_get_dm_telemetry_CMockIgnoreArg_telemetry3(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_set_dm_configuration_IgnoreAndReturn(cmock_retval) ccsm_drv_set_dm_configuration_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void ccsm_drv_set_dm_configuration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_set_dm_configuration_StopIgnore() ccsm_drv_set_dm_configuration_CMockStopIgnore() +void ccsm_drv_set_dm_configuration_CMockStopIgnore(void); +#define ccsm_drv_set_dm_configuration_ExpectAnyArgsAndReturn(cmock_retval) ccsm_drv_set_dm_configuration_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void ccsm_drv_set_dm_configuration_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_set_dm_configuration_ExpectAndReturn(reg, config, cmock_retval) ccsm_drv_set_dm_configuration_CMockExpectAndReturn(__LINE__, reg, config, cmock_retval) +void ccsm_drv_set_dm_configuration_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, uint32_t config, int cmock_to_return); +typedef int (* CMOCK_ccsm_drv_set_dm_configuration_CALLBACK)(struct ccsm_reg* reg, uint32_t config, int cmock_num_calls); +void ccsm_drv_set_dm_configuration_AddCallback(CMOCK_ccsm_drv_set_dm_configuration_CALLBACK Callback); +void ccsm_drv_set_dm_configuration_Stub(CMOCK_ccsm_drv_set_dm_configuration_CALLBACK Callback); +#define ccsm_drv_set_dm_configuration_StubWithCallback ccsm_drv_set_dm_configuration_Stub +#define ccsm_drv_set_dm_configuration_ExpectWithArrayAndReturn(reg, reg_Depth, config, cmock_retval) ccsm_drv_set_dm_configuration_CMockExpectWithArrayAndReturn(__LINE__, reg, reg_Depth, config, cmock_retval) +void ccsm_drv_set_dm_configuration_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, uint32_t config, int cmock_to_return); +#define ccsm_drv_set_dm_configuration_ReturnThruPtr_reg(reg) ccsm_drv_set_dm_configuration_CMockReturnMemThruPtr_reg(__LINE__, reg, sizeof(struct ccsm_reg)) +#define ccsm_drv_set_dm_configuration_ReturnArrayThruPtr_reg(reg, cmock_len) ccsm_drv_set_dm_configuration_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_len * sizeof(*reg)) +#define ccsm_drv_set_dm_configuration_ReturnMemThruPtr_reg(reg, cmock_size) ccsm_drv_set_dm_configuration_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_size) +void ccsm_drv_set_dm_configuration_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size); +#define ccsm_drv_set_dm_configuration_IgnoreArg_reg() ccsm_drv_set_dm_configuration_CMockIgnoreArg_reg(__LINE__) +void ccsm_drv_set_dm_configuration_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_set_dm_configuration_IgnoreArg_config() ccsm_drv_set_dm_configuration_CMockIgnoreArg_config(__LINE__) +void ccsm_drv_set_dm_configuration_CMockIgnoreArg_config(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_mod_configuration_IgnoreAndReturn(cmock_retval) ccsm_drv_get_mod_configuration_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void ccsm_drv_get_mod_configuration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_get_mod_configuration_StopIgnore() ccsm_drv_get_mod_configuration_CMockStopIgnore() +void ccsm_drv_get_mod_configuration_CMockStopIgnore(void); +#define ccsm_drv_get_mod_configuration_ExpectAnyArgsAndReturn(cmock_retval) ccsm_drv_get_mod_configuration_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void ccsm_drv_get_mod_configuration_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_get_mod_configuration_ExpectAndReturn(reg, core_id, config, cmock_retval) ccsm_drv_get_mod_configuration_CMockExpectAndReturn(__LINE__, reg, core_id, config, cmock_retval) +void ccsm_drv_get_mod_configuration_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, enum mod_ccsm_mod_select core_id, uint32_t* config, int cmock_to_return); +typedef int (* CMOCK_ccsm_drv_get_mod_configuration_CALLBACK)(struct ccsm_reg* reg, enum mod_ccsm_mod_select core_id, uint32_t* config, int cmock_num_calls); +void ccsm_drv_get_mod_configuration_AddCallback(CMOCK_ccsm_drv_get_mod_configuration_CALLBACK Callback); +void ccsm_drv_get_mod_configuration_Stub(CMOCK_ccsm_drv_get_mod_configuration_CALLBACK Callback); +#define ccsm_drv_get_mod_configuration_StubWithCallback ccsm_drv_get_mod_configuration_Stub +#define ccsm_drv_get_mod_configuration_ExpectWithArrayAndReturn(reg, reg_Depth, core_id, config, config_Depth, cmock_retval) ccsm_drv_get_mod_configuration_CMockExpectWithArrayAndReturn(__LINE__, reg, reg_Depth, core_id, config, config_Depth, cmock_retval) +void ccsm_drv_get_mod_configuration_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_mod_select core_id, uint32_t* config, int config_Depth, int cmock_to_return); +#define ccsm_drv_get_mod_configuration_ReturnThruPtr_reg(reg) ccsm_drv_get_mod_configuration_CMockReturnMemThruPtr_reg(__LINE__, reg, sizeof(struct ccsm_reg)) +#define ccsm_drv_get_mod_configuration_ReturnArrayThruPtr_reg(reg, cmock_len) ccsm_drv_get_mod_configuration_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_len * sizeof(*reg)) +#define ccsm_drv_get_mod_configuration_ReturnMemThruPtr_reg(reg, cmock_size) ccsm_drv_get_mod_configuration_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_size) +void ccsm_drv_get_mod_configuration_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size); +#define ccsm_drv_get_mod_configuration_ReturnThruPtr_config(config) ccsm_drv_get_mod_configuration_CMockReturnMemThruPtr_config(__LINE__, config, sizeof(uint32_t)) +#define ccsm_drv_get_mod_configuration_ReturnArrayThruPtr_config(config, cmock_len) ccsm_drv_get_mod_configuration_CMockReturnMemThruPtr_config(__LINE__, config, cmock_len * sizeof(*config)) +#define ccsm_drv_get_mod_configuration_ReturnMemThruPtr_config(config, cmock_size) ccsm_drv_get_mod_configuration_CMockReturnMemThruPtr_config(__LINE__, config, cmock_size) +void ccsm_drv_get_mod_configuration_CMockReturnMemThruPtr_config(UNITY_LINE_TYPE cmock_line, uint32_t* config, size_t cmock_size); +#define ccsm_drv_get_mod_configuration_IgnoreArg_reg() ccsm_drv_get_mod_configuration_CMockIgnoreArg_reg(__LINE__) +void ccsm_drv_get_mod_configuration_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_mod_configuration_IgnoreArg_core_id() ccsm_drv_get_mod_configuration_CMockIgnoreArg_core_id(__LINE__) +void ccsm_drv_get_mod_configuration_CMockIgnoreArg_core_id(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_mod_configuration_IgnoreArg_config() ccsm_drv_get_mod_configuration_CMockIgnoreArg_config(__LINE__) +void ccsm_drv_get_mod_configuration_CMockIgnoreArg_config(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_set_mod_configuration_IgnoreAndReturn(cmock_retval) ccsm_drv_set_mod_configuration_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void ccsm_drv_set_mod_configuration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_set_mod_configuration_StopIgnore() ccsm_drv_set_mod_configuration_CMockStopIgnore() +void ccsm_drv_set_mod_configuration_CMockStopIgnore(void); +#define ccsm_drv_set_mod_configuration_ExpectAnyArgsAndReturn(cmock_retval) ccsm_drv_set_mod_configuration_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void ccsm_drv_set_mod_configuration_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_set_mod_configuration_ExpectAndReturn(reg, core_id, config, cmock_retval) ccsm_drv_set_mod_configuration_CMockExpectAndReturn(__LINE__, reg, core_id, config, cmock_retval) +void ccsm_drv_set_mod_configuration_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, enum mod_ccsm_mod_select core_id, uint32_t config, int cmock_to_return); +typedef int (* CMOCK_ccsm_drv_set_mod_configuration_CALLBACK)(struct ccsm_reg* reg, enum mod_ccsm_mod_select core_id, uint32_t config, int cmock_num_calls); +void ccsm_drv_set_mod_configuration_AddCallback(CMOCK_ccsm_drv_set_mod_configuration_CALLBACK Callback); +void ccsm_drv_set_mod_configuration_Stub(CMOCK_ccsm_drv_set_mod_configuration_CALLBACK Callback); +#define ccsm_drv_set_mod_configuration_StubWithCallback ccsm_drv_set_mod_configuration_Stub +#define ccsm_drv_set_mod_configuration_ExpectWithArrayAndReturn(reg, reg_Depth, core_id, config, cmock_retval) ccsm_drv_set_mod_configuration_CMockExpectWithArrayAndReturn(__LINE__, reg, reg_Depth, core_id, config, cmock_retval) +void ccsm_drv_set_mod_configuration_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_mod_select core_id, uint32_t config, int cmock_to_return); +#define ccsm_drv_set_mod_configuration_ReturnThruPtr_reg(reg) ccsm_drv_set_mod_configuration_CMockReturnMemThruPtr_reg(__LINE__, reg, sizeof(struct ccsm_reg)) +#define ccsm_drv_set_mod_configuration_ReturnArrayThruPtr_reg(reg, cmock_len) ccsm_drv_set_mod_configuration_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_len * sizeof(*reg)) +#define ccsm_drv_set_mod_configuration_ReturnMemThruPtr_reg(reg, cmock_size) ccsm_drv_set_mod_configuration_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_size) +void ccsm_drv_set_mod_configuration_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size); +#define ccsm_drv_set_mod_configuration_IgnoreArg_reg() ccsm_drv_set_mod_configuration_CMockIgnoreArg_reg(__LINE__) +void ccsm_drv_set_mod_configuration_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_set_mod_configuration_IgnoreArg_core_id() ccsm_drv_set_mod_configuration_CMockIgnoreArg_core_id(__LINE__) +void ccsm_drv_set_mod_configuration_CMockIgnoreArg_core_id(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_set_mod_configuration_IgnoreArg_config() ccsm_drv_set_mod_configuration_CMockIgnoreArg_config(__LINE__) +void ccsm_drv_set_mod_configuration_CMockIgnoreArg_config(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_is_irq_error_clear_IgnoreAndReturn(cmock_retval) ccsm_drv_is_irq_error_clear_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void ccsm_drv_is_irq_error_clear_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); +#define ccsm_drv_is_irq_error_clear_StopIgnore() ccsm_drv_is_irq_error_clear_CMockStopIgnore() +void ccsm_drv_is_irq_error_clear_CMockStopIgnore(void); +#define ccsm_drv_is_irq_error_clear_ExpectAnyArgsAndReturn(cmock_retval) ccsm_drv_is_irq_error_clear_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void ccsm_drv_is_irq_error_clear_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); +#define ccsm_drv_is_irq_error_clear_ExpectAndReturn(reg, cmock_retval) ccsm_drv_is_irq_error_clear_CMockExpectAndReturn(__LINE__, reg, cmock_retval) +void ccsm_drv_is_irq_error_clear_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, void* reg, bool cmock_to_return); +typedef bool (* CMOCK_ccsm_drv_is_irq_error_clear_CALLBACK)(void* reg, int cmock_num_calls); +void ccsm_drv_is_irq_error_clear_AddCallback(CMOCK_ccsm_drv_is_irq_error_clear_CALLBACK Callback); +void ccsm_drv_is_irq_error_clear_Stub(CMOCK_ccsm_drv_is_irq_error_clear_CALLBACK Callback); +#define ccsm_drv_is_irq_error_clear_StubWithCallback ccsm_drv_is_irq_error_clear_Stub +#define ccsm_drv_is_irq_error_clear_ExpectWithArrayAndReturn(reg, reg_Depth, cmock_retval) ccsm_drv_is_irq_error_clear_CMockExpectWithArrayAndReturn(__LINE__, reg, reg_Depth, cmock_retval) +void ccsm_drv_is_irq_error_clear_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, void* reg, int reg_Depth, bool cmock_to_return); +#define ccsm_drv_is_irq_error_clear_ReturnThruPtr_reg(reg) ccsm_drv_is_irq_error_clear_CMockReturnMemThruPtr_reg(__LINE__, reg, sizeof(void)) +#define ccsm_drv_is_irq_error_clear_ReturnArrayThruPtr_reg(reg, cmock_len) ccsm_drv_is_irq_error_clear_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_len * sizeof(*reg)) +#define ccsm_drv_is_irq_error_clear_ReturnMemThruPtr_reg(reg, cmock_size) ccsm_drv_is_irq_error_clear_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_size) +void ccsm_drv_is_irq_error_clear_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, void* reg, size_t cmock_size); +#define ccsm_drv_is_irq_error_clear_IgnoreArg_reg() ccsm_drv_is_irq_error_clear_CMockIgnoreArg_reg(__LINE__) +void ccsm_drv_is_irq_error_clear_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_clear_irq_error_IgnoreAndReturn(cmock_retval) ccsm_drv_get_clear_irq_error_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void ccsm_drv_get_clear_irq_error_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_get_clear_irq_error_StopIgnore() ccsm_drv_get_clear_irq_error_CMockStopIgnore() +void ccsm_drv_get_clear_irq_error_CMockStopIgnore(void); +#define ccsm_drv_get_clear_irq_error_ExpectAnyArgsAndReturn(cmock_retval) ccsm_drv_get_clear_irq_error_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void ccsm_drv_get_clear_irq_error_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_get_clear_irq_error_ExpectAndReturn(reg, error, cmock_retval) ccsm_drv_get_clear_irq_error_CMockExpectAndReturn(__LINE__, reg, error, cmock_retval) +void ccsm_drv_get_clear_irq_error_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, uint32_t* error, int cmock_to_return); +typedef int (* CMOCK_ccsm_drv_get_clear_irq_error_CALLBACK)(struct ccsm_reg* reg, uint32_t* error, int cmock_num_calls); +void ccsm_drv_get_clear_irq_error_AddCallback(CMOCK_ccsm_drv_get_clear_irq_error_CALLBACK Callback); +void ccsm_drv_get_clear_irq_error_Stub(CMOCK_ccsm_drv_get_clear_irq_error_CALLBACK Callback); +#define ccsm_drv_get_clear_irq_error_StubWithCallback ccsm_drv_get_clear_irq_error_Stub +#define ccsm_drv_get_clear_irq_error_ExpectWithArrayAndReturn(reg, reg_Depth, error, error_Depth, cmock_retval) ccsm_drv_get_clear_irq_error_CMockExpectWithArrayAndReturn(__LINE__, reg, reg_Depth, error, error_Depth, cmock_retval) +void ccsm_drv_get_clear_irq_error_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, uint32_t* error, int error_Depth, int cmock_to_return); +#define ccsm_drv_get_clear_irq_error_ReturnThruPtr_reg(reg) ccsm_drv_get_clear_irq_error_CMockReturnMemThruPtr_reg(__LINE__, reg, sizeof(struct ccsm_reg)) +#define ccsm_drv_get_clear_irq_error_ReturnArrayThruPtr_reg(reg, cmock_len) ccsm_drv_get_clear_irq_error_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_len * sizeof(*reg)) +#define ccsm_drv_get_clear_irq_error_ReturnMemThruPtr_reg(reg, cmock_size) ccsm_drv_get_clear_irq_error_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_size) +void ccsm_drv_get_clear_irq_error_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size); +#define ccsm_drv_get_clear_irq_error_ReturnThruPtr_error(error) ccsm_drv_get_clear_irq_error_CMockReturnMemThruPtr_error(__LINE__, error, sizeof(uint32_t)) +#define ccsm_drv_get_clear_irq_error_ReturnArrayThruPtr_error(error, cmock_len) ccsm_drv_get_clear_irq_error_CMockReturnMemThruPtr_error(__LINE__, error, cmock_len * sizeof(*error)) +#define ccsm_drv_get_clear_irq_error_ReturnMemThruPtr_error(error, cmock_size) ccsm_drv_get_clear_irq_error_CMockReturnMemThruPtr_error(__LINE__, error, cmock_size) +void ccsm_drv_get_clear_irq_error_CMockReturnMemThruPtr_error(UNITY_LINE_TYPE cmock_line, uint32_t* error, size_t cmock_size); +#define ccsm_drv_get_clear_irq_error_IgnoreArg_reg() ccsm_drv_get_clear_irq_error_CMockIgnoreArg_reg(__LINE__) +void ccsm_drv_get_clear_irq_error_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_clear_irq_error_IgnoreArg_error() ccsm_drv_get_clear_irq_error_CMockIgnoreArg_error(__LINE__) +void ccsm_drv_get_clear_irq_error_CMockIgnoreArg_error(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_is_irq_status_clear_IgnoreAndReturn(cmock_retval) ccsm_drv_is_irq_status_clear_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void ccsm_drv_is_irq_status_clear_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); +#define ccsm_drv_is_irq_status_clear_StopIgnore() ccsm_drv_is_irq_status_clear_CMockStopIgnore() +void ccsm_drv_is_irq_status_clear_CMockStopIgnore(void); +#define ccsm_drv_is_irq_status_clear_ExpectAnyArgsAndReturn(cmock_retval) ccsm_drv_is_irq_status_clear_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void ccsm_drv_is_irq_status_clear_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); +#define ccsm_drv_is_irq_status_clear_ExpectAndReturn(reg, cmock_retval) ccsm_drv_is_irq_status_clear_CMockExpectAndReturn(__LINE__, reg, cmock_retval) +void ccsm_drv_is_irq_status_clear_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, void* reg, bool cmock_to_return); +typedef bool (* CMOCK_ccsm_drv_is_irq_status_clear_CALLBACK)(void* reg, int cmock_num_calls); +void ccsm_drv_is_irq_status_clear_AddCallback(CMOCK_ccsm_drv_is_irq_status_clear_CALLBACK Callback); +void ccsm_drv_is_irq_status_clear_Stub(CMOCK_ccsm_drv_is_irq_status_clear_CALLBACK Callback); +#define ccsm_drv_is_irq_status_clear_StubWithCallback ccsm_drv_is_irq_status_clear_Stub +#define ccsm_drv_is_irq_status_clear_ExpectWithArrayAndReturn(reg, reg_Depth, cmock_retval) ccsm_drv_is_irq_status_clear_CMockExpectWithArrayAndReturn(__LINE__, reg, reg_Depth, cmock_retval) +void ccsm_drv_is_irq_status_clear_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, void* reg, int reg_Depth, bool cmock_to_return); +#define ccsm_drv_is_irq_status_clear_ReturnThruPtr_reg(reg) ccsm_drv_is_irq_status_clear_CMockReturnMemThruPtr_reg(__LINE__, reg, sizeof(void)) +#define ccsm_drv_is_irq_status_clear_ReturnArrayThruPtr_reg(reg, cmock_len) ccsm_drv_is_irq_status_clear_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_len * sizeof(*reg)) +#define ccsm_drv_is_irq_status_clear_ReturnMemThruPtr_reg(reg, cmock_size) ccsm_drv_is_irq_status_clear_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_size) +void ccsm_drv_is_irq_status_clear_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, void* reg, size_t cmock_size); +#define ccsm_drv_is_irq_status_clear_IgnoreArg_reg() ccsm_drv_is_irq_status_clear_CMockIgnoreArg_reg(__LINE__) +void ccsm_drv_is_irq_status_clear_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_clear_irq_status_IgnoreAndReturn(cmock_retval) ccsm_drv_get_clear_irq_status_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void ccsm_drv_get_clear_irq_status_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_get_clear_irq_status_StopIgnore() ccsm_drv_get_clear_irq_status_CMockStopIgnore() +void ccsm_drv_get_clear_irq_status_CMockStopIgnore(void); +#define ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(cmock_retval) ccsm_drv_get_clear_irq_status_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void ccsm_drv_get_clear_irq_status_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_get_clear_irq_status_ExpectAndReturn(reg, status, cmock_retval) ccsm_drv_get_clear_irq_status_CMockExpectAndReturn(__LINE__, reg, status, cmock_retval) +void ccsm_drv_get_clear_irq_status_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, uint32_t* status, int cmock_to_return); +typedef int (* CMOCK_ccsm_drv_get_clear_irq_status_CALLBACK)(struct ccsm_reg* reg, uint32_t* status, int cmock_num_calls); +void ccsm_drv_get_clear_irq_status_AddCallback(CMOCK_ccsm_drv_get_clear_irq_status_CALLBACK Callback); +void ccsm_drv_get_clear_irq_status_Stub(CMOCK_ccsm_drv_get_clear_irq_status_CALLBACK Callback); +#define ccsm_drv_get_clear_irq_status_StubWithCallback ccsm_drv_get_clear_irq_status_Stub +#define ccsm_drv_get_clear_irq_status_ExpectWithArrayAndReturn(reg, reg_Depth, status, status_Depth, cmock_retval) ccsm_drv_get_clear_irq_status_CMockExpectWithArrayAndReturn(__LINE__, reg, reg_Depth, status, status_Depth, cmock_retval) +void ccsm_drv_get_clear_irq_status_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, uint32_t* status, int status_Depth, int cmock_to_return); +#define ccsm_drv_get_clear_irq_status_ReturnThruPtr_reg(reg) ccsm_drv_get_clear_irq_status_CMockReturnMemThruPtr_reg(__LINE__, reg, sizeof(struct ccsm_reg)) +#define ccsm_drv_get_clear_irq_status_ReturnArrayThruPtr_reg(reg, cmock_len) ccsm_drv_get_clear_irq_status_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_len * sizeof(*reg)) +#define ccsm_drv_get_clear_irq_status_ReturnMemThruPtr_reg(reg, cmock_size) ccsm_drv_get_clear_irq_status_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_size) +void ccsm_drv_get_clear_irq_status_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size); +#define ccsm_drv_get_clear_irq_status_ReturnThruPtr_status(status) ccsm_drv_get_clear_irq_status_CMockReturnMemThruPtr_status(__LINE__, status, sizeof(uint32_t)) +#define ccsm_drv_get_clear_irq_status_ReturnArrayThruPtr_status(status, cmock_len) ccsm_drv_get_clear_irq_status_CMockReturnMemThruPtr_status(__LINE__, status, cmock_len * sizeof(*status)) +#define ccsm_drv_get_clear_irq_status_ReturnMemThruPtr_status(status, cmock_size) ccsm_drv_get_clear_irq_status_CMockReturnMemThruPtr_status(__LINE__, status, cmock_size) +void ccsm_drv_get_clear_irq_status_CMockReturnMemThruPtr_status(UNITY_LINE_TYPE cmock_line, uint32_t* status, size_t cmock_size); +#define ccsm_drv_get_clear_irq_status_IgnoreArg_reg() ccsm_drv_get_clear_irq_status_CMockIgnoreArg_reg(__LINE__) +void ccsm_drv_get_clear_irq_status_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_get_clear_irq_status_IgnoreArg_status() ccsm_drv_get_clear_irq_status_CMockIgnoreArg_status(__LINE__) +void ccsm_drv_get_clear_irq_status_CMockIgnoreArg_status(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_is_request_complete_IgnoreAndReturn(cmock_retval) ccsm_drv_is_request_complete_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void ccsm_drv_is_request_complete_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); +#define ccsm_drv_is_request_complete_StopIgnore() ccsm_drv_is_request_complete_CMockStopIgnore() +void ccsm_drv_is_request_complete_CMockStopIgnore(void); +#define ccsm_drv_is_request_complete_ExpectAnyArgsAndReturn(cmock_retval) ccsm_drv_is_request_complete_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void ccsm_drv_is_request_complete_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return); +#define ccsm_drv_is_request_complete_ExpectAndReturn(reg, cmock_retval) ccsm_drv_is_request_complete_CMockExpectAndReturn(__LINE__, reg, cmock_retval) +void ccsm_drv_is_request_complete_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, void* reg, bool cmock_to_return); +typedef bool (* CMOCK_ccsm_drv_is_request_complete_CALLBACK)(void* reg, int cmock_num_calls); +void ccsm_drv_is_request_complete_AddCallback(CMOCK_ccsm_drv_is_request_complete_CALLBACK Callback); +void ccsm_drv_is_request_complete_Stub(CMOCK_ccsm_drv_is_request_complete_CALLBACK Callback); +#define ccsm_drv_is_request_complete_StubWithCallback ccsm_drv_is_request_complete_Stub +#define ccsm_drv_is_request_complete_ExpectWithArrayAndReturn(reg, reg_Depth, cmock_retval) ccsm_drv_is_request_complete_CMockExpectWithArrayAndReturn(__LINE__, reg, reg_Depth, cmock_retval) +void ccsm_drv_is_request_complete_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, void* reg, int reg_Depth, bool cmock_to_return); +#define ccsm_drv_is_request_complete_ReturnThruPtr_reg(reg) ccsm_drv_is_request_complete_CMockReturnMemThruPtr_reg(__LINE__, reg, sizeof(void)) +#define ccsm_drv_is_request_complete_ReturnArrayThruPtr_reg(reg, cmock_len) ccsm_drv_is_request_complete_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_len * sizeof(*reg)) +#define ccsm_drv_is_request_complete_ReturnMemThruPtr_reg(reg, cmock_size) ccsm_drv_is_request_complete_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_size) +void ccsm_drv_is_request_complete_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, void* reg, size_t cmock_size); +#define ccsm_drv_is_request_complete_IgnoreArg_reg() ccsm_drv_is_request_complete_CMockIgnoreArg_reg(__LINE__) +void ccsm_drv_is_request_complete_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_set_request_IgnoreAndReturn(cmock_retval) ccsm_drv_set_request_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void ccsm_drv_set_request_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_set_request_StopIgnore() ccsm_drv_set_request_CMockStopIgnore() +void ccsm_drv_set_request_CMockStopIgnore(void); +#define ccsm_drv_set_request_ExpectAnyArgsAndReturn(cmock_retval) ccsm_drv_set_request_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void ccsm_drv_set_request_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_set_request_ExpectAndReturn(reg, req_type, cmock_retval) ccsm_drv_set_request_CMockExpectAndReturn(__LINE__, reg, req_type, cmock_retval) +void ccsm_drv_set_request_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, enum mod_ccsm_request_type req_type, int cmock_to_return); +typedef int (* CMOCK_ccsm_drv_set_request_CALLBACK)(struct ccsm_reg* reg, enum mod_ccsm_request_type req_type, int cmock_num_calls); +void ccsm_drv_set_request_AddCallback(CMOCK_ccsm_drv_set_request_CALLBACK Callback); +void ccsm_drv_set_request_Stub(CMOCK_ccsm_drv_set_request_CALLBACK Callback); +#define ccsm_drv_set_request_StubWithCallback ccsm_drv_set_request_Stub +#define ccsm_drv_set_request_ExpectWithArrayAndReturn(reg, reg_Depth, req_type, cmock_retval) ccsm_drv_set_request_CMockExpectWithArrayAndReturn(__LINE__, reg, reg_Depth, req_type, cmock_retval) +void ccsm_drv_set_request_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, enum mod_ccsm_request_type req_type, int cmock_to_return); +#define ccsm_drv_set_request_ReturnThruPtr_reg(reg) ccsm_drv_set_request_CMockReturnMemThruPtr_reg(__LINE__, reg, sizeof(struct ccsm_reg)) +#define ccsm_drv_set_request_ReturnArrayThruPtr_reg(reg, cmock_len) ccsm_drv_set_request_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_len * sizeof(*reg)) +#define ccsm_drv_set_request_ReturnMemThruPtr_reg(reg, cmock_size) ccsm_drv_set_request_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_size) +void ccsm_drv_set_request_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size); +#define ccsm_drv_set_request_IgnoreArg_reg() ccsm_drv_set_request_CMockIgnoreArg_reg(__LINE__) +void ccsm_drv_set_request_CMockIgnoreArg_reg(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_set_request_IgnoreArg_req_type() ccsm_drv_set_request_CMockIgnoreArg_req_type(__LINE__) +void ccsm_drv_set_request_CMockIgnoreArg_req_type(UNITY_LINE_TYPE cmock_line); +#define ccsm_drv_clear_request_IgnoreAndReturn(cmock_retval) ccsm_drv_clear_request_CMockIgnoreAndReturn(__LINE__, cmock_retval) +void ccsm_drv_clear_request_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_clear_request_StopIgnore() ccsm_drv_clear_request_CMockStopIgnore() +void ccsm_drv_clear_request_CMockStopIgnore(void); +#define ccsm_drv_clear_request_ExpectAnyArgsAndReturn(cmock_retval) ccsm_drv_clear_request_CMockExpectAnyArgsAndReturn(__LINE__, cmock_retval) +void ccsm_drv_clear_request_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return); +#define ccsm_drv_clear_request_ExpectAndReturn(reg, cmock_retval) ccsm_drv_clear_request_CMockExpectAndReturn(__LINE__, reg, cmock_retval) +void ccsm_drv_clear_request_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int cmock_to_return); +typedef int (* CMOCK_ccsm_drv_clear_request_CALLBACK)(struct ccsm_reg* reg, int cmock_num_calls); +void ccsm_drv_clear_request_AddCallback(CMOCK_ccsm_drv_clear_request_CALLBACK Callback); +void ccsm_drv_clear_request_Stub(CMOCK_ccsm_drv_clear_request_CALLBACK Callback); +#define ccsm_drv_clear_request_StubWithCallback ccsm_drv_clear_request_Stub +#define ccsm_drv_clear_request_ExpectWithArrayAndReturn(reg, reg_Depth, cmock_retval) ccsm_drv_clear_request_CMockExpectWithArrayAndReturn(__LINE__, reg, reg_Depth, cmock_retval) +void ccsm_drv_clear_request_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, int reg_Depth, int cmock_to_return); +#define ccsm_drv_clear_request_ReturnThruPtr_reg(reg) ccsm_drv_clear_request_CMockReturnMemThruPtr_reg(__LINE__, reg, sizeof(struct ccsm_reg)) +#define ccsm_drv_clear_request_ReturnArrayThruPtr_reg(reg, cmock_len) ccsm_drv_clear_request_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_len * sizeof(*reg)) +#define ccsm_drv_clear_request_ReturnMemThruPtr_reg(reg, cmock_size) ccsm_drv_clear_request_CMockReturnMemThruPtr_reg(__LINE__, reg, cmock_size) +void ccsm_drv_clear_request_CMockReturnMemThruPtr_reg(UNITY_LINE_TYPE cmock_line, struct ccsm_reg* reg, size_t cmock_size); +#define ccsm_drv_clear_request_IgnoreArg_reg() ccsm_drv_clear_request_CMockIgnoreArg_reg(__LINE__) +void ccsm_drv_clear_request_CMockIgnoreArg_reg(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/ccsm/test/mod_ccsm_extra.h b/module/ccsm/test/mod_ccsm_extra.h new file mode 100644 index 000000000..e44009753 --- /dev/null +++ b/module/ccsm/test/mod_ccsm_extra.h @@ -0,0 +1,237 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include + +#include + +/* Driver functions*/ + +/*! + * \brief Get PLL static configuration registers. + * + * \param reg Pointer to the CCSM register struct. + * + * \param pll_select Selector for physical PLL to read from. + * + * \param[out] config Current static configuration register value for the PLL. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_E_PARAM The `pll_select` parameter was an invalid value. + */ +int ccsm_drv_get_pll_static_settings( + struct ccsm_reg *reg, + enum mod_ccsm_pll_static_select pll_select, + uint32_t *config); + +/*! + * \brief Get PLL dynamic configuration registers. + * + * \param reg Pointer to the CCSM register struct. + * + * \param pll_select Selector for which PLL to read from, nominal or fallback. + * + * \param[out] config0 Current register value read for settings 0. + * + * \param[out] config1 Current register value read for settings 1. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_E_PARAM The `pll_select` parameter was an invalid value. + */ +int ccsm_drv_get_pll_dynamic_settings( + struct ccsm_reg *reg, + enum mod_ccsm_pll_dynamic_select pll_select, + uint32_t *config0, + uint32_t *config1); + +/*! + * \brief Set static config for a PLL. + * + * \param reg Pointer to the CCSM register struct. + * + * \param pll_select Selector for which physical PLL to update. + * + * \param config The register value to be set for static config of PLL. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_E_PARAM The `pll_select` parameter was an invalid value. + */ +int ccsm_drv_set_pll_static_settings( + struct ccsm_reg *reg, + enum mod_ccsm_pll_static_select pll_select, + uint32_t config); + +/*! + * \brief Set dynamic config for a PLL. + * + * \param reg Pointer to the CCSM register struct. + * + * \param pll_select Selector for which PLL to update, nominal or fallback. + * + * \param config0 The register value to be set for settings 0. + * + * \param config1 The register value to be set for settings 1. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_E_PARAM The `pll_select` parameter was an invalid value. + */ +int ccsm_drv_set_pll_dynamic_settings( + struct ccsm_reg *reg, + enum mod_ccsm_pll_dynamic_select pll_select, + uint32_t config0, + uint32_t config1); + +/*! + * \brief Get current droop mitigation config. + * + * \param reg Pointer to the CCSM register struct. + * + * \param[out] config Contents of current droop mitigation config register. + * + * \retval ::FWK_SUCCESS The operation succeeded. + */ +int ccsm_drv_get_dm_configuration(struct ccsm_reg *reg, uint32_t *config); + +/*! + * \brief Get droop mitigation telemetry. Requires debug to be enabled. + * + * \param reg Pointer to the CCSM register struct. + * + * \param[out] telemetry1 Contents of telemetry register 1. + * + * \param[out] telemetry2 Contents of telemetry register 2. + * + * \param[out] telemetry3 Contents of telemetry register 3. + * + * \retval ::FWK_SUCCESS The operation succeeded. + */ +int ccsm_drv_get_dm_telemetry( + struct ccsm_reg *reg, + uint32_t *telemetry1, + uint32_t *telemetry2, + uint32_t *telemetry3); + +/*! + * \brief Set target droop mitigation config, applied in next DVFS/DM command. + * + * \param reg Pointer to the CCSM register struct. + * + * \param[in] config The target droop mitigation config register value to set. + * + * \retval ::FWK_SUCCESS The operation succeeded. + */ +int ccsm_drv_set_dm_configuration(struct ccsm_reg *reg, uint32_t config); + +/*! + * \brief Get current modulator config for a core. + * + * \param reg Pointer to the CCSM register struct. + * + * \param core_id Identifier for the core. + * + * \param[out] config The current modulator config register value. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_E_PARAM The `core_id` parameter was an invalid value. + */ +int ccsm_drv_get_mod_configuration( + struct ccsm_reg *reg, + enum mod_ccsm_mod_select core_id, + uint32_t *config); + +/*! + * \brief Set modulator configuration, to be applied in next set_mod command. + * + * \param reg Pointer to the CCSM register struct. + * + * \param core_id Identifier for the core to be updated. + * + * \param config The target modulator config register value to set. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_E_PARAM The `core_id` parameter was an invalid value. + */ +int ccsm_drv_set_mod_configuration( + struct ccsm_reg *reg, + enum mod_ccsm_mod_select core_id, + uint32_t config); + +/*! + * \brief Check if IRQ error register is clear. + * + * \param reg Pointer to the CCSM register struct. + * + * \retval true The IRQ error register is clear. + * \retval false The IRQ error register is not clear. + */ +bool ccsm_drv_is_irq_error_clear(void *reg); + +/*! + * \brief Get IRQ error register and clear. + * + * \param reg Pointer to the CCSM register struct. + * + * \param[out] error The IRQ error register contents. + * + * \retval ::FWK_SUCCESS The operation succeeded. + */ +int ccsm_drv_get_clear_irq_error(struct ccsm_reg *reg, uint32_t *error); + +/*! + * \brief Check if IRQ status register is clear. + * + * \param reg Pointer to the CCSM register struct. + * + * \retval true The IRQ status register is clear. + * \retval false The IRQ status register is not clear. + */ +bool ccsm_drv_is_irq_status_clear(void *reg); + +/*! + * \brief Get IRQ status register and clear. + * + * \param reg Pointer to the CCSM register struct. + * + * \param[out] status The IRQ status register contents. + * + * \retval ::FWK_SUCCESS The operation succeeded. + */ +int ccsm_drv_get_clear_irq_status(struct ccsm_reg *reg, uint32_t *status); + +/*! + * \brief Check if current CCSM request is complete. + * + * \param reg Pointer to the CCSM register struct. + * + * \retval true The request is complete. + * \retval false The request is ongoing. + */ +bool ccsm_drv_is_request_complete(void *reg); + +/*! + * \brief Set request registers and trigger a CCSM request. + * + * \param reg Pointer to the CCSM register struct. + * + * \param req_type Type of request to be triggered. + * + * \retval ::FWK_SUCCESS The operation succeeded. + * \retval ::FWK_E_DEVICE A request has not been cleared from the device. + * \retval ::FWK_E_BUSY A request is still ongoing. + */ +int ccsm_drv_set_request( + struct ccsm_reg *reg, + enum mod_ccsm_request_type req_type); + +/*! + * \brief Clear request registers. + * + * \param reg Pointer to the CCSM register struct. + * + * \retval ::FWK_SUCCESS The operation succeeded. + */ +int ccsm_drv_clear_request(struct ccsm_reg *reg); diff --git a/module/ccsm/test/mod_ccsm_unit_test.c b/module/ccsm/test/mod_ccsm_unit_test.c new file mode 100644 index 000000000..c7d022258 --- /dev/null +++ b/module/ccsm/test/mod_ccsm_unit_test.c @@ -0,0 +1,1271 @@ +/* + * Arm SCP/MCP Software + * Copyright (c) 2024, Arm Limited and Contributors. All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "scp_unity.h" +#include "unity.h" + +#ifdef TEST_ON_TARGET +# include +# include +#else +# include +# include +#endif + +#include + +#include + +#include +#include + +#include UNIT_TEST_SRC + +#define BUILD_HAS_BASE_PROTOCOL + +#define FAKE_MODULE_ID 0x5 + +enum fake_ccsm { + FAKE_CCSM_IDX_CONTINUOUS, + FAKE_CCSM_IDX_INDEXED, + FAKE_CCSM_IDX_COUNT, +}; + +#define FAKE_API_IDX_TIMER 0x4 + +#define CLOCK_RATE_MAX 2000 * FWK_MHZ +#define CLOCK_RATE_MIN 300 * FWK_MHZ + +static const struct mod_ccsm_clock_rate clock_config_default = { 1500 * FWK_MHZ, + 0 }; + +static const struct mod_ccsm_dm_config dm_config_default = { + .strategy = MOD_CCSM_DM_NOM_ONLY, + .dd = MOD_CCSM_DM_ARM_DD, + .soff = MOD_CCSM_DM_SW_SOFF_STOP, + .transition_pause = 6, + .mitigation_duration = 144 +}; + +static const struct mod_ccsm_mod_config mod_config_default = { + .numerator_oc = 1, + .numerator_regular = 1, + .denominator = 1 +}; + +static const struct mod_ccsm_clock_rate_reg_value reg_rate_table_fake[] = { + { .clock_rate_hz = 100 * FWK_MHZ, + .pll_settings_0 = 0x01000000, + .pll_settings_1 = 0xFFFF0100 }, + { .clock_rate_hz = 200 * FWK_MHZ, + .pll_settings_0 = 0x02000000, + .pll_settings_1 = 0xFFFF0200 }, + { .clock_rate_hz = 300 * FWK_MHZ, + .pll_settings_0 = 0x03000000, + .pll_settings_1 = 0xFFFF0300 }, + { .clock_rate_hz = 400 * FWK_MHZ, + .pll_settings_0 = 0x04000000, + .pll_settings_1 = 0xFFFF0400 }, + { .clock_rate_hz = 500 * FWK_MHZ, + .pll_settings_0 = 0x05000000, + .pll_settings_1 = 0xFFFF0500 }, + { .clock_rate_hz = 600 * FWK_MHZ, + .pll_settings_0 = 0x06000000, + .pll_settings_1 = 0xFFFF0600 }, + { .clock_rate_hz = 700 * FWK_MHZ, + .pll_settings_0 = 0x07000000, + .pll_settings_1 = 0xFFFF0700 }, + { .clock_rate_hz = 800 * FWK_MHZ, + .pll_settings_0 = 0x08000000, + .pll_settings_1 = 0xFFFF0800 }, + { .clock_rate_hz = 900 * FWK_MHZ, + .pll_settings_0 = 0x09000000, + .pll_settings_1 = 0xFFFF0900 }, + { .clock_rate_hz = 1000 * FWK_MHZ, + .pll_settings_0 = 0x10000000, + .pll_settings_1 = 0xFFFF1000 }, + { .clock_rate_hz = 1100 * FWK_MHZ, + .pll_settings_0 = 0x11000000, + .pll_settings_1 = 0xFFFF1100 }, + { .clock_rate_hz = 1200 * FWK_MHZ, + .pll_settings_0 = 0x12000000, + .pll_settings_1 = 0xFFFF1200 }, + { .clock_rate_hz = 1300 * FWK_MHZ, + .pll_settings_0 = 0x13000000, + .pll_settings_1 = 0xFFFF1300 }, + { .clock_rate_hz = 1400 * FWK_MHZ, + .pll_settings_0 = 0x14000000, + .pll_settings_1 = 0xFFFF1400 }, + { .clock_rate_hz = 1500 * FWK_MHZ, + .pll_settings_0 = 0x15000000, + .pll_settings_1 = 0xFFFF1500 }, + { .clock_rate_hz = 1600 * FWK_MHZ, + .pll_settings_0 = 0x16000000, + .pll_settings_1 = 0xFFFF1600 }, + { .clock_rate_hz = 1700 * FWK_MHZ, + .pll_settings_0 = 0x17000000, + .pll_settings_1 = 0xFFFF1700 }, + { .clock_rate_hz = 1800 * FWK_MHZ, + .pll_settings_0 = 0x18000000, + .pll_settings_1 = 0xFFFF1800 }, + { .clock_rate_hz = 1900 * FWK_MHZ, + .pll_settings_0 = 0x19000000, + .pll_settings_1 = 0xFFFF1900 }, + { .clock_rate_hz = 2000 * FWK_MHZ, + .pll_settings_0 = 0x20000000, + .pll_settings_1 = 0xFFFF2000 } +}; + +static const struct mod_ccsm_clock_rate rate_table_fake[] = { + { /* Super Underdrive */ + .nominal_clock_rate_hz = 300 * FWK_MHZ, + .fallback_clock_rate_hz = 0 }, + { /* Nominal */ + .nominal_clock_rate_hz = 1500 * FWK_MHZ, + .fallback_clock_rate_hz = 0 }, + { /* Overdrive */ + .nominal_clock_rate_hz = 1800 * FWK_MHZ, + .fallback_clock_rate_hz = 1600 * FWK_MHZ }, + { /* Super Overdrive */ + .nominal_clock_rate_hz = 2000 * FWK_MHZ, + .fallback_clock_rate_hz = 1800 * FWK_MHZ }, +}; + +static const struct fwk_element element_table[] = { + [FAKE_CCSM_IDX_CONTINUOUS] = { .name = "CCSM continuous", + .data = + &(struct mod_ccsm_dev_config){ + .rate_lookup_table_is_provided = + false, + .minimum_clock_rate_fallback_enable_hz = + 1700 * FWK_MHZ, + .fallback_clock_percentage = 90, + .min_clock_rate_hz = CLOCK_RATE_MIN, + .max_clock_rate_hz = CLOCK_RATE_MAX, + .clock_rate_step_hz = 100 * FWK_MHZ, + .base_address = 0xBA5E, + .default_rates_table = + &clock_config_default, + .register_rate_table = + reg_rate_table_fake, + .register_rate_count = 20, + .droop_mitigation_default = + &dm_config_default, + .modulator_default = + &mod_config_default, + .modulator_count = 1 } }, + [FAKE_CCSM_IDX_INDEXED] = { .name = "CCSM indexed", + .data = + &(struct mod_ccsm_dev_config){ + .rate_lookup_table_is_provided = true, + .base_address = 0x1DBA5E, + .min_clock_rate_hz = CLOCK_RATE_MIN, + .max_clock_rate_hz = CLOCK_RATE_MAX, + .clock_rate_step_hz = 100 * FWK_MHZ, + .default_rates_table = + &clock_config_default, + .droop_mitigation_default = + &dm_config_default, + .modulator_default = + &mod_config_default, + .modulator_count = 1, + .register_rate_table = + reg_rate_table_fake, + .register_rate_count = 20, + .rate_table = rate_table_fake, + .rate_count = 4 } }, + [FAKE_CCSM_IDX_COUNT] = { 0 }, +}; + +static const struct fwk_element *get_element_table(fwk_id_t module_id) +{ + return element_table; +} + +struct fwk_module_config config_ccsm = { + .elements = FWK_MODULE_DYNAMIC_ELEMENTS(get_element_table), +}; + +static int ccsm_dummy_wait( + fwk_id_t dev_id, + uint32_t microseconds, + bool (*cond)(void *), + void *data) +{ + return FWK_SUCCESS; +} + +struct mod_timer_api *timer_api = + &(struct mod_timer_api){ .wait = ccsm_dummy_wait }; + +void setUp(void) +{ + struct ccsm_dev_ctx *ctx; + + module_ctx.dev_ctx_table = + fwk_mm_calloc(FAKE_CCSM_IDX_COUNT, sizeof(module_ctx.dev_ctx_table[0])); + module_ctx.dev_count = FAKE_CCSM_IDX_COUNT; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + ctx->config = + (struct mod_ccsm_dev_config *)element_table[FAKE_CCSM_IDX_CONTINUOUS] + .data; + ctx->initialized = true; + ctx->current_nominal_clock_rate_hz = + ctx->config->default_rates_table->nominal_clock_rate_hz; + ctx->current_fallback_clock_rate_hz = + ctx->config->default_rates_table->fallback_clock_rate_hz; + ctx->current_state = MOD_CLOCK_STATE_RUNNING; + ctx->timer_api = timer_api; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_INDEXED]; + ctx->config = + (struct mod_ccsm_dev_config *)element_table[FAKE_CCSM_IDX_INDEXED].data; + ctx->initialized = true; + ctx->current_nominal_clock_rate_hz = + ctx->config->default_rates_table->nominal_clock_rate_hz; + ctx->current_fallback_clock_rate_hz = + ctx->config->default_rates_table->fallback_clock_rate_hz; + ctx->current_state = MOD_CLOCK_STATE_RUNNING; + ctx->timer_api = timer_api; +} + +void tearDown(void) +{ +} + +void test_function_ccsm_clock_select_rates_pass_continuous_in_range(void) +{ + int status; + struct mod_ccsm_clock_rate clock_rates; + struct ccsm_dev_ctx *ctx; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + + status = ccsm_clock_select_rates( + ctx, + ((1800 * FWK_MHZ) - (90 * FWK_MHZ)), + MOD_CLOCK_ROUND_MODE_UP, + &clock_rates); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(1800 * FWK_MHZ, clock_rates.nominal_clock_rate_hz); + TEST_ASSERT_EQUAL(1600 * FWK_MHZ, clock_rates.fallback_clock_rate_hz); +} + +void test_function_ccsm_clock_select_rates_pass_continuous_min(void) +{ + int status; + struct mod_ccsm_clock_rate clock_rates; + struct ccsm_dev_ctx *ctx; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + + status = ccsm_clock_select_rates( + ctx, + ((400 * FWK_MHZ) - (10 * FWK_MHZ)), + MOD_CLOCK_ROUND_MODE_DOWN, + &clock_rates); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(300 * FWK_MHZ, clock_rates.nominal_clock_rate_hz); + TEST_ASSERT_EQUAL(0, clock_rates.fallback_clock_rate_hz); +} + +void test_function_ccsm_clock_select_rates_pass_continuous_max(void) +{ + int status; + struct mod_ccsm_clock_rate clock_rates; + struct ccsm_dev_ctx *ctx; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + + status = ccsm_clock_select_rates( + ctx, + ((2000 * FWK_MHZ) - (49 * FWK_MHZ)), + MOD_CLOCK_ROUND_MODE_NEAREST, + &clock_rates); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(2000 * FWK_MHZ, clock_rates.nominal_clock_rate_hz); + TEST_ASSERT_EQUAL(1800 * FWK_MHZ, clock_rates.fallback_clock_rate_hz); +} + +void test_function_ccsm_clock_select_rates_fail_continuous_low(void) +{ + int status; + struct mod_ccsm_clock_rate clock_rates; + struct ccsm_dev_ctx *ctx; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + + status = ccsm_clock_select_rates( + ctx, + ((200 * FWK_MHZ) - (10 * FWK_MHZ)), + MOD_CLOCK_ROUND_MODE_DOWN, + &clock_rates); + + TEST_ASSERT_EQUAL(FWK_E_SUPPORT, status); +} + +void test_function_ccsm_clock_select_rates_fail_continuous_high(void) +{ + int status; + struct mod_ccsm_clock_rate clock_rates; + struct ccsm_dev_ctx *ctx; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + + status = ccsm_clock_select_rates( + ctx, + ((2200 * FWK_MHZ) - (10 * FWK_MHZ)), + MOD_CLOCK_ROUND_MODE_DOWN, + &clock_rates); + + TEST_ASSERT_EQUAL(FWK_E_SUPPORT, status); +} + +void test_function_ccsm_clock_select_rates_pass_indexed_in_range(void) +{ + int status; + struct mod_ccsm_clock_rate clock_rates; + struct ccsm_dev_ctx *ctx; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_INDEXED]; + + status = ccsm_clock_select_rates( + ctx, (1800 * FWK_MHZ), MOD_CLOCK_ROUND_MODE_UP, &clock_rates); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(1800 * FWK_MHZ, clock_rates.nominal_clock_rate_hz); + TEST_ASSERT_EQUAL(1600 * FWK_MHZ, clock_rates.fallback_clock_rate_hz); +} + +void test_function_ccsm_clock_select_rates_pass_indexed_min(void) +{ + int status; + struct mod_ccsm_clock_rate clock_rates; + struct ccsm_dev_ctx *ctx; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_INDEXED]; + + status = ccsm_clock_select_rates( + ctx, (300 * FWK_MHZ), MOD_CLOCK_ROUND_MODE_DOWN, &clock_rates); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(300 * FWK_MHZ, clock_rates.nominal_clock_rate_hz); + TEST_ASSERT_EQUAL(0, clock_rates.fallback_clock_rate_hz); +} + +void test_function_ccsm_clock_select_rates_pass_indexed_max(void) +{ + int status; + struct mod_ccsm_clock_rate clock_rates; + struct ccsm_dev_ctx *ctx; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_INDEXED]; + + status = ccsm_clock_select_rates( + ctx, (2000 * FWK_MHZ), MOD_CLOCK_ROUND_MODE_NEAREST, &clock_rates); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(2000 * FWK_MHZ, clock_rates.nominal_clock_rate_hz); + TEST_ASSERT_EQUAL(1800 * FWK_MHZ, clock_rates.fallback_clock_rate_hz); +} + +void test_function_ccsm_clock_select_rates_fail_indexed_low(void) +{ + int status; + struct mod_ccsm_clock_rate clock_rates; + struct ccsm_dev_ctx *ctx; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_INDEXED]; + + status = ccsm_clock_select_rates( + ctx, (200 * FWK_MHZ), MOD_CLOCK_ROUND_MODE_DOWN, &clock_rates); + + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void test_function_ccsm_clock_select_rates_fail_indexed_high(void) +{ + int status; + struct mod_ccsm_clock_rate clock_rates; + struct ccsm_dev_ctx *ctx; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_INDEXED]; + + status = ccsm_clock_select_rates( + ctx, (2200 * FWK_MHZ), MOD_CLOCK_ROUND_MODE_DOWN, &clock_rates); + + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void test_function_ccsm_clock_select_rates_fail_round_none(void) +{ + int status; + struct mod_ccsm_clock_rate clock_rates; + struct ccsm_dev_ctx *ctx; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + + status = ccsm_clock_select_rates( + ctx, + ((1800 * FWK_MHZ) - (100 * FWK_KHZ)), + MOD_CLOCK_ROUND_MODE_NONE, + &clock_rates); + + TEST_ASSERT_EQUAL(FWK_E_RANGE, status); +} + +void test_function_ccsm_clock_set_rate_pass_continuous_uninitialized(void) +{ + int status; + uint64_t rate = 1800 * FWK_MHZ; + uint64_t read_rate; + struct ccsm_dev_ctx *ctx; + + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + ctx->initialized = false; + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + ccsm_drv_set_mod_configuration_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_set_dm_configuration_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_SET_DM, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_SET_MOD, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + ccsm_drv_set_pll_static_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_set_pll_static_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_SET_DVFS, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + status = ccsm_clock_set_rate(dev_id, rate, MOD_CLOCK_ROUND_MODE_NEAREST); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + status = ccsm_clock_get_rate(dev_id, &read_rate); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(1800 * FWK_MHZ, read_rate); + + ctx->initialized = true; +} + +void test_function_ccsm_clock_set_rate_pass_indexed_initialized(void) +{ + int status; + uint64_t rate = 1800 * FWK_MHZ; + uint64_t read_rate; + struct ccsm_dev_ctx *ctx; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_INDEXED); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_INDEXED]; + ctx->initialized = true; + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_INDEXED); + + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_GO_UP, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_GO_UP2, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + status = ccsm_clock_set_rate(dev_id, rate, MOD_CLOCK_ROUND_MODE_NEAREST); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_INDEXED); + + status = ccsm_clock_get_rate(dev_id, &read_rate); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(1800 * FWK_MHZ, read_rate); +} + +void test_function_ccsm_clock_set_rate_pass_indexed_uninitialized(void) +{ + int status; + uint64_t rate = 1800 * FWK_MHZ; + uint64_t read_rate; + struct ccsm_dev_ctx *ctx; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_INDEXED); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_INDEXED]; + ctx->initialized = false; + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_INDEXED); + + ccsm_drv_set_mod_configuration_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_set_dm_configuration_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_SET_DM, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_SET_MOD, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + ccsm_drv_set_pll_static_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_set_pll_static_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_SET_DVFS, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + status = ccsm_clock_set_rate(dev_id, rate, MOD_CLOCK_ROUND_MODE_NEAREST); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_INDEXED); + + status = ccsm_clock_get_rate(dev_id, &read_rate); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(1800 * FWK_MHZ, read_rate); +} + +void test_function_ccsm_clock_set_rate_pass_continuous_initialized(void) +{ + int status; + uint64_t rate = 1800 * FWK_MHZ; + uint64_t read_rate; + struct ccsm_dev_ctx *ctx; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_GO_UP, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_GO_UP2, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + status = ccsm_clock_set_rate(dev_id, rate, MOD_CLOCK_ROUND_MODE_NEAREST); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + status = ccsm_clock_get_rate(dev_id, &read_rate); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(1800 * FWK_MHZ, read_rate); +} + +void test_function_ccsm_clock_set_rate_pass_continuous_initialized_dn(void) +{ + int status; + uint64_t rate = 1800 * FWK_MHZ; + uint64_t read_rate; + struct ccsm_dev_ctx *ctx; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + ctx->current_nominal_clock_rate_hz = 2000 * FWK_MHZ; + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_GO_DN, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_GO_DN2, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + status = ccsm_clock_set_rate(dev_id, rate, MOD_CLOCK_ROUND_MODE_NEAREST); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + status = ccsm_clock_get_rate(dev_id, &read_rate); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(1800 * FWK_MHZ, read_rate); +} + +void test_function_ccsm_clock_set_rate_fail_stopped(void) +{ + int status; + uint64_t rate = 1800 * FWK_MHZ; + struct ccsm_dev_ctx *ctx; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + ctx->current_state = MOD_CLOCK_STATE_STOPPED; + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + status = ccsm_clock_set_rate(dev_id, rate, MOD_CLOCK_ROUND_MODE_NEAREST); + TEST_ASSERT_EQUAL(FWK_E_PWRSTATE, status); +} + +void test_function_ccsm_clock_set_rate_pass_same_rate(void) +{ + int status; + uint64_t rate; + uint64_t read_rate; + struct ccsm_dev_ctx *ctx; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + rate = ctx->config->default_rates_table->nominal_clock_rate_hz; + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + status = ccsm_clock_set_rate(dev_id, rate, MOD_CLOCK_ROUND_MODE_NEAREST); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + status = ccsm_clock_get_rate(dev_id, &read_rate); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(rate, read_rate); +} + +void test_function_ccsm_clock_get_rate_pass(void) +{ + int status; + uint64_t rate; + struct ccsm_dev_ctx *ctx; + + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + status = ccsm_clock_get_rate(dev_id, &rate); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL( + ctx->config->default_rates_table->nominal_clock_rate_hz, rate); +} + +void test_function_ccsm_clock_get_rate_from_index_pass(void) +{ + int status; + uint64_t rate; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_INDEXED); + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_INDEXED); + + status = ccsm_clock_get_rate_from_index(dev_id, 0, &rate); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(300 * FWK_MHZ, rate); +} + +void test_function_ccsm_clock_get_rate_from_index_fail_rate_null(void) +{ + int status; + uint64_t *rate = NULL; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_INDEXED); + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + + status = ccsm_clock_get_rate_from_index(dev_id, 0, rate); + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void test_function_ccsm_clock_get_rate_from_index_fail_count_exceeded(void) +{ + int status; + uint64_t rate; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_INDEXED); + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_INDEXED); + + status = ccsm_clock_get_rate_from_index(dev_id, 4, &rate); + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} +void test_function_ccsm_clock_get_rate_from_index_fail_continuous(void) +{ + int status; + uint64_t rate; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + status = ccsm_clock_get_rate_from_index(dev_id, 0, &rate); + TEST_ASSERT_EQUAL(FWK_E_SUPPORT, status); +} + +void test_function_ccsm_dm_get_configuration_pass(void) +{ + int status; + uint32_t ccsm_strategy_in; + struct mod_ccsm_dm_config dm_config = { 0 }; + struct ccsm_dev_ctx *ctx; + + ccsm_strategy_in = 0x11011FFFu; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + + ccsm_drv_get_dm_configuration_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_get_dm_configuration_ReturnThruPtr_config(&ccsm_strategy_in); + + status = ccsm_dm_get_configuration(ctx, &dm_config); + + TEST_ASSERT_EQUAL(status, FWK_SUCCESS); + + TEST_ASSERT_EQUAL(ccsm_strategy_in, 0x11011FFFu); + TEST_ASSERT_EQUAL(MOD_CCSM_DM_SW_FB, dm_config.strategy); + TEST_ASSERT_EQUAL(MOD_CCSM_DM_TPIP, dm_config.dd); + TEST_ASSERT_EQUAL(MOD_CCSM_DM_SW_SOFF_STOP, dm_config.soff); + TEST_ASSERT_EQUAL(15, dm_config.transition_pause); + TEST_ASSERT_EQUAL(511, dm_config.mitigation_duration); + + ccsm_strategy_in = 0x11021FFFu; + + ccsm_drv_get_dm_configuration_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_get_dm_configuration_ReturnThruPtr_config(&ccsm_strategy_in); + + status = ccsm_dm_get_configuration(ctx, &dm_config); + + TEST_ASSERT_EQUAL(status, FWK_SUCCESS); + + TEST_ASSERT_EQUAL(MOD_CCSM_DM_NOM_ONLY, dm_config.strategy); + TEST_ASSERT_EQUAL(MOD_CCSM_DM_TPIP, dm_config.dd); + TEST_ASSERT_EQUAL(MOD_CCSM_DM_SW_SOFF_STOP, dm_config.soff); + TEST_ASSERT_EQUAL(15, dm_config.transition_pause); + TEST_ASSERT_EQUAL(511, dm_config.mitigation_duration); + + ccsm_strategy_in = 0x01001FFFu; + + ccsm_drv_get_dm_configuration_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_get_dm_configuration_ReturnThruPtr_config(&ccsm_strategy_in); + + status = ccsm_dm_get_configuration(ctx, &dm_config); + + TEST_ASSERT_EQUAL(status, FWK_SUCCESS); + + TEST_ASSERT_EQUAL(MOD_CCSM_DM_STOP_CLK, dm_config.strategy); + TEST_ASSERT_EQUAL(MOD_CCSM_DM_ARM_DD, dm_config.dd); + TEST_ASSERT_EQUAL(MOD_CCSM_DM_SW_SOFF_STOP, dm_config.soff); + TEST_ASSERT_EQUAL(15, dm_config.transition_pause); + TEST_ASSERT_EQUAL(511, dm_config.mitigation_duration); + + ccsm_strategy_in = 0x00101FFFu; + + ccsm_drv_get_dm_configuration_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_get_dm_configuration_ReturnThruPtr_config(&ccsm_strategy_in); + + status = ccsm_dm_get_configuration(ctx, &dm_config); + + TEST_ASSERT_EQUAL(status, FWK_SUCCESS); + + TEST_ASSERT_EQUAL(MOD_CCSM_DM_CLK_ON_DVFS, dm_config.strategy); + TEST_ASSERT_EQUAL(MOD_CCSM_DM_ARM_DD, dm_config.dd); + TEST_ASSERT_EQUAL(MOD_CCSM_DM_SW_SOFF_IGNORE, dm_config.soff); + TEST_ASSERT_EQUAL(15, dm_config.transition_pause); + TEST_ASSERT_EQUAL(511, dm_config.mitigation_duration); +} + +void test_function_ccsm_dm_set_configuration_pass(void) +{ + int status; + + struct ccsm_dev_ctx *ctx; + + struct mod_ccsm_dm_config dm_config = { .strategy = MOD_CCSM_DM_NOM_ONLY, + .dd = MOD_CCSM_DM_ARM_DD, + .soff = MOD_CCSM_DM_SW_SOFF_IGNORE, + .transition_pause = 6, + .mitigation_duration = 705 }; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + + ccsm_drv_set_dm_configuration_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, 0x00022C16, FWK_SUCCESS); + + status = ccsm_dm_set_configuration(ctx, &dm_config); + TEST_ASSERT_EQUAL(status, FWK_SUCCESS); +} + +void test_function_ccsm_mod_set_configuration_pass(void) +{ + int status; + struct ccsm_dev_ctx *ctx; + struct mod_ccsm_mod_config mod_config = { .numerator_regular = 240, + .numerator_oc = 31, + .denominator = 255 }; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + + ccsm_drv_set_mod_configuration_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + 0, + 0x001FFFF0, + FWK_SUCCESS); + + status = ccsm_mod_set_configuration(ctx, 0, &mod_config); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void test_function_ccsm_mod_set_configuration_fail(void) +{ + int status; + struct ccsm_dev_ctx *ctx; + struct mod_ccsm_mod_config mod_config = { .numerator_regular = 255, + .numerator_oc = 31, + .denominator = 100 }; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + + status = ccsm_mod_set_configuration(ctx, 0, &mod_config); + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void test_function_ccsm_clock_set_state_pass(void) +{ + int status; + struct ccsm_dev_ctx *ctx; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + + status = ccsm_clock_set_state(dev_id, MOD_CLOCK_STATE_RUNNING); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(MOD_CLOCK_STATE_RUNNING, ctx->current_state); +} + +void test_function_ccsm_clock_set_state_fail(void) +{ + int status; + struct ccsm_dev_ctx *ctx; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + + status = ccsm_clock_set_state(dev_id, MOD_CLOCK_STATE_STOPPED); + TEST_ASSERT_EQUAL(FWK_E_SUPPORT, status); + TEST_ASSERT_EQUAL(MOD_CLOCK_STATE_RUNNING, ctx->current_state); +} + +void test_function_ccsm_clock_get_state_pass(void) +{ + int status; + enum mod_clock_state cur_state; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + status = ccsm_clock_get_state(dev_id, &cur_state); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(MOD_CLOCK_STATE_RUNNING, cur_state); +} + +void test_function_ccsm_clock_get_state_fail(void) +{ + int status; + enum mod_clock_state *cur_state = NULL; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + + status = ccsm_clock_get_state(dev_id, cur_state); + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void test_function_ccsm_clock_get_range_continuous_pass(void) +{ + int status; + struct mod_clock_range range; + struct ccsm_dev_ctx *ctx; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + status = ccsm_clock_get_range(dev_id, &range); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(MOD_CLOCK_RATE_TYPE_CONTINUOUS, range.rate_type); + TEST_ASSERT_EQUAL(ctx->config->min_clock_rate_hz, range.min); + TEST_ASSERT_EQUAL(ctx->config->max_clock_rate_hz, range.max); + TEST_ASSERT_EQUAL(ctx->config->clock_rate_step_hz, range.step); +} + +void test_function_ccsm_clock_get_range_fail_null(void) +{ + int status; + struct mod_clock_range *range = NULL; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + + status = ccsm_clock_get_range(dev_id, range); + TEST_ASSERT_EQUAL(FWK_E_PARAM, status); +} + +void test_function_ccsm_clock_get_range_indexed_pass(void) +{ + int status; + struct mod_clock_range range; + struct ccsm_dev_ctx *ctx; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_INDEXED); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_INDEXED]; + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_INDEXED); + + status = ccsm_clock_get_range(dev_id, &range); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(MOD_CLOCK_RATE_TYPE_DISCRETE, range.rate_type); + TEST_ASSERT_EQUAL( + ctx->config->rate_table[0].nominal_clock_rate_hz, range.min); + TEST_ASSERT_EQUAL( + ctx->config->rate_table[ctx->config->rate_count - 1] + .nominal_clock_rate_hz, + range.max); + TEST_ASSERT_EQUAL(ctx->config->rate_count, range.rate_count); +} + +void test_function_ccsm_power_state_change_off_pass(void) +{ + int status; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + status = ccsm_clock_power_state_change(dev_id, MOD_PD_STATE_OFF); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void test_function_ccsm_power_state_change_on_pass(void) +{ + int status; + uint64_t rate = 1900 * FWK_MHZ; + uint64_t read_rate; + struct ccsm_dev_ctx *ctx; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + ctx->initialized = true; + ctx->current_nominal_clock_rate_hz = rate; + + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + ccsm_drv_set_mod_configuration_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_get_dm_configuration_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_set_dm_configuration_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_SET_DM, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_SET_MOD, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + ccsm_drv_set_pll_static_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_set_pll_static_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_SET_DVFS, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + status = ccsm_clock_power_state_change(dev_id, MOD_PD_STATE_ON); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + status = ccsm_clock_get_rate(dev_id, &read_rate); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(rate, read_rate); +} + +void test_function_ccsm_clock_power_state_pending_change_pass(void) +{ + int status; + struct ccsm_dev_ctx *ctx; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_CONTINUOUS]; + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_CONTINUOUS); + + status = ccsm_clock_power_state_pending_change(dev_id, 0, MOD_PD_STATE_OFF); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(MOD_CLOCK_STATE_STOPPED, ctx->current_state); +} + +void test_function_ccsm_init(void) +{ + int status; + + status = ccsm_init(FWK_ID_MODULE(FWK_MODULE_IDX_CCSM), 0, NULL); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + + status = ccsm_init( + FWK_ID_MODULE(FWK_MODULE_IDX_CCSM), FAKE_CCSM_IDX_COUNT, NULL); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +void test_function_ccsm_element_init(void) +{ + int status; + struct ccsm_dev_ctx *ctx; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_INDEXED); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_INDEXED]; + + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_INDEXED); + + status = + ccsm_element_init(dev_id, 0, element_table[FAKE_CCSM_IDX_INDEXED].data); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + + TEST_ASSERT_EQUAL(ctx->initialized, false); + TEST_ASSERT_EQUAL(ctx->current_state, MOD_CLOCK_STATE_STOPPED); + + dev_id = FWK_ID_ELEMENT(FAKE_MODULE_ID, FAKE_CCSM_IDX_COUNT); + + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_COUNT); + + status = + ccsm_element_init(dev_id, 0, element_table[FAKE_CCSM_IDX_INDEXED].data); + TEST_ASSERT_EQUAL(FWK_E_DATA, status); +} + +void test_function_ccsm_process_bind_request(void) +{ + int status; + struct mod_clock_drv_api *clock_api; + fwk_id_t req_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_INDEXED); + fwk_id_t element_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + fwk_id_t api_type = FWK_ID_API(FAKE_MODULE_ID, MOD_CCSM_CLOCK_API); + + fwk_id_get_api_idx_ExpectAndReturn(api_type, MOD_CCSM_CLOCK_API); + + status = ccsm_process_bind_request( + req_id, element_id, api_type, (const void **)&clock_api); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL_PTR(&api_ccsm_clock, clock_api); +} + +void test_function_ccsm_bind(void) +{ + int status; + fwk_id_t req_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_CONTINUOUS); + + fwk_id_is_type_ExpectAndReturn(req_id, FWK_ID_TYPE_ELEMENT, true); + fwk_id_get_element_idx_ExpectAndReturn(req_id, FAKE_CCSM_IDX_INDEXED); + fwk_module_bind_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + status = ccsm_bind(req_id, 1); + + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); +} + +int ccsm_test_main(void) +{ + UNITY_BEGIN(); + + RUN_TEST(test_function_ccsm_init); + RUN_TEST(test_function_ccsm_element_init); + RUN_TEST(test_function_ccsm_process_bind_request); + RUN_TEST(test_function_ccsm_bind); + + RUN_TEST(test_function_ccsm_clock_select_rates_pass_continuous_in_range); + RUN_TEST(test_function_ccsm_clock_select_rates_pass_continuous_max); + RUN_TEST(test_function_ccsm_clock_select_rates_pass_continuous_min); + RUN_TEST(test_function_ccsm_clock_select_rates_fail_continuous_low); + RUN_TEST(test_function_ccsm_clock_select_rates_fail_continuous_high); + + RUN_TEST(test_function_ccsm_clock_select_rates_pass_indexed_in_range); + RUN_TEST(test_function_ccsm_clock_select_rates_pass_indexed_max); + RUN_TEST(test_function_ccsm_clock_select_rates_pass_indexed_min); + RUN_TEST(test_function_ccsm_clock_select_rates_fail_indexed_low); + RUN_TEST(test_function_ccsm_clock_select_rates_fail_indexed_high); + + RUN_TEST(test_function_ccsm_clock_select_rates_fail_round_none); + + RUN_TEST(test_function_ccsm_clock_set_rate_pass_indexed_uninitialized); + RUN_TEST(test_function_ccsm_clock_set_rate_pass_indexed_initialized); + + RUN_TEST(test_function_ccsm_clock_set_rate_pass_continuous_uninitialized); + RUN_TEST(test_function_ccsm_clock_set_rate_pass_continuous_initialized); + RUN_TEST(test_function_ccsm_clock_set_rate_pass_continuous_initialized_dn); + + RUN_TEST(test_function_ccsm_clock_set_rate_pass_same_rate); + RUN_TEST(test_function_ccsm_clock_set_rate_fail_stopped); + + RUN_TEST(test_function_ccsm_clock_get_rate_pass); + + RUN_TEST(test_function_ccsm_clock_get_rate_from_index_pass); + RUN_TEST(test_function_ccsm_clock_get_rate_from_index_fail_count_exceeded); + RUN_TEST(test_function_ccsm_clock_get_rate_from_index_fail_rate_null); + RUN_TEST(test_function_ccsm_clock_get_rate_from_index_fail_continuous); + + RUN_TEST(test_function_ccsm_dm_get_configuration_pass); + RUN_TEST(test_function_ccsm_dm_set_configuration_pass); + + RUN_TEST(test_function_ccsm_mod_set_configuration_pass); + RUN_TEST(test_function_ccsm_mod_set_configuration_fail); + + RUN_TEST(test_function_ccsm_clock_set_state_pass); + RUN_TEST(test_function_ccsm_clock_set_state_fail); + RUN_TEST(test_function_ccsm_clock_get_state_pass); + RUN_TEST(test_function_ccsm_clock_get_state_fail); + + RUN_TEST(test_function_ccsm_clock_get_range_continuous_pass); + RUN_TEST(test_function_ccsm_clock_get_range_fail_null); + RUN_TEST(test_function_ccsm_clock_get_range_indexed_pass); + + RUN_TEST(test_function_ccsm_power_state_change_off_pass); + RUN_TEST(test_function_ccsm_power_state_change_on_pass); + + RUN_TEST(test_function_ccsm_clock_power_state_pending_change_pass); + + return UNITY_END(); +} + +#if !defined(TEST_ON_TARGET) +int main(void) +{ + return ccsm_test_main(); +} +#endif diff --git a/unit_test/CMakeLists.txt b/unit_test/CMakeLists.txt index c20685a86..21109531c 100644 --- a/unit_test/CMakeLists.txt +++ b/unit_test/CMakeLists.txt @@ -110,6 +110,7 @@ list(APPEND UNIT_MODULE armv8r_mpu) list(APPEND UNIT_MODULE amu_mmap) list(APPEND UNIT_MODULE amu_smcf_drv) list(APPEND UNIT_MODULE atu) +list(APPEND UNIT_MODULE ccsm) list(APPEND UNIT_MODULE dvfs) list(APPEND UNIT_MODULE fch_polled) list(APPEND UNIT_MODULE gtimer) -- GitLab From da994d5f43f2463c6d30e232656aa6ebc301312d Mon Sep 17 00:00:00 2001 From: Ellie Lewis Date: Wed, 17 Jul 2024 14:49:21 +0100 Subject: [PATCH 3/4] module/ccsm: Add fallback configuration support Enables support for configuring fallback PLL in CCSM, enabling use of switch to fallback droop mitigation mode. Signed-off-by: Ellie Lewis --- module/ccsm/src/mod_ccsm.c | 86 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 83 insertions(+), 3 deletions(-) diff --git a/module/ccsm/src/mod_ccsm.c b/module/ccsm/src/mod_ccsm.c index b07d70fad..78904e80a 100644 --- a/module/ccsm/src/mod_ccsm.c +++ b/module/ccsm/src/mod_ccsm.c @@ -114,9 +114,7 @@ static int get_register_value_rate( return FWK_E_PARAM; } - if (pll_settings_0 == NULL || pll_settings_1 == NULL) { - return FWK_E_PARAM; - } + fwk_assert((pll_settings_0 != NULL) || (pll_settings_1 != NULL)); /* * Perform a binary search to find the entry matching the requested rate. @@ -221,6 +219,32 @@ static int set_static_pll_settings(struct ccsm_dev_ctx *ctx) return status; } +static int set_fallback_dynamic_settings( + struct ccsm_dev_ctx *ctx, + uint64_t fallback_clock_rate_hz) +{ + int status; + uint32_t settings_0_register_value; + uint32_t settings_1_register_value; + + status = get_register_value_rate( + ctx, + fallback_clock_rate_hz, + &settings_0_register_value, + &settings_1_register_value); + if (status != FWK_SUCCESS) { + return status; + } + + status = ccsm_drv_set_pll_dynamic_settings( + (struct ccsm_reg *)ctx->config->base_address, + MOD_CCSM_PLL_FALLBACK, + settings_0_register_value, + settings_1_register_value); + + return status; +} + static inline uint64_t clock_rate_round_nearest( uint64_t rate, uint64_t clock_rate_step) @@ -432,6 +456,50 @@ static int ccsm_dm_get_configuration( return FWK_SUCCESS; } +static int sw_fb_dm_config_handler( + struct ccsm_dev_ctx *ctx, + struct mod_ccsm_clock_rate rate_entry) +{ + int status; + struct mod_ccsm_dm_config dm_config; + + /* Fallback remains enabled, no change required. */ + if ((rate_entry.fallback_clock_rate_hz != 0) && + (ctx->current_fallback_clock_rate_hz != 0)) { + return FWK_SUCCESS; + } + + /* Fallback remains disabled, no change required. */ + if ((rate_entry.fallback_clock_rate_hz == 0) && + (ctx->current_fallback_clock_rate_hz == 0)) { + return FWK_SUCCESS; + } + + status = ccsm_dm_get_configuration(ctx, &dm_config); + if (status != FWK_SUCCESS) { + return status; + } + + if ((rate_entry.fallback_clock_rate_hz == 0) && + (dm_config.strategy == MOD_CCSM_DM_SW_FB)) { + /* Switch to nominal only so fallback can be disabled */ + dm_config.strategy = MOD_CCSM_DM_NOM_ONLY; + + status = ccsm_dm_set_configuration(ctx, &dm_config); + } else if ( + (ctx->current_fallback_clock_rate_hz == 0) && + (dm_config.strategy == MOD_CCSM_DM_NOM_ONLY)) { + /* Restore switch to fallback configuration */ + dm_config.strategy = MOD_CCSM_DM_SW_FB; + + status = ccsm_dm_set_configuration(ctx, &dm_config); + } else { + status = FWK_SUCCESS; + } + + return status; +} + /*! Get register values from PLL driver and update CCSM. */ static int ccsm_clock_update_registers( struct ccsm_dev_ctx *ctx, @@ -466,6 +534,11 @@ static int ccsm_clock_update_registers( return status; } + if (clock_rates->fallback_clock_rate_hz != 0) { + status = set_fallback_dynamic_settings( + ctx, clock_rates->fallback_clock_rate_hz); + } + return status; } @@ -567,6 +640,13 @@ static int ccsm_clock_set_rate( return status; } + if (ctx->config->droop_mitigation_default->strategy == MOD_CCSM_DM_SW_FB) { + status = sw_fb_dm_config_handler(ctx, clock_rates); + if (status != FWK_SUCCESS) { + return status; + } + } + /* Send DVFS command as required */ if (clock_rates.nominal_clock_rate_hz > ctx->current_nominal_clock_rate_hz) { -- GitLab From 1cf442d56a95a28f503c5bcb3f3a494d10d5c309 Mon Sep 17 00:00:00 2001 From: Ellie Lewis Date: Wed, 17 Jul 2024 14:50:05 +0100 Subject: [PATCH 4/4] module/ccsm: Update tests to handle dual-PLL programming Signed-off-by: Ellie Lewis --- module/ccsm/test/mod_ccsm_unit_test.c | 170 +++++++++++++++++++++++++- 1 file changed, 167 insertions(+), 3 deletions(-) diff --git a/module/ccsm/test/mod_ccsm_unit_test.c b/module/ccsm/test/mod_ccsm_unit_test.c index c7d022258..d7b78c5fd 100644 --- a/module/ccsm/test/mod_ccsm_unit_test.c +++ b/module/ccsm/test/mod_ccsm_unit_test.c @@ -32,6 +32,7 @@ enum fake_ccsm { FAKE_CCSM_IDX_CONTINUOUS, FAKE_CCSM_IDX_INDEXED, + FAKE_CCSM_IDX_INDEXED_SWFB, FAKE_CCSM_IDX_COUNT, }; @@ -43,7 +44,7 @@ enum fake_ccsm { static const struct mod_ccsm_clock_rate clock_config_default = { 1500 * FWK_MHZ, 0 }; -static const struct mod_ccsm_dm_config dm_config_default = { +static const struct mod_ccsm_dm_config dm_config_default_nom_only = { .strategy = MOD_CCSM_DM_NOM_ONLY, .dd = MOD_CCSM_DM_ARM_DD, .soff = MOD_CCSM_DM_SW_SOFF_STOP, @@ -51,6 +52,14 @@ static const struct mod_ccsm_dm_config dm_config_default = { .mitigation_duration = 144 }; +static const struct mod_ccsm_dm_config dm_config_default_sw_fb = { + .strategy = MOD_CCSM_DM_SW_FB, + .dd = MOD_CCSM_DM_ARM_DD, + .soff = MOD_CCSM_DM_SW_SOFF_STOP, + .transition_pause = 6, + .mitigation_duration = 144 +}; + static const struct mod_ccsm_mod_config mod_config_default = { .numerator_oc = 1, .numerator_regular = 1, @@ -154,7 +163,7 @@ static const struct fwk_element element_table[] = { reg_rate_table_fake, .register_rate_count = 20, .droop_mitigation_default = - &dm_config_default, + &dm_config_default_nom_only, .modulator_default = &mod_config_default, .modulator_count = 1 } }, @@ -169,7 +178,7 @@ static const struct fwk_element element_table[] = { .default_rates_table = &clock_config_default, .droop_mitigation_default = - &dm_config_default, + &dm_config_default_nom_only, .modulator_default = &mod_config_default, .modulator_count = 1, @@ -178,6 +187,30 @@ static const struct fwk_element element_table[] = { .register_rate_count = 20, .rate_table = rate_table_fake, .rate_count = 4 } }, + [FAKE_CCSM_IDX_INDEXED_SWFB] = { .name = "CCSM indexed switch to fallback", + .data = + &(struct mod_ccsm_dev_config){ + .rate_lookup_table_is_provided = + true, + .base_address = 0xFBBA5E, + .min_clock_rate_hz = + CLOCK_RATE_MIN, + .max_clock_rate_hz = + CLOCK_RATE_MAX, + .clock_rate_step_hz = + 100 * FWK_MHZ, + .default_rates_table = + &clock_config_default, + .droop_mitigation_default = + &dm_config_default_sw_fb, + .modulator_default = + &mod_config_default, + .modulator_count = 1, + .register_rate_table = + reg_rate_table_fake, + .register_rate_count = 20, + .rate_table = rate_table_fake, + .rate_count = 4 } }, [FAKE_CCSM_IDX_COUNT] = { 0 }, }; @@ -232,6 +265,18 @@ void setUp(void) ctx->config->default_rates_table->fallback_clock_rate_hz; ctx->current_state = MOD_CLOCK_STATE_RUNNING; ctx->timer_api = timer_api; + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_INDEXED_SWFB]; + ctx->config = + (struct mod_ccsm_dev_config *)element_table[FAKE_CCSM_IDX_INDEXED_SWFB] + .data; + ctx->initialized = true; + ctx->current_nominal_clock_rate_hz = + ctx->config->default_rates_table->nominal_clock_rate_hz; + ctx->current_fallback_clock_rate_hz = + ctx->config->default_rates_table->fallback_clock_rate_hz; + ctx->current_state = MOD_CLOCK_STATE_RUNNING; + ctx->timer_api = timer_api; } void tearDown(void) @@ -678,6 +723,122 @@ void test_function_ccsm_clock_set_rate_pass_continuous_initialized_dn(void) TEST_ASSERT_EQUAL(1800 * FWK_MHZ, read_rate); } +void test_function_ccsm_clock_set_rate_pass_swfb_up(void) +{ + int status; + uint64_t rate = 1800 * FWK_MHZ; + uint64_t read_rate; + uint32_t ccsm_strategy_nom_only = 0x000200FFu; + uint32_t ccsm_strategy_swfb = 0x000100FFu; + struct ccsm_dev_ctx *ctx; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_INDEXED_SWFB); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_INDEXED_SWFB]; + ctx->initialized = true; + ctx->current_nominal_clock_rate_hz = 1500 * FWK_MHZ; + ctx->current_fallback_clock_rate_hz = 0; + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_INDEXED_SWFB); + + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + ccsm_drv_get_dm_configuration_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_get_dm_configuration_ReturnThruPtr_config(&ccsm_strategy_nom_only); + + ccsm_drv_set_dm_configuration_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + ccsm_strategy_swfb, + FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_GO_UP, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_GO_UP2, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + status = ccsm_clock_set_rate(dev_id, rate, MOD_CLOCK_ROUND_MODE_NEAREST); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_INDEXED_SWFB); + + status = ccsm_clock_get_rate(dev_id, &read_rate); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(1800 * FWK_MHZ, read_rate); + TEST_ASSERT_EQUAL(1600 * FWK_MHZ, ctx->current_fallback_clock_rate_hz); +} + +void test_function_ccsm_clock_set_rate_pass_swfb_down(void) +{ + int status; + uint64_t rate = 1500 * FWK_MHZ; + uint64_t read_rate; + uint32_t ccsm_strategy_nom_only = 0x000200FFu; + uint32_t ccsm_strategy_swfb = 0x000100FFu; + struct ccsm_dev_ctx *ctx; + fwk_id_t dev_id = + FWK_ID_ELEMENT_INIT(FAKE_MODULE_ID, FAKE_CCSM_IDX_INDEXED_SWFB); + + ctx = &module_ctx.dev_ctx_table[FAKE_CCSM_IDX_INDEXED_SWFB]; + ctx->initialized = true; + ctx->current_nominal_clock_rate_hz = 1800 * FWK_MHZ; + ctx->current_fallback_clock_rate_hz = 1600; + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_INDEXED_SWFB); + + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_set_pll_dynamic_settings_ExpectAnyArgsAndReturn(FWK_SUCCESS); + + ccsm_drv_get_dm_configuration_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_get_dm_configuration_ReturnThruPtr_config(&ccsm_strategy_swfb); + + ccsm_drv_set_dm_configuration_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + ccsm_strategy_nom_only, + FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_GO_DN, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + ccsm_drv_set_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, + CCSM_REQUEST_TYPE_GO_DN2, + FWK_SUCCESS); + ccsm_drv_get_clear_irq_status_ExpectAnyArgsAndReturn(FWK_SUCCESS); + ccsm_drv_clear_request_ExpectAndReturn( + (struct ccsm_reg *)ctx->config->base_address, FWK_SUCCESS); + + status = ccsm_clock_set_rate(dev_id, rate, MOD_CLOCK_ROUND_MODE_NEAREST); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + + fwk_module_is_valid_element_id_ExpectAndReturn(dev_id, true); + fwk_id_get_element_idx_ExpectAndReturn(dev_id, FAKE_CCSM_IDX_INDEXED_SWFB); + + status = ccsm_clock_get_rate(dev_id, &read_rate); + TEST_ASSERT_EQUAL(FWK_SUCCESS, status); + TEST_ASSERT_EQUAL(1500 * FWK_MHZ, read_rate); + TEST_ASSERT_EQUAL(0, ctx->current_fallback_clock_rate_hz); +} + void test_function_ccsm_clock_set_rate_fail_stopped(void) { int status; @@ -1230,6 +1391,9 @@ int ccsm_test_main(void) RUN_TEST(test_function_ccsm_clock_set_rate_pass_continuous_initialized); RUN_TEST(test_function_ccsm_clock_set_rate_pass_continuous_initialized_dn); + RUN_TEST(test_function_ccsm_clock_set_rate_pass_swfb_up); + RUN_TEST(test_function_ccsm_clock_set_rate_pass_swfb_down); + RUN_TEST(test_function_ccsm_clock_set_rate_pass_same_rate); RUN_TEST(test_function_ccsm_clock_set_rate_fail_stopped); -- GitLab