/* Writes a page to the EEPROM using IRQ I2C transfer. */
void i2c_irq_write_example()
{
QM_PUTS("IRQ write");
async_irq_write_xfer.tx = eeprom_irq_write_data;
async_irq_write_xfer.tx_len =
EEPROM_PAGE_SIZE_BYTES + EEPROM_ADDR_SIZE_BYTES;
async_irq_write_xfer.callback = i2c_0_irq_callback;
async_irq_write_xfer.callback_data = &id_write;
async_irq_write_xfer.rx = NULL;
async_irq_write_xfer.rx_len = 0;
async_irq_write_xfer.stop = true;
if (qm_i2c_master_irq_transfer(QM_I2C_0, &async_irq_write_xfer,
EEPROM_SLAVE_ADDR)) {
QM_PUTS("Error: IRQ write failed");
}
/* Wait until complete flag is set in callback. */
while (!i2c_0_irq_complete)
;
if (i2c_0_irq_rc_error) {
QM_PUTS("Error: I2C IRQ Transfer failed");
} else {
QM_PUTS("I2C IRQ Transfer complete");
}
/* Wait for EEPROM to complete the write operation. */
clk_sys_udelay(EEPROM_WRITE_WAIT_TIME_US);
}
/* Reads a page from the EEPROM using combined IRQ I2C transfer. */
void i2c_irq_combined_transaction_example()
{
QM_PUTS("IRQ combined write + read");
async_irq_read_xfer.tx = eeprom_read_addr;
async_irq_read_xfer.tx_len = EEPROM_ADDR_SIZE_BYTES;
async_irq_read_xfer.callback = i2c_0_irq_callback;
async_irq_read_xfer.callback_data = &id_read;
async_irq_read_xfer.rx = eeprom_read_buf;
async_irq_read_xfer.rx_len = EEPROM_PAGE_SIZE_BYTES;
async_irq_read_xfer.stop = true;
i2c_0_irq_complete = false;
i2c_0_irq_rc_error = false;
if (qm_i2c_master_irq_transfer(QM_I2C_0, &async_irq_read_xfer,
EEPROM_SLAVE_ADDR)) {
QM_PUTS("Error: IRQ read failed");
}
/* Wait until complete flag is set in callback. */
while (!i2c_0_irq_complete)
;
if (i2c_0_irq_rc_error) {
QM_PUTS("Error: I2C IRQ Transfer failed");
} else {
QM_PUTS("I2C IRQ Transfer complete");
}
}
static int i2c_qmsi_transfer(struct device *dev, struct i2c_msg *msgs,
u8_t num_msgs, u16_t addr)
{
struct i2c_qmsi_driver_data *driver_data = GET_DRIVER_DATA(dev);
qm_i2c_t instance = GET_CONTROLLER_INSTANCE(dev);
int rc;
__ASSERT_NO_MSG(msgs);
if (!num_msgs) {
return 0;
}
device_busy_set(dev);
for (int i = 0; i < num_msgs; i++) {
u8_t op = msgs[i].flags & I2C_MSG_RW_MASK;
bool stop = (msgs[i].flags & I2C_MSG_STOP) == I2C_MSG_STOP;
qm_i2c_transfer_t xfer = { 0 };
if (op == I2C_MSG_WRITE) {
xfer.tx = msgs[i].buf;
xfer.tx_len = msgs[i].len;
} else {
xfer.rx = msgs[i].buf;
xfer.rx_len = msgs[i].len;
}
xfer.callback = transfer_complete;
xfer.callback_data = dev;
xfer.stop = stop;
k_sem_take(&driver_data->sem, K_FOREVER);
rc = qm_i2c_master_irq_transfer(instance, &xfer, addr);
k_sem_give(&driver_data->sem);
if (rc != 0) {
device_busy_clear(dev);
return -EIO;
}
/* Block current thread until the I2C transfer completes. */
k_sem_take(&driver_data->device_sync_sem, K_FOREVER);
if (driver_data->transfer_status != 0) {
device_busy_clear(dev);
return -EIO;
}
}
device_busy_clear(dev);
return 0;
}
static qm_rc_t
begin_transfer(qm_i2c_t i2c, uint16_t slave, uint32_t id, const uint8_t *tx,
uint32_t tx_len, const uint8_t *rx, uint32_t rx_len, bool stop)
{
qm_i2c_transfer_t xfer;
xfer.tx = (uint8_t *)tx;
xfer.tx_len = tx_len;
xfer.rx = (uint8_t *)rx;
xfer.rx_len = rx_len;
xfer.id = id;
xfer.stop = stop;
xfer.tx_callback = tx_callback;
xfer.rx_callback = rx_callback;
xfer.err_callback = err_callback;
return qm_i2c_master_irq_transfer(i2c, &xfer, slave);
}
