src/acpi_multiply/controller/acpi_controller.cc - sdk-samples/drivers - Git at Google

 // Copyright 2022 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 "acpi_controller.h"

 #include <fidl/fuchsia.component.decl/cpp/wire_types.h>
 #include <fidl/fuchsia.driver.framework/cpp/wire.h>
 #include <fidl/fuchsia.hardware.acpi/cpp/wire_types.h>
 #include <fidl/fuchsia.mem/cpp/wire_types.h>
 #include <lib/async/cpp/task.h>
 #include <lib/driver2/record_cpp.h>
 #include <lib/driver2/structured_logger.h>
 #include <lib/fidl/cpp/wire/connect_service.h>
 #include <lib/zx/clock.h>
 #include <zircon/errors.h>
 #include <zircon/syscalls.h>
 #include <zircon/types.h>

 #include "registers.h"

 namespace acpi_multiply {

 zx::status<std::unique_ptr<AcpiMultiplyController>> AcpiMultiplyController::Start(
     fuchsia_driver_framework::wire::DriverStartArgs &start_args, fdf::UnownedDispatcher dispatcher,
     fidl::WireSharedClient<fuchsia_driver_framework::Node> node, driver::Namespace ns,
     driver::Logger logger) {
   auto driver = std::make_unique<AcpiMultiplyController>(
       dispatcher->async_dispatcher(), std::move(node), std::move(ns), std::move(logger));

   auto result = driver->Run(std::move(start_args.outgoing_dir()));
   if (result.is_error()) {
     return result.take_error();
   }

   return zx::ok(std::move(driver));
 }

 zx::status<> AcpiMultiplyController::Run(fidl::ServerEnd<fuchsia_io::Directory> outgoing_dir) {
   // Allocate an MMIO buffer representing the ACPI multiply device
   zx::vmo vmo;
   zx_status_t raw_status = zx::vmo::create(zx_system_get_page_size(), 0, &vmo);
   if (raw_status != ZX_OK) {
     return zx::error(raw_status);
   }

   auto buffer = fdf::MmioBuffer::Create(0, zx_system_get_page_size(), std::move(vmo),
                                         ZX_CACHE_POLICY_UNCACHED_DEVICE);
   if (buffer.is_error()) {
     return buffer.take_error();
   }
   buffer_ = std::move(buffer.value());

   // Create an IRQ resource for the ACPI multiply device
   raw_status = zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq_);
   if (raw_status != ZX_OK) {
     return zx::error(raw_status);
   }

   // Serve `fuchsia.hardware.acpi/Device` to child device nodes
   auto service = [this](fidl::ServerEnd<fuchsia_hardware_acpi::Device> server_end) {
     fidl::BindServer(dispatcher_, std::move(server_end), this);
   };

   auto status = outgoing_.AddProtocol<fuchsia_hardware_acpi::Device>(std::move(service));
   if (status.is_error()) {
     FDF_SLOG(ERROR, "Failed to add protocol", KV("status", status.status_string()));
     return status;
   }

   status = AddChild();
   if (status.is_error()) {
     return status;
   }

   return outgoing_.Serve(std::move(outgoing_dir));
 }

 zx::status<> AcpiMultiplyController::AddChild() {
   fidl::Arena arena;

   // Offer fuchsia.hardware.acpi.Device to the driver that binds to the node.
   auto protocol_offer =
       fuchsia_component_decl::wire::OfferProtocol::Builder(arena)
           .source_name(arena, fidl::DiscoverableProtocolName<fuchsia_hardware_acpi::Device>)
           .target_name(arena, fidl::DiscoverableProtocolName<fuchsia_hardware_acpi::Device>)
           .dependency_type(fuchsia_component_decl::wire::DependencyType::kStrong)
           .Build();
   fuchsia_component_decl::wire::Offer offer =
       fuchsia_component_decl::wire::Offer::WithProtocol(arena, protocol_offer);

   // Set the properties of the node that a driver binds to.
   auto properties = fidl::VectorView<fuchsia_driver_framework::wire::NodeProperty>(arena, 2);
   properties[0] =
       fuchsia_driver_framework::wire::NodeProperty::Builder(arena)
           .key(fuchsia_driver_framework::wire::NodePropertyKey::WithIntValue(1 /* BIND_PROTOCOL */))
           .value(fuchsia_driver_framework::wire::NodePropertyValue::WithIntValue(
               30 /* ZX_PROTOCOL_ACPI */))
           .Build();

   properties[1] = fuchsia_driver_framework::wire::NodeProperty::Builder(arena)
                       .key(fuchsia_driver_framework::wire::NodePropertyKey::WithStringValue(
                           arena, fidl::StringView::FromExternal("fuchsia.acpi.hid")))
                       .value(fuchsia_driver_framework::wire::NodePropertyValue::WithStringValue(
                           arena, fidl::StringView::FromExternal("FDFS0001")))
                       .Build();

   auto args =
       fuchsia_driver_framework::wire::NodeAddArgs::Builder(arena)
           .name(arena, "acpi-child")
           .offers(fidl::VectorView<fuchsia_component_decl::wire::Offer>::FromExternal(&offer, 1))
           .properties(properties)
           .Build();

   // Create endpoints of the `NodeController` for the node.
   auto endpoints = fidl::CreateEndpoints<fuchsia_driver_framework::NodeController>();
   if (endpoints.is_error()) {
     FDF_SLOG(ERROR, "Failed to create endpoint", KV("status", endpoints.status_string()));
     return zx::error(endpoints.status_value());
   }

   auto result = node_.sync()->AddChild(args, std::move(endpoints->server), {});
   if (!result.ok()) {
     FDF_SLOG(ERROR, "Failed to add child", KV("status", result.status_string()));
     return zx::error(result.status());
   }

   return zx::ok();
 }

 // Protocol method for `fuchsia.hardware.acpi/Device` to return a requested MMIO region.
 void AcpiMultiplyController::GetMmio(GetMmioRequestView request,
                                      GetMmioCompleter::Sync &completer) {
   if (request->index != 0) {
     completer.ReplyError(ZX_ERR_OUT_OF_RANGE);
     return;
   }

   zx::vmo clone;
   zx_status_t status = buffer_->get_vmo()->duplicate(ZX_RIGHT_SAME_RIGHTS, &clone);
   if (status != ZX_OK) {
     completer.ReplyError(status);
     return;
   }

   completer.ReplySuccess(fuchsia_mem::wire::Range{
       .vmo = std::move(clone),
       .offset = 0,
       .size = zx_system_get_page_size(),
   });
 }

 // Protocol method for `fuchsia.hardware.acpi/Device` to return the requested IRQ.
 void AcpiMultiplyController::MapInterrupt(MapInterruptRequestView request,
                                           MapInterruptCompleter::Sync &completer) {
   if (request->index != 0) {
     completer.ReplyError(ZX_ERR_OUT_OF_RANGE);
     return;
   }

   zx::interrupt clone;
   zx_status_t status = irq_.duplicate(ZX_RIGHT_SAME_RIGHTS, &clone);
   if (status != ZX_OK) {
     completer.ReplyError(status);
     return;
   }

   completer.ReplySuccess(std::move(clone));
 }

 // Protocol method for `fuchsia.hardware.acpi/Device` to interpret an invoke the control method
 // associated with the provided object path.
 void AcpiMultiplyController::EvaluateObject(EvaluateObjectRequestView request,
                                             EvaluateObjectCompleter::Sync &completer) {
   if (request->mode != fuchsia_hardware_acpi::wire::EvaluateObjectMode::kPlainObject) {
     completer.ReplyError(fuchsia_hardware_acpi::wire::Status::kNotSupported);
     return;
   }

   if (request->path.get() != "_MUL") {
     completer.ReplyError(fuchsia_hardware_acpi::wire::Status::kNotFound);
     return;
   }

   fidl::Arena arena;
   completer.ReplySuccess(fuchsia_hardware_acpi::wire::EncodedObject());
   // To simulate asynchronous hardware, we post a delayed task and trigger an interrupt when the
   // task is complete.
   async::PostDelayedTask(
       dispatcher_,
       [this]() mutable {
         auto value1 = acpi_multiply::MultiplyArgumentReg::Get(true).ReadFrom(&buffer_.value());
         auto value2 = acpi_multiply::MultiplyArgumentReg::Get(false).ReadFrom(&buffer_.value());
         auto status_reg = acpi_multiply::MultiplyStatusReg::Get().FromValue(0);
         auto result_reg = acpi_multiply::MultiplyResultReg::Get().FromValue(0);

         uint32_t result = value1.operand() * value2.operand();
         // Check for overflow
         if (value1.operand() != 0 && result / value1.operand() != value2.operand()) {
           status_reg.set_overflow(true);
         }
         result_reg.set_result(result);
         result_reg.WriteTo(&buffer_.value());
         status_reg.set_finished(true).WriteTo(&buffer_.value());
         zx_status_t status = irq_.trigger(0, zx::clock::get_monotonic());
         if (status != ZX_OK) {
           FDF_SLOG(ERROR, "Failed to trigger interrupt",
                    KV("status", zx_status_get_string(status)));
         }
       },
       zx::msec(10));
 }

 }  // namespace acpi_multiply

 FUCHSIA_DRIVER_RECORD_CPP_V1(acpi_multiply::AcpiMultiplyController);
	// Copyright 2022 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 "acpi_controller.h"

	#include <fidl/fuchsia.component.decl/cpp/wire_types.h>
	#include <fidl/fuchsia.driver.framework/cpp/wire.h>
	#include <fidl/fuchsia.hardware.acpi/cpp/wire_types.h>
	#include <fidl/fuchsia.mem/cpp/wire_types.h>
	#include <lib/async/cpp/task.h>
	#include <lib/driver2/record_cpp.h>
	#include <lib/driver2/structured_logger.h>
	#include <lib/fidl/cpp/wire/connect_service.h>
	#include <lib/zx/clock.h>
	#include <zircon/errors.h>
	#include <zircon/syscalls.h>
	#include <zircon/types.h>

	#include "registers.h"

	namespace acpi_multiply {

	zx::status<std::unique_ptr<AcpiMultiplyController>> AcpiMultiplyController::Start(
	fuchsia_driver_framework::wire::DriverStartArgs &start_args, fdf::UnownedDispatcher dispatcher,
	fidl::WireSharedClient<fuchsia_driver_framework::Node> node, driver::Namespace ns,
	driver::Logger logger) {
	auto driver = std::make_unique<AcpiMultiplyController>(
	dispatcher->async_dispatcher(), std::move(node), std::move(ns), std::move(logger));

	auto result = driver->Run(std::move(start_args.outgoing_dir()));
	if (result.is_error()) {
	return result.take_error();
	}

	return zx::ok(std::move(driver));
	}

	zx::status<> AcpiMultiplyController::Run(fidl::ServerEnd<fuchsia_io::Directory> outgoing_dir) {
	// Allocate an MMIO buffer representing the ACPI multiply device
	zx::vmo vmo;
	zx_status_t raw_status = zx::vmo::create(zx_system_get_page_size(), 0, &vmo);
	if (raw_status != ZX_OK) {
	return zx::error(raw_status);
	}

	auto buffer = fdf::MmioBuffer::Create(0, zx_system_get_page_size(), std::move(vmo),
	ZX_CACHE_POLICY_UNCACHED_DEVICE);
	if (buffer.is_error()) {
	return buffer.take_error();
	}
	buffer_ = std::move(buffer.value());

	// Create an IRQ resource for the ACPI multiply device
	raw_status = zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq_);
	if (raw_status != ZX_OK) {
	return zx::error(raw_status);
	}

	// Serve `fuchsia.hardware.acpi/Device` to child device nodes
	auto service = [this](fidl::ServerEnd<fuchsia_hardware_acpi::Device> server_end) {
	fidl::BindServer(dispatcher_, std::move(server_end), this);
	};

	auto status = outgoing_.AddProtocol<fuchsia_hardware_acpi::Device>(std::move(service));
	if (status.is_error()) {
	FDF_SLOG(ERROR, "Failed to add protocol", KV("status", status.status_string()));
	return status;
	}

	status = AddChild();
	if (status.is_error()) {
	return status;
	}

	return outgoing_.Serve(std::move(outgoing_dir));
	}

	zx::status<> AcpiMultiplyController::AddChild() {
	fidl::Arena arena;

	// Offer fuchsia.hardware.acpi.Device to the driver that binds to the node.
	auto protocol_offer =
	fuchsia_component_decl::wire::OfferProtocol::Builder(arena)
	.source_name(arena, fidl::DiscoverableProtocolName<fuchsia_hardware_acpi::Device>)
	.target_name(arena, fidl::DiscoverableProtocolName<fuchsia_hardware_acpi::Device>)
	.dependency_type(fuchsia_component_decl::wire::DependencyType::kStrong)
	.Build();
	fuchsia_component_decl::wire::Offer offer =
	fuchsia_component_decl::wire::Offer::WithProtocol(arena, protocol_offer);

	// Set the properties of the node that a driver binds to.
	auto properties = fidl::VectorView<fuchsia_driver_framework::wire::NodeProperty>(arena, 2);
	properties[0] =
	fuchsia_driver_framework::wire::NodeProperty::Builder(arena)
	.key(fuchsia_driver_framework::wire::NodePropertyKey::WithIntValue(1 /* BIND_PROTOCOL */))
	.value(fuchsia_driver_framework::wire::NodePropertyValue::WithIntValue(
	30 /* ZX_PROTOCOL_ACPI */))
	.Build();

	properties[1] = fuchsia_driver_framework::wire::NodeProperty::Builder(arena)
	.key(fuchsia_driver_framework::wire::NodePropertyKey::WithStringValue(
	arena, fidl::StringView::FromExternal("fuchsia.acpi.hid")))
	.value(fuchsia_driver_framework::wire::NodePropertyValue::WithStringValue(
	arena, fidl::StringView::FromExternal("FDFS0001")))
	.Build();

	auto args =
	fuchsia_driver_framework::wire::NodeAddArgs::Builder(arena)
	.name(arena, "acpi-child")
	.offers(fidl::VectorView<fuchsia_component_decl::wire::Offer>::FromExternal(&offer, 1))
	.properties(properties)
	.Build();

	// Create endpoints of the `NodeController` for the node.
	auto endpoints = fidl::CreateEndpoints<fuchsia_driver_framework::NodeController>();
	if (endpoints.is_error()) {
	FDF_SLOG(ERROR, "Failed to create endpoint", KV("status", endpoints.status_string()));
	return zx::error(endpoints.status_value());
	}

	auto result = node_.sync()->AddChild(args, std::move(endpoints->server), {});
	if (!result.ok()) {
	FDF_SLOG(ERROR, "Failed to add child", KV("status", result.status_string()));
	return zx::error(result.status());
	}

	return zx::ok();
	}

	// Protocol method for `fuchsia.hardware.acpi/Device` to return a requested MMIO region.
	void AcpiMultiplyController::GetMmio(GetMmioRequestView request,
	GetMmioCompleter::Sync &completer) {
	if (request->index != 0) {
	completer.ReplyError(ZX_ERR_OUT_OF_RANGE);
	return;
	}

	zx::vmo clone;
	zx_status_t status = buffer_->get_vmo()->duplicate(ZX_RIGHT_SAME_RIGHTS, &clone);
	if (status != ZX_OK) {
	completer.ReplyError(status);
	return;
	}

	completer.ReplySuccess(fuchsia_mem::wire::Range{
	.vmo = std::move(clone),
	.offset = 0,
	.size = zx_system_get_page_size(),
	});
	}

	// Protocol method for `fuchsia.hardware.acpi/Device` to return the requested IRQ.
	void AcpiMultiplyController::MapInterrupt(MapInterruptRequestView request,
	MapInterruptCompleter::Sync &completer) {
	if (request->index != 0) {
	completer.ReplyError(ZX_ERR_OUT_OF_RANGE);
	return;
	}

	zx::interrupt clone;
	zx_status_t status = irq_.duplicate(ZX_RIGHT_SAME_RIGHTS, &clone);
	if (status != ZX_OK) {
	completer.ReplyError(status);
	return;
	}

	completer.ReplySuccess(std::move(clone));
	}

	// Protocol method for `fuchsia.hardware.acpi/Device` to interpret an invoke the control method
	// associated with the provided object path.
	void AcpiMultiplyController::EvaluateObject(EvaluateObjectRequestView request,
	EvaluateObjectCompleter::Sync &completer) {
	if (request->mode != fuchsia_hardware_acpi::wire::EvaluateObjectMode::kPlainObject) {
	completer.ReplyError(fuchsia_hardware_acpi::wire::Status::kNotSupported);
	return;
	}

	if (request->path.get() != "_MUL") {
	completer.ReplyError(fuchsia_hardware_acpi::wire::Status::kNotFound);
	return;
	}

	fidl::Arena arena;
	completer.ReplySuccess(fuchsia_hardware_acpi::wire::EncodedObject());
	// To simulate asynchronous hardware, we post a delayed task and trigger an interrupt when the
	// task is complete.
	async::PostDelayedTask(
	dispatcher_,
	[this]() mutable {
	auto value1 = acpi_multiply::MultiplyArgumentReg::Get(true).ReadFrom(&buffer_.value());
	auto value2 = acpi_multiply::MultiplyArgumentReg::Get(false).ReadFrom(&buffer_.value());
	auto status_reg = acpi_multiply::MultiplyStatusReg::Get().FromValue(0);
	auto result_reg = acpi_multiply::MultiplyResultReg::Get().FromValue(0);

	uint32_t result = value1.operand() * value2.operand();
	// Check for overflow
	if (value1.operand() != 0 && result / value1.operand() != value2.operand()) {
	status_reg.set_overflow(true);
	}
	result_reg.set_result(result);
	result_reg.WriteTo(&buffer_.value());
	status_reg.set_finished(true).WriteTo(&buffer_.value());
	zx_status_t status = irq_.trigger(0, zx::clock::get_monotonic());
	if (status != ZX_OK) {
	FDF_SLOG(ERROR, "Failed to trigger interrupt",
	KV("status", zx_status_get_string(status)));
	}
	},
	zx::msec(10));
	}

	} // namespace acpi_multiply

	FUCHSIA_DRIVER_RECORD_CPP_V1(acpi_multiply::AcpiMultiplyController);