uint32_t nrf_drv_ppi_channel_fork_assign(nrf_ppi_channel_t channel, uint32_t fork_tep)
{
ret_code_t err_code = NRF_SUCCESS;
#ifdef PPI_FEATURE_FORKS_PRESENT
if (!is_programmable_app_channel(channel))
{
err_code = NRF_ERROR_INVALID_PARAM;
}
else if (!is_allocated_channel(channel))
{
err_code = NRF_ERROR_INVALID_STATE;
}
else
{
nrf_ppi_fork_endpoint_setup(channel, fork_tep);
NRF_LOG_INFO("Fork assigned channel: %d, task end point: %d.", channel, fork_tep);
}
NRF_LOG_INFO("Function: %s, error code: %s.", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
#else
err_code = NRF_ERROR_NOT_SUPPORTED;
NRF_LOG_WARNING("Function: %s, error code: %s.", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
#endif
}
uint32_t nrf_drv_ppi_channels_include_in_group(uint32_t channel_mask,
nrf_ppi_channel_group_t group)
{
ret_code_t err_code = NRF_SUCCESS;
if (!is_app_group(group))
{
err_code = NRF_ERROR_INVALID_PARAM;
}
else if (!is_allocated_group(group))
{
err_code = NRF_ERROR_INVALID_STATE;
}
else if (!are_app_channels(channel_mask))
{
err_code = NRF_ERROR_INVALID_PARAM;
}
else
{
CRITICAL_REGION_ENTER();
nrf_ppi_channels_include_in_group(channel_mask, group);
CRITICAL_REGION_EXIT();
}
NRF_LOG_INFO("Function: %s, error code: %s.", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
uint32_t nrf_drv_ppi_group_alloc(nrf_ppi_channel_group_t * p_group)
{
uint32_t err_code;
uint32_t mask = 0;
nrf_ppi_channel_group_t group;
err_code = NRF_ERROR_NO_MEM;
mask = NRF_PPI_ALL_APP_GROUPS_MASK;
for (group = NRF_PPI_CHANNEL_GROUP0; mask != 0; mask &= ~group_to_mask(group), group++)
{
CRITICAL_REGION_ENTER();
if ((mask & group_to_mask(group)) && (!is_allocated_group(group)))
{
group_allocated_set(group);
*p_group = group;
err_code = NRF_SUCCESS;
}
CRITICAL_REGION_EXIT();
if (err_code == NRF_SUCCESS)
{
NRF_LOG_INFO("Allocated group: %d.", group);
break;
}
}
NRF_LOG_INFO("Function: %s, error code: %s.", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
uint32_t nrf_drv_ppi_channel_alloc(nrf_ppi_channel_t * p_channel)
{
uint32_t err_code = NRF_SUCCESS;
nrf_ppi_channel_t channel;
uint32_t mask = 0;
err_code = NRF_ERROR_NO_MEM;
mask = NRF_PPI_PROG_APP_CHANNELS_MASK;
for (channel = NRF_PPI_CHANNEL0; mask != 0; mask &= ~nrf_drv_ppi_channel_to_mask(channel), channel++)
{
CRITICAL_REGION_ENTER();
if ((mask & nrf_drv_ppi_channel_to_mask(channel)) && (!is_allocated_channel(channel)))
{
channel_allocated_set(channel);
*p_channel = channel;
err_code = NRF_SUCCESS;
}
CRITICAL_REGION_EXIT();
if (err_code == NRF_SUCCESS)
{
NRF_LOG_INFO("Allocated channel: %d.", channel);
break;
}
}
NRF_LOG_INFO("Function: %s, error code: %s.", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
uint32_t nrf_drv_ppi_uninit(void)
{
ret_code_t err_code = NRF_SUCCESS;
uint32_t mask = NRF_PPI_ALL_APP_GROUPS_MASK;
nrf_ppi_channel_group_t group;
if (m_drv_state == NRF_DRV_STATE_UNINITIALIZED)
{
err_code = NRF_ERROR_INVALID_STATE;
NRF_LOG_WARNING("Function: %s, error code: %s.", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
m_drv_state = NRF_DRV_STATE_UNINITIALIZED;
// Disable all channels and groups
nrf_ppi_channels_disable(NRF_PPI_ALL_APP_CHANNELS_MASK);
for (group = NRF_PPI_CHANNEL_GROUP0; mask != 0; mask &= ~group_to_mask(group), group++)
{
if (mask & group_to_mask(group))
{
nrf_ppi_channel_group_clear(group);
}
}
channel_allocated_clr_all();
group_allocated_clr_all();
NRF_LOG_INFO("Function: %s, error code: %s.", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
ret_code_t nrf_drv_i2s_init(nrf_drv_i2s_config_t const * p_config,
nrf_drv_i2s_data_handler_t handler)
{
ASSERT(handler);
ret_code_t err_code;
if (m_cb.state != NRF_DRV_STATE_UNINITIALIZED)
{
err_code = NRF_ERROR_INVALID_STATE;
NRF_LOG_WARNING("Function: %s, error code: %s.",
(uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
if (p_config == NULL)
{
p_config = &m_default_config;
}
if (!nrf_i2s_configure(NRF_I2S, p_config->mode,
p_config->format,
p_config->alignment,
p_config->sample_width,
p_config->channels,
p_config->mck_setup,
p_config->ratio))
{
err_code = NRF_ERROR_INVALID_PARAM;
NRF_LOG_WARNING("Function: %s, error code: %s.",
(uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
configure_pins(p_config);
m_cb.handler = handler;
nrf_drv_common_irq_enable(I2S_IRQn, p_config->irq_priority);
m_cb.state = NRF_DRV_STATE_INITIALIZED;
err_code = NRF_SUCCESS;
NRF_LOG_INFO("Function: %s, error code: %s.",
(uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
uint32_t nrf_drv_ppi_group_disable(nrf_ppi_channel_group_t group)
{
ret_code_t err_code = NRF_SUCCESS;
if (!is_app_group(group))
{
err_code = NRF_ERROR_INVALID_PARAM;
}
else
{
nrf_ppi_group_disable(group);
}
NRF_LOG_INFO("Function: %s, error code: %s.", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
uint32_t nrf_drv_ppi_init(void)
{
uint32_t err_code;
if (m_drv_state == NRF_DRV_STATE_UNINITIALIZED)
{
m_drv_state = NRF_DRV_STATE_INITIALIZED;
err_code = NRF_SUCCESS;
}
else
{
err_code = NRF_ERROR_MODULE_ALREADY_INITIALIZED;
}
NRF_LOG_INFO("Function: %s, error code: %s.", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
uint32_t nrf_drv_ppi_channel_enable(nrf_ppi_channel_t channel)
{
ret_code_t err_code = NRF_SUCCESS;
if (!is_app_channel(channel))
{
err_code = NRF_ERROR_INVALID_PARAM;
}
else if (is_programmable_app_channel(channel) && !is_allocated_channel(channel))
{
err_code = NRF_ERROR_INVALID_STATE;
}
else
{
nrf_ppi_channel_enable(channel);
}
NRF_LOG_INFO("Function: %s, error code: %s.", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
uint32_t nrf_drv_ppi_channel_free(nrf_ppi_channel_t channel)
{
ret_code_t err_code = NRF_SUCCESS;
if (!is_programmable_app_channel(channel))
{
err_code = NRF_ERROR_INVALID_PARAM;
}
else
{
// First disable this channel
nrf_ppi_channel_disable(channel);
CRITICAL_REGION_ENTER();
channel_allocated_clr(channel);
CRITICAL_REGION_EXIT();
}
NRF_LOG_INFO("Function: %s, error code: %s.", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
ret_code_t nrf_drv_rng_rand(uint8_t * p_buff, uint8_t length)
{
ret_code_t err_code = NRF_SUCCESS;
ASSERT(m_rng_cb.state == NRFX_DRV_STATE_INITIALIZED);
#ifdef SOFTDEVICE_PRESENT
do {
bool sd_is_enabled;
NRF_DRV_RNG_LOCK();
sd_is_enabled = NRF_DRV_RNG_SD_IS_ENABLED();
if (!sd_is_enabled)
#endif // SOFTDEVICE_PRESENT
{
err_code = nrf_queue_read(&m_rand_pool, p_buff, (uint32_t)length);
nrfx_rng_start();
}
#ifdef SOFTDEVICE_PRESENT
NRF_DRV_RNG_RELEASE();
if (sd_is_enabled)
{
err_code = sd_rand_application_vector_get(p_buff, length);
if (err_code == NRF_ERROR_SOC_RAND_NOT_ENOUGH_VALUES)
{
err_code = NRF_ERROR_NOT_FOUND;
}
}
} while (err_code == NRF_ERROR_SOFTDEVICE_NOT_ENABLED);
#endif // SOFTDEVICE_PRESENT
ASSERT((err_code == NRF_SUCCESS) || (err_code == NRF_ERROR_NOT_FOUND));
#if defined(RNG_CONFIG_RANDOM_NUMBER_LOG_ENABLED) && (RNG_CONFIG_RANDOM_NUMBER_LOG_ENABLED != 0)
NRF_LOG_DEBUG("Rand buffer data:");
NRF_LOG_HEXDUMP_DEBUG((uint8_t *)p_buff, length);
#endif // RNG_CONFIG_RANDOM_NUMBER_LOG_ENABLED
NRF_LOG_WARNING("Function: %s, error code: %s.",
(uint32_t)__func__,
(uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
uint32_t nrf_drv_ppi_group_free(nrf_ppi_channel_group_t group)
{
ret_code_t err_code = NRF_SUCCESS;
if (!is_app_group(group))
{
err_code = NRF_ERROR_INVALID_PARAM;
}
if (!is_allocated_group(group))
{
err_code = NRF_ERROR_INVALID_STATE;
}
else
{
nrf_ppi_group_disable(group);
CRITICAL_REGION_ENTER();
group_allocated_clr(group);
CRITICAL_REGION_EXIT();
}
NRF_LOG_INFO("Function: %s, error code: %s.", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
uint32_t nrf_drv_ppi_channel_assign(nrf_ppi_channel_t channel, uint32_t eep, uint32_t tep)
{
VERIFY_PARAM_NOT_NULL((uint32_t *)eep);
VERIFY_PARAM_NOT_NULL((uint32_t *)tep);
ret_code_t err_code = NRF_SUCCESS;
if (!is_programmable_app_channel(channel))
{
err_code = NRF_ERROR_INVALID_PARAM;
}
else if (!is_allocated_channel(channel))
{
err_code = NRF_ERROR_INVALID_STATE;
}
else
{
nrf_ppi_channel_endpoint_setup(channel, eep, tep);
NRF_LOG_INFO("Assigned channel: %d, event end point: %x, task end point: %x.", channel, eep, tep);
}
NRF_LOG_INFO("Function: %s, error code: %s.", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
ret_code_t nrf_drv_i2s_start(uint32_t * p_rx_buffer,
uint32_t * p_tx_buffer,
uint16_t buffer_size,
uint8_t flags)
{
ASSERT((p_rx_buffer != NULL) || (p_tx_buffer != NULL));
uint16_t buffer_half_size = buffer_size / 2;
ASSERT(buffer_half_size != 0);
VERIFY_MODULE_INITIALIZED();
ret_code_t err_code;
if ((p_rx_buffer != NULL) && !nrf_drv_is_in_RAM(p_rx_buffer))
{
err_code = NRF_ERROR_INVALID_ADDR;
NRF_LOG_WARNING("Function: %s, error code: %s.",
(uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
if ((p_tx_buffer != NULL) && !nrf_drv_is_in_RAM(p_tx_buffer))
{
err_code = NRF_ERROR_INVALID_ADDR;
NRF_LOG_WARNING("Function: %s, error code: %s.",
(uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
// Initially we set up the peripheral to use the first half of each buffer,
// then in 'I2S_IRQHandler' we will switch to the second half.
nrf_i2s_transfer_set(NRF_I2S, buffer_half_size, p_rx_buffer, p_tx_buffer);
m_cb.p_rx_buffer = p_rx_buffer;
m_cb.p_tx_buffer = p_tx_buffer;
m_cb.buffer_half_size = buffer_half_size;
m_cb.just_started = true;
if ((flags & NRF_DRV_I2S_FLAG_SYNCHRONIZED_MODE) &&
// [synchronized mode makes sense only when both RX and TX are enabled]
(m_cb.p_rx_buffer != NULL) && (m_cb.p_tx_buffer != NULL))
{
m_cb.synchronized_mode = true;
m_cb.rx_ready = false;
m_cb.tx_ready = false;
}
else
{
m_cb.synchronized_mode = false;
}
nrf_i2s_enable(NRF_I2S);
m_cb.state = NRF_DRV_STATE_POWERED_ON;
if (m_cb.p_tx_buffer != NULL)
{
// Get from the application the first portion of data to be sent - we
// need to have it in the transmit buffer before we start the transfer.
// Unless the synchronized mode is active. In this mode we must wait
// with this until the first portion of data is received, so here we
// just make sure that there will be silence on the SDOUT line prior
// to that moment.
if (m_cb.synchronized_mode)
{
memset(m_cb.p_tx_buffer, 0,
m_cb.buffer_half_size * sizeof(uint32_t));
}
else
{
m_cb.handler(NULL, m_cb.p_tx_buffer, m_cb.buffer_half_size);
}
}
nrf_i2s_event_clear(NRF_I2S, NRF_I2S_EVENT_RXPTRUPD);
nrf_i2s_event_clear(NRF_I2S, NRF_I2S_EVENT_TXPTRUPD);
nrf_i2s_int_enable(NRF_I2S,
NRF_I2S_INT_RXPTRUPD_MASK | NRF_I2S_INT_TXPTRUPD_MASK);
nrf_i2s_task_trigger(NRF_I2S, NRF_I2S_TASK_START);
err_code = NRF_SUCCESS;
NRF_LOG_INFO("Function: %s, error code: %s.",
(uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
