src/devices/board/drivers/x86/x86.cc - 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 "src/devices/board/drivers/x86/x86.h"

 #include <fidl/fuchsia.hardware.acpi/cpp/wire.h>
 #include <fidl/fuchsia.hardware.platform.bus/cpp/driver/fidl.h>
 #include <fidl/fuchsia.hardware.platform.bus/cpp/fidl.h>
 #include <lib/async/cpp/task.h>
 #include <lib/ddk/binding_driver.h>
 #include <lib/ddk/debug.h>
 #include <lib/ddk/driver.h>
 #include <lib/ddk/metadata.h>
 #include <lib/ddk/platform-defs.h>
 #include <lib/driver-unit-test/utils.h>
 #include <lib/fdf/cpp/dispatcher.h>
 #include <stdlib.h>
 #include <string.h>
 #include <zircon/status.h>

 #include <acpica/acpi.h>
 #include <ddktl/fidl.h>
 #include <fbl/alloc_checker.h>
 #include <fbl/vector.h>

 #include "src/devices/board/drivers/x86/include/acpi.h"
 #include "src/devices/board/drivers/x86/include/sysmem.h"
 #include "src/devices/board/lib/acpi/manager-fuchsia.h"
 #include "src/devices/board/lib/smbios/smbios.h"

 using fuchsia_acpi_tables::wire::kMaxAcpiTableEntries;
 using fuchsia_acpi_tables::wire::TableInfo;

 zx_handle_t mmio_resource_handle;
 zx_handle_t ioport_resource_handle;
 zx_handle_t irq_resource_handle;
 zx_handle_t power_resource_handle;

 namespace x86 {

 void SysSuspender::Callback(CallbackRequestView request, CallbackCompleter::Sync& completer) {
   uint8_t out_state;
   zx_status_t status = acpi_suspend(device_, request->requested_state, request->enable_wake,
                                     request->suspend_reason, &out_state);
   completer.Reply(status, out_state);
 }

 namespace fpbus = fuchsia_hardware_platform_bus;

 X86::~X86() {
   if (acpica_initialized_) {
     AcpiTerminate();
   }
 }

 zx_status_t X86::DoInit() {
   // Create the ACPI manager.
   acpi_manager_ = std::make_unique<acpi::FuchsiaManager>(acpi_.get(), &iommu_manager_, zxdev());

   zx_status_t status = SysmemInit();
   if (status != ZX_OK) {
     zxlogf(ERROR, "%s: SysmemInit() failed: %d", __func__, status);
     return status;
   }

   status = publish_acpi_devices(acpi_manager_.get(), parent(), zxdev());
   if (status != ZX_OK) {
     zxlogf(ERROR, "%s: publish_acpi_devices() failed: %d", __func__, status);
     return status;
   }

   status = GoldfishControlInit();
   if (status != ZX_OK) {
     zxlogf(ERROR, "%s: GoldfishControlInit() failed: %d", __func__, status);
     return status;
   }
   return ZX_OK;
 }

 void X86::DdkInit(ddk::InitTxn txn) {
   async::PostTask(fdf::Dispatcher::GetCurrent()->async_dispatcher(),
                   [txn = std::move(txn), this]() mutable {
                     zx_status_t status = DoInit();
                     txn.Reply(status);
                   });
 }

 void X86::DdkRelease() { delete this; }

 zx_status_t X86::Create(void* ctx, zx_device_t* parent, std::unique_ptr<X86>* out) {
   auto endpoints = fdf::CreateEndpoints<fpbus::PlatformBus>();
   if (endpoints.is_error()) {
     return endpoints.error_value();
   }

   zx_status_t status = device_connect_runtime_protocol(
       parent, fpbus::Service::PlatformBus::ServiceName, fpbus::Service::PlatformBus::Name,
       endpoints->server.TakeHandle().release());
   if (status != ZX_OK) {
     zxlogf(ERROR, "Failed to connect to platform bus: %s", zx_status_get_string(status));
     return status;
   }

   ZX_ASSERT(zx_handle_duplicate(get_ioport_resource(parent), ZX_RIGHT_SAME_RIGHTS,
                                 &ioport_resource_handle) == ZX_OK);

   ZX_ASSERT(zx_handle_duplicate(get_mmio_resource(parent), ZX_RIGHT_SAME_RIGHTS,
                                 &mmio_resource_handle) == ZX_OK);

   ZX_ASSERT(zx_handle_duplicate(get_irq_resource(parent), ZX_RIGHT_SAME_RIGHTS,
                                 &irq_resource_handle) == ZX_OK);

   ZX_ASSERT(zx_handle_duplicate(get_power_resource(parent), ZX_RIGHT_SAME_RIGHTS,
                                 &power_resource_handle) == ZX_OK);

   fbl::AllocChecker ac;
   *out = fbl::make_unique_checked<X86>(&ac, parent, std::move(endpoints->client),
                                        std::make_unique<acpi::AcpiImpl>());
   if (!ac.check()) {
     return ZX_ERR_NO_MEMORY;
   }
   return ZX_OK;
 }

 zx_status_t X86::CreateAndBind(void* ctx, zx_device_t* parent) {
   std::unique_ptr<X86> board;

   zx_status_t status = Create(ctx, parent, &board);
   if (status != ZX_OK) {
     return status;
   }

   status = board->Bind();
   if (status == ZX_OK) {
     // DevMgr now owns this pointer, release it to avoid destroying the
     // object when device goes out of scope.
     [[maybe_unused]] auto* ptr = board.release();
   }
   return status;
 }

 static void SetField(const char* label, const std::string& value, std::optional<std::string>& out) {
   if (value.empty()) {
     zxlogf(ERROR, "acpi: smbios %s could not be read", label);
   } else if (value.size() >= fpbus::kMaxInfoStringLength) {
     zxlogf(INFO, "acpi: smbios %s too big for sysinfo: %s", label, value.data());
   } else {
     out = value;
   }
 }

 zx_status_t X86::Bind() {
   // Do early init of ACPICA etc.
   zx_status_t status = EarlyInit();
   if (status != ZX_OK) {
     zxlogf(ERROR, "%s: failed to perform early initialization %d ", __func__, status);
     return status;
   }

   // publish the board as ACPI root under /dev/sys/platform. PCI will get created under /dev/sys
   // (to preserve compatibility).
   status = DdkAdd("acpi", DEVICE_ADD_NON_BINDABLE);

   if (status != ZX_OK) {
     zxlogf(ERROR, "acpi: error %d in device_add(sys/platform/pt/acpi)", status);
     return status;
   }

   fpbus::BoardInfo board_info;
   board_info.board_name() = "x64";
   board_info.board_revision() = 0;
   fpbus::BootloaderInfo bootloader_info;
   bootloader_info.vendor() = "<unknown>";

   // Load SMBIOS information.
   smbios::SmbiosInfo smbios;
   status = smbios.Load(zx::unowned_resource(get_mmio_resource(parent())));
   if (status == ZX_OK) {
     SetField("board name", smbios.board_name(), board_info.board_name());
     SetField("vendor", smbios.vendor(), bootloader_info.vendor());
   }

   fdf::Arena arena('X86I');
   {
     // Inform the platform bus of our board info.
     fidl::Arena fidl_arena;
     auto result = pbus_.buffer(arena)->SetBoardInfo(fidl::ToWire(fidl_arena, board_info));
     if (!result.ok()) {
       zxlogf(ERROR, "SetBoardInfo request failed: %s", result.FormatDescription().data());
     } else if (result->is_error()) {
       zxlogf(ERROR, "SetBoardInfo failed: %s", zx_status_get_string(result->error_value()));
     }
   }

   {
     // Inform the platform bus of our bootloader info.
     fidl::Arena fidl_arena;
     auto result = pbus_.buffer(arena)->SetBootloaderInfo(fidl::ToWire(fidl_arena, bootloader_info));
     if (!result.ok()) {
       zxlogf(ERROR, "SetBootloaderInfo request failed: %s", result.FormatDescription().data());
     } else if (result->is_error()) {
       zxlogf(ERROR, "SetBootloaderInfo failed: %s", zx_status_get_string(result->error_value()));
     }
   }

   // Set the "sys" suspend op in platform-bus.
   // The devmgr coordinator code that arranges ordering in which the suspend hooks
   // are called makes sure the suspend hook attached to sys/ is called dead last,
   // (coordinator.cpp:BuildSuspendList()). If move this suspend hook elsewhere,
   // we must make sure that the coordinator code arranges for this suspend op to be
   // called last.
   auto endpoints = fidl::CreateEndpoints<fpbus::SysSuspend>();
   if (endpoints.is_error()) {
     zxlogf(ERROR, "%s: Could not create suspend callback endpoints: %s", __func__,
            endpoints.status_string());
   } else {
     suspender_loop_.StartThread("sys suspender");
     fidl::BindServer(suspender_loop_.dispatcher(), std::move(endpoints->server), &suspender_);
     auto result = pbus_.buffer(arena)->RegisterSysSuspendCallback(std::move(endpoints->client));
     if (!result.ok()) {
       zxlogf(ERROR, "RegisterSysSuspendCallback request failed: %s",
              result.FormatDescription().data());
     } else if (result->is_error()) {
       zxlogf(ERROR, "RegisterSysSuspendCallback failed: %s",
              zx_status_get_string(result->error_value()));
     }
   }

   return ZX_OK;
 }

 bool X86::RunUnitTests(void* ctx, zx_device_t* parent, zx_handle_t channel) {
   return driver_unit_test::RunZxTests("X86Tests", parent, channel);
 }

 zx_status_t X86::GetAcpiTableEntries(fbl::Vector<TableInfo>* entries) {
   ZX_DEBUG_ASSERT(acpica_initialized_);

   for (uint32_t i = 0; i < kMaxAcpiTableEntries; i++) {
     // Fetch the next table entry.
     ACPI_TABLE_HEADER* table;
     ACPI_STATUS status = AcpiGetTableByIndex(i, &table);
     if (status == AE_BAD_PARAMETER) {
       // End of iteration.
       break;
     } else if (status != AE_OK) {
       // Unexpected error.
       return ZX_ERR_INTERNAL;
     }

     // Create an ACPI table header entry.
     TableInfo info;
     static_assert(sizeof(info.name) == sizeof(table->Signature));
     memcpy(info.name.data(), table->Signature, sizeof(table->Signature));
     info.size = table->Length;

     // Add it to the list.
     fbl::AllocChecker ac;
     entries->push_back(info, &ac);
     if (!ac.check()) {
       return ZX_ERR_NO_MEMORY;
     }
   }

   return ZX_OK;
 }

 void X86::ListTableEntries(ListTableEntriesCompleter::Sync& completer) {
   ZX_DEBUG_ASSERT(acpica_initialized_);

   // Fetch the entries.
   fbl::Vector<TableInfo> entries;
   zx_status_t status = GetAcpiTableEntries(&entries);
   if (status != ZX_OK) {
     completer.ReplyError(status);
     return;
   }

   // Send them back to the user.
   completer.ReplySuccess(fidl::VectorView<TableInfo>::FromExternal(entries.data(), entries.size()));
 }

 void X86::ReadNamedTable(ReadNamedTableRequestView request,
                          ReadNamedTableCompleter::Sync& completer) {
   // Fetch the requested table.
   ACPI_TABLE_HEADER* table;
   if (ACPI_STATUS status =
           AcpiGetTable(reinterpret_cast<char*>(request->name.data()), request->instance, &table);
       status != AE_OK) {
     completer.ReplyError(status == AE_NOT_FOUND ? ZX_ERR_NOT_FOUND : ZX_ERR_INTERNAL);
     return;
   }

   // Copy it into the VMO.
   if (zx_status_t status =
           request->result.write(reinterpret_cast<uint8_t*>(table), /*offset=*/0, table->Length);
       status != ZX_OK) {
     completer.ReplyError(status);
     return;
   }

   completer.ReplySuccess(table->Length);
 }

 static zx_driver_ops_t x86_driver_ops = []() {
   zx_driver_ops_t ops = {};
   ops.version = DRIVER_OPS_VERSION;
   ops.bind = X86::CreateAndBind;
   ops.run_unit_tests = X86::RunUnitTests;
   return ops;
 }();

 }  // namespace x86

 ZIRCON_DRIVER(acpi_bus, x86::x86_driver_ops, "zircon", "0.1");
	// 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/board/drivers/x86/x86.h"

	#include <fidl/fuchsia.hardware.acpi/cpp/wire.h>
	#include <fidl/fuchsia.hardware.platform.bus/cpp/driver/fidl.h>
	#include <fidl/fuchsia.hardware.platform.bus/cpp/fidl.h>
	#include <lib/async/cpp/task.h>
	#include <lib/ddk/binding_driver.h>
	#include <lib/ddk/debug.h>
	#include <lib/ddk/driver.h>
	#include <lib/ddk/metadata.h>
	#include <lib/ddk/platform-defs.h>
	#include <lib/driver-unit-test/utils.h>
	#include <lib/fdf/cpp/dispatcher.h>
	#include <stdlib.h>
	#include <string.h>
	#include <zircon/status.h>

	#include <acpica/acpi.h>
	#include <ddktl/fidl.h>
	#include <fbl/alloc_checker.h>
	#include <fbl/vector.h>

	#include "src/devices/board/drivers/x86/include/acpi.h"
	#include "src/devices/board/drivers/x86/include/sysmem.h"
	#include "src/devices/board/lib/acpi/manager-fuchsia.h"
	#include "src/devices/board/lib/smbios/smbios.h"

	using fuchsia_acpi_tables::wire::kMaxAcpiTableEntries;
	using fuchsia_acpi_tables::wire::TableInfo;

	zx_handle_t mmio_resource_handle;
	zx_handle_t ioport_resource_handle;
	zx_handle_t irq_resource_handle;
	zx_handle_t power_resource_handle;

	namespace x86 {

	void SysSuspender::Callback(CallbackRequestView request, CallbackCompleter::Sync& completer) {
	uint8_t out_state;
	zx_status_t status = acpi_suspend(device_, request->requested_state, request->enable_wake,
	request->suspend_reason, &out_state);
	completer.Reply(status, out_state);
	}

	namespace fpbus = fuchsia_hardware_platform_bus;

	X86::~X86() {
	if (acpica_initialized_) {
	AcpiTerminate();
	}
	}

	zx_status_t X86::DoInit() {
	// Create the ACPI manager.
	acpi_manager_ = std::make_unique<acpi::FuchsiaManager>(acpi_.get(), &iommu_manager_, zxdev());

	zx_status_t status = SysmemInit();
	if (status != ZX_OK) {
	zxlogf(ERROR, "%s: SysmemInit() failed: %d", __func__, status);
	return status;
	}

	status = publish_acpi_devices(acpi_manager_.get(), parent(), zxdev());
	if (status != ZX_OK) {
	zxlogf(ERROR, "%s: publish_acpi_devices() failed: %d", __func__, status);
	return status;
	}

	status = GoldfishControlInit();
	if (status != ZX_OK) {
	zxlogf(ERROR, "%s: GoldfishControlInit() failed: %d", __func__, status);
	return status;
	}
	return ZX_OK;
	}

	void X86::DdkInit(ddk::InitTxn txn) {
	async::PostTask(fdf::Dispatcher::GetCurrent()->async_dispatcher(),
	[txn = std::move(txn), this]() mutable {
	zx_status_t status = DoInit();
	txn.Reply(status);
	});
	}

	void X86::DdkRelease() { delete this; }

	zx_status_t X86::Create(void* ctx, zx_device_t* parent, std::unique_ptr<X86>* out) {
	auto endpoints = fdf::CreateEndpoints<fpbus::PlatformBus>();
	if (endpoints.is_error()) {
	return endpoints.error_value();
	}

	zx_status_t status = device_connect_runtime_protocol(
	parent, fpbus::Service::PlatformBus::ServiceName, fpbus::Service::PlatformBus::Name,
	endpoints->server.TakeHandle().release());
	if (status != ZX_OK) {
	zxlogf(ERROR, "Failed to connect to platform bus: %s", zx_status_get_string(status));
	return status;
	}

	ZX_ASSERT(zx_handle_duplicate(get_ioport_resource(parent), ZX_RIGHT_SAME_RIGHTS,
	&ioport_resource_handle) == ZX_OK);

	ZX_ASSERT(zx_handle_duplicate(get_mmio_resource(parent), ZX_RIGHT_SAME_RIGHTS,
	&mmio_resource_handle) == ZX_OK);

	ZX_ASSERT(zx_handle_duplicate(get_irq_resource(parent), ZX_RIGHT_SAME_RIGHTS,
	&irq_resource_handle) == ZX_OK);

	ZX_ASSERT(zx_handle_duplicate(get_power_resource(parent), ZX_RIGHT_SAME_RIGHTS,
	&power_resource_handle) == ZX_OK);

	fbl::AllocChecker ac;
	*out = fbl::make_unique_checked<X86>(&ac, parent, std::move(endpoints->client),
	std::make_unique<acpi::AcpiImpl>());
	if (!ac.check()) {
	return ZX_ERR_NO_MEMORY;
	}
	return ZX_OK;
	}

	zx_status_t X86::CreateAndBind(void* ctx, zx_device_t* parent) {
	std::unique_ptr<X86> board;

	zx_status_t status = Create(ctx, parent, &board);
	if (status != ZX_OK) {
	return status;
	}

	status = board->Bind();
	if (status == ZX_OK) {
	// DevMgr now owns this pointer, release it to avoid destroying the
	// object when device goes out of scope.
	[[maybe_unused]] auto* ptr = board.release();
	}
	return status;
	}

	static void SetField(const char* label, const std::string& value, std::optional<std::string>& out) {
	if (value.empty()) {
	zxlogf(ERROR, "acpi: smbios %s could not be read", label);
	} else if (value.size() >= fpbus::kMaxInfoStringLength) {
	zxlogf(INFO, "acpi: smbios %s too big for sysinfo: %s", label, value.data());
	} else {
	out = value;
	}
	}

	zx_status_t X86::Bind() {
	// Do early init of ACPICA etc.
	zx_status_t status = EarlyInit();
	if (status != ZX_OK) {
	zxlogf(ERROR, "%s: failed to perform early initialization %d ", __func__, status);
	return status;
	}

	// publish the board as ACPI root under /dev/sys/platform. PCI will get created under /dev/sys
	// (to preserve compatibility).
	status = DdkAdd("acpi", DEVICE_ADD_NON_BINDABLE);

	if (status != ZX_OK) {
	zxlogf(ERROR, "acpi: error %d in device_add(sys/platform/pt/acpi)", status);
	return status;
	}

	fpbus::BoardInfo board_info;
	board_info.board_name() = "x64";
	board_info.board_revision() = 0;
	fpbus::BootloaderInfo bootloader_info;
	bootloader_info.vendor() = "<unknown>";

	// Load SMBIOS information.
	smbios::SmbiosInfo smbios;
	status = smbios.Load(zx::unowned_resource(get_mmio_resource(parent())));
	if (status == ZX_OK) {
	SetField("board name", smbios.board_name(), board_info.board_name());
	SetField("vendor", smbios.vendor(), bootloader_info.vendor());
	}

	fdf::Arena arena('X86I');
	{
	// Inform the platform bus of our board info.
	fidl::Arena fidl_arena;
	auto result = pbus_.buffer(arena)->SetBoardInfo(fidl::ToWire(fidl_arena, board_info));
	if (!result.ok()) {
	zxlogf(ERROR, "SetBoardInfo request failed: %s", result.FormatDescription().data());
	} else if (result->is_error()) {
	zxlogf(ERROR, "SetBoardInfo failed: %s", zx_status_get_string(result->error_value()));
	}
	}

	{
	// Inform the platform bus of our bootloader info.
	fidl::Arena fidl_arena;
	auto result = pbus_.buffer(arena)->SetBootloaderInfo(fidl::ToWire(fidl_arena, bootloader_info));
	if (!result.ok()) {
	zxlogf(ERROR, "SetBootloaderInfo request failed: %s", result.FormatDescription().data());
	} else if (result->is_error()) {
	zxlogf(ERROR, "SetBootloaderInfo failed: %s", zx_status_get_string(result->error_value()));
	}
	}

	// Set the "sys" suspend op in platform-bus.
	// The devmgr coordinator code that arranges ordering in which the suspend hooks
	// are called makes sure the suspend hook attached to sys/ is called dead last,
	// (coordinator.cpp:BuildSuspendList()). If move this suspend hook elsewhere,
	// we must make sure that the coordinator code arranges for this suspend op to be
	// called last.
	auto endpoints = fidl::CreateEndpoints<fpbus::SysSuspend>();
	if (endpoints.is_error()) {
	zxlogf(ERROR, "%s: Could not create suspend callback endpoints: %s", __func__,
	endpoints.status_string());
	} else {
	suspender_loop_.StartThread("sys suspender");
	fidl::BindServer(suspender_loop_.dispatcher(), std::move(endpoints->server), &suspender_);
	auto result = pbus_.buffer(arena)->RegisterSysSuspendCallback(std::move(endpoints->client));
	if (!result.ok()) {
	zxlogf(ERROR, "RegisterSysSuspendCallback request failed: %s",
	result.FormatDescription().data());
	} else if (result->is_error()) {
	zxlogf(ERROR, "RegisterSysSuspendCallback failed: %s",
	zx_status_get_string(result->error_value()));
	}
	}

	return ZX_OK;
	}

	bool X86::RunUnitTests(void* ctx, zx_device_t* parent, zx_handle_t channel) {
	return driver_unit_test::RunZxTests("X86Tests", parent, channel);
	}

	zx_status_t X86::GetAcpiTableEntries(fbl::Vector<TableInfo>* entries) {
	ZX_DEBUG_ASSERT(acpica_initialized_);

	for (uint32_t i = 0; i < kMaxAcpiTableEntries; i++) {
	// Fetch the next table entry.
	ACPI_TABLE_HEADER* table;
	ACPI_STATUS status = AcpiGetTableByIndex(i, &table);
	if (status == AE_BAD_PARAMETER) {
	// End of iteration.
	break;
	} else if (status != AE_OK) {
	// Unexpected error.
	return ZX_ERR_INTERNAL;
	}

	// Create an ACPI table header entry.
	TableInfo info;
	static_assert(sizeof(info.name) == sizeof(table->Signature));
	memcpy(info.name.data(), table->Signature, sizeof(table->Signature));
	info.size = table->Length;

	// Add it to the list.
	fbl::AllocChecker ac;
	entries->push_back(info, &ac);
	if (!ac.check()) {
	return ZX_ERR_NO_MEMORY;
	}
	}

	return ZX_OK;
	}

	void X86::ListTableEntries(ListTableEntriesCompleter::Sync& completer) {
	ZX_DEBUG_ASSERT(acpica_initialized_);

	// Fetch the entries.
	fbl::Vector<TableInfo> entries;
	zx_status_t status = GetAcpiTableEntries(&entries);
	if (status != ZX_OK) {
	completer.ReplyError(status);
	return;
	}

	// Send them back to the user.
	completer.ReplySuccess(fidl::VectorView<TableInfo>::FromExternal(entries.data(), entries.size()));
	}

	void X86::ReadNamedTable(ReadNamedTableRequestView request,
	ReadNamedTableCompleter::Sync& completer) {
	// Fetch the requested table.
	ACPI_TABLE_HEADER* table;
	if (ACPI_STATUS status =
	AcpiGetTable(reinterpret_cast<char*>(request->name.data()), request->instance, &table);
	status != AE_OK) {
	completer.ReplyError(status == AE_NOT_FOUND ? ZX_ERR_NOT_FOUND : ZX_ERR_INTERNAL);
	return;
	}

	// Copy it into the VMO.
	if (zx_status_t status =
	request->result.write(reinterpret_cast<uint8_t>(table), /offset=*/0, table->Length);
	status != ZX_OK) {
	completer.ReplyError(status);
	return;
	}

	completer.ReplySuccess(table->Length);
	}

	static zx_driver_ops_t x86_driver_ops = []() {
	zx_driver_ops_t ops = {};
	ops.version = DRIVER_OPS_VERSION;
	ops.bind = X86::CreateAndBind;
	ops.run_unit_tests = X86::RunUnitTests;
	return ops;
	}();

	} // namespace x86

	ZIRCON_DRIVER(acpi_bus, x86::x86_driver_ops, "zircon", "0.1");