diff options
Diffstat (limited to 'thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf')
35 files changed, 6951 insertions, 0 deletions
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/esb/nrf_esb.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/esb/nrf_esb.c new file mode 100644 index 0000000..5624d19 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/esb/nrf_esb.c @@ -0,0 +1,1603 @@ +/** + * Copyright (c) 2016 - 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 "nrf_error.h" +#include "nrf_esb.h" +#include "nrf_esb_error_codes.h" +#include "nrf_gpio.h" +#include <string.h> +#include <stddef.h> +#include "sdk_common.h" +#include "sdk_macros.h" +#include "app_util.h" +#include "nrf_log.h" +#include "nrf_delay.h" + +#define BIT_MASK_UINT_8(x) (0xFF >> (8 - (x))) +#define NRF_ESB_PIPE_COUNT 8 + +// Constant parameters +#define RX_WAIT_FOR_ACK_TIMEOUT_US_2MBPS (48) /**< 2 Mb RX wait for acknowledgment time-out value. Smallest reliable value - 43. */ +#define RX_WAIT_FOR_ACK_TIMEOUT_US_1MBPS (64) /**< 1 Mb RX wait for acknowledgment time-out value. Smallest reliable value - 59. */ +#define RX_WAIT_FOR_ACK_TIMEOUT_US_250KBPS (250) /**< 250 Kb RX wait for acknowledgment time-out value. */ +#define RX_WAIT_FOR_ACK_TIMEOUT_US_1MBPS_BLE (73) /**< 1 Mb RX wait for acknowledgment time-out (combined with BLE). Smallest reliable value - 68.*/ + +// Interrupt flags +#define NRF_ESB_INT_TX_SUCCESS_MSK 0x01 /**< Interrupt mask value for TX success. */ +#define NRF_ESB_INT_TX_FAILED_MSK 0x02 /**< Interrupt mask value for TX failure. */ +#define NRF_ESB_INT_RX_DATA_RECEIVED_MSK 0x04 /**< Interrupt mask value for RX_DR. */ + +#define NRF_ESB_PID_RESET_VALUE 0xFF /**< Invalid PID value which is guaranteed to not collide with any valid PID value. */ +#define NRF_ESB_PID_MAX 3 /**< Maximum value for PID. */ +#define NRF_ESB_CRC_RESET_VALUE 0xFFFF /**< CRC reset value. */ + +// Internal Enhanced ShockBurst module state. +typedef enum { + NRF_ESB_STATE_IDLE, /**< Module idle. */ + NRF_ESB_STATE_PTX_TX, /**< Module transmitting without acknowledgment. */ + NRF_ESB_STATE_PTX_TX_ACK, /**< Module transmitting with acknowledgment. */ + NRF_ESB_STATE_PTX_RX_ACK, /**< Module transmitting with acknowledgment and reception of payload with the acknowledgment response. */ + NRF_ESB_STATE_PRX, /**< Module receiving packets without acknowledgment. */ + NRF_ESB_STATE_PRX_SEND_ACK, /**< Module transmitting acknowledgment in RX mode. */ +} nrf_esb_mainstate_t; + + +#define DISABLE_RF_IRQ() NVIC_DisableIRQ(RADIO_IRQn) +#define ENABLE_RF_IRQ() NVIC_EnableIRQ(RADIO_IRQn) + +#define _RADIO_SHORTS_COMMON ( RADIO_SHORTS_READY_START_Msk | RADIO_SHORTS_END_DISABLE_Msk | \ + RADIO_SHORTS_ADDRESS_RSSISTART_Msk | RADIO_SHORTS_DISABLED_RSSISTOP_Msk ) + +#define VERIFY_PAYLOAD_LENGTH(p) \ +do \ +{ \ + if (p->length == 0 || \ + p->length > NRF_ESB_MAX_PAYLOAD_LENGTH || \ + (m_config_local.protocol == NRF_ESB_PROTOCOL_ESB && \ + p->length > m_config_local.payload_length)) \ + { \ + return NRF_ERROR_INVALID_LENGTH; \ + } \ +}while (0) + + +/* @brief Structure holding pipe info PID and CRC and acknowledgment payload. */ +typedef struct +{ + uint16_t crc; /**< CRC value of the last received packet (Used to detect retransmits). */ + uint8_t pid; /**< Packet ID of the last received packet (Used to detect retransmits). */ + bool ack_payload; /**< Flag indicating the state of the transmission of acknowledgment payloads. */ +} pipe_info_t; + + +/* @brief First-in, first-out queue of payloads to be transmitted. */ +typedef struct +{ + nrf_esb_payload_t * p_payload[NRF_ESB_TX_FIFO_SIZE]; /**< Pointer to the actual queue. */ + uint32_t entry_point; /**< Current start of queue. */ + uint32_t exit_point; /**< Current end of queue. */ + uint32_t count; /**< Current number of elements in the queue. */ +} nrf_esb_payload_tx_fifo_t; + + +/* @brief First-in, first-out queue of received payloads. */ +typedef struct +{ + nrf_esb_payload_t * p_payload[NRF_ESB_RX_FIFO_SIZE]; /**< Pointer to the actual queue. */ + uint32_t entry_point; /**< Current start of queue. */ + uint32_t exit_point; /**< Current end of queue. */ + uint32_t count; /**< Current number of elements in the queue. */ +} nrf_esb_payload_rx_fifo_t; + + +/**@brief Enhanced ShockBurst address. + * + * Enhanced ShockBurst addresses consist of a base address and a prefix + * that is unique for each pipe. See @ref esb_addressing in the ESB user + * guide for more information. +*/ +typedef struct +{ + uint8_t base_addr_p0[4]; /**< Base address for pipe 0 encoded in big endian. */ + uint8_t base_addr_p1[4]; /**< Base address for pipe 1-7 encoded in big endian. */ + uint8_t pipe_prefixes[8]; /**< Address prefix for pipe 0 to 7. */ + uint8_t num_pipes; /**< Number of pipes available. */ + uint8_t addr_length; /**< Length of the address including the prefix. */ + uint8_t rx_pipes_enabled; /**< Bitfield for enabled pipes. */ + uint8_t rf_channel; /**< Channel to use (must be between 0 and 100). */ +} nrf_esb_address_t; + + +// Module state +static bool m_esb_initialized = false; +static nrf_esb_mainstate_t m_nrf_esb_mainstate = NRF_ESB_STATE_IDLE; +static nrf_esb_payload_t * mp_current_payload; + +static nrf_esb_event_handler_t m_event_handler; + +// Address parameters +__ALIGN(4) static nrf_esb_address_t m_esb_addr = NRF_ESB_ADDR_DEFAULT; + +// RF parameters +static nrf_esb_config_t m_config_local; + +// TX FIFO +static nrf_esb_payload_t m_tx_fifo_payload[NRF_ESB_TX_FIFO_SIZE]; +static nrf_esb_payload_tx_fifo_t m_tx_fifo; + +// RX FIFO +static nrf_esb_payload_t m_rx_fifo_payload[NRF_ESB_RX_FIFO_SIZE]; +static nrf_esb_payload_rx_fifo_t m_rx_fifo; + +// Payload buffers +static uint8_t m_tx_payload_buffer[NRF_ESB_MAX_PAYLOAD_LENGTH + 2]; +static uint8_t m_rx_payload_buffer[NRF_ESB_MAX_PAYLOAD_LENGTH + 2]; + +// Run time variables +static volatile uint32_t m_interrupt_flags = 0; +static uint8_t m_pids[NRF_ESB_PIPE_COUNT]; +static pipe_info_t m_rx_pipe_info[NRF_ESB_PIPE_COUNT]; +static volatile uint32_t m_retransmits_remaining; +static volatile uint32_t m_last_tx_attempts; +static volatile uint32_t m_wait_for_ack_timeout_us; + +// nRF52 address workaround enable +#ifdef NRF52 +static bool m_address_hang_fix_enable = true; +#endif +static uint32_t m_radio_shorts_common = _RADIO_SHORTS_COMMON; + +// These function pointers are changed dynamically, depending on protocol configuration and state. +static void (*on_radio_disabled)(void) = 0; +static void (*on_radio_end)(void) = 0; +static void (*update_rf_payload_format)(uint32_t payload_length) = 0; + + +// The following functions are assigned to the function pointers above. +static void on_radio_disabled_tx_noack(void); +static void on_radio_disabled_tx(void); +static void on_radio_disabled_tx_wait_for_ack(void); +static void on_radio_disabled_rx(void); +static void on_radio_disabled_rx_ack(void); + + +#define NRF_ESB_ADDR_UPDATE_MASK_BASE0 (1 << 0) /*< Mask value to signal updating BASE0 radio address. */ +#define NRF_ESB_ADDR_UPDATE_MASK_BASE1 (1 << 1) /*< Mask value to signal updating BASE1 radio address. */ +#define NRF_ESB_ADDR_UPDATE_MASK_PREFIX (1 << 2) /*< Mask value to signal updating radio prefixes. */ + + +// Function to do bytewise bit-swap on an unsigned 32-bit value +static uint32_t bytewise_bit_swap(uint8_t const * p_inp) +{ + uint32_t inp = (*(uint32_t*)p_inp); +#if __CORTEX_M == (0x04U) + return __REV((uint32_t)__RBIT(inp)); //lint -esym(628, __rev) -esym(526, __rev) -esym(628, __rbit) -esym(526, __rbit) */ +#else + inp = (inp & 0xF0F0F0F0) >> 4 | (inp & 0x0F0F0F0F) << 4; + inp = (inp & 0xCCCCCCCC) >> 2 | (inp & 0x33333333) << 2; + inp = (inp & 0xAAAAAAAA) >> 1 | (inp & 0x55555555) << 1; + return inp; +#endif +} + + +// Internal function to convert base addresses from nRF24L type addressing to nRF51 type addressing +static uint32_t addr_conv(uint8_t const* p_addr) +{ + return __REV(bytewise_bit_swap(p_addr)); //lint -esym(628, __rev) -esym(526, __rev) */ +} + + +static ret_code_t apply_address_workarounds() +{ +#ifdef NRF52 + // Set up radio parameters. + NRF_RADIO->MODECNF0 = (NRF_RADIO->MODECNF0 & ~RADIO_MODECNF0_RU_Msk) | RADIO_MODECNF0_RU_Default << RADIO_MODECNF0_RU_Pos; + + // Workaround for nRF52832 Rev 1 Errata 102 and nRF52832 Rev 1 Errata 106. This will reduce sensitivity by 3dB. + *((volatile uint32_t *)0x40001774) = (*((volatile uint32_t *)0x40001774) & 0xFFFFFFFE) | 0x01000000; +#endif + return NRF_SUCCESS; +} + + +static void update_rf_payload_format_esb_dpl(uint32_t payload_length) +{ +#if (NRF_ESB_MAX_PAYLOAD_LENGTH <= 32) + // Using 6 bits for length + NRF_RADIO->PCNF0 = (0 << RADIO_PCNF0_S0LEN_Pos) | + (6 << RADIO_PCNF0_LFLEN_Pos) | + (3 << RADIO_PCNF0_S1LEN_Pos) ; +#else + // Using 8 bits for length + NRF_RADIO->PCNF0 = (0 << RADIO_PCNF0_S0LEN_Pos) | + (8 << RADIO_PCNF0_LFLEN_Pos) | + (3 << RADIO_PCNF0_S1LEN_Pos) ; +#endif + NRF_RADIO->PCNF1 = (RADIO_PCNF1_WHITEEN_Disabled << RADIO_PCNF1_WHITEEN_Pos) | + (RADIO_PCNF1_ENDIAN_Big << RADIO_PCNF1_ENDIAN_Pos) | + ((m_esb_addr.addr_length - 1) << RADIO_PCNF1_BALEN_Pos) | + (0 << RADIO_PCNF1_STATLEN_Pos) | + (NRF_ESB_MAX_PAYLOAD_LENGTH << RADIO_PCNF1_MAXLEN_Pos); +} + + +static void update_rf_payload_format_esb(uint32_t payload_length) +{ + NRF_RADIO->PCNF0 = (1 << RADIO_PCNF0_S0LEN_Pos) | + (0 << RADIO_PCNF0_LFLEN_Pos) | + (1 << RADIO_PCNF0_S1LEN_Pos); + + NRF_RADIO->PCNF1 = (RADIO_PCNF1_WHITEEN_Disabled << RADIO_PCNF1_WHITEEN_Pos) | + (RADIO_PCNF1_ENDIAN_Big << RADIO_PCNF1_ENDIAN_Pos) | + ((m_esb_addr.addr_length - 1) << RADIO_PCNF1_BALEN_Pos) | + (payload_length << RADIO_PCNF1_STATLEN_Pos) | + (payload_length << RADIO_PCNF1_MAXLEN_Pos); +} + + +static void update_radio_addresses(uint8_t update_mask) +{ + if ((update_mask & NRF_ESB_ADDR_UPDATE_MASK_BASE0) != 0) + { + NRF_RADIO->BASE0 = addr_conv(m_esb_addr.base_addr_p0); + } + + if ((update_mask & NRF_ESB_ADDR_UPDATE_MASK_BASE1) != 0) + { + NRF_RADIO->BASE1 = addr_conv(m_esb_addr.base_addr_p1); + } + + if ((update_mask & NRF_ESB_ADDR_UPDATE_MASK_PREFIX) != 0) + { + NRF_RADIO->PREFIX0 = bytewise_bit_swap(&m_esb_addr.pipe_prefixes[0]); + NRF_RADIO->PREFIX1 = bytewise_bit_swap(&m_esb_addr.pipe_prefixes[4]); + } +} + + +static void update_radio_tx_power() +{ + NRF_RADIO->TXPOWER = m_config_local.tx_output_power << RADIO_TXPOWER_TXPOWER_Pos; +} + + +static bool update_radio_bitrate() +{ + NRF_RADIO->MODE = m_config_local.bitrate << RADIO_MODE_MODE_Pos; + + switch (m_config_local.bitrate) + { + case NRF_ESB_BITRATE_2MBPS: +#ifdef NRF52 + case NRF_ESB_BITRATE_2MBPS_BLE: +#endif + m_wait_for_ack_timeout_us = RX_WAIT_FOR_ACK_TIMEOUT_US_2MBPS; + break; + + case NRF_ESB_BITRATE_1MBPS: + m_wait_for_ack_timeout_us = RX_WAIT_FOR_ACK_TIMEOUT_US_1MBPS; + break; + +#ifdef NRF51 + case NRF_ESB_BITRATE_250KBPS: + m_wait_for_ack_timeout_us = RX_WAIT_FOR_ACK_TIMEOUT_US_250KBPS; + break; +#endif + + case NRF_ESB_BITRATE_1MBPS_BLE: + m_wait_for_ack_timeout_us = RX_WAIT_FOR_ACK_TIMEOUT_US_1MBPS_BLE; + break; + + default: + // Should not be reached + return false; + } + return true; +} + + +static bool update_radio_protocol() +{ + switch (m_config_local.protocol) + { + case NRF_ESB_PROTOCOL_ESB_DPL: + update_rf_payload_format = update_rf_payload_format_esb_dpl; + break; + + case NRF_ESB_PROTOCOL_ESB: + update_rf_payload_format = update_rf_payload_format_esb; + break; + + default: + // Should not be reached + return false; + } + return true; +} + + +static bool update_radio_crc() +{ + switch(m_config_local.crc) + { + case NRF_ESB_CRC_16BIT: + NRF_RADIO->CRCINIT = 0xFFFFUL; // Initial value + NRF_RADIO->CRCPOLY = 0x11021UL; // CRC poly: x^16+x^12^x^5+1 + break; + + case NRF_ESB_CRC_8BIT: + NRF_RADIO->CRCINIT = 0xFFUL; // Initial value + NRF_RADIO->CRCPOLY = 0x107UL; // CRC poly: x^8+x^2^x^1+1 + break; + + case NRF_ESB_CRC_OFF: + break; + + default: + return false; + } + NRF_RADIO->CRCCNF = m_config_local.crc << RADIO_CRCCNF_LEN_Pos; + return true; +} + + +static bool update_radio_parameters() +{ + bool params_valid = true; + update_radio_tx_power(); + params_valid &= update_radio_bitrate(); + params_valid &= update_radio_protocol(); + params_valid &= update_radio_crc(); + update_rf_payload_format(m_config_local.payload_length); + params_valid &= (m_config_local.retransmit_delay >= NRF_ESB_RETRANSMIT_DELAY_MIN); + return params_valid; +} + + +static void reset_fifos() +{ + m_tx_fifo.entry_point = 0; + m_tx_fifo.exit_point = 0; + m_tx_fifo.count = 0; + + m_rx_fifo.entry_point = 0; + m_rx_fifo.exit_point = 0; + m_rx_fifo.count = 0; +} + + +static void initialize_fifos() +{ + reset_fifos(); + + for (int i = 0; i < NRF_ESB_TX_FIFO_SIZE; i++) + { + m_tx_fifo.p_payload[i] = &m_tx_fifo_payload[i]; + } + + for (int i = 0; i < NRF_ESB_RX_FIFO_SIZE; i++) + { + m_rx_fifo.p_payload[i] = &m_rx_fifo_payload[i]; + } +} + + +static void tx_fifo_remove_last() +{ + if (m_tx_fifo.count > 0) + { + DISABLE_RF_IRQ(); + + m_tx_fifo.count--; + if (++m_tx_fifo.exit_point >= NRF_ESB_TX_FIFO_SIZE) + { + m_tx_fifo.exit_point = 0; + } + + ENABLE_RF_IRQ(); + } +} + +/** @brief Function to push the content of the rx_buffer to the RX FIFO. + * + * The module will point the register NRF_RADIO->PACKETPTR to a buffer for receiving packets. + * After receiving a packet the module will call this function to copy the received data to + * the RX FIFO. + * + * @param pipe Pipe number to set for the packet. + * @param pid Packet ID. + * + * @retval true Operation successful. + * @retval false Operation failed. + */ +static bool rx_fifo_push_rfbuf(uint8_t pipe, uint8_t pid) +{ + if (m_rx_fifo.count < NRF_ESB_RX_FIFO_SIZE) + { + if (m_config_local.protocol == NRF_ESB_PROTOCOL_ESB_DPL) + { + if (m_rx_payload_buffer[0] > NRF_ESB_MAX_PAYLOAD_LENGTH) + { + return false; + } + + m_rx_fifo.p_payload[m_rx_fifo.entry_point]->length = m_rx_payload_buffer[0]; + } + else if (m_config_local.mode == NRF_ESB_MODE_PTX) + { + // Received packet is an acknowledgment + m_rx_fifo.p_payload[m_rx_fifo.entry_point]->length = 0; + } + else + { + m_rx_fifo.p_payload[m_rx_fifo.entry_point]->length = m_config_local.payload_length; + } + + memcpy(m_rx_fifo.p_payload[m_rx_fifo.entry_point]->data, &m_rx_payload_buffer[2], + m_rx_fifo.p_payload[m_rx_fifo.entry_point]->length); + + m_rx_fifo.p_payload[m_rx_fifo.entry_point]->pipe = pipe; + m_rx_fifo.p_payload[m_rx_fifo.entry_point]->rssi = NRF_RADIO->RSSISAMPLE; + m_rx_fifo.p_payload[m_rx_fifo.entry_point]->pid = pid; + m_rx_fifo.p_payload[m_rx_fifo.entry_point]->noack = !(m_rx_payload_buffer[1] & 0x01); + if (++m_rx_fifo.entry_point >= NRF_ESB_RX_FIFO_SIZE) + { + m_rx_fifo.entry_point = 0; + } + m_rx_fifo.count++; + + return true; + } + + return false; +} + + +static void sys_timer_init() +{ + // Configure the system timer with a 1 MHz base frequency + NRF_ESB_SYS_TIMER->PRESCALER = 4; + NRF_ESB_SYS_TIMER->BITMODE = TIMER_BITMODE_BITMODE_16Bit; + NRF_ESB_SYS_TIMER->SHORTS = TIMER_SHORTS_COMPARE1_CLEAR_Msk | TIMER_SHORTS_COMPARE1_STOP_Msk; +} + + +static void ppi_init() +{ + NRF_PPI->CH[NRF_ESB_PPI_TIMER_START].EEP = (uint32_t)&NRF_RADIO->EVENTS_READY; + NRF_PPI->CH[NRF_ESB_PPI_TIMER_START].TEP = (uint32_t)&NRF_ESB_SYS_TIMER->TASKS_START; + + NRF_PPI->CH[NRF_ESB_PPI_TIMER_STOP].EEP = (uint32_t)&NRF_RADIO->EVENTS_ADDRESS; + NRF_PPI->CH[NRF_ESB_PPI_TIMER_STOP].TEP = (uint32_t)&NRF_ESB_SYS_TIMER->TASKS_STOP; + + NRF_PPI->CH[NRF_ESB_PPI_RX_TIMEOUT].EEP = (uint32_t)&NRF_ESB_SYS_TIMER->EVENTS_COMPARE[0]; + NRF_PPI->CH[NRF_ESB_PPI_RX_TIMEOUT].TEP = (uint32_t)&NRF_RADIO->TASKS_DISABLE; + + NRF_PPI->CH[NRF_ESB_PPI_TX_START].EEP = (uint32_t)&NRF_ESB_SYS_TIMER->EVENTS_COMPARE[1]; + NRF_PPI->CH[NRF_ESB_PPI_TX_START].TEP = (uint32_t)&NRF_RADIO->TASKS_TXEN; +} + + +static void start_tx_transaction() +{ + bool ack; + + m_last_tx_attempts = 1; + // Prepare the payload + mp_current_payload = m_tx_fifo.p_payload[m_tx_fifo.exit_point]; + + + switch (m_config_local.protocol) + { + case NRF_ESB_PROTOCOL_ESB: + update_rf_payload_format(mp_current_payload->length); + m_tx_payload_buffer[0] = mp_current_payload->pid; + m_tx_payload_buffer[1] = 0; + memcpy(&m_tx_payload_buffer[2], mp_current_payload->data, mp_current_payload->length); + + NRF_RADIO->SHORTS = m_radio_shorts_common | RADIO_SHORTS_DISABLED_RXEN_Msk; + NRF_RADIO->INTENSET = RADIO_INTENSET_DISABLED_Msk | RADIO_INTENSET_READY_Msk; + + // Configure the retransmit counter + m_retransmits_remaining = m_config_local.retransmit_count; + on_radio_disabled = on_radio_disabled_tx; + m_nrf_esb_mainstate = NRF_ESB_STATE_PTX_TX_ACK; + break; + + case NRF_ESB_PROTOCOL_ESB_DPL: + ack = !mp_current_payload->noack || !m_config_local.selective_auto_ack; + m_tx_payload_buffer[0] = mp_current_payload->length; + m_tx_payload_buffer[1] = mp_current_payload->pid << 1; + m_tx_payload_buffer[1] |= mp_current_payload->noack ? 0x00 : 0x01; + memcpy(&m_tx_payload_buffer[2], mp_current_payload->data, mp_current_payload->length); + + // Handling ack if noack is set to false or if selective auto ack is turned off + if (ack) + { + NRF_RADIO->SHORTS = m_radio_shorts_common | RADIO_SHORTS_DISABLED_RXEN_Msk; + NRF_RADIO->INTENSET = RADIO_INTENSET_DISABLED_Msk | RADIO_INTENSET_READY_Msk; + + // Configure the retransmit counter + m_retransmits_remaining = m_config_local.retransmit_count; + on_radio_disabled = on_radio_disabled_tx; + m_nrf_esb_mainstate = NRF_ESB_STATE_PTX_TX_ACK; + } + else + { + NRF_RADIO->SHORTS = m_radio_shorts_common; + NRF_RADIO->INTENSET = RADIO_INTENSET_DISABLED_Msk; + on_radio_disabled = on_radio_disabled_tx_noack; + m_nrf_esb_mainstate = NRF_ESB_STATE_PTX_TX; + } + break; + + default: + // Should not be reached + break; + } + + NRF_RADIO->TXADDRESS = mp_current_payload->pipe; + NRF_RADIO->RXADDRESSES = 1 << mp_current_payload->pipe; + + NRF_RADIO->FREQUENCY = m_esb_addr.rf_channel; + NRF_RADIO->PACKETPTR = (uint32_t)m_tx_payload_buffer; + + NVIC_ClearPendingIRQ(RADIO_IRQn); + NVIC_EnableIRQ(RADIO_IRQn); + + NRF_RADIO->EVENTS_ADDRESS = 0; + NRF_RADIO->EVENTS_PAYLOAD = 0; + NRF_RADIO->EVENTS_DISABLED = 0; + + DEBUG_PIN_SET(DEBUGPIN4); + NRF_RADIO->TASKS_TXEN = 1; +} + + +static void on_radio_disabled_tx_noack() +{ + m_interrupt_flags |= NRF_ESB_INT_TX_SUCCESS_MSK; + tx_fifo_remove_last(); + + if (m_tx_fifo.count == 0) + { + m_nrf_esb_mainstate = NRF_ESB_STATE_IDLE; + NVIC_SetPendingIRQ(ESB_EVT_IRQ); + } + else + { + NVIC_SetPendingIRQ(ESB_EVT_IRQ); + start_tx_transaction(); + } +} + + +static void on_radio_disabled_tx() +{ + // Remove the DISABLED -> RXEN shortcut, to make sure the radio stays + // disabled after the RX window + NRF_RADIO->SHORTS = m_radio_shorts_common; + + // Make sure the timer is started the next time the radio is ready, + // and that it will disable the radio automatically if no packet is + // received by the time defined in m_wait_for_ack_timeout_us + NRF_ESB_SYS_TIMER->CC[0] = m_wait_for_ack_timeout_us; + NRF_ESB_SYS_TIMER->CC[1] = m_config_local.retransmit_delay - 130; + NRF_ESB_SYS_TIMER->TASKS_CLEAR = 1; + NRF_ESB_SYS_TIMER->EVENTS_COMPARE[0] = 0; + NRF_ESB_SYS_TIMER->EVENTS_COMPARE[1] = 0; + + NRF_PPI->CHENSET = (1 << NRF_ESB_PPI_TIMER_START) | + (1 << NRF_ESB_PPI_RX_TIMEOUT) | + (1 << NRF_ESB_PPI_TIMER_STOP); + NRF_PPI->CHENCLR = (1 << NRF_ESB_PPI_TX_START); + NRF_RADIO->EVENTS_END = 0; + + if (m_config_local.protocol == NRF_ESB_PROTOCOL_ESB) + { + update_rf_payload_format(0); + } + + NRF_RADIO->PACKETPTR = (uint32_t)m_rx_payload_buffer; + on_radio_disabled = on_radio_disabled_tx_wait_for_ack; + m_nrf_esb_mainstate = NRF_ESB_STATE_PTX_RX_ACK; +} + + +static void on_radio_disabled_tx_wait_for_ack() +{ + // This marks the completion of a TX_RX sequence (TX with ACK) + + // Make sure the timer will not deactivate the radio if a packet is received + NRF_PPI->CHENCLR = (1 << NRF_ESB_PPI_TIMER_START) | + (1 << NRF_ESB_PPI_RX_TIMEOUT) | + (1 << NRF_ESB_PPI_TIMER_STOP); + + // If the radio has received a packet and the CRC status is OK + if (NRF_RADIO->EVENTS_END && NRF_RADIO->CRCSTATUS != 0) + { + NRF_ESB_SYS_TIMER->TASKS_STOP = 1; + NRF_PPI->CHENCLR = (1 << NRF_ESB_PPI_TX_START); + m_interrupt_flags |= NRF_ESB_INT_TX_SUCCESS_MSK; + m_last_tx_attempts = m_config_local.retransmit_count - m_retransmits_remaining + 1; + + tx_fifo_remove_last(); + + if (m_config_local.protocol != NRF_ESB_PROTOCOL_ESB && m_rx_payload_buffer[0] > 0) + { + if (rx_fifo_push_rfbuf((uint8_t)NRF_RADIO->TXADDRESS, m_rx_payload_buffer[1] >> 1)) + { + m_interrupt_flags |= NRF_ESB_INT_RX_DATA_RECEIVED_MSK; + } + } + + if ((m_tx_fifo.count == 0) || (m_config_local.tx_mode == NRF_ESB_TXMODE_MANUAL)) + { + m_nrf_esb_mainstate = NRF_ESB_STATE_IDLE; + NVIC_SetPendingIRQ(ESB_EVT_IRQ); + } + else + { + NVIC_SetPendingIRQ(ESB_EVT_IRQ); + start_tx_transaction(); + } + } + else + { + if (m_retransmits_remaining-- == 0) + { + NRF_ESB_SYS_TIMER->TASKS_STOP = 1; + NRF_PPI->CHENCLR = (1 << NRF_ESB_PPI_TX_START); + // All retransmits are expended, and the TX operation is suspended + m_last_tx_attempts = m_config_local.retransmit_count + 1; + m_interrupt_flags |= NRF_ESB_INT_TX_FAILED_MSK; + + m_nrf_esb_mainstate = NRF_ESB_STATE_IDLE; + NVIC_SetPendingIRQ(ESB_EVT_IRQ); + } + else + { + // There are still more retransmits left, TX mode should be + // entered again as soon as the system timer reaches CC[1]. + NRF_RADIO->SHORTS = m_radio_shorts_common | RADIO_SHORTS_DISABLED_RXEN_Msk; + update_rf_payload_format(mp_current_payload->length); + NRF_RADIO->PACKETPTR = (uint32_t)m_tx_payload_buffer; + on_radio_disabled = on_radio_disabled_tx; + m_nrf_esb_mainstate = NRF_ESB_STATE_PTX_TX_ACK; + NRF_ESB_SYS_TIMER->TASKS_START = 1; + NRF_PPI->CHENSET = (1 << NRF_ESB_PPI_TX_START); + if (NRF_ESB_SYS_TIMER->EVENTS_COMPARE[1]) + { + NRF_RADIO->TASKS_TXEN = 1; + } + } + } +} + +static void clear_events_restart_rx(void) +{ + NRF_RADIO->SHORTS = m_radio_shorts_common; + update_rf_payload_format(m_config_local.payload_length); + NRF_RADIO->PACKETPTR = (uint32_t)m_rx_payload_buffer; + NRF_RADIO->EVENTS_DISABLED = 0; + NRF_RADIO->TASKS_DISABLE = 1; + + while (NRF_RADIO->EVENTS_DISABLED == 0); + + NRF_RADIO->EVENTS_DISABLED = 0; + NRF_RADIO->SHORTS = m_radio_shorts_common | RADIO_SHORTS_DISABLED_TXEN_Msk; + + NRF_RADIO->TASKS_RXEN = 1; +} + +static void on_radio_disabled_rx(void) +{ + bool ack = false; + bool retransmit_payload = false; + bool send_rx_event = true; + pipe_info_t * p_pipe_info; + + if (NRF_RADIO->CRCSTATUS == 0) + { + clear_events_restart_rx(); + return; + } + + if (m_rx_fifo.count >= NRF_ESB_RX_FIFO_SIZE) + { + clear_events_restart_rx(); + return; + } + + p_pipe_info = &m_rx_pipe_info[NRF_RADIO->RXMATCH]; + if (NRF_RADIO->RXCRC == p_pipe_info->crc && + (m_rx_payload_buffer[1] >> 1) == p_pipe_info->pid + ) + { + retransmit_payload = true; + send_rx_event = false; + } + + p_pipe_info->pid = m_rx_payload_buffer[1] >> 1; + p_pipe_info->crc = NRF_RADIO->RXCRC; + + if ((m_config_local.selective_auto_ack == false) || ((m_rx_payload_buffer[1] & 0x01) == 1)) + { + ack = true; + } + + if (ack) + { + NRF_RADIO->SHORTS = m_radio_shorts_common | RADIO_SHORTS_DISABLED_RXEN_Msk; + + switch (m_config_local.protocol) + { + case NRF_ESB_PROTOCOL_ESB_DPL: + { + if (m_tx_fifo.count > 0 && + (m_tx_fifo.p_payload[m_tx_fifo.exit_point]->pipe == NRF_RADIO->RXMATCH) + ) + { + // Pipe stays in ACK with payload until TX FIFO is empty + // Do not report TX success on first ack payload or retransmit + if (p_pipe_info->ack_payload == true && !retransmit_payload) + { + if (++m_tx_fifo.exit_point >= NRF_ESB_TX_FIFO_SIZE) + { + m_tx_fifo.exit_point = 0; + } + + m_tx_fifo.count--; + + // ACK payloads also require TX_DS + // (page 40 of the 'nRF24LE1_Product_Specification_rev1_6.pdf'). + m_interrupt_flags |= NRF_ESB_INT_TX_SUCCESS_MSK; + } + + p_pipe_info->ack_payload = true; + + mp_current_payload = m_tx_fifo.p_payload[m_tx_fifo.exit_point]; + + update_rf_payload_format(mp_current_payload->length); + m_tx_payload_buffer[0] = mp_current_payload->length; + memcpy(&m_tx_payload_buffer[2], + mp_current_payload->data, + mp_current_payload->length); + } + else + { + p_pipe_info->ack_payload = false; + update_rf_payload_format(0); + m_tx_payload_buffer[0] = 0; + } + + m_tx_payload_buffer[1] = m_rx_payload_buffer[1]; + } + break; + + case NRF_ESB_PROTOCOL_ESB: + { + update_rf_payload_format(0); + m_tx_payload_buffer[0] = m_rx_payload_buffer[0]; + m_tx_payload_buffer[1] = 0; + } + break; + } + + m_nrf_esb_mainstate = NRF_ESB_STATE_PRX_SEND_ACK; + NRF_RADIO->TXADDRESS = NRF_RADIO->RXMATCH; + NRF_RADIO->PACKETPTR = (uint32_t)m_tx_payload_buffer; + on_radio_disabled = on_radio_disabled_rx_ack; + } + else + { + clear_events_restart_rx(); + } + + if (send_rx_event) + { + // Push the new packet to the RX buffer and trigger a received event if the operation was + // successful. + if (rx_fifo_push_rfbuf(NRF_RADIO->RXMATCH, p_pipe_info->pid)) + { + m_interrupt_flags |= NRF_ESB_INT_RX_DATA_RECEIVED_MSK; + NVIC_SetPendingIRQ(ESB_EVT_IRQ); + } + } +} + + +static void on_radio_disabled_rx_ack(void) +{ + NRF_RADIO->SHORTS = m_radio_shorts_common | RADIO_SHORTS_DISABLED_TXEN_Msk; + update_rf_payload_format(m_config_local.payload_length); + + NRF_RADIO->PACKETPTR = (uint32_t)m_rx_payload_buffer; + on_radio_disabled = on_radio_disabled_rx; + + m_nrf_esb_mainstate = NRF_ESB_STATE_PRX; +} + + +/**@brief Function for clearing pending interrupts. + * + * @param[in,out] p_interrupts Pointer to the value that holds the current interrupts. + * + * @retval NRF_SUCCESS If the interrupts were cleared successfully. + * @retval NRF_ERROR_NULL If the required parameter was NULL. + * @retval NRF_INVALID_STATE If the module is not initialized. + */ +static uint32_t nrf_esb_get_clear_interrupts(uint32_t * p_interrupts) +{ + VERIFY_TRUE(m_esb_initialized, NRF_ERROR_INVALID_STATE); + VERIFY_PARAM_NOT_NULL(p_interrupts); + + DISABLE_RF_IRQ(); + + *p_interrupts = m_interrupt_flags; + m_interrupt_flags = 0; + + ENABLE_RF_IRQ(); + + return NRF_SUCCESS; +} + + +void RADIO_IRQHandler() +{ + if (NRF_RADIO->EVENTS_READY && (NRF_RADIO->INTENSET & RADIO_INTENSET_READY_Msk)) + { + NRF_RADIO->EVENTS_READY = 0; + DEBUG_PIN_SET(DEBUGPIN1); + } + + if (NRF_RADIO->EVENTS_END && (NRF_RADIO->INTENSET & RADIO_INTENSET_END_Msk)) + { + NRF_RADIO->EVENTS_END = 0; + DEBUG_PIN_SET(DEBUGPIN2); + + // Call the correct on_radio_end function, depending on the current protocol state + if (on_radio_end) + { + on_radio_end(); + } + } + + if (NRF_RADIO->EVENTS_DISABLED && (NRF_RADIO->INTENSET & RADIO_INTENSET_DISABLED_Msk)) + { + NRF_RADIO->EVENTS_DISABLED = 0; + DEBUG_PIN_SET(DEBUGPIN3); + + // Call the correct on_radio_disable function, depending on the current protocol state + if (on_radio_disabled) + { + on_radio_disabled(); + } + } + + DEBUG_PIN_CLR(DEBUGPIN1); + DEBUG_PIN_CLR(DEBUGPIN2); + DEBUG_PIN_CLR(DEBUGPIN3); + DEBUG_PIN_CLR(DEBUGPIN4); +} + + +uint32_t nrf_esb_init(nrf_esb_config_t const * p_config) +{ + uint32_t err_code; + + VERIFY_PARAM_NOT_NULL(p_config); + + if (m_esb_initialized) + { + err_code = nrf_esb_disable(); + if (err_code != NRF_SUCCESS) + { + return err_code; + } + } + + m_event_handler = p_config->event_handler; + + memcpy(&m_config_local, p_config, sizeof(nrf_esb_config_t)); + + m_interrupt_flags = 0; + + memset(m_rx_pipe_info, 0, sizeof(m_rx_pipe_info)); + memset(m_pids, 0, sizeof(m_pids)); + + VERIFY_TRUE(update_radio_parameters(), NRF_ERROR_INVALID_PARAM); + + // Configure radio address registers according to ESB default values + NRF_RADIO->BASE0 = 0xE7E7E7E7; + NRF_RADIO->BASE1 = 0x43434343; + NRF_RADIO->PREFIX0 = 0x23C343E7; + NRF_RADIO->PREFIX1 = 0x13E363A3; + + initialize_fifos(); + + sys_timer_init(); + + ppi_init(); + + NVIC_SetPriority(RADIO_IRQn, m_config_local.radio_irq_priority & ESB_IRQ_PRIORITY_MSK); + NVIC_SetPriority(ESB_EVT_IRQ, m_config_local.event_irq_priority & ESB_IRQ_PRIORITY_MSK); + NVIC_EnableIRQ(ESB_EVT_IRQ); + +#ifdef NRF52 + if(m_address_hang_fix_enable) + { + // Setup a timeout timer to start on an ADDRESS match, and stop on a BCMATCH event. + // If the BCMATCH event never occurs the CC[0] event will fire, and the timer interrupt will disable the radio to recover. + m_radio_shorts_common |= RADIO_SHORTS_ADDRESS_BCSTART_Msk; + NRF_RADIO->BCC = 2; + NRF_ESB_BUGFIX_TIMER->BITMODE = TIMER_BITMODE_BITMODE_32Bit << TIMER_BITMODE_BITMODE_Pos; + NRF_ESB_BUGFIX_TIMER->PRESCALER = 4; + NRF_ESB_BUGFIX_TIMER->CC[0] = 5; + NRF_ESB_BUGFIX_TIMER->SHORTS = TIMER_SHORTS_COMPARE0_STOP_Msk | TIMER_SHORTS_COMPARE0_CLEAR_Msk; + NRF_ESB_BUGFIX_TIMER->MODE = TIMER_MODE_MODE_Timer << TIMER_MODE_MODE_Pos; + NRF_ESB_BUGFIX_TIMER->INTENSET = TIMER_INTENSET_COMPARE0_Msk; + NRF_ESB_BUGFIX_TIMER->TASKS_CLEAR = 1; + NVIC_SetPriority(NRF_ESB_BUGFIX_TIMER_IRQn, 5); + NVIC_EnableIRQ(NRF_ESB_BUGFIX_TIMER_IRQn); + + NRF_PPI->CH[NRF_ESB_PPI_BUGFIX1].EEP = (uint32_t)&NRF_RADIO->EVENTS_ADDRESS; + NRF_PPI->CH[NRF_ESB_PPI_BUGFIX1].TEP = (uint32_t)&NRF_ESB_BUGFIX_TIMER->TASKS_START; + + NRF_PPI->CH[NRF_ESB_PPI_BUGFIX2].EEP = (uint32_t)&NRF_RADIO->EVENTS_BCMATCH; + NRF_PPI->CH[NRF_ESB_PPI_BUGFIX2].TEP = (uint32_t)&NRF_ESB_BUGFIX_TIMER->TASKS_STOP; + + NRF_PPI->CH[NRF_ESB_PPI_BUGFIX3].EEP = (uint32_t)&NRF_RADIO->EVENTS_BCMATCH; + NRF_PPI->CH[NRF_ESB_PPI_BUGFIX3].TEP = (uint32_t)&NRF_ESB_BUGFIX_TIMER->TASKS_CLEAR; + + NRF_PPI->CHENSET = (1 << NRF_ESB_PPI_BUGFIX1) | (1 << NRF_ESB_PPI_BUGFIX2) | (1 << NRF_ESB_PPI_BUGFIX3); + } +#endif + + m_nrf_esb_mainstate = NRF_ESB_STATE_IDLE; + m_esb_initialized = true; + + return NRF_SUCCESS; +} + + +uint32_t nrf_esb_suspend(void) +{ + VERIFY_TRUE(m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE, NRF_ERROR_BUSY); + + // Clear PPI + NRF_PPI->CHENCLR = (1 << NRF_ESB_PPI_TIMER_START) | + (1 << NRF_ESB_PPI_TIMER_STOP) | + (1 << NRF_ESB_PPI_RX_TIMEOUT) | + (1 << NRF_ESB_PPI_TX_START); + + m_nrf_esb_mainstate = NRF_ESB_STATE_IDLE; + + return NRF_SUCCESS; +} + + +uint32_t nrf_esb_disable(void) +{ + // Clear PPI + NRF_PPI->CHENCLR = (1 << NRF_ESB_PPI_TIMER_START) | + (1 << NRF_ESB_PPI_TIMER_STOP) | + (1 << NRF_ESB_PPI_RX_TIMEOUT) | + (1 << NRF_ESB_PPI_TX_START); + + m_nrf_esb_mainstate = NRF_ESB_STATE_IDLE; + + reset_fifos(); + + memset(m_rx_pipe_info, 0, sizeof(m_rx_pipe_info)); + memset(m_pids, 0, sizeof(m_pids)); + + // Disable the radio + NVIC_DisableIRQ(ESB_EVT_IRQ); + NRF_RADIO->SHORTS = RADIO_SHORTS_READY_START_Enabled << RADIO_SHORTS_READY_START_Pos | + RADIO_SHORTS_END_DISABLE_Enabled << RADIO_SHORTS_END_DISABLE_Pos; + + return NRF_SUCCESS; +} + + +bool nrf_esb_is_idle(void) +{ + return m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE; +} + + +void ESB_EVT_IRQHandler(void) +{ + ret_code_t err_code; + uint32_t interrupts; + nrf_esb_evt_t event; + + event.tx_attempts = m_last_tx_attempts; + + err_code = nrf_esb_get_clear_interrupts(&interrupts); + if (err_code == NRF_SUCCESS && m_event_handler != 0) + { + if (interrupts & NRF_ESB_INT_TX_SUCCESS_MSK) + { + event.evt_id = NRF_ESB_EVENT_TX_SUCCESS; + m_event_handler(&event); + } + if (interrupts & NRF_ESB_INT_TX_FAILED_MSK) + { + event.evt_id = NRF_ESB_EVENT_TX_FAILED; + m_event_handler(&event); + } + if (interrupts & NRF_ESB_INT_RX_DATA_RECEIVED_MSK) + { + event.evt_id = NRF_ESB_EVENT_RX_RECEIVED; + m_event_handler(&event); + } + } +} + +uint32_t nrf_esb_write_payload(nrf_esb_payload_t const * p_payload) +{ + VERIFY_TRUE(m_esb_initialized, NRF_ERROR_INVALID_STATE); + VERIFY_PARAM_NOT_NULL(p_payload); + VERIFY_PAYLOAD_LENGTH(p_payload); + VERIFY_FALSE(m_tx_fifo.count >= NRF_ESB_TX_FIFO_SIZE, NRF_ERROR_NO_MEM); + VERIFY_TRUE(p_payload->pipe < NRF_ESB_PIPE_COUNT, NRF_ERROR_INVALID_PARAM); + + DISABLE_RF_IRQ(); + + memcpy(m_tx_fifo.p_payload[m_tx_fifo.entry_point], p_payload, sizeof(nrf_esb_payload_t)); + + m_pids[p_payload->pipe] = (m_pids[p_payload->pipe] + 1) % (NRF_ESB_PID_MAX + 1); + m_tx_fifo.p_payload[m_tx_fifo.entry_point]->pid = m_pids[p_payload->pipe]; + + if (++m_tx_fifo.entry_point >= NRF_ESB_TX_FIFO_SIZE) + { + m_tx_fifo.entry_point = 0; + } + + m_tx_fifo.count++; + + ENABLE_RF_IRQ(); + + + if (m_config_local.mode == NRF_ESB_MODE_PTX && + m_config_local.tx_mode == NRF_ESB_TXMODE_AUTO && + m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE) + { + start_tx_transaction(); + } + + return NRF_SUCCESS; +} + + +uint32_t nrf_esb_read_rx_payload(nrf_esb_payload_t * p_payload) +{ + VERIFY_TRUE(m_esb_initialized, NRF_ERROR_INVALID_STATE); + VERIFY_PARAM_NOT_NULL(p_payload); + + if (m_rx_fifo.count == 0) + { + return NRF_ERROR_NOT_FOUND; + } + + DISABLE_RF_IRQ(); + + p_payload->length = m_rx_fifo.p_payload[m_rx_fifo.exit_point]->length; + p_payload->pipe = m_rx_fifo.p_payload[m_rx_fifo.exit_point]->pipe; + p_payload->rssi = m_rx_fifo.p_payload[m_rx_fifo.exit_point]->rssi; + p_payload->pid = m_rx_fifo.p_payload[m_rx_fifo.exit_point]->pid; + p_payload->noack = m_rx_fifo.p_payload[m_rx_fifo.exit_point]->noack; + memcpy(p_payload->data, m_rx_fifo.p_payload[m_rx_fifo.exit_point]->data, p_payload->length); + + if (++m_rx_fifo.exit_point >= NRF_ESB_RX_FIFO_SIZE) + { + m_rx_fifo.exit_point = 0; + } + + m_rx_fifo.count--; + + ENABLE_RF_IRQ(); + + return NRF_SUCCESS; +} + + +uint32_t nrf_esb_start_tx(void) +{ + VERIFY_TRUE(m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE, NRF_ERROR_BUSY); + + if (m_tx_fifo.count == 0) + { + return NRF_ERROR_BUFFER_EMPTY; + } + + start_tx_transaction(); + + return NRF_SUCCESS; +} + + +uint32_t nrf_esb_start_rx(void) +{ + VERIFY_TRUE(m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE, NRF_ERROR_BUSY); + + NRF_RADIO->INTENCLR = 0xFFFFFFFF; + NRF_RADIO->EVENTS_DISABLED = 0; + on_radio_disabled = on_radio_disabled_rx; + + NRF_RADIO->SHORTS = m_radio_shorts_common | RADIO_SHORTS_DISABLED_TXEN_Msk; + NRF_RADIO->INTENSET = RADIO_INTENSET_DISABLED_Msk; + m_nrf_esb_mainstate = NRF_ESB_STATE_PRX; + + NRF_RADIO->RXADDRESSES = m_esb_addr.rx_pipes_enabled; + NRF_RADIO->FREQUENCY = m_esb_addr.rf_channel; + NRF_RADIO->PACKETPTR = (uint32_t)m_rx_payload_buffer; + + NVIC_ClearPendingIRQ(RADIO_IRQn); + NVIC_EnableIRQ(RADIO_IRQn); + + NRF_RADIO->EVENTS_ADDRESS = 0; + NRF_RADIO->EVENTS_PAYLOAD = 0; + NRF_RADIO->EVENTS_DISABLED = 0; + + NRF_RADIO->TASKS_RXEN = 1; + + return NRF_SUCCESS; +} + + +uint32_t nrf_esb_stop_rx(void) +{ + if (m_nrf_esb_mainstate == NRF_ESB_STATE_PRX) + { + NRF_RADIO->SHORTS = 0; + NRF_RADIO->INTENCLR = 0xFFFFFFFF; + on_radio_disabled = NULL; + NRF_RADIO->EVENTS_DISABLED = 0; + NRF_RADIO->TASKS_DISABLE = 1; + while (NRF_RADIO->EVENTS_DISABLED == 0); + m_nrf_esb_mainstate = NRF_ESB_STATE_IDLE; + + return NRF_SUCCESS; + } + + return NRF_ESB_ERROR_NOT_IN_RX_MODE; +} + + +uint32_t nrf_esb_flush_tx(void) +{ + VERIFY_TRUE(m_esb_initialized, NRF_ERROR_INVALID_STATE); + + DISABLE_RF_IRQ(); + + m_tx_fifo.count = 0; + m_tx_fifo.entry_point = 0; + m_tx_fifo.exit_point = 0; + + ENABLE_RF_IRQ(); + + return NRF_SUCCESS; +} + + +uint32_t nrf_esb_pop_tx(void) +{ + VERIFY_TRUE(m_esb_initialized, NRF_ERROR_INVALID_STATE); + VERIFY_TRUE(m_tx_fifo.count > 0, NRF_ERROR_BUFFER_EMPTY); + + DISABLE_RF_IRQ(); + + if (++m_tx_fifo.entry_point >= NRF_ESB_TX_FIFO_SIZE) + { + m_tx_fifo.entry_point = 0; + } + m_tx_fifo.count--; + + ENABLE_RF_IRQ(); + + return NRF_SUCCESS; +} + + +uint32_t nrf_esb_flush_rx(void) +{ + VERIFY_TRUE(m_esb_initialized, NRF_ERROR_INVALID_STATE); + + DISABLE_RF_IRQ(); + + m_rx_fifo.count = 0; + m_rx_fifo.entry_point = 0; + m_rx_fifo.exit_point = 0; + + memset(m_rx_pipe_info, 0, sizeof(m_rx_pipe_info)); + + ENABLE_RF_IRQ(); + + return NRF_SUCCESS; +} + + +uint32_t nrf_esb_set_address_length(uint8_t length) +{ + VERIFY_TRUE(m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE, NRF_ERROR_BUSY); + VERIFY_TRUE(length > 2 && length < 6, NRF_ERROR_INVALID_PARAM); + + /* + Workaround for nRF52832 Rev 1 Errata 107 + Check if pipe 0 or pipe 1-7 has a 'zero address'. + Avoid using access addresses in the following pattern (where X is don't care): + ADDRLEN=5 + BASE0 = 0x0000XXXX, PREFIX0 = 0xXXXXXX00 + BASE1 = 0x0000XXXX, PREFIX0 = 0xXXXX00XX + BASE1 = 0x0000XXXX, PREFIX0 = 0xXX00XXXX + BASE1 = 0x0000XXXX, PREFIX0 = 0x00XXXXXX + BASE1 = 0x0000XXXX, PREFIX1 = 0xXXXXXX00 + BASE1 = 0x0000XXXX, PREFIX1 = 0xXXXX00XX + BASE1 = 0x0000XXXX, PREFIX1 = 0xXX00XXXX + BASE1 = 0x0000XXXX, PREFIX1 = 0x00XXXXXX + + ADDRLEN=4 + BASE0 = 0x00XXXXXX, PREFIX0 = 0xXXXXXX00 + BASE1 = 0x00XXXXXX, PREFIX0 = 0xXXXX00XX + BASE1 = 0x00XXXXXX, PREFIX0 = 0xXX00XXXX + BASE1 = 0x00XXXXXX, PREFIX0 = 0x00XXXXXX + BASE1 = 0x00XXXXXX, PREFIX1 = 0xXXXXXX00 + BASE1 = 0x00XXXXXX, PREFIX1 = 0xXXXX00XX + BASE1 = 0x00XXXXXX, PREFIX1 = 0xXX00XXXX + BASE1 = 0x00XXXXXX, PREFIX1 = 0x00XXXXXX + */ + uint32_t base_address_mask = length == 5 ? 0xFFFF0000 : 0xFF000000; + if((NRF_RADIO->BASE0 & base_address_mask) == 0 && (NRF_RADIO->PREFIX0 & 0x000000FF) == 0) + { + return NRF_ERROR_INVALID_PARAM; + } + if((NRF_RADIO->BASE1 & base_address_mask) == 0 && ((NRF_RADIO->PREFIX0 & 0x0000FF00) == 0 ||(NRF_RADIO->PREFIX0 & 0x00FF0000) == 0 || (NRF_RADIO->PREFIX0 & 0xFF000000) == 0 || + (NRF_RADIO->PREFIX1 & 0xFF000000) == 0 || (NRF_RADIO->PREFIX1 & 0x00FF0000) == 0 ||(NRF_RADIO->PREFIX1 & 0x0000FF00) == 0 || (NRF_RADIO->PREFIX1 & 0x000000FF) == 0)) + { + return NRF_ERROR_INVALID_PARAM; + } + + m_esb_addr.addr_length = length; + + update_rf_payload_format(m_config_local.payload_length); + + return NRF_SUCCESS; +} + + +uint32_t nrf_esb_set_base_address_0(uint8_t const * p_addr) +{ + VERIFY_TRUE(m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE, NRF_ERROR_BUSY); + VERIFY_PARAM_NOT_NULL(p_addr); + + /* + Workaround for nRF52832 Rev 1 Errata 107 + Check if pipe 0 or pipe 1-7 has a 'zero address'. + Avoid using access addresses in the following pattern (where X is don't care): + ADDRLEN=5 + BASE0 = 0x0000XXXX, PREFIX0 = 0xXXXXXX00 + BASE1 = 0x0000XXXX, PREFIX0 = 0xXXXX00XX + BASE1 = 0x0000XXXX, PREFIX0 = 0xXX00XXXX + BASE1 = 0x0000XXXX, PREFIX0 = 0x00XXXXXX + BASE1 = 0x0000XXXX, PREFIX1 = 0xXXXXXX00 + BASE1 = 0x0000XXXX, PREFIX1 = 0xXXXX00XX + BASE1 = 0x0000XXXX, PREFIX1 = 0xXX00XXXX + BASE1 = 0x0000XXXX, PREFIX1 = 0x00XXXXXX + + ADDRLEN=4 + BASE0 = 0x00XXXXXX, PREFIX0 = 0xXXXXXX00 + BASE1 = 0x00XXXXXX, PREFIX0 = 0xXXXX00XX + BASE1 = 0x00XXXXXX, PREFIX0 = 0xXX00XXXX + BASE1 = 0x00XXXXXX, PREFIX0 = 0x00XXXXXX + BASE1 = 0x00XXXXXX, PREFIX1 = 0xXXXXXX00 + BASE1 = 0x00XXXXXX, PREFIX1 = 0xXXXX00XX + BASE1 = 0x00XXXXXX, PREFIX1 = 0xXX00XXXX + BASE1 = 0x00XXXXXX, PREFIX1 = 0x00XXXXXX + */ + uint32_t base_address_mask = m_esb_addr.addr_length == 5 ? 0xFFFF0000 : 0xFF000000; + if((addr_conv(p_addr) & base_address_mask) == 0 && (NRF_RADIO->PREFIX0 & 0x000000FF) == 0) + { + return NRF_ERROR_INVALID_PARAM; + } + + memcpy(m_esb_addr.base_addr_p0, p_addr, 4); + + update_radio_addresses(NRF_ESB_ADDR_UPDATE_MASK_BASE0); + + return apply_address_workarounds(); +} + + +uint32_t nrf_esb_set_base_address_1(uint8_t const * p_addr) +{ + VERIFY_TRUE(m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE, NRF_ERROR_BUSY); + VERIFY_PARAM_NOT_NULL(p_addr); + + /* + Workaround for nRF52832 Rev 1 Errata 107 + Check if pipe 0 or pipe 1-7 has a 'zero address'. + Avoid using access addresses in the following pattern (where X is don't care): + ADDRLEN=5 + BASE0 = 0x0000XXXX, PREFIX0 = 0xXXXXXX00 + BASE1 = 0x0000XXXX, PREFIX0 = 0xXXXX00XX + BASE1 = 0x0000XXXX, PREFIX0 = 0xXX00XXXX + BASE1 = 0x0000XXXX, PREFIX0 = 0x00XXXXXX + BASE1 = 0x0000XXXX, PREFIX1 = 0xXXXXXX00 + BASE1 = 0x0000XXXX, PREFIX1 = 0xXXXX00XX + BASE1 = 0x0000XXXX, PREFIX1 = 0xXX00XXXX + BASE1 = 0x0000XXXX, PREFIX1 = 0x00XXXXXX + + ADDRLEN=4 + BASE0 = 0x00XXXXXX, PREFIX0 = 0xXXXXXX00 + BASE1 = 0x00XXXXXX, PREFIX0 = 0xXXXX00XX + BASE1 = 0x00XXXXXX, PREFIX0 = 0xXX00XXXX + BASE1 = 0x00XXXXXX, PREFIX0 = 0x00XXXXXX + BASE1 = 0x00XXXXXX, PREFIX1 = 0xXXXXXX00 + BASE1 = 0x00XXXXXX, PREFIX1 = 0xXXXX00XX + BASE1 = 0x00XXXXXX, PREFIX1 = 0xXX00XXXX + BASE1 = 0x00XXXXXX, PREFIX1 = 0x00XXXXXX + */ + uint32_t base_address_mask = m_esb_addr.addr_length == 5 ? 0xFFFF0000 : 0xFF000000; + if((addr_conv(p_addr) & base_address_mask) == 0 && ((NRF_RADIO->PREFIX0 & 0x0000FF00) == 0 ||(NRF_RADIO->PREFIX0 & 0x00FF0000) == 0 || (NRF_RADIO->PREFIX0 & 0xFF000000) == 0 || + (NRF_RADIO->PREFIX1 & 0xFF000000) == 0 || (NRF_RADIO->PREFIX1 & 0x00FF0000) == 0 ||(NRF_RADIO->PREFIX1 & 0x0000FF00) == 0 || (NRF_RADIO->PREFIX1 & 0x000000FF) == 0)) + { + return NRF_ERROR_INVALID_PARAM; + } + + memcpy(m_esb_addr.base_addr_p1, p_addr, 4); + + update_radio_addresses(NRF_ESB_ADDR_UPDATE_MASK_BASE1); + + return apply_address_workarounds(); +} + + +uint32_t nrf_esb_set_prefixes(uint8_t const * p_prefixes, uint8_t num_pipes) +{ + VERIFY_TRUE(m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE, NRF_ERROR_BUSY); + VERIFY_PARAM_NOT_NULL(p_prefixes); + VERIFY_TRUE(num_pipes < 9, NRF_ERROR_INVALID_PARAM); + + /* + Workaround for nRF52832 Rev 1 Errata 107 + Check if pipe 0 or pipe 1-7 has a 'zero address'. + Avoid using access addresses in the following pattern (where X is don't care): + ADDRLEN=5 + BASE0 = 0x0000XXXX, PREFIX0 = 0xXXXXXX00 + BASE1 = 0x0000XXXX, PREFIX0 = 0xXXXX00XX + BASE1 = 0x0000XXXX, PREFIX0 = 0xXX00XXXX + BASE1 = 0x0000XXXX, PREFIX0 = 0x00XXXXXX + BASE1 = 0x0000XXXX, PREFIX1 = 0xXXXXXX00 + BASE1 = 0x0000XXXX, PREFIX1 = 0xXXXX00XX + BASE1 = 0x0000XXXX, PREFIX1 = 0xXX00XXXX + BASE1 = 0x0000XXXX, PREFIX1 = 0x00XXXXXX + + ADDRLEN=4 + BASE0 = 0x00XXXXXX, PREFIX0 = 0xXXXXXX00 + BASE1 = 0x00XXXXXX, PREFIX0 = 0xXXXX00XX + BASE1 = 0x00XXXXXX, PREFIX0 = 0xXX00XXXX + BASE1 = 0x00XXXXXX, PREFIX0 = 0x00XXXXXX + BASE1 = 0x00XXXXXX, PREFIX1 = 0xXXXXXX00 + BASE1 = 0x00XXXXXX, PREFIX1 = 0xXXXX00XX + BASE1 = 0x00XXXXXX, PREFIX1 = 0xXX00XXXX + BASE1 = 0x00XXXXXX, PREFIX1 = 0x00XXXXXX + */ + uint32_t base_address_mask = m_esb_addr.addr_length == 5 ? 0xFFFF0000 : 0xFF000000; + if(num_pipes >= 1 && (NRF_RADIO->BASE0 & base_address_mask) == 0 && p_prefixes[0] == 0) + { + return NRF_ERROR_INVALID_PARAM; + } + + if((NRF_RADIO->BASE1 & base_address_mask) == 0) + { + for (uint8_t i = 1; i < num_pipes; i++) + { + if (p_prefixes[i] == 0) + { + return NRF_ERROR_INVALID_PARAM; + } + } + } + + memcpy(m_esb_addr.pipe_prefixes, p_prefixes, num_pipes); + m_esb_addr.num_pipes = num_pipes; + m_esb_addr.rx_pipes_enabled = BIT_MASK_UINT_8(num_pipes); + + update_radio_addresses(NRF_ESB_ADDR_UPDATE_MASK_PREFIX); + + return apply_address_workarounds(); +} + + +uint32_t nrf_esb_update_prefix(uint8_t pipe, uint8_t prefix) +{ + VERIFY_TRUE(m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE, NRF_ERROR_BUSY); + VERIFY_TRUE(pipe < 8, NRF_ERROR_INVALID_PARAM); + + /* + Workaround for nRF52832 Rev 1 Errata 107 + Check if pipe 0 or pipe 1-7 has a 'zero address'. + Avoid using access addresses in the following pattern (where X is don't care): + ADDRLEN=5 + BASE0 = 0x0000XXXX, PREFIX0 = 0xXXXXXX00 + BASE1 = 0x0000XXXX, PREFIX0 = 0xXXXX00XX + BASE1 = 0x0000XXXX, PREFIX0 = 0xXX00XXXX + BASE1 = 0x0000XXXX, PREFIX0 = 0x00XXXXXX + BASE1 = 0x0000XXXX, PREFIX1 = 0xXXXXXX00 + BASE1 = 0x0000XXXX, PREFIX1 = 0xXXXX00XX + BASE1 = 0x0000XXXX, PREFIX1 = 0xXX00XXXX + BASE1 = 0x0000XXXX, PREFIX1 = 0x00XXXXXX + + ADDRLEN=4 + BASE0 = 0x00XXXXXX, PREFIX0 = 0xXXXXXX00 + BASE1 = 0x00XXXXXX, PREFIX0 = 0xXXXX00XX + BASE1 = 0x00XXXXXX, PREFIX0 = 0xXX00XXXX + BASE1 = 0x00XXXXXX, PREFIX0 = 0x00XXXXXX + BASE1 = 0x00XXXXXX, PREFIX1 = 0xXXXXXX00 + BASE1 = 0x00XXXXXX, PREFIX1 = 0xXXXX00XX + BASE1 = 0x00XXXXXX, PREFIX1 = 0xXX00XXXX + BASE1 = 0x00XXXXXX, PREFIX1 = 0x00XXXXXX + */ + uint32_t base_address_mask = m_esb_addr.addr_length == 5 ? 0xFFFF0000 : 0xFF000000; + if (pipe == 0) + { + if((NRF_RADIO->BASE0 & base_address_mask) == 0 && prefix == 0) + { + return NRF_ERROR_INVALID_PARAM; + } + } + else{ + if((NRF_RADIO->BASE1 & base_address_mask) == 0 && prefix == 0) + { + return NRF_ERROR_INVALID_PARAM; + } + } + + m_esb_addr.pipe_prefixes[pipe] = prefix; + + update_radio_addresses(NRF_ESB_ADDR_UPDATE_MASK_PREFIX); + + return apply_address_workarounds(); +} + + +uint32_t nrf_esb_enable_pipes(uint8_t enable_mask) +{ + VERIFY_TRUE(m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE, NRF_ERROR_BUSY); + + m_esb_addr.rx_pipes_enabled = enable_mask; + + return apply_address_workarounds(); +} + + +uint32_t nrf_esb_set_rf_channel(uint32_t channel) +{ + VERIFY_TRUE(m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE, NRF_ERROR_BUSY); + VERIFY_TRUE(channel <= 100, NRF_ERROR_INVALID_PARAM); + + m_esb_addr.rf_channel = channel; + + return NRF_SUCCESS; +} + + +uint32_t nrf_esb_get_rf_channel(uint32_t * p_channel) +{ + VERIFY_PARAM_NOT_NULL(p_channel); + + *p_channel = m_esb_addr.rf_channel; + + return NRF_SUCCESS; +} + + +uint32_t nrf_esb_set_tx_power(nrf_esb_tx_power_t tx_output_power) +{ + VERIFY_TRUE(m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE, NRF_ERROR_BUSY); + + if ( m_config_local.tx_output_power != tx_output_power ) + { + m_config_local.tx_output_power = tx_output_power; + update_radio_tx_power(); + } + + return NRF_SUCCESS; +} + + +uint32_t nrf_esb_set_retransmit_delay(uint16_t delay) +{ + VERIFY_TRUE(m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE, NRF_ERROR_BUSY); + VERIFY_TRUE(delay >= NRF_ESB_RETRANSMIT_DELAY_MIN, NRF_ERROR_INVALID_PARAM); + + m_config_local.retransmit_delay = delay; + return NRF_SUCCESS; +} + + +uint32_t nrf_esb_set_retransmit_count(uint16_t count) +{ + VERIFY_TRUE(m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE, NRF_ERROR_BUSY); + + m_config_local.retransmit_count = count; + return NRF_SUCCESS; +} + + +uint32_t nrf_esb_set_bitrate(nrf_esb_bitrate_t bitrate) +{ + VERIFY_TRUE(m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE, NRF_ERROR_BUSY); + + m_config_local.bitrate = bitrate; + return update_radio_bitrate() ? NRF_SUCCESS : NRF_ERROR_INVALID_PARAM; +} + + +uint32_t nrf_esb_reuse_pid(uint8_t pipe) +{ + VERIFY_TRUE(m_nrf_esb_mainstate == NRF_ESB_STATE_IDLE, NRF_ERROR_BUSY); + VERIFY_TRUE(pipe < 8, NRF_ERROR_INVALID_PARAM); + + m_pids[pipe] = (m_pids[pipe] + NRF_ESB_PID_MAX) % (NRF_ESB_PID_MAX + 1); + return NRF_SUCCESS; +} + + +// Handler for +#ifdef NRF52 +void NRF_ESB_BUGFIX_TIMER_IRQHandler(void) +{ + if(NRF_ESB_BUGFIX_TIMER->EVENTS_COMPARE[0]) + { + NRF_ESB_BUGFIX_TIMER->EVENTS_COMPARE[0] = 0; + + // If the timeout timer fires and we are in the PTX receive ACK state, disable the radio + if(m_nrf_esb_mainstate == NRF_ESB_STATE_PTX_RX_ACK) + { + NRF_RADIO->TASKS_DISABLE = 1; + } + } +} +#endif diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/esb/nrf_esb.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/esb/nrf_esb.h new file mode 100644 index 0000000..0c80efb --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/esb/nrf_esb.h @@ -0,0 +1,609 @@ +/** + * Copyright (c) 2016 - 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_ESB_H +#define __NRF_ESB_H + +#include <stdbool.h> +#include <stdint.h> +#include "nrf.h" +#include "app_util.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** @defgroup nrf_esb Enhanced ShockBurst + * @{ + * @ingroup proprietary_api + * + * @brief Enhanced ShockBurst (ESB) is a basic protocol that supports two-way data + * packet communication including packet buffering, packet acknowledgment, + * and automatic retransmission of lost packets. + */ + +/** @name Debug pins + * @{ + * @brief If NRF_ESB_DEBUG is defined, these GPIO pins can be used for debug timing. + */ + +#define DEBUGPIN1 12 //!< If NRF_ESB_DEBUG is defined, this GPIO pin is set with every radio interrupt. +#define DEBUGPIN2 13 //!< If NRF_ESB_DEBUG is defined, this GPIO pin is set with every NRF_RADIO->EVENTS_END. +#define DEBUGPIN3 14 //!< If NRF_ESB_DEBUG is defined, this GPIO pin is set with every NRF_RADIO->EVENTS_DISABLED. +#define DEBUGPIN4 15 //!< If NRF_ESB_DEBUG is defined, this GPIO pin is set when the radio is set to start transmission. + + +#ifdef NRF_ESB_DEBUG +#define DEBUG_PIN_SET(a) (NRF_GPIO->OUTSET = (1 << (a))) //!< Used internally to set debug pins. +#define DEBUG_PIN_CLR(a) (NRF_GPIO->OUTCLR = (1 << (a))) //!< Used internally to clear debug pins. +#else +#define DEBUG_PIN_SET(a) //!< Used internally to set debug pins. +#define DEBUG_PIN_CLR(a) //!< Used internally to clear debug pins. +#endif + + /** @} */ + +#define NRF_ESB_RETRANSMIT_DELAY_MIN 135 + +// Hardcoded parameters - change if necessary +#ifndef NRF_ESB_MAX_PAYLOAD_LENGTH +#define NRF_ESB_MAX_PAYLOAD_LENGTH 32 //!< The maximum size of the payload. Valid values are 1 to 252. +#endif + +#define NRF_ESB_TX_FIFO_SIZE 8 //!< The size of the transmission first-in, first-out buffer. +#define NRF_ESB_RX_FIFO_SIZE 8 //!< The size of the reception first-in, first-out buffer. + +// 252 is the largest possible payload size according to the nRF5 architecture. +STATIC_ASSERT(NRF_ESB_MAX_PAYLOAD_LENGTH <= 252); + +#define NRF_ESB_SYS_TIMER NRF_TIMER2 //!< The timer that is used by the module. +#define NRF_ESB_SYS_TIMER_IRQ_Handler TIMER2_IRQHandler //!< The handler that is used by @ref NRF_ESB_SYS_TIMER. + +#define NRF_ESB_PPI_TIMER_START 10 //!< The PPI channel used for starting the timer. +#define NRF_ESB_PPI_TIMER_STOP 11 //!< The PPI channel used for stopping the timer. +#define NRF_ESB_PPI_RX_TIMEOUT 12 //!< The PPI channel used for RX time-out. +#define NRF_ESB_PPI_TX_START 13 //!< The PPI channel used for starting TX. + +/**@cond NO_DOXYGEN */ + +// nRF52 address fix timer and PPI defines +#ifdef NRF52 +#define NRF_ESB_PPI_BUGFIX1 9 +#define NRF_ESB_PPI_BUGFIX2 8 +#define NRF_ESB_PPI_BUGFIX3 7 + +#define NRF_ESB_BUGFIX_TIMER NRF_TIMER3 +#define NRF_ESB_BUGFIX_TIMER_IRQn TIMER3_IRQn +#define NRF_ESB_BUGFIX_TIMER_IRQHandler TIMER3_IRQHandler +#endif + +/** @endcond */ + +// Interrupt flags +#define NRF_ESB_INT_TX_SUCCESS_MSK 0x01 //!< The flag used to indicate a success since the last event. +#define NRF_ESB_INT_TX_FAILED_MSK 0x02 //!< The flag used to indicate a failure since the last event. +#define NRF_ESB_INT_RX_DR_MSK 0x04 //!< The flag used to indicate that a packet was received since the last event. + +#define NRF_ESB_PID_RESET_VALUE 0xFF //!< Invalid PID value that is guaranteed to not collide with any valid PID value. +#define NRF_ESB_PID_MAX 3 //!< The maximum value for PID. +#define NRF_ESB_CRC_RESET_VALUE 0xFFFF //!< The CRC reset value. + +#define ESB_EVT_IRQ SWI0_IRQn //!< The ESB event IRQ number when running on an nRF5 device. +#define ESB_EVT_IRQHandler SWI0_IRQHandler //!< The handler for @ref ESB_EVT_IRQ when running on an nRF5 device. + +#if defined(NRF52) +#define ESB_IRQ_PRIORITY_MSK 0x07 //!< The mask used to enforce a valid IRQ priority. +#else +#define ESB_IRQ_PRIORITY_MSK 0x03 //!< The mask used to enforce a valid IRQ priority. +#endif + +/** @brief Default address configuration for ESB. + * @details Roughly equal to the nRF24Lxx default (except for the number of pipes, because more pipes are supported). */ +#define NRF_ESB_ADDR_DEFAULT \ +{ \ + .base_addr_p0 = { 0xE7, 0xE7, 0xE7, 0xE7 }, \ + .base_addr_p1 = { 0xC2, 0xC2, 0xC2, 0xC2 }, \ + .pipe_prefixes = { 0xE7, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8 }, \ + .addr_length = 5, \ + .num_pipes = 8, \ + .rf_channel = 2, \ + .rx_pipes_enabled = 0xFF \ +} + + +/** @brief Default radio parameters. + * @details Roughly equal to the nRF24Lxx default parameters (except for CRC, which is set to 16 bit, and protocol, which is set to DPL). */ +#define NRF_ESB_DEFAULT_CONFIG {.protocol = NRF_ESB_PROTOCOL_ESB_DPL, \ + .mode = NRF_ESB_MODE_PTX, \ + .event_handler = 0, \ + .bitrate = NRF_ESB_BITRATE_2MBPS, \ + .crc = NRF_ESB_CRC_16BIT, \ + .tx_output_power = NRF_ESB_TX_POWER_0DBM, \ + .retransmit_delay = 250, \ + .retransmit_count = 3, \ + .tx_mode = NRF_ESB_TXMODE_AUTO, \ + .radio_irq_priority = 1, \ + .event_irq_priority = 2, \ + .payload_length = 32, \ + .selective_auto_ack = false \ +} + + +/** @brief Default legacy radio parameters. Identical to the nRF24Lxx defaults. */ +#define NRF_ESB_LEGACY_CONFIG {.protocol = NRF_ESB_PROTOCOL_ESB, \ + .mode = NRF_ESB_MODE_PTX, \ + .event_handler = 0, \ + .bitrate = NRF_ESB_BITRATE_2MBPS, \ + .crc = NRF_ESB_CRC_8BIT, \ + .tx_output_power = NRF_ESB_TX_POWER_0DBM, \ + .retransmit_delay = 600, \ + .retransmit_count = 3, \ + .tx_mode = NRF_ESB_TXMODE_AUTO, \ + .radio_irq_priority = 1, \ + .event_irq_priority = 2, \ + .payload_length = 32, \ + .selective_auto_ack = false \ +} + + +/** @brief Macro to create an initializer for a TX data packet. + * + * @details This macro generates an initializer. Using the initializer is more efficient + * than setting the individual parameters dynamically. + * + * @param[in] _pipe The pipe to use for the data packet. + * @param[in] ... Comma separated list of character data to put in the TX buffer. + * Supported values consist of 1 to 63 characters. + * + * @return Initializer that sets up the pipe, length, and byte array for content of the TX data. + */ +#define NRF_ESB_CREATE_PAYLOAD(_pipe, ...) \ + {.pipe = _pipe, .length = NUM_VA_ARGS(__VA_ARGS__), .data = {__VA_ARGS__}}; \ + STATIC_ASSERT(NUM_VA_ARGS(__VA_ARGS__) > 0 && NUM_VA_ARGS(__VA_ARGS__) <= 63) + + +/**@brief Enhanced ShockBurst protocols. */ +typedef enum { + NRF_ESB_PROTOCOL_ESB, /**< Enhanced ShockBurst with fixed payload length. */ + NRF_ESB_PROTOCOL_ESB_DPL /**< Enhanced ShockBurst with dynamic payload length. */ +} nrf_esb_protocol_t; + + +/**@brief Enhanced ShockBurst modes. */ +typedef enum { + NRF_ESB_MODE_PTX, /**< Primary transmitter mode. */ + NRF_ESB_MODE_PRX /**< Primary receiver mode. */ +} nrf_esb_mode_t; + + +/**@brief Enhanced ShockBurst bitrate modes. */ +typedef enum { + NRF_ESB_BITRATE_2MBPS = RADIO_MODE_MODE_Nrf_2Mbit, /**< 2 Mb radio mode. */ + NRF_ESB_BITRATE_1MBPS = RADIO_MODE_MODE_Nrf_1Mbit, /**< 1 Mb radio mode. */ + NRF_ESB_BITRATE_250KBPS = RADIO_MODE_MODE_Nrf_250Kbit, /**< 250 Kb radio mode. */ + NRF_ESB_BITRATE_1MBPS_BLE = RADIO_MODE_MODE_Ble_1Mbit, /**< 1 Mb radio mode using @e Bluetooth low energy radio parameters. */ +#if defined(NRF52) + NRF_ESB_BITRATE_2MBPS_BLE = 4 /**< 2 Mb radio mode using @e Bluetooth low energy radio parameters. */ +#endif +} nrf_esb_bitrate_t; + + +/**@brief Enhanced ShockBurst CRC modes. */ +typedef enum { + NRF_ESB_CRC_16BIT = RADIO_CRCCNF_LEN_Two, /**< Use two-byte CRC. */ + NRF_ESB_CRC_8BIT = RADIO_CRCCNF_LEN_One, /**< Use one-byte CRC. */ + NRF_ESB_CRC_OFF = RADIO_CRCCNF_LEN_Disabled /**< Disable CRC. */ +} nrf_esb_crc_t; + + +/**@brief Enhanced ShockBurst radio transmission power modes. */ +typedef enum { + NRF_ESB_TX_POWER_4DBM = RADIO_TXPOWER_TXPOWER_Pos4dBm, /**< 4 dBm radio transmit power. */ +#if defined(NRF52) + NRF_ESB_TX_POWER_3DBM = RADIO_TXPOWER_TXPOWER_Pos3dBm, /**< 3 dBm radio transmit power. */ +#endif + NRF_ESB_TX_POWER_0DBM = RADIO_TXPOWER_TXPOWER_0dBm, /**< 0 dBm radio transmit power. */ + NRF_ESB_TX_POWER_NEG4DBM = RADIO_TXPOWER_TXPOWER_Neg4dBm, /**< -4 dBm radio transmit power. */ + NRF_ESB_TX_POWER_NEG8DBM = RADIO_TXPOWER_TXPOWER_Neg8dBm, /**< -8 dBm radio transmit power. */ + NRF_ESB_TX_POWER_NEG12DBM = RADIO_TXPOWER_TXPOWER_Neg12dBm, /**< -12 dBm radio transmit power. */ + NRF_ESB_TX_POWER_NEG16DBM = RADIO_TXPOWER_TXPOWER_Neg16dBm, /**< -16 dBm radio transmit power. */ + NRF_ESB_TX_POWER_NEG20DBM = RADIO_TXPOWER_TXPOWER_Neg20dBm, /**< -20 dBm radio transmit power. */ + NRF_ESB_TX_POWER_NEG30DBM = RADIO_TXPOWER_TXPOWER_Neg30dBm /**< -30 dBm radio transmit power. */ +} nrf_esb_tx_power_t; + + +/**@brief Enhanced ShockBurst transmission modes. */ +typedef enum { + NRF_ESB_TXMODE_AUTO, /**< Automatic TX mode: When the TX FIFO contains packets and the radio is idle, packets are sent automatically. */ + NRF_ESB_TXMODE_MANUAL, /**< Manual TX mode: Packets are not sent until @ref nrf_esb_start_tx is called. This mode can be used to ensure consistent packet timing. */ + NRF_ESB_TXMODE_MANUAL_START /**< Manual start TX mode: Packets are not sent until @ref nrf_esb_start_tx is called. Then, transmission continues automatically until the TX FIFO is empty. */ +} nrf_esb_tx_mode_t; + + +/**@brief Enhanced ShockBurst event IDs used to indicate the type of the event. */ +typedef enum +{ + NRF_ESB_EVENT_TX_SUCCESS, /**< Event triggered on TX success. */ + NRF_ESB_EVENT_TX_FAILED, /**< Event triggered on TX failure. */ + NRF_ESB_EVENT_RX_RECEIVED /**< Event triggered on RX received. */ +} nrf_esb_evt_id_t; + + +/**@brief Enhanced ShockBurst payload. + * + * @details The payload is used both for transmissions and for acknowledging a + * received packet with a payload. +*/ +typedef struct +{ + uint8_t length; //!< Length of the packet (maximum value is @ref NRF_ESB_MAX_PAYLOAD_LENGTH). + uint8_t pipe; //!< Pipe used for this payload. + int8_t rssi; //!< RSSI for the received packet. + uint8_t noack; //!< Flag indicating that this packet will not be acknowledgement. + uint8_t pid; //!< PID assigned during communication. + uint8_t data[NRF_ESB_MAX_PAYLOAD_LENGTH]; //!< The payload data. +} nrf_esb_payload_t; + + +/**@brief Enhanced ShockBurst event. */ +typedef struct +{ + nrf_esb_evt_id_t evt_id; //!< Enhanced ShockBurst event ID. + uint32_t tx_attempts; //!< Number of TX retransmission attempts. +} nrf_esb_evt_t; + + +/**@brief Definition of the event handler for the module. */ +typedef void (* nrf_esb_event_handler_t)(nrf_esb_evt_t const * p_event); + + +/**@brief Main configuration structure for the module. */ +typedef struct +{ + nrf_esb_protocol_t protocol; //!< Enhanced ShockBurst protocol. + nrf_esb_mode_t mode; //!< Enhanced ShockBurst mode. + nrf_esb_event_handler_t event_handler; //!< Enhanced ShockBurst event handler. + + // General RF parameters + nrf_esb_bitrate_t bitrate; //!< Enhanced ShockBurst bitrate mode. + nrf_esb_crc_t crc; //!< Enhanced ShockBurst CRC mode. + + nrf_esb_tx_power_t tx_output_power; //!< Enhanced ShockBurst radio transmission power mode. + + uint16_t retransmit_delay; //!< The delay between each retransmission of unacknowledged packets. + uint16_t retransmit_count; //!< The number of retransmission attempts before transmission fail. + + // Control settings + nrf_esb_tx_mode_t tx_mode; //!< Enhanced ShockBurst transmission mode. + + uint8_t radio_irq_priority; //!< nRF radio interrupt priority. + uint8_t event_irq_priority; //!< ESB event interrupt priority. + uint8_t payload_length; //!< Length of the payload (maximum length depends on the platforms that are used on each side). + + bool selective_auto_ack; //!< Enable or disable selective auto acknowledgement. +} nrf_esb_config_t; + + +/**@brief Function for initializing the Enhanced ShockBurst module. + * + * @param p_config Parameters for initializing the module. + * + * @retval NRF_SUCCESS If initialization was successful. + * @retval NRF_ERROR_NULL If the @p p_config argument was NULL. + * @retval NRF_ERROR_BUSY If the function failed because the radio is busy. + */ +uint32_t nrf_esb_init(nrf_esb_config_t const * p_config); + + +/**@brief Function for suspending the Enhanced ShockBurst module. + * + * Calling this function stops ongoing communications without changing the queues. + * + * @retval NRF_SUCCESS If Enhanced ShockBurst was suspended. + * @retval NRF_ERROR_BUSY If the function failed because the radio is busy. + */ +uint32_t nrf_esb_suspend(void); + + +/**@brief Function for disabling the Enhanced ShockBurst module. + * + * Calling this function disables the Enhanced ShockBurst module immediately. + * Doing so might stop ongoing communications. + * + * @note All queues are flushed by this function. + * + * @retval NRF_SUCCESS If Enhanced ShockBurst was disabled. + */ +uint32_t nrf_esb_disable(void); + + +/**@brief Function for checking if the Enhanced ShockBurst module is idle. + * + * @retval true If the module is idle. + * @retval false If the module is busy. + */ +bool nrf_esb_is_idle(void); + + +/**@brief Function for writing a payload for transmission or acknowledgement. + * + * This function writes a payload that is added to the queue. When the module is in PTX mode, the + * payload is queued for a regular transmission. When the module is in PRX mode, the payload + * is queued for when a packet is received that requires an acknowledgement with payload. + * + * @param[in] p_payload Pointer to the structure that contains information and state of the payload. + * + * @retval NRF_SUCCESS If the payload was successfully queued for writing. + * @retval NRF_ERROR_NULL If the required parameter was NULL. + * @retval NRF_INVALID_STATE If the module is not initialized. + * @retval NRF_ERROR_NOT_SUPPORTED If @p p_payload->noack was false, but selective acknowledgement is not enabled. + * @retval NRF_ERROR_NO_MEM If the TX FIFO is full. + * @retval NRF_ERROR_INVALID_LENGTH If the payload length was invalid (zero or larger than the allowed maximum). + */ +uint32_t nrf_esb_write_payload(nrf_esb_payload_t const * p_payload); + + +/**@brief Function for reading an RX payload. + * + * @param[in,out] p_payload Pointer to the structure that contains information and state of the payload. + * + * @retval NRF_SUCCESS If the data was read successfully. + * @retval NRF_ERROR_NULL If the required parameter was NULL. + * @retval NRF_INVALID_STATE If the module is not initialized. + */ +uint32_t nrf_esb_read_rx_payload(nrf_esb_payload_t * p_payload); + + +/**@brief Function for starting transmission. + * + * @retval NRF_SUCCESS If the TX started successfully. + * @retval NRF_ERROR_BUFFER_EMPTY If the TX did not start because the FIFO buffer is empty. + * @retval NRF_ERROR_BUSY If the function failed because the radio is busy. + */ +uint32_t nrf_esb_start_tx(void); + + +/**@brief Function for starting to transmit data from the FIFO buffer. + * + * @retval NRF_SUCCESS If the transmission was started successfully. + * @retval NRF_ERROR_BUSY If the function failed because the radio is busy. + */ +uint32_t nrf_esb_start_rx(void); + + +/** @brief Function for stopping data reception. + * + * @retval NRF_SUCCESS If data reception was stopped successfully. + * @retval NRF_ESB_ERROR_NOT_IN_RX_MODE If the function failed because the module is not in RX mode. + */ +uint32_t nrf_esb_stop_rx(void); + + +/**@brief Function for removing remaining items from the TX buffer. + * + * This function clears the TX FIFO buffer. + * + * @retval NRF_SUCCESS If pending items in the TX buffer were successfully cleared. + * @retval NRF_INVALID_STATE If the module is not initialized. + */ +uint32_t nrf_esb_flush_tx(void); + + +/**@brief Function for removing the first item from the TX buffer. + * + * @retval NRF_SUCCESS If the operation completed successfully. + * @retval NRF_INVALID_STATE If the module is not initialized. + * @retval NRF_ERROR_BUFFER_EMPTY If there are no items in the queue to remove. + */ +uint32_t nrf_esb_pop_tx(void); + + +/**@brief Function for removing remaining items from the RX buffer. + * + * @retval NRF_SUCCESS If the pending items in the RX buffer were successfully cleared. + * @retval NRF_INVALID_STATE If the module is not initialized. + */ +uint32_t nrf_esb_flush_rx(void); + + +/**@brief Function for setting the length of the address. + * + * @param[in] length Length of the ESB address (in bytes). + * + * @retval NRF_SUCCESS If the address length was set successfully. + * @retval NRF_ERROR_INVALID_PARAM If the address length was invalid. + * @retval NRF_ERROR_BUSY If the function failed because the radio is busy. + */ +uint32_t nrf_esb_set_address_length(uint8_t length); + + +/**@brief Function for setting the base address for pipe 0. + * + * @param[in] p_addr Pointer to the address data. + * + * @retval NRF_SUCCESS If the base address was set successfully. + * @retval NRF_ERROR_BUSY If the function failed because the radio is busy. + * @retval NRF_ERROR_INVALID_PARAM If the function failed because the address given was too close to a zero address. + * @retval NRF_ERROR_NULL If the required parameter was NULL. + */ +uint32_t nrf_esb_set_base_address_0(uint8_t const * p_addr); + + +/**@brief Function for setting the base address for pipe 1 to pipe 7. + * + * @param[in] p_addr Pointer to the address data. + * + * @retval NRF_SUCCESS If the base address was set successfully. + * @retval NRF_ERROR_BUSY If the function failed because the radio is busy. + * @retval NRF_ERROR_INVALID_PARAM If the function failed because the address given was too close to a zero address. + * @retval NRF_ERROR_NULL If the required parameter was NULL. + */ +uint32_t nrf_esb_set_base_address_1(uint8_t const * p_addr); + + +/**@brief Function for setting the number of pipes and the pipe prefix addresses. + * + * This function configures the number of available pipes, enables the pipes, + * and sets their prefix addresses. + * + * @param[in] p_prefixes Pointer to a char array that contains the prefix for each pipe. + * @param[in] num_pipes Number of pipes. + * + * @retval NRF_SUCCESS If the prefix addresses were set successfully. + * @retval NRF_ERROR_BUSY If the function failed because the radio is busy. + * @retval NRF_ERROR_NULL If a required parameter was NULL. + * @retval NRF_ERROR_INVALID_PARAM If an invalid number of pipes was given or if the address given was too close to a zero address. + */ +uint32_t nrf_esb_set_prefixes(uint8_t const * p_prefixes, uint8_t num_pipes); + + +/**@brief Function for enabling pipes. + * + * The @p enable_mask parameter must contain the same number of pipes as has been configured + * with @ref nrf_esb_set_prefixes. + * + * @param enable_mask Bitfield mask to enable or disable pipes. Setting a bit to + * 0 disables the pipe. Setting a bit to 1 enables the pipe. + * + * @retval NRF_SUCCESS If the pipes were enabled and disabled successfully. + * @retval NRF_ERROR_BUSY If the function failed because the radio is busy. + * @retval NRF_ERROR_INVALID_PARAM If the function failed because the address given was too close to a zero address. + */ +uint32_t nrf_esb_enable_pipes(uint8_t enable_mask); + + +/**@brief Function for updating the prefix for a pipe. + * + * @param pipe Pipe for which to set the prefix. + * @param prefix Prefix to set for the pipe. + * + * @retval NRF_SUCCESS If the operation completed successfully. + * @retval NRF_ERROR_BUSY If the function failed because the radio is busy. + * @retval NRF_ERROR_INVALID_PARAM If the given pipe number was invalid or if the address given was too close to a zero address. + */ +uint32_t nrf_esb_update_prefix(uint8_t pipe, uint8_t prefix); + + +/** @brief Function for setting the channel to use for the radio. + * + * The module must be in an idle state to call this function. As a PTX, the + * application must wait for an idle state and as a PRX, the application must stop RX + * before changing the channel. After changing the channel, operation can be resumed. + * + * @param[in] channel Channel to use for radio. + * + * @retval NRF_SUCCESS If the operation completed successfully. + * @retval NRF_INVALID_STATE If the module is not initialized. + * @retval NRF_ERROR_BUSY If the module was not in idle state. + * @retval NRF_ERROR_INVALID_PARAM If the channel is invalid (larger than 100). + */ +uint32_t nrf_esb_set_rf_channel(uint32_t channel); + + +/**@brief Function for getting the current radio channel. + * + * @param[in, out] p_channel Pointer to the channel data. + * + * @retval NRF_SUCCESS If the operation completed successfully. + * @retval NRF_ERROR_NULL If the required parameter was NULL. + */ +uint32_t nrf_esb_get_rf_channel(uint32_t * p_channel); + + +/**@brief Function for setting the radio output power. + * + * @param[in] tx_output_power Output power. + * + * @retval NRF_SUCCESS If the operation completed successfully. + * @retval NRF_ERROR_BUSY If the function failed because the radio is busy. + */ +uint32_t nrf_esb_set_tx_power(nrf_esb_tx_power_t tx_output_power); + + +/**@brief Function for setting the packet retransmit delay. + * + * @param[in] delay Delay between retransmissions. + * + * @retval NRF_SUCCESS If the operation completed successfully. + * @retval NRF_ERROR_BUSY If the function failed because the radio is busy. + */ +uint32_t nrf_esb_set_retransmit_delay(uint16_t delay); + + +/**@brief Function for setting the number of retransmission attempts. + * + * @param[in] count Number of retransmissions. + * + * @retval NRF_SUCCESS If the operation completed successfully. + * @retval NRF_ERROR_BUSY If the function failed because the radio is busy. + */ +uint32_t nrf_esb_set_retransmit_count(uint16_t count); + + +/**@brief Function for setting the radio bitrate. + * + * @param[in] bitrate Radio bitrate. + * + * @retval NRF_SUCCESS If the operation completed successfully. + * @retval NRF_ERROR_BUSY If the function failed because the radio is busy. + */ +uint32_t nrf_esb_set_bitrate(nrf_esb_bitrate_t bitrate); + + +/**@brief Function for reusing a packet ID for a specific pipe. + * + * The ESB protocol uses a 2-bit sequence number (packet ID) to identify + * retransmitted packets. By default, the packet ID is incremented for every + * uploaded packet. Use this function to prevent this and send two different + * packets with the same packet ID. + * + * @param[in] pipe Pipe. + * + * @retval NRF_SUCCESS If the operation completed successfully. + * @retval NRF_ERROR_BUSY If the function failed because the radio is busy. + */ +uint32_t nrf_esb_reuse_pid(uint8_t pipe); + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif // NRF_ESB diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/esb/nrf_esb_error_codes.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/esb/nrf_esb_error_codes.h new file mode 100644 index 0000000..88b24ff --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/esb/nrf_esb_error_codes.h @@ -0,0 +1,56 @@ +/** + * Copyright (c) 2016 - 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_ESB_ERROR_CODES_H__ +#define __NRF_ESB_ERROR_CODES_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#define NRF_ERROR_BUFFER_EMPTY (0x0100) + +#define NRF_ESB_ERROR_NOT_IN_RX_MODE (0x0101) + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/esb/nrf_esb_resources.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/esb/nrf_esb_resources.h new file mode 100644 index 0000000..3e1af51 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/esb/nrf_esb_resources.h @@ -0,0 +1,72 @@ +/** + * Copyright (c) 2016 - 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_ESB_RESOURCES_H__ +#define NRF_ESB_RESOURCES_H__ + +#include <stdint.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup nrf_esb_resources ESB resources + * @{ + * @ingroup nrf_esb + */ + +#ifndef ESB_ALTERNATIVE_RESOURCES + #define ESB_PPI_CHANNELS_USED 0x00000007uL /**< PPI channels used by ESB (not available to the application). */ + #define ESB_TIMERS_USED 0x00000004uL /**< Timers used by ESB. */ + #define ESB_SWI_USED 0x00000001uL /**< Software interrupts used by ESB. */ +#else + #define ESB_PPI_CHANNELS_USED 0x00000700uL /**< PPI channels used by ESB (not available to the application). */ + #define ESB_TIMERS_USED 0x00000001uL /**< Timers used by ESB. */ + #define ESB_SWI_USED 0x00000002uL /**< Software interrupts used by ESB. */ +#endif + +/** @} */ + + +#ifdef __cplusplus +} +#endif + +#endif /* NRF_ESB_RESOURCES_H__ */ diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf51_arm.lib b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf51_arm.lib Binary files differnew file mode 100644 index 0000000..e0e9915 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf51_arm.lib diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf51_sd_resources_arm.lib b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf51_sd_resources_arm.lib Binary files differnew file mode 100644 index 0000000..aedb24e --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf51_sd_resources_arm.lib diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf52840_arm.lib b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf52840_arm.lib Binary files differnew file mode 100644 index 0000000..63503ab --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf52840_arm.lib diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf52840_sd_resources_arm.lib b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf52840_sd_resources_arm.lib Binary files differnew file mode 100644 index 0000000..25cb7d3 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf52840_sd_resources_arm.lib diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf52_arm.lib b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf52_arm.lib Binary files differnew file mode 100644 index 0000000..afd9a9b --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf52_arm.lib diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf52_sd_resources_arm.lib b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf52_sd_resources_arm.lib Binary files differnew file mode 100644 index 0000000..12596fc --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/gzll_nrf52_sd_resources_arm.lib diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/license.txt b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/license.txt new file mode 100644 index 0000000..957d928 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/arm/license.txt @@ -0,0 +1,37 @@ +Copyright (c) 2010 - 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. + diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/config/nrf_gzp_config.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/config/nrf_gzp_config.h new file mode 100644 index 0000000..801cc3f --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/config/nrf_gzp_config.h @@ -0,0 +1,168 @@ +/** + * Copyright (c) 2008 - 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 __GZP_CONFIG_H +#define __GZP_CONFIG_H + +#include "nrf.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * Definition of "secret key" used during "Host ID exchange". + */ + +#define GZP_SECRET_KEY {1, 23, 45, 57, 26, 68, 12, 64, 13, 73, 13, 62, 26, 45, 12, 77} + +//----------------------------------------------------------------------------- + +/** + Definition of the first static selected pairing channel. Should be located in + the lower Nth of the channel range, where N is the size if the channel subset + selected by the application. +*/ +#define GZP_CHANNEL_LOW 2 + +/** + Definition of the second static selected pairing channel. Should be located in + the upper Nth of the channel range, where N is the size if the channel subset + selected by the application. +*/ +#define GZP_CHANNEL_HIGH 79 + +/** + Definition of the static "global" pairing address. +*/ +#define GZP_ADDRESS 4, 6, 8, 10 + +/** + Reduced TX power for use during close proximity pairing. + */ +#define GZP_POWER NRF_GZLL_TX_POWER_N16_DBM + +/** + Definition of pairing request timeout. +*/ +#define GZP_REQ_TX_TIMEOUT 200 + +/** + Definition of the maximimum number of "backoff" packets (step 0) to be transmitted. +*/ +#define GZP_MAX_BACKOFF_PACKETS 100 + +/** + Definition of the period a device shall wait before attempting to send the packet for + fetching the pairing response (step 1). +*/ +#define GZP_TX_ACK_WAIT_TIMEOUT (GZP_CLOSE_PROXIMITY_BACKOFF_RX_TIMEOUT + 50) + +/** + Definition of the period a device in close proximity shall back off on the pairing + address after a backoff packet has been received. +*/ +#define GZP_CLOSE_PROXIMITY_BACKOFF_RX_TIMEOUT ((GZP_REQ_TX_TIMEOUT / 2) + 50) + +/** + Definition of the period a device NOT in close proximity shall back off on the pairing + address after a backoff packet has been received. +*/ +#define GZP_NOT_PROXIMITY_BACKOFF_RX_TIMEOUT (GZP_CLOSE_PROXIMITY_BACKOFF_RX_TIMEOUT + GZP_STEP1_RX_TIMEOUT) + +/** + Definition of the time the host waits for a device to complete + transmission of the pairing request step 1 packet. +*/ +#define GZP_STEP1_RX_TIMEOUT (((GZP_REQ_TX_TIMEOUT / 2) + GZP_TX_ACK_WAIT_TIMEOUT) + 50) + +/** + Definition of the lowest boundary for the channel range to be used. +*/ +#define GZP_CHANNEL_MIN 2 + +/** + Definition of the upper boundary for the channel range to be used. +*/ +#define GZP_CHANNEL_MAX 80 + +/** + Definition of the minimum channel spacing for the channel subset generated + during pairing. +*/ +#define GZP_CHANNEL_SPACING_MIN 5 + +/** + Non volatile memory (Flash or OTP) storage address. A device will + require GZP_DEVICE_PARAMS_STORAGE_SIZE bytes of memory, and + Host 11 bytes. When using flash memory, storage address should + be a multiple of chip page size. +*/ +#define GZP_PARAMS_STORAGE_ADR 0x00001000 + +/** + Number of bytes available for parameter storage in Device. + It is equal to flash page size on nRF5x chips. +*/ +#if defined (NRF51) + #define GZP_DEVICE_PARAMS_STORAGE_SIZE 1024 +#elif defined (NRF52_SERIES) + #define GZP_DEVICE_PARAMS_STORAGE_SIZE 4096 +#else + #error Chip type is undefined! +#endif + +/** + Maximum Device TX payload length [bytes]. + */ +#define GZP_MAX_FW_PAYLOAD_LENGTH 17 + +/** + Maximum Host ACK payload length [bytes]. + */ +#define GZP_MAX_ACK_PAYLOAD_LENGTH 10 + + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf51_gcc.a b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf51_gcc.a Binary files differnew file mode 100644 index 0000000..8c9fe0a --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf51_gcc.a diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf51_sd_resources_gcc.a b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf51_sd_resources_gcc.a Binary files differnew file mode 100644 index 0000000..4896b0c --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf51_sd_resources_gcc.a diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf52840_gcc.a b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf52840_gcc.a Binary files differnew file mode 100644 index 0000000..911ae7d --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf52840_gcc.a diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf52840_sd_resources_gcc.a b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf52840_sd_resources_gcc.a Binary files differnew file mode 100644 index 0000000..46284ef --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf52840_sd_resources_gcc.a diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf52_gcc.a b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf52_gcc.a Binary files differnew file mode 100644 index 0000000..d463ca4 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf52_gcc.a diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf52_sd_resources_gcc.a b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf52_sd_resources_gcc.a Binary files differnew file mode 100644 index 0000000..052634c --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/gzll_nrf52_sd_resources_gcc.a diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/license.txt b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/license.txt new file mode 100644 index 0000000..957d928 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/gcc/license.txt @@ -0,0 +1,37 @@ +Copyright (c) 2010 - 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. + diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf51_iar.a b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf51_iar.a Binary files differnew file mode 100644 index 0000000..bf4ad39 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf51_iar.a diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf51_sd_resources_iar.a b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf51_sd_resources_iar.a Binary files differnew file mode 100644 index 0000000..23fcdd1 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf51_sd_resources_iar.a diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf52840_iar.a b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf52840_iar.a Binary files differnew file mode 100644 index 0000000..755dbfd --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf52840_iar.a diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf52840_sd_resources_iar.a b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf52840_sd_resources_iar.a Binary files differnew file mode 100644 index 0000000..b7971e6 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf52840_sd_resources_iar.a diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf52_iar.a b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf52_iar.a Binary files differnew file mode 100644 index 0000000..36e7653 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf52_iar.a diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf52_sd_resources_iar.a b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf52_sd_resources_iar.a Binary files differnew file mode 100644 index 0000000..d09ca0f --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/gzll_nrf52_sd_resources_iar.a diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/license.txt b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/license.txt new file mode 100644 index 0000000..957d928 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/iar/license.txt @@ -0,0 +1,37 @@ +Copyright (c) 2010 - 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. + diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzll.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzll.h new file mode 100644 index 0000000..79a9ee8 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzll.h @@ -0,0 +1,937 @@ +/** + * Copyright (c) 2012 - 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. + * + */ +/** + * @file + * @brief Gazell Link Layer API. + */ + +#ifndef NRF_GZLL_H__ +#define NRF_GZLL_H__ + +#include <stdbool.h> +#include "nrf.h" +#include "nrf_gzll_constants.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** +* @defgroup gzll_02_api Gazell Link Layer +* @{ +* @ingroup modules_01_gzll +* @brief Gazell Link Layer Application Programming Interface (API). +*/ + +/** + * @enum nrf_gzll_mode_t + * @brief Enumerator used for selecting Gazell mode. + */ +typedef enum +{ + NRF_GZLL_MODE_DEVICE, ///< Device mode + NRF_GZLL_MODE_HOST, ///< Host mode + NRF_GZLL_MODE_SUSPEND, ///< Suspend mode ("disabled with timer running") +} nrf_gzll_mode_t; + +/** + * @enum nrf_gzll_device_channel_selection_policy_t + * @brief Enumerator used for selecting Gazell Device channel + * selection policy. + */ +typedef enum +{ + NRF_GZLL_DEVICE_CHANNEL_SELECTION_POLICY_USE_SUCCESSFUL, ///< Start on previous successful channel + NRF_GZLL_DEVICE_CHANNEL_SELECTION_POLICY_USE_CURRENT, ///< Start on channel currently monitored by Host +} nrf_gzll_device_channel_selection_policy_t; + +/** + * @enum nrf_gzll_tx_power_t + * @brief Enumerator used for selecting the transmit (TX) power. + */ +typedef enum +{ + NRF_GZLL_TX_POWER_4_DBM, ///< 4 dBm transmit power. + NRF_GZLL_TX_POWER_0_DBM, ///< 0 dBm transmit power. + NRF_GZLL_TX_POWER_N4_DBM, ///< -4 dBm transmit power. + NRF_GZLL_TX_POWER_N8_DBM, ///< -8 dBm transmit power. + NRF_GZLL_TX_POWER_N12_DBM, ///< -12 dBm transmit power. + NRF_GZLL_TX_POWER_N16_DBM, ///< -16 dBm transmit power. + NRF_GZLL_TX_POWER_N20_DBM ///< -20 dBm transmit power. +} nrf_gzll_tx_power_t; + +/** + * @enum nrf_gzll_datarate_t + * @brief Enumerator used for selecting the radio datarate. + */ +typedef enum +{ +#ifdef NRF51 + NRF_GZLL_DATARATE_250KBIT = 0, ///< 250 Kbps datarate, available only for the nRF51. +#endif + NRF_GZLL_DATARATE_1MBIT = 1, ///< 1 Mbps datarate. + NRF_GZLL_DATARATE_2MBIT = 2 ///< 2 Mbps datarate. +} nrf_gzll_datarate_t; + +/** + * @enum nrf_gzll_xosc_ctl_t + * @brief Enumerator used for specifying whether switching the + * external 16 MHz oscillator on/off shall be handled automatically + * inside Gazell or manually by the application. + */ +typedef enum +{ + NRF_GZLL_XOSC_CTL_AUTO, ///< Switch XOSC on/off automatically + NRF_GZLL_XOSC_CTL_MANUAL ///< Switch XOSC on/off manually +} nrf_gzll_xosc_ctl_t; + +/** + * @enum nrf_gzll_error_code_t + * @brief Enumerator used for error codes for Gazell API functions + */ +typedef enum +{ + NRF_GZLL_ERROR_CODE_NO_ERROR = 0, ///< No error has been detected. + NRF_GZLL_ERROR_CODE_FAILED_TO_INITIALIZE = 1, ///< The function NRF_GZLL_init failed. + NRF_GZLL_ERROR_CODE_ATTEMPTED_TO_CONFIGURE_WHEN_ENABLED = 2, ///< A call to a configuration 'set' function was made while Gazell was enabled. + NRF_GZLL_ERROR_CODE_POINTER_IS_NULL = 3, ///< A null pointer was given as an input to a function. + NRF_GZLL_ERROR_CODE_INVALID_PIPE = 4, ///< An invalid pipe number was given as an input to a function. + NRF_GZLL_ERROR_CODE_INVALID_MODE = 5, ///< An invalid value for the nrf_gzll_mode_t enumerator was given as input to a function. + NRF_GZLL_ERROR_CODE_INVALID_PAYLOAD_LENGTH = 6, ///< An invalid payload length was given as an input to a function. + NRF_GZLL_ERROR_CODE_INVALID_CHANNEL_TABLE_SIZE = 7, ///< An invalid channel table size was given as an input to a function. + NRF_GZLL_ERROR_CODE_INSUFFICIENT_PACKETS_AVAILABLE = 8, ///< There are insufficient packets in the Gazell memory pool to successfully execute the operation. + NRF_GZLL_ERROR_CODE_ATTEMPTED_TO_ADD_TO_FULL_FIFO = 9, ///< There is insufficient space in the TX FIFO for the data packet. + NRF_GZLL_ERROR_CODE_NO_SPACE_IN_RX_FIFO_FOR_ACK = 10, ///< There is insufficient space in the RX FIFO for the ACK. + NRF_GZLL_ERROR_CODE_ATTEMPTED_TO_FETCH_FROM_EMPTY_FIFO = 11, ///< Attempted to fetch a packet from an empty FIFO. Use the functions nrf_gzll_get_tx_fifo_packet_count() or nrf_gzll_get_rx_fifo_packet_count() + NRF_GZLL_ERROR_CODE_ATTEMPTED_TO_FLUSH_WHEN_ENABLED = 12, ///< Attempted to fetch a packet from an empty FIFO. Use the functions nrf_gzll_get_tx_fifo_packet_count() or nrf_gzll_get_rx_fifo_packet_count() + NRF_GZLL_ERROR_CODE_INVALID_PARAMETER = 14, ///< Attempted to set a variable which was not valid. + NRF_GZLL_ERROR_CODE_INTERNAL_ASSERT_OCCURRED = 15, ///< An internal assert occurred. + NRF_GZLL_ERROR_CODE_CALLBACK_NOT_IMPLEMENTED = 16, ///< A callback was called but not implemented by the application. + NRF_GZLL_ERROR_CODE_INVALID_ADDRESS = 17, ///< Invalid pipe 0 address detected, see Anomaly 107 at nRF52832 errata document. + NRF_GZLL_ERROR_CODE_NUMBER_OF_ERROR_CODES = 18, ///< Number of possible error codes. +} nrf_gzll_error_code_t; + +/** + * @struct nrf_gzll_device_tx_info_t; + * @brief Data structure containing information about the last packet + * transmission. + */ +typedef struct +{ + bool payload_received_in_ack; ///< A payload was received in the ACK. + uint16_t num_tx_attempts; ///< Number of attempts used on previous Device packet transmission. + uint16_t num_channel_switches; ///< Number of channel switches needed during previous packet transmission. + int8_t rssi; ///< Received signal strength indicator in dBm. @sa nrf_gzll_enable_rssi(). + uint8_t rf_channel; ///< Channel on which packet has been transmitted. +} nrf_gzll_device_tx_info_t; + + +/** + * @struct nrf_gzll_host_rx_info_t; + * @brief Data structure containing information about the last packet + * received. + */ +typedef struct +{ + bool packet_removed_from_tx_fifo; ///< A payload was received in the ACK. + int8_t rssi; ///< Received signal strength indicator in dBm. @sa nrf_gzll_enable_rssi(). + uint8_t rf_channel; ///< Channel on which packet has been received. +} nrf_gzll_host_rx_info_t; + + +typedef struct +{ + uint32_t packets_num; ///< Number of succesfully transmitted packets + uint32_t timeouts_num; ///< Total timeouts number + uint32_t channel_timeouts[NRF_GZLL_CONST_MAX_CHANNEL_TABLE_SIZE]; ///< Transmission timeouts per channel + uint32_t channel_packets[NRF_GZLL_CONST_MAX_CHANNEL_TABLE_SIZE]; ///< Succesfully transmitted packets per channel +} nrf_gzll_tx_statistics_t; + + +/**< Transmission timeout callback function definition */ +typedef void (*nrf_gzll_tx_timeout_callback)(uint32_t pipe, uint8_t rf_channel); + + +/**< Transmission CRC failure callback function definition */ +typedef void (*nrf_gzll_crc_failure_callback)(uint32_t pipe, uint8_t rf_channel); + + +#if defined(NRF52_SERIES) || defined(__SDK_DOXYGEN__) +/** + * @brief Data structure holding external front + * end control configuration. + */ +typedef struct +{ + bool pa_enabled; ///< Flag indicating if PA control is enabled. + bool pa_active_high; ///< Flag indicating if PA is active in high input state. + uint8_t pa_gpio_pin; ///< Number of output pin used for PA control. + uint8_t pa_gpiote_channel; ///< Number of GPIOTE channel used for PA control. + bool lna_enabled; ///< Flag indicating if LNA control is enabled. + bool lna_active_high; ///< Flag indicating if LNA is active in high input state. + uint8_t lna_gpio_pin; ///< Number of output pin used for LNA control. + uint8_t lna_gpiote_channel; ///< Number of GPIOTE channel used for LNA control. + NRF_TIMER_Type * timer; ///< Pointer to the TIMER instance. + uint8_t ppi_channels[NRF_GZLL_PA_LNA_PPI_CHANNELS_NUM]; ///< PPI channels used to control front end. + uint8_t ramp_up_time; ///< Determines how early should the PA/LNA be turned one before RADIO activity. Should be less than @ref NRF_GZLL_PA_LNA_MAX_RAMP_UP_TIME. +} nrf_gzll_pa_lna_cfg_t; +#endif + +/******************************************************************************/ +/** @name General API functions + * @{ */ +/******************************************************************************/ + +/** + * @brief Initialize Gazell. + * + * @param mode The mode to initialize Gazell in. + * + * @retval true if Gazell initialized. + * @retval false if Gazell failed to initialize. + */ +bool nrf_gzll_init(nrf_gzll_mode_t mode); + +/** + * @brief Enable Gazell. + * + * When enabled the behaviour described for the current Gazell Link Layer mode + * will apply. + * + * @retval false if nrf_gzll_init has not previously been called or invalid address + * has been set - see Anomaly 107 at nRF52832 errata document. + */ +bool nrf_gzll_enable(void); + +/** + * @brief Disable Gazell. + * + * When calling this function the Gazell Link Layer will begin disabling, + * and will be fully disabled when Gazell calls nrf_gzll_disabled(). + * If there are any pending notifications, or if any new notifications are + * being added to the internal notification queue while Gazell is disabling, + * these will be sent to the application before Gazell is fully disabled. + * + * After Gazell has been fully disabled, no more notifications will be sent to + * the application. + */ +void nrf_gzll_disable(void); + +/** Check whether Gazell is enabled or disabled. + * + * @retval true If Gazell is enabled. + * @retval false If Gazell is disabled. + */ +bool nrf_gzll_is_enabled(void); + +/** @} */ + +/******************************************************************************/ +/** @name Device mode callback functions + * @{ */ +/******************************************************************************/ + +/** + * @brief ACK received callback (Device mode only). + * + * This callback is made when the Device receives an ACK (acknowledgement) + * packet. + * @sa nrf_gzll_ack_payload_received. + * + * @param pipe is the pipe on which an ACK packet was received. + * @param tx_info struct used to indicate whether a payload was received in the + * ack, as well as the number of TX attempts and channel switches required. + */ +void nrf_gzll_device_tx_success(uint32_t pipe, nrf_gzll_device_tx_info_t tx_info); + +/** + * @brief Transmission failed callback (Device mode only). + * + * This callback is made when a packet does not receive an ACK after + * nrf_gzll_max_retries is reached. The packet is deleted by Gazell. + * + * @param pipe is the pipe on which the transmission failed. + * @param tx_info struct used to indicate whether a payload was received + * in the ack, as well as RSSI and the number of TX attempts and + * channel switches required. + */ +void nrf_gzll_device_tx_failed(uint32_t pipe, nrf_gzll_device_tx_info_t tx_info); + +/** @} */ + +/******************************************************************************/ +/** @name Host mode callback functions + * @{ */ +/******************************************************************************/ + +/** + * @brief Data packet received callback (Host mode only). + * + * This callback is made when a Host receives a data packet from a Device. + * + * @param pipe is the pipe on which the data packet was received. + * @param rx_info struct used to indicate whether a payload was removed from the + * pipe's TX FIFO, as well as RSSI. + */ +void nrf_gzll_host_rx_data_ready(uint32_t pipe, nrf_gzll_host_rx_info_t rx_info); + +/** @} */ + +/******************************************************************************/ +/** @name Callback functions for both Device and Host mode + * @{ */ +/******************************************************************************/ + +/** + * @brief Disabled callback. + * + * This is called after Gazell enters the disabled state. + * There is no further CPU use by Gazell, the radio is disabled and the timer is + * powered down. + */ +void nrf_gzll_disabled(void); + +/** + * @brief Mode changed callbackl. + * + * This function is called after the Gazell mode has been changed. + * This function can only be called when Gazell is enabled. + */ +void nrf_gzll_mode_changed(void); + +/** @} */ + +/******************************************************************************/ +/** @name Packet transmission and receiving functions + * @{ */ +/******************************************************************************/ + +/** + * @brief Add a packet to the tail of the TX FIFO. + * + * In Device mode, the packet will be added. + * In Host mode, the payload will be piggybacked onto an ACK. + * + * @param pipe Pipe to which to add the payload. This value must be < NRF_GZLL_CONST_PIPE_COUNT. + * @param p_payload Pointer to the payload. + * @param length Number of bytes of the payload to transmit + * (0 to NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH). + * + * @retval true if the packet was successfully added to the TX FIFO. + * @retval false if unsuccessful, check nrf_gzll_error_code_t for more information. + */ +bool nrf_gzll_add_packet_to_tx_fifo(uint32_t pipe, uint8_t * p_payload, uint32_t length); + +/** + * @brief Fetch a packet from the head of the RX FIFO. + * + * @param pipe Pipe from which to fetch the payload. This value must be < NRF_GZLL_CONST_PIPE_COUNT. + * @param p_payload Pointer to copy the payload to. + * @param p_length Length must be at least as large as the the number of bytes + * in the received payload length. + * + * @retval true If the fetch was successful. + * @retval false If unsuccessful, check nrf_gzll_error_code_t for more information. + */ +bool nrf_gzll_fetch_packet_from_rx_fifo(uint32_t pipe, uint8_t * p_payload, uint32_t * p_length); + +/** + * @brief Get the number of packets in the TX FIFO on a specific pipe. + * + * @param pipe The pipe for which to check. This value must be < NRF_GZLL_CONST_PIPE_COUNT. + * + * @retval >=0 The number of packets in the TX FIFO for the pipe. + * @retval -1 If the pipe number is invalid. + */ +int32_t nrf_gzll_get_tx_fifo_packet_count(uint32_t pipe); + +/** + * @brief Get the number of packets in the RX FIFO on a specific pipe. + * + * @param pipe The pipe for which to check. This value must be < NRF_GZLL_CONST_PIPE_COUNT. + * @retval >=0 The number of packets in the RX FIFO for the pipe. + * @retval -1 If the pipe number is invalid. + */ +int32_t nrf_gzll_get_rx_fifo_packet_count(uint32_t pipe); + +/** + * @brief Get the total number of packets residing in all TX and RX FIFOs. + * + * Can be used to check against NRF_GZLL_CONST_MAX_TOTAL_PACKETS to + * determine if there is free space in the memory pool for more packets. + * + * @return The number of packets residing in all TX and RX FIFOs. + */ +uint32_t nrf_gzll_get_total_allocated_packet_count(void); + +/** + * @brief Check if adding a packet to a pipe's TX FIFO should be successful. + * + * Checks if there is another space in the pipe's TX and RX FIFOs + * as well as enough overall space in the packet pool. + * + * @param pipe The pip for which to check. This value must be < NRF_GZLL_CONST_PIPE_COUNT. + * + * @retval true If there is another space. + * @retval false If there is not enough space, or the pipe is invalid. + */ +bool nrf_gzll_ok_to_add_packet_to_tx_fifo(uint32_t pipe); + +/** + * @brief Flush the RX FIFO for a specific pipe. + * + * Delete all the packets and free the memory of the TX FIFO for a + * specific pipe. + * + * Note that it is not allowed to flush a TX FIFO when + * Gazell is enabled. + * + * @param pipe is the pipe for which to flush. This value must be < NRF_GZLL_CONST_PIPE_COUNT. + * @retval true if the pipe was flushed. + * @retval false if the pipe was not flushed. + */ +bool nrf_gzll_flush_tx_fifo(uint32_t pipe); + +/** + * @brief Flush the RX FIFO for a specific pipe. + * + * Delete all the packets and free the memory of the RX FIFO for a + * specific pipe. + * + * @param pipe is the pipe for which to flush. This value must be < NRF_GZLL_CONST_PIPE_COUNT. + * @retval true if the pipe was flushed. + * @retval false if the pipe was not flushed. + */ +bool nrf_gzll_flush_rx_fifo(uint32_t pipe); + +/** + * @brief Function for enabling transmission statistics. + * + * @param p_statistics Pointer to the statistics structure. + * + * @return True if channel statistics has been enabled, false otherwise. + */ +bool nrf_gzll_tx_statistics_enable(nrf_gzll_tx_statistics_t * p_statistics); + +/** + * @brief Function for disabling transmission statistics. + */ +void nrf_gzll_tx_statistics_disable(void); + +/** + * @brief Function for obtaining number of transmission timeouts for specific channel. + * + * @param[in] channel_index Channel index in channel table. + * @param[out] p_timeouts Pointer for the result. + * + * @return True in case of success, false otherwise. + */ +bool nrf_gzll_get_channel_timeouts(uint8_t channel_index, uint32_t *p_timeouts); + +/** + * @brief Function for clearing transmission statistic structure. + */ +void nrf_gzll_reset_tx_statistics(void); + +/** @} */ + +/******************************************************************************/ +/** @name Configuration functions + * + * Configuration 'set' functions may only be called while Gazell is disabled. The + * new parameter comes into effect when Gazell is enabled again. + * + * Configuration 'get' functions may be called at any time. + * + * @{ */ +/******************************************************************************/ + +/** + * @brief Function for registering callback to be called on the transmission timeout. + */ +void nrf_gzll_tx_timeout_callback_register(nrf_gzll_tx_timeout_callback callback); + + +/** + * @brief Function for registering callback to be called on the packet CRC failure. + */ +void nrf_gzll_crc_failure_callback_register(nrf_gzll_crc_failure_callback callback); + + +/** + * @brief Set the mode. + * + * @param mode The mode to be used. + * See nrf_gzll_mode_t for a list of valid modes. + * + * It is allowed to change mode when Gazell is enabled. If the mode is + * being changed while Gazell is enabled, the mode will not change right away. + * In this case the callback function nrf_gzll_mode_changed() will be called + * after the mdoe has changed. + * + * @retval true If the parameter was set. + */ +bool nrf_gzll_set_mode(nrf_gzll_mode_t mode); + +/** + * @brief Get function counterpart to nrf_gzll_set_mode(). + * + * @return The current mode. + */ +nrf_gzll_mode_t nrf_gzll_get_mode(void); + +/** + * @brief Set the base address for pipe 0. + * + * The full on-air address for each pipe is composed of a multi-byte base address + * prepended to a prefix byte. + * + * For packets to be received correctly, the most significant byte of + * the base address should not be an alternating sequence of 0s and 1s i.e. + * it should not be 0x55 or 0xAA. + * + * @param base_address The 4 byte base address. All bytes are used. + * + * @note Due to the nRF52 Anomaly 107, pipe 0 address should not have + * both prefix and two LSB of base address set to 0. + * + * @retval true If the parameter was set. + * @return false If Gazell was enabled. + */ +bool nrf_gzll_set_base_address_0(uint32_t base_address); + +/** + * @brief Get function counterpart to nrf_gzll_set_base_address_0(). + * + * @return Base address 0. + */ +uint32_t nrf_gzll_get_base_address_0(void); + +/** + * @brief Set the base address for pipes 1-7. + * + * Pipes 1 through 7 share base_address_1. @sa nrf_gzll_set_base_address_0. + * + * @param base_address The 4 byte base address. + * + * @retval true If the parameter was set. + * @retval false If Gazell was enabled. + */ +bool nrf_gzll_set_base_address_1(uint32_t base_address); + +/** + * @brief Get function counterpart to nrf_gzll_set_base_address_1(). + * + * @return Base address 1. + */ +uint32_t nrf_gzll_get_base_address_1(void); + +/** + * @brief Set the address prefix byte for a specific pipe. + * + * Each pipe should have its own unique prefix byte. + * + * @param pipe The pipe that the address should apply to. + * This value must be < NRF_GZLL_CONST_PIPE_COUNT. + * @param address_prefix_byte The address prefix byte. + * + * @note Due to the Anomaly 107, pipe 0 address should not have + * both prefix and two LSB of base address set to 0. + * + * @retval true If the parameter was set. + * @retval false If Gazell was enabled, or if the pipe was invalid. + */ +bool nrf_gzll_set_address_prefix_byte(uint32_t pipe, uint8_t address_prefix_byte); + +/** + * @brief Get function counterpart to nrf_gzll_set_address_prefix_byte(). + * + * @param pipe The pipe for which to get the address. + * This value must be < NRF_GZLL_CONST_PIPE_COUNT. + * @param p_out_address_prefix_byte The pointer in which to return the + * address prefix byte. + * + * @retval true If the parameter was returned. + * @retval false If Gazell was enabled, the pipe was invalid or + * out_address was a NULL pointer. + */ +bool nrf_gzll_get_address_prefix_byte(uint32_t pipe, uint8_t * p_out_address_prefix_byte); + +/** + * @brief Set which pipes shall listen for packets in Host mode. + * + * This value is a bitmap, and each bit corresponds to a given pipe number. + * Bit 0 set to "1" enables pipes 0, bit 1 set to "1" enables pipe 1 + * and so forth. + * The maximum number of pipes is defined by NRF_GZLL_CONST_PIPE_COUNT. + * + * @param pipes A bitmap specifying which pipes to monitor. + * + * @retval true If the parameter was set. + * @retval false If Gazell was enabled. + */ +bool nrf_gzll_set_rx_pipes_enabled(uint32_t pipes); + +/** + * @brief Get function counterpart to nrf_gzll_set_rx_pipes_enabled(). + * + * @return Bitmap holding the current enabled pipes. + */ +uint32_t nrf_gzll_get_rx_pipes_enabled(void); + +/** + * @brief Set the timeslot period. + * + * The length in microseconds of a Gazell link layer timeslot. + * + * The minimum value of the timeslot period is dependent of the + * radio data rate (@sa nrf_gzll_set_datarate()). + * + * - For NRF_GZLL_DATARATE_2MBIT the timeslot period must be >= 600 us. + * - For NRF_GZLL_DATARATE_1MBIT the timeslot period must be >= 900 us. + * - For NRF_GZLL_DATARATE_250KBIT the timeslot period must be >= 2700 us. + * + * @param period_us The timeslot period in microseconds. + * + * @retval true If the parameter was set. + * @retval false If Gazell was enabled. + */ +bool nrf_gzll_set_timeslot_period(uint32_t period_us); + +/** + * @brief Get function counterpart to nrf_gzll_get_timeslot_period(). + * + * @return The current timeslot period. + */ +uint32_t nrf_gzll_get_timeslot_period(void); + +/** + * @brief Set the Device channel selection policy + * + * The policy determines the initial channel when starting a new packet. + * transmission. + * + * @param policy The channel selection policy. + * + * @arg NRF_GZLL_DEVICE_CHANNEL_SELECTION_POLICY_USE_SUCCESSFUL specifies + * that a new packet transmission always shall use the previous + * successful channel from the channel table. If Gazell is "in sync", Gazell + * will wait until this channel is being monitored by the Host before starting + * the transmission. + * + * @arg NRF_GZLL_DEVICE_CHANNEL_SELECTION_POLICY_USE_CURRENT specifies that + * Gazell shall transmit on the channel that is currently being monitored by the + * Host. This parameter is only used when Gazell is "in sync". When "out of" sync, + * Gazell will always start using the "previous successful" channel. + * + * @retval true If the parameter was set. + * @retval false If Gazell was enabled or the policy was invalid. + */ +bool nrf_gzll_set_device_channel_selection_policy(nrf_gzll_device_channel_selection_policy_t policy); + +/** + * @brief Get function counterpart to nrf_gzll_set_device_channel_selection_policy(). + * + * @return the Device channel selection policy. + */ +nrf_gzll_device_channel_selection_policy_t nrf_gzll_get_device_channel_selection_policy(void); + +/** + * @brief Set the number of timeslots that Gazell shall + * reside on a single channel before switching to another channel. + * + * This parameter applies in Host mode and for a Device that is + * in the "in sync" state. + * + * Since the Device and Host can not be in perfect synchronization, a + * transmission should overlap to adjacent timeslots on the Host. + * Therefore this value should be at least 2. + * + * @sa nrf_gzll_set_timeslots_per_channel_when_device_out_of_sync + * + * @param timeslots The number of timeslots to reside on + * each channel before channel switch. + * + * @retval true If the parameter was set. + * @retval false If Gazell was enabled. + */ +bool nrf_gzll_set_timeslots_per_channel(uint32_t timeslots); + +/** + * @brief Get function counterpart to nrf_gzll_set_timeslots_per_channel(). + * + * @return The current number of timeslots. + */ +uint32_t nrf_gzll_get_timeslots_per_channel(void); + +/** + * @brief Set the number of timeslots that a Gazell shall + * reside on a single channel before switching to another channel when + * in the "out of sync" state. + * + * This value should be set so that the Device transmits on one channel + * while the Host goes through a full channel rotation, i.e., + * channel_table_size*timeslots_per_channel. + * This ensures that the channels on the Device and Host will coincide + * at some point. + * Further increasing the value has been observed to provide better performance + * in the presence of interferers. + * + * @param timeslots The number of timeslots to reside on + * each channel before channel switch. + * + * @retval true If the parameter was set. + * @retval false If Gazell was enabled. + */ +bool nrf_gzll_set_timeslots_per_channel_when_device_out_of_sync(uint32_t timeslots); + +/** + * @brief Get function counterpart to + * nrf_gzll_set_timeslots_per_channel_when_device_out_of_sync(). + * + * @return The current number of timeslots. + */ +uint32_t nrf_gzll_get_timeslots_per_channel_when_device_out_of_sync(void); + +/** + * @brief Set the number of timeslots after a successful + * reception of a Device or Host packet that the Gazell Link Layer shall assume + * that the link is synchronized. A value of 0 implies that the + * link is always out of sync. + * + * @param lifetime The sync lifetime in number of timeslots. + * + * @retval true If the sync lifetime was set. + * @retval false If Gazell was enabled. + */ +bool nrf_gzll_set_sync_lifetime(uint32_t lifetime); + +/** + * @brief Get function counterpart to nrf_gzll_set_sync_lifetime(). + * + * @return The sync lifetime measured in number of timeslots. + */ +uint32_t nrf_gzll_get_sync_lifetime(void); + +/** + * @brief Set the maximum number of TX attempts + * that can be used for a single packet. + * + * After the maximum number of attempts have been spent without + * receiving any ACK from the Host, the transmission will be terminated + * and the nrf_gzll_device_tx_failed() callback will be called. A zero + * value of the function parameter implies the infinite number of TX attempts. + * + * @param max_tx_attempts The maximum number of TX attempts. + */ +void nrf_gzll_set_max_tx_attempts(uint16_t max_tx_attempts); + +/** + * @brief Get function counterpart to nrf_gzll_set_max_tx_attempts(). + * + * @return The current max Device TX attempts. + */ +uint16_t nrf_gzll_get_max_tx_attempts(void); + +/** + * @brief Set the table of Radio Frequency (RF) channels. + * + * The valid channels are in the range 0 <= channel <= 125, where the + * actual centre frequency is (2400 + channel) MHz. + * The maximum channel table size is defined by + * NRF_GZLL_CONST_MAX_CHANNEL_TABLE_SIZE. + * + * @param p_channel_table Pointer to the channel table. + * @param size The size of the channel table. + * + * @retval true If the channel table was set. + * @retval false If Gazell was enabled, or the channel_table pointer was NULL, + * or the size was invalid. + */ +bool nrf_gzll_set_channel_table(uint8_t * p_channel_table, uint32_t size); + +/** + * @brief Get the table of Radio Frequency (RF) channels. + * + * @param p_channel_table Pointer to copy the channel table to. + * @param p_size Pointer to copy the size of the channel table to. + * The value already at size must be at least the size + * of the channel table. + * + * @retval true If the channel table was copied to channel_table. + * @retval false If the channel_table pointer was NULL, + * or the size was not large enough. + */ +bool nrf_gzll_get_channel_table(uint8_t * p_channel_table, uint32_t * p_size); + +/** + * @brief Get the current channel table size. + * + * @return The current channel table size. + */ +uint32_t nrf_gzll_get_channel_table_size(void); + +/** + * @brief Set the radio TX power. + * + * @param tx_power TX power. + * + * @retval true If the parameter was set. + * @retval false If the TX power was invalid. +*/ +bool nrf_gzll_set_tx_power(nrf_gzll_tx_power_t tx_power); + +/** + * @brief Get function counterpart to nrf_gzll_set_tx_power(). + * + * @return The current TX power. + */ +nrf_gzll_tx_power_t nrf_gzll_get_tx_power(void); + +/** + * @brief Set the radio datarate. + * + * @param data_rate Datarate. + * + * @retval true If the parameter was set. + * @retval false If Gazell was enabled or the datarate was invalid. + */ +bool nrf_gzll_set_datarate(nrf_gzll_datarate_t data_rate); + +/** + * @brief Get function counterpart to nrf_gzll_set_datarate(). + * + * @return The current datarate. + */ +nrf_gzll_datarate_t nrf_gzll_get_datarate(void); + +/** + * @brief Set whether start/stop of external oscillator (XOSC) shall be handled + * automatically inside Gazell or manually by the application. + * + * When controlling the XOSC manually from the application it is + * required that the XOSC is started before Gazell is enabled. + * + * When start/stop of the XOSC is handled automatically by Gazell, + * the XOSC will only be running when needed, that is when the radio + * is being used or when Gazell needs to maintain synchronization. + * + * It is required that the XOSC is started in order for the radio to be + * able to send or receive any packets. + * + * @param xosc_ctl setting for XOSC control. + * + * @retval true if the parameter was set. + * @retval false if Gazell was enabled or the xosc_ctl value was invalid. + */ +bool nrf_gzll_set_xosc_ctl(nrf_gzll_xosc_ctl_t xosc_ctl); + +/** + * Get function counterpart for nrf_gzll_set_xosc_ctl(); + * + * @return The XOSC control setting. + */ +nrf_gzll_xosc_ctl_t nrf_gzll_get_xosc_ctl(void); + +/** + * @brief Set Gazell to disable automatically after a certain number of timeslot ticks. + * + * @param num_ticks Number of timeslot ticks. + * + */ +void nrf_gzll_set_auto_disable(uint32_t num_ticks); + +#if defined(NRF52_SERIES) || defined(__SDK_DOXYGEN__) +/** + * @brief Set up external front end control. + * + * @param p_pa_lna_cfg Pointer to the configuration struct. + */ +bool nrf_gzll_set_pa_lna_cfg(nrf_gzll_pa_lna_cfg_t const * p_pa_lna_cfg); +#endif + +/** + * @brief Get the number of timeslot ticks that have occurred since + * nrf_gzll_init() was called. + * + * @return Number of timeslot ticks. + * + */ +uint32_t nrf_gzll_get_tick_count(void); + +/** + * @brief Clear the internal timeslot tick count variable that is read + * by nrf_gzll_get_tick_count(). + * + */ +void nrf_gzll_clear_tick_count(void); + +/** @} */ + +/******************************************************************************/ +/** @name Error handling functions + * @{ */ +/******************************************************************************/ + +/** + * @brief Gets the Gazell error code. + * + * @return The current error code. + */ +nrf_gzll_error_code_t nrf_gzll_get_error_code(void); + + +/** + * @brief Reset the Gazell error code. + * + * The error code is reset to NRF_GZLL_ERROR_CODE_NO_ERRROR. + */ +void nrf_gzll_reset_error_code(void); + +/** @} */ + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzll_constants.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzll_constants.h new file mode 100644 index 0000000..80df7c1 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzll_constants.h @@ -0,0 +1,188 @@ +/** + * Copyright (c) 2011 - 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. + * + */ +/** + * @file + * @brief Gazell Link Layer constants and default values. + * + * NOTE! Changing values here has no effect. They are only provided as a reference. + */ + +#ifndef NRF_GZLL_CONSTANTS_H__ +#define NRF_GZLL_CONSTANTS_H__ + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * @addtogroup gzll_02_api + * @{ + */ + + +/*****************************************************************************/ +/** @name Hardware resources used by Gazell */ +/*****************************************************************************/ +#define NRF_GZLL_HIGH_IRQ_PRIORITY 0 ///< Interrupt priority the Gazell timer and the radio +#define NRF_GZLL_LOW_IRQ_PRIORITY 1 ///< Interrupt priority for Gazell callback functions. + +#ifndef USE_SD_HW_RESOURCES + +#define NRF_GZLL_SWI_IRQn SWI0_IRQn ///< Software interrupt # used for callback functions. +#define NRF_GZLL_SWI_IRQ_HANDLER SWI0_IRQHandler ///< Software interrupt handler used for callback functions. +#define NRF_GZLL_TIMER NRF_TIMER2 ///< Timer to be used as flywheel timer. +#define NRF_GZLL_TIMER_IRQn TIMER2_IRQn ///< Interrupt # for the timer. +#define NRF_GZLL_TIMER_IRQ_HANDLER TIMER2_IRQHandler ///< Interrupt handler for the timer. + +// In addition, Gazell uses the radio peripheral and radio interrupts. + +/* + * PPI configuration + */ +#define NRF_GZLL_PPI_EEP0 (NRF_PPI->CH0_EEP) ///< Gazell PPI event endpoint 0 +#define NRF_GZLL_PPI_TEP0 (NRF_PPI->CH0_TEP) ///< Gazell PPI task endpoint 0 +#define NRF_GZLL_PPI_EEP1 (NRF_PPI->CH1_EEP) ///< Gazell PPI event endpoint 1 +#define NRF_GZLL_PPI_TEP1 (NRF_PPI->CH1_TEP) ///< Gazell PPI task endpoint 1 +#define NRF_GZLL_PPI_EEP2 (NRF_PPI->CH2_EEP) ///< Gazell PPI event endpoint 2 +#define NRF_GZLL_PPI_TEP2 (NRF_PPI->CH2_TEP) ///< Gazell PPI task endpoint 2 + +#define NRF_GZLL_PPI_CHEN_MSK_0_AND_1 (0x03) ///< Channel enable/disable mask for PPI endpoint 0 and 1. +#define NRF_GZLL_PPI_CHEN_MSK_2 (0x04) ///< Channel enable/disable mask for PPI endpoint 2. + +#else + +#define NRF_GZLL_SWI_IRQn SWI1_IRQn ///< Software interrupt # used for callback functions. +#define NRF_GZLL_SWI_IRQ_HANDLER SWI1_IRQHandler ///< Software interrupt handler used for callback functions. +#define NRF_GZLL_TIMER NRF_TIMER0 ///< Timer to be used as flywheel timer. +#define NRF_GZLL_TIMER_PERPOWER_Msk POWER_PERPOWER_TIMER0_Msk ///< PERPOWER mask for the timer. +#define NRF_GZLL_TIMER_IRQn TIMER0_IRQn ///< Interrupt # for the timer. +#define NRF_GZLL_TIMER_IRQ_HANDLER TIMER0_IRQHandler ///< Interrupt handler for the timer. + +// In addition, Gazell uses the radio peripheral and radio interrupts. + +/* + * PPI configuration + */ +#define NRF_GZLL_PPI_EEP0 (NRF_PPI->CH8_EEP) ///< Gazell PPI event endpoint 0 +#define NRF_GZLL_PPI_TEP0 (NRF_PPI->CH8_TEP) ///< Gazell PPI task endpoint 0 +#define NRF_GZLL_PPI_EEP1 (NRF_PPI->CH9_EEP) ///< Gazell PPI event endpoint 1 +#define NRF_GZLL_PPI_TEP1 (NRF_PPI->CH9_TEP) ///< Gazell PPI task endpoint 1 +#define NRF_GZLL_PPI_EEP2 (NRF_PPI->CH10_EEP) ///< Gazell PPI event endpoint 2 +#define NRF_GZLL_PPI_TEP2 (NRF_PPI->CH10_TEP) ///< Gazell PPI task endpoint 2 + +#define NRF_GZLL_PPI_CHEN_MSK_0_AND_1 (0x300) ///< Channel enable/disable mask for PPI endpoint 0 and 1. +#define NRF_GZLL_PPI_CHEN_MSK_2 (0x400) ///< Channel enable/disable mask for PPI endpoint 2. + +#endif +/** @} */ + +/*****************************************************************************/ +/** @name Constant pipe and FIFO configuration */ +/*****************************************************************************/ +#define NRF_GZLL_CONST_PIPE_COUNT 8 ///< Number of TX pipes (at least one for each Device-Host pairs). +#define NRF_GZLL_CONST_FIFO_LENGTH 3 ///< Maximum number of packets allowed in a TX or RX FIFO. +#define NRF_GZLL_CONST_MAX_TOTAL_PACKETS 6 ///< Maximum number of packets available for reservation at any one time. +#define NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH 32 ///< Maximum allowed payload length in bytes. +#define NRF_GZLL_CONST_CALLBACK_QUEUE_LENGTH 10 ///< Maximum number of notifications allowed in the callback queue. +/** @} */ + +/*****************************************************************************/ +/** @name Default radio configuration */ +/*****************************************************************************/ +#define NRF_GZLL_DEFAULT_TX_POWER NRF_GZLL_TX_POWER_0_DBM ///< Default TX power. +#define NRF_GZLL_DEFAULT_DATARATE NRF_GZLL_DATARATE_2MBIT ///< Default data rate. + +#define NRF_GZLL_DEFAULT_CHANNEL_TABLE {4, 25, 42, 63, 77} ///< Default channel table. +#define NRF_GZLL_DEFAULT_CHANNEL_TABLE_SIZE 5 ///< Default channel table size. +#define NRF_GZLL_CONST_MAX_CHANNEL_TABLE_SIZE 16 ///< Maximum channel table size allowed by Gazell. +/** @} */ + +/*****************************************************************************/ +/** @name Default Address configuration */ +/*****************************************************************************/ + +/* +Corresponds to Legacy nRFgo SDK Gazell config: +#define GZLL_DEFAULT_ADDRESS_PIPE0 {0x01, 0x04, 0x07, 0x0A, 0x0D} +#define GZLL_DEFAULT_ADDRESS_PIPE1 {0x02, 0x05, 0x08, 0x0B, 0x0E} +#define GZLL_DEFAULT_ADDRESS_PIPE2 3 +#define GZLL_DEFAULT_ADDRESS_PIPE3 4 +#define GZLL_DEFAULT_ADDRESS_PIPE4 5 +#define GZLL_DEFAULT_ADDRESS_PIPE5 6 +*/ + +#define NRF_GZLL_DEFAULT_FULL_ADDRESS_PIPE0 {0x01, 0x04, 0x07, 0x0A, 0x0D} ///< Corresponding legacy Gazell pipe 0 address. +#define NRF_GZLL_DEFAULT_BASE_ADDRESS_0 0x0D0A0704 ///< Default base address 0. +#define NRF_GZLL_DEFAULT_BASE_ADDRESS_1 0x0E0B0805 ///< Default base address 1. +#define NRF_GZLL_DEFAULT_PREFIX_BYTE_0 1 ///< Default prefix address pipe 0. +#define NRF_GZLL_DEFAULT_PREFIX_BYTE_1 2 ///< Default prefix address pipe 1. +#define NRF_GZLL_DEFAULT_PREFIX_BYTE_2 3 ///< Default prefix address pipe 2. +#define NRF_GZLL_DEFAULT_PREFIX_BYTE_3 4 ///< Default prefix address pipe 3. +#define NRF_GZLL_DEFAULT_PREFIX_BYTE_4 5 ///< Default prefix address pipe 4. +#define NRF_GZLL_DEFAULT_PREFIX_BYTE_5 6 ///< Default prefix address pipe 5. +#define NRF_GZLL_DEFAULT_PREFIX_BYTE_6 7 ///< Default prefix address pipe 6. +#define NRF_GZLL_DEFAULT_PREFIX_BYTE_7 8 ///< Default prefix address pipe 7. +#define NRF_GZLL_DEFAULT_BASE_ADDRESS_LENGTH NRF_GZLL_BASE_ADDRESS_LENGTH_4B ///< Default on-air base address length. +#define NRF_GZLL_DEFAULT_RX_PIPES_ENABLED 0x000000FF ///< Enabled Rx pipes. See nrf_gzll_set_rx_pipes_enabled(). +/** @} */ + +/*****************************************************************************/ +/** @name Default timeslot and synchronization configuration */ +/*****************************************************************************/ +#define NRF_GZLL_DEFAULT_TIMESLOT_PERIOD 600 ///< Default timeslot period. +#define NRF_GZLL_DEFAULT_TIMESLOTS_PER_CHANNEL 2 ///< Timeslots use by the Host and by the Device when communication is in sync. +#define NRF_GZLL_DEFAULT_DEVICE_CHANNEL_SELECTION_POLICY NRF_GZLL_DEVICE_CHANNEL_SELECTION_POLICY_USE_SUCCESSFUL ///< Default channel Gazell Device channel selection policy +#define NRF_GZLL_DEFAULT_MAX_TX_ATTEMPTS 0 ///< Default maximum TX attempts for each packet. A value of zero implies the infinite number of TX attempts. +#define NRF_GZLL_DEFAULT_XOSC_CTL NRF_GZLL_XOSC_CTL_AUTO ///< Deafult setting for controlling the XOSC +#define NRF_GZLL_DEFAULT_TIMESLOTS_PER_CHANNEL_WHEN_DEVICE_OUT_OF_SYNC 15 ///< Timeslots use by the Device before communication is in sync. +#define NRF_GZLL_DEFAULT_SYNC_LIFETIME (3 * NRF_GZLL_DEFAULT_CHANNEL_TABLE_SIZE * NRF_GZLL_DEFAULT_TIMESLOTS_PER_CHANNEL) ///< Number of timeslots to keep the timer running so that communication remains synchronized. +/** @} */ + +#define NRF_GZLL_PA_LNA_MAX_RAMP_UP_TIME 129 ///< Max external front end ramp up time [us]. +#define NRF_GZLL_PA_LNA_PPI_CHANNELS_NUM 4 ///< Number of PPI channels used for front end control. + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzll_error.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzll_error.h new file mode 100644 index 0000000..6806a1b --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzll_error.h @@ -0,0 +1,72 @@ +/** + * Copyright (c) 2016 - 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. + * + */ +/** + * @file + * @brief Gazell error API. + */ + +#ifndef NRF_GZLL_ERROR_H__ +#define NRF_GZLL_ERROR_H__ + +#include "sdk_errors.h" +#include "nrf_gzll.h" +#include "app_error.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define GAZELLE_ERROR_CODE_CHECK(GZLL_RESULT) \ + do \ + { \ + if ((GZLL_RESULT) == false) \ + { \ + nrf_gzll_error_code_t gzll_error_code = nrf_gzll_get_error_code(); \ + ret_code_t error_code = gzll_error_code + NRF_ERROR_GAZELLE_ERR_BASE; \ + APP_ERROR_HANDLER(error_code); \ + } \ + } while (0) + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzll_resources.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzll_resources.h new file mode 100644 index 0000000..f419b6a --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzll_resources.h @@ -0,0 +1,66 @@ +/** + * 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. + * + */ +#ifndef NRF_GZLL_RESOURCES_H__ +#define NRF_GZLL_RESOURCES_H__ + +#include <stdint.h> + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef GAZELL_ALTERNATIVE_RESOURCES + #define GZLL_PPI_CHANNELS_USED 0x00000007uL /**< PPI channels utilized by Gazell (not available to th spplication). */ + #define GZLL_TIMERS_USED 0x00000004uL /**< Timers used by Gazell. */ + #define GZLL_SWI_USED 0x00000001uL /**< Software interrupts used by Gazell */ +#else + #define GZLL_PPI_CHANNELS_USED 0x00000700uL /**< PPI channels utilized by Gazell (not available to th spplication). */ + #define GZLL_TIMERS_USED 0x00000001uL /**< Timers used by Gazell. */ + #define GZLL_SWI_USED 0x00000002uL /**< Software interrupts used by Gazell */ +#endif + + + + +#ifdef __cplusplus +} +#endif + +#endif /* NRF_GZLL_RESOURCES_H__ */ diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzp.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzp.c new file mode 100644 index 0000000..07e0488 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzp.c @@ -0,0 +1,363 @@ +/** + * Copyright (c) 2009 - 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. + * + */ +/** + * @file + * @brief Implementation of Gazell Pairing Library (gzp), Common functions. + * @defgroup gzp_source_common Gazell Pairing common functions implementation + * @{ + * @ingroup gzp_04_source + */ + + +#include "nrf_gzp.h" +#include "nrf_gzll.h" +#include "nrf_ecb.h" +#include <string.h> + + +#define SOURCE_FILE NRF_SOURCE_FILE_GZP ///< File identifer for asserts. + + +/******************************************************************************/ +/** @name Global variables + * @{ */ +/******************************************************************************/ + +/** + * Constant holding base address part of the pairing address. + */ +static const uint8_t pairing_base_address[4] = { GZP_ADDRESS }; + +/** + * Constant holding prefix byte of the pairing address. + */ +static const uint8_t pairing_address_prefix_byte = 0; + +/** + * Constant holding pre-defined "validation ID". + */ +static const uint8_t gzp_validation_id[GZP_VALIDATION_ID_LENGTH] = GZP_VALIDATION_ID; + +/** + * Constant holding pre-defined "secret key". + */ +static const uint8_t gzp_secret_key[16] = GZP_SECRET_KEY; + +/** + * Variable used for AES key selection + */ +static gzp_key_select_t gzp_key_select; + + +/** @} */ + + +/******************************************************************************/ +/** @name Misc. external variables. + * @{ */ +/******************************************************************************/ +static uint8_t gzp_session_token[GZP_SESSION_TOKEN_LENGTH]; +static uint8_t gzp_dyn_key[GZP_DYN_KEY_LENGTH]; + +/** @} */ + +/******************************************************************************/ +/** @name Implementation common internal GZP functions + * @{ */ +/******************************************************************************/ +bool gzp_update_radio_params(const uint8_t* system_address) +{ + uint8_t i; + uint8_t channels[NRF_GZLL_CONST_MAX_CHANNEL_TABLE_SIZE]; + uint32_t channel_table_size; + uint32_t pairing_base_address_32, system_address_32; + bool update_ok = true; + bool gzll_enabled_state; + + gzll_enabled_state = nrf_gzll_is_enabled(); + + // Configure "global" pairing address + pairing_base_address_32 = (pairing_base_address[0]) + + ((uint32_t)pairing_base_address[1] << 8) + + ((uint32_t)pairing_base_address[2] << 16) + + ((uint32_t)pairing_base_address[3] << 24) ; + if (system_address != NULL) + { + system_address_32 = (system_address[0]) + + ((uint32_t)system_address[1] << 8) + + ((uint32_t)system_address[2] << 16) + + ((uint32_t)system_address[3] << 24) ; + } + else + { + return false; + } + + nrf_gzp_disable_gzll(); + update_ok = update_ok && nrf_gzll_set_base_address_0(pairing_base_address_32); + update_ok = update_ok && nrf_gzll_set_address_prefix_byte(GZP_PAIRING_PIPE, pairing_address_prefix_byte); + update_ok = update_ok && nrf_gzll_set_base_address_1(system_address_32); + + // Configure address for pipe 1 - 5. Address byte set to equal pipe number. + for (i = 1; i < NRF_GZLL_CONST_PIPE_COUNT; i++) + { + update_ok = update_ok && nrf_gzll_set_address_prefix_byte(i,i); + } + + channel_table_size = nrf_gzll_get_channel_table_size(); + gzp_generate_channels(&channels[0], system_address, channel_table_size); + + // Write generated channel subset to Gazell Link Layer + update_ok = update_ok && nrf_gzll_set_channel_table(&channels[0], channel_table_size); + if (gzll_enabled_state) + { + update_ok = update_ok && nrf_gzll_enable(); + } + return update_ok; +} + +void gzp_generate_channels(uint8_t* ch_dst, const uint8_t* system_address, uint8_t channel_tab_size) +{ + uint8_t binsize, spacing, i; + + binsize = (GZP_CHANNEL_MAX - GZP_CHANNEL_MIN) / channel_tab_size; + + ch_dst[0] = GZP_CHANNEL_LOW; + ch_dst[channel_tab_size - 1] = GZP_CHANNEL_HIGH; + + if (system_address != NULL) + { + for (i = 1; i < (channel_tab_size - 1); i++) + { + ch_dst[i] = (binsize * i) + (system_address[i % 4] % binsize); + } + } + + // If channels are too close, shift them to better positions + for (i = 1; i < channel_tab_size; i++) + { + spacing = (ch_dst[i] - ch_dst[i - 1]); + if (spacing < GZP_CHANNEL_SPACING_MIN) + { + ch_dst[i] += (GZP_CHANNEL_SPACING_MIN - spacing); + } + } +} + +__INLINE void nrf_gzp_disable_gzll(void) +{ + if (nrf_gzll_is_enabled()) + { + nrf_gzll_disable(); + __WFI(); + while (nrf_gzll_is_enabled()) + { + } + } +} + +#ifndef GZP_CRYPT_DISABLE + +void gzp_xor_cipher(uint8_t* dst, const uint8_t* src, const uint8_t* pad, uint8_t length) +{ + uint8_t i; + + for (i = 0; i < length; i++) + { + *dst = *src ^ *pad; + dst++; + src++; + pad++; + } +} + +bool gzp_validate_id(const uint8_t* id) +{ + return (memcmp(id, (void*)gzp_validation_id, GZP_VALIDATION_ID_LENGTH) == 0); +} + +void gzp_add_validation_id(uint8_t* dst) +{ + memcpy(dst, (void const*)gzp_validation_id, GZP_VALIDATION_ID_LENGTH); +} + +void gzp_crypt_set_session_token(const uint8_t * token) +{ + memcpy(gzp_session_token, (void const*)token, GZP_SESSION_TOKEN_LENGTH); +} + +void gzp_crypt_set_dyn_key(const uint8_t* key) +{ + memcpy(gzp_dyn_key, (void const*)key, GZP_DYN_KEY_LENGTH); +} + +void gzp_crypt_get_session_token(uint8_t * dst_token) +{ + memcpy(dst_token, (void const*)gzp_session_token, GZP_SESSION_TOKEN_LENGTH); +} + +void gzp_crypt_get_dyn_key(uint8_t* dst_key) +{ + memcpy(dst_key, (void const*)gzp_dyn_key, GZP_DYN_KEY_LENGTH); +} + +void gzp_crypt_select_key(gzp_key_select_t key_select) +{ + gzp_key_select = key_select; +} + +void gzp_crypt(uint8_t* dst, const uint8_t* src, uint8_t length) +{ + uint8_t i; + uint8_t key[16]; + uint8_t iv[16]; + + // Build AES key based on "gzp_key_select" + + switch (gzp_key_select) + { + case GZP_ID_EXCHANGE: + memcpy(key, (void const*)gzp_secret_key, 16); + break; + case GZP_KEY_EXCHANGE: + memcpy(key, (void const*)gzp_secret_key, 16); + gzp_get_host_id(key); + break; + case GZP_DATA_EXCHANGE: + memcpy(key, (void const*)gzp_secret_key, 16); + memcpy(key, (void const*)gzp_dyn_key, GZP_DYN_KEY_LENGTH); + break; + default: + return; + } + + // Build init vector from "gzp_session_token" + for (i = 0; i < 16; i++) + { + if (i < GZP_SESSION_TOKEN_LENGTH) + { + iv[i] = gzp_session_token[i]; + } + else + { + iv[i] = 0; + } + } + + // Set up hal_aes using new key and init vector + (void)nrf_ecb_init(); + nrf_ecb_set_key(key); + //hal_aes_setup(false, ECB, key, NULL); // Note, here we skip the IV as we use ECB mode + + // Encrypt IV using ECB mode + (void)nrf_ecb_crypt(iv, iv); + + // Encrypt data by XOR'ing with AES output + gzp_xor_cipher(dst, src, iv, length); + +} + +void gzp_random_numbers_generate(uint8_t * dst, uint8_t n) +{ + uint8_t i; + + NRF_RNG->EVENTS_VALRDY=0; + NRF_RNG->TASKS_START = 1; + for (i = 0; i < n; i++) + { + while (NRF_RNG->EVENTS_VALRDY==0) + {} + dst[i] = (uint8_t)NRF_RNG->VALUE; + NRF_RNG->EVENTS_VALRDY=0; + } + NRF_RNG->TASKS_STOP = 1; +} + + +/******************************************************************************/ +/** @name Implementation of nRF51 specific GZP functions + * @{ */ +/******************************************************************************/ + +/** +* @brief Function for setting the Primask variable. Only necessary if ARMCC +* compiler skips __set_PRIMASK at high optimization levels. +* +* @param primask The primask value. 1 to disable interrupts, 0 otherwise. +*/ +static void nrf_gzp_set_primask(uint32_t primask) +{ + #if defined(__CC_ARM) + //lint -save -e10 -e618 -e438 -e550 -e526 -e628 -e526 + volatile register uint32_t __regPriMask __ASM("primask"); + __regPriMask = (primask); + #else + __set_PRIMASK(primask); + #endif + //lint -restore +} + +void nrf_gzp_flush_rx_fifo(uint32_t pipe) +{ + static uint8_t dummy_packet[NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH]; + uint32_t length; + + nrf_gzp_set_primask(1); + while (nrf_gzll_get_rx_fifo_packet_count(pipe) >0) + { + length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH; + (void)nrf_gzll_fetch_packet_from_rx_fifo(pipe,dummy_packet,&length); + } + nrf_gzp_set_primask(0); +} +/** @} */ + + + +/******************************************************************************/ +/** @name Implementation of debug functions + * @{ */ +/******************************************************************************/ + + +/** @} */ + +/** @} */ +#endif diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzp.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzp.h new file mode 100644 index 0000000..336151f --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzp.h @@ -0,0 +1,665 @@ +/** + * Copyright (c) 2012 - 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. + * + */ +/** + * @file + * @brief Gazell Pairing API + */ + +#ifndef __GZP_H +#define __GZP_H + +#include "nrf.h" +#include "nrf_gzp_config.h" +#include <stdbool.h> + +#ifdef __cplusplus +extern "C" { +#endif + + +/** +* @defgroup gzp_02_api Gazell Pairing +* @{ +* @ingroup modules_02_gzp +* @brief Gazell Pairing Application Programming Interface (API). +*/ + + +/******************************************************************************/ +/** @name Pairing configuration defines + * @{ */ +/******************************************************************************/ + + +#define GZP_PAIRING_PIPE 0 ///< Pipe reserved for initial pairing communication. +#define GZP_DATA_PIPE 1 ///< Pipe reserved for GZP encrypted data communication (one pipe only). +#define GZP_TX_RX_TRANS_DELAY 10 ///< Time to wait between request and fetch packets in RX_PERIODS (2 timeslot periods) +#define GZP_SYSTEM_ADDRESS_WIDTH 4 ///< Must equal Gazell base address length. + + +#define GZP_VALIDATION_ID {0x32, 0x53, 0x66} ///< Validation ID. Required to be shared by Host and Device. Not a secret. +#define GZP_VALIDATION_ID_LENGTH 3 ///< Validation ID length in bytes. +#define GZP_HOST_ID_LENGTH 5 ///< Host ID length in bytes. +#define GZP_SESSION_TOKEN_LENGTH GZP_HOST_ID_LENGTH ///< Session token length in bytes. +#define GZP_DYN_KEY_LENGTH (16 - GZP_VALIDATION_ID_LENGTH) ///< Dynamic key length in bytes. + +#define GZP_HOST_RX_POWER_THRESHOLD -64 ///< RSSI threshold for when signal strength in RX packet power is high enough. + +/** @} */ + + +/******************************************************************************/ +/** @name Device -> Host packet definitions + * @{ */ +/******************************************************************************/ + +#define GZP_CMD_HOST_ADDRESS_REQ_PAYLOAD_LENGTH 1 ///< "Host address request" packet, payload length + +#define GZP_CMD_HOST_ADDRESS_FETCH_PAYLOAD_LENGTH 1 ///< "Host address fetch" packet, payload length + +#define GZP_CMD_HOST_ID_REQ_SESSION_TOKEN 1 ///< "Host ID request" packet, session token position +#define GZP_CMD_HOST_ID_REQ_PAYLOAD_LENGTH (GZP_CMD_HOST_ID_REQ_SESSION_TOKEN + GZP_SESSION_TOKEN_LENGTH) ///< "Host ID request" payload length + +#if (GZP_CMD_HOST_ID_REQ_PAYLOAD_LENGTH > 17) +#error GZP_SESSION_TOKEN_LENGTH too long. +#endif + + +#define GZP_CMD_HOST_ID_FETCH_VALIDATION_ID 1 ///< "Host ID fetch" packet +#define GZP_CMD_HOST_ID_FETCH_PAYLOAD_LENGTH (GZP_CMD_HOST_ID_FETCH_VALIDATION_ID + GZP_VALIDATION_ID_LENGTH) ///< "Host ID fetch" payload length + +#if (GZP_CMD_HOST_ID_FETCH_PAYLOAD_LENGTH > 17) +#error GZP_VALIDATION_ID_LENGTH set too long. +#endif + +#define GZP_CMD_KEY_UPDATE_PREPARE_PAYLOAD_LENGTH 1 ///< "Key update prepare" payload length + +#define GZP_CMD_KEY_UPDATE_VALIDATION_ID 1 ///< "Key update" packet, validation ID position +#define GZP_CMD_KEY_UPDATE_NEW_KEY (GZP_CMD_KEY_UPDATE_VALIDATION_ID + GZP_VALIDATION_ID_LENGTH) ///< "Key update" packet, new key position +#define GZP_CMD_KEY_UPDATE_PAYLOAD_LENGTH (GZP_CMD_KEY_UPDATE_NEW_KEY + GZP_DYN_KEY_LENGTH) ///< "Key update" packet, payload length + +#if (GZP_CMD_KEY_UPDATE_PAYLOAD_LENGTH > 17) +#error Sum (GZP_VALIDATION_ID_LENGTH + GZP_DYN_KEY_LENGTH) too high. +#endif + + +#define GZP_CMD_ENCRYPTED_USER_DATA_VALIDATION_ID 1 ///< "Encrypted user data" packet, validation ID position +#define GZP_CMD_ENCRYPTED_USER_DATA_PAYLOAD ((GZP_CMD_ENCRYPTED_USER_DATA_VALIDATION_ID + GZP_VALIDATION_ID_LENGTH)) ///< "Encrypted user data" packet, user data position +#define GZP_ENCRYPTED_USER_DATA_PACKET_OVERHEAD ( GZP_CMD_ENCRYPTED_USER_DATA_VALIDATION_ID + GZP_VALIDATION_ID_LENGTH) ///< "Encrypted user data" packet, packet overhead length +#define GZP_ENCRYPTED_USER_DATA_MAX_LENGTH (17 - GZP_ENCRYPTED_USER_DATA_PACKET_OVERHEAD) ///< "Encrypted user data" packet, max payload length + +#if (GZP_MAX_FW_PAYLOAD_LENGTH < 17) + #error GZP_MAX_FW_PAYLOAD_LENGTH must be greater or equal to 17. +#endif + +#define GZP_CMD_FETCH_RESP_PAYLOAD_LENGTH 1 ///< General "fetch response" packet, payload_length + +/** @} */ + + +/******************************************************************************/ +/** @name Host -> Device packet definitions + * @{ */ +/******************************************************************************/ + + +#define GZP_CMD_HOST_ADDRESS_RESP_ADDRESS 1 ///< "Host address fetch" response packet, address position +#define GZP_CMD_HOST_ADDRESS_RESP_PAYLOAD_LENGTH (GZP_CMD_HOST_ADDRESS_RESP_ADDRESS + GZP_SYSTEM_ADDRESS_WIDTH) ///< ///< "Host address fetch" response packet, payload length + +#if (GZP_MAX_ACK_PAYLOAD_LENGTH < GZP_CMD_HOST_ADDRESS_RESP_PAYLOAD_LENGTH) + #error GZP_MAX_ACK_PAYLOAD_LENGTH must be greater or equal to GZP_CMD_HOST_ADDRESS_RESP_PAYLOAD_LENGTH. +#endif + + +#define GZP_CMD_HOST_ID_FETCH_RESP_VALIDATION_ID 1 ///< "Host ID fetch" response packet, validation ID position +#define GZP_CMD_HOST_ID_FETCH_RESP_STATUS (GZP_CMD_HOST_ID_FETCH_RESP_VALIDATION_ID + GZP_VALIDATION_ID_LENGTH) ///< "Host ID fetch" response packet, status position +#define GZP_CMD_HOST_ID_FETCH_RESP_HOST_ID (GZP_CMD_HOST_ID_FETCH_RESP_STATUS + 1) ///< "Host ID fetch" response packet, Host ID position +#define GZP_CMD_HOST_ID_FETCH_RESP_PAYLOAD_LENGTH (GZP_CMD_HOST_ID_FETCH_RESP_HOST_ID + GZP_HOST_ID_LENGTH) ///< "Host ID fetch" response packet, payload length + +#if (GZP_MAX_ACK_PAYLOAD_LENGTH < GZP_CMD_HOST_ID_FETCH_RESP_PAYLOAD_LENGTH) + #error GZP_MAX_ACK_PAYLOAD_LENGTH must be greater or equal to GZP_CMD_HOST_ID_FETCH_RESP_PAYLOAD_LENGTH. +#endif + + +#define GZP_CMD_KEY_UPDATE_PREPARE_RESP_SESSION_TOKEN 1 ///< "Key update prepare" response packet, session token position +#define GZP_CMD_KEY_UPDATE_PREPARE_RESP_PAYLOAD_LENGTH (GZP_CMD_KEY_UPDATE_PREPARE_RESP_SESSION_TOKEN + GZP_SESSION_TOKEN_LENGTH) ///< "Key update prepare" response packet, payload length position + +#if (GZP_MAX_ACK_PAYLOAD_LENGTH < GZP_CMD_KEY_UPDATE_PREPARE_RESP_PAYLOAD_LENGTH) + #error GZP_MAX_ACK_PAYLOAD_LENGTH must be greater or equal to GZP_CMD_KEY_UPDATE_PREPARE_RESP_PAYLOAD_LENGTH. +#endif + + +#define GZP_CMD_ENCRYPTED_USER_DATA_RESP_SESSION_TOKEN 1 ///< "Encrypted user data" response packet, session token position +#define GZP_CMD_ENCRYPTED_USER_DATA_RESP_VALIDATION_ID (GZP_CMD_ENCRYPTED_USER_DATA_RESP_SESSION_TOKEN + GZP_SESSION_TOKEN_LENGTH) ///< "Encrypted user data" response packet, validation ID position +#define GZP_CMD_ENCRYPTED_USER_DATA_RESP_PAYLOAD_LENGTH (GZP_CMD_ENCRYPTED_USER_DATA_RESP_VALIDATION_ID + GZP_VALIDATION_ID_LENGTH) ///< "Encrypted user data" response packet, payload length position + +#if (GZP_MAX_ACK_PAYLOAD_LENGTH < GZP_CMD_ENCRYPTED_USER_DATA_RESP_PAYLOAD_LENGTH) + #error GZP_MAX_ACK_PAYLOAD_LENGTH must be greater or equal to GZP_CMD_ENCRYPTED_USER_DATA_RESP_PAYLOAD_LENGTH. +#endif + +#if (GZP_VALIDATION_ID_LENGTH > GZP_HOST_ID_LENGTH) + #error GZP_HOST_ID_LENGTH should be greater or equal to GZP_VALIDATION_ID_LENGTH. +#endif + +#if (GZP_SESSION_TOKEN_LENGTH != GZP_HOST_ID_LENGTH) + #error GZP_SESSION_TOKEN_LENGTH must equal GZP_HOST_ID_LENGTH. +#endif + +#ifdef GZLL_CRYPT_ENABLE + #error Gazell encryption can not be enabled when using the Gazell pairing library. \ + GZLL_CRYPT_ENABLE must be undefined. +#endif + +/** @} */ + + +/******************************************************************************/ +/** @name Typedefs + * @{ */ +/******************************************************************************/ + + +/** + * @enum gzp_key_select_t + * @brief Enumerator used for selecting the key to be used for encryption. + */ +typedef enum +{ + GZP_ID_EXCHANGE, ///< "Secret key" only + GZP_KEY_EXCHANGE, ///< "Secret key" and "Host ID" + GZP_DATA_EXCHANGE ///< "Dynamic key" and "Host ID" +} gzp_key_select_t; + + +/** + * @enum gzp_cmd_t + * @brief Enumerator used in the first payload byte of each packet to + * indicate the packet type. + */ +typedef enum +{ + GZP_CMD_HOST_ADDRESS_REQ = 0, ///< Host address request + GZP_CMD_HOST_ADDRESS_FETCH, ///< Host address fetch + GZP_CMD_HOST_ID_REQ, ///< Host ID request + GZP_CMD_HOST_ID_FETCH, ///< Host ID fetch request + GZP_CMD_KEY_UPDATE_PREPARE, ///< Key update prepare + GZP_CMD_KEY_UPDATE, ///< Key update + GZP_CMD_ENCRYPTED_USER_DATA, ///< Encrypted user data + GZP_CMD_FETCH_RESP, ///< Fetch response + GZP_CMD_HOST_ADDRESS_RESP, ///< Host address response + GZP_CMD_HOST_ID_FETCH_RESP, ///< Host ID fetch response + GZP_CMD_KEY_UPDATE_PREPARE_RESP, ///< Key update prepare + GZP_CMD_ENCRYPTED_USER_DATA_RESP, ///< Encrypted user data response +} gzp_cmd_t; + + +/** + * @enum gzp_id_req_res_t + * @brief Enumerator used to identify the state of the current + * Host ID request. + */ +typedef enum +{ + GZP_ID_RESP_PENDING, ///< ID response pending + GZP_ID_RESP_GRANTED, ///< ID response granted + GZP_ID_RESP_REJECTED, ///< ID response rejected + GZP_ID_RESP_FAILED, ///< ID response failed + GZP_ID_RESP_NO_REQUEST ///< Default value. No ID request has yet been received. +} gzp_id_req_res_t; + + +/** @} */ + + +/******************************************************************************/ +/** @name Misc. function prototypes + * @{ */ +/******************************************************************************/ + +/** + * Set the session token. + * + * @param token Pointer to the session token to set. + */ +void gzp_crypt_set_session_token(const uint8_t *token); + + +/** + * Get the session token. + * + * @param dst_token Pointer to write the session token. + */ +void gzp_crypt_get_session_token(uint8_t *dst_token); + + +/** + * Set the dynamic key. + * + * @param dyn_key Pointer to the dynamic key to set. + */ +void gzp_crypt_set_dyn_key(const uint8_t* dyn_key); + + +/** + * Get the dynamic key. + * + * @param dst_key Pointer to write the dynamic key too. + */ +void gzp_crypt_get_dyn_key(uint8_t *dst_key); + + +/** + * Set the Host ID. + * + * @param src Pointer to the Host ID to set. + */ +static void gzp_set_host_id(const uint8_t* src); + + +/** + * Get the Host ID. + * + * @param dst Pointer to write the Host ID to. + */ +void gzp_get_host_id(uint8_t *dst); + + +/** + * Selecting what key-set that should be used when encrypting data + * using gzp_crypt(). + * + * @param key_select Key-set to use. + */ +void gzp_crypt_select_key(gzp_key_select_t key_select); + + +/** + * Encypt / decrypt data. + * + * The current "session token" will be used as initialization vector (IV). + * The AES key to be used is selected by gzp_crypt_select_key(). + * AES is a symmetric encryption scheme, this function can be used + * to perform both encryption and decryption. + * + * @param dst Destination to write encrypted data to. Should be 16 bytes long. + * @param src Source data to encrypt. + * @param length Length in bytes of src. + */ +void gzp_crypt(uint8_t* dst, const uint8_t* src, uint8_t length); + + +/** + * Compare the *src_id with a pre-defined validation ID. + * + * @param src_id Pointer to the source validation ID to compare to. + * + * @retval true If *src_id equals the pre-defined ID. + * @retval false If *src_id does not equal the pre-defined ID. + */ +bool gzp_validate_id(const uint8_t *src_id); + + +/** + * Add the pre-defined validation ID to dst_id. + * GZP_VALIDATION_ID_LENGTH bytes will be added. + * + * @param dst_id Pointer to add the GZP validation ID to. + */ +void gzp_add_validation_id(uint8_t *dst_id); + + +/** + * Generate random bytes. + * + * @param dst Destination to write the random bytes to. + * @param n Number of bytes to generate. + */ +void gzp_random_numbers_generate(uint8_t *dst, uint8_t n); + + +/** + * Update the channel table and the system address. + * + * The channel table is updated to pseudo-random set generated using the + * system address. The channel table still includes GZP_CHANNEL_MAX and + * GZP_CHANNEL_MIN. + * The system address is applied to base address 1 and therefore applies + * to pipes 1-7. + * + * @param system_address Pointer to the system_address to set. + * + * @retval true If theradio parameters were updated successfully. + * @retval false If there was an error updated the radio parameters. + */ +bool gzp_update_radio_params(const uint8_t *system_address); + + +/** + * Generate a set of channels from a 4 byte address. + * + * @param ch_dst Destination to write the channel set to. The channel set + * includes GZP_CHANNEL_MAX and GZP_CHANNEL_MIN. + * @param address Four byte address to generate the channel set from. + * @param channel_set_size Size of the channel set to generate. + */ +void gzp_generate_channels(uint8_t *ch_dst, const uint8_t * address, uint8_t channel_set_size); + + +/** + * Perform an XOR on two byte strings. + * + * @param dst Destination to write the result to. Should be of size length. + * @param src + * @param pad + * @param length Number of bytes to perform the XOR operation on. + */ +void gzp_xor_cipher(uint8_t* dst, const uint8_t* src, const uint8_t* pad, uint8_t length); + + +/******************************************************************************/ +/** @name Common Device and Host functions + * @{ */ +/******************************************************************************/ + + +/** + * Initialization function. This function initializes the Gazell Pairing Library. + + * This function must be called before any of the other Gazell Pairing Library functions are + * used and must be called @b after gzll_init() is called. + * + */ +void gzp_init(void); + +/** + * Function for erasing all pairing data. + */ +void gzp_erase_pairing_data(void); + +/** + * Disable Gazell and sleep while waiting for nrf_gzll_disabled callback. + */ +void nrf_gzp_disable_gzll(void); + +/** + Function for cancelling an ongoing (pending) "Host ID request". + + After calling this function the "Host ID request" status will go to + "ID request Idle". +*/ +void gzp_id_req_cancel(void); + +/** + * Flush the GZLL RX FIFO for a specific pipe while GZLL is disabled. + * + * @param pipe Pipe. + */ +void nrf_gzp_flush_rx_fifo(uint32_t pipe); + +/** +@name Device functions +*/ + +/** + * Check whether current GZP packet transaction has completed. + * + * @retval true + * @retval false + */ +bool nrf_gzp_tx_complete(void); + +/** + * Check whether previous GZP packet transaction was successful. + * + * @retval true + * @retval false + */ +bool nrf_gzp_tx_success(void); + +/** + * Reset tx_complete status. + */ +void nrf_gzp_reset_tx_complete(void); + +/** + * Reset tx_success status. + */ +void nrf_gzp_reset_tx_success(void); + +/** +* Function to check whether a Device has existing pairing data, implying that it is +* paired to a Host. +* +* @retval -2 The pairing database is empty. +* @retval -1 The device has a system address but no Host ID. +* @retval >=0 The device has a system address and HostID at this index value in the database. +*/ +int8_t gzp_get_pairing_status(void); + +/** + Function for sending a "system address" request to a Host. + + When calling this function the Device will attempt acquiring the "system address" from + any Host within close proximity. + + If a host is located within close proximity and pairing is enabled in the Host, + a "system address" will be sent in return to the Device. + + The new "system address" will apply immediately in the Device, and the new "system address" + will be stored in non volatile (NV) memory. + + Note. Using OTP devices limits the number of times a new "system address" can + be stored in NV memory. + + @return + + @retval true if new "system address" was received from a Host. + @retval false if no "system address" was received from a Host. +*/ +bool gzp_address_req_send(void); + +/** + Function for sending a "Host ID request" to a Host. + + The "Host ID" is needed to be able to send encrypted data using + gzp_crypt_data_send(). + + The request will be sent using the "system address" previously received using + gzp_address_req_send(). + + It is not required that the Host is within close proximity in order to acquire the + "Host ID". + + The new "Host ID" will apply immediately for the Device, and the new "Host ID" + will be stored in non volatile (NV) memory. + + Note. Using OTP devices limits the number of times a new "Host ID" can + be stored in NV memory. + + @return + + @retval GZP_ID_RESP_PENDING if a "Host ID request" has been sent to the Host, but the Host application has + not yet decided whether to Grant or Reject the "ID request". + @retval GZP_ID_RESP_GRANTED if the "Host ID" has been received from the Host. The received "Host ID" will be stored + in non volatile memory. + @retval GZP_ID_RESP_REJECTED if the Host application has rejected the "Host ID request". + @retval GZP_ID_RESP_FAILED if failing to send a request or receive a response from the Host. +*/ +gzp_id_req_res_t gzp_id_req_send(void); + +/** + Function for sending encrypted user data to the Host. + + Before any data can be sent the Device must acquire both the Host's + "system address" by using gzp_address_req_send() and the "Host ID" by using + gzp_id_req_send(). + + @param *src is a pointer to the data packet to be sent. + @param length is the length of the data packet to be sent. + + + @return + @retval true if the data was successfully transmitted and decrypted by the Host. + @retval false if data transmission failed or Host failed to decryption data correctly. +*/ +bool gzp_crypt_data_send(const uint8_t *src, uint8_t length); + + +/** +@name Host functions +*/ + +/** + Function for enabling/disabling pairing in a host. When pairing is enabled the host will + be monitoring for "system address" and "Host ID" requests from Devices. + + A "system address request" received from a Device will always be granted. + When a "host ID request" has been received, the Host application have to grant, + reject or cancel this by using one of the following functions: + + - gzp_id_req_grant() + - gzp_id_req_reject() + - gzp_id_req_cancel() + + @param enable + @arg true enables pairing. + @arg false disables pairing. +*/ +void gzp_pairing_enable(bool enable); + +/** + * Execute the Gazell Pairing Library Host operation. + * + * This function must be called regularly by the Host application. + */ +void gzp_host_execute(void); + +/** + * Address exchanged check. + * + * @retval true If a "system address" was delivered to a requesting Device during the + * previous call to gzp_host_execute(); + * @retval false Otherwise. +*/ +bool gzp_address_exchanged(void); + +/** + Function for checking if a "Host ID request" has been received from a Device. + + If a request has been received, the Pairing library will enter "ID request pending" + state. + + The application is responsible for responding to this request by calling + one of the following functions: + + - gzp_id_req_grant() + - gzp_id_req_reject() + - gzp_id_req_cancel() + + @retval true if a "Host ID request" has been received (internal state is "ID request pending") + @retval false if no "Host ID request" has been received (internal state is "ID request idle") +*/ +bool gzp_id_req_received(void); + +/** + Function for rejecting the previously received "Host ID request". This function should be called + only when a "Host ID request" has been received (internal state is "ID request pending"). + + The internal state of the Pairing library will remain "ID request pending" until the a "reject" message + has been successfully transmitted to the requesting Device. After this the internal state will + change to "ID request idle". +*/ +void gzp_id_req_reject(void); + +/** + * Function for granting the previously received "Host ID request". This function should be called + only when a "Host ID request" has been received (internal state is "ID request pending"). + + The internal state of the Pairing library will remain "ID request pending" until the "Host ID" has + been successfully transmitted to the requesting Device. After this the internal state will + change to "ID request idle". +*/ +void gzp_id_req_grant(void); + + +/** + * Check if user data has been received. + * + * @retval true If encrypted user data has been received. + * @retval false Otherwise. +*/ +bool gzp_crypt_user_data_received(void); + +/** + Function for reading encrypted user data. + + Note that the read user data will be automatically decrypted. Only data + that was decrypted correctly will be presented. + + @param dst* is a pointer to where the received data will be written. + @param length* is a pointer for returning the number of bytes received. Only 1 byte will + be writtem to length*. + + @return + @retval true if data has been received and is written to dst* + @retval false if no data has been received. +*/ +bool gzp_crypt_user_data_read(uint8_t* dst, uint8_t* length); + + +/** + Function emulating behavior of gzll_rx_start() in legeacy nRF24xx Gaell + linbrary. + + This functions sets Gazell in Host mode and starts reception (enable). +*/ +void gzll_rx_start(void); + + +/** @} */ +/** @} */ +/** @} */ + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzp_device.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzp_device.c new file mode 100644 index 0000000..7ee4037 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzp_device.c @@ -0,0 +1,1146 @@ +/** + * Copyright (c) 2009 - 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. + * + */ +/** + * @file + * @brief Implementation of Gazell Pairing Library (gzp), Device functions. + * @defgroup gzp_source_device Gazell Pairing Device implementation. + * @{ + * @ingroup gzp_04_source + */ + + +#include <stdint.h> +#include <stdbool.h> +#include <string.h> + +#include "nrf_gzll.h" +#include "nrf_gzp.h" +#include "nrf_delay.h" +#include "nrf_nvmc.h" + +#define SOURCE_FILE NRF_SOURCE_FILE_GZP_DEVICE ///< File identifer for asserts. + +/******************************************************************************/ +/** @name Misc. defines + * @{ */ +/******************************************************************************/ + +#define GZP_PARAMS_DB_ELEMENT_SYSTEM_ADDRESS 0 ///< System address position. +#define GZP_PARAMS_DB_ELEMENT_HOST_ID (GZP_PARAMS_DB_ELEMENT_SYSTEM_ADDRESS + GZP_SYSTEM_ADDRESS_WIDTH) ///< Host ID position +#define GZP_PARAMS_DB_ELEMENT_SIZE (GZP_SYSTEM_ADDRESS_WIDTH + GZP_HOST_ID_LENGTH)///< Total size +#define GZP_PARAMS_DB_MAX_ENTRIES 14 ///< Maximum allowed entries in the database. + +/** @} */ + +/******************************************************************************/ +/** @name Derived parameters + * @{ */ +/******************************************************************************/ + +//lint -esym(40, GZP_PARAMS_STORAGE_ADR) "Undeclare identifier" +#define GZP_PARAMS_DB_ADR GZP_PARAMS_STORAGE_ADR ///< +#define GZP_PARAMS_DB_SIZE (GZP_PARAMS_DB_MAX_ENTRIES * GZP_PARAMS_DB_ELEMENT_SIZE) ///< + +#define GZP_INDEX_DB_ADR (GZP_PARAMS_STORAGE_ADR + GZP_PARAMS_DB_SIZE) ///< +#define GZP_INDEX_DB_SIZE (GZP_DEVICE_PARAMS_STORAGE_SIZE - GZP_PARAMS_DB_SIZE) ///< + +#if (GZP_DEVICE_PARAMS_STORAGE_SIZE < GZP_PARAMS_DB_SIZE) + #error GZP_DEVICE_PARAMS_STORAGE_SIZE must be greater or equal to GZP_PAIRING_PARAMS_DB_SIZE +#elif (GZP_DEVICE_PARAMS_STORAGE_SIZE == GZP_PARAMS_DB_SIZE ) + #warning GZP_DEVICE_PARAMS_STORAGE_SIZE to low to be able store any pairing parameters NV memory +#endif +/** @} */ + + +/******************************************************************************/ +/** @name Typedefs + * @{ */ +/******************************************************************************/ + + +/** + * Possible return values for the function gzp_tx_rx_transaction() + */ +typedef enum +{ + GZP_TX_RX_SUCCESS, ///< ACK received. Transaction successful. + GZP_TX_RX_FAILED_TO_SEND, ///< + GZP_TX_RX_NO_RESPONSE ///< +} gzp_tx_rx_trans_result_t; +/** @} */ + + +/******************************************************************************/ +/** @name Internal variables + * @{ */ +/******************************************************************************/ + +static uint8_t gzp_system_address[GZP_SYSTEM_ADDRESS_WIDTH]; ///< +static uint8_t gzp_host_id[GZP_HOST_ID_LENGTH]; ///< +static uint8_t dyn_key[GZP_DYN_KEY_LENGTH]; +static bool gzp_id_req_pending = false; + +/** @} */ + + +/******************************************************************************/ +/** @name Internal (static) function prototypes + * @{ */ +/******************************************************************************/ + +/** + * Function for sending an encrypted packet. + * + * The function waits for the transmission to complete. + * + * @param tx_packet Pointer to the packet to be sent. + * @param length Length of the packet to be sent. + * @param pipe Pipe on which the packet should be sent. + * + * @retval true If the transmission succeeded. + * @retval false If the transmission failed (timed out). + */ +static bool gzp_tx_packet(const uint8_t* tx_packet, uint8_t length, uint8_t pipe); + +/** + * Function sending the packet *tx_packet and a subsequent packet fetching the response + * to *tx_packet. + * + * @param tx_packet is a pointer to the packet to be sent. + * @param tx_length is the length of the packet to be sent. + * @param rx_dst is a pointer to where the received response packet should be stored. + * @param rx_length is a pointer to where the length of the received packet should be stored. + * @param pipe is the pipe on which the packet should be sent. + * + * @return result of the transaction. + */ + static gzp_tx_rx_trans_result_t gzp_tx_rx_transaction(const uint8_t *tx_packet, uint8_t tx_length, uint8_t *rx_dst, uint32_t *rx_length, uint8_t pipe); + +/** + * Function for sending an encrypted packet. The function detects whether the correct + * key was used, and attempts to send a "key update" to the host if the wrong key was being + * used. + + * @param tx_packet is a pointer to the packet to be sent. + * @param length is the length of the packet to be sent. + + * @retval true if transmission succeeded and packet was decrypted correctly by host. + * @retval false if transmission failed or packet was not decrypted correctly by host. + */ +static bool gzp_crypt_tx_transaction(const uint8_t *tx_packet, uint8_t length); + +/** + * Function updateing the "dynamic key" and sending a "key update" to the host. + * + * @retval true if key update succeeded. + * @retval false if if key update failed. + */ +static bool gzp_key_update(void); + +/** + * Function for adding an element to "parameters data base" in non volatile (NV) memory. An element is + * GZP_PARAMS_ELEMENT_SYSTEM_ADDRESS bytes long, holding the "system address" and "host ID". + * + * The "parameters data base" can store up to GZP_DEVICE_PAIRING_PARAMS_DB_MAX_ENTRIES + * elements. + * + * @param src_element is a pointer to the element. + * @param index is a number between 0 and (GZP_PARAMS_DB_MAX_ENTRIES - 1) + * selecting the location in which the element will be stored. + */ +static void gzp_params_db_add(const uint8_t *src_element, uint8_t index); + +/** + * Function for reading an element from "parameters data base" in non volatile (NV) memory. An element is + * GZP_PARAMS_ELEMENT_SYSTEM_ADDRESS bytes long, holding the "system address" and "host ID". + * + * @param dst_element is a pointer where the read element should be stored. + * @param index is a number between 0 and (GZP_PARAMS_DB_MAX_ENTRIES - 1). + * selecting the location that should be read. + */ +static void gzp_params_db_read(uint8_t* dst_element, uint8_t index); + +/** + * Function for writing an index to the "index data base" in non volatile (NV) memory. + * + * @param index is the index to be written to the data base. + */ +static void gzp_index_db_add(uint8_t index); + +/** + * Function for reading the index previously written to the "index data base" in NV memory. + * + * @return + */ +static uint8_t gzp_index_db_read(void); + +/** + * Check "index data base" is full. + * + * @retval true + * @retval false + */ +static bool gzp_index_db_full(void); + +/** + * Function returning @b true if the "index data base" is empty. + * + * @retval true + * @retval false + */ +static bool gzp_index_db_empty(void); + +/** + * Function returning @b true if array contains only 1s (0xff). + * + * @param *src is a pointer to the array to be evaluated. + * @param length is the length of the array to be evaluated. + * + * @retval true + * @retval false + */ +static bool gzp_array_is_set(const uint8_t* src, uint8_t length); + +/** + * Function for storing the current "system address" and "host ID" in NV memory. + * + * @param store_all selects whether only "system address" or both "system address" and + * "host ID" should be stored. + * @arg true selects that both should be stored. + * @arg false selects that only "system address" should be stored. + * + * @retval true + * @retval false + */ +static bool gzp_params_store(bool store_all); + +/** + * Restore the "system address" and "host ID" from NV memory. + * @retval true + * @retval false + */ +static bool gzp_params_restore(void); + +/** + * Delay function. Will add a delay equal to GZLL_RX_PERIOD * rx_periods [us]. + * + * @param rx_periods + */ +void gzp_delay_rx_periods(uint32_t rx_periods); + +/** + * Delay function. Will add a delay equal to GZLL_RX_PERIOD * rx_periods [us] using the + * gazell timer and not a delay loop. + * + * @param rx_periods + */ +void gzp_tick_sleep_rx_periods(uint32_t rx_periods); + +/* + * Print debug string. By default does nothing. + * + * If GZP_DEBUG is defined then the print string function is required to + * be implemented. + */ +void print_string(char* p_expr); + +/** @} */ + +/******************************************************************************/ +/** @name Internal (static) variables + * @{ */ +/******************************************************************************/ + +static nrf_gzll_device_tx_info_t latest_tx_info; ///< Information about the last TX attempt, e.g. RSSI of ACK. + +static volatile bool tx_complete; ///< Flag to indicate whether a GZLL TX attempt has completed. +static bool tx_success; ///< Flag to indicate whether a GZLL TX attempt was successful. + +// Define Macro to make array initialization nicer +#define REP4(X) X X X X + +#if defined(__ICCARM__) + #if GZP_PARAMS_DB_ADR == 0x1000 + static const uint32_t database[GZP_DEVICE_PARAMS_STORAGE_SIZE/4] @ "gzp_dev_data" + #elif GZP_PARAMS_DB_ADR == 0x15000 + static const uint32_t database[GZP_DEVICE_PARAMS_STORAGE_SIZE/4] @ "gzp_dev_data_sd" + #else + #error + #endif +#else +static const uint32_t database[GZP_DEVICE_PARAMS_STORAGE_SIZE / 4] __attribute__((at(GZP_PARAMS_DB_ADR))) +#endif += { + #define STATIC_INIT_VALUE 0xFFFFFFFF + #define STATIC_INIT_COUNT (GZP_DEVICE_PARAMS_STORAGE_SIZE / 4) + #define INIT_1 STATIC_INIT_VALUE, + #define INIT_4 REP4(INIT_1) + #define INIT_16 REP4(INIT_4) + #define INIT_64 REP4(INIT_16) + #define INIT_256 REP4(INIT_64) + #define INIT_1024 REP4(INIT_256) + + #if (STATIC_INIT_COUNT == 256) + INIT_256 + #elif (STATIC_INIT_COUNT == 1024) + INIT_1024 + #else + #error Gazell Pairing Library database not initialized properly! + #endif +}; ///< Database for storing keys. + + +/** @} */ + + +/******************************************************************************/ +// Implementation: Device-specific API functions +/******************************************************************************/ + + +void gzp_init() +{ + gzp_id_req_pending = false; + +#ifndef GZP_NV_STORAGE_DISABLE + (void)gzp_params_restore(); +#endif + + // Update radio parameters from gzp_system_address + (void)gzp_update_radio_params(gzp_system_address); +} + + +void gzp_erase_pairing_data(void) +{ + // Erase database flash page so that it can be later written to. + nrf_nvmc_page_erase((uint32_t)database); +} + +bool gzp_address_req_send() +{ + //lint -save -e514 Unusual use of a Boolean expression (gzll_update_ok &= ...) + uint8_t i; + bool retval = false; + bool success; + uint8_t address_req[GZP_CMD_HOST_ADDRESS_REQ_PAYLOAD_LENGTH]; + uint8_t rx_payload[NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH]; + uint32_t rx_payload_length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH; + nrf_gzll_tx_power_t temp_power; + uint32_t temp_max_tx_attempts; + bool gzll_update_ok = true; + + + // Store parameters that are temporarily changed + temp_max_tx_attempts = nrf_gzll_get_max_tx_attempts(); + temp_power = nrf_gzll_get_tx_power(); + + // Modify parameters + nrf_gzp_disable_gzll(); + nrf_gzll_set_max_tx_attempts(GZP_REQ_TX_TIMEOUT); + gzll_update_ok &= nrf_gzll_set_tx_power(GZP_POWER); + + // Flush RX FIFO + gzll_update_ok &= nrf_gzll_flush_rx_fifo(GZP_PAIRING_PIPE); + gzll_update_ok &= nrf_gzll_enable(); + // Build "request" packet + address_req[0] = (uint8_t)GZP_CMD_HOST_ADDRESS_REQ; + + // Send a number of packets in order to broadcast that devices not within + // close proximity must back off. + for (i = 0; i < GZP_MAX_BACKOFF_PACKETS; i++) + { + success = gzp_tx_packet(address_req, GZP_CMD_HOST_ADDRESS_REQ_PAYLOAD_LENGTH, GZP_PAIRING_PIPE); + if (success) + { + nrf_gzp_flush_rx_fifo(GZP_PAIRING_PIPE); + } + else + { + break; + } + } + + gzp_delay_rx_periods(GZP_TX_ACK_WAIT_TIMEOUT); + // Send message for fetching pairing response from host. + address_req[0] = (uint8_t)GZP_CMD_HOST_ADDRESS_FETCH; + + success = gzp_tx_packet(address_req, GZP_CMD_HOST_ADDRESS_REQ_PAYLOAD_LENGTH, GZP_PAIRING_PIPE); + if (success && latest_tx_info.payload_received_in_ack) + { + // If pairing response received + if (nrf_gzll_get_rx_fifo_packet_count(GZP_PAIRING_PIPE) > 0) + { + rx_payload_length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH; //dummy placeholder + if (nrf_gzll_fetch_packet_from_rx_fifo(GZP_PAIRING_PIPE, rx_payload, &rx_payload_length)) + { + if (rx_payload[0] == (uint8_t)GZP_CMD_HOST_ADDRESS_RESP) + { + memcpy(gzp_system_address, &rx_payload[GZP_CMD_HOST_ADDRESS_RESP_ADDRESS], GZP_SYSTEM_ADDRESS_WIDTH); + gzll_update_ok &= gzp_update_radio_params(&rx_payload[GZP_CMD_HOST_ADDRESS_RESP_ADDRESS]); + #ifndef GZP_NV_STORAGE_DISABLE + (void)gzp_params_store(false); // "False" indicates that only "system address" part of DB element will be stored + #endif + retval = true; + } + } + } + } + else + { + gzp_delay_rx_periods(GZP_NOT_PROXIMITY_BACKOFF_RX_TIMEOUT - GZP_TX_ACK_WAIT_TIMEOUT); + } + gzp_delay_rx_periods(GZP_STEP1_RX_TIMEOUT); + + // Clean-up and restore parameters temporarily modified + nrf_gzp_disable_gzll(); + gzll_update_ok &= nrf_gzll_flush_rx_fifo(GZP_PAIRING_PIPE); + gzll_update_ok &= nrf_gzll_flush_tx_fifo(GZP_PAIRING_PIPE); + nrf_gzll_set_max_tx_attempts(temp_max_tx_attempts); + gzll_update_ok &= nrf_gzll_set_tx_power(temp_power); + gzll_update_ok &= nrf_gzll_enable(); + + if (!gzll_update_ok) + { + /* + The update of the Gazell parameters failed. Use nrf_gzll_get_error_code() + to investigate the cause. + */ + } + + return retval; + //lint -restore +} + +#ifndef GZP_CRYPT_DISABLE + +gzp_id_req_res_t gzp_id_req_send() +{ + uint8_t tx_packet[GZP_CMD_HOST_ID_REQ_PAYLOAD_LENGTH]; + uint8_t rx_packet[GZP_MAX_ACK_PAYLOAD_LENGTH]; + gzp_tx_rx_trans_result_t trans_result; + + // If no ID request is pending, send new "ID request" + if (!gzp_id_req_pending) + { + // Build "Host ID request packet" + tx_packet[0] = (uint8_t)GZP_CMD_HOST_ID_REQ; + + // Generate new session token + gzp_random_numbers_generate(&tx_packet[GZP_CMD_HOST_ID_REQ_SESSION_TOKEN], GZP_SESSION_TOKEN_LENGTH); + + // Send "Host ID request" + if (gzp_tx_packet(tx_packet, GZP_CMD_HOST_ID_REQ_PAYLOAD_LENGTH, GZP_DATA_PIPE)) + { + // Update session token if "Host ID request" was successfully transmitted + gzp_crypt_set_session_token(&tx_packet[GZP_CMD_HOST_ID_REQ_SESSION_TOKEN]); + gzp_id_req_pending = true; + + return GZP_ID_RESP_PENDING; + } + } + else // If "ID request is pending" send "fetch ID" packet + { + // Build "host ID fetch" packet + tx_packet[0] = (uint8_t)GZP_CMD_HOST_ID_FETCH; + gzp_add_validation_id(&tx_packet[GZP_CMD_HOST_ID_FETCH_VALIDATION_ID]); + + // Encrypt "host ID fetch" packet + gzp_crypt_select_key(GZP_ID_EXCHANGE); + gzp_crypt(&tx_packet[1], &tx_packet[1], GZP_CMD_HOST_ID_FETCH_PAYLOAD_LENGTH - 1); + + trans_result = gzp_tx_rx_transaction(tx_packet, GZP_CMD_HOST_ID_FETCH_PAYLOAD_LENGTH, rx_packet, NULL, GZP_DATA_PIPE); + // If packet was successfully sent AND a response packet was received + if (trans_result == GZP_TX_RX_SUCCESS) + { + // Validate response packet + if (rx_packet[0] == (uint8_t)GZP_CMD_HOST_ID_FETCH_RESP) + { + gzp_crypt(&rx_packet[1], &rx_packet[1], GZP_CMD_HOST_ID_FETCH_RESP_PAYLOAD_LENGTH - 1); + if (gzp_validate_id(&rx_packet[GZP_CMD_HOST_ID_FETCH_RESP_VALIDATION_ID])) + { + switch (rx_packet[GZP_CMD_HOST_ID_FETCH_RESP_STATUS]) + { + case GZP_ID_RESP_PENDING: + break; + case GZP_ID_RESP_REJECTED: + gzp_id_req_pending = false; + break; + case GZP_ID_RESP_GRANTED: + gzp_set_host_id(&rx_packet[GZP_CMD_HOST_ID_FETCH_RESP_HOST_ID]); + gzp_random_numbers_generate(dyn_key, GZP_DYN_KEY_LENGTH); + gzp_crypt_set_dyn_key(dyn_key); + #ifndef GZP_NV_STORAGE_DISABLE + (void)gzp_params_store(true); + #endif + gzp_id_req_pending = false; + break; + default: + break; + } + + return (gzp_id_req_res_t)rx_packet[GZP_CMD_HOST_ID_FETCH_RESP_STATUS]; + } + else + { + gzp_id_req_pending = false; + return GZP_ID_RESP_REJECTED; + } + } + } + } + + gzp_id_req_pending = false; + return GZP_ID_RESP_FAILED; +} + +void gzp_id_req_cancel() +{ + gzp_id_req_pending = false; +} + +bool gzp_crypt_data_send(const uint8_t *src, uint8_t length) +{ + if (length <= GZP_ENCRYPTED_USER_DATA_MAX_LENGTH) + { + if (gzp_crypt_tx_transaction(src, length)) + { + return true; + } + else + { + //print_string("GZP_CRYPT_TX failed\r\n"); + // Attempt key update if user data transmission failed + // during normal operation (!gzp_id_req_pending) + if (!gzp_id_req_pending) + { + //print_string("KEY UPDATE\r\n"); + if (gzp_key_update()) + { + return gzp_crypt_tx_transaction(src, length); + } + } + return false; + } + } + else + { + return false; + } +} + +#endif +/** @} */ + + +/******************************************************************************/ +// Implementation: Internal (static) functions +/******************************************************************************/ + +static bool gzp_tx_packet(const uint8_t* tx_packet, uint8_t length, uint8_t pipe) +{ + tx_complete = false; + tx_success = false; + + if (nrf_gzll_add_packet_to_tx_fifo(pipe,(uint8_t *)tx_packet, length)) + { + while (tx_complete == false) + { + __WFI(); + } + return tx_success; + } + else + { + return false; + } +} + +static gzp_tx_rx_trans_result_t gzp_tx_rx_transaction(const uint8_t *tx_packet, uint8_t tx_length, uint8_t *rx_dst, uint32_t *rx_length, uint8_t pipe) +{ + + gzp_tx_rx_trans_result_t retval; + uint8_t fetch_packet[GZP_CMD_FETCH_RESP_PAYLOAD_LENGTH]; + bool tx_packet_success; + bool fetch_success; + uint32_t local_rx_length = GZP_MAX_ACK_PAYLOAD_LENGTH; + uint32_t temp_lifetime; + + nrf_gzp_flush_rx_fifo(pipe); + + retval = GZP_TX_RX_FAILED_TO_SEND; + + (void)nrf_gzll_disable(); + while (nrf_gzll_is_enabled()) + {} + temp_lifetime = nrf_gzll_get_sync_lifetime(); + (void)nrf_gzll_set_sync_lifetime(GZP_TX_RX_TRANS_DELAY * 3); // 3 = RXPERIOD * 2 + margin + (void)nrf_gzll_enable(); + + tx_packet_success = gzp_tx_packet(tx_packet, tx_length, pipe); + + if (tx_packet_success) + { + retval = GZP_TX_RX_NO_RESPONSE; + + nrf_gzp_flush_rx_fifo(pipe); + + fetch_packet[0] = (uint8_t)GZP_CMD_FETCH_RESP; + + gzp_tick_sleep_rx_periods(GZP_TX_RX_TRANS_DELAY); + + tx_packet_success = gzp_tx_packet(fetch_packet, GZP_CMD_FETCH_RESP_PAYLOAD_LENGTH, pipe); + + if (tx_packet_success) + { + if (nrf_gzll_get_rx_fifo_packet_count(pipe)) + { + local_rx_length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH; + fetch_success = nrf_gzll_fetch_packet_from_rx_fifo(pipe, rx_dst, &local_rx_length); + } + else + { + fetch_success = false; + } + + if (fetch_success) + { + retval = GZP_TX_RX_SUCCESS; + } + else + { + //print_string("GZP_TX_FETCH_FAILED\r\n"); + } + } + else + { + //print_string("GZP_TX_FETCH_NO_ACK\r\n"); + } + } + + (void)nrf_gzll_disable(); + while (nrf_gzll_is_enabled()) + {} + (void)nrf_gzll_set_sync_lifetime(temp_lifetime); + (void)nrf_gzll_enable(); + + return retval; +} + +#ifndef GZP_CRYPT_DISABLE + +static bool gzp_crypt_tx_transaction(const uint8_t *src, uint8_t length) +{ + uint8_t tx_packet[GZP_MAX_FW_PAYLOAD_LENGTH]; + uint8_t rx_packet[GZP_MAX_ACK_PAYLOAD_LENGTH]; + uint8_t tx_packet_length; + + gzp_tx_rx_trans_result_t result; + + tx_packet_length = length + (uint8_t)GZP_ENCRYPTED_USER_DATA_PACKET_OVERHEAD; + + // Assemble tx packet + tx_packet[0] = (uint8_t)GZP_CMD_ENCRYPTED_USER_DATA; + gzp_add_validation_id(&tx_packet[GZP_CMD_ENCRYPTED_USER_DATA_VALIDATION_ID]); + memcpy(&tx_packet[GZP_CMD_ENCRYPTED_USER_DATA_PAYLOAD], (uint8_t*)src, length); + + // Encrypt tx packet + if (gzp_id_req_pending) + { + gzp_crypt_select_key(GZP_ID_EXCHANGE); + } + else + { + gzp_crypt_select_key(GZP_DATA_EXCHANGE); + } + gzp_crypt(&tx_packet[1], &tx_packet[1], tx_packet_length - 1); + + // If packet was successfully sent AND a response packet was received + result = gzp_tx_rx_transaction(tx_packet, tx_packet_length, rx_packet, NULL, GZP_DATA_PIPE); + if (result == GZP_TX_RX_SUCCESS) + { + if (rx_packet[0] == (uint8_t)GZP_CMD_ENCRYPTED_USER_DATA_RESP) + { + gzp_crypt(&rx_packet[GZP_CMD_ENCRYPTED_USER_DATA_RESP_VALIDATION_ID], &rx_packet[GZP_CMD_ENCRYPTED_USER_DATA_RESP_VALIDATION_ID], GZP_VALIDATION_ID_LENGTH); + + // Validate response in order to know whether packet was correctly decrypted by host + if (gzp_validate_id(&rx_packet[GZP_CMD_ENCRYPTED_USER_DATA_RESP_VALIDATION_ID])) + { + // Update session token if normal operation (!gzp_id_req_pending) + if (!gzp_id_req_pending) + { + gzp_crypt_set_session_token(&rx_packet[GZP_CMD_ENCRYPTED_USER_DATA_RESP_SESSION_TOKEN]); + } + return true; + } + else + { + //print_string("GZP_CRYPT_TX_TRANS: Validation ID bad\r\n"); + return false; + } + } + else + { + //print_string("GZP_CRYPT_TX_TRANS: Bad CMD. \r\n"); + return false; + } + } + else + { + //print_string("GZP_CRYPT_TX_TRANS: gzp_tx_rx_trans not SUCCESS\r\n"); + return false; + } +} + +static bool gzp_key_update(void) +{ + uint8_t tx_packet[GZP_CMD_KEY_UPDATE_PAYLOAD_LENGTH], rx_packet[GZP_MAX_ACK_PAYLOAD_LENGTH]; + + // Send "prepare packet" to get session token to be used for key update + tx_packet[0] = (uint8_t)GZP_CMD_KEY_UPDATE_PREPARE; + + // If packet was successfully sent AND a response packet was received + if (gzp_tx_rx_transaction(tx_packet, GZP_CMD_KEY_UPDATE_PREPARE_PAYLOAD_LENGTH, rx_packet, NULL, GZP_DATA_PIPE) == GZP_TX_RX_SUCCESS) + { + if (rx_packet[0] == (uint8_t)GZP_CMD_KEY_UPDATE_PREPARE_RESP) + { + gzp_crypt_set_session_token(&rx_packet[GZP_CMD_KEY_UPDATE_PREPARE_RESP_SESSION_TOKEN]); + + // Build "key update" packet + tx_packet[0] = (uint8_t)GZP_CMD_KEY_UPDATE; + gzp_add_validation_id(&tx_packet[GZP_CMD_KEY_UPDATE_VALIDATION_ID]); + gzp_random_numbers_generate(&tx_packet[GZP_CMD_KEY_UPDATE_NEW_KEY], GZP_DYN_KEY_LENGTH); + gzp_crypt_set_dyn_key(&tx_packet[GZP_CMD_KEY_UPDATE_NEW_KEY]); + + // Encrypt "key update packet" + gzp_crypt_select_key(GZP_KEY_EXCHANGE); + gzp_crypt(&tx_packet[1], &tx_packet[1], GZP_CMD_KEY_UPDATE_PAYLOAD_LENGTH - 1); + + // Send "key update" packet + if (gzp_tx_packet(tx_packet, GZP_CMD_KEY_UPDATE_PAYLOAD_LENGTH, GZP_DATA_PIPE)) + { + return true; + } + } + } + + return false; +} + +#endif + +void gzp_set_host_id(const uint8_t * id) +{ + memcpy(gzp_host_id, id, GZP_HOST_ID_LENGTH); +} + +void gzp_get_host_id(uint8_t * dst_id) +{ + memcpy(dst_id, gzp_host_id, GZP_HOST_ID_LENGTH); +} + +static void gzp_params_db_add(const uint8_t* src_element, uint8_t index) +{ + nrf_nvmc_write_bytes((GZP_PARAMS_DB_ADR + (index * GZP_PARAMS_DB_ELEMENT_SIZE)), src_element, (uint32_t)GZP_PARAMS_DB_ELEMENT_SIZE); +} + + +static void gzp_params_db_read(uint8_t* dst_element, uint8_t index) +{ + memcpy(dst_element,(uint8_t*)(GZP_PARAMS_DB_ADR + (index * GZP_PARAMS_DB_ELEMENT_SIZE)), GZP_PARAMS_DB_ELEMENT_SIZE); +} + + +static void gzp_index_db_add(uint8_t val) +{ + int16_t i; + uint8_t temp_val; + uint32_t addr; + + // Search for unwritten loacation in index DB + for (i = 0; i < GZP_INDEX_DB_SIZE; i++) + { + temp_val = *(uint8_t*)(GZP_INDEX_DB_ADR + i); + + // Lower nibble + if (i != (GZP_INDEX_DB_SIZE - 1)) + { + if ((temp_val & 0x0f) == 0x0f) + { + temp_val = (temp_val & 0xf0) | val; + break; + } + // Upper nibble + else if ((temp_val & 0xf0) == 0xf0) + { + temp_val = (temp_val & 0x0f) | (val << 4); + break; + } + } + else + { + temp_val = (GZP_PARAMS_DB_MAX_ENTRIES << 4) | val; + break; + } + } + + // Write index DB + addr = (GZP_INDEX_DB_ADR + i); + nrf_nvmc_write_byte(addr, temp_val); +} + +static uint8_t gzp_index_db_read() +{ + uint8_t retval; + int16_t i; + + // Search for previously written location + for (i = (GZP_INDEX_DB_SIZE - 1); i >= 0; i--) + { + retval = *(uint8_t*)(GZP_INDEX_DB_ADR + i); + + if (retval != 0xff) + { + break; + } + } + + if (retval == 0xff) + { + retval = GZP_PARAMS_DB_MAX_ENTRIES; // index db empty + } + else if ((retval & 0xf0) != 0xf0) + { + retval >>= 4; + } + else + { + retval &= 0x0f; + } + + return retval; +} + +int8_t gzp_get_pairing_status(void) +{ + uint8_t db_byte; + int8_t db_index; + int16_t i; + uint8_t temp_element[GZP_PARAMS_DB_ELEMENT_SIZE]; + uint8_t default_host_id[GZP_HOST_ID_LENGTH]; + + db_index = -2; + + // Populate default Host ID with F's. + for (i=0; i< GZP_HOST_ID_LENGTH; i++) + { + default_host_id[i] = 0xFF; + } + + // Search for previously written location + for (i = (GZP_INDEX_DB_SIZE - 1); i >= 0; i--) + { + db_byte = *(uint8_t*)(GZP_INDEX_DB_ADR + i); + + // Check if idx has been written to + if (db_byte != 0xff) + { + // Convert 4-bit nibble to index + if ((db_byte & 0xf0) != 0xf0) + { + db_byte = (db_byte >> 4) & 0x0f; + } + else + { + db_byte = db_byte & 0x0f; + } + + // Retrieve database entry + gzp_params_db_read(temp_element, db_byte); + + // Check if database entry is all F's + if ( memcmp(&temp_element[GZP_PARAMS_DB_ELEMENT_HOST_ID], default_host_id, GZP_HOST_ID_LENGTH) != 0) + { + + db_index = db_byte; + } + else + { + db_index = -1; + } + break; + } + } + + return db_index; +} + + +static bool gzp_index_db_full() +{ +#if (GZP_INDEX_DB_SIZE != 0) + return ((*(uint8_t*)(GZP_INDEX_DB_ADR + (GZP_INDEX_DB_SIZE - 1)) != 0xff)); +#else + return true; +#endif +} + +//lint -save -e506 Constant value boolean +static bool gzp_index_db_empty() +{ +#if (GZP_INDEX_DB_SIZE != 0) + return ((GZP_INDEX_DB_SIZE == 0) || ((*(uint8_t*)(GZP_INDEX_DB_ADR)) == 0xff)); +#else + return true; +#endif +} +//lint -restore + +static bool gzp_array_is_set(const uint8_t* src, uint8_t length) +{ + uint8_t i; + + for (i = 0; i < length; i++) + { + if (*(src++) != 0xff) + { + return false; + } + } + return true; +} + +static bool gzp_params_store(bool store_all) +{ + uint8_t i; + bool write_index_db = false; + bool write_param_db = false; + uint8_t new_db_index = 0; + uint8_t temp_element[GZP_PARAMS_DB_ELEMENT_SIZE]; + + // Search param DB to see if current setup exists + if (store_all) + { + // Search for: Current system address and host ID exists + for (i = 0; i < GZP_PARAMS_DB_MAX_ENTRIES; i++) + { + gzp_params_db_read(temp_element, i); + + if (((memcmp(&temp_element[GZP_PARAMS_DB_ELEMENT_SYSTEM_ADDRESS], gzp_system_address, GZP_SYSTEM_ADDRESS_WIDTH)) == 0) && ((memcmp(&temp_element[GZP_PARAMS_DB_ELEMENT_HOST_ID], gzp_host_id, GZP_HOST_ID_LENGTH)) == 0)) + { + write_index_db = true; + new_db_index = i; + break; // System address + host_id allready exists in database + } + } + + // Search for: Current system address and cleared host ID + if (!write_index_db) + { + for (i = 0; i < GZP_PARAMS_DB_MAX_ENTRIES; i++) + { + gzp_params_db_read(temp_element, i); + + if (((memcmp(&temp_element[GZP_PARAMS_DB_ELEMENT_SYSTEM_ADDRESS], gzp_system_address, GZP_SYSTEM_ADDRESS_WIDTH)) == 0) && \ + (gzp_array_is_set(&temp_element[GZP_PARAMS_DB_ELEMENT_HOST_ID], GZP_HOST_ID_LENGTH))) + { + memcpy(&temp_element[GZP_PARAMS_DB_ELEMENT_HOST_ID], gzp_host_id, GZP_HOST_ID_LENGTH); + new_db_index = i; + write_index_db = true; + write_param_db = true; + break; + } + } + } + + // Search for: Cleared system address and cleared host ID + if (!write_index_db) + { + for (i = 0; i < GZP_PARAMS_DB_MAX_ENTRIES; i++) + { + gzp_params_db_read(temp_element, i); + + if (gzp_array_is_set(temp_element, GZP_PARAMS_DB_ELEMENT_SIZE)) + { + memcpy(&temp_element[GZP_PARAMS_DB_ELEMENT_SYSTEM_ADDRESS], gzp_system_address, GZP_SYSTEM_ADDRESS_WIDTH); + memcpy(&temp_element[GZP_PARAMS_DB_ELEMENT_HOST_ID], gzp_host_id, GZP_HOST_ID_LENGTH); + new_db_index = i; + write_index_db = true; + write_param_db = true; + break; + } + } + } + } + else + { + // Search for: System address + any host ID + for (i = 0; i < GZP_PARAMS_DB_MAX_ENTRIES; i++) + { + gzp_params_db_read(temp_element, i); + + if ((memcmp(&temp_element[GZP_PARAMS_DB_ELEMENT_SYSTEM_ADDRESS], gzp_system_address, GZP_SYSTEM_ADDRESS_WIDTH)) == 0) + { + //memcpy(&temp_element[GZP_PARAMS_DB_ELEMENT_HOST_ID], gzp_host_id, GZP_HOST_ID_LENGTH); + write_index_db = true; + new_db_index = i; + break; + } + } + + // Search for: System address cleared + if (!write_index_db) + { + for (i = 0; i < GZP_PARAMS_DB_MAX_ENTRIES; i++) + { + gzp_params_db_read(temp_element, i); + + if (gzp_array_is_set(&temp_element[GZP_PARAMS_DB_ELEMENT_SYSTEM_ADDRESS], GZP_SYSTEM_ADDRESS_WIDTH)) + { + memcpy(&temp_element[GZP_PARAMS_DB_ELEMENT_SYSTEM_ADDRESS], gzp_system_address, GZP_SYSTEM_ADDRESS_WIDTH); + write_index_db = true; + write_param_db = true; + new_db_index = i; + break; + } + } + } + } + + if (write_param_db) + { + gzp_params_db_add(temp_element, new_db_index); + } + + if (write_index_db) + { + if (!gzp_index_db_full() && (new_db_index != gzp_index_db_read()) && (new_db_index != GZP_PARAMS_DB_MAX_ENTRIES)) + { + gzp_index_db_add(new_db_index); + return true; + } + } + + return false; +} + +static bool gzp_params_restore(void) +{ + uint8_t i; + uint8_t temp_element[GZP_PARAMS_DB_ELEMENT_SIZE]; + + if (!gzp_index_db_full() && !gzp_index_db_empty()) + { + i = gzp_index_db_read(); + + if (i < GZP_PARAMS_DB_MAX_ENTRIES) + { + gzp_params_db_read(temp_element, i); + memcpy(gzp_system_address, &temp_element[GZP_PARAMS_DB_ELEMENT_SYSTEM_ADDRESS], GZP_SYSTEM_ADDRESS_WIDTH); + gzp_set_host_id(&temp_element[GZP_PARAMS_DB_ELEMENT_HOST_ID]); + return true; + } + } + + return false; +} + +void gzp_delay_rx_periods(uint32_t rx_periods) +{ + nrf_delay_us(rx_periods * 2 * nrf_gzll_get_timeslot_period()); +} + +void gzp_tick_sleep_rx_periods(uint32_t rx_periods) +{ + nrf_gzll_clear_tick_count(); + + while (nrf_gzll_get_tick_count() < 2 * rx_periods) + { + __WFI(); + } +} + + +void nrf_gzll_device_tx_success(uint32_t pipe, nrf_gzll_device_tx_info_t tx_info) +{ + latest_tx_info = tx_info; + + tx_complete = true; + tx_success = true; +} + +void nrf_gzll_device_tx_failed(uint32_t pipe, nrf_gzll_device_tx_info_t tx_info) +{ + latest_tx_info = tx_info; + + tx_complete = true; + tx_success = false; +} + +bool nrf_gzp_tx_complete(void) +{ + return tx_complete; +} + +bool nrf_gzp_tx_success(void) +{ + return tx_success; +} + +void nrf_gzp_reset_tx_complete() +{ + tx_complete = false; +} + +void nrf_gzp_reset_tx_success() +{ + tx_success = false; +} + +void nrf_gzll_disabled(void) +{ +} + +void nrf_gzll_host_rx_data_ready(uint32_t pipe, nrf_gzll_host_rx_info_t rx_info) +{ +} + +/** @} */ +/** @} */ diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzp_host.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzp_host.c new file mode 100644 index 0000000..6e331a9 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzp_host.c @@ -0,0 +1,821 @@ +/** + * Copyright (c) 2009 - 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. + * + */ +/** + * @file + * @brief Implementation of Gazell Pairing Library (gzp), Host functions. + * @defgroup gzp_source_host Gazell Pairing Host implementation + * @{ + * @ingroup gzp_04_source + */ + + +#include "nrf_gzp.h" +#include "nrf_gzll.h" +#include <string.h> +#include <stdint.h> +#include <stdbool.h> +#include "nrf_assert.h" +#include "nrf_ecb.h" +#include "nrf_nvmc.h" + + +//lint -esym(40, GZP_PARAMS_STORAGE_ADR) "Undeclared identifier" +#define GZP_PARAMS_DB_ADR GZP_PARAMS_STORAGE_ADR // Address of the GZP parameters flash page. + + +/******************************************************************************/ +/** @name Typedefs + * @{ */ +/******************************************************************************/ + +/** + * Definition of internal states. + */ +typedef enum +{ + GZP_ID_REQ_IDLE, ///< No Host ID request received from Device. + GZP_ID_REQ_PENDING, ///< Host ID request received and waiting on application to grant/reject. + GZP_ID_REQ_PENDING_AND_GRANTED, ///< Host ID request received and granted by application. + GZP_ID_REQ_PENDING_AND_REJECTED, ///< Host ID request received and rejected by application. +} gzp_id_req_stat_t; + +/** @} */ + + +/******************************************************************************/ +/** @name Internal (static) function prototypes + * @{ */ +/******************************************************************************/ + + +/** + * Function for incrementing internal session counter. + */ +static void gzp_session_counter_inc(void); + + +/** + * Function for reading value of internal session counter. + * @param dst Current session counter. + */ +static void gzp_get_session_counter(uint8_t* dst); + + +/** + * Function processing received "system address request" from Device. + * + * @param gzp_req Pointer to RX payload containing system address request. + */ +static void gzp_process_address_req(uint8_t* gzp_req); + + +/** + * Function to process Host ID request from device. + * + * The Host shall retrieve the Host ID from NVM, or shall generate if + * it does not yet exist. + * + * @param rx_payload Pointer to rx_payload contaning Host ID request. + */ +static void gzp_process_id_req(uint8_t* rx_payload); + +/** + * Function to process Host ID fetch request from Device. + * + * The Device fetches the Host ID after the Host has generated/retrieved + * the Host ID. + * + * @param rx_payload Pointer to rx_payload contaning Host ID fetch request. + */ +static void gzp_process_id_fetch(uint8_t* rx_payload); + + +/** + * Function to process Key Update Prepare packet. + * + * Device requests the Session Token to be used for the Key Update request. + */ +static void gzp_process_key_update_prepare(void); + + +/** + * Function to process Key Update packet. + * + * Device requests a Key Update and sends a new Dynamic Key. The Dynamic Key is + * updated on the Host. + * + * @param rx_payload Pointer to rx_payload containing Key Update request. + */ +static void gzp_process_key_update(uint8_t* rx_payload); + + +/** + * Function to process received Encrypted User packet. + * + * @param rx_payload Pointer to rx_payload containing the encrypted user data. + * @param length Length of encrypted user data. + */ +static void gzp_process_encrypted_user_data(uint8_t* rx_payload, uint8_t length); + + +/** + * Function to preload the payload for the next ACK. + * + * @param src Pointer to source payload. + * @param length Length of source payload. + * @param pipe Pipe for the ACK payload. + */ +static void gzp_preload_ack(uint8_t* src, uint8_t length, uint8_t pipe); + + +/** + * Function for reading the Chip ID from non-volatile memory. + * + * The chip ID is used for the system address. + * + * If the Chip ID is not yet created a random Chip ID is created and + * written to non-volatile memory. Note that the term chip ID is used as + * the factory programmed chip sequence number was used for the system + * address in nRF24LU ICs. + * + * @param dst Address to copy Host ID to. + * @param[in] n Number of bytes in the Host ID. + */ +void gzp_host_chip_id_read(uint8_t *dst, uint8_t n); + + +/** + * Function to set the Host ID. + * + * Writes the Host ID to non-volatile memory. + * @param src Address of the Host ID to copy from. + */ +static void gzp_set_host_id(const uint8_t* src); + + +/** + * Function to request disabling of Gazell and wait for it to be disabled. + * + * Emulates legacy gzll_goto_idle(). + */ +static void gzll_goto_idle(void); + + +/** + * Flush all TX FIFOs. + * + * Emulates legacy gzll_tx_fifo_flush(). + */ +static void gzll_tx_fifo_flush(void); + + +/** + * Flush all RX FIFOs. + * + * Emulates legacy gzll_rx_fifo_flush(). + */ +static void gzll_rx_fifo_flush(void); + + +/** + * Set a timeout for the reception of packets on the Gazell Host. + * + * Emulates legacy Gazell function: gzll_set_param(GZLL_PARAM_RX_TIMEOUT, x). + * + * @param timeout Timeout in number of legacy "RX periods" + * (1 RX period = 2 timeslot periods). + */ +static void gzll_set_rx_timeout(uint32_t timeout); + +/** @} */ + + +/******************************************************************************/ +/** @name Internal (static) variabls + * @{ */ +/******************************************************************************/ + +static gzp_id_req_stat_t gzp_id_req_stat; ///< Current state of Host ID request. +static bool gzp_pairing_enabled_f; ///< True if Host is paired with a device. +static bool gzp_address_exchanged_f; ///< True if Host has exchanged a system address with a device and thus pairing has begun. + +static uint8_t gzp_session_counter[GZP_SESSION_TOKEN_LENGTH]; ///< Session counter used for key generation and update. + +static bool gzp_encrypted_user_data[GZP_ENCRYPTED_USER_DATA_MAX_LENGTH]; ///< Placeholder for encrypted data from Device. +static uint8_t gzp_encrypted_user_data_length; ///< Length of gzp_encrypted_user_data. Zero implies no data received. + +static nrf_gzll_host_rx_info_t prev_gzp_rx_info = {0, 0}; ///< RSSI and status of ACK payload transmission of previous Gazell packet. + +// Define Macro to make array initialization nicer +#define REP4(X) X X X X + +#if defined(__ICCARM__) + #if GZP_PARAMS_DB_ADR == 0x1000 + static const uint32_t database[GZP_DEVICE_PARAMS_STORAGE_SIZE/4] @ "gzp_dev_data" + #elif GZP_PARAMS_DB_ADR == 0x15000 + static const uint32_t database[GZP_DEVICE_PARAMS_STORAGE_SIZE/4] @ "gzp_dev_data_sd" + #else + #error + #endif +#else +static const uint32_t database[GZP_DEVICE_PARAMS_STORAGE_SIZE / 4] __attribute__((at(GZP_PARAMS_DB_ADR))) +#endif += { + #define STATIC_INIT_VALUE 0xFFFFFFFF + #define STATIC_INIT_COUNT (GZP_DEVICE_PARAMS_STORAGE_SIZE / 4) + #define INIT_1 STATIC_INIT_VALUE, + #define INIT_4 REP4(INIT_1) + #define INIT_16 REP4(INIT_4) + #define INIT_64 REP4(INIT_16) + #define INIT_256 REP4(INIT_64) + #define INIT_1024 REP4(INIT_256) + + #if (STATIC_INIT_COUNT == 256) + INIT_256 + #elif (STATIC_INIT_COUNT == 1024) + INIT_1024 + #else + #error Gazell Pairing Library database not initialized properly! + #endif +}; ///< Database for storing keys. + +/** @} */ + + +/******************************************************************************/ +// Implementation: Host-specific API functions +/******************************************************************************/ + +void gzp_init() +{ + uint8_t system_address[GZP_SYSTEM_ADDRESS_WIDTH]; + + // Read "chip id", of which 4 bytes (GZP_SYSTEM_ADDRESS_WIDTH) + // are used as system address + gzp_host_chip_id_read(system_address, GZP_SYSTEM_ADDRESS_WIDTH); + + // Set up radio parameters (addresses and channel subset) from system_address + (void)gzp_update_radio_params(system_address); + + // Only "data pipe" enabled by default + + (void)nrf_gzll_set_rx_pipes_enabled(nrf_gzll_get_rx_pipes_enabled() | (1 << GZP_DATA_PIPE)); + + gzp_pairing_enabled_f = false; + gzp_address_exchanged_f = false; + gzp_id_req_stat = GZP_ID_REQ_IDLE; + gzp_encrypted_user_data_length = 0; + + // Infinite RX timeout + gzll_set_rx_timeout(0); +} + +void gzp_pairing_enable(bool enable) +{ + if (gzp_pairing_enabled_f != enable) + { + gzll_goto_idle(); + + if (enable) + { + (void)nrf_gzll_set_rx_pipes_enabled(nrf_gzll_get_rx_pipes_enabled() | (1 << GZP_PAIRING_PIPE)); + } + else + { + (void)nrf_gzll_set_rx_pipes_enabled(nrf_gzll_get_rx_pipes_enabled() & ~(1 << GZP_PAIRING_PIPE)); + + gzp_id_req_stat = GZP_ID_REQ_IDLE; + } + + gzp_pairing_enabled_f = enable; + + gzll_rx_start(); + } +} + +void gzp_host_execute() +{ + bool gzp_packet_received = false; + uint32_t payload_length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH; + uint8_t rx_payload[NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH]; + + gzp_address_exchanged_f = false; + + if (nrf_gzll_get_rx_fifo_packet_count(GZP_PAIRING_PIPE) > 0) + { + gzp_packet_received = nrf_gzll_fetch_packet_from_rx_fifo(GZP_PAIRING_PIPE, rx_payload, &payload_length); + } + + if (!gzp_packet_received && (gzp_encrypted_user_data_length == 0)) + { + if (nrf_gzll_get_rx_fifo_packet_count(GZP_DATA_PIPE) > 0) + { + gzp_packet_received = nrf_gzll_fetch_packet_from_rx_fifo(GZP_DATA_PIPE, rx_payload, &payload_length); + } + } + + if (gzp_packet_received) + { + //lint -save -esym(644,rx_payload) //may not have been initialized + switch (rx_payload[0]) + { + case GZP_CMD_HOST_ADDRESS_REQ: + gzp_process_address_req(rx_payload); + break; + + #ifndef GZP_CRYPT_DISABLE + + case GZP_CMD_HOST_ID_REQ: + gzp_process_id_req(rx_payload); + break; + case GZP_CMD_HOST_ID_FETCH: + gzp_process_id_fetch(rx_payload); + break; + case GZP_CMD_KEY_UPDATE_PREPARE: + gzp_process_key_update_prepare(); + break; + case GZP_CMD_KEY_UPDATE: + gzp_process_key_update(rx_payload); + break; + case GZP_CMD_ENCRYPTED_USER_DATA: + gzp_process_encrypted_user_data(rx_payload, payload_length); + break; + + #endif + + case GZP_CMD_FETCH_RESP: + default: + break; + } + } + + // Restart reception if "not proximity backoff" period has elapsed + if (!nrf_gzll_is_enabled()) + { + gzll_set_rx_timeout(0); + + if (gzp_pairing_enabled_f) + { + (void)nrf_gzll_set_rx_pipes_enabled(nrf_gzll_get_rx_pipes_enabled() | (1 << GZP_PAIRING_PIPE)); + } + + gzll_rx_start(); + } + + #ifndef GZP_CRYPT_DISABLE + gzp_session_counter_inc(); + #endif +} + +void gzll_rx_start(void) +{ + if (nrf_gzll_get_mode() != NRF_GZLL_MODE_HOST) + { + gzll_goto_idle(); + (void)nrf_gzll_set_mode(NRF_GZLL_MODE_HOST); + } + + if (!nrf_gzll_is_enabled()) + { + (void)nrf_gzll_enable(); + } +} + +bool gzp_id_req_received() +{ + return (gzp_id_req_stat != GZP_ID_REQ_IDLE); +} + +void gzp_id_req_reject() +{ + if (gzp_id_req_received()) + { + gzp_id_req_stat = GZP_ID_REQ_PENDING_AND_REJECTED; + } +} + +void gzp_id_req_grant() +{ + if (gzp_id_req_received()) + { + gzp_id_req_stat = GZP_ID_REQ_PENDING_AND_GRANTED; + } +} + +void gzp_id_req_cancel() +{ + if (gzp_id_req_received()) + { + gzp_id_req_stat = GZP_ID_REQ_IDLE; + } +} + +//----------------------------------------------------------------------------- +// Implementation: Static functions +//----------------------------------------------------------------------------- + +static void gzp_process_address_req(uint8_t* gzp_req) +{ + uint8_t temp_rx_pipes; + uint8_t pairing_resp[GZP_CMD_HOST_ADDRESS_RESP_PAYLOAD_LENGTH]; + uint32_t rx_payload_length = NRF_GZLL_CONST_MAX_PAYLOAD_LENGTH; + + gzp_address_exchanged_f = false; + + gzll_goto_idle(); + ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); + + temp_rx_pipes = nrf_gzll_get_rx_pipes_enabled(); + ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); + + // If requesting Device within close proximity + if (prev_gzp_rx_info.rssi >= GZP_HOST_RX_POWER_THRESHOLD) + { + (void)nrf_gzll_set_rx_pipes_enabled(0); + ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); + + gzll_set_rx_timeout(GZP_CLOSE_PROXIMITY_BACKOFF_RX_TIMEOUT); + ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); + + gzll_rx_fifo_flush(); + ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); + + // Start "proximity" back off period + gzll_rx_start(); + ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); + + while (nrf_gzll_is_enabled()) + {} + + // Build pairing response packet + pairing_resp[0] = (uint8_t)GZP_CMD_HOST_ADDRESS_RESP; + gzp_host_chip_id_read(&pairing_resp[GZP_CMD_HOST_ADDRESS_RESP_ADDRESS], GZP_SYSTEM_ADDRESS_WIDTH); + + (void)nrf_gzll_add_packet_to_tx_fifo(0, &pairing_resp[0], GZP_CMD_HOST_ADDRESS_RESP_PAYLOAD_LENGTH); + ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); + gzll_set_rx_timeout(GZP_STEP1_RX_TIMEOUT); + + // Enable only pairing pipe when waiting for pairing request step 1 + (void)nrf_gzll_set_rx_pipes_enabled((1 << GZP_PAIRING_PIPE)); + + gzll_rx_start(); + + while (nrf_gzll_is_enabled()) + { + if (nrf_gzll_get_rx_fifo_packet_count(GZP_PAIRING_PIPE)) + { + (void)nrf_gzll_fetch_packet_from_rx_fifo(GZP_PAIRING_PIPE, &gzp_req[0], &rx_payload_length); + + // Validate step 1 of pairing request + if (gzp_req[0] == (uint8_t)GZP_CMD_HOST_ADDRESS_FETCH) + { + gzp_address_exchanged_f = true; + } + } + } + + gzll_tx_fifo_flush(); + gzll_rx_fifo_flush(); + + gzll_set_rx_timeout(0); + + (void)nrf_gzll_set_rx_pipes_enabled(temp_rx_pipes); + + // Return to normal operation + gzll_rx_start(); + } + else + { + (void)nrf_gzll_set_rx_pipes_enabled(temp_rx_pipes & ~(1 << GZP_PAIRING_PIPE)); + + gzll_set_rx_timeout(GZP_NOT_PROXIMITY_BACKOFF_RX_TIMEOUT); + + // Start "not proximity" backoff period + gzll_rx_start(); + } +} + +static void gzp_preload_ack(uint8_t* src, uint8_t length, uint8_t pipe) +{ + gzll_goto_idle(); + + gzll_tx_fifo_flush(); + + (void)nrf_gzll_add_packet_to_tx_fifo(pipe, src, length); + + gzll_rx_start(); +} + +static void gzll_set_rx_timeout(uint32_t timeout) +{ + timeout *= 2; // * 2 as gzll_set_rx_timeout() takes RX_PERIODS as input, which equals 2 timeslots. + nrf_gzll_set_auto_disable(timeout); +} + +bool gzp_address_exchanged() +{ + return gzp_address_exchanged_f; +} + +#ifndef GZP_CRYPT_DISABLE + +bool gzp_crypt_user_data_received() +{ + return (gzp_encrypted_user_data_length > 0); +} + +bool gzp_crypt_user_data_read(uint8_t* dst, uint8_t* length) +{ + if (gzp_encrypted_user_data_length > 0) + { + memcpy(dst, (void*)gzp_encrypted_user_data, gzp_encrypted_user_data_length); + + if (length != NULL) + { + *length = gzp_encrypted_user_data_length; + } + gzp_encrypted_user_data_length = 0; + + return true; + } + else + { + return false; + } +} + +static void gzp_session_counter_inc() +{ + uint8_t i; + + for (i = 0; i < GZP_SESSION_TOKEN_LENGTH; i++) + { + gzp_session_counter[i]++; + if (gzp_session_counter[i] != 0) + { + break; + } + } +} + +static void gzp_get_session_counter(uint8_t* dst) +{ + memcpy(dst, (void*)gzp_session_counter, GZP_SESSION_TOKEN_LENGTH); +} + +static void gzp_set_host_id(const uint8_t* src) +{ + if (*((uint8_t*)database) == 0xff) + { + nrf_nvmc_write_bytes(GZP_PARAMS_STORAGE_ADR + 1, src, GZP_HOST_ID_LENGTH); + nrf_nvmc_write_byte(GZP_PARAMS_STORAGE_ADR, 0x00); + } +} + +void gzp_get_host_id(uint8_t *dst) +{ + memcpy(dst, (uint8_t*)GZP_PARAMS_STORAGE_ADR + 1, GZP_HOST_ID_LENGTH); +} + +static void gzp_process_id_req(uint8_t* rx_payload) +{ + int i; + uint8_t temp_host_id[GZP_HOST_ID_LENGTH]; + + if (gzp_pairing_enabled_f) + { + if (!gzp_id_req_received()) + { + gzp_crypt_set_session_token(&rx_payload[GZP_CMD_HOST_ID_REQ_SESSION_TOKEN]); + gzp_id_req_stat = GZP_ID_REQ_PENDING; + } + + gzp_get_host_id(temp_host_id); + + // Added: + for (i = 0; i < GZP_HOST_ID_LENGTH; i++) + { + if (temp_host_id[i] != 0xFF) + { + break; + } + } + + if (i == GZP_HOST_ID_LENGTH) // If host not generated yet + { + gzp_get_session_counter(temp_host_id); + +#if (GZP_HOST_ID_LENGTH > GZP_SESSION_TOKEN_LENGTH) + gzp_xor_cipher(temp_host_id, temp_host_id, &rx_payload[GZP_CMD_HOST_ID_REQ_SESSION_TOKEN], GZP_SESSION_TOKEN_LENGTH); +#else //(GZP_HOST_ID_LENGTH > GZP_SESSION_TOKEN_LENGTH) + gzp_xor_cipher(temp_host_id, temp_host_id, &rx_payload[GZP_CMD_HOST_ID_REQ_SESSION_TOKEN], GZP_HOST_ID_LENGTH); +#endif //(GZP_HOST_ID_LENGTH > GZP_SESSION_TOKEN_LENGTH) + + gzp_set_host_id(temp_host_id); + } + } +} + +static void gzp_process_id_fetch(uint8_t* rx_payload) +{ + uint8_t tx_payload[GZP_CMD_HOST_ID_FETCH_RESP_PAYLOAD_LENGTH]; + + if (gzp_id_req_received()) + { + gzp_crypt_select_key(GZP_ID_EXCHANGE); + gzp_crypt(&rx_payload[1], &rx_payload[1], GZP_CMD_HOST_ID_FETCH_PAYLOAD_LENGTH - 1); + if (gzp_validate_id(&rx_payload[GZP_CMD_HOST_ID_FETCH_VALIDATION_ID])) + { + switch (gzp_id_req_stat) + { + case GZP_ID_REQ_PENDING_AND_GRANTED: + tx_payload[GZP_CMD_HOST_ID_FETCH_RESP_STATUS] = (uint8_t)GZP_ID_RESP_GRANTED; + gzp_get_host_id(&tx_payload[GZP_CMD_HOST_ID_FETCH_RESP_HOST_ID]); + gzp_id_req_stat = GZP_ID_REQ_IDLE; + break; + case GZP_ID_REQ_PENDING_AND_REJECTED: + tx_payload[GZP_CMD_HOST_ID_FETCH_RESP_STATUS] = (uint8_t)GZP_ID_RESP_REJECTED; + gzp_id_req_stat = GZP_ID_REQ_IDLE; + break; + case GZP_ID_REQ_PENDING: + default: + tx_payload[GZP_CMD_HOST_ID_FETCH_RESP_STATUS] = (uint8_t)GZP_ID_RESP_PENDING; + break; + } + + tx_payload[0] = (uint8_t)GZP_CMD_HOST_ID_FETCH_RESP; + gzp_add_validation_id(&tx_payload[GZP_CMD_HOST_ID_FETCH_RESP_VALIDATION_ID]); + gzp_crypt(&tx_payload[1], &tx_payload[1], GZP_CMD_HOST_ID_FETCH_RESP_PAYLOAD_LENGTH - 1); + + ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); + gzp_preload_ack(tx_payload, GZP_CMD_HOST_ID_FETCH_RESP_PAYLOAD_LENGTH, GZP_DATA_PIPE); + ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); + } + } +} + +static void gzp_process_key_update_prepare() +{ + uint8_t tx_payload[GZP_CMD_KEY_UPDATE_PREPARE_RESP_PAYLOAD_LENGTH]; + + tx_payload[0] = (uint8_t)GZP_CMD_KEY_UPDATE_PREPARE_RESP; + + gzp_get_session_counter(&tx_payload[GZP_CMD_KEY_UPDATE_PREPARE_RESP_SESSION_TOKEN]); + + // Update session token if no ID request is pending + if (!gzp_id_req_received()) + { + gzp_crypt_set_session_token(&tx_payload[GZP_CMD_KEY_UPDATE_PREPARE_RESP_SESSION_TOKEN]); + } + + gzp_preload_ack(tx_payload, GZP_CMD_KEY_UPDATE_PREPARE_RESP_PAYLOAD_LENGTH, GZP_DATA_PIPE); + ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); +} + +static void gzp_process_key_update(uint8_t* rx_payload) +{ + gzp_crypt_select_key(GZP_KEY_EXCHANGE); + gzp_crypt(&rx_payload[1], &rx_payload[1], GZP_CMD_KEY_UPDATE_PAYLOAD_LENGTH - 1); + if (gzp_validate_id(&rx_payload[GZP_CMD_KEY_UPDATE_VALIDATION_ID])) + { + gzp_crypt_set_dyn_key(&rx_payload[GZP_CMD_KEY_UPDATE_NEW_KEY]); + } +} + +static void gzp_process_encrypted_user_data(uint8_t* rx_payload, uint8_t length) +{ + uint8_t tx_payload[GZP_CMD_ENCRYPTED_USER_DATA_RESP_PAYLOAD_LENGTH]; + + if (gzp_id_req_received()) + { + gzp_crypt_select_key(GZP_ID_EXCHANGE); + } + else + { + gzp_crypt_select_key(GZP_DATA_EXCHANGE); + } + + gzp_crypt(&rx_payload[1], &rx_payload[1], length - 1); + if (gzp_validate_id(&rx_payload[GZP_CMD_ENCRYPTED_USER_DATA_VALIDATION_ID])) + { + gzp_encrypted_user_data_length = length - GZP_ENCRYPTED_USER_DATA_PACKET_OVERHEAD; + memcpy((void*)gzp_encrypted_user_data, &rx_payload[GZP_CMD_ENCRYPTED_USER_DATA_PAYLOAD], gzp_encrypted_user_data_length); + } + + // Build response packet + tx_payload[0] = (uint8_t)GZP_CMD_ENCRYPTED_USER_DATA_RESP; + gzp_add_validation_id(&tx_payload[GZP_CMD_ENCRYPTED_USER_DATA_RESP_VALIDATION_ID]); + gzp_crypt(&tx_payload[GZP_CMD_ENCRYPTED_USER_DATA_RESP_VALIDATION_ID], &tx_payload[GZP_CMD_ENCRYPTED_USER_DATA_RESP_VALIDATION_ID], GZP_VALIDATION_ID_LENGTH); + gzp_get_session_counter(&tx_payload[GZP_CMD_ENCRYPTED_USER_DATA_RESP_SESSION_TOKEN]); + + // Update "session token" only if no ID request is pending + if (!gzp_id_req_received()) + { + gzp_crypt_set_session_token(&tx_payload[GZP_CMD_ENCRYPTED_USER_DATA_RESP_SESSION_TOKEN]); + } + + ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); + gzp_preload_ack(tx_payload, GZP_CMD_ENCRYPTED_USER_DATA_RESP_PAYLOAD_LENGTH, GZP_DATA_PIPE); + ASSERT(nrf_gzll_get_error_code() == NRF_GZLL_ERROR_CODE_NO_ERROR); +} + +//----------------------------------------------------------------------------- +// Function added during LE1 -> nRF51 port +//----------------------------------------------------------------------------- + +static void gzll_goto_idle() +{ + nrf_gzll_disable(); + while (nrf_gzll_is_enabled()) + {} +} + +static void gzll_tx_fifo_flush(void) +{ + int i; + + for (i = 0; i < NRF_GZLL_CONST_PIPE_COUNT; i++) + { + (void)nrf_gzll_flush_tx_fifo(i); + } +} + +static void gzll_rx_fifo_flush(void) +{ + int i; + + for (i = 0; i < NRF_GZLL_CONST_PIPE_COUNT; i++) + { + (void)nrf_gzll_flush_rx_fifo(i); + } +} + + +/******************************************************************************/ +// Implementation: Gazell callback functions +/******************************************************************************/ + +void nrf_gzll_device_tx_failed(uint32_t pipe, nrf_gzll_device_tx_info_t tx_info) +{ +} + + +void nrf_gzll_device_tx_success(uint32_t pipe, nrf_gzll_device_tx_info_t tx_info) +{ +} + + +void nrf_gzll_disabled(void) +{ +} + + +void nrf_gzll_host_rx_data_ready(uint32_t pipe, nrf_gzll_host_rx_info_t rx_info) +{ + if (pipe == GZP_PAIRING_PIPE) + { + prev_gzp_rx_info = rx_info; + } +} + +/** @} */ +/** @} */ + +#endif diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzp_host_nrf5x.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzp_host_nrf5x.c new file mode 100644 index 0000000..b78c34c --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/proprietary_rf/gzll/nrf_gzp_host_nrf5x.c @@ -0,0 +1,74 @@ +/** + * Copyright (c) 2009 - 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 "nrf_gzp.h" +#include "nrf_nvmc.h" + +/** + * @file + * @brief Implementation of Gazell Pairing Library (gzp), nRF5x specific Host functions. + * @defgroup gzp_source_host_nrf5x Gazell Pairing Host nRF5x specific implementation + * @{ + * @ingroup gzp_04_source + */ + + +void gzp_host_chip_id_read(uint8_t *dst, uint8_t n) +{ + uint8_t i; + uint8_t random_number; + + if ( *((uint8_t*)(GZP_PARAMS_STORAGE_ADR + GZP_HOST_ID_LENGTH + 1)) == 0xff) + { + nrf_nvmc_write_byte((GZP_PARAMS_STORAGE_ADR + GZP_HOST_ID_LENGTH + 1) , 0x00); + + for (i = 0; i < n; i++) + { + gzp_random_numbers_generate(&random_number, 1); + nrf_nvmc_write_byte((GZP_PARAMS_STORAGE_ADR + GZP_HOST_ID_LENGTH + 2 + i) , random_number); + } + } + + for (i = 0; i < n; i++) + { + *(dst++) = *((uint8_t*)(GZP_PARAMS_STORAGE_ADR + GZP_HOST_ID_LENGTH + 2 + i)); + } +} + +/** @} */ |