int i2c_byte_read(i2c_t *obj, int last)
{
NRF_TWI_Type *twi = m_twi_instances[TWI_IDX(obj)];
uint32_t t0;
if (last) {
nrf_twi_shorts_set(twi, NRF_TWI_SHORT_BB_STOP_MASK);
}
nrf_twi_task_trigger(twi, NRF_TWI_TASK_RESUME);
t0 = ticker_read(get_us_ticker_data());
do {
if (nrf_twi_event_check(twi, NRF_TWI_EVENT_RXDREADY)) {
nrf_twi_event_clear(twi, NRF_TWI_EVENT_RXDREADY);
return nrf_twi_rxd_get(twi);
}
if (nrf_twi_event_check(twi, NRF_TWI_EVENT_ERROR)) {
nrf_twi_event_clear(twi, NRF_TWI_EVENT_ERROR);
return I2C_ERROR_NO_SLAVE;
}
} while (((uint32_t)ticker_read(get_us_ticker_data()) - t0) < I2C_TIMEOUT_VALUE_US);
return I2C_ERROR_BUS_BUSY;
}
/**@brief Generic function for handling TWI interrupt
*
* @param[in] p_reg Pointer to instance register structure.
* @param[in] instance_id Index of instance.
*/
__STATIC_INLINE void nrf_drv_twi_int_handler(NRF_TWI_Type * p_reg, uint32_t instance_id)
{
volatile transfer_t * p_transfer = &(m_cb[instance_id].transfer);
sm_evt_t sm_event;
bool error_occured = nrf_twi_event_check(p_reg, NRF_TWI_EVENTS_ERROR);
bool end_evt_occured = nrf_twi_event_check(p_reg, p_transfer->end_event);
nrf_twi_event_clear(p_reg, NRF_TWI_EVENTS_ERROR);
nrf_twi_event_clear(p_reg, NRF_TWI_EVENTS_TXDSENT);
nrf_twi_event_clear(p_reg, NRF_TWI_EVENTS_RXDREADY);
nrf_twi_event_clear(p_reg, NRF_TWI_EVENTS_STOPPED);
if (error_occured || end_evt_occured)
{
if (error_occured)
{
sm_event = ON_ERROR;
}
else
{
sm_event = p_transfer->is_tx ? TX_DONE : RX_DONE;
}
state_machine(m_instances[instance_id], sm_event);
if (p_transfer->error_condition)
{
p_transfer->transfer_in_progress = false;
nrf_drv_twi_evt_t evt =
{
.type = NRF_DRV_TWI_ERROR,
.p_data = p_transfer->p_data,
.length = p_transfer->count,
// Driver uses shortcuts, so NRF_TWI_ERROR_OVERRUN_NACK will not take place.
.error_src = (nrf_twi_error_source_get(p_reg) &
NRF_TWI_ERROR_ADDRESS_NACK) ? NRF_TWI_ERROR_ADDRESS_NACK
: NRF_TWI_ERROR_DATA_NACK,
};
m_handlers[instance_id](&evt);
}
else if (p_transfer->count >= p_transfer->length)
{
p_transfer->transfer_in_progress = false;
nrf_drv_twi_evt_t evt =
{
.type = p_transfer->is_tx ? NRF_DRV_TWI_TX_DONE : NRF_DRV_TWI_RX_DONE,
.p_data = p_transfer->p_data,
.length = p_transfer->count,
};
m_handlers[instance_id](&evt);
}
}
/**
* @brief Function for blocking the module until desired event occurs.
*
* @param[in] p_instance TWI.
*
* @return False if any error has occurred.
*/
static bool twi_action_wait(nrf_drv_twi_t const * const p_instance)
{
bool error;
bool done;
uint32_t timeout = 0;
volatile transfer_t * p_transfer = &(m_cb[p_instance->instance_id].transfer);
do
{
done = nrf_twi_event_check(p_instance->p_reg, p_transfer->end_event);
error = nrf_twi_event_check(p_instance->p_reg, NRF_TWI_EVENTS_ERROR);
error |= (++timeout < BUSY_LOOP_TIMEOUT) ? false : true;
} while (!(error | done));
return !error;
}
static uint8_t twi_byte_write(NRF_TWI_Type *twi, uint8_t data)
{
uint32_t t0;
nrf_twi_event_clear(twi, NRF_TWI_EVENT_TXDSENT);
nrf_twi_event_clear(twi, NRF_TWI_EVENT_ERROR);
nrf_twi_txd_set(twi, data);
t0 = ticker_read(get_us_ticker_data());
do {
if (nrf_twi_event_check(twi, NRF_TWI_EVENT_TXDSENT)) {
nrf_twi_event_clear(twi, NRF_TWI_EVENT_TXDSENT);
return 1; // ACK received
}
if (nrf_twi_event_check(twi, NRF_TWI_EVENT_ERROR)) {
nrf_twi_event_clear(twi, NRF_TWI_EVENT_ERROR);
return 0; // some error occurred
}
} while (((uint32_t)ticker_read(get_us_ticker_data()) - t0) < I2C_TIMEOUT_VALUE_US);
return 2; // timeout;
}
int i2c_stop(i2c_t *obj)
{
NRF_TWI_Type *twi = m_twi_instances[TWI_IDX(obj)];
uint32_t t0;
// The current transfer may be suspended (if it is RX), so it must be
// resumed before the STOP task is triggered.
nrf_twi_task_trigger(twi, NRF_TWI_TASK_RESUME);
nrf_twi_task_trigger(twi, NRF_TWI_TASK_STOP);
t0 = ticker_read(get_us_ticker_data());
do {
if (nrf_twi_event_check(twi, NRF_TWI_EVENT_STOPPED)) {
return 0;
}
} while (((uint32_t)ticker_read(get_us_ticker_data()) - t0) < I2C_TIMEOUT_VALUE_US);
return 1;
}
int i2c_write(i2c_t *obj, int address, const char *data, int length, int stop)
{
twi_info_t *twi_info = TWI_INFO(obj);
bool timeout = false;
uint32_t t0, t1;
#if DEVICE_I2C_ASYNCH
if (twi_info->active) {
return I2C_ERROR_BUS_BUSY;
}
#endif
twi_info->start_twi = false;
NRF_TWI_Type *twi = m_twi_instances[TWI_IDX(obj)];
start_twi_write(twi, address);
// Special case - transaction with no data.
// It can be used to check if a slave acknowledges the address.
if (length == 0) {
nrf_twi_event_t event;
if (stop) {
event = NRF_TWI_EVENT_STOPPED;
nrf_twi_task_trigger(twi, NRF_TWI_TASK_STOP);
} else {
event = NRF_TWI_EVENT_SUSPENDED;
nrf_twi_event_clear(twi, event);
nrf_twi_task_trigger(twi, NRF_TWI_TASK_SUSPEND);
}
t0 = ticker_read(get_us_ticker_data());
do {
if (nrf_twi_event_check(twi, event)) {
break;
}
t1 = ticker_read(get_us_ticker_data());
timeout = (t1 - t0) >= I2C_TIMEOUT_VALUE_US;
} while (!timeout);
uint32_t errorsrc = nrf_twi_errorsrc_get_and_clear(twi);
if (errorsrc & NRF_TWI_ERROR_ADDRESS_NACK) {
if (!stop) {
i2c_stop(obj);
}
return I2C_ERROR_NO_SLAVE;
}
return (timeout ? I2C_ERROR_BUS_BUSY : 0);
}
int result = length;
do {
uint8_t byte_write_result = twi_byte_write(twi, (uint8_t)*data++);
if (byte_write_result != 1) {
if (byte_write_result == 0) {
// Check what kind of error has been signaled by TWI.
uint32_t errorsrc = nrf_twi_errorsrc_get_and_clear(twi);
if (errorsrc & NRF_TWI_ERROR_ADDRESS_NACK) {
result = I2C_ERROR_NO_SLAVE;
} else {
// Some other error - return the number of bytes that
// have been sent successfully.
result -= length;
}
} else {
result = I2C_ERROR_BUS_BUSY;
}
// Force STOP condition.
stop = 1;
break;
}
--length;
} while (length > 0);
if (stop) {
(void)i2c_stop(obj);
}
return result;
}
static void twi_irq_handler(uint8_t instance_idx)
{
twi_info_t *twi_info = &m_twi_info[instance_idx];
NRF_TWI_Type *twi = m_twi_instances[instance_idx];
if (nrf_twi_event_check(twi, NRF_TWI_EVENT_ERROR)) {
nrf_twi_event_clear(twi, NRF_TWI_EVENT_ERROR);
// In case of an error, force STOP.
// The current transfer may be suspended (if it is RX), so it must be
// resumed before the STOP task is triggered.
nrf_twi_task_trigger(twi, NRF_TWI_TASK_RESUME);
nrf_twi_task_trigger(twi, NRF_TWI_TASK_STOP);
uint32_t errorsrc = nrf_twi_errorsrc_get_and_clear(twi);
twi_info->events |= I2C_EVENT_ERROR;
if (errorsrc & NRF_TWI_ERROR_ADDRESS_NACK) {
twi_info->events |= I2C_EVENT_ERROR_NO_SLAVE;
}
if (errorsrc & NRF_TWI_ERROR_DATA_NACK) {
twi_info->events |= I2C_EVENT_TRANSFER_EARLY_NACK;
}
}
bool finished = false;
if (nrf_twi_event_check(twi, NRF_TWI_EVENT_TXDSENT)) {
nrf_twi_event_clear(twi, NRF_TWI_EVENT_TXDSENT);
MBED_ASSERT(twi_info->tx_length > 0);
--(twi_info->tx_length);
// Send next byte if there is still something to be sent.
if (twi_info->tx_length > 0) {
nrf_twi_txd_set(twi, *(twi_info->tx));
++(twi_info->tx);
// It TX is done, start RX if requested.
} else if (twi_info->rx_length > 0) {
start_asynch_rx(twi_info, twi);
// If there is nothing more to do, finalize the transfer.
} else {
if (twi_info->stop) {
nrf_twi_task_trigger(twi, NRF_TWI_TASK_STOP);
} else {
nrf_twi_task_trigger(twi, NRF_TWI_TASK_SUSPEND);
finished = true;
}
twi_info->events |= I2C_EVENT_TRANSFER_COMPLETE;
}
}
if (nrf_twi_event_check(twi, NRF_TWI_EVENT_RXDREADY)) {
nrf_twi_event_clear(twi, NRF_TWI_EVENT_RXDREADY);
MBED_ASSERT(twi_info->rx_length > 0);
*(twi_info->rx) = nrf_twi_rxd_get(twi);
++(twi_info->rx);
--(twi_info->rx_length);
if (twi_info->rx_length > 0) {
// If more bytes should be received, resume the transfer
// (in case the stop condition should be generated after the next
// byte, change the shortcuts configuration first).
if (twi_info->rx_length == 1 && twi_info->stop) {
nrf_twi_shorts_set(twi, NRF_TWI_SHORT_BB_STOP_MASK);
}
nrf_twi_task_trigger(twi, NRF_TWI_TASK_RESUME);
} else {
// If all requested bytes were received, finalize the transfer.
finished = true;
twi_info->events |= I2C_EVENT_TRANSFER_COMPLETE;
}
}
if (finished ||
nrf_twi_event_check(twi, NRF_TWI_EVENT_STOPPED) ||
(nrf_twi_int_enable_check(twi, NRF_TWI_INT_SUSPENDED_MASK) &&
nrf_twi_event_check(twi, NRF_TWI_EVENT_SUSPENDED))) {
// There is no need to clear the STOPPED and SUSPENDED events here,
// they will no longer generate the interrupt - see below.
nrf_twi_shorts_set(twi, 0);
// Disable all interrupt sources.
nrf_twi_int_disable(twi, UINT32_MAX);
twi_info->active = false;
if (twi_info->handler) {
twi_info->handler();
}
}
}
