// 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 "aml-axg-gpio.h"

#include <ddk/platform-defs.h>
#include <fbl/alloc_checker.h>
#include <fbl/auto_call.h>
#include <mock-mmio-reg/mock-mmio-reg.h>

#include "a113-blocks.h"
#include "lib/device-protocol/pdev.h"
#include "s905d2-blocks.h"

namespace {

constexpr size_t kGpioRegSize = 0x00300000 / sizeof(uint32_t);  // in 32 bits chunks.

// Fake functions
zx_status_t mmio_fn(void *ctx, uint32_t index, pdev_mmio_t *out_mmio) { return ZX_OK; }
zx_status_t interrupt_fn(void *ctx, uint32_t index, uint32_t flags, zx_handle_t *out_irq) {
  return ZX_OK;
}
zx_status_t bti_fn(void *ctx, uint32_t index, zx_handle_t *out_bti) { return ZX_OK; }
zx_status_t smc_fn(void *ctx, uint32_t index, zx_handle_t *out_smc) { return ZX_OK; }
zx_status_t device_info_fn(void *ctx, pdev_device_info_t *out_info) { return ZX_OK; }
zx_status_t board_info_fn(void *ctx, pdev_board_info_t *out_info) { return ZX_OK; }

pdev_protocol_ops_t fake_ops{.get_mmio = &mmio_fn,
                             .get_interrupt = &interrupt_fn,
                             .get_bti = &bti_fn,
                             .get_smc = &smc_fn,
                             .get_device_info = &device_info_fn,
                             .get_board_info = &board_info_fn};
pdev_protocol_t fake_proto{.ops = &fake_ops, .ctx = nullptr};

}  // namespace

namespace gpio {

class FakeAmlAxgGpio : public AmlAxgGpio {
 public:
  static FakeAmlAxgGpio *Create(pdev_device_info info, ddk_mock::MockMmioRegRegion *mock_mmio_gpio,
                                ddk_mock::MockMmioRegRegion *mock_mmio_gpio_a0,
                                ddk_mock::MockMmioRegRegion *mock_mmio_interrupt) {
    const AmlGpioBlock *gpio_blocks;
    const AmlGpioInterrupt *gpio_interrupt;
    size_t block_count;

    switch (info.pid) {
      case PDEV_PID_AMLOGIC_A113:
        gpio_blocks = a113_gpio_blocks;
        block_count = countof(a113_gpio_blocks);
        gpio_interrupt = &a113_interrupt_block;
        break;
      case PDEV_PID_AMLOGIC_S905D2:
      case PDEV_PID_AMLOGIC_T931:
        // S905D2 and T931 are identical.
        gpio_blocks = s905d2_gpio_blocks;
        block_count = countof(s905d2_gpio_blocks);
        gpio_interrupt = &s905d2_interrupt_block;
        break;
      default:
        zxlogf(ERROR, "FakeAmlAxgGpio::Create: unsupported SOC PID %u", info.pid);
        return nullptr;
    }

    fbl::AllocChecker ac;

    fbl::Array<uint16_t> irq_info(new (&ac) uint16_t[info.irq_count], info.irq_count);
    if (!ac.check()) {
      zxlogf(ERROR, "FakeAmlAxgGpio::Create: irq_info alloc failed");
      return nullptr;
    }
    for (uint32_t i = 0; i < info.irq_count; i++) {
      irq_info[i] = 255 + 1;
    }  // initialize irq_info

    ddk::MmioBuffer mmio_gpio(mock_mmio_gpio->GetMmioBuffer());
    ddk::MmioBuffer mmio_gpio_a0(mock_mmio_gpio_a0->GetMmioBuffer());
    ddk::MmioBuffer mmio_interrupt(mock_mmio_interrupt->GetMmioBuffer());

    FakeAmlAxgGpio *device(new (&ac) FakeAmlAxgGpio(
        std::move(mmio_gpio), std::move(mmio_gpio_a0), std::move(mmio_interrupt), gpio_blocks,
        gpio_interrupt, block_count, std::move(info), std::move(irq_info)));
    if (!ac.check()) {
      zxlogf(ERROR, "FakeAmlAxgGpio::Create: device object alloc failed");
      return nullptr;
    }

    return device;
  }

