diff --git a/doxygen/Doxyfile.erpc b/doxygen/Doxyfile.erpc index b3e5f091..cb3003e4 100644 --- a/doxygen/Doxyfile.erpc +++ b/doxygen/Doxyfile.erpc @@ -38,7 +38,7 @@ PROJECT_NAME = "eRPC API Reference" # could be handy for archiving the generated documentation or if some version # control system is used. -PROJECT_NUMBER = "Rev. 1.10.0" +PROJECT_NUMBER = "Rev. 1.11.0" # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer a diff --git a/doxygen/Doxyfile.erpcgen b/doxygen/Doxyfile.erpcgen index 348fffc9..97ff2321 100644 --- a/doxygen/Doxyfile.erpcgen +++ b/doxygen/Doxyfile.erpcgen @@ -38,7 +38,7 @@ PROJECT_NAME = "eRPC Generator (erpcgen)" # could be handy for archiving the generated documentation or if some version # control system is used. -PROJECT_NUMBER = "Rev. 1.10.0" +PROJECT_NUMBER = "Rev. 1.11.0" # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer a diff --git a/erpc_c/infra/erpc_version.h b/erpc_c/infra/erpc_version.h index bd52c132..7490eedc 100644 --- a/erpc_c/infra/erpc_version.h +++ b/erpc_c/infra/erpc_version.h @@ -1,6 +1,6 @@ /* * Copyright (c) 2016, Freescale Semiconductor, Inc. - * Copyright 2016-2022 NXP + * Copyright 2016-2023 NXP * All rights reserved. * * @@ -20,9 +20,9 @@ //////////////////////////////////////////////////////////////////////////////// //! @brief String version of eRPC. -#define ERPC_VERSION "1.10.0" +#define ERPC_VERSION "1.11.0" //! @brief Integer version of eRPC. -#define ERPC_VERSION_NUMBER 11000 +#define ERPC_VERSION_NUMBER 11100 /*! @} */ diff --git a/erpc_c/setup/erpc_setup_lpi2c_slave.cpp b/erpc_c/setup/erpc_setup_lpi2c_slave.cpp new file mode 100644 index 00000000..f527e1d1 --- /dev/null +++ b/erpc_c/setup/erpc_setup_lpi2c_slave.cpp @@ -0,0 +1,30 @@ +/* + * Copyright 2022-2023 NXP + * All rights reserved. + * + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "erpc_lpi2c_slave_transport.hpp" +#include "erpc_manually_constructed.hpp" +#include "erpc_transport_setup.h" + +using namespace erpc; + +//////////////////////////////////////////////////////////////////////////////// +// Variables +//////////////////////////////////////////////////////////////////////////////// + +static ManuallyConstructed s_transport; + +//////////////////////////////////////////////////////////////////////////////// +// Code +//////////////////////////////////////////////////////////////////////////////// + +erpc_transport_t erpc_transport_lpi2c_slave_init(void *baseAddr, uint32_t baudRate, uint32_t srcClock_Hz) +{ + s_transport.construct(reinterpret_cast(baseAddr), baudRate, srcClock_Hz); + (void)s_transport->init(); + return reinterpret_cast(s_transport.get()); +} diff --git a/erpc_c/setup/erpc_setup_lpspi_slave.cpp b/erpc_c/setup/erpc_setup_lpspi_slave.cpp new file mode 100644 index 00000000..3e254107 --- /dev/null +++ b/erpc_c/setup/erpc_setup_lpspi_slave.cpp @@ -0,0 +1,28 @@ +/* + * Copyright 2022-2023 NXP + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "erpc_lpspi_slave_transport.hpp" +#include "erpc_manually_constructed.hpp" +#include "erpc_transport_setup.h" + +using namespace erpc; + +//////////////////////////////////////////////////////////////////////////////// +// Variables +//////////////////////////////////////////////////////////////////////////////// + +ERPC_MANUALLY_CONSTRUCTED(LPSpiSlaveTransport, s_transport); + +//////////////////////////////////////////////////////////////////////////////// +// Code +//////////////////////////////////////////////////////////////////////////////// + +erpc_transport_t erpc_transport_lpspi_slave_init(void *baseAddr, uint32_t baudRate, uint32_t srcClock_Hz) +{ + s_transport.construct(reinterpret_cast(baseAddr), baudRate, srcClock_Hz); + (void)s_transport->init(); + return reinterpret_cast(s_transport.get()); +} diff --git a/erpc_c/setup/erpc_transport_setup.h b/erpc_c/setup/erpc_transport_setup.h index eaa8b0ce..a86f9840 100644 --- a/erpc_c/setup/erpc_transport_setup.h +++ b/erpc_c/setup/erpc_transport_setup.h @@ -1,6 +1,6 @@ /* * Copyright (c) 2014-2016, Freescale Semiconductor, Inc. - * Copyright 2016-2021 NXP + * Copyright 2016-2022 NXP * Copyright 2019 ACRIOS Systems s.r.o. * All rights reserved. * @@ -132,6 +132,23 @@ erpc_transport_t erpc_transport_dspi_master_init(void *baseAddr, uint32_t baudRa erpc_transport_t erpc_transport_dspi_slave_init(void *baseAddr, uint32_t baudRate, uint32_t srcClock_Hz); //@} +//! @name LPSPI transport setup +//@{ + +/*! + * @brief Create a LPSPI slave transport. + * + * Create LPSPI slave transport instance, to be used at slave core. + * + * @param[in] baseAddr Base address of LPSPI peripheral used in this transport layer. + * @param[in] baudRate LPSPI baud rate. + * @param[in] srcClock_Hz LPSPI source clock in Hz. + * + * @return Return NULL or erpc_transport_t instance pointer. + */ +erpc_transport_t erpc_transport_lpspi_slave_init(void *baseAddr, uint32_t baudRate, uint32_t srcClock_Hz); +//@} + //! @name SPIdev transport setup //@{ @@ -373,6 +390,23 @@ erpc_transport_t erpc_transport_usb_cdc_init(void *serialHandle, void *serialCon erpc_transport_t erpc_transport_i2c_slave_init(void *baseAddr, uint32_t baudRate, uint32_t srcClock_Hz); //@} +//! @name LPI2C transport setup +//@{ + +/*! + * @brief Create an LPI2C slave transport. + * + * Create LPI2C slave transport instance, to be used at slave core. + * + * @param[in] baseAddr Base address of LPI2C peripheral used in this transport layer. + * @param[in] baudRate SPI baud rate. + * @param[in] srcClock_Hz LPI2C source clock in Hz. + * + * @return Return NULL or erpc_transport_t instance pointer. + */ +erpc_transport_t erpc_transport_lpi2c_slave_init(void *baseAddr, uint32_t baudRate, uint32_t srcClock_Hz); +//@} + //@} #ifdef __cplusplus diff --git a/erpc_c/transports/erpc_i2c_slave_transport.hpp b/erpc_c/transports/erpc_i2c_slave_transport.hpp index 006d9b46..bd10280a 100644 --- a/erpc_c/transports/erpc_i2c_slave_transport.hpp +++ b/erpc_c/transports/erpc_i2c_slave_transport.hpp @@ -1,5 +1,5 @@ /* - * Copyright 2021 NXP + * Copyright 2021-2023 NXP * All rights reserved. * * @@ -9,7 +9,7 @@ #ifndef _EMBEDDED_RPC__I2C_SLAVE_TRANSPORT_H_ #define _EMBEDDED_RPC__I2C_SLAVE_TRANSPORT_H_ -#include "" +#include #include "erpc_config_internal.h" #if ERPC_THREADS #include "erpc_threading.h" diff --git a/erpc_c/transports/erpc_lpi2c_slave_transport.cpp b/erpc_c/transports/erpc_lpi2c_slave_transport.cpp new file mode 100644 index 00000000..96e3e7dc --- /dev/null +++ b/erpc_c/transports/erpc_lpi2c_slave_transport.cpp @@ -0,0 +1,242 @@ +/* + * Copyright 2022 NXP + * All rights reserved. + * + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "erpc_lpi2c_slave_transport.hpp" + +#include +#include + +extern "C" { +#include "board.h" +#include "fsl_gpio.h" +#include "fsl_lpi2c.h" +} + +using namespace std; +using namespace erpc; + +//////////////////////////////////////////////////////////////////////////////// +// Definitions +//////////////////////////////////////////////////////////////////////////////// + +#ifndef ERPC_BOARD_LPI2C_INT_GPIO +#error "Please define the ERPC_BOARD_LPI2C_INT_GPIO used to notify when the LPI2C Slave is ready to transmit" +#endif + +#define LPI2C_SLAVE_TRANSPORT_ADDR_7BIT (0x7EU) + +//////////////////////////////////////////////////////////////////////////////// +// Variables +//////////////////////////////////////////////////////////////////////////////// + +static lpi2c_slave_handle_t s_handle; +static volatile bool s_isTransferCompleted = false; +static LPI2cSlaveTransport *s_lpi2c_slave_instance = NULL; + +typedef struct lpi2c_clb_user_data +{ + uint8_t *tx_buffer; + uint32_t tx_size; + uint8_t *rx_buffer; + uint32_t rx_size; +} LPI2C_CLB_USER_DATA, *LPI2C_CLB_USER_DATA_PTR; +static volatile LPI2C_CLB_USER_DATA s_callback_user_data = { NULL, 0, NULL, 0 }; + +//////////////////////////////////////////////////////////////////////////////// +// Code +//////////////////////////////////////////////////////////////////////////////// + +/* @brief Initialize the GPIO used to notify the LPI2C Master */ +static inline void LPI2cSlaveTransport_NotifyTransferGpioInit() +{ + gpio_pin_config_t gpioConfig; + + gpioConfig.pinDirection = kGPIO_DigitalOutput; + gpioConfig.outputLogic = 1U; + +#ifdef ERPC_BOARD_LPI2C_INT_PORT + /* NXP LPC parts with the MCUXpressoSDK LPC GPIO driver */ + GPIO_PinInit(ERPC_BOARD_LPI2C_INT_GPIO, ERPC_BOARD_LPI2C_INT_PORT, ERPC_BOARD_LPI2C_INT_PIN, &gpioConfig); +#else + /* NXP Kinetis/iMX parts with the MCUXpressoSDK GPIO driver */ + GPIO_PinInit(ERPC_BOARD_LPI2C_INT_GPIO, ERPC_BOARD_LPI2C_INT_PIN, &gpioConfig); +#endif +} + +/* @brief Notify the LPI2C Master that the Slave is ready for a new transfer */ +static inline void LPI2cSlaveTransport_NotifyTransferGpioReady() +{ +#ifdef ERPC_BOARD_LPI2C_INT_PORT + /* NXP LPC parts with the MCUXpressoSDK LPC GPIO driver */ + GPIO_PortClear(ERPC_BOARD_LPI2C_INT_GPIO, ERPC_BOARD_LPI2C_INT_PORT, 1U << ERPC_BOARD_LPI2C_INT_PIN); +#else + /* NXP Kinetis/iMX parts with the MCUXpressoSDK GPIO driver */ + GPIO_PortClear(ERPC_BOARD_LPI2C_INT_GPIO, 1U << ERPC_BOARD_LPI2C_INT_PIN); +#endif +} + +/* @brief Notify the LPI2C Master that the Slave has finished the transfer */ +static inline void LPI2cSlaveTransport_NotifyTransferGpioCompleted() +{ +#ifdef ERPC_BOARD_LPI2C_INT_PORT + /* NXP LPC parts with the MCUXpressoSDK LPC GPIO driver */ + GPIO_PortSet(ERPC_BOARD_LPI2C_INT_GPIO, ERPC_BOARD_LPI2C_INT_PORT, 1U << ERPC_BOARD_LPI2C_INT_PIN); +#else + /* NXP Kinetis/iMX parts with the MCUXpressoSDK GPIO driver */ + GPIO_PortSet(ERPC_BOARD_LPI2C_INT_GPIO, 1U << ERPC_BOARD_LPI2C_INT_PIN); +#endif +} + +void LPI2cSlaveTransport::transfer_cb(void) +{ +#if ERPC_THREADS + m_txrxSemaphore.putFromISR(); +#else + s_isTransferCompleted = true; +#endif +} + +static void LPI2C_SlaveUserCallback(LPI2C_Type *base, lpi2c_slave_transfer_t *transfer, void *userData) +{ + LPI2cSlaveTransport *transport = s_lpi2c_slave_instance; + switch (transfer->event) + { + break; + /* Transmit request */ + case kLPI2C_SlaveTransmitEvent: + /* Update information for transmit process */ + transfer->data = ((LPI2C_CLB_USER_DATA *)userData)->tx_buffer; + transfer->dataSize = ((LPI2C_CLB_USER_DATA *)userData)->tx_size; + break; + + /* Setup the slave receive buffer */ + case kLPI2C_SlaveReceiveEvent: + /* Update information for received process */ + transfer->data = ((LPI2C_CLB_USER_DATA *)userData)->rx_buffer; + transfer->dataSize = ((LPI2C_CLB_USER_DATA *)userData)->rx_size; + break; + + /* The master has sent a stop transition on the bus */ + case kLPI2C_SlaveCompletionEvent: + /* Filter out dummy transaction completions (additional dummy recv./transmit) */ + if (!(transfer->transferredCount == 0 && transfer->dataSize == 0) && transfer->data != NULL) + { + transport->transfer_cb(); + transfer->data = NULL; + transfer->dataSize = 0; + } + break; + + default: + s_isTransferCompleted = false; + break; + } +} + +LPI2cSlaveTransport::LPI2cSlaveTransport(LPI2C_Type *lpi2cBaseAddr, uint32_t baudRate, uint32_t srcClock_Hz) +: m_lpi2cBaseAddr(lpi2cBaseAddr) +, m_baudRate(baudRate) +, m_srcClock_Hz(srcClock_Hz) +, m_isInited(false) +#if ERPC_THREADS +, m_txrxSemaphore() +#endif +{ + s_lpi2c_slave_instance = this; +} + +LPI2cSlaveTransport::~LPI2cSlaveTransport(void) +{ + if (m_isInited) + { + LPI2cSlaveTransport_NotifyTransferGpioCompleted(); + LPI2C_SlaveDeinit(m_lpi2cBaseAddr); + m_isInited = false; + } +} + +erpc_status_t LPI2cSlaveTransport::init(void) +{ + lpi2c_slave_config_t lpi2cConfig; + + LPI2C_SlaveGetDefaultConfig(&lpi2cConfig); + lpi2cConfig.address0 = (LPI2C_SLAVE_TRANSPORT_ADDR_7BIT); + + LPI2C_SlaveInit(m_lpi2cBaseAddr, &lpi2cConfig, m_srcClock_Hz); + LPI2C_SlaveTransferCreateHandle(m_lpi2cBaseAddr, &s_handle, LPI2C_SlaveUserCallback, (void *)&s_callback_user_data); + + LPI2cSlaveTransport_NotifyTransferGpioInit(); + + m_isInited = true; + return kErpcStatus_Success; +} + +erpc_status_t LPI2cSlaveTransport::underlyingReceive(uint8_t *data, uint32_t size) +{ + status_t status; + s_isTransferCompleted = false; + uint8_t dummy = 0x0; + + s_callback_user_data.rx_buffer = data; + s_callback_user_data.rx_size = size; + s_callback_user_data.tx_buffer = &dummy; + s_callback_user_data.tx_size = 1; + + status = LPI2C_SlaveTransferNonBlocking(m_lpi2cBaseAddr, &s_handle, kLPI2C_SlaveCompletionEvent); + + if (kStatus_Success == status) + { + LPI2cSlaveTransport_NotifyTransferGpioReady(); + +/* wait until the receiving is finished */ +#if ERPC_THREADS + m_txrxSemaphore.get(); +#else + while (!s_isTransferCompleted) + { + } +#endif + + LPI2cSlaveTransport_NotifyTransferGpioCompleted(); + } + + return (status != kStatus_Success) ? kErpcStatus_ReceiveFailed : kErpcStatus_Success; +} + +erpc_status_t LPI2cSlaveTransport::underlyingSend(const uint8_t *data, uint32_t size) +{ + status_t status; + s_isTransferCompleted = false; + + s_callback_user_data.rx_buffer = NULL; + s_callback_user_data.rx_size = 0; + s_callback_user_data.tx_buffer = (uint8_t *)data; + s_callback_user_data.tx_size = size; + + { + status = LPI2C_SlaveTransferNonBlocking(m_lpi2cBaseAddr, &s_handle, kLPI2C_SlaveCompletionEvent); + + if (kStatus_Success == status) + { + LPI2cSlaveTransport_NotifyTransferGpioReady(); + +/* wait until the sending is finished */ +#if ERPC_THREADS + m_txrxSemaphore.get(); +#else + while (!s_isTransferCompleted) + { + } +#endif + + LPI2cSlaveTransport_NotifyTransferGpioCompleted(); + } + } + + return (status != kStatus_Success) ? kErpcStatus_SendFailed : kErpcStatus_Success; +} diff --git a/erpc_c/transports/erpc_lpi2c_slave_transport.hpp b/erpc_c/transports/erpc_lpi2c_slave_transport.hpp new file mode 100644 index 00000000..407ed7ac --- /dev/null +++ b/erpc_c/transports/erpc_lpi2c_slave_transport.hpp @@ -0,0 +1,107 @@ +/* + * Copyright 2022-2023 NXP + * All rights reserved. + * + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef _EMBEDDED_RPC__LPI2C_SLAVE_TRANSPORT_H_ +#define _EMBEDDED_RPC__LPI2C_SLAVE_TRANSPORT_H_ + +#include "erpc_config_internal.h" +#if ERPC_THREADS +#include "erpc_threading.h" +#endif +#include "erpc_framed_transport.hpp" + +extern "C" { +#include "fsl_gpio.h" +#include "fsl_lpi2c.h" +} + +/*! + * @addtogroup lpi2c_slave_transport + * @{ + * @file + */ + +//////////////////////////////////////////////////////////////////////////////// +// Classes +//////////////////////////////////////////////////////////////////////////////// + +namespace erpc { +/*! + * @brief Very basic transport to send/receive messages via LPI2C. + * + * @ingroup lpi2c_slave_transport + */ +class LPI2cSlaveTransport : public FramedTransport +{ +public: + /*! + * @brief Constructor. + * + * @param[in] lpi2cBaseAddr LPI2C peripheral base address. + * @param[in] baudRate Baudrate. + * @param[in] srcClock_Hz Source clock. + */ + LPI2cSlaveTransport(LPI2C_Type *lpi2cBaseAddr, uint32_t baudRate, uint32_t srcClock_Hz); + + /*! + * @brief Destructor. + */ + virtual ~LPI2cSlaveTransport(void); + + /*! + * @brief Initialize LPI2C peripheral configuration structure with values specified in LPI2cTransport constructor. + * + * @retval kErpcStatus_Success Always returns success status. + */ + virtual erpc_status_t init(void); + + /*! + * @brief Function called from LPI2C_SlaveUserCallback when LPI2C transfer is completed + * + * Unblocks the send/receive function. + */ + void transfer_cb(void); + +protected: + LPI2C_Type *m_lpi2cBaseAddr; /*!< Base address of LPI2C peripheral used in this transport layer */ + uint32_t m_baudRate; /*!< Baud rate of LPI2C peripheral used in this transport layer */ + uint32_t m_srcClock_Hz; /*!< Source clock of LPI2C peripheral used in this transport layer */ + bool m_isInited; /*!< the LPI2C peripheral init status flag */ +#if ERPC_THREADS + Semaphore m_txrxSemaphore; /*!< Semaphore used by RTOS to block task until the sending/receiving is not complete */ +#endif + +private: + /*! + * @brief Receive data from LPI2C peripheral. + * + * @param[inout] data Preallocated buffer for receiving data. + * @param[in] size Size of data to read. + * + * @retval kErpcStatus_ReceiveFailed LPI2C failed to receive data. + * @retval kErpcStatus_Success Successfully received all data. + */ + virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size); + + /*! + * @brief Write data to LPI2C peripheral. + * + * @param[in] data Buffer to send. + * @param[in] size Size of data to send. + * + * @retval kErpcStatus_SendFailed LPI2C failed to send data. + * @retval kErpcStatus_Success Successfully sent all data. + */ + virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size); +}; + +} // namespace erpc + +/*! @} */ + +#endif // _EMBEDDED_RPC__LPI2C_SLAVE_TRANSPORT_H_ diff --git a/erpc_c/transports/erpc_lpspi_slave_transport.cpp b/erpc_c/transports/erpc_lpspi_slave_transport.cpp new file mode 100644 index 00000000..94f3ecc2 --- /dev/null +++ b/erpc_c/transports/erpc_lpspi_slave_transport.cpp @@ -0,0 +1,243 @@ +/* + * Copyright 2022 NXP + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "erpc_lpspi_slave_transport.hpp" + +#include +#include + +extern "C" { +#include "board.h" +#include "fsl_gpio.h" +#include "fsl_lpspi.h" +} + +using namespace std; +using namespace erpc; + +//////////////////////////////////////////////////////////////////////////////// +// Definitions +//////////////////////////////////////////////////////////////////////////////// + +#ifndef ERPC_BOARD_LPSPI_SLAVE_READY_USE_GPIO +#define ERPC_BOARD_LPSPI_SLAVE_READY_MARKER_LEN 2U +#define ERPC_BOARD_LPSPI_SLAVE_READY_MARKER1 0xABU +#define ERPC_BOARD_LPSPI_SLAVE_READY_MARKER2 0xCDU +#else +#ifndef ERPC_BOARD_LPSPI_INT_GPIO +#error "Please define the ERPC_BOARD_LPSPI_INT_GPIO used to notify when the LPSPI Slave is ready to transmit" +#endif +#endif + +//////////////////////////////////////////////////////////////////////////////// +// Variables +//////////////////////////////////////////////////////////////////////////////// + +static lpspi_slave_handle_t s_handle; +static volatile bool s_isTransferCompleted = false; +static LPSpiSlaveTransport *s_lpspi_slave_instance = NULL; + +//////////////////////////////////////////////////////////////////////////////// +// Code +//////////////////////////////////////////////////////////////////////////////// + +#ifdef ERPC_BOARD_LPSPI_SLAVE_READY_USE_GPIO +/* @brief Initialize the GPIO used to notify the LPSPI Master */ +static inline void LPSpiSlaveTransport_NotifyTransferGpioInit(void) +{ + gpio_pin_config_t gpioConfig; + + gpioConfig.pinDirection = kGPIO_DigitalOutput; + gpioConfig.outputLogic = 1U; + +#ifdef ERPC_BOARD_LPSPI_INT_GPIO_LPC + /* NXP LPC parts with the MCUXpressoSDK LPC GPIO driver */ + GPIO_PinInit(ERPC_BOARD_LPSPI_INT_GPIO, ERPC_BOARD_LPSPI_INT_PORT, ERPC_BOARD_LPSPI_INT_PIN, &gpioConfig); +#else + /* NXP Kinetis/iMX parts with the MCUXpressoSDK GPIO driver */ + GPIO_PinInit(ERPC_BOARD_LPSPI_INT_GPIO, ERPC_BOARD_LPSPI_INT_PIN, &gpioConfig); +#endif +} + +/* @brief Notify the LPSPI Master that the Slave is ready for a new transfer */ +static inline void LPSpiSlaveTransport_NotifyTransferGpioReady(void) +{ +#ifdef ERPC_BOARD_LPSPI_INT_GPIO_LPC + /* NXP LPC parts with the MCUXpressoSDK LPC GPIO driver */ + GPIO_PortClear(ERPC_BOARD_LPSPI_INT_GPIO, ERPC_BOARD_LPSPI_INT_PORT, 1U << ERPC_BOARD_LPSPI_INT_PIN); +#else + /* NXP Kinetis/iMX parts with the MCUXpressoSDK GPIO driver */ + GPIO_PortClear(ERPC_BOARD_LPSPI_INT_GPIO, 1U << ERPC_BOARD_LPSPI_INT_PIN); +#endif +} + +/* @brief Notify the LPSPI Master that the Slave has finished the transfer */ +static inline void LPSpiSlaveTransport_NotifyTransferGpioCompleted(void) +{ +#ifdef ERPC_BOARD_LPSPI_INT_GPIO_LPC + /* NXP LPC parts with the MCUXpressoSDK LPC GPIO driver */ + GPIO_PortSet(ERPC_BOARD_LPSPI_INT_GPIO, ERPC_BOARD_LPSPI_INT_PORT, 1U << ERPC_BOARD_LPSPI_INT_PIN); +#else + /* NXP Kinetis/iMX parts with the MCUXpressoSDK GPIO driver */ + GPIO_PortSet(ERPC_BOARD_LPSPI_INT_GPIO, 1U << ERPC_BOARD_LPSPI_INT_PIN); +#endif +} +#endif + +void LPSpiSlaveTransport::transfer_cb(void) +{ +#if ERPC_THREADS + m_txrxSemaphore.putFromISR(); +#else + s_isTransferCompleted = true; +#endif +} + +static void LPSPI_SlaveUserCallback(LPSPI_Type *base, lpspi_slave_handle_t *handle, status_t status, void *userData) +{ + (void)base; + (void)handle; + (void)status; + (void)userData; + + LPSpiSlaveTransport *transport = s_lpspi_slave_instance; + + transport->transfer_cb(); +} + +LPSpiSlaveTransport::LPSpiSlaveTransport(LPSPI_Type *lpspiBaseAddr, uint32_t baudRate, uint32_t srcClock_Hz) +: m_lpspiBaseAddr(lpspiBaseAddr) +, m_baudRate(baudRate) +, m_srcClock_Hz(srcClock_Hz) +, m_isInited(false) +#if ERPC_THREADS +, m_txrxSemaphore() +#endif +{ + s_lpspi_slave_instance = this; +} + +LPSpiSlaveTransport::~LPSpiSlaveTransport(void) +{ + if (m_isInited) + { +#ifdef ERPC_BOARD_LPSPI_SLAVE_READY_USE_GPIO + LPSpiSlaveTransport_NotifyTransferGpioCompleted(); +#endif + LPSPI_Deinit(m_lpspiBaseAddr); + m_isInited = false; + } +} + +erpc_status_t LPSpiSlaveTransport::init(void) +{ + lpspi_slave_config_t lpspiConfig; + + LPSPI_SlaveGetDefaultConfig(&lpspiConfig); + + (void)LPSPI_SlaveInit(m_lpspiBaseAddr, &lpspiConfig); + (void)LPSPI_SlaveTransferCreateHandle(m_lpspiBaseAddr, &s_handle, LPSPI_SlaveUserCallback, NULL); + +#ifdef ERPC_BOARD_LPSPI_SLAVE_READY_USE_GPIO + LPSpiSlaveTransport_NotifyTransferGpioInit(); +#endif + + m_isInited = true; + return kErpcStatus_Success; +} + +erpc_status_t LPSpiSlaveTransport::underlyingReceive(uint8_t *data, uint32_t size) +{ + status_t status; + lpspi_transfer_t slaveXfer = { 0 }; + + slaveXfer.txData = NULL; + slaveXfer.rxData = data; + slaveXfer.dataSize = size; + s_isTransferCompleted = false; + + status = LPSPI_SlaveTransferNonBlocking(m_lpspiBaseAddr, &s_handle, &slaveXfer); + + if (kStatus_Success == status) + { +#ifdef ERPC_BOARD_LPSPI_SLAVE_READY_USE_GPIO + LPSpiSlaveTransport_NotifyTransferGpioReady(); +#endif + +/* wait until the receiving is finished */ +#if ERPC_THREADS + m_txrxSemaphore.get(); +#else + while (!s_isTransferCompleted) + { + } +#endif + +#ifdef ERPC_BOARD_LPSPI_SLAVE_READY_USE_GPIO + LPSpiSlaveTransport_NotifyTransferGpioCompleted(); +#endif + } + + return (status != kStatus_Success) ? kErpcStatus_ReceiveFailed : kErpcStatus_Success; +} + +erpc_status_t LPSpiSlaveTransport::underlyingSend(const uint8_t *data, uint32_t size) +{ + status_t status; + lpspi_transfer_t slaveXfer = { 0 }; + s_isTransferCompleted = false; + +#ifdef ERPC_BOARD_LPSPI_SLAVE_READY_USE_GPIO + slaveXfer.txData = (uint8_t *)data; + slaveXfer.rxData = NULL; + slaveXfer.dataSize = size; + { +#else + uint8_t *lpspiData = new (nothrow) uint8_t[size + ERPC_BOARD_LPSPI_SLAVE_READY_MARKER_LEN]; + if (lpspiData != NULL) + { + lpspiData[0] = ERPC_BOARD_LPSPI_SLAVE_READY_MARKER1; + lpspiData[1] = ERPC_BOARD_LPSPI_SLAVE_READY_MARKER2; + (void)memcpy(&lpspiData[ERPC_BOARD_LPSPI_SLAVE_READY_MARKER_LEN], data, size); + slaveXfer.txData = lpspiData; + slaveXfer.rxData = NULL; + slaveXfer.dataSize = size + ERPC_BOARD_LPSPI_SLAVE_READY_MARKER_LEN; +#endif + + status = LPSPI_SlaveTransferNonBlocking(m_lpspiBaseAddr, &s_handle, &slaveXfer); + + if (kStatus_Success == status) + { +#ifdef ERPC_BOARD_LPSPI_SLAVE_READY_USE_GPIO + LPSpiSlaveTransport_NotifyTransferGpioReady(); +#endif + +/* wait until the sending is finished */ +#if ERPC_THREADS + m_txrxSemaphore.get(); +#else + while (!s_isTransferCompleted) + { + } +#endif + +#ifdef ERPC_BOARD_LPSPI_SLAVE_READY_USE_GPIO + LPSpiSlaveTransport_NotifyTransferGpioCompleted(); +#endif + } +#ifdef ERPC_BOARD_LPSPI_SLAVE_READY_USE_GPIO + } +#else + delete[] lpspiData; + } + else + { + status = kErpcStatus_SendFailed; + } +#endif + + return (status != kStatus_Success) ? kErpcStatus_SendFailed : kErpcStatus_Success; +} diff --git a/erpc_c/transports/erpc_lpspi_slave_transport.hpp b/erpc_c/transports/erpc_lpspi_slave_transport.hpp new file mode 100644 index 00000000..7c5c726a --- /dev/null +++ b/erpc_c/transports/erpc_lpspi_slave_transport.hpp @@ -0,0 +1,108 @@ +/* + * Copyright 2022 NXP + * + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef _EMBEDDED_RPC__LPSPI_SLAVE_TRANSPORT_H_ +#define _EMBEDDED_RPC__LPSPI_SLAVE_TRANSPORT_H_ + +#include "erpc_config_internal.h" + +#include +#if ERPC_THREADS +#include "erpc_threading.h" +#endif +#include "erpc_framed_transport.hpp" + +extern "C" { +#include "fsl_gpio.h" +#include "fsl_lpspi.h" +} + +/*! + * @addtogroup lpspi_slave_transport + * @{ + * @file + */ + +//////////////////////////////////////////////////////////////////////////////// +// Classes +//////////////////////////////////////////////////////////////////////////////// + +namespace erpc { +/*! + * @brief Very basic transport to send/receive messages via LPSPI. + * + * @ingroup lpspi_slave_transport + */ +class LPSpiSlaveTransport : public FramedTransport +{ +public: + /*! + * @brief Constructor. + * + * @param[in] lpspiBaseAddr LPSPI peripheral base address. + * @param[in] baudRate Baudrate. + * @param[in] srcClock_Hz Source clock. + */ + LPSpiSlaveTransport(LPSPI_Type *lpspiBaseAddr, uint32_t baudRate, uint32_t srcClock_Hz); + + /*! + * @brief Destructor. + */ + virtual ~LPSpiSlaveTransport(void); + + /*! + * @brief Initialize LPSPI peripheral configuration structure with values specified in LPSpiTransport constructor. + * + * @retval kErpcStatus_Success Always returns success status. + */ + virtual erpc_status_t init(void); + + /*! + * @brief Function called from LPSPI_SlaveUserCallback when LPSPI transfer is completed + * + * Unblocks the send/receive function. + */ + void transfer_cb(void); + +protected: + LPSPI_Type *m_lpspiBaseAddr; /*!< Base address of LPSPI peripheral used in this transport layer */ + uint32_t m_baudRate; /*!< Baud rate of LPSPI peripheral used in this transport layer */ + uint32_t m_srcClock_Hz; /*!< Source clock of LPSPI peripheral used in this transport layer */ + bool m_isInited; /*!< the LPSPI peripheral init status flag */ +#if ERPC_THREADS + Semaphore m_txrxSemaphore; /*!< Semaphore used by RTOS to block task until the sending/receiving is not complete */ +#endif + +private: + /*! + * @brief Receive data from LPSPI peripheral. + * + * @param[inout] data Preallocated buffer for receiving data. + * @param[in] size Size of data to read. + * + * @retval kErpcStatus_ReceiveFailed LPSPI failed to receive data. + * @retval kErpcStatus_Success Successfully received all data. + */ + virtual erpc_status_t underlyingReceive(uint8_t *data, uint32_t size); + + /*! + * @brief Write data to LPSPI peripheral. + * + * @param[in] data Buffer to send. + * @param[in] size Size of data to send. + * + * @retval kErpcStatus_SendFailed LPSPI failed to send data. + * @retval kErpcStatus_Success Successfully sent all data. + */ + virtual erpc_status_t underlyingSend(const uint8_t *data, uint32_t size); +}; + +} // namespace erpc + +/*! @} */ + +#endif // _EMBEDDED_RPC__LPSPI_SLAVE_TRANSPORT_H_ diff --git a/erpc_c/transports/erpc_mu_transport.cpp b/erpc_c/transports/erpc_mu_transport.cpp index d94c5119..15de63f8 100644 --- a/erpc_c/transports/erpc_mu_transport.cpp +++ b/erpc_c/transports/erpc_mu_transport.cpp @@ -1,5 +1,5 @@ /* - * Copyright 2017-2022 NXP + * Copyright 2017-2023 NXP * Copyright 2021 ACRIOS Systems s.r.o. * All rights reserved. * @@ -176,7 +176,7 @@ void MUTransport::tx_cb(void) { tx = m_txBuffer[m_txCntBytes >> 2]; } - MU_SendMsgNonBlocking(m_muBase, i, tx); + MU_SendMsg(m_muBase, i, tx); m_txCntBytes += 4U; } @@ -252,7 +252,7 @@ erpc_status_t MUTransport::send(MessageBuffer *message) m_txCntBytes = 0; m_txBuffer = reinterpret_cast(message->get()); - MU_SendMsgNonBlocking(m_muBase, 0, m_txMsgSize); + MU_SendMsg(m_muBase, 0, m_txMsgSize); // write to next MU tx registers for (i = 1; i < MU_REG_COUNT; i++) @@ -263,7 +263,7 @@ erpc_status_t MUTransport::send(MessageBuffer *message) { tx = m_txBuffer[m_txCntBytes >> 2]; } - MU_SendMsgNonBlocking(m_muBase, i, tx); + MU_SendMsg(m_muBase, i, tx); m_txCntBytes += 4U; } diff --git a/erpc_c/transports/erpc_mu_transport.hpp b/erpc_c/transports/erpc_mu_transport.hpp index d9f1ca71..b2c38afe 100644 --- a/erpc_c/transports/erpc_mu_transport.hpp +++ b/erpc_c/transports/erpc_mu_transport.hpp @@ -1,5 +1,5 @@ /* - * Copyright 2017-2022 NXP + * Copyright 2017-2023 NXP * All rights reserved. * * @@ -48,8 +48,7 @@ extern "C" { #define MU_REG_COUNT (MU_RR_COUNT) /*!< Count of MU tx/rx registers to be used by this transport layer */ #endif /* ERPC_TRANSPORT_MU_USE_MCMGR */ -#if (defined(CPU_MIMXRT1189AVM8A_cm7) || defined(CPU_MIMXRT1189CVM8A_cm7) || defined(CPU_MIMXRT1189CVM8A_cm7) || \ - defined(CPU_MIMXRT1189AVM8A_cm33) || defined(CPU_MIMXRT1189CVM8A_cm33) || defined(CPU_MIMXRT1189CVM8A_cm33)) +#if (defined(MIMXRT1187_cm7_SERIES) || defined(MIMXRT1187_cm33_SERIES) || defined(MIMXRT1189_cm7_SERIES) || defined(MIMXRT1189_cm33_SERIES)) #define MU_TX_SHIFT (1UL << (MU_REG_COUNT - 1U)) #define MU_RX_SHIFT (1UL << (MU_REG_COUNT - 1U)) #define MU_RX_INTR_MASK (MU_RX_INTR(MU_RX_SHIFT)) diff --git a/erpc_c/transports/erpc_rpmsg_lite_transport.hpp b/erpc_c/transports/erpc_rpmsg_lite_transport.hpp index 7fcaa3c9..8ac958ff 100644 --- a/erpc_c/transports/erpc_rpmsg_lite_transport.hpp +++ b/erpc_c/transports/erpc_rpmsg_lite_transport.hpp @@ -1,6 +1,6 @@ /* * Copyright (c) 2015-2016, Freescale Semiconductor, Inc. - * Copyright 2016-2022 NXP + * Copyright 2016-2023 NXP * All rights reserved. * * @@ -150,7 +150,7 @@ class RPMsgTransport : public RPMsgBaseTransport */ static int32_t rpmsg_read_cb(void *payload, uint32_t payload_len, uint32_t src, void *priv); - StaticQueue + StaticQueue m_messageQueue; /*!< Received messages. Queue of messages with buffers filled in rpmsg callback. */ uint32_t m_dst_addr; /*!< Destination address used by rpmsg. */ diff --git a/erpc_c/transports/erpc_uart_cmsis_transport.cpp b/erpc_c/transports/erpc_uart_cmsis_transport.cpp index 9eb344ab..9dddd85d 100644 --- a/erpc_c/transports/erpc_uart_cmsis_transport.cpp +++ b/erpc_c/transports/erpc_uart_cmsis_transport.cpp @@ -1,6 +1,6 @@ /* * Copyright (c) 2014-2016, Freescale Semiconductor, Inc. - * Copyright 2016-2021 NXP + * Copyright 2016-2023 NXP * Copyright 2021 ACRIOS Systems s.r.o. * All rights reserved. * @@ -85,15 +85,7 @@ erpc_status_t UartTransport::init(void) status = (*m_uartDrv).PowerControl(ARM_POWER_FULL); /* Enable Receiver and Transmitter lines */ if (status == ARM_DRIVER_OK) { - status = m_uartDrv->Control(ARM_USART_CONTROL_TX, 1); - if (status == ARM_DRIVER_OK) - { - status = m_uartDrv->Control(ARM_USART_CONTROL_RX, 1); - if (status == ARM_DRIVER_OK) - { - erpcStatus = kErpcStatus_Success; - } - } + erpcStatus = kErpcStatus_Success; } } diff --git a/erpc_python/erpc/erpc_version.py b/erpc_python/erpc/erpc_version.py index b3f67c57..e32900af 100644 --- a/erpc_python/erpc/erpc_version.py +++ b/erpc_python/erpc/erpc_version.py @@ -1,9 +1,9 @@ #!/usr/bin/env python -# Copyright 2017-2022 NXP +# Copyright 2017-2023 NXP # All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause # Should be same as in erpc_version.h -ERPC_VERSION = "1.10.0" +ERPC_VERSION = "1.11.0" diff --git a/erpc_python/erpc/transport.py b/erpc_python/erpc/transport.py index 00ae4636..725a0abb 100644 --- a/erpc_python/erpc/transport.py +++ b/erpc_python/erpc/transport.py @@ -1,7 +1,7 @@ #!/usr/bin/env python # Copyright (c) 2015-2016 Freescale Semiconductor, Inc. -# Copyright 2016-2021 NXP +# Copyright 2016-2022 NXP # Copyright 2022 ACRIOS Systems s.r.o. # All rights reserved. # @@ -240,13 +240,13 @@ def __init__(self, baudrate=None, cs_gpio_port=None, cs_gpio_pin=None, devidx=No self.sio = LIBUSBSIO() # Get number of LIBUSBSIO devices - res = self.sio.GetNumPorts(pidvids=[LIBUSBSIO.PIDVID_LPCLINK2]) + res = self.sio.GetNumPorts(vidpids=[LIBUSBSIO.VIDPID_LPCLINK2]) if res != 0: self._gpioport = 1 self._gpiopin = 2 self._gpiomode = 1 else: - res = self.sio.GetNumPorts(pidvids=[LIBUSBSIO.PIDVID_MCULINK]) + res = self.sio.GetNumPorts(vidpids=[LIBUSBSIO.VIDPID_MCULINK]) if res != 0: self._gpioport = 0 self._gpiopin = 4 @@ -347,13 +347,13 @@ def __init__(self, baudrate=None, devidx=None): self.sio = LIBUSBSIO() # Get number of LIBUSBSIO devices - res = self.sio.GetNumPorts(pidvids=[LIBUSBSIO.PIDVID_LPCLINK2]) + res = self.sio.GetNumPorts(vidpids=[LIBUSBSIO.VIDPID_LPCLINK2]) if res != 0: self._gpioport = 1 self._gpiopin = 2 self._gpiomode = 1 else: - res = self.sio.GetNumPorts(pidvids=[LIBUSBSIO.PIDVID_MCULINK]) + res = self.sio.GetNumPorts(vidpids=[LIBUSBSIO.VIDPID_MCULINK]) if res != 0: self._gpioport = 1 self._gpiopin = 3 @@ -405,12 +405,12 @@ def _base_send(self, message): res = self.sio.GPIO_GetPin(self._gpioport, self._gpiopin) # Send the header first data, rxbytesnumber = self._hI2CPort.FastXfer( - 0x7E, message[:self.HEADER_LEN], self.HEADER_LEN, 0, 0) + 0x7E, message[:self.HEADER_LEN], self.HEADER_LEN, 0, False, True) if rxbytesnumber > 0: #print('I2C received %d number of bytes' % rxbytesnumber) # Send the payload/data data, rxbytesnumber = self._hI2CPort.FastXfer( - 0x7E, bytes(message[4:]), len(message) - self.HEADER_LEN, 0, 0) + 0x7E, bytes(message[4:]), len(message) - self.HEADER_LEN, 0, False, True) else: print('I2C transfer error: %d' % rxbytesnumber) @@ -420,7 +420,7 @@ def _base_receive(self, count): while (1 == res): res = self.sio.GPIO_GetPin(self._gpioport, self._gpiopin) # Issue the I2C_Transfer API - data, rxbytesnumber = self._hI2CPort.FastXfer(0x7E, 0, 0, count, 0) + data, rxbytesnumber = self._hI2CPort.FastXfer(0x7E, 0, 0, count, False, True) if rxbytesnumber > 0: #print('I2C received %d number of bytes' % rxbytesnumber) return bytes(data[:count]) diff --git a/test/common/retarget_cpp_streamed_io.c b/test/common/retarget_cpp_streamed_io.c index 69fa28a9..69f24e15 100644 --- a/test/common/retarget_cpp_streamed_io.c +++ b/test/common/retarget_cpp_streamed_io.c @@ -200,9 +200,9 @@ long _sys_flen(FILEHANDLE fh) * name. Returns 0 on failure. maxlen is the maximum name length * allowed. */ -int _sys_tmpnam(char *name, int sig, unsigned maxlen) +void _sys_tmpnam(char *name, int sig, unsigned maxlen) { - return 0; // fail, not supported + return; // fail, not supported } /* diff --git a/test/common/unit_test_arbitrator_app0.cpp b/test/common/unit_test_arbitrator_app0.cpp index 0866ee8a..a15b6ad5 100644 --- a/test/common/unit_test_arbitrator_app0.cpp +++ b/test/common/unit_test_arbitrator_app0.cpp @@ -1,6 +1,6 @@ /* * Copyright (c) 2016, Freescale Semiconductor, Inc. - * Copyright 2016 - 2022 NXP + * Copyright 2016 - 2023 NXP * All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause @@ -30,7 +30,7 @@ extern "C" { #include "fsl_debug_console.h" #include "mcmgr.h" #if defined(__CC_ARM) || defined(__ARMCC_VERSION) -int main(int argc, char **argv); +int main(void); #endif #ifdef __cplusplus } @@ -115,18 +115,6 @@ void runClient(void *arg) vTaskSuspend(NULL); } -/*! - * @brief Application-specific implementation of the SystemInitHook() weak function. - */ -void SystemInitHook(void) -{ - /* Initialize MCMGR - low level multicore management library. Call this - function as close to the reset entry as possible to allow CoreUp event - triggering. The SystemInitHook() weak function overloading is used in this - application. */ - MCMGR_EarlyInit(); -} - void runInit(void *arg) { // Initialize MCMGR before calling its API @@ -245,9 +233,13 @@ class MinimalistPrinter : public ::testing::EmptyTestEventListener * end of reused snippet ***********************************************************************************/ -int main(int argc, char **argv) +int main(void) { - ::testing::InitGoogleTest(&argc, argv); + int fake_argc = 1; + const auto fake_arg0 = "dummy"; + char* fake_argv0 = const_cast(fake_arg0); + char** fake_argv = &fake_argv0; + ::testing::InitGoogleTest(&fake_argc, fake_argv); BOARD_InitHardware(); ::testing::TestEventListeners &listeners = ::testing::UnitTest::GetInstance()->listeners(); diff --git a/test/common/unit_test_arbitrator_app1.cpp b/test/common/unit_test_arbitrator_app1.cpp index e328fd54..5d81c78b 100644 --- a/test/common/unit_test_arbitrator_app1.cpp +++ b/test/common/unit_test_arbitrator_app1.cpp @@ -1,6 +1,6 @@ /* * Copyright (c) 2016, Freescale Semiconductor, Inc. - * Copyright 2016 - 2020 NXP + * Copyright 2016 - 2023 NXP * All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause @@ -28,7 +28,7 @@ extern "C" { #include "board.h" #include "mcmgr.h" #if defined(__CC_ARM) || defined(__ARMCC_VERSION) -int main(int argc, char **argv); +int main(void); #endif #ifdef __cplusplus } @@ -125,18 +125,6 @@ static void SignalReady(void) MCMGR_TriggerEvent(kMCMGR_RemoteApplicationEvent, APP_ERPC_READY_EVENT_DATA); } -/*! - * @brief Application-specific implementation of the SystemInitHook() weak function. - */ -void SystemInitHook(void) -{ - /* Initialize MCMGR - low level multicore management library. Call this - function as close to the reset entry as possible to allow CoreUp event - triggering. The SystemInitHook() weak function overloading is used in this - application. */ - MCMGR_EarlyInit(); -} - void runInit(void *arg) { // Initialize MCMGR before calling its API @@ -202,7 +190,7 @@ void runInit(void *arg) vTaskSuspend(NULL); } -int main(int argc, char **argv) +int main(void) { BOARD_InitHardware(); diff --git a/test/common/unit_test_client.cpp b/test/common/unit_test_client.cpp index 573894cf..09830b11 100644 --- a/test/common/unit_test_client.cpp +++ b/test/common/unit_test_client.cpp @@ -1,6 +1,6 @@ /* * Copyright (c) 2014, Freescale Semiconductor, Inc. - * Copyright 2016-2020 NXP + * Copyright 2016-2023 NXP * All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause @@ -21,7 +21,7 @@ extern "C" { #include "fsl_debug_console.h" #include "mcmgr.h" #if defined(__CC_ARM) || defined(__ARMCC_VERSION) -int main(int argc, char **argv); +int main(void); #endif } @@ -105,23 +105,15 @@ static void eRPCReadyEventHandler(uint16_t eventData, void *context) { eRPCReadyEventData = eventData; } - -/*! - * @brief Application-specific implementation of the SystemInitHook() weak function. - */ -void SystemInitHook(void) -{ - /* Initialize MCMGR - low level multicore management library. Call this - function as close to the reset entry as possible to allow CoreUp event - triggering. The SystemInitHook() weak function overloading is used in this - application. */ - MCMGR_EarlyInit(); -} #endif -int main(int argc, char **argv) +int main(void) { - ::testing::InitGoogleTest(&argc, argv); + int fake_argc = 1; + const auto fake_arg0 = "dummy"; + char* fake_argv0 = const_cast(fake_arg0); + char** fake_argv = &fake_argv0; + ::testing::InitGoogleTest(&fake_argc, fake_argv); ::testing::TestEventListeners &listeners = ::testing::UnitTest::GetInstance()->listeners(); listeners.Append(new LeakChecker); diff --git a/test/common/unit_test_server.cpp b/test/common/unit_test_server.cpp index 10c8efc2..c10dda3a 100644 --- a/test/common/unit_test_server.cpp +++ b/test/common/unit_test_server.cpp @@ -1,6 +1,6 @@ /* * Copyright (c) 2014-2016, Freescale Semiconductor, Inc. - * Copyright 2016 - 2020 NXP + * Copyright 2016 - 2023 NXP * All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause @@ -25,7 +25,7 @@ extern "C" { #include "app_core1.h" #endif #if defined(__CC_ARM) || defined(__ARMCC_VERSION) -int main(int argc, const char *argv[]); +int main(void); #endif } #endif @@ -52,20 +52,9 @@ static void SignalReady(void) /* Signal the other core we are ready by trigerring the event and passing the APP_ERPC_READY_EVENT_DATA */ MCMGR_TriggerEvent(kMCMGR_RemoteApplicationEvent, APP_ERPC_READY_EVENT_DATA); } -/*! - * @brief Application-specific implementation of the SystemInitHook() weak function. - */ -void SystemInitHook(void) -{ - /* Initialize MCMGR - low level multicore management library. Call this - function as close to the reset entry as possible to allow CoreUp event - triggering. The SystemInitHook() weak function overloading is used in this - application. */ - MCMGR_EarlyInit(); -} #endif -int main(int argc, const char *argv[]) +int main(void) { BOARD_InitHardware(); diff --git a/test/test_arbitrator/test_arbitrator_client_impl.cpp b/test/test_arbitrator/test_arbitrator_client_impl.cpp index 9d63631b..ec009e76 100644 --- a/test/test_arbitrator/test_arbitrator_client_impl.cpp +++ b/test/test_arbitrator/test_arbitrator_client_impl.cpp @@ -18,8 +18,8 @@ #define number 15 #define nestedCallsCount 10 -int j = 0; -int numbers[number]; +volatile int j = 0; +volatile int numbers[number]; volatile bool enabled = false; SecondInterface_service *svc; diff --git a/test/test_arbitrator/test_arbitrator_server_impl.cpp b/test/test_arbitrator/test_arbitrator_server_impl.cpp index 0785075f..f4ccc399 100644 --- a/test/test_arbitrator/test_arbitrator_server_impl.cpp +++ b/test/test_arbitrator/test_arbitrator_server_impl.cpp @@ -16,8 +16,8 @@ //////////////////////////////////////////////////////////////////////////////// #define number 15 -int i = 0; -int numbers[number]; +volatile int i = 0; +volatile int numbers[number]; FirstInterface_service *svc; void firstSendInt(int32_t a)