Пример #1
0
/* 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);
}
Пример #2
0
/* 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");
	}
}
Пример #3
0
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;
}
Пример #4
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);
}