 private:
  explicit FakeAmlAxgGpio(ddk::MmioBuffer mock_mmio_gpio, ddk::MmioBuffer mock_mmio_gpio_a0,
                          ddk::MmioBuffer mock_mmio_interrupt, const AmlGpioBlock *gpio_blocks,
                          const AmlGpioInterrupt *gpio_interrupt, size_t block_count,
                          pdev_device_info_t info, fbl::Array<uint16_t> irq_info)
      : AmlAxgGpio(&fake_proto, std::move(mock_mmio_gpio), std::move(mock_mmio_gpio_a0),
                   std::move(mock_mmio_interrupt), gpio_blocks, gpio_interrupt, block_count,
                   std::move(info), std::move(irq_info)) {}
};

class A113AmlAxgGpioTest : public zxtest::Test {
 public:
  void SetUp() override {
    fbl::AllocChecker ac;

    gpio_regs_ = fbl::Array(new (&ac) ddk_mock::MockMmioReg[kGpioRegSize], kGpioRegSize);
    if (!ac.check()) {
      zxlogf(ERROR, "AmlAxgGpioTest::SetUp: gpio_regs_ alloc failed");
      return;
    }
    mock_mmio_gpio_ =
        new (&ac) ddk_mock::MockMmioRegRegion(gpio_regs_.get(), sizeof(uint32_t), kGpioRegSize);
    if (!ac.check()) {
      zxlogf(ERROR, "AmlAxgGpioTest::SetUp: mock_mmio_gpio_ alloc failed");
      return;
    }
    gpio_a0_regs_ = fbl::Array(new (&ac) ddk_mock::MockMmioReg[kGpioRegSize], kGpioRegSize);
    if (!ac.check()) {
      zxlogf(ERROR, "AmlAxgGpioTest::SetUp: gpio_a0_regs_ alloc failed");
      return;
    }
    mock_mmio_gpio_a0_ =
        new (&ac) ddk_mock::MockMmioRegRegion(gpio_a0_regs_.get(), sizeof(uint32_t), kGpioRegSize);
    if (!ac.check()) {
      zxlogf(ERROR, "AmlAxgGpioTest::SetUp: mock_mmio_gpio_a0_ alloc failed");
      return;
    }
    interrupt_regs_ = fbl::Array(new (&ac) ddk_mock::MockMmioReg[kGpioRegSize], kGpioRegSize);
    if (!ac.check()) {
      zxlogf(ERROR, "AmlAxgGpioTest::SetUp: interrupt_regs_ alloc failed");
      return;
    }
    mock_mmio_interrupt_ = new (&ac)
        ddk_mock::MockMmioRegRegion(interrupt_regs_.get(), sizeof(uint32_t), kGpioRegSize);
    if (!ac.check()) {
      zxlogf(ERROR, "AmlAxgGpioTest::SetUp: mock_mmio_interrupt_ alloc failed");
      return;
    }

    // make-up info, pid and irq_count needed for Create
    auto info = pdev_device_info{0, PDEV_PID_AMLOGIC_A113, 0, 2, 3, 0, 0, 0, {0}, "fake_info"};

    gpio_ = FakeAmlAxgGpio::Create(info, mock_mmio_gpio_, mock_mmio_gpio_a0_, mock_mmio_interrupt_);
  }

  void TearDown() override {
    delete mock_mmio_gpio_;
    delete mock_mmio_gpio_a0_;
    delete mock_mmio_interrupt_;
    delete gpio_;
  }

