zircon/system/dev/serial/ftdi/ftdi-i2c.cpp - fuchsia - Git at Google

 // Copyright 2019 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "ftdi-i2c.h"

 #include <fuchsia/hardware/ftdi/c/fidl.h>

 #include <ddk/debug.h>
 #include <ddk/device.h>
 #include <ddk/driver.h>
 #include <ddk/metadata.h>
 #include <ddk/metadata/i2c.h>

 #include <inttypes.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <vector>

 #include "ftdi.h"

 namespace ftdi_mpsse {

 zx_status_t FtdiI2c::Enable() {
     if (!mpsse_.IsValid()) {
         zxlogf(ERROR, "ftdi_i2c: mpsse is invalid!\n");
         return ZX_ERR_INTERNAL;
     }

     zx_status_t status = mpsse_.Sync();
     if (status != ZX_OK) {
         zxlogf(ERROR, "ftdi_i2c: mpsse failed to sync %d\n", status);
         return status;
     }
     status = mpsse_.FlushGpio();
     if (status != ZX_OK) {
         zxlogf(ERROR, "ftdi_i2c: mpsse failed flush GPIO\n");
         return status;
     }

     status = mpsse_.SetClock(false, true, 100000);
     if (status != ZX_OK) {
         return status;
     }

     // Enable drive-zero mode -- this means sending 0 to GPIO drives outputs low
     // and sending 1 drives them with tri-state. This matches the I2C protocol
     // and lets multiple devices share the bus.
     uint8_t buf[3] = {kFtdiCommandDriveZeroMode, 0x07, 0x00};
     status = mpsse_.Write(buf, sizeof(buf));
     if (status != ZX_OK) {
         return status;
     }

     std::vector<uint8_t> buffer(6);
     size_t bytes_written;
     status = WriteIdleToBuf(0, &buffer, &bytes_written);
     if (status != ZX_OK) {
         return status;
     }
     status = mpsse_.Write(buffer.data(), buffer.size());

     DdkMakeVisible();
     return ZX_OK;
 }

 zx_status_t FtdiI2c::Bind() {
     zx_status_t status = DdkAdd("ftdi-i2c", DEVICE_ADD_INVISIBLE);
     if (status != ZX_OK) {
         return status;
     }

     std::vector<i2c_channel_t> i2c_channels(i2c_devices_.size());
     for (size_t i = 0; i < i2c_devices_.size(); i++) {
         i2c_channel_t& chan = i2c_channels[i];
         I2cDevice& dev = i2c_devices_[i];
         chan.bus_id = 0;
         chan.address = static_cast<uint16_t>(dev.address);
         chan.vid = dev.vid;
         chan.pid = dev.pid;
         chan.did = dev.did;
     }
     status = DdkAddMetadata(DEVICE_METADATA_I2C_CHANNELS,
                             i2c_channels.data(), i2c_channels.size() * sizeof(i2c_channel_t));
     if (status != ZX_OK) {
         DdkRemove();
         return status;
     }

     auto f = [](void* arg) -> int {
         return reinterpret_cast<FtdiI2c*>(arg)->Enable();
     };

     int rc = thrd_create_with_name(&enable_thread_, f, this, "ftdi-i2c-enable-thread");
     if (rc != thrd_success) {
         return ZX_ERR_INTERNAL;
     }

     return ZX_OK;
 }

 // This adds the command to set SCL and SDA high into buffer. It must be called
 // at least once for initial setup.
 zx_status_t FtdiI2c::WriteIdleToBuf(size_t index, std::vector<uint8_t>* buffer,
                                     size_t* bytes_written) {
     mpsse_.SetGpio(pin_layout_.scl, Mpsse::Direction::OUT, Mpsse::Level::HIGH);
     mpsse_.SetGpio(pin_layout_.sda_out, Mpsse::Direction::OUT, Mpsse::Level::HIGH);
     mpsse_.SetGpio(pin_layout_.sda_in, Mpsse::Direction::IN, Mpsse::Level::LOW);
     mpsse_.GpioWriteCommandToBuffer(index, buffer, bytes_written);
     return ZX_OK;
 }

 void FtdiI2c::DdkUnbind() {
     thrd_join(enable_thread_, NULL);
     DdkRemove();
 }

 zx_status_t FtdiI2c::Write(uint8_t bus_address, std::vector<uint8_t> data) {
     std::vector<uint8_t> transaction(kI2cNumCommandBytesPerFullWrite
                                      + (kI2cNumCommandBytesPerWriteByte * data.size()));
     size_t transaction_index = 0;
     size_t bytes_written = 0;

     zx_status_t status = WriteIdleToBuf(transaction_index, &transaction, &bytes_written);
     if (status != ZX_OK) {
         return status;
     }
     transaction_index += bytes_written;

     status = WriteTransactionStartToBuf(transaction_index, &transaction, &bytes_written);
     if (status != ZX_OK) {
         return status;
     }
     transaction_index += bytes_written;

     auto it = data.begin();
     it = data.insert(it, static_cast<uint8_t>(bus_address << 1));

     for (size_t i = 0; i < data.size(); i++) {
         transaction[transaction_index++] = kI2cWriteCommandByte1;
         transaction[transaction_index++] = kI2cWriteCommandByte2;
         transaction[transaction_index++] = kI2cWriteCommandByte3;
         transaction[transaction_index++] = data[i];

         mpsse_.SetGpio(pin_layout_.scl, Mpsse::Direction::OUT, Mpsse::Level::LOW);
         mpsse_.SetGpio(pin_layout_.sda_out, Mpsse::Direction::OUT, Mpsse::Level::HIGH);
         mpsse_.GpioWriteCommandToBuffer(transaction_index, &transaction, &bytes_written);
         transaction_index += bytes_written;

         // Read bit for ACK/NAK.
         transaction[transaction_index++] = kI2cReadAckCommandByte1;
         transaction[transaction_index++] = kI2cReadAckCommandByte2;
     }

     status = WriteTransactionEndToBuf(transaction_index, &transaction, &bytes_written);
     if (status != ZX_OK) {
         return status;
     }
     transaction_index += bytes_written;

     // Ask for response immediately
     transaction[transaction_index++] = kI2cCommandFinishTransaction;

     if (transaction_index != transaction.size()) {
         printf("Index (%ld) != size (%ld) \n", transaction_index, transaction.size());
         return ZX_ERR_INTERNAL;
     }

     status = mpsse_.Write(transaction.data(), transaction.size());
     if (status != ZX_OK) {
         return status;
     }

     std::vector<uint8_t> response(data.size());
     status = mpsse_.Read(response.data(), data.size());
     if (status != ZX_OK) {
         return status;
     }

     // Check each response byte to see if its an ACK (zero) or NACK (non-zero).
     for (size_t i = 0; i < response.size(); i++) {
         if ((response[i] & 0x1) != 0) {
             return ZX_ERR_INTERNAL;
         }
     }

     return ZX_OK;
 }

 zx_status_t FtdiI2c::Ping(uint8_t bus_address) {
     std::vector<uint8_t> data(1);
     data[0] = 0x00;
     return Write(bus_address, data);
 }

 // This adds the command to transition SCL from high to low.
 zx_status_t FtdiI2c::WriteTransactionStartToBuf(size_t index, std::vector<uint8_t>* buffer,
                                                 size_t* bytes_written) {
     size_t sub_written = 0;
     *bytes_written = 0;

     mpsse_.SetGpio(pin_layout_.scl, Mpsse::Direction::OUT, Mpsse::Level::HIGH);
     mpsse_.SetGpio(pin_layout_.sda_out, Mpsse::Direction::OUT, Mpsse::Level::LOW);
     mpsse_.GpioWriteCommandToBuffer(index + *bytes_written, buffer, &sub_written);
     *bytes_written += sub_written;

     mpsse_.SetGpio(pin_layout_.scl, Mpsse::Direction::OUT, Mpsse::Level::LOW);
     mpsse_.SetGpio(pin_layout_.sda_out, Mpsse::Direction::OUT, Mpsse::Level::LOW);
     mpsse_.GpioWriteCommandToBuffer(index + *bytes_written, buffer, &sub_written);
     *bytes_written += sub_written;

     return ZX_OK;
 }

 zx_status_t FtdiI2c::WriteTransactionEndToBuf(size_t index, std::vector<uint8_t>* buffer,
                                               size_t* bytes_written) {
     size_t sub_written = 0;
     *bytes_written = 0;

     mpsse_.SetGpio(pin_layout_.scl, Mpsse::Direction::OUT, Mpsse::Level::LOW);
     mpsse_.SetGpio(pin_layout_.sda_out, Mpsse::Direction::OUT, Mpsse::Level::LOW);
     mpsse_.GpioWriteCommandToBuffer(index + *bytes_written, buffer, &sub_written);
     *bytes_written += sub_written;

     mpsse_.SetGpio(pin_layout_.scl, Mpsse::Direction::OUT, Mpsse::Level::HIGH);
     mpsse_.SetGpio(pin_layout_.sda_out, Mpsse::Direction::OUT, Mpsse::Level::LOW);
     mpsse_.GpioWriteCommandToBuffer(index + *bytes_written, buffer, &sub_written);
     *bytes_written += sub_written;

     mpsse_.SetGpio(pin_layout_.scl, Mpsse::Direction::OUT, Mpsse::Level::HIGH);
     mpsse_.SetGpio(pin_layout_.sda_out, Mpsse::Direction::OUT, Mpsse::Level::HIGH);
     mpsse_.GpioWriteCommandToBuffer(index + *bytes_written, buffer, &sub_written);
     *bytes_written += sub_written;

     return ZX_OK;
 }

 zx_status_t FtdiI2c::I2cImplTransact(uint32_t bus_id, const i2c_impl_op_t* op_list,
                                      size_t op_count) {
     zx_status_t status;
     std::vector<uint8_t> write_data(kFtdiI2cMaxTransferSize);
     size_t write_data_index = 0;
     for (size_t i = 0; i < op_count; i++) {
         if (op_list[i].is_read) {
             // TODO(dgilhooley) - Hook up FTDI to an i2c device that supports Read, so
             // Read can be tested and implemented
             return ZX_ERR_NOT_SUPPORTED;
         } else {
             size_t copy_amt = op_list[i].data_size;
             uint8_t* data_buffer = reinterpret_cast<uint8_t*>(op_list[i].data_buffer);
             size_t data_buffer_index = 0;
             while (copy_amt--) {
                 if (write_data_index == kFtdiI2cMaxTransferSize) {
                     return ZX_ERR_INTERNAL;
                 }
                 write_data[write_data_index++] = data_buffer[data_buffer_index++];
             }
         }

         if (op_list[i].stop) {
             write_data.resize(write_data_index);
             status = Write(static_cast<uint8_t>(op_list[i].address), write_data);
             if (status != ZX_OK) {
                 return status;
             }

             // Reset the write_data for the next transaction.
             write_data.resize(kFtdiI2cMaxTransferSize);
             write_data_index = 0;
         }
     }

     return ZX_OK;
 }

 zx_status_t FtdiI2c::Create(zx_device_t* device,
                             const fuchsia_hardware_ftdi_I2cBusLayout* layout,
                             const fuchsia_hardware_ftdi_I2cDevice* i2c_dev) {
     // TODO(dgilhooley: Support i2c on different sets of pins and then remove this check.
     if (layout->scl != 0 && layout->sda_out != 1 && layout->sda_in != 2) {
         return ZX_ERR_OUT_OF_RANGE;
     }

     ftdi_mpsse::FtdiI2c::I2cLayout i2c_layout;
     i2c_layout.scl = layout->scl;
     i2c_layout.sda_out = layout->sda_out;
     i2c_layout.sda_in = layout->sda_in;

     std::vector<ftdi_mpsse::FtdiI2c::I2cDevice> i2c_devices(1);
     i2c_devices[0].address = i2c_dev->address;
     i2c_devices[0].vid = i2c_dev->vid;
     i2c_devices[0].pid = i2c_dev->pid;
     i2c_devices[0].did = i2c_dev->did;

     auto dev = std::make_unique<ftdi_mpsse::FtdiI2c>(device, i2c_layout, i2c_devices);
     zx_status_t status = dev->Bind();
     if (status == ZX_OK) {
         // devmgr is now in charge of the memory for dev
         dev.release();
     }

     return ZX_OK;
 }

 } // namespace ftdi_mpsse
	// Copyright 2019 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "ftdi-i2c.h"

	#include <fuchsia/hardware/ftdi/c/fidl.h>

	#include <ddk/debug.h>
	#include <ddk/device.h>
	#include <ddk/driver.h>
	#include <ddk/metadata.h>
	#include <ddk/metadata/i2c.h>

	#include <inttypes.h>
	#include <stdlib.h>
	#include <unistd.h>
	#include <vector>

	#include "ftdi.h"

	namespace ftdi_mpsse {

	zx_status_t FtdiI2c::Enable() {
	if (!mpsse_.IsValid()) {
	zxlogf(ERROR, "ftdi_i2c: mpsse is invalid!\n");
	return ZX_ERR_INTERNAL;
	}

	zx_status_t status = mpsse_.Sync();
	if (status != ZX_OK) {
	zxlogf(ERROR, "ftdi_i2c: mpsse failed to sync %d\n", status);
	return status;
	}
	status = mpsse_.FlushGpio();
	if (status != ZX_OK) {
	zxlogf(ERROR, "ftdi_i2c: mpsse failed flush GPIO\n");
	return status;
	}

	status = mpsse_.SetClock(false, true, 100000);
	if (status != ZX_OK) {
	return status;
	}

	// Enable drive-zero mode -- this means sending 0 to GPIO drives outputs low
	// and sending 1 drives them with tri-state. This matches the I2C protocol
	// and lets multiple devices share the bus.
	uint8_t buf[3] = {kFtdiCommandDriveZeroMode, 0x07, 0x00};
	status = mpsse_.Write(buf, sizeof(buf));
	if (status != ZX_OK) {
	return status;
	}

	std::vector<uint8_t> buffer(6);
	size_t bytes_written;
	status = WriteIdleToBuf(0, &buffer, &bytes_written);
	if (status != ZX_OK) {
	return status;
	}
	status = mpsse_.Write(buffer.data(), buffer.size());

	DdkMakeVisible();
	return ZX_OK;
	}

	zx_status_t FtdiI2c::Bind() {
	zx_status_t status = DdkAdd("ftdi-i2c", DEVICE_ADD_INVISIBLE);
	if (status != ZX_OK) {
	return status;
	}

	std::vector<i2c_channel_t> i2c_channels(i2c_devices_.size());
	for (size_t i = 0; i < i2c_devices_.size(); i++) {
	i2c_channel_t& chan = i2c_channels[i];
	I2cDevice& dev = i2c_devices_[i];
	chan.bus_id = 0;
	chan.address = static_cast<uint16_t>(dev.address);
	chan.vid = dev.vid;
	chan.pid = dev.pid;
	chan.did = dev.did;
	}
	status = DdkAddMetadata(DEVICE_METADATA_I2C_CHANNELS,
	i2c_channels.data(), i2c_channels.size() * sizeof(i2c_channel_t));
	if (status != ZX_OK) {
	DdkRemove();
	return status;
	}

	auto f = [](void* arg) -> int {
	return reinterpret_cast<FtdiI2c*>(arg)->Enable();
	};

	int rc = thrd_create_with_name(&enable_thread_, f, this, "ftdi-i2c-enable-thread");
	if (rc != thrd_success) {
	return ZX_ERR_INTERNAL;
	}

	return ZX_OK;
	}

	// This adds the command to set SCL and SDA high into buffer. It must be called
	// at least once for initial setup.
	zx_status_t FtdiI2c::WriteIdleToBuf(size_t index, std::vector<uint8_t>* buffer,
	size_t* bytes_written) {
	mpsse_.SetGpio(pin_layout_.scl, Mpsse::Direction::OUT, Mpsse::Level::HIGH);
	mpsse_.SetGpio(pin_layout_.sda_out, Mpsse::Direction::OUT, Mpsse::Level::HIGH);
	mpsse_.SetGpio(pin_layout_.sda_in, Mpsse::Direction::IN, Mpsse::Level::LOW);
	mpsse_.GpioWriteCommandToBuffer(index, buffer, bytes_written);
	return ZX_OK;
	}

	void FtdiI2c::DdkUnbind() {
	thrd_join(enable_thread_, NULL);
	DdkRemove();
	}

	zx_status_t FtdiI2c::Write(uint8_t bus_address, std::vector<uint8_t> data) {
	std::vector<uint8_t> transaction(kI2cNumCommandBytesPerFullWrite
	+ (kI2cNumCommandBytesPerWriteByte * data.size()));
	size_t transaction_index = 0;
	size_t bytes_written = 0;

	zx_status_t status = WriteIdleToBuf(transaction_index, &transaction, &bytes_written);
	if (status != ZX_OK) {
	return status;
	}
	transaction_index += bytes_written;

	status = WriteTransactionStartToBuf(transaction_index, &transaction, &bytes_written);
	if (status != ZX_OK) {
	return status;
	}
	transaction_index += bytes_written;

	auto it = data.begin();
	it = data.insert(it, static_cast<uint8_t>(bus_address << 1));

	for (size_t i = 0; i < data.size(); i++) {
	transaction[transaction_index++] = kI2cWriteCommandByte1;
	transaction[transaction_index++] = kI2cWriteCommandByte2;
	transaction[transaction_index++] = kI2cWriteCommandByte3;
	transaction[transaction_index++] = data[i];

	mpsse_.SetGpio(pin_layout_.scl, Mpsse::Direction::OUT, Mpsse::Level::LOW);
	mpsse_.SetGpio(pin_layout_.sda_out, Mpsse::Direction::OUT, Mpsse::Level::HIGH);
	mpsse_.GpioWriteCommandToBuffer(transaction_index, &transaction, &bytes_written);
	transaction_index += bytes_written;

	// Read bit for ACK/NAK.
	transaction[transaction_index++] = kI2cReadAckCommandByte1;
	transaction[transaction_index++] = kI2cReadAckCommandByte2;
	}

	status = WriteTransactionEndToBuf(transaction_index, &transaction, &bytes_written);
	if (status != ZX_OK) {
	return status;
	}
	transaction_index += bytes_written;

	// Ask for response immediately
	transaction[transaction_index++] = kI2cCommandFinishTransaction;

	if (transaction_index != transaction.size()) {
	printf("Index (%ld) != size (%ld) \n", transaction_index, transaction.size());
	return ZX_ERR_INTERNAL;
	}

	status = mpsse_.Write(transaction.data(), transaction.size());
	if (status != ZX_OK) {
	return status;
	}

	std::vector<uint8_t> response(data.size());
	status = mpsse_.Read(response.data(), data.size());
	if (status != ZX_OK) {
	return status;
	}

	// Check each response byte to see if its an ACK (zero) or NACK (non-zero).
	for (size_t i = 0; i < response.size(); i++) {
	if ((response[i] & 0x1) != 0) {
	return ZX_ERR_INTERNAL;
	}
	}

	return ZX_OK;
	}

	zx_status_t FtdiI2c::Ping(uint8_t bus_address) {
	std::vector<uint8_t> data(1);
	data[0] = 0x00;
	return Write(bus_address, data);
	}

	// This adds the command to transition SCL from high to low.
	zx_status_t FtdiI2c::WriteTransactionStartToBuf(size_t index, std::vector<uint8_t>* buffer,
	size_t* bytes_written) {
	size_t sub_written = 0;
	*bytes_written = 0;

	mpsse_.SetGpio(pin_layout_.scl, Mpsse::Direction::OUT, Mpsse::Level::HIGH);
	mpsse_.SetGpio(pin_layout_.sda_out, Mpsse::Direction::OUT, Mpsse::Level::LOW);
	mpsse_.GpioWriteCommandToBuffer(index + *bytes_written, buffer, &sub_written);
	*bytes_written += sub_written;

	mpsse_.SetGpio(pin_layout_.scl, Mpsse::Direction::OUT, Mpsse::Level::LOW);
	mpsse_.SetGpio(pin_layout_.sda_out, Mpsse::Direction::OUT, Mpsse::Level::LOW);
	mpsse_.GpioWriteCommandToBuffer(index + *bytes_written, buffer, &sub_written);
	*bytes_written += sub_written;

	return ZX_OK;
	}

	zx_status_t FtdiI2c::WriteTransactionEndToBuf(size_t index, std::vector<uint8_t>* buffer,
	size_t* bytes_written) {
	size_t sub_written = 0;
	*bytes_written = 0;

	mpsse_.SetGpio(pin_layout_.scl, Mpsse::Direction::OUT, Mpsse::Level::LOW);
	mpsse_.SetGpio(pin_layout_.sda_out, Mpsse::Direction::OUT, Mpsse::Level::LOW);
	mpsse_.GpioWriteCommandToBuffer(index + *bytes_written, buffer, &sub_written);
	*bytes_written += sub_written;

	mpsse_.SetGpio(pin_layout_.scl, Mpsse::Direction::OUT, Mpsse::Level::HIGH);
	mpsse_.SetGpio(pin_layout_.sda_out, Mpsse::Direction::OUT, Mpsse::Level::LOW);
	mpsse_.GpioWriteCommandToBuffer(index + *bytes_written, buffer, &sub_written);
	*bytes_written += sub_written;

	mpsse_.SetGpio(pin_layout_.scl, Mpsse::Direction::OUT, Mpsse::Level::HIGH);
	mpsse_.SetGpio(pin_layout_.sda_out, Mpsse::Direction::OUT, Mpsse::Level::HIGH);
	mpsse_.GpioWriteCommandToBuffer(index + *bytes_written, buffer, &sub_written);
	*bytes_written += sub_written;

	return ZX_OK;
	}

	zx_status_t FtdiI2c::I2cImplTransact(uint32_t bus_id, const i2c_impl_op_t* op_list,
	size_t op_count) {
	zx_status_t status;
	std::vector<uint8_t> write_data(kFtdiI2cMaxTransferSize);
	size_t write_data_index = 0;
	for (size_t i = 0; i < op_count; i++) {
	if (op_list[i].is_read) {
	// TODO(dgilhooley) - Hook up FTDI to an i2c device that supports Read, so
	// Read can be tested and implemented
	return ZX_ERR_NOT_SUPPORTED;
	} else {
	size_t copy_amt = op_list[i].data_size;
	uint8_t* data_buffer = reinterpret_cast<uint8_t*>(op_list[i].data_buffer);
	size_t data_buffer_index = 0;
	while (copy_amt--) {
	if (write_data_index == kFtdiI2cMaxTransferSize) {
	return ZX_ERR_INTERNAL;
	}
	write_data[write_data_index++] = data_buffer[data_buffer_index++];
	}
	}

	if (op_list[i].stop) {
	write_data.resize(write_data_index);
	status = Write(static_cast<uint8_t>(op_list[i].address), write_data);
	if (status != ZX_OK) {
	return status;
	}

	// Reset the write_data for the next transaction.
	write_data.resize(kFtdiI2cMaxTransferSize);
	write_data_index = 0;
	}
	}

	return ZX_OK;
	}

	zx_status_t FtdiI2c::Create(zx_device_t* device,
	const fuchsia_hardware_ftdi_I2cBusLayout* layout,
	const fuchsia_hardware_ftdi_I2cDevice* i2c_dev) {
	// TODO(dgilhooley: Support i2c on different sets of pins and then remove this check.
	if (layout->scl != 0 && layout->sda_out != 1 && layout->sda_in != 2) {
	return ZX_ERR_OUT_OF_RANGE;
	}

	ftdi_mpsse::FtdiI2c::I2cLayout i2c_layout;
	i2c_layout.scl = layout->scl;
	i2c_layout.sda_out = layout->sda_out;
	i2c_layout.sda_in = layout->sda_in;

	std::vector<ftdi_mpsse::FtdiI2c::I2cDevice> i2c_devices(1);
	i2c_devices[0].address = i2c_dev->address;
	i2c_devices[0].vid = i2c_dev->vid;
	i2c_devices[0].pid = i2c_dev->pid;
	i2c_devices[0].did = i2c_dev->did;

	auto dev = std::make_unique<ftdi_mpsse::FtdiI2c>(device, i2c_layout, i2c_devices);
	zx_status_t status = dev->Bind();
	if (status == ZX_OK) {
	// devmgr is now in charge of the memory for dev
	dev.release();
	}

	return ZX_OK;
	}

	} // namespace ftdi_mpsse