src/connectivity/ethernet/drivers/asix-88179/asix-88179-test.cc

// 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 <dirent.h>
#include <endian.h>
#include <fcntl.h>
#include <fuchsia/device/llcpp/fidl.h>
#include <fuchsia/hardware/ax88179/llcpp/fidl.h>
#include <fuchsia/hardware/ethernet/llcpp/fidl.h>
#include <fuchsia/hardware/usb/virtual/bus/llcpp/fidl.h>
#include <lib/fdio/cpp/caller.h>
#include <lib/fdio/fdio.h>
#include <lib/fdio/watcher.h>
#include <lib/fzl/vmo-mapper.h>
#include <lib/usb-virtual-bus-launcher/usb-virtual-bus-launcher.h>
#include <lib/zx/clock.h>
#include <zircon/device/ethernet.h>
#include <zircon/hw/usb.h>
#include <zircon/hw/usb/cdc.h>

#include <zxtest/zxtest.h>

#include "asix-88179-regs.h"

namespace usb_ax88179 {
namespace {

namespace ethernet = ::llcpp::fuchsia::hardware::ethernet;
namespace ax88179 = ::llcpp::fuchsia::hardware::ax88179;

class USBVirtualBus : public usb_virtual_bus_base::USBVirtualBusBase {
 public:
  USBVirtualBus() = default;

  void InitUsbAx88179(fbl::String* dev_path, fbl::String* test_function_path);
};

void USBVirtualBus::InitUsbAx88179(fbl::String* dev_path, fbl::String* test_function_path) {
  namespace usb_peripheral = ::llcpp::fuchsia::hardware::usb::peripheral;
  using ConfigurationDescriptor =
      ::fidl::VectorView<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor>;

  usb_peripheral::DeviceDescriptor device_desc = {};
  device_desc.bcd_usb = htole16(0x0200);
  device_desc.b_max_packet_size0 = 64;
  device_desc.bcd_device = htole16(0x0100);
  device_desc.b_num_configurations = 1;

  usb_peripheral::FunctionDescriptor usb_ax88179_desc = {
      .interface_class = USB_CLASS_COMM,
      .interface_subclass = USB_CDC_SUBCLASS_ETHERNET,
      .interface_protocol = 0,
  };

  device_desc.id_vendor = htole16(ASIX_VID);
  device_desc.id_product = htole16(AX88179_PID);
  std::vector<ConfigurationDescriptor> config_descs;
  std::vector<usb_peripheral::FunctionDescriptor> function_descs;
  function_descs.push_back(usb_ax88179_desc);
  ConfigurationDescriptor config_desc;
  config_desc = fidl::VectorView(fidl::unowned_ptr(function_descs.data()), function_descs.size());
  config_descs.push_back(std::move(config_desc));
  ASSERT_NO_FATAL_FAILURES(SetupPeripheralDevice(std::move(device_desc), std::move(config_descs)));

  fbl::unique_fd fd(openat(devmgr_.devfs_root().get(), "class/ethernet", O_RDONLY));
  while (fdio_watch_directory(fd.get(), usb_virtual_bus::WaitForAnyFile, ZX_TIME_INFINITE,
                              dev_path) != ZX_ERR_STOP) {
  }
  *dev_path = fbl::String::Concat({fbl::String("class/ethernet/"), *dev_path});

  fd.reset(openat(devmgr_.devfs_root().get(), "class/test-asix-function", O_RDONLY));
  while (fdio_watch_directory(fd.get(), usb_virtual_bus::WaitForAnyFile, ZX_TIME_INFINITE,
                              test_function_path) != ZX_ERR_STOP) {
  }
  *test_function_path =
      fbl::String::Concat({fbl::String("class/test-asix-function/"), *test_function_path});
}

class UsbAx88179Test : public zxtest::Test {
 public:
  void SetUp() override {
    ASSERT_NO_FATAL_FAILURES(bus_.InitUsbAx88179(&dev_path_, &test_function_path_));
  }

  void TearDown() override {
    ASSERT_NO_FATAL_FAILURES(bus_.ClearPeripheralDeviceFunctions());

    auto result2 = bus_.virtual_bus().Disable();
    ASSERT_NO_FATAL_FAILURES(usb_virtual_bus::ValidateResult(result2));
  }

  void ConnectEthernetClient() {
    fbl::unique_fd fd(openat(bus_.GetRootFd(), dev_path_.c_str(), O_RDWR));
    zx::channel ethernet_handle;
    ASSERT_OK(fdio_get_service_handle(fd.release(), ethernet_handle.reset_and_get_address()));
    ethernet_client_.reset(new ethernet::Device::SyncClient(std::move(ethernet_handle)));

    // Get device information
    auto get_info_result = ethernet_client_->GetInfo();
    ASSERT_OK(get_info_result.status());
    auto info = get_info_result.Unwrap()->info;
    auto get_fifos_result = ethernet_client_->GetFifos();
    ASSERT_OK(get_fifos_result.status());
    auto fifos = get_fifos_result.Unwrap()->info.get();
    // Calculate optimal size of VMO, and set up RX and TX buffers.
    size_t optimal_vmo_size = (fifos->rx_depth * info.mtu) + (fifos->tx_depth * info.mtu);
    zx::vmo vmo;
    fzl::VmoMapper mapper;
    ASSERT_OK(mapper.CreateAndMap(optimal_vmo_size, ZX_VM_FLAG_PERM_READ | ZX_VM_FLAG_PERM_WRITE,
                                  nullptr, &vmo));
    uint8_t* io_buffer = nullptr;
    size_t io_buffer_size = 0;
    io_buffer = static_cast<uint8_t*>(mapper.start());
    io_buffer_size = optimal_vmo_size;
    auto set_io_buffer_result = ethernet_client_->SetIOBuffer(std::move(vmo));
    ASSERT_OK(set_io_buffer_result.status());

    rx_fifo_ = std::move(fifos->rx);
    tx_fifo_ = std::move(fifos->tx);
  }

  void StartDevice() {
    auto start_result = ethernet_client_->Start();
    ASSERT_OK(start_result.status());
  }

  void SetDeviceOnline() {
    fbl::unique_fd fd(openat(bus_.GetRootFd(), test_function_path_.c_str(), O_RDWR));
    zx::channel test_handle;
    ASSERT_OK(fdio_get_service_handle(fd.release(), test_handle.reset_and_get_address()));

    std::unique_ptr<ax88179::Hooks::SyncClient> test_client;
    test_client.reset(new ax88179::Hooks::SyncClient(std::move(test_handle)));

    // Ensure SIGNAL_STATUS is de-asserted before we set it.
    ASSERT_OK(ethernet_client_->GetStatus().status());

    auto online_result = test_client->SetOnline(true);
    ASSERT_OK(online_result.status());
    auto result = online_result.Unwrap()->status;
    ASSERT_OK(result);
  }

  ethernet::DeviceStatus GetDeviceStatus() {
    auto status_result = ethernet_client_->GetStatus();
    ZX_ASSERT(status_result.status() == ZX_OK);
    return status_result.Unwrap()->device_status;
  }

  void ExpectStatusOnline() {
    // Two attempts, as SIGNAL_STATUS is triggered by both ethernet.cc starting
    // up and also by our fake function driver. As we can't control the delivery
    // order, confirm that we get to online eventually.
    for (int tries = 0; tries < 2; ++tries) {
      zx_signals_t pending;
      ASSERT_OK(rx_fifo_.wait_one(ethernet::SIGNAL_STATUS, zx::time::infinite(), &pending));
      ASSERT_EQ((pending & ethernet::SIGNAL_STATUS), ethernet::SIGNAL_STATUS);
      if (GetDeviceStatus() & ethernet::DeviceStatus::ONLINE) {
        return;
      }
    }
    ADD_FATAL_FAILURE();
  }

 protected:
  USBVirtualBus bus_;
  fbl::String dev_path_;
  fbl::String test_function_path_;
  std::unique_ptr<ethernet::Device::SyncClient> ethernet_client_;
  zx::fifo rx_fifo_;
  zx::fifo tx_fifo_;
};

TEST_F(UsbAx88179Test, SetupShutdownTest) { ASSERT_NO_FATAL_FAILURES(); }

TEST_F(UsbAx88179Test, OfflineByDefault) {
  ASSERT_NO_FATAL_FAILURES(ConnectEthernetClient());

  ASSERT_NO_FATAL_FAILURES(StartDevice());

  ASSERT_FALSE(GetDeviceStatus() & ethernet::DeviceStatus::ONLINE);
}

TEST_F(UsbAx88179Test, SetOnlineAfterStart) {
  ASSERT_NO_FATAL_FAILURES(ConnectEthernetClient());

  ASSERT_NO_FATAL_FAILURES(StartDevice());

  ASSERT_NO_FATAL_FAILURES(SetDeviceOnline());

  ASSERT_NO_FATAL_FAILURES(ExpectStatusOnline());
}

// This is for https://fxbug.dev/40786#c41.
TEST_F(UsbAx88179Test, SetOnlineBeforeStart) {
  ASSERT_NO_FATAL_FAILURES(ConnectEthernetClient());

  ASSERT_NO_FATAL_FAILURES(SetDeviceOnline());

  ASSERT_NO_FATAL_FAILURES(StartDevice());

  ASSERT_NO_FATAL_FAILURES(ExpectStatusOnline());
}

}  // namespace
}  // namespace usb_ax88179