 protected:
  FakeAmlAxgGpio *gpio_;
  fbl::Array<ddk_mock::MockMmioReg> gpio_regs_;
  fbl::Array<ddk_mock::MockMmioReg> gpio_a0_regs_;
  fbl::Array<ddk_mock::MockMmioReg> interrupt_regs_;
  ddk_mock::MockMmioRegRegion *mock_mmio_gpio_;
  ddk_mock::MockMmioRegRegion *mock_mmio_gpio_a0_;
  ddk_mock::MockMmioRegRegion *mock_mmio_interrupt_;
};

class S905d2AmlAxgGpioTest : public zxtest::Test {
 public:
  void SetUp() override {
    fbl::AllocChecker ac;

    gpio_regs_ = fbl::Array(new (&ac) ddk_mock::MockMmioReg[kGpioRegSize], kGpioRegSize);
    if (!ac.check()) {
      zxlogf(ERROR, "AmlAxgGpioTest::SetUp: gpio_regs_ alloc failed");
      return;
    }
    mock_mmio_gpio_ =
        new (&ac) ddk_mock::MockMmioRegRegion(gpio_regs_.get(), sizeof(uint32_t), kGpioRegSize);
    if (!ac.check()) {
      zxlogf(ERROR, "AmlAxgGpioTest::SetUp: mock_mmio_gpio_ alloc failed");
      return;
    }
    gpio_a0_regs_ = fbl::Array(new (&ac) ddk_mock::MockMmioReg[kGpioRegSize], kGpioRegSize);
    if (!ac.check()) {
      zxlogf(ERROR, "AmlAxgGpioTest::SetUp: gpio_a0_regs_ alloc failed");
      return;
    }
    mock_mmio_gpio_a0_ =
        new (&ac) ddk_mock::MockMmioRegRegion(gpio_a0_regs_.get(), sizeof(uint32_t), kGpioRegSize);
    if (!ac.check()) {
      zxlogf(ERROR, "AmlAxgGpioTest::SetUp: mock_mmio_gpio_a0_ alloc failed");
      return;
    }
    interrupt_regs_ = fbl::Array(new (&ac) ddk_mock::MockMmioReg[kGpioRegSize], kGpioRegSize);
    if (!ac.check()) {
      zxlogf(ERROR, "AmlAxgGpioTest::SetUp: interrupt_regs_ alloc failed");
      return;
    }
    mock_mmio_interrupt_ = new (&ac)
        ddk_mock::MockMmioRegRegion(interrupt_regs_.get(), sizeof(uint32_t), kGpioRegSize);
    if (!ac.check()) {
      zxlogf(ERROR, "AmlAxgGpioTest::SetUp: mock_mmio_interrupt_ alloc failed");
      return;
    }

    // make-up info, pid and irq_count needed for Create
    auto info = pdev_device_info{0, PDEV_PID_AMLOGIC_S905D2, 0, 2, 3, 0, 0, 0, {0}, "fake_info"};

    gpio_ = FakeAmlAxgGpio::Create(info, mock_mmio_gpio_, mock_mmio_gpio_a0_, mock_mmio_interrupt_);
  }

  void TearDown() override {
    delete mock_mmio_gpio_;
    delete mock_mmio_gpio_a0_;
    delete mock_mmio_interrupt_;
    delete gpio_;
  }

 protected:
  FakeAmlAxgGpio *gpio_;
  fbl::Array<ddk_mock::MockMmioReg> gpio_regs_;
  fbl::Array<ddk_mock::MockMmioReg> gpio_a0_regs_;
  fbl::Array<ddk_mock::MockMmioReg> interrupt_regs_;
  ddk_mock::MockMmioRegRegion *mock_mmio_gpio_;
  ddk_mock::MockMmioRegRegion *mock_mmio_gpio_a0_;
  ddk_mock::MockMmioRegRegion *mock_mmio_interrupt_;
};

// GpioImplSetAltFunction Tests
TEST_F(A113AmlAxgGpioTest, A113AltMode1) {
  (*mock_mmio_gpio_)[0x24 * sizeof(uint32_t)].ExpectRead(0x00000000).ExpectWrite(0x00000001);
  EXPECT_OK(gpio_->GpioImplSetAltFunction(0x00, 1));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

TEST_F(A113AmlAxgGpioTest, A113AltMode2) {
  (*mock_mmio_gpio_)[0x26 * sizeof(uint32_t)]
      .ExpectRead(0x00000009 << 8)
      .ExpectWrite(0x00000005 << 8);
  EXPECT_OK(gpio_->GpioImplSetAltFunction(0x12, 5));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

TEST_F(A113AmlAxgGpioTest, A113AltMode3) {
  (*mock_mmio_gpio_a0_)[0x05 * sizeof(uint32_t)]
      .ExpectRead(0x00000000)
      .ExpectWrite(0x00000005 << 16);
  EXPECT_OK(gpio_->GpioImplSetAltFunction(0x56, 5));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

TEST_F(S905d2AmlAxgGpioTest, S905d2AltMode) {
  (*mock_mmio_gpio_)[0xb6 * sizeof(uint32_t)].ExpectRead(0x00000000).ExpectWrite(0x00000001);
  EXPECT_OK(gpio_->GpioImplSetAltFunction(0x00, 1));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

TEST_F(A113AmlAxgGpioTest, AltModeFail1) {
  EXPECT_NOT_OK(gpio_->GpioImplSetAltFunction(0x00, 16));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

TEST_F(A113AmlAxgGpioTest, AltModeFail2) {
  EXPECT_NOT_OK(gpio_->GpioImplSetAltFunction(0xFFFF, 1));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

// GpioImplConfigIn Tests
TEST_F(A113AmlAxgGpioTest, A113NoPull0) {
  (*mock_mmio_gpio_)[0x12 * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // oen
  (*mock_mmio_gpio_)[0x3c * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // pull
  (*mock_mmio_gpio_)[0x4a * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFE);  // pull_en
  EXPECT_OK(gpio_->GpioImplConfigIn(0, GPIO_NO_PULL));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

TEST_F(A113AmlAxgGpioTest, A113NoPullMid) {
  (*mock_mmio_gpio_)[0x12 * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // oen
  (*mock_mmio_gpio_)[0x3c * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // pull
  (*mock_mmio_gpio_)[0x4a * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFBFFFF);  // pull_en
  EXPECT_OK(gpio_->GpioImplConfigIn(0x12, GPIO_NO_PULL));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

TEST_F(A113AmlAxgGpioTest, A113NoPullHigh) {
  (*mock_mmio_gpio_a0_)[0x08 * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // oen
  (*mock_mmio_gpio_a0_)[0x0b * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // pull
  (*mock_mmio_gpio_a0_)[0x0b * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFEFFFF);  // pull_en
  EXPECT_OK(gpio_->GpioImplConfigIn(0x56, GPIO_NO_PULL));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

TEST_F(S905d2AmlAxgGpioTest, S905d2NoPull0) {
  (*mock_mmio_gpio_)[0x1c * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // oen
  (*mock_mmio_gpio_)[0x3e * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // pull
  (*mock_mmio_gpio_)[0x4c * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFE);  // pull_en
  EXPECT_OK(gpio_->GpioImplConfigIn(0, GPIO_NO_PULL));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

TEST_F(S905d2AmlAxgGpioTest, S905d2PullUp) {
  (*mock_mmio_gpio_)[0x10 * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // oen
  (*mock_mmio_gpio_)[0x3a * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // pull
  (*mock_mmio_gpio_)[0x48 * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // pull_en
  EXPECT_OK(gpio_->GpioImplConfigIn(0x21, GPIO_PULL_UP));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

TEST_F(S905d2AmlAxgGpioTest, S905d2PullDown) {
  (*mock_mmio_gpio_)[0x10 * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // oen
  (*mock_mmio_gpio_)[0x3a * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFE);  // pull
  (*mock_mmio_gpio_)[0x48 * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // pull_en
  EXPECT_OK(gpio_->GpioImplConfigIn(0x20, GPIO_PULL_DOWN));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

TEST_F(A113AmlAxgGpioTest, A113NoPullFail) {
  EXPECT_NOT_OK(gpio_->GpioImplConfigIn(0xFFFF, GPIO_NO_PULL));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

// GpioImplConfigOut Tests
TEST_F(A113AmlAxgGpioTest, A113Out) {
  (*mock_mmio_gpio_)[0x0d * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // output
  (*mock_mmio_gpio_)[0x0c * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFB);  // oen
  EXPECT_OK(gpio_->GpioImplConfigOut(0x19, 1));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

// GpioImplRead Tests
TEST_F(A113AmlAxgGpioTest, A113Read) {
  (*mock_mmio_gpio_)[0x12 * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // oen
  (*mock_mmio_gpio_)[0x3c * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // pull
  (*mock_mmio_gpio_)[0x4a * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFDF);  // pull_en
  EXPECT_OK(gpio_->GpioImplConfigIn(5, GPIO_NO_PULL));
  (*mock_mmio_gpio_)[0x14 * sizeof(uint32_t)].ExpectRead(0x00000020);  // read 0x01.
  (*mock_mmio_gpio_)[0x14 * sizeof(uint32_t)].ExpectRead(0x00000000);  // read 0x00.
  (*mock_mmio_gpio_)[0x14 * sizeof(uint32_t)].ExpectRead(0x00000020);  // read 0x01.
  uint8_t out_value = 0;
  EXPECT_OK(gpio_->GpioImplRead(5, &out_value));
  EXPECT_EQ(out_value, 0x01);
  EXPECT_OK(gpio_->GpioImplRead(5, &out_value));
  EXPECT_EQ(out_value, 0x00);
  EXPECT_OK(gpio_->GpioImplRead(5, &out_value));
  EXPECT_EQ(out_value, 0x01);
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

// GpioImplWrite Tests
TEST_F(A113AmlAxgGpioTest, A113Write) {
  (*mock_mmio_gpio_)[0x13 * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // write
  (*mock_mmio_gpio_)[0x13 * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFBFFF);  // write
  (*mock_mmio_gpio_)[0x13 * sizeof(uint32_t)]
      .ExpectRead(0xFFFFFFFF)
      .ExpectWrite(0xFFFFFFFF);  // write
  EXPECT_OK(gpio_->GpioImplWrite(14, 200));
  EXPECT_OK(gpio_->GpioImplWrite(14, 0));
  EXPECT_OK(gpio_->GpioImplWrite(14, 92));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

// GpioImplGetInterrupt Tests
TEST_F(A113AmlAxgGpioTest, A113GetInterruptFail) {
  zx::interrupt out_int;
  EXPECT_NOT_OK(gpio_->GpioImplGetInterrupt(0xFFFF, ZX_INTERRUPT_MODE_EDGE_LOW, &out_int));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

TEST_F(A113AmlAxgGpioTest, A113GetInterrupt) {
  (*mock_mmio_interrupt_)[0x3c21 * sizeof(uint32_t)]
      .ExpectRead(0x00000000)
      .ExpectWrite(0x00000048);  // modify
  (*mock_mmio_interrupt_)[0x3c20 * sizeof(uint32_t)].ExpectRead(0x00000000).ExpectWrite(0x00010001);
  (*mock_mmio_interrupt_)[0x3c23 * sizeof(uint32_t)].ExpectRead(0x00000000).ExpectWrite(0x00000007);
  zx::interrupt out_int;
  EXPECT_OK(gpio_->GpioImplGetInterrupt(0x0B, ZX_INTERRUPT_MODE_EDGE_LOW, &out_int));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

// GpioImplReleaseInterrupt Tests
TEST_F(A113AmlAxgGpioTest, A113ReleaseInterruptFail) {
  EXPECT_NOT_OK(gpio_->GpioImplReleaseInterrupt(0x66));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

TEST_F(A113AmlAxgGpioTest, A113ReleaseInterrupt) {
  (*mock_mmio_interrupt_)[0x3c21 * sizeof(uint32_t)]
      .ExpectRead(0x00000000)
      .ExpectWrite(0x00000048);  // modify
  (*mock_mmio_interrupt_)[0x3c20 * sizeof(uint32_t)].ExpectRead(0x00000000).ExpectWrite(0x00010001);
  (*mock_mmio_interrupt_)[0x3c23 * sizeof(uint32_t)].ExpectRead(0x00000000).ExpectWrite(0x00000007);
  zx::interrupt out_int;
  EXPECT_OK(gpio_->GpioImplGetInterrupt(0x0B, ZX_INTERRUPT_MODE_EDGE_LOW, &out_int));
  EXPECT_OK(gpio_->GpioImplReleaseInterrupt(0x0B));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

// GpioImplSetPolarity Tests
TEST_F(A113AmlAxgGpioTest, A113InterruptSetPolarityEdge) {
  (*mock_mmio_interrupt_)[0x3c21 * sizeof(uint32_t)]
      .ExpectRead(0x00000000)
      .ExpectWrite(0x00000048);  // modify
  (*mock_mmio_interrupt_)[0x3c20 * sizeof(uint32_t)].ExpectRead(0x00000000).ExpectWrite(0x00010001);
  (*mock_mmio_interrupt_)[0x3c23 * sizeof(uint32_t)].ExpectRead(0x00000000).ExpectWrite(0x00000007);
  zx::interrupt out_int;
  EXPECT_OK(gpio_->GpioImplGetInterrupt(0x0B, ZX_INTERRUPT_MODE_EDGE_LOW, &out_int));

  (*mock_mmio_interrupt_)[0x3c20 * sizeof(uint32_t)]
      .ExpectRead(0x00010001)
      .ExpectWrite(0x00000001);  // polarity + for any edge.
  EXPECT_OK(gpio_->GpioImplSetPolarity(0x0B, true));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

// GpioImplSetDriveStrength Tests
TEST_F(A113AmlAxgGpioTest, A113SetDriveStrength) {
  EXPECT_NOT_OK(gpio_->GpioImplSetDriveStrength(0x87, 2, nullptr));
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

TEST_F(S905d2AmlAxgGpioTest, S905d2SetDriveStrength) {
  (*mock_mmio_gpio_a0_)[0x08 * sizeof(uint32_t)].ExpectRead(0xFFFFFFFF).ExpectWrite(0xFFFFFFFB);
  uint64_t actual = 0;
  EXPECT_OK(gpio_->GpioImplSetDriveStrength(0x62, 3000, &actual));
  EXPECT_EQ(actual, 3000);
  mock_mmio_gpio_->VerifyAll();
  mock_mmio_gpio_a0_->VerifyAll();
  mock_mmio_interrupt_->VerifyAll();
}

}  // namespace gpio

int main(int argc, char **argv) { return RUN_ALL_TESTS(argc, argv); }