static void tx_prepare(volatile nrf_drv_twi_t const * const p_instance) { volatile transfer_t * p_transfer = &(m_cb[p_instance->instance_id].transfer); nrf_twi_txd_set(p_instance->p_reg, p_transfer->p_data[p_transfer->count]); txrx_shorts_set_task_start(p_instance); }
void i2c_transfer_asynch(i2c_t *obj, const void *tx, size_t tx_length, void *rx, size_t rx_length, uint32_t address, uint32_t stop, uint32_t handler, uint32_t event, DMAUsage hint) { (void)hint; twi_info_t *twi_info = TWI_INFO(obj); if (twi_info->active) { return; } twi_info->active = true; twi_info->events = 0; twi_info->handler = (void (*)(void))handler; twi_info->evt_mask = event; twi_info->tx_length = tx_length; twi_info->tx = tx; twi_info->rx_length = rx_length; twi_info->rx = rx; twi_info->stop = stop; NRF_TWI_Type *twi = m_twi_instances[TWI_IDX(obj)]; nrf_twi_event_clear(twi, NRF_TWI_EVENT_TXDSENT); nrf_twi_event_clear(twi, NRF_TWI_EVENT_RXDREADY); nrf_twi_event_clear(twi, NRF_TWI_EVENT_STOPPED); nrf_twi_event_clear(twi, NRF_TWI_EVENT_SUSPENDED); nrf_twi_event_clear(twi, NRF_TWI_EVENT_ERROR); (void)nrf_twi_errorsrc_get_and_clear(twi); nrf_twi_address_set(twi, twi_address(address)); nrf_twi_task_trigger(twi, NRF_TWI_TASK_RESUME); // TX only, or TX + RX (after a repeated start). if (tx_length > 0) { nrf_twi_task_trigger(twi, NRF_TWI_TASK_STARTTX); nrf_twi_txd_set(twi, *(twi_info->tx)); ++(twi_info->tx); // RX only. } else if (rx_length > 0) { start_asynch_rx(twi_info, twi); // Both 'tx_length' and 'rx_length' are 0 - this case may be used // to test if the slave is presentand ready for transfer (by just // sending the address and checking if it is acknowledged). } else { nrf_twi_task_trigger(twi, NRF_TWI_TASK_STARTTX); if (stop) { nrf_twi_task_trigger(twi, NRF_TWI_TASK_STOP); } else { nrf_twi_task_trigger(twi, NRF_TWI_TASK_SUSPEND); nrf_twi_int_enable(twi, NRF_TWI_INT_SUSPENDED_MASK); } twi_info->events |= I2C_EVENT_TRANSFER_COMPLETE; } nrf_twi_int_enable(twi, NRF_TWI_INT_TXDSENT_MASK | NRF_TWI_INT_RXDREADY_MASK | NRF_TWI_INT_STOPPED_MASK | NRF_TWI_INT_ERROR_MASK); }
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; }
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(); } } }