blob: 4a55bc629bb0f2dc38013095490eeeb67528bd13 [file]
// Copyright 2020 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 "gpio.h"
#include <fuchsia/hardware/gpioimpl/cpp/banjo-mock.h>
#include <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
#include <lib/ddk/debug.h>
#include <lib/ddk/metadata.h>
#include <lib/fidl-async/cpp/bind.h>
#include <ddk/metadata/gpio.h>
#include <fbl/alloc_checker.h>
#include "src/devices/testing/mock-ddk/mock-device.h"
namespace gpio {
class FakeGpio : public GpioDevice {
public:
static std::unique_ptr<FakeGpio> Create(const gpio_impl_protocol_t* proto) {
fbl::AllocChecker ac;
auto device = fbl::make_unique_checked<FakeGpio>(&ac, proto);
if (!ac.check()) {
zxlogf(ERROR, "FakeGpio::Create: device object alloc failed\n");
return nullptr;
}
return device;
}
zx_status_t Connect(async_dispatcher_t* dispatcher, zx::channel request) {
return fidl::BindSingleInFlightOnly(dispatcher, std::move(request), this);
}
explicit FakeGpio(const gpio_impl_protocol_t* gpio_impl)
: GpioDevice(nullptr, const_cast<gpio_impl_protocol_t*>(gpio_impl), 0) {}
};
class GpioTest : public zxtest::Test {
public:
void SetUp() override {
gpio_ = FakeGpio::Create(gpio_impl_.GetProto());
ASSERT_NOT_NULL(gpio_);
loop_ = std::make_unique<async::Loop>(&kAsyncLoopConfigAttachToCurrentThread);
zx::channel server;
ASSERT_OK(zx::channel::create(0, &client_, &server));
ASSERT_OK(loop_->StartThread("gpio-test-loop"));
ASSERT_OK(gpio_->Connect(loop_->dispatcher(), std::move(server)));
}
void TearDown() override {
gpio_impl_.VerifyAndClear();
loop_->Shutdown();
}
protected:
std::unique_ptr<FakeGpio> gpio_;
ddk::MockGpioImpl gpio_impl_;
std::unique_ptr<async::Loop> loop_;
zx::channel client_;
};
TEST_F(GpioTest, TestFidlAll) {
fidl::WireSyncClient<fuchsia_hardware_gpio::Gpio> client(std::move(client_));
gpio_impl_.ExpectRead(ZX_OK, 0, 20);
auto result_read = client->Read();
EXPECT_OK(result_read.status());
EXPECT_EQ(result_read->value()->value, 20);
gpio_impl_.ExpectWrite(ZX_OK, 0, 11);
auto result_write = client->Write(11);
EXPECT_OK(result_write.status());
gpio_impl_.ExpectConfigIn(ZX_OK, 0, 0);
auto result_in = client->ConfigIn(GpioFlags::kPullDown);
EXPECT_OK(result_in.status());
gpio_impl_.ExpectConfigOut(ZX_OK, 0, 5);
auto result_out = client->ConfigOut(5);
EXPECT_OK(result_out.status());
gpio_impl_.ExpectSetDriveStrength(ZX_OK, 0, 2000, 2000);
auto result_drivestrength = client->SetDriveStrength(2000);
EXPECT_OK(result_drivestrength.status());
EXPECT_EQ(result_drivestrength->value()->actual_ds_ua, 2000);
gpio_impl_.ExpectGetDriveStrength(ZX_OK, 0, 2000);
auto result_getds = client->GetDriveStrength();
EXPECT_OK(result_getds.status());
EXPECT_EQ(result_getds->value()->result_ua, 2000);
}
TEST_F(GpioTest, TestBanjoSetDriveStrength) {
uint64_t actual = 0;
gpio_impl_.ExpectSetDriveStrength(ZX_OK, 0, 3000, 3000);
EXPECT_OK(gpio_->GpioSetDriveStrength(3000, &actual));
EXPECT_EQ(actual, 3000);
}
TEST_F(GpioTest, TestBanjoGetDriveStrength) {
uint64_t result = 0;
gpio_impl_.ExpectGetDriveStrength(ZX_OK, 0, 3000);
EXPECT_OK(gpio_->GpioGetDriveStrength(&result));
EXPECT_EQ(result, 3000);
}
TEST_F(GpioTest, TestCloseReleasesInterrupt) {
EXPECT_OK(gpio_->DdkOpen(nullptr, 0));
zx::interrupt interrupt;
gpio_impl_.ExpectReleaseInterrupt(ZX_OK, 0);
EXPECT_OK(gpio_->DdkClose(0));
ASSERT_NO_FAILURES(gpio_impl_.VerifyAndClear());
}
TEST_F(GpioTest, TestOneClient) {
gpio_impl_.ExpectReleaseInterrupt(ZX_OK, 0).ExpectReleaseInterrupt(ZX_OK, 0);
EXPECT_OK(gpio_->DdkOpen(nullptr, 0));
EXPECT_NOT_OK(gpio_->DdkOpen(nullptr, 0));
EXPECT_OK(gpio_->DdkClose(0));
EXPECT_OK(gpio_->DdkOpen(nullptr, 0));
EXPECT_OK(gpio_->DdkClose(0));
}
TEST_F(GpioTest, ValidateMetadataOk) {
constexpr gpio_pin_t pins[] = {
{0},
{1},
{2},
};
auto parent = MockDevice::FakeRootParent();
parent->AddProtocol(ZX_PROTOCOL_GPIO_IMPL, gpio_impl_.GetProto()->ops,
gpio_impl_.GetProto()->ctx);
parent->SetMetadata(DEVICE_METADATA_GPIO_PINS, pins, std::size(pins) * sizeof(gpio_pin_t));
ASSERT_OK(GpioDevice::Create(nullptr, parent.get()));
}
TEST_F(GpioTest, ValidateMetadataRejectDuplicates) {
constexpr gpio_pin_t pins[] = {{2}, {1}, {2}, {0}};
auto parent = MockDevice::FakeRootParent();
parent->AddProtocol(ZX_PROTOCOL_GPIO_IMPL, gpio_impl_.GetProto()->ops,
gpio_impl_.GetProto()->ctx);
parent->SetMetadata(DEVICE_METADATA_GPIO_PINS, pins, std::size(pins) * sizeof(gpio_pin_t));
ASSERT_NOT_OK(GpioDevice::Create(nullptr, parent.get()));
}
} // namespace gpio