src/media/audio/drivers/codecs/tas27xx/tas27xx-test.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 "tas27xx.h"

 #include <fuchsia/hardware/gpio/cpp/banjo-mock.h>
 #include <lib/fake_ddk/fake_ddk.h>
 #include <lib/inspect/cpp/inspect.h>
 #include <lib/mock-i2c/mock-i2c.h>
 #include <lib/simple-codec/simple-codec-client.h>
 #include <lib/simple-codec/simple-codec-helper.h>
 #include <lib/sync/completion.h>

 #include <sdk/lib/inspect/testing/cpp/zxtest/inspect.h>
 #include <zxtest/zxtest.h>

 namespace audio {

 audio::DaiFormat GetDefaultDaiFormat() {
   return {
       .number_of_channels = 2,
       .channels_to_use_bitmask = 1,  // Use one channel in this mono codec.
       .sample_format = SampleFormat::PCM_SIGNED,
       .frame_format = FrameFormat::I2S,
       .frame_rate = 24'000,
       .bits_per_slot = 32,
       .bits_per_sample = 16,
   };
 }

 struct Tas27xxCodec : public Tas27xx {
   explicit Tas27xxCodec(ddk::I2cChannel i2c, ddk::GpioProtocolClient fault)
       : Tas27xx(fake_ddk::kFakeParent, std::move(i2c), std::move(fault), true, true) {}
   codec_protocol_t GetProto() { return {&this->codec_protocol_ops_, this}; }
   inspect::Inspector& inspect() { return Tas27xx::inspect(); }
 };

 class Tas27xxTest : public inspect::InspectTestHelper, public zxtest::Test {
  public:
   void SetUp() override {}

   void TearDown() override {}

  protected:
   fake_ddk::Bind ddk_;
 };

 TEST_F(Tas27xxTest, CodecInitGood) {
   zx::interrupt irq;
   ASSERT_OK(zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq));

   mock_i2c::MockI2c mock_i2c;
   ddk::MockGpio mock_fault;
   mock_fault.ExpectGetInterrupt(ZX_OK, ZX_INTERRUPT_MODE_EDGE_LOW, std::move(irq));

   auto codec = SimpleCodecServer::Create<Tas27xxCodec>(mock_i2c.GetProto(), mock_fault.GetProto());
   ASSERT_NOT_NULL(codec);

   codec->DdkAsyncRemove();
   ASSERT_TRUE(ddk_.Ok());
   codec.release()->DdkRelease();  // codec release managed by the DDK
   mock_i2c.VerifyAndClear();
   mock_fault.VerifyAndClear();
 }

 TEST_F(Tas27xxTest, CodecInitBad) {
   zx::interrupt irq;
   ASSERT_OK(zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq));

   mock_i2c::MockI2c mock_i2c;
   ddk::MockGpio mock_fault;
   // Error when getting the interrupt.
   mock_fault.ExpectGetInterrupt(ZX_ERR_INTERNAL, ZX_INTERRUPT_MODE_EDGE_LOW, std::move(irq));

   auto codec = SimpleCodecServer::Create<Tas27xxCodec>(mock_i2c.GetProto(), mock_fault.GetProto());
   ASSERT_NULL(codec);
   mock_i2c.VerifyAndClear();
   mock_fault.VerifyAndClear();
 }

 TEST_F(Tas27xxTest, CodecGetInfo) {
   zx::interrupt irq;
   ASSERT_OK(zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq));

   mock_i2c::MockI2c mock_i2c;
   ddk::MockGpio mock_fault;
   mock_fault.ExpectGetInterrupt(ZX_OK, ZX_INTERRUPT_MODE_EDGE_LOW, std::move(irq));

   auto codec = SimpleCodecServer::Create<Tas27xxCodec>(mock_i2c.GetProto(), mock_fault.GetProto());
   ASSERT_NOT_NULL(codec);
   auto codec_proto = codec->GetProto();
   SimpleCodecClient client;
   client.SetProtocol(&codec_proto);
   auto info = client.GetInfo();
   ASSERT_EQ(info->unique_id.compare(""), 0);
   ASSERT_EQ(info->manufacturer.compare("Texas Instruments"), 0);
   ASSERT_EQ(info->product_name.compare("TAS2770"), 0);

   codec->DdkAsyncRemove();
   ASSERT_TRUE(ddk_.Ok());
   codec.release()->DdkRelease();  // codec release managed by the DDK
   mock_i2c.VerifyAndClear();
   mock_fault.VerifyAndClear();
 }

 TEST_F(Tas27xxTest, CodecReset) {
   zx::interrupt irq;
   ASSERT_OK(zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq));

   mock_i2c::MockI2c mock_i2c;
   // Reset by the call to Reset.
   mock_i2c
       .ExpectWriteStop({0x01, 0x01}, ZX_ERR_INTERNAL)  // SW_RESET error, will retry.
       .ExpectWriteStop({0x01, 0x01}, ZX_OK)            // SW_RESET.
       .ExpectWriteStop({0x02, 0x0d})                   // PRW_CTL stopped.
       .ExpectWriteStop({0x3c, 0x10})                   // CLOCK_CFG.
       .ExpectWriteStop({0x0a, 0x07})                   // SetRate.
       .ExpectWriteStop({0x0c, 0x22})                   // TDM_CFG2.
       .ExpectWriteStop({0x0e, 0x02})                   // TDM_CFG4.
       .ExpectWriteStop({0x0f, 0x44})                   // TDM_CFG5.
       .ExpectWriteStop({0x10, 0x40})                   // TDM_CFG6.
       .ExpectWrite({0x24})
       .ExpectReadStop({0x00})  // INT_LTCH0.
       .ExpectWrite({0x25})
       .ExpectReadStop({0x00})  // INT_LTCH1.
       .ExpectWrite({0x26})
       .ExpectReadStop({0x00})          // INT_LTCH2.
       .ExpectWriteStop({0x20, 0xf8})   // INT_MASK0.
       .ExpectWriteStop({0x21, 0xff})   // INT_MASK1.
       .ExpectWriteStop({0x30, 0x01})   // INT_CFG.
       .ExpectWriteStop({0x05, 0x3c})   // -30dB.
       .ExpectWriteStop({0x02, 0x0d});  // PWR_CTL stopped.

   ddk::MockGpio mock_fault;
   mock_fault.ExpectGetInterrupt(ZX_OK, ZX_INTERRUPT_MODE_EDGE_LOW, std::move(irq));

   auto codec = SimpleCodecServer::Create<Tas27xxCodec>(mock_i2c.GetProto(), mock_fault.GetProto());
   ASSERT_NOT_NULL(codec);
   auto codec_proto = codec->GetProto();
   SimpleCodecClient client;
   client.SetProtocol(&codec_proto);
   ASSERT_OK(client.Reset());

   codec->DdkAsyncRemove();
   ASSERT_TRUE(ddk_.Ok());
   codec.release()->DdkRelease();  // codec release managed by the DDK
   mock_i2c.VerifyAndClear();
   mock_fault.VerifyAndClear();
 }

 TEST_F(Tas27xxTest, ExternalConfig) {
   zx::interrupt irq;
   ASSERT_OK(zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq));

   metadata::ti::TasConfig metadata = {};
   metadata.number_of_writes1 = 2;
   metadata.init_sequence1[0].address = 0x12;
   metadata.init_sequence1[0].value = 0x34;
   metadata.init_sequence1[1].address = 0x56;
   metadata.init_sequence1[1].value = 0x78;
   metadata.number_of_writes2 = 3;
   metadata.init_sequence2[0].address = 0x11;
   metadata.init_sequence2[0].value = 0x22;
   metadata.init_sequence2[1].address = 0x33;
   metadata.init_sequence2[1].value = 0x44;
   metadata.init_sequence2[2].address = 0x55;
   metadata.init_sequence2[2].value = 0x66;
   ddk_.SetMetadata(&metadata, sizeof(metadata));

   mock_i2c::MockI2c mock_i2c;
   // Reset by the call to Reset.
   mock_i2c
       .ExpectWriteStop({0x01, 0x01}, ZX_ERR_INTERNAL)  // SW_RESET error, will retry.
       .ExpectWriteStop({0x01, 0x01}, ZX_OK)            // SW_RESET.
       .ExpectWriteStop({0x12, 0x34})                   // External config.
       .ExpectWriteStop({0x56, 0x78})                   // External config.
       .ExpectWriteStop({0x11, 0x22})                   // External config.
       .ExpectWriteStop({0x33, 0x44})                   // External config.
       .ExpectWriteStop({0x55, 0x66})                   // External config.
       .ExpectWriteStop({0x02, 0x0d})                   // PRW_CTL stopped.
       .ExpectWriteStop({0x3c, 0x10})                   // CLOCK_CFG.
       .ExpectWriteStop({0x0a, 0x07})                   // SetRate.
       .ExpectWriteStop({0x0c, 0x22})                   // TDM_CFG2.
       .ExpectWriteStop({0x0e, 0x02})                   // TDM_CFG4.
       .ExpectWriteStop({0x0f, 0x44})                   // TDM_CFG5.
       .ExpectWriteStop({0x10, 0x40})                   // TDM_CFG6.
       .ExpectWrite({0x24})
       .ExpectReadStop({0x00})  // INT_LTCH0.
       .ExpectWrite({0x25})
       .ExpectReadStop({0x00})  // INT_LTCH1.
       .ExpectWrite({0x26})
       .ExpectReadStop({0x00})          // INT_LTCH2.
       .ExpectWriteStop({0x20, 0xf8})   // INT_MASK0.
       .ExpectWriteStop({0x21, 0xff})   // INT_MASK1.
       .ExpectWriteStop({0x30, 0x01})   // INT_CFG.
       .ExpectWriteStop({0x05, 0x3c})   // -30dB.
       .ExpectWriteStop({0x02, 0x0d});  // PWR_CTL stopped.

   ddk::MockGpio mock_fault;
   mock_fault.ExpectGetInterrupt(ZX_OK, ZX_INTERRUPT_MODE_EDGE_LOW, std::move(irq));

   auto codec = SimpleCodecServer::Create<Tas27xxCodec>(mock_i2c.GetProto(), mock_fault.GetProto());
   ASSERT_NOT_NULL(codec);
   auto codec_proto = codec->GetProto();
   SimpleCodecClient client;
   client.SetProtocol(&codec_proto);
   ASSERT_OK(client.Reset());

   codec->DdkAsyncRemove();
   ASSERT_TRUE(ddk_.Ok());
   codec.release()->DdkRelease();  // codec release managed by the DDK
   mock_i2c.VerifyAndClear();
   mock_fault.VerifyAndClear();
 }

 TEST_F(Tas27xxTest, CodecBridgedMode) {
   zx::interrupt irq;
   ASSERT_OK(zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq));

   mock_i2c::MockI2c mock_i2c;
   ddk::MockGpio mock_fault;
   mock_fault.ExpectGetInterrupt(ZX_OK, ZX_INTERRUPT_MODE_EDGE_LOW, std::move(irq));

   auto codec = SimpleCodecServer::Create<Tas27xxCodec>(mock_i2c.GetProto(), mock_fault.GetProto());
   ASSERT_NOT_NULL(codec);
   auto codec_proto = codec->GetProto();
   SimpleCodecClient client;
   client.SetProtocol(&codec_proto);
   {
     auto bridgeable = client.IsBridgeable();
     ASSERT_FALSE(bridgeable.value());
   }
   client.SetBridgedMode(false);

   codec->DdkAsyncRemove();
   ASSERT_TRUE(ddk_.Ok());
   codec.release()->DdkRelease();  // codec release managed by the DDK
   mock_i2c.VerifyAndClear();
   mock_fault.VerifyAndClear();
 }

 TEST_F(Tas27xxTest, CodecDaiFormat) {
   zx::interrupt irq;
   ASSERT_OK(zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq));

   mock_i2c::MockI2c mock_i2c;
   ddk::MockGpio mock_fault;
   mock_fault.ExpectGetInterrupt(ZX_OK, ZX_INTERRUPT_MODE_EDGE_LOW, std::move(irq));

   auto codec = SimpleCodecServer::Create<Tas27xxCodec>(mock_i2c.GetProto(), mock_fault.GetProto());
   ASSERT_NOT_NULL(codec);
   auto codec_proto = codec->GetProto();
   SimpleCodecClient client;
   client.SetProtocol(&codec_proto);

   // We complete all i2c mock setup before executing server methods in a different thread.
   mock_i2c.ExpectWriteStop({0x0a, 0x07});
   mock_i2c.ExpectWriteStop({0x0a, 0x09});

   // Check getting DAI formats.
   {
     auto formats = client.GetDaiFormats();
     ASSERT_EQ(formats.value().number_of_channels.size(), 1);
     ASSERT_EQ(formats.value().number_of_channels[0], 2);
     ASSERT_EQ(formats.value().sample_formats.size(), 1);
     ASSERT_EQ(formats.value().sample_formats[0], SampleFormat::PCM_SIGNED);
     ASSERT_EQ(formats.value().frame_formats.size(), 1);
     ASSERT_EQ(formats.value().frame_formats[0], FrameFormat::I2S);
     ASSERT_EQ(formats.value().frame_rates.size(), 2);
     ASSERT_EQ(formats.value().frame_rates[0], 48000);
     ASSERT_EQ(formats.value().frame_rates[1], 96000);
     ASSERT_EQ(formats.value().bits_per_slot.size(), 1);
     ASSERT_EQ(formats.value().bits_per_slot[0], 32);
     ASSERT_EQ(formats.value().bits_per_sample.size(), 1);
     ASSERT_EQ(formats.value().bits_per_sample[0], 16);
   }

   // Check inspect state.
   ASSERT_NO_FATAL_FAILURES(ReadInspect(codec->inspect().DuplicateVmo()));
   auto* simple_codec = hierarchy().GetByPath({"simple_codec"});
   ASSERT_TRUE(simple_codec);
   ASSERT_NO_FATAL_FAILURES(
       CheckProperty(simple_codec->node(), "state", inspect::StringPropertyValue("created")));
   ASSERT_NO_FATAL_FAILURES(
       CheckProperty(simple_codec->node(), "start_time", inspect::IntPropertyValue(0)));
   ASSERT_NO_FATAL_FAILURES(CheckProperty(simple_codec->node(), "manufacturer",
                                          inspect::StringPropertyValue("Texas Instruments")));
   ASSERT_NO_FATAL_FAILURES(
       CheckProperty(simple_codec->node(), "product", inspect::StringPropertyValue("TAS2770")));
   ASSERT_NO_FATAL_FAILURES(
       CheckProperty(hierarchy().node(), "status_time", inspect::IntPropertyValue(0)));
   ASSERT_NO_FATAL_FAILURES(
       CheckProperty(hierarchy().node(), "codec_status", inspect::UintPropertyValue(0)));

   // Check setting DAI formats.
   {
     DaiFormat format = GetDefaultDaiFormat();
     format.frame_rate = 48'000;
     auto formats = client.GetDaiFormats();
     ASSERT_TRUE(IsDaiFormatSupported(format, formats.value()));
     ASSERT_OK(client.SetDaiFormat(std::move(format)));
   }

   {
     DaiFormat format = GetDefaultDaiFormat();
     format.frame_rate = 96'000;
     auto formats = client.GetDaiFormats();
     ASSERT_TRUE(IsDaiFormatSupported(format, formats.value()));
     ASSERT_OK(client.SetDaiFormat(std::move(format)));
   }

   {
     DaiFormat format = GetDefaultDaiFormat();
     format.frame_rate = 192'000;
     auto formats = client.GetDaiFormats();
     ASSERT_FALSE(IsDaiFormatSupported(format, formats.value()));
     ASSERT_NOT_OK(client.SetDaiFormat(std::move(format)));
   }

   codec->DdkAsyncRemove();
   ASSERT_TRUE(ddk_.Ok());
   codec.release()->DdkRelease();  // codec release managed by the DDK
   mock_i2c.VerifyAndClear();
   mock_fault.VerifyAndClear();
 }

 TEST_F(Tas27xxTest, CodecGain) {
   zx::interrupt irq;
   ASSERT_OK(zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq));

   mock_i2c::MockI2c mock_i2c;
   ddk::MockGpio mock_fault;
   mock_fault.ExpectGetInterrupt(ZX_OK, ZX_INTERRUPT_MODE_EDGE_LOW, std::move(irq));

   auto codec = SimpleCodecServer::Create<Tas27xxCodec>(mock_i2c.GetProto(), mock_fault.GetProto());
   ASSERT_NOT_NULL(codec);
   auto codec_proto = codec->GetProto();
   SimpleCodecClient client;
   client.SetProtocol(&codec_proto);

   // We complete all i2c mock setup before executing server methods in a different thread.
   mock_i2c
       .ExpectWriteStop({0x05, 0x40})   // -32dB.
       .ExpectWriteStop({0x02, 0x0d});  // PWR_CTL stopped.

   // Lower than min gain.
   mock_i2c
       .ExpectWriteStop({0x05, 0xc8})   // -100dB.
       .ExpectWriteStop({0x02, 0x0d});  // PWR_CTL stopped.

   // Higher than max gain.
   mock_i2c
       .ExpectWriteStop({0x05, 0x0})    // 0dB.
       .ExpectWriteStop({0x02, 0x0d});  // PWR_CTL stopped.

   client.SetGainState({
       .gain = -32.f,
       .muted = false,
       .agc_enabled = false,
   });
   client.SetGainState({
       .gain = -999.f,
       .muted = false,
       .agc_enabled = false,
   });
   client.SetGainState({
       .gain = 111.f,
       .muted = false,
       .agc_enabled = false,
   });

   // Make a 2-wal call to make sure the server (we know single threaded) completed previous calls.
   auto unused = client.GetInfo();
   static_cast<void>(unused);

   codec->DdkAsyncRemove();
   ASSERT_TRUE(ddk_.Ok());
   codec.release()->DdkRelease();  // codec release managed by the DDK
   mock_i2c.VerifyAndClear();
   mock_fault.VerifyAndClear();
 }

 }  // namespace audio
	// 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 "tas27xx.h"

	#include <fuchsia/hardware/gpio/cpp/banjo-mock.h>
	#include <lib/fake_ddk/fake_ddk.h>
	#include <lib/inspect/cpp/inspect.h>
	#include <lib/mock-i2c/mock-i2c.h>
	#include <lib/simple-codec/simple-codec-client.h>
	#include <lib/simple-codec/simple-codec-helper.h>
	#include <lib/sync/completion.h>

	#include <sdk/lib/inspect/testing/cpp/zxtest/inspect.h>
	#include <zxtest/zxtest.h>

	namespace audio {

	audio::DaiFormat GetDefaultDaiFormat() {
	return {
	.number_of_channels = 2,
	.channels_to_use_bitmask = 1, // Use one channel in this mono codec.
	.sample_format = SampleFormat::PCM_SIGNED,
	.frame_format = FrameFormat::I2S,
	.frame_rate = 24'000,
	.bits_per_slot = 32,
	.bits_per_sample = 16,
	};
	}

	struct Tas27xxCodec : public Tas27xx {
	explicit Tas27xxCodec(ddk::I2cChannel i2c, ddk::GpioProtocolClient fault)
	: Tas27xx(fake_ddk::kFakeParent, std::move(i2c), std::move(fault), true, true) {}
	codec_protocol_t GetProto() { return {&this->codec_protocol_ops_, this}; }
	inspect::Inspector& inspect() { return Tas27xx::inspect(); }
	};

	class Tas27xxTest : public inspect::InspectTestHelper, public zxtest::Test {
	public:
	void SetUp() override {}

	void TearDown() override {}

	protected:
	fake_ddk::Bind ddk_;
	};

	TEST_F(Tas27xxTest, CodecInitGood) {
	zx::interrupt irq;
	ASSERT_OK(zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq));

	mock_i2c::MockI2c mock_i2c;
	ddk::MockGpio mock_fault;
	mock_fault.ExpectGetInterrupt(ZX_OK, ZX_INTERRUPT_MODE_EDGE_LOW, std::move(irq));

	auto codec = SimpleCodecServer::Create<Tas27xxCodec>(mock_i2c.GetProto(), mock_fault.GetProto());
	ASSERT_NOT_NULL(codec);

	codec->DdkAsyncRemove();
	ASSERT_TRUE(ddk_.Ok());
	codec.release()->DdkRelease(); // codec release managed by the DDK
	mock_i2c.VerifyAndClear();
	mock_fault.VerifyAndClear();
	}

	TEST_F(Tas27xxTest, CodecInitBad) {
	zx::interrupt irq;
	ASSERT_OK(zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq));

	mock_i2c::MockI2c mock_i2c;
	ddk::MockGpio mock_fault;
	// Error when getting the interrupt.
	mock_fault.ExpectGetInterrupt(ZX_ERR_INTERNAL, ZX_INTERRUPT_MODE_EDGE_LOW, std::move(irq));

	auto codec = SimpleCodecServer::Create<Tas27xxCodec>(mock_i2c.GetProto(), mock_fault.GetProto());
	ASSERT_NULL(codec);
	mock_i2c.VerifyAndClear();
	mock_fault.VerifyAndClear();
	}

	TEST_F(Tas27xxTest, CodecGetInfo) {
	zx::interrupt irq;
	ASSERT_OK(zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq));

	mock_i2c::MockI2c mock_i2c;
	ddk::MockGpio mock_fault;
	mock_fault.ExpectGetInterrupt(ZX_OK, ZX_INTERRUPT_MODE_EDGE_LOW, std::move(irq));

	auto codec = SimpleCodecServer::Create<Tas27xxCodec>(mock_i2c.GetProto(), mock_fault.GetProto());
	ASSERT_NOT_NULL(codec);
	auto codec_proto = codec->GetProto();
	SimpleCodecClient client;
	client.SetProtocol(&codec_proto);
	auto info = client.GetInfo();
	ASSERT_EQ(info->unique_id.compare(""), 0);
	ASSERT_EQ(info->manufacturer.compare("Texas Instruments"), 0);
	ASSERT_EQ(info->product_name.compare("TAS2770"), 0);

	codec->DdkAsyncRemove();
	ASSERT_TRUE(ddk_.Ok());
	codec.release()->DdkRelease(); // codec release managed by the DDK
	mock_i2c.VerifyAndClear();
	mock_fault.VerifyAndClear();
	}

	TEST_F(Tas27xxTest, CodecReset) {
	zx::interrupt irq;
	ASSERT_OK(zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq));

	mock_i2c::MockI2c mock_i2c;
	// Reset by the call to Reset.
	mock_i2c
	.ExpectWriteStop({0x01, 0x01}, ZX_ERR_INTERNAL) // SW_RESET error, will retry.
	.ExpectWriteStop({0x01, 0x01}, ZX_OK) // SW_RESET.
	.ExpectWriteStop({0x02, 0x0d}) // PRW_CTL stopped.
	.ExpectWriteStop({0x3c, 0x10}) // CLOCK_CFG.
	.ExpectWriteStop({0x0a, 0x07}) // SetRate.
	.ExpectWriteStop({0x0c, 0x22}) // TDM_CFG2.
	.ExpectWriteStop({0x0e, 0x02}) // TDM_CFG4.
	.ExpectWriteStop({0x0f, 0x44}) // TDM_CFG5.
	.ExpectWriteStop({0x10, 0x40}) // TDM_CFG6.
	.ExpectWrite({0x24})
	.ExpectReadStop({0x00}) // INT_LTCH0.
	.ExpectWrite({0x25})
	.ExpectReadStop({0x00}) // INT_LTCH1.
	.ExpectWrite({0x26})
	.ExpectReadStop({0x00}) // INT_LTCH2.
	.ExpectWriteStop({0x20, 0xf8}) // INT_MASK0.
	.ExpectWriteStop({0x21, 0xff}) // INT_MASK1.
	.ExpectWriteStop({0x30, 0x01}) // INT_CFG.
	.ExpectWriteStop({0x05, 0x3c}) // -30dB.
	.ExpectWriteStop({0x02, 0x0d}); // PWR_CTL stopped.

	ddk::MockGpio mock_fault;
	mock_fault.ExpectGetInterrupt(ZX_OK, ZX_INTERRUPT_MODE_EDGE_LOW, std::move(irq));

	auto codec = SimpleCodecServer::Create<Tas27xxCodec>(mock_i2c.GetProto(), mock_fault.GetProto());
	ASSERT_NOT_NULL(codec);
	auto codec_proto = codec->GetProto();
	SimpleCodecClient client;
	client.SetProtocol(&codec_proto);
	ASSERT_OK(client.Reset());

	codec->DdkAsyncRemove();
	ASSERT_TRUE(ddk_.Ok());
	codec.release()->DdkRelease(); // codec release managed by the DDK
	mock_i2c.VerifyAndClear();
	mock_fault.VerifyAndClear();
	}

	TEST_F(Tas27xxTest, ExternalConfig) {
	zx::interrupt irq;
	ASSERT_OK(zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq));

	metadata::ti::TasConfig metadata = {};
	metadata.number_of_writes1 = 2;
	metadata.init_sequence1[0].address = 0x12;
	metadata.init_sequence1[0].value = 0x34;
	metadata.init_sequence1[1].address = 0x56;
	metadata.init_sequence1[1].value = 0x78;
	metadata.number_of_writes2 = 3;
	metadata.init_sequence2[0].address = 0x11;
	metadata.init_sequence2[0].value = 0x22;
	metadata.init_sequence2[1].address = 0x33;
	metadata.init_sequence2[1].value = 0x44;
	metadata.init_sequence2[2].address = 0x55;
	metadata.init_sequence2[2].value = 0x66;
	ddk_.SetMetadata(&metadata, sizeof(metadata));

	mock_i2c::MockI2c mock_i2c;
	// Reset by the call to Reset.
	mock_i2c
	.ExpectWriteStop({0x01, 0x01}, ZX_ERR_INTERNAL) // SW_RESET error, will retry.
	.ExpectWriteStop({0x01, 0x01}, ZX_OK) // SW_RESET.
	.ExpectWriteStop({0x12, 0x34}) // External config.
	.ExpectWriteStop({0x56, 0x78}) // External config.
	.ExpectWriteStop({0x11, 0x22}) // External config.
	.ExpectWriteStop({0x33, 0x44}) // External config.
	.ExpectWriteStop({0x55, 0x66}) // External config.
	.ExpectWriteStop({0x02, 0x0d}) // PRW_CTL stopped.
	.ExpectWriteStop({0x3c, 0x10}) // CLOCK_CFG.
	.ExpectWriteStop({0x0a, 0x07}) // SetRate.
	.ExpectWriteStop({0x0c, 0x22}) // TDM_CFG2.
	.ExpectWriteStop({0x0e, 0x02}) // TDM_CFG4.
	.ExpectWriteStop({0x0f, 0x44}) // TDM_CFG5.
	.ExpectWriteStop({0x10, 0x40}) // TDM_CFG6.
	.ExpectWrite({0x24})
	.ExpectReadStop({0x00}) // INT_LTCH0.
	.ExpectWrite({0x25})
	.ExpectReadStop({0x00}) // INT_LTCH1.
	.ExpectWrite({0x26})
	.ExpectReadStop({0x00}) // INT_LTCH2.
	.ExpectWriteStop({0x20, 0xf8}) // INT_MASK0.
	.ExpectWriteStop({0x21, 0xff}) // INT_MASK1.
	.ExpectWriteStop({0x30, 0x01}) // INT_CFG.
	.ExpectWriteStop({0x05, 0x3c}) // -30dB.
	.ExpectWriteStop({0x02, 0x0d}); // PWR_CTL stopped.

	ddk::MockGpio mock_fault;
	mock_fault.ExpectGetInterrupt(ZX_OK, ZX_INTERRUPT_MODE_EDGE_LOW, std::move(irq));

	auto codec = SimpleCodecServer::Create<Tas27xxCodec>(mock_i2c.GetProto(), mock_fault.GetProto());
	ASSERT_NOT_NULL(codec);
	auto codec_proto = codec->GetProto();
	SimpleCodecClient client;
	client.SetProtocol(&codec_proto);
	ASSERT_OK(client.Reset());

	codec->DdkAsyncRemove();
	ASSERT_TRUE(ddk_.Ok());
	codec.release()->DdkRelease(); // codec release managed by the DDK
	mock_i2c.VerifyAndClear();
	mock_fault.VerifyAndClear();
	}

	TEST_F(Tas27xxTest, CodecBridgedMode) {
	zx::interrupt irq;
	ASSERT_OK(zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq));

	mock_i2c::MockI2c mock_i2c;
	ddk::MockGpio mock_fault;
	mock_fault.ExpectGetInterrupt(ZX_OK, ZX_INTERRUPT_MODE_EDGE_LOW, std::move(irq));

	auto codec = SimpleCodecServer::Create<Tas27xxCodec>(mock_i2c.GetProto(), mock_fault.GetProto());
	ASSERT_NOT_NULL(codec);
	auto codec_proto = codec->GetProto();
	SimpleCodecClient client;
	client.SetProtocol(&codec_proto);
	{
	auto bridgeable = client.IsBridgeable();
	ASSERT_FALSE(bridgeable.value());
	}
	client.SetBridgedMode(false);

	codec->DdkAsyncRemove();
	ASSERT_TRUE(ddk_.Ok());
	codec.release()->DdkRelease(); // codec release managed by the DDK
	mock_i2c.VerifyAndClear();
	mock_fault.VerifyAndClear();
	}

	TEST_F(Tas27xxTest, CodecDaiFormat) {
	zx::interrupt irq;
	ASSERT_OK(zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq));

	mock_i2c::MockI2c mock_i2c;
	ddk::MockGpio mock_fault;
	mock_fault.ExpectGetInterrupt(ZX_OK, ZX_INTERRUPT_MODE_EDGE_LOW, std::move(irq));

	auto codec = SimpleCodecServer::Create<Tas27xxCodec>(mock_i2c.GetProto(), mock_fault.GetProto());
	ASSERT_NOT_NULL(codec);
	auto codec_proto = codec->GetProto();
	SimpleCodecClient client;
	client.SetProtocol(&codec_proto);

	// We complete all i2c mock setup before executing server methods in a different thread.
	mock_i2c.ExpectWriteStop({0x0a, 0x07});
	mock_i2c.ExpectWriteStop({0x0a, 0x09});

	// Check getting DAI formats.
	{
	auto formats = client.GetDaiFormats();
	ASSERT_EQ(formats.value().number_of_channels.size(), 1);
	ASSERT_EQ(formats.value().number_of_channels[0], 2);
	ASSERT_EQ(formats.value().sample_formats.size(), 1);
	ASSERT_EQ(formats.value().sample_formats[0], SampleFormat::PCM_SIGNED);
	ASSERT_EQ(formats.value().frame_formats.size(), 1);
	ASSERT_EQ(formats.value().frame_formats[0], FrameFormat::I2S);
	ASSERT_EQ(formats.value().frame_rates.size(), 2);
	ASSERT_EQ(formats.value().frame_rates[0], 48000);
	ASSERT_EQ(formats.value().frame_rates[1], 96000);
	ASSERT_EQ(formats.value().bits_per_slot.size(), 1);
	ASSERT_EQ(formats.value().bits_per_slot[0], 32);
	ASSERT_EQ(formats.value().bits_per_sample.size(), 1);
	ASSERT_EQ(formats.value().bits_per_sample[0], 16);
	}

	// Check inspect state.
	ASSERT_NO_FATAL_FAILURES(ReadInspect(codec->inspect().DuplicateVmo()));
	auto* simple_codec = hierarchy().GetByPath({"simple_codec"});
	ASSERT_TRUE(simple_codec);
	ASSERT_NO_FATAL_FAILURES(
	CheckProperty(simple_codec->node(), "state", inspect::StringPropertyValue("created")));
	ASSERT_NO_FATAL_FAILURES(
	CheckProperty(simple_codec->node(), "start_time", inspect::IntPropertyValue(0)));
	ASSERT_NO_FATAL_FAILURES(CheckProperty(simple_codec->node(), "manufacturer",
	inspect::StringPropertyValue("Texas Instruments")));
	ASSERT_NO_FATAL_FAILURES(
	CheckProperty(simple_codec->node(), "product", inspect::StringPropertyValue("TAS2770")));
	ASSERT_NO_FATAL_FAILURES(
	CheckProperty(hierarchy().node(), "status_time", inspect::IntPropertyValue(0)));
	ASSERT_NO_FATAL_FAILURES(
	CheckProperty(hierarchy().node(), "codec_status", inspect::UintPropertyValue(0)));

	// Check setting DAI formats.
	{
	DaiFormat format = GetDefaultDaiFormat();
	format.frame_rate = 48'000;
	auto formats = client.GetDaiFormats();
	ASSERT_TRUE(IsDaiFormatSupported(format, formats.value()));
	ASSERT_OK(client.SetDaiFormat(std::move(format)));
	}

	{
	DaiFormat format = GetDefaultDaiFormat();
	format.frame_rate = 96'000;
	auto formats = client.GetDaiFormats();
	ASSERT_TRUE(IsDaiFormatSupported(format, formats.value()));
	ASSERT_OK(client.SetDaiFormat(std::move(format)));
	}

	{
	DaiFormat format = GetDefaultDaiFormat();
	format.frame_rate = 192'000;
	auto formats = client.GetDaiFormats();
	ASSERT_FALSE(IsDaiFormatSupported(format, formats.value()));
	ASSERT_NOT_OK(client.SetDaiFormat(std::move(format)));
	}

	codec->DdkAsyncRemove();
	ASSERT_TRUE(ddk_.Ok());
	codec.release()->DdkRelease(); // codec release managed by the DDK
	mock_i2c.VerifyAndClear();
	mock_fault.VerifyAndClear();
	}

	TEST_F(Tas27xxTest, CodecGain) {
	zx::interrupt irq;
	ASSERT_OK(zx::interrupt::create(zx::resource(), 0, ZX_INTERRUPT_VIRTUAL, &irq));

	mock_i2c::MockI2c mock_i2c;
	ddk::MockGpio mock_fault;
	mock_fault.ExpectGetInterrupt(ZX_OK, ZX_INTERRUPT_MODE_EDGE_LOW, std::move(irq));

	auto codec = SimpleCodecServer::Create<Tas27xxCodec>(mock_i2c.GetProto(), mock_fault.GetProto());
	ASSERT_NOT_NULL(codec);
	auto codec_proto = codec->GetProto();
	SimpleCodecClient client;
	client.SetProtocol(&codec_proto);

	// We complete all i2c mock setup before executing server methods in a different thread.
	mock_i2c
	.ExpectWriteStop({0x05, 0x40}) // -32dB.
	.ExpectWriteStop({0x02, 0x0d}); // PWR_CTL stopped.

	// Lower than min gain.
	mock_i2c
	.ExpectWriteStop({0x05, 0xc8}) // -100dB.
	.ExpectWriteStop({0x02, 0x0d}); // PWR_CTL stopped.

	// Higher than max gain.
	mock_i2c
	.ExpectWriteStop({0x05, 0x0}) // 0dB.
	.ExpectWriteStop({0x02, 0x0d}); // PWR_CTL stopped.

	client.SetGainState({
	.gain = -32.f,
	.muted = false,
	.agc_enabled = false,
	});
	client.SetGainState({
	.gain = -999.f,
	.muted = false,
	.agc_enabled = false,
	});
	client.SetGainState({
	.gain = 111.f,
	.muted = false,
	.agc_enabled = false,
	});

	// Make a 2-wal call to make sure the server (we know single threaded) completed previous calls.
	auto unused = client.GetInfo();
	static_cast<void>(unused);

	codec->DdkAsyncRemove();
	ASSERT_TRUE(ddk_.Ok());
	codec.release()->DdkRelease(); // codec release managed by the DDK
	mock_i2c.VerifyAndClear();
	mock_fault.VerifyAndClear();
	}

	} // namespace audio