// 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 "bt-hci-mediatek.h"

#include <lib/mock-function/mock-function.h>
#include <lib/mock-sdio/mock-sdio.h>
#include <zxtest/zxtest.h>

namespace bluetooth {

class BtHciMediatekTest : public BtHciMediatek {
 public:
  struct CardTxnResult {
    zx_status_t status;
    uint32_t data;
  };

  struct CardBlockTxnResult {
    zx_status_t status;
    const uint8_t* data;
    size_t size;
  };

  BtHciMediatekTest(const ddk::SdioProtocolClient& sdio, size_t fw_part_max_size = 0)
      : BtHciMediatek(nullptr, sdio, zx::port(), fw_part_max_size) {}

  mock_function::MockFunction<CardTxnResult, uint32_t>& mock_CardRead32() { return mock_read32_; }
  mock_function::MockFunction<zx_status_t, uint32_t, uint32_t>& mock_CardWrite32() {
    return mock_write32_;
  }
  mock_function::MockFunction<CardTxnResult>& mock_CardRecvPacket() { return mock_recv_packet_; }
  mock_function::MockFunction<zx_status_t>& mock_CardReset() { return mock_reset_; }
  mock_function::MockFunction<CardTxnResult>& mock_CardGetHwVersion() {
    return mock_get_hw_version_;
  }
  mock_function::MockFunction<CardBlockTxnResult, FirmwarePartMode>& mock_CardSendFirmwarePart() {
    return mock_send_firmware_part_;
  }

  void VerifyAll() {
    mock_read32_.VerifyAndClear();
    mock_write32_.VerifyAndClear();
    mock_recv_packet_.VerifyAndClear();
    mock_reset_.VerifyAndClear();
    mock_get_hw_version_.VerifyAndClear();
    mock_send_firmware_part_.VerifyAndClear();
  }

  zx_status_t CardRecvPacket(uint32_t* size) override {
    if (mock_recv_packet_.HasExpectations()) {
      CardTxnResult result = mock_recv_packet_.Call();
      *size = result.data;
      return result.status;
    } else {
      return BtHciMediatek::CardRecvPacket(size);
    }
  }

  zx_status_t CardSendFirmwarePart(zx_handle_t vmo, uint8_t* buffer, const uint8_t* fw_data,
                                   size_t size, FirmwarePartMode mode) override {
    if (mock_send_firmware_part_.HasExpectations()) {
      CardBlockTxnResult result = mock_send_firmware_part_.Call(mode);
      CardSendFirmwarePartHelper(result, fw_data, size);
      return result.status;
    } else {
      return BtHciMediatek::CardSendFirmwarePart(vmo, buffer, fw_data, size, mode);
    }
  }

 private:
  zx_status_t CardRead32(uint32_t address, uint32_t* value) override {
    CardTxnResult result = mock_read32_.Call(address);
    *value = result.data;
    return result.status;
  }

  zx_status_t CardWrite32(uint32_t address, uint32_t value) override {
    return mock_write32_.Call(address, value);
  }

  zx_status_t CardReset() override { return mock_reset_.Call(); }

  zx_status_t CardGetHwVersion(uint32_t* version) override {
    CardTxnResult result = mock_get_hw_version_.Call();
    *version = result.data;
    return result.status;
  }

  void CardSendFirmwarePartHelper(const CardBlockTxnResult& result, const uint8_t* fw_data,
                                  size_t size) {
    ASSERT_EQ(result.size, size);
    EXPECT_BYTES_EQ(result.data, fw_data, result.size);
  }

  mock_function::MockFunction<CardTxnResult, uint32_t> mock_read32_;
  mock_function::MockFunction<zx_status_t, uint32_t, uint32_t> mock_write32_;
  mock_function::MockFunction<CardTxnResult> mock_recv_packet_;
  mock_function::MockFunction<zx_status_t> mock_reset_;
  mock_function::MockFunction<CardTxnResult> mock_get_hw_version_;
  mock_function::MockFunction<CardBlockTxnResult, FirmwarePartMode> mock_send_firmware_part_;
};

TEST(BtHciMediatekTest, TestCardRecvPacket) {
  mock_sdio::MockSdio sdio;
  BtHciMediatekTest test(ddk::SdioProtocolClient(sdio.GetProto()));

  test.mock_CardRead32().ExpectCall({ZX_OK, 0xabcd1236}, 0x10);
  test.mock_CardWrite32().ExpectCall(ZX_OK, 0x10, 0x00001232);

  uint32_t size = 0;
  EXPECT_OK(test.CardRecvPacket(&size));
  EXPECT_EQ(0xabcd, size);

  test.VerifyAll();

  // Test a timeout condition.
  test.mock_CardRead32()
      .ExpectCall({ZX_OK, 0xabcd0000}, 0x10)
      .ExpectCall({ZX_OK, 0x00000000}, 0x10)
      .ExpectCall({ZX_OK, 0x00000000}, 0x10)
      .ExpectCall({ZX_OK, 0x00000002}, 0x10)
      .ExpectCall({ZX_OK, 0x12340000}, 0x10)
      .ExpectCall({ZX_OK, 0x00000002}, 0x10);
  test.mock_CardWrite32().ExpectNoCall();

  EXPECT_EQ(ZX_ERR_TIMED_OUT, test.CardRecvPacket(&size));

  test.VerifyAll();
}

TEST(BtHciMediatekTest, TestCardSendVendorPacketCmd) {
  mock_sdio::MockSdio sdio;
  BtHciMediatekTest test(ddk::SdioProtocolClient(sdio.GetProto()));

  fbl::Vector<uint8_t> write_data = {0x10, 0x00, 0x00, 0x00, 0x01, 0xcd, 0xfc, 0x08,
                                     0xe5, 0xd5, 0x4d, 0x4d, 0x4d, 0xad, 0x47, 0xd0};

  fbl::Vector<uint8_t> read_data = {0x14, 0x00, 0x00, 0x00, 0x32, 0xbf, 0x9c, 0x81, 0x70, 0xdd,
                                    0x9a, 0x68, 0xf0, 0x36, 0x06, 0x49, 0x7c, 0x7b, 0x83, 0x21};
  uint8_t expected_read_packet[16];
  memcpy(expected_read_packet, read_data.get() + 4, read_data.size() - 4);

  uint8_t packet[32];
  size_t size = write_data.size() - 8;
  memcpy(packet, write_data.get() + 8, size);

  sdio.ExpectFifoWrite(0x18, std::move(write_data), false);
  test.mock_CardRecvPacket().ExpectCall({ZX_OK, static_cast<uint32_t>(read_data.size())});
  sdio.ExpectFifoRead(0x1c, std::move(read_data), true);

  EXPECT_OK(test.CardSendVendorPacket(1, 0xcd, packet, &size, sizeof(packet)));
  ASSERT_EQ(sizeof(expected_read_packet), size);
  EXPECT_BYTES_EQ(expected_read_packet, packet, sizeof(expected_read_packet));

  test.VerifyAll();
  sdio.VerifyAndClear();
}

TEST(BtHciMediatekTest, TestCardSendVendorPacketAcl) {
  mock_sdio::MockSdio sdio;
  BtHciMediatekTest test(ddk::SdioProtocolClient(sdio.GetProto()));

  fbl::Vector<uint8_t> write_data = {0x19, 0x00, 0x00, 0x00, 0x02, 0xab, 0xfc, 0x10, 0x00,
                                     0x87, 0xae, 0x01, 0x46, 0x3c, 0xd9, 0xd7, 0x68, 0x8b,
                                     0x07, 0x9b, 0xc8, 0xb1, 0xf3, 0x99, 0x13};

  fbl::Vector<uint8_t> read_data = {0x08, 0x00, 0x00, 0x00, 0xc6, 0x7b, 0x1a, 0x84};
  uint8_t expected_read_packet[4];
  memcpy(expected_read_packet, read_data.get() + 4, read_data.size() - 4);

  uint8_t packet[32];
  size_t size = write_data.size() - 9;
  memcpy(packet, write_data.get() + 9, size);

  sdio.ExpectFifoWrite(0x18, std::move(write_data), false);
  test.mock_CardRecvPacket().ExpectCall({ZX_OK, static_cast<uint32_t>(read_data.size())});
  sdio.ExpectFifoRead(0x1c, std::move(read_data), true);

  EXPECT_OK(test.CardSendVendorPacket(2, 0xab, packet, &size, sizeof(packet)));
  ASSERT_EQ(sizeof(expected_read_packet), size);
  EXPECT_BYTES_EQ(expected_read_packet, packet, sizeof(expected_read_packet));

  test.VerifyAll();
  sdio.VerifyAndClear();
}

TEST(BtHciMediatekTest, TestCardSendVendorPacketEdgeCases) {
  mock_sdio::MockSdio sdio;
  BtHciMediatekTest test(ddk::SdioProtocolClient(sdio.GetProto()));

  fbl::Vector<uint8_t> write_data = {0x0c, 0x00, 0x00, 0x00, 0x01, 0xef,
                                     0xfc, 0x04, 0x02, 0xe6, 0x55, 0xa6};

  fbl::Vector<uint8_t> read_data = {0x04, 0x00, 0x00, 0x00};

  uint8_t packet[12];
  size_t size = write_data.size() - 8;
  memcpy(packet, write_data.get() + 8, size);

  sdio.ExpectFifoWrite(0x18, std::move(write_data), false);
  test.mock_CardRecvPacket().ExpectCall({ZX_OK, static_cast<uint32_t>(read_data.size())});
  sdio.ExpectFifoRead(0x1c, std::move(read_data), true);

  EXPECT_OK(test.CardSendVendorPacket(1, 0xef, packet, &size, sizeof(packet)));
  ASSERT_EQ(0, size);

  test.VerifyAll();
  sdio.VerifyAndClear();
}

TEST(BtHciMediatekTest, TestCardSendVendorPacketFail) {
  mock_sdio::MockSdio sdio;
  BtHciMediatekTest test(ddk::SdioProtocolClient(sdio.GetProto()));

  // Received packet is shorter than the SDIO header.
  fbl::Vector<uint8_t> write_data = {0x0c, 0x00, 0x00, 0x00, 0x01, 0x00,
                                     0xfc, 0x04, 0x31, 0x7b, 0xc0, 0x78};

  uint8_t packet[12];
  size_t size = write_data.size() - 8;
  memcpy(packet, write_data.get() + 8, size);

  sdio.ExpectFifoWrite(0x18, std::move(write_data), false);
  test.mock_CardRecvPacket().ExpectCall({ZX_OK, 3});

  EXPECT_NE(ZX_OK, test.CardSendVendorPacket(1, 0x00, packet, &size, sizeof(packet)));

  test.VerifyAll();
  sdio.VerifyAndClear();

  // Received packet does not fit in the provided buffer.
  write_data = {0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0xfc, 0x04, 0x25, 0xce, 0xd4, 0xf2};

  size = write_data.size() - 8;
  memcpy(packet, write_data.get() + 8, size);

  sdio.ExpectFifoWrite(0x18, std::move(write_data), false);
  test.mock_CardRecvPacket().ExpectCall({ZX_OK, sizeof(packet) + 5});

  EXPECT_NE(ZX_OK, test.CardSendVendorPacket(1, 0x00, packet, &size, sizeof(packet)));

  test.VerifyAll();
  sdio.VerifyAndClear();

  // Received packet size field doesn't match size field from CHISR register.
  write_data = {0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0xfc, 0x04, 0xcd, 0x9b, 0x46, 0xfc};

  fbl::Vector<uint8_t> read_data = {0x06, 0x00, 0x00, 0x00, 0xa3, 0x2f, 0x2c, 0xf0};

  size = write_data.size() - 8;
  memcpy(packet, write_data.get() + 8, size);

  sdio.ExpectFifoWrite(0x18, std::move(write_data), false);
  test.mock_CardRecvPacket().ExpectCall({ZX_OK, static_cast<uint32_t>(read_data.size())});
  sdio.ExpectFifoRead(0x1c, std::move(read_data), true);

  EXPECT_NE(ZX_OK, test.CardSendVendorPacket(1, 0x00, packet, &size, sizeof(packet)));

  test.VerifyAll();
  sdio.VerifyAndClear();
}

TEST(BtHciMediatekTest, TestCardSendFirmwarePart) {
  constexpr uint8_t kExpectedResponse[] = {0x0c, 0x00, 0x00, 0x00, 0x04, 0xe4,
                                           0x05, 0x02, 0x01, 0x01, 0x00, 0x00};
  mock_sdio::MockSdio sdio;
  BtHciMediatekTest test(ddk::SdioProtocolClient(sdio.GetProto()));

  fbl::Vector<uint8_t> write_data = {0x2e, 0x00, 0x00, 0x00,        // SDIO header
                                     0x02, 0x6f, 0xfc, 0x25, 0x00,  // Vendor header
                                     0x01, 0x01, 0x21, 0x00, 0x01,  // STP header
                                     0xc9, 0xad, 0x54, 0x57, 0x36, 0xe3, 0x02, 0x9b,  // Payload
                                     0x71, 0x93, 0x0e, 0x64, 0xfb, 0xe4, 0x5c, 0x94,
                                     0xd5, 0xae, 0x0b, 0x37, 0x45, 0xbf, 0x30, 0x54,
                                     0x52, 0x29, 0x2f, 0x27, 0xa4, 0x74, 0x4f, 0xd9};

  zx::vmo vmo;
  fzl::VmoMapper mapper;
  ASSERT_OK(
      mapper.CreateAndMap(write_data.size(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, nullptr, &vmo));
  uint8_t* buffer = reinterpret_cast<uint8_t*>(mapper.start());

  uint8_t fw_data[32];
  size_t fw_data_size = write_data.size() - 14;
  memcpy(fw_data, write_data.get() + 14, fw_data_size);

  fbl::Vector<uint8_t> read_data;
  for (size_t i = 0; i < sizeof(kExpectedResponse); i++) {
    read_data.push_back(kExpectedResponse[i]);
  }

  sdio.ExpectFifoWrite(0x18, std::move(write_data), false);
  test.mock_CardRecvPacket().ExpectCall({ZX_OK, static_cast<uint32_t>(read_data.size())});
  sdio.ExpectFifoRead(0x1c, std::move(read_data), true);

  EXPECT_OK(test.CardSendFirmwarePart(vmo.get(), buffer, fw_data, fw_data_size,
                                      BtHciMediatek::kFirmwarePartFirst));

  test.VerifyAll();
  sdio.VerifyAndClear();

  write_data = {0x2e, 0x00, 0x00, 0x00, 0x02, 0x6f, 0xfc, 0x25, 0x00, 0x01, 0x01, 0x21,
                0x00, 0x02, 0xe9, 0x39, 0x18, 0x18, 0x6a, 0x3b, 0xd7, 0x1a, 0x94, 0xca,
                0xd2, 0x93, 0xdc, 0x34, 0xbb, 0x86, 0x4a, 0x7d, 0x48, 0x48, 0x6b, 0xfd,
                0xc0, 0xa6, 0xb6, 0x01, 0xe1, 0xec, 0x3f, 0xac, 0x57, 0x2f};

  fw_data_size = write_data.size() - 14;
  memcpy(fw_data, write_data.get() + 14, fw_data_size);

  for (size_t i = 0; i < sizeof(kExpectedResponse); i++) {
    read_data.push_back(kExpectedResponse[i]);
  }

  sdio.ExpectFifoWrite(0x18, std::move(write_data), false);
  test.mock_CardRecvPacket().ExpectCall({ZX_OK, static_cast<uint32_t>(read_data.size())});
  sdio.ExpectFifoRead(0x1c, std::move(read_data), true);

  EXPECT_OK(test.CardSendFirmwarePart(vmo.get(), buffer, fw_data, fw_data_size,
                                      BtHciMediatek::kFirmwarePartContinue));

  test.VerifyAll();
  sdio.VerifyAndClear();

  write_data = {0x16, 0x00, 0x00, 0x00, 0x02, 0x6f, 0xfc, 0x0d, 0x00, 0x01, 0x01,
                0x09, 0x00, 0x03, 0x90, 0x8a, 0x05, 0xd6, 0x68, 0x5c, 0x39, 0x81};

  fw_data_size = write_data.size() - 14;
  memcpy(fw_data, write_data.get() + 14, fw_data_size);

  for (size_t i = 0; i < sizeof(kExpectedResponse); i++) {
    read_data.push_back(kExpectedResponse[i]);
  }

  sdio.ExpectFifoWrite(0x18, std::move(write_data), false);
  test.mock_CardRecvPacket().ExpectCall({ZX_OK, static_cast<uint32_t>(read_data.size())});
  sdio.ExpectFifoRead(0x1c, std::move(read_data), true);

  EXPECT_OK(test.CardSendFirmwarePart(vmo.get(), buffer, fw_data, fw_data_size,
                                      BtHciMediatek::kFirmwarePartLast));

  test.VerifyAll();
  sdio.VerifyAndClear();
}

TEST(BtHciMediatekTest, TestCardSendFirmwarePartFail) {
  mock_sdio::MockSdio sdio;
  BtHciMediatekTest test(ddk::SdioProtocolClient(sdio.GetProto()));

  fbl::Vector<uint8_t> write_data = {0x16, 0x00, 0x00, 0x00, 0x02, 0x6f, 0xfc, 0x0d,
                                     0x00, 0x01, 0x01, 0x09, 0x00, 0x01, 0x5e, 0xe0,
                                     0xb5, 0x7e, 0xf8, 0x90, 0x46, 0xa3};

  zx::vmo vmo;
  fzl::VmoMapper mapper;
  ASSERT_OK(
      mapper.CreateAndMap(write_data.size(), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, nullptr, &vmo));
  uint8_t* buffer = reinterpret_cast<uint8_t*>(mapper.start());

  uint8_t fw_data[8];
  size_t fw_data_size = write_data.size() - 14;
  memcpy(fw_data, write_data.get() + 14, fw_data_size);

  sdio.ExpectFifoWrite(0x18, std::move(write_data), false);
  test.mock_CardRecvPacket().ExpectCall({ZX_OK, 13});

  EXPECT_NE(ZX_OK, test.CardSendFirmwarePart(vmo.get(), buffer, fw_data, fw_data_size,
                                             BtHciMediatek::kFirmwarePartFirst));

  test.VerifyAll();
  sdio.VerifyAndClear();

  write_data = {0x16, 0x00, 0x00, 0x00, 0x02, 0x6f, 0xfc, 0x0d, 0x00, 0x01, 0x01,
                0x09, 0x00, 0x03, 0x7c, 0x4b, 0x8b, 0xd2, 0x73, 0x0d, 0x72, 0x8e};

  fw_data_size = write_data.size() - 14;
  memcpy(fw_data, write_data.get() + 14, fw_data_size);

  fbl::Vector<uint8_t> read_data = {0x0c, 0x00, 0x00, 0x00, 0x04, 0xe4,
                                    0x05, 0x02, 0x01, 0x01, 0x00, 0x01};

  sdio.ExpectFifoWrite(0x18, std::move(write_data), false);
  test.mock_CardRecvPacket().ExpectCall({ZX_OK, static_cast<uint32_t>(read_data.size())});
  sdio.ExpectFifoRead(0x1c, std::move(read_data), true);

  EXPECT_NE(ZX_OK, test.CardSendFirmwarePart(vmo.get(), buffer, fw_data, fw_data_size,
                                             BtHciMediatek::kFirmwarePartLast));

  test.VerifyAll();
  sdio.VerifyAndClear();
}

TEST(BtHciMediatekTest, TestCardDownloadFirmware) {
  mock_sdio::MockSdio sdio;
  BtHciMediatekTest test(ddk::SdioProtocolClient(sdio.GetProto()), 8);

  const uint8_t fw_data[] = {0x7f, 0x26, 0x56, 0xd1, 0x44, 0x2c, 0xff, 0x5d,  // Header
                             0xa5, 0xdf, 0x69, 0xf5, 0x0b, 0x7e, 0xc0, 0x6b, 0x50, 0xda, 0x6e,
                             0x0c, 0x6e, 0xb0, 0x75, 0xc3, 0xd9, 0x91, 0xff, 0x92, 0xf4, 0x06,
                             0x89, 0xf0, 0x13, 0x10, 0x7a, 0xa6, 0x52, 0x40,  // Firmware data
                             0x92, 0xe5, 0x96, 0x52, 0x86, 0x14, 0x90, 0x11, 0xd1, 0x94, 0x3f,
                             0x2f, 0xf9, 0x6d, 0xab, 0x9e, 0xa0, 0x59, 0x0a, 0xfd};

  zx::vmo vmo;
  fzl::VmoMapper mapper;
  ASSERT_OK(
      mapper.CreateAndMap(sizeof(fw_data), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, nullptr, &vmo));
  memcpy(mapper.start(), fw_data, sizeof(fw_data));

  test.mock_CardGetHwVersion().ExpectCall({ZX_OK, 0});
  test.mock_CardSendFirmwarePart().ExpectCall({ZX_OK, fw_data + 30, 8},
                                              BtHciMediatek::kFirmwarePartFirst);
  test.mock_CardSendFirmwarePart().ExpectCall({ZX_OK, fw_data + 38, 8},
                                              BtHciMediatek::kFirmwarePartContinue);
  test.mock_CardSendFirmwarePart().ExpectCall({ZX_OK, fw_data + 46, 8},
                                              BtHciMediatek::kFirmwarePartContinue);
  test.mock_CardSendFirmwarePart().ExpectCall({ZX_OK, fw_data + 54, 4},
                                              BtHciMediatek::kFirmwarePartLast);
  test.mock_CardRead32().ExpectCall({ZX_OK, 0}, 0x0c);
  test.mock_CardWrite32().ExpectCall(ZX_OK, 0x0c, 2);
  test.mock_CardReset().ExpectCall(ZX_OK);

  EXPECT_OK(test.CardDownloadFirmware(vmo, sizeof(fw_data)));

  test.VerifyAll();
  sdio.VerifyAndClear();
}

TEST(BtHciMediatekTest, TestCardDownloadFirmwareEdgeCases) {
  mock_sdio::MockSdio sdio;
  BtHciMediatekTest test(ddk::SdioProtocolClient(sdio.GetProto()), 8);

  const uint8_t fw_data[] = {0xb0, 0x4f, 0xe7, 0x35, 0x71, 0x41, 0xc4, 0xac, 0x72, 0x95, 0x63,
                             0x9d, 0x3c, 0x93, 0xfb, 0x0c, 0xee, 0x84, 0x05, 0xbf, 0x98, 0xe5,
                             0xde, 0x30, 0xf8, 0xaf, 0xbf, 0x2c, 0xfd, 0x7f, 0xc4, 0x6b, 0x59,
                             0x3e, 0xc2, 0xc2, 0x77, 0xc4, 0x5e, 0xe1, 0x89, 0xe4, 0x93, 0xf8,
                             0x0b, 0x22, 0x4b, 0x20, 0xc2, 0x9b, 0x0f, 0x6f, 0x0c, 0x4e};

  zx::vmo vmo;
  fzl::VmoMapper mapper;
  ASSERT_OK(
      mapper.CreateAndMap(sizeof(fw_data), ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, nullptr, &vmo));
  memcpy(mapper.start(), fw_data, sizeof(fw_data) - 16);

  test.mock_CardGetHwVersion().ExpectCall({ZX_OK, 0});
  test.mock_CardSendFirmwarePart().ExpectCall({ZX_OK, fw_data + 30, 8},
                                              BtHciMediatek::kFirmwarePartFirst);
  test.mock_CardRead32().ExpectCall({ZX_OK, 0}, 0x0c);
  test.mock_CardWrite32().ExpectCall(ZX_OK, 0x0c, 2);
  test.mock_CardReset().ExpectCall(ZX_OK);

  EXPECT_OK(test.CardDownloadFirmware(vmo, sizeof(fw_data) - 16));

  test.VerifyAll();
  sdio.VerifyAndClear();

  memcpy(mapper.start(), fw_data, sizeof(fw_data) - 4);

  test.mock_CardGetHwVersion().ExpectCall({ZX_OK, 0});
  test.mock_CardSendFirmwarePart().ExpectCall({ZX_OK, fw_data + 30, 4},
                                              BtHciMediatek::kFirmwarePartFirst);
  test.mock_CardRead32().ExpectCall({ZX_OK, 0}, 0x0c);
  test.mock_CardWrite32().ExpectCall(ZX_OK, 0x0c, 2);
  test.mock_CardReset().ExpectCall(ZX_OK);

  EXPECT_OK(test.CardDownloadFirmware(vmo, sizeof(fw_data) - 20));

  test.VerifyAll();
  sdio.VerifyAndClear();

  memcpy(mapper.start(), fw_data, sizeof(fw_data));

  test.mock_CardGetHwVersion().ExpectCall({ZX_OK, 0});
  test.mock_CardSendFirmwarePart().ExpectCall({ZX_OK, fw_data + 30, 8},
                                              BtHciMediatek::kFirmwarePartFirst);
  test.mock_CardSendFirmwarePart().ExpectCall({ZX_OK, fw_data + 38, 8},
                                              BtHciMediatek::kFirmwarePartContinue);
  test.mock_CardSendFirmwarePart().ExpectCall({ZX_OK, fw_data + 46, 8},
                                              BtHciMediatek::kFirmwarePartLast);
  test.mock_CardRead32().ExpectCall({ZX_OK, 0}, 0x0c);
  test.mock_CardWrite32().ExpectCall(ZX_OK, 0x0c, 2);
  test.mock_CardReset().ExpectCall(ZX_OK);

  EXPECT_OK(test.CardDownloadFirmware(vmo, sizeof(fw_data)));

  test.VerifyAll();
  sdio.VerifyAndClear();

  memcpy(mapper.start(), fw_data, sizeof(fw_data) - 24);

  test.mock_CardGetHwVersion().ExpectCall({ZX_OK, 0});
  test.mock_CardRead32().ExpectCall({ZX_OK, 0}, 0x0c);
  test.mock_CardWrite32().ExpectCall(ZX_OK, 0x0c, 2);
  test.mock_CardReset().ExpectCall(ZX_OK);

  EXPECT_OK(test.CardDownloadFirmware(vmo, sizeof(fw_data) - 24));

  test.VerifyAll();
  sdio.VerifyAndClear();
}

TEST(BtHciMediatekTest, TestCardDownloadFirmwareFail) {
  mock_sdio::MockSdio sdio;
  BtHciMediatekTest test(ddk::SdioProtocolClient(sdio.GetProto()), 8);

  zx::vmo vmo;
  fzl::VmoMapper mapper;
  ASSERT_OK(mapper.CreateAndMap(32, ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, nullptr, &vmo));

  EXPECT_NE(ZX_OK, test.CardDownloadFirmware(vmo, 29));

  test.VerifyAll();
  sdio.VerifyAndClear();

  test.mock_CardGetHwVersion().ExpectCall({ZX_OK, 0x8a00});

  EXPECT_NE(ZX_OK, test.CardDownloadFirmware(vmo, 32));

  test.VerifyAll();
  sdio.VerifyAndClear();
}

}  // namespace bluetooth