diff options
Diffstat (limited to 'thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/spi_mngr')
| -rw-r--r-- | thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/spi_mngr/nrf_spi_mngr.c | 348 | ||||
| -rw-r--r-- | thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/spi_mngr/nrf_spi_mngr.h | 310 |
2 files changed, 658 insertions, 0 deletions
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/spi_mngr/nrf_spi_mngr.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/spi_mngr/nrf_spi_mngr.c new file mode 100644 index 0000000..b66dfbb --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/spi_mngr/nrf_spi_mngr.c @@ -0,0 +1,348 @@ +/** + * Copyright (c) 2017 - 2018, Nordic Semiconductor ASA + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. + * + * 3. Neither the name of Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ +#include "sdk_common.h" + +#if NRF_MODULE_ENABLED(NRF_SPI_MNGR) +#include "nrf_spi_mngr.h" +#include "nrf_assert.h" +#include "app_util_platform.h" + +typedef volatile struct +{ + bool transaction_in_progress; + uint8_t transaction_result; +} nrf_spi_mngr_cb_data_t; + +static ret_code_t start_transfer(nrf_spi_mngr_t const * p_nrf_spi_mngr) +{ + ASSERT(p_nrf_spi_mngr != NULL); + + // use a local variable to avoid using two volatile variables in one + // expression + uint8_t curr_transfer_idx = p_nrf_spi_mngr->p_nrf_spi_mngr_cb->current_transfer_idx; + nrf_spi_mngr_transfer_t const * p_transfer = + &p_nrf_spi_mngr->p_nrf_spi_mngr_cb->p_current_transaction->p_transfers[curr_transfer_idx]; + + return nrf_drv_spi_transfer(&p_nrf_spi_mngr->spi, + p_transfer->p_tx_data, p_transfer->tx_length, + p_transfer->p_rx_data, p_transfer->rx_length); +} + + +static void transaction_begin_signal(nrf_spi_mngr_t const * p_nrf_spi_mngr) +{ + ASSERT(p_nrf_spi_mngr != NULL); + + nrf_spi_mngr_transaction_t const * p_current_transaction = + p_nrf_spi_mngr->p_nrf_spi_mngr_cb->p_current_transaction; + + + if (p_current_transaction->begin_callback != NULL) + { + void * p_user_data = p_current_transaction->p_user_data; + p_current_transaction->begin_callback(p_user_data); + } +} + + +static void transaction_end_signal(nrf_spi_mngr_t const * p_nrf_spi_mngr, + ret_code_t result) +{ + ASSERT(p_nrf_spi_mngr != NULL); + + nrf_spi_mngr_transaction_t const * p_current_transaction = + p_nrf_spi_mngr->p_nrf_spi_mngr_cb->p_current_transaction; + + if (p_current_transaction->end_callback != NULL) + { + void * p_user_data = p_current_transaction->p_user_data; + p_current_transaction->end_callback(result, p_user_data); + } +} + + +static void spi_event_handler(nrf_drv_spi_evt_t const * p_event, + void * p_context); + + +// This function starts pending transaction if there is no current one or +// when 'switch_transaction' parameter is set to true. It is important to +// switch to new transaction without setting 'p_nrf_spi_mngr->p_curr_transaction' +// to NULL in between, since this pointer is used to check idle status - see +// 'nrf_spi_mngr_is_idle()'. +static void start_pending_transaction(nrf_spi_mngr_t const * p_nrf_spi_mngr, + bool switch_transaction) +{ + ASSERT(p_nrf_spi_mngr != NULL); + + while (1) + { + bool start_transaction = false; + nrf_spi_mngr_cb_t * p_cb = p_nrf_spi_mngr->p_nrf_spi_mngr_cb; + + CRITICAL_REGION_ENTER(); + if (switch_transaction || nrf_spi_mngr_is_idle(p_nrf_spi_mngr)) + { + if (nrf_queue_pop(p_nrf_spi_mngr->p_queue, + (void *)(&p_cb->p_current_transaction)) + == NRF_SUCCESS) + { + start_transaction = true; + } + else + { + p_cb->p_current_transaction = NULL; + } + } + CRITICAL_REGION_EXIT(); + + if (!start_transaction) + { + return; + } + + nrf_drv_spi_config_t const * p_instance_cfg; + if (p_cb->p_current_transaction->p_required_spi_cfg == NULL) + { + p_instance_cfg = &p_cb->default_configuration; + } + else + { + p_instance_cfg = p_cb->p_current_transaction->p_required_spi_cfg; + } + + ret_code_t result; + + if (memcmp(p_cb->p_current_configuration, p_instance_cfg, sizeof(*p_instance_cfg)) != 0) + { + nrf_drv_spi_uninit(&p_nrf_spi_mngr->spi); + result = nrf_drv_spi_init(&p_nrf_spi_mngr->spi, + p_instance_cfg, + spi_event_handler, + (void *)p_nrf_spi_mngr); + ASSERT(result == NRF_SUCCESS); + p_cb->p_current_configuration = p_instance_cfg; + } + + // Try to start first transfer for this new transaction. + p_cb->current_transfer_idx = 0; + + // Execute user code if available before starting transaction + transaction_begin_signal(p_nrf_spi_mngr); + result = start_transfer(p_nrf_spi_mngr); + + // If transaction started successfully there is nothing more to do here now. + if (result == NRF_SUCCESS) + { + return; + } + + // Transfer failed to start - notify user that this transaction + // cannot be started and try with next one (in next iteration of + // the loop). + transaction_end_signal(p_nrf_spi_mngr, result); + + switch_transaction = true; + } +} + + +// This function shall be called to handle SPI events. It shall be mainly used by SPI IRQ for +// finished tranfer. +static void spi_event_handler(nrf_drv_spi_evt_t const * p_event, + void * p_context) +{ + ASSERT(p_event != NULL); + ASSERT(p_context != NULL); + + ret_code_t result; + nrf_spi_mngr_cb_t * p_cb = ((nrf_spi_mngr_t const *)p_context)->p_nrf_spi_mngr_cb; + + // This callback should be called only during transaction. + ASSERT(p_cb->p_current_transaction != NULL); + + if (p_event->type == NRF_DRV_SPI_EVENT_DONE) + { + result = NRF_SUCCESS; + + // Transfer finished successfully. If there is another one to be + // performed in the current transaction, start it now. + // use a local variable to avoid using two volatile variables in one + // expression + uint8_t curr_transfer_idx = p_cb->current_transfer_idx; + ++curr_transfer_idx; + if (curr_transfer_idx < p_cb->p_current_transaction->number_of_transfers) + { + p_cb->current_transfer_idx = curr_transfer_idx; + + result = start_transfer(((nrf_spi_mngr_t const *)p_context)); + + if (result == NRF_SUCCESS) + { + // The current transaction is running and its next transfer + // has been successfully started. There is nothing more to do. + return; + } + // if the next transfer could not be started due to some error + // we finish the transaction with this error code as the result + } + } + else + { + result = NRF_ERROR_INTERNAL; + } + + // The current transaction has been completed or interrupted by some error. + // Notify the user and start next one (if there is any). + transaction_end_signal(((nrf_spi_mngr_t const *)p_context), result); + // we switch transactions here ('p_nrf_spi_mngr->p_current_transaction' is set + // to NULL only if there is nothing more to do) in order to not generate + // spurious idle status (even for a moment) + start_pending_transaction(((nrf_spi_mngr_t const *)p_context), true); +} + + +ret_code_t nrf_spi_mngr_init(nrf_spi_mngr_t const * p_nrf_spi_mngr, + nrf_drv_spi_config_t const * p_default_spi_config) +{ + ASSERT(p_nrf_spi_mngr != NULL); + ASSERT(p_nrf_spi_mngr->p_queue != NULL); + ASSERT(p_nrf_spi_mngr->p_queue->size > 0); + ASSERT(p_default_spi_config != NULL); + + ret_code_t err_code; + + err_code = nrf_drv_spi_init(&p_nrf_spi_mngr->spi, + p_default_spi_config, + spi_event_handler, + (void *)p_nrf_spi_mngr); + + if (err_code == NRF_SUCCESS) + { + nrf_spi_mngr_cb_t * p_cb = p_nrf_spi_mngr->p_nrf_spi_mngr_cb; + + p_cb->p_current_transaction = NULL; + p_cb->default_configuration = *p_default_spi_config; + p_cb->p_current_configuration = &p_cb->default_configuration; + } + + return err_code; +} + + +void nrf_spi_mngr_uninit(nrf_spi_mngr_t const * p_nrf_spi_mngr) +{ + ASSERT(p_nrf_spi_mngr != NULL); + + nrf_drv_spi_uninit(&p_nrf_spi_mngr->spi); + + p_nrf_spi_mngr->p_nrf_spi_mngr_cb->p_current_transaction = NULL; +} + + +ret_code_t nrf_spi_mngr_schedule(nrf_spi_mngr_t const * p_nrf_spi_mngr, + nrf_spi_mngr_transaction_t const * p_transaction) +{ + ASSERT(p_nrf_spi_mngr != NULL); + ASSERT(p_transaction != NULL); + ASSERT(p_transaction->p_transfers != NULL); + ASSERT(p_transaction->number_of_transfers != 0); + + ret_code_t result = nrf_queue_push(p_nrf_spi_mngr->p_queue, (void *)(&p_transaction)); + if (result == NRF_SUCCESS) + { + // New transaction has been successfully added to queue, + // so if we are currently idle it's time to start the job. + start_pending_transaction(p_nrf_spi_mngr, false); + } + + return result; +} + + +static void spi_internal_transaction_cb(ret_code_t result, void * p_user_data) +{ + nrf_spi_mngr_cb_data_t * p_cb_data = (nrf_spi_mngr_cb_data_t *)p_user_data; + + p_cb_data->transaction_result = result; + p_cb_data->transaction_in_progress = false; +} + +ret_code_t nrf_spi_mngr_perform(nrf_spi_mngr_t const * p_nrf_spi_mngr, + nrf_drv_spi_config_t const * p_config, + nrf_spi_mngr_transfer_t const * p_transfers, + uint8_t number_of_transfers, + void (* user_function)(void)) +{ + ASSERT(p_nrf_spi_mngr != NULL); + ASSERT(p_transfers != NULL); + ASSERT(number_of_transfers != 0); + + nrf_spi_mngr_cb_data_t cb_data = + { + .transaction_in_progress = true + }; + + nrf_spi_mngr_transaction_t internal_transaction = + { + .begin_callback = NULL, + .end_callback = spi_internal_transaction_cb, + .p_user_data = (void *)&cb_data, + .p_transfers = p_transfers, + .number_of_transfers = number_of_transfers, + .p_required_spi_cfg = p_config + }; + + ret_code_t result = nrf_spi_mngr_schedule(p_nrf_spi_mngr, &internal_transaction); + VERIFY_SUCCESS(result); + + while (cb_data.transaction_in_progress) + { + if (user_function) + { + user_function(); + } + } + + return cb_data.transaction_result; +} + +#endif //NRF_MODULE_ENABLED(NRF_SPI_MNGR) + diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/spi_mngr/nrf_spi_mngr.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/spi_mngr/nrf_spi_mngr.h new file mode 100644 index 0000000..434c950 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/spi_mngr/nrf_spi_mngr.h @@ -0,0 +1,310 @@ +/** + * Copyright (c) 2017 - 2018, Nordic Semiconductor ASA + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. + * + * 3. Neither the name of Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ +#ifndef NRF_SPI_MNGR_H__ +#define NRF_SPI_MNGR_H__ + +#include <stdint.h> +#include "nrf_drv_spi.h" +#include "sdk_errors.h" +#include "nrf_queue.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/*lint -save -e491*/ +#ifndef NRF_SPI_MNGR_BUFFERS_IN_RAM + #define NRF_SPI_MNGR_BUFFERS_IN_RAM defined(SPIM_PRESENT) +#endif + +#if NRF_SPI_MNGR_BUFFERS_IN_RAM + #define NRF_SPI_MNGR_BUFFER_LOC_IND +#else + #define NRF_SPI_MNGR_BUFFER_LOC_IND const +#endif +/*lint -restore*/ + +/** + * @defgroup nrf_spi_mngr SPI transaction manager + * @{ + * @ingroup app_common + * + * @brief Module for scheduling SPI transactions. + */ + + +/** + * @brief Macro for creating a simple SPI transfer. + * + * @param[in] _p_tx_data Pointer to the data to be sent. + * @param[in] _tx_length Number of bytes to send. + * @param[in] _p_rx_data Pointer to a buffer for received data. + * @param[in] _rx_length Number of bytes to receive. + */ +#define NRF_SPI_MNGR_TRANSFER(_p_tx_data, _tx_length, _p_rx_data, _rx_length) \ +{ \ + .p_tx_data = (uint8_t const *)_p_tx_data, \ + .tx_length = (uint8_t) _tx_length, \ + .p_rx_data = (uint8_t *) _p_rx_data, \ + .rx_length = (uint8_t) _rx_length, \ +} + + +/** + * @brief SPI transaction end callback prototype. + * + * @param result Result of operation (NRF_SUCCESS on success, + * otherwise a relevant error code). + * @param[in] p_user_data Pointer to user data defined in transaction + * descriptor. + */ +typedef void (* nrf_spi_mngr_callback_end_t)(ret_code_t result, void * p_user_data); + +/** + * @brief SPI transaction begin callback prototype. + * + * @param[in] p_user_data Pointer to user data defined in transaction + * descriptor. + */ +typedef void (* nrf_spi_mngr_callback_begin_t)(void * p_user_data); + + +/** + * @brief SPI transfer descriptor. + */ +typedef struct +{ + uint8_t const * p_tx_data; ///< Pointer to the data to be sent. + uint8_t tx_length; ///< Number of bytes to send. + uint8_t * p_rx_data; ///< Pointer to a buffer for received data. + uint8_t rx_length; ///< Number of bytes to receive. +} nrf_spi_mngr_transfer_t; + + +/** + * @brief SPI transaction descriptor. + */ +typedef struct +{ + nrf_spi_mngr_callback_begin_t begin_callback; + ///< User-specified function to be called before the transaction is started. + + nrf_spi_mngr_callback_end_t end_callback; + ///< User-specified function to be called after the transaction is finished. + + void * p_user_data; + ///< Pointer to user data to be passed to the end_callback. + + nrf_spi_mngr_transfer_t const * p_transfers; + ///< Pointer to the array of transfers that make up the transaction. + + uint8_t number_of_transfers; + ///< Number of transfers that make up the transaction. + + nrf_drv_spi_config_t const * p_required_spi_cfg; + ///< Pointer to instance hardware configuration. +} nrf_spi_mngr_transaction_t; + + +/** + * @brief SPI instance control block. + */ +typedef struct +{ + nrf_spi_mngr_transaction_t const * volatile p_current_transaction; + ///< Currently realized transaction. + + nrf_drv_spi_config_t default_configuration; + ///< Default hardware configuration. + + nrf_drv_spi_config_t const * p_current_configuration; + ///< Pointer to current hardware configuration. + + uint8_t volatile current_transfer_idx; + ///< Index of currently performed transfer (within current transaction). +} nrf_spi_mngr_cb_t; + + +/** + * @brief SPI transaction manager instance. + */ +typedef struct +{ + nrf_spi_mngr_cb_t * p_nrf_spi_mngr_cb; + ///< Control block of instance. + + nrf_queue_t const * p_queue; + ///< Transaction queue. + + nrf_drv_spi_t spi; + ///< Pointer to SPI master driver instance. +} nrf_spi_mngr_t; + + +/** + * @brief Macro for simplifying the defining of an SPI transaction manager + * instance. + * + * This macro allocates a static buffer for the transaction queue. + * Therefore, it should be used in only one place in the code for a given + * instance. + * + * @note The queue size is the maximum number of pending transactions + * not counting the one that is currently realized. This means that + * for an empty queue with size of for example 4 elements, it is + * possible to schedule up to 5 transactions. + * + * @param[in] _nrf_spi_mngr_name Name of instance to be created. + * @param[in] _queue_size Size of the transaction queue (maximum number + * of pending transactions). + * @param[in] _spi_idx Index of hardware SPI instance to be used. + */ +#define NRF_SPI_MNGR_DEF(_nrf_spi_mngr_name, _queue_size, _spi_idx) \ + NRF_QUEUE_DEF(nrf_spi_mngr_transaction_t const *, \ + _nrf_spi_mngr_name##_queue, \ + (_queue_size), \ + NRF_QUEUE_MODE_NO_OVERFLOW); \ + static nrf_spi_mngr_cb_t CONCAT_2(_nrf_spi_mngr_name, _cb); \ + static const nrf_spi_mngr_t _nrf_spi_mngr_name = \ + { \ + .p_nrf_spi_mngr_cb = &CONCAT_2(_nrf_spi_mngr_name, _cb), \ + .p_queue = &_nrf_spi_mngr_name##_queue, \ + .spi = NRF_DRV_SPI_INSTANCE(_spi_idx) \ + } + + + /** + * @brief Function for initializing an SPI transaction manager instance. + * + * @param[in] p_nrf_spi_mngr Pointer to the instance to be initialized. + * @param[in] p_default_spi_config Pointer to the SPI driver configuration. This configuration + * will be used whenever the scheduled transaction will have + * p_spi_config set to NULL value. + * + * @return Values returned by the @ref nrf_drv_spi_init function. + */ +ret_code_t nrf_spi_mngr_init(nrf_spi_mngr_t const * p_nrf_spi_mngr, + nrf_drv_spi_config_t const * p_default_spi_config); + + +/** + * @brief Function for uninitializing an SPI transaction manager instance. + * + * @param[in] p_nrf_spi_mngr Pointer to the instance to be uninitialized. + */ +void nrf_spi_mngr_uninit(nrf_spi_mngr_t const * p_nrf_spi_mngr); + + +/** + * @brief Function for scheduling an SPI transaction. + * + * The transaction is enqueued and started as soon as the SPI bus is + * available, thus when all previously scheduled transactions have been + * finished (possibly immediately). + * + * @note If @ref nrf_spi_mngr_transaction_t::p_required_spi_cfg + * is set to a non-NULL value the module will compare it with + * @ref nrf_spi_mngr_cb_t::p_current_configuration and reinitialize hardware + * SPI instance with new parameters if any differences are found. + * If @ref nrf_spi_mngr_transaction_t::p_required_spi_cfg is set to NULL then + * it will treat it as it would be set to @ref nrf_spi_mngr_cb_t::default_configuration. + * + * @param[in] p_nrf_spi_mngr Pointer to the SPI transaction manager instance. + * @param[in] p_transaction Pointer to the descriptor of the transaction to be + * scheduled. + * + * @retval NRF_SUCCESS If the transaction has been successfully scheduled. + * @retval NRF_ERROR_NO_MEM If the queue is full (Only if queue in + * @ref NRF_QUEUE_MODE_NO_OVERFLOW). + */ +ret_code_t nrf_spi_mngr_schedule(nrf_spi_mngr_t const * p_nrf_spi_mngr, + nrf_spi_mngr_transaction_t const * p_transaction); + + +/** + * @brief Function for scheduling a transaction and waiting until it is finished. + * + * This function schedules a transaction that consists of one or more transfers + * and waits until it is finished. + * + * @param[in] p_nrf_spi_mngr Pointer to the SPI transaction manager instance. + * @param[in] p_config Required SPI configuration. + * @param[in] p_transfers Pointer to an array of transfers to be performed. + * @param number_of_transfers Number of transfers to be performed. + * @param user_function User-specified function to be called while + * waiting. NULL if such functionality + * is not needed. + * + * @retval NRF_SUCCESS If the transfers have been successfully realized. + * @retval NRF_ERROR_BUSY If some transfers are already being performed. + * @retval - Other error codes mean that the transaction has failed + * with the error reported by @ref nrf_drv_spi_transfer(). + */ +ret_code_t nrf_spi_mngr_perform(nrf_spi_mngr_t const * p_nrf_spi_mngr, + nrf_drv_spi_config_t const * p_config, + nrf_spi_mngr_transfer_t const * p_transfers, + uint8_t number_of_transfers, + void (* user_function)(void)); + + +/** + * @brief Function for getting the current state of an SPI transaction manager + * instance. + * + * @param[in] p_nrf_spi_mngr Pointer to the SPI transaction manager instance. + * + * @retval true If all scheduled transactions have been finished. + * @retval false Otherwise. + */ +__STATIC_INLINE bool nrf_spi_mngr_is_idle(nrf_spi_mngr_t const * p_nrf_spi_mngr) +{ + return (p_nrf_spi_mngr->p_nrf_spi_mngr_cb->p_current_transaction == NULL); +} + +/** + *@} + **/ +//typedef int p_current_transaction; + +#ifdef __cplusplus +} +#endif + +#endif // NRF_SPI_MNGR_H__ |