blob: 3a43f14f786069de9ce15214f23dbebbcc78c915 [file] [edit]
// 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 "src/devices/i2c/drivers/i2c/i2c.h"
#include <fidl/fuchsia.hardware.i2c/cpp/fidl.h>
#include <fidl/fuchsia.hardware.i2cimpl/cpp/fidl.h>
#include <fidl/fuchsia.scheduler/cpp/fidl.h>
#include <lib/driver/component/cpp/driver_export.h>
#include <lib/driver/logging/cpp/logger.h>
#include <lib/driver/metadata/cpp/metadata.h>
#include <lib/trace/event.h>
#include "src/devices/i2c/drivers/i2c/i2c_parser.h"
namespace i2c {
namespace {
fuchsia_hardware_i2c_businfo::I2CBusMetadata ConvertMetadata(i2c_metadata::I2cMetadata generic) {
std::vector<fuchsia_hardware_i2c_businfo::I2CChannel> channels;
for (auto& c : generic.channels) {
fuchsia_hardware_i2c_businfo::I2CChannel channel;
channel.address(c.address);
if (c.id) {
channel.global_id(*c.id);
}
if (c.name) {
channel.name(std::move(*c.name));
}
channels.push_back(std::move(channel));
}
return {{.channels = std::move(channels), .bus_id = generic.bus_id}};
}
} // namespace
zx::result<> I2cDriver::Start(fdf::DriverContext context) {
auto incoming = std::shared_ptr<fdf::Namespace>(context.take_incoming());
auto i2cimpl_result = incoming->Connect<fuchsia_hardware_i2cimpl::Service::Device>();
if (i2cimpl_result.is_error()) {
fdf::error("Failed to connect to fuchsia.hardware.i2cimpl service: {}", i2cimpl_result);
return i2cimpl_result.take_error();
}
i2c_.Bind(std::move(*i2cimpl_result), fdf::Dispatcher::GetCurrent()->get());
fidl::Arena arena;
std::optional<fuchsia_hardware_i2c_businfo::I2CBusMetadata> metadata;
// Try to get generic metadata first
zx::result generic_res =
fdf_metadata::GetMetadataFromFidlServiceIfExists<fuchsia_driver_metadata::Dictionary>(
incoming->svc_dir(), "fuchsia.hardware.i2c.businfo.I2CBusMetadata");
if (generic_res.is_ok() && generic_res.value().has_value()) {
auto parsed = i2c_metadata::I2cMetadata::Parse(*generic_res.value());
if (parsed) {
metadata = ConvertMetadata(std::move(*parsed));
} else {
fdf::error("Failed to parse generic I2C metadata");
}
}
if (!metadata.has_value()) {
// Fall back to old metadata
zx::result i2c_bus_metadata_res =
fdf_metadata::GetMetadata<fuchsia_hardware_i2c_businfo::I2CBusMetadata>(incoming);
if (i2c_bus_metadata_res.is_error()) {
fdf::error("Failed to get i2c_bus_metadata {}", i2c_bus_metadata_res);
return i2c_bus_metadata_res.take_error();
}
metadata = std::move(*i2c_bus_metadata_res);
}
fuchsia_hardware_i2c_businfo::I2CBusMetadata i2c_bus_metadata = std::move(*metadata);
if (!i2c_bus_metadata.channels().has_value()) {
fdf::error("No channels supplied from the metadata");
return zx::error(ZX_ERR_NO_RESOURCES);
}
fdf::Arena i2c_arena('I2CI');
fdf::WireUnownedResult max_transfer_size = i2c_.sync().buffer(i2c_arena)->GetMaxTransferSize();
if (!max_transfer_size.ok()) {
fdf::error("Failed to send GetMaxTransferSize request: {}", max_transfer_size.status_string());
return zx::error(max_transfer_size.status());
}
if (max_transfer_size->is_error()) {
fdf::error("Failed to get max transfer size: {}",
zx_status_get_string(max_transfer_size->error_value()));
return zx::error(max_transfer_size->error_value());
}
max_transfer_ = max_transfer_size->value()->size;
// Add owned i2c node.
zx::result child = AddOwnedChild("i2c");
if (child.is_error()) {
fdf::error("failed to add i2c child node: {}", child);
return child.take_error();
}
i2c_node_ = std::move(child->node_);
const auto config = context.take_config<i2c_config::Config>();
if (zx::result<> result = AddI2cChildren(i2c_bus_metadata, config, context.node_name(), incoming);
result.is_error()) {
return result;
}
zx_status_t status =
fdf_dispatcher_seal(driver_dispatcher()->get(), FDF_DISPATCHER_OPTION_ALLOW_SYNC_CALLS);
if (status != ZX_OK) {
fdf::error("Failed to sync seal dispatcher: {}", zx_status_get_string(status));
return zx::error(status);
}
return zx::ok();
}
void I2cDriver::Stop(fdf::StopCompleter completer) {
shutdown_ = true;
completer(zx::ok());
}
I2cDriver::~I2cDriver() {
// The dispatcher has been stopped, meaning the current request must have already been completed.
ZX_DEBUG_ASSERT(!current_request_.has_value());
std::ranges::for_each(pending_requests_.begin(), pending_requests_.end(),
[](Request& request) { request.Complete(ZX_ERR_CANCELED); });
}
zx::result<> I2cDriver::AddI2cChildren(const fuchsia_hardware_i2c_businfo::I2CBusMetadata& metadata,
i2c_config::Config config,
const std::optional<std::string>& node_name,
const std::shared_ptr<fdf::Namespace>& incoming) {
if (!metadata.channels()) {
fdf::error("Failed to find number of channels in metadata: {}",
zx_status_get_string(ZX_ERR_NOT_FOUND));
return zx::error(ZX_ERR_NOT_FOUND);
}
fdf::debug("Number of i2c channels supplied: {}", metadata.channels()->size());
const uint32_t bus_id = metadata.bus_id().value_or(0);
for (const auto& channel : metadata.channels().value()) {
// Add an i2c child to the owned i2c node.
auto i2c_child_server = I2cChildServer::CreateAndAddChild(
fit::bind_member(this, &I2cDriver::Transact), i2c_node_, logger(), bus_id, channel,
incoming, outgoing(), node_name, config);
if (i2c_child_server.is_error()) {
fdf::error("Failed to create child server: {}",
zx_status_get_string(i2c_child_server.error_value()));
return i2c_child_server.take_error();
}
child_servers_.push_back(std::move(i2c_child_server.value()));
}
return zx::ok();
}
void I2cDriver::Transact(uint16_t address, TransferRequestView request,
TransferCompleter::Sync& completer) {
TRACE_DURATION("i2c", "I2cDevice Process Queued Transacts");
if (shutdown_) {
completer.ReplyError(ZX_ERR_CANCELED);
return;
}
if (request->transactions.size() < 1) {
completer.ReplyError(ZX_ERR_INVALID_ARGS);
return;
}
if (request->transactions.size() > fuchsia_hardware_i2c::wire::kMaxCountTransactions) {
completer.ReplyError(ZX_ERR_OUT_OF_RANGE);
return;
}
RequestConverter converter(request, address, max_transfer_);
if (current_request_.has_value()) {
if (pending_requests_.size() >= kMaxTransactionsPerChild * child_servers_.size()) {
fdf::error("Queue is full, dropping request");
completer.ReplyError(ZX_ERR_SHOULD_WAIT);
return;
}
// An I2C request is already pending. Save this request and push it to the queue to be completed
// later.
zx_status_t status = pending_requests_.emplace_back(completer.ToAsync()).SaveRequest(converter);
if (status != ZX_OK) {
pending_requests_.back().Complete(status);
pending_requests_.pop_back();
}
return;
}
// If no request is pending, we can immediately call to the i2cimpl driver without persisting the
// request data.
impl_ops_.clear();
impl_ops_.insert(impl_ops_.cend(), request->transactions.size(), {});
zx_status_t status = converter.Convert(
[](fidl::VectorView<uint8_t>& write_vector) {
return fidl::ObjectView<fidl::VectorView<uint8_t>>::FromExternal(&write_vector);
},
impl_ops_);
if (status == ZX_OK) {
current_request_.emplace(
fidl::VectorView<fuchsia_hardware_i2cimpl::wire::I2cImplOp>::FromExternal(impl_ops_),
completer.ToAsync());
StartCurrentRequest();
} else {
completer.ReplyError(status);
}
impl_ops_.clear();
}
void I2cDriver::StartCurrentRequest() {
ZX_DEBUG_ASSERT(current_request_.has_value());
RequestStorage& request = *current_request_;
i2c_.buffer(request.arena())
->Transact(request->ops())
.ThenExactlyOnce(fit::bind_member<&I2cDriver::CompleteRequest>(this));
}
void I2cDriver::CompleteRequest(
fdf::WireUnownedResult<fuchsia_hardware_i2cimpl::Device::Transact>& result) {
TRACE_DURATION("i2c", "I2cDevice Complete Transacts");
ZX_DEBUG_ASSERT(current_request_.has_value());
if (RequestStorage& request = current_request_.value(); !result.ok()) {
if (!shutdown_ || !result.error().is_dispatcher_shutdown()) {
fdf::error("Failed to send Transfer request: {}", result.status_string());
}
request->Complete(result.status());
} else if (result->is_error()) {
// Don't log at ERROR severity here, as some I2C devices intentionally NACK to indicate that
// they are busy.
fdf::debug("Failed to perform transfer: {}", zx_status_get_string(result->error_value()));
request->Complete(result->error_value());
} else {
read_vectors_.clear();
for (const auto& read : result.value()->read) {
read_vectors_.emplace_back(read.data);
}
request->Complete(fidl::VectorView<fidl::VectorView<uint8_t>>::FromExternal(read_vectors_));
read_vectors_.clear();
}
current_request_.reset();
// Break on shutdown to prevent recursive calls to cancel every request in the queue.
if (!pending_requests_.empty() && !shutdown_) {
current_request_.emplace(&pending_requests_.front(), GetCurrentRequestDeleter());
StartCurrentRequest();
}
}
} // namespace i2c
FUCHSIA_DRIVER_EXPORT2(i2c::I2cDriver);