diff options
Diffstat (limited to 'thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/twi_mngr/nrf_twi_mngr.c')
-rw-r--r-- | thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/twi_mngr/nrf_twi_mngr.c | 366 |
1 files changed, 366 insertions, 0 deletions
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/twi_mngr/nrf_twi_mngr.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/twi_mngr/nrf_twi_mngr.c new file mode 100644 index 0000000..56a14e5 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/twi_mngr/nrf_twi_mngr.c @@ -0,0 +1,366 @@ +/** + * Copyright (c) 2015 - 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_TWI_MNGR) +#include "nrf_twi_mngr.h" +#include "nrf_assert.h" +#include "app_util_platform.h" + +typedef volatile struct +{ + bool transaction_in_progress; + uint8_t transaction_result; +} nrf_twi_mngr_cb_data_t; + + +static ret_code_t start_transfer(nrf_twi_mngr_t const * p_nrf_twi_mngr) +{ + ASSERT(p_nrf_twi_mngr != NULL); + + // Pointer for cleaner code. + nrf_twi_mngr_cb_t * p_cb = p_nrf_twi_mngr->p_nrf_twi_mngr_cb; + + // [use a local variable to avoid using two volatile variables in one + // expression] + uint8_t current_transfer_idx = p_cb->current_transfer_idx; + nrf_twi_mngr_transfer_t const * p_transfer = + &p_cb->p_current_transaction->p_transfers[current_transfer_idx]; + uint8_t address = NRF_TWI_MNGR_OP_ADDRESS(p_transfer->operation); + + nrf_drv_twi_xfer_desc_t xfer_desc; + uint32_t flags; + + xfer_desc.address = address; + xfer_desc.p_primary_buf = p_transfer->p_data; + xfer_desc.primary_length = p_transfer->length; + + /* If it is possible try to bind two transfers together. They can be combined if: + * - there is no stop condition after current transfer. + * - current transfer is TX. + * - there is at least one more transfer in the transaction. + * - address of next transfer is the same as current transfer. + */ + if ((p_transfer->flags & NRF_TWI_MNGR_NO_STOP) && + !NRF_TWI_MNGR_IS_READ_OP(p_transfer->operation) && + // Adding 1 to check if next transfer is from the same transaction. + ((current_transfer_idx + 1) < p_cb->p_current_transaction->number_of_transfers) && + (NRF_TWI_MNGR_OP_ADDRESS(p_transfer->operation) == + NRF_TWI_MNGR_OP_ADDRESS(p_cb->p_current_transaction-> + p_transfers[current_transfer_idx + 1].operation))) + { + nrf_twi_mngr_transfer_t const * p_second_transfer = + &p_cb->p_current_transaction->p_transfers[current_transfer_idx + 1]; + xfer_desc.p_secondary_buf = p_second_transfer->p_data; + xfer_desc.secondary_length = p_second_transfer->length; + xfer_desc.type = NRF_TWI_MNGR_IS_READ_OP(p_second_transfer->operation) ? + NRF_DRV_TWI_XFER_TXRX : NRF_DRV_TWI_XFER_TXTX; + flags = (p_second_transfer->flags & NRF_TWI_MNGR_NO_STOP) ? NRF_DRV_TWI_FLAG_TX_NO_STOP : 0; + p_cb->current_transfer_idx++; + } + else + { + xfer_desc.type = NRF_TWI_MNGR_IS_READ_OP(p_transfer->operation) ? NRF_DRV_TWI_XFER_RX : + NRF_DRV_TWI_XFER_TX; + xfer_desc.p_secondary_buf = NULL; + xfer_desc.secondary_length = 0; + flags = (p_transfer->flags & NRF_TWI_MNGR_NO_STOP) ? NRF_DRV_TWI_FLAG_TX_NO_STOP : 0; + } + + return nrf_drv_twi_xfer(&p_nrf_twi_mngr->twi, &xfer_desc, flags); +} + + +static void transaction_end_signal(nrf_twi_mngr_t const * p_nrf_twi_mngr, + ret_code_t result) +{ + ASSERT(p_nrf_twi_mngr != NULL); + + if (p_nrf_twi_mngr->p_nrf_twi_mngr_cb->p_current_transaction->callback) + { + // [use a local variable to avoid using two volatile variables in one + // expression] + void * p_user_data = p_nrf_twi_mngr->p_nrf_twi_mngr_cb->p_current_transaction->p_user_data; + p_nrf_twi_mngr->p_nrf_twi_mngr_cb->p_current_transaction->callback(result, p_user_data); + } +} + +static void twi_event_handler(nrf_drv_twi_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_twi_mngr->p_current_transaction' +// to NULL in between, since this pointer is used to check idle status - see +// 'nrf_twi_mngr_is_idle()'. +static void start_pending_transaction(nrf_twi_mngr_t const * p_nrf_twi_mngr, + bool switch_transaction) +{ + ASSERT(p_nrf_twi_mngr != NULL); + + // Pointer for cleaner code. + nrf_twi_mngr_cb_t * p_cb = p_nrf_twi_mngr->p_nrf_twi_mngr_cb; + + for (;;) + { + bool start_transaction = false; + + CRITICAL_REGION_ENTER(); + if (switch_transaction || nrf_twi_mngr_is_idle(p_nrf_twi_mngr)) + { + if (nrf_queue_pop(p_nrf_twi_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; + } + else + { + ret_code_t result; + + nrf_drv_twi_config_t const * p_instance_cfg = + p_cb->p_current_transaction->p_required_twi_cfg == NULL ? + &p_cb->default_configuration : + p_cb->p_current_transaction->p_required_twi_cfg; + + if (memcmp(p_cb->p_current_configuration, p_instance_cfg, sizeof(*p_instance_cfg)) != 0) + { + ret_code_t err_code; + nrf_drv_twi_uninit(&p_nrf_twi_mngr->twi); + err_code = nrf_drv_twi_init(&p_nrf_twi_mngr->twi, + p_instance_cfg, + twi_event_handler, + (void *)p_nrf_twi_mngr); + ASSERT(err_code == NRF_SUCCESS); + nrf_drv_twi_enable(&p_nrf_twi_mngr->twi); + UNUSED_VARIABLE(err_code); + p_cb->p_current_configuration = p_instance_cfg; + } + + // Try to start first transfer for this new transaction. + p_cb->current_transfer_idx = 0; + result = start_transfer(p_nrf_twi_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_twi_mngr, result); + + switch_transaction = true; + } + } +} + + +static void twi_event_handler(nrf_drv_twi_evt_t const * p_event, + void * p_context) +{ + ASSERT(p_event != NULL); + + nrf_twi_mngr_t * p_nrf_twi_mngr = (nrf_twi_mngr_t *)p_context; + ret_code_t result; + + // This callback should be called only during transaction. + ASSERT(p_nrf_twi_mngr->p_nrf_twi_mngr_cb->p_current_transaction != NULL); + + if (p_event->type == NRF_DRV_TWI_EVT_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 current_transfer_idx = p_nrf_twi_mngr->p_nrf_twi_mngr_cb->current_transfer_idx; + ++current_transfer_idx; + if (current_transfer_idx < + p_nrf_twi_mngr->p_nrf_twi_mngr_cb->p_current_transaction->number_of_transfers) + { + p_nrf_twi_mngr->p_nrf_twi_mngr_cb->current_transfer_idx = current_transfer_idx; + + result = start_transfer(p_nrf_twi_mngr); + + if (result == NRF_SUCCESS) + { + // The current transaction goes on and we've successfully + // started its next transfer -> 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(p_nrf_twi_mngr, result); + // [we switch transactions here ('p_nrf_twi_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(p_nrf_twi_mngr, true); +} + + +ret_code_t nrf_twi_mngr_init(nrf_twi_mngr_t const * p_nrf_twi_mngr, + nrf_drv_twi_config_t const * p_default_twi_config) +{ + ASSERT(p_nrf_twi_mngr != NULL); + ASSERT(p_nrf_twi_mngr->p_queue != NULL); + ASSERT(p_nrf_twi_mngr->p_queue->size > 0); + ASSERT(p_default_twi_config != NULL); + + ret_code_t err_code; + + err_code = nrf_drv_twi_init(&p_nrf_twi_mngr->twi, + p_default_twi_config, + twi_event_handler, + (void *)p_nrf_twi_mngr); + VERIFY_SUCCESS(err_code); + + nrf_drv_twi_enable(&p_nrf_twi_mngr->twi); + + p_nrf_twi_mngr->p_nrf_twi_mngr_cb->p_current_transaction = NULL; + p_nrf_twi_mngr->p_nrf_twi_mngr_cb->default_configuration = *p_default_twi_config; + p_nrf_twi_mngr->p_nrf_twi_mngr_cb->p_current_configuration = + &p_nrf_twi_mngr->p_nrf_twi_mngr_cb->default_configuration; + + return NRF_SUCCESS; +} + + +void nrf_twi_mngr_uninit(nrf_twi_mngr_t const * p_nrf_twi_mngr) +{ + ASSERT(p_nrf_twi_mngr != NULL); + + nrf_drv_twi_uninit(&p_nrf_twi_mngr->twi); + + p_nrf_twi_mngr->p_nrf_twi_mngr_cb->p_current_transaction = NULL; +} + + +ret_code_t nrf_twi_mngr_schedule(nrf_twi_mngr_t const * p_nrf_twi_mngr, + nrf_twi_mngr_transaction_t const * p_transaction) +{ + ASSERT(p_nrf_twi_mngr != NULL); + ASSERT(p_transaction != NULL); + ASSERT(p_transaction->p_transfers != NULL); + ASSERT(p_transaction->number_of_transfers != 0); + + ret_code_t result = NRF_SUCCESS; + + result = nrf_queue_push(p_nrf_twi_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_twi_mngr, false); + } + + return result; +} + + +static void internal_transaction_cb(ret_code_t result, void * p_user_data) +{ + nrf_twi_mngr_cb_data_t *p_cb_data = (nrf_twi_mngr_cb_data_t *)p_user_data; + + p_cb_data->transaction_result = result; + p_cb_data->transaction_in_progress = false; +} + + +ret_code_t nrf_twi_mngr_perform(nrf_twi_mngr_t const * p_nrf_twi_mngr, + nrf_drv_twi_config_t const * p_config, + nrf_twi_mngr_transfer_t const * p_transfers, + uint8_t number_of_transfers, + void (* user_function)(void)) +{ + ASSERT(p_nrf_twi_mngr != NULL); + ASSERT(p_transfers != NULL); + ASSERT(number_of_transfers != 0); + + nrf_twi_mngr_cb_data_t cb_data = + { + .transaction_in_progress = true + }; + + nrf_twi_mngr_transaction_t internal_transaction = + { + .callback = internal_transaction_cb, + .p_user_data = (void *)&cb_data, + .p_transfers = p_transfers, + .number_of_transfers = number_of_transfers, + .p_required_twi_cfg = p_config + }; + + ret_code_t result = nrf_twi_mngr_schedule(p_nrf_twi_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_TWI_MNGR) |