void I2S_IRQHandler(void)
{
uint32_t const * p_data_received = NULL;
uint32_t * p_data_to_send = NULL;
if (nrf_i2s_event_check(NRF_I2S, NRF_I2S_EVENT_TXPTRUPD))
{
nrf_i2s_event_clear(NRF_I2S, NRF_I2S_EVENT_TXPTRUPD);
NRF_LOG_DEBUG("Event: %s.",
(uint32_t)EVT_TO_STR(NRF_I2S_EVENT_TXPTRUPD));
// If transmission is not enabled, but for some reason the TXPTRUPD
// event has been generated, just ignore it.
if (m_cb.p_tx_buffer != NULL)
{
uint32_t * p_tx_buffer_next;
if (nrf_i2s_tx_buffer_get(NRF_I2S) == m_cb.p_tx_buffer)
{
p_tx_buffer_next = m_cb.p_tx_buffer + m_cb.buffer_half_size;
}
else
{
p_tx_buffer_next = m_cb.p_tx_buffer;
}
nrf_i2s_tx_buffer_set(NRF_I2S, p_tx_buffer_next);
m_cb.tx_ready = true;
// Now the part of the buffer that we've configured as "next" should
// be filled by the application with proper data to be sent;
// the peripheral is sending data from the other part of the buffer
// (but it will finish soon...).
p_data_to_send = p_tx_buffer_next;
}
}
if (nrf_i2s_event_check(NRF_I2S, NRF_I2S_EVENT_RXPTRUPD))
{
nrf_i2s_event_clear(NRF_I2S, NRF_I2S_EVENT_RXPTRUPD);
NRF_LOG_DEBUG("Event: %s.",
(uint32_t)EVT_TO_STR(NRF_I2S_EVENT_RXPTRUPD));
// If reception is not enabled, but for some reason the RXPTRUPD event
// has been generated, just ignore it.
if (m_cb.p_rx_buffer != NULL)
{
uint32_t * p_rx_buffer_next;
if (nrf_i2s_rx_buffer_get(NRF_I2S) == m_cb.p_rx_buffer)
{
p_rx_buffer_next = m_cb.p_rx_buffer + m_cb.buffer_half_size;
}
else
{
p_rx_buffer_next = m_cb.p_rx_buffer;
}
nrf_i2s_rx_buffer_set(NRF_I2S, p_rx_buffer_next);
m_cb.rx_ready = true;
// The RXPTRUPD event is generated for the first time right after
// the transfer is started. Since there is no data received yet at
// this point we only update the buffer pointer (it is done above),
// there is no callback to the application.
// [for synchronized mode this has to be handled differently -
// see below]
if (m_cb.just_started && !m_cb.synchronized_mode)
{
m_cb.just_started = false;
}
else
{
// The RXPTRUPD event indicates that from now on the peripheral
// will be filling the part of the buffer that was pointed at
// the time the event has been generated, hence now we can let
// the application process the data stored in the other part of
// the buffer - the one that we've just set to be filled next.
p_data_received = p_rx_buffer_next;
}
}
}
// Call the data handler passing received data to the application and/or
// requesting data to be sent.
if (!m_cb.synchronized_mode)
{
if ((p_data_received != NULL) || (p_data_to_send != NULL))
{
if (p_data_received != NULL)
{
NRF_LOG_DEBUG("Rx data:");
NRF_LOG_HEXDUMP_DEBUG(p_data_received,
m_cb.buffer_half_size * sizeof(p_data_received[0]));
}
m_cb.handler(p_data_received, p_data_to_send,
m_cb.buffer_half_size);
if (p_data_to_send != NULL)
{
NRF_LOG_DEBUG("Tx data:");
NRF_LOG_HEXDUMP_DEBUG(p_data_to_send,
m_cb.buffer_half_size * sizeof(p_data_to_send[0]));
}
}
}
// In the synchronized mode wait until the events for both RX and TX occur.
// And ignore the initial occurrences of these events, since they only
// indicate that the transfer has started - no data is received yet at
// that moment, so we have got nothing to pass to the application.
else
{
if (m_cb.rx_ready && m_cb.tx_ready)
{
m_cb.rx_ready = false;
m_cb.tx_ready = false;
if (m_cb.just_started)
{
m_cb.just_started = false;
}
else
{
NRF_LOG_DEBUG("Rx data:");
NRF_LOG_HEXDUMP_DEBUG(nrf_i2s_rx_buffer_get(NRF_I2S),
m_cb.buffer_half_size * sizeof(p_data_to_send[0]));
m_cb.handler(nrf_i2s_rx_buffer_get(NRF_I2S),
nrf_i2s_tx_buffer_get(NRF_I2S),
m_cb.buffer_half_size);
NRF_LOG_DEBUG("Tx data:");
NRF_LOG_HEXDUMP_DEBUG(nrf_i2s_tx_buffer_get(NRF_I2S),
m_cb.buffer_half_size * sizeof(p_data_to_send[0]));
}
}
}
}
void nrfx_i2s_irq_handler(void)
{
if (nrf_i2s_event_check(NRF_I2S, NRF_I2S_EVENT_TXPTRUPD))
{
nrf_i2s_event_clear(NRF_I2S, NRF_I2S_EVENT_TXPTRUPD);
m_cb.tx_ready = true;
if (m_cb.use_tx && m_cb.buffers_needed)
{
m_cb.buffers_reused = true;
}
}
if (nrf_i2s_event_check(NRF_I2S, NRF_I2S_EVENT_RXPTRUPD))
{
nrf_i2s_event_clear(NRF_I2S, NRF_I2S_EVENT_RXPTRUPD);
m_cb.rx_ready = true;
if (m_cb.use_rx && m_cb.buffers_needed)
{
m_cb.buffers_reused = true;
}
}
if (nrf_i2s_event_check(NRF_I2S, NRF_I2S_EVENT_STOPPED))
{
nrf_i2s_event_clear(NRF_I2S, NRF_I2S_EVENT_STOPPED);
nrf_i2s_int_disable(NRF_I2S, NRF_I2S_INT_STOPPED_MASK);
nrf_i2s_disable(NRF_I2S);
// When stopped, release all buffers, including these scheduled for
// the next transfer.
m_cb.handler(&m_cb.current_buffers, 0);
m_cb.handler(&m_cb.next_buffers, 0);
m_cb.state = NRFX_DRV_STATE_INITIALIZED;
NRFX_LOG_INFO("Stopped.");
}
else
{
// Check if the requested transfer has been completed:
// - full-duplex mode
if ((m_cb.use_tx && m_cb.use_rx && m_cb.tx_ready && m_cb.rx_ready) ||
// - TX only mode
(!m_cb.use_rx && m_cb.tx_ready) ||
// - RX only mode
(!m_cb.use_tx && m_cb.rx_ready))
{
m_cb.tx_ready = false;
m_cb.rx_ready = false;
// If the application did not supply the buffers for the next
// part of the transfer until this moment, the current buffers
// cannot be released, since the I2S peripheral already started
// using them. Signal this situation to the application by
// passing NULL instead of the structure with released buffers.
if (m_cb.buffers_reused)
{
m_cb.buffers_reused = false;
// This will most likely be set at this point. However, there is
// a small time window between TXPTRUPD and RXPTRUPD events,
// and it is theoretically possible that next buffers will be
// set in this window, so to be sure this flag is set to true,
// set it explicitly.
m_cb.buffers_needed = true;
m_cb.handler(NULL,
NRFX_I2S_STATUS_NEXT_BUFFERS_NEEDED);
}
else
{
// Buffers that have been used by the I2S peripheral (current)
// are now released and will be returned to the application,
// and the ones scheduled to be used as next become the current
// ones.
nrfx_i2s_buffers_t released_buffers = m_cb.current_buffers;
m_cb.current_buffers = m_cb.next_buffers;
m_cb.next_buffers.p_rx_buffer = NULL;
m_cb.next_buffers.p_tx_buffer = NULL;
m_cb.buffers_needed = true;
m_cb.handler(&released_buffers,
NRFX_I2S_STATUS_NEXT_BUFFERS_NEEDED);
}
}
}
}
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;
}
nrfx_err_t nrfx_i2s_start(nrfx_i2s_buffers_t const * p_initial_buffers,
uint16_t buffer_size,
uint8_t flags)
{
NRFX_ASSERT(p_initial_buffers != NULL);
NRFX_ASSERT(p_initial_buffers->p_rx_buffer != NULL ||
p_initial_buffers->p_tx_buffer != NULL);
NRFX_ASSERT(buffer_size != 0);
(void)(flags);
nrfx_err_t err_code;
if (m_cb.state != NRFX_DRV_STATE_INITIALIZED)
{
err_code = NRFX_ERROR_INVALID_STATE;
NRFX_LOG_WARNING("Function: %s, error code: %s.",
__func__,
NRFX_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
if (((p_initial_buffers->p_rx_buffer != NULL)
&& !nrfx_is_in_ram(p_initial_buffers->p_rx_buffer))
||
((p_initial_buffers->p_tx_buffer != NULL)
&& !nrfx_is_in_ram(p_initial_buffers->p_tx_buffer)))
{
err_code = NRFX_ERROR_INVALID_ADDR;
NRFX_LOG_WARNING("Function: %s, error code: %s.",
__func__,
NRFX_LOG_ERROR_STRING_GET(err_code));
return err_code;
}
m_cb.use_rx = (p_initial_buffers->p_rx_buffer != NULL);
m_cb.use_tx = (p_initial_buffers->p_tx_buffer != NULL);
m_cb.rx_ready = false;
m_cb.tx_ready = false;
m_cb.buffers_needed = false;
m_cb.buffer_size = buffer_size;
// Set the provided initial buffers as next, they will become the current
// ones after the IRQ handler is called for the first time, what will occur
// right after the START task is triggered.
m_cb.next_buffers = *p_initial_buffers;
m_cb.current_buffers.p_rx_buffer = NULL;
m_cb.current_buffers.p_tx_buffer = NULL;
nrf_i2s_transfer_set(NRF_I2S,
m_cb.buffer_size,
m_cb.next_buffers.p_rx_buffer,
m_cb.next_buffers.p_tx_buffer);
nrf_i2s_enable(NRF_I2S);
m_cb.state = NRFX_DRV_STATE_POWERED_ON;
nrf_i2s_event_clear(NRF_I2S, NRF_I2S_EVENT_RXPTRUPD);
nrf_i2s_event_clear(NRF_I2S, NRF_I2S_EVENT_TXPTRUPD);
nrf_i2s_event_clear(NRF_I2S, NRF_I2S_EVENT_STOPPED);
nrf_i2s_int_enable(NRF_I2S, (m_cb.use_rx ? NRF_I2S_INT_RXPTRUPD_MASK : 0) |
(m_cb.use_tx ? NRF_I2S_INT_TXPTRUPD_MASK : 0) |
NRF_I2S_INT_STOPPED_MASK);
nrf_i2s_task_trigger(NRF_I2S, NRF_I2S_TASK_START);
NRFX_LOG_INFO("Started.");
return NRFX_SUCCESS;
}
