src/devices/bus/lib/device-protocol-pdev/pdev-fidl.cc

// Copyright 2023 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 <lib/ddk/debug.h>
#include <lib/device-protocol/pdev-fidl.h>
#include <lib/mmio/mmio.h>

#include <ddktl/device.h>

namespace ddk {

PDevFidl::PDevFidl(zx_device_t* parent) {
  zx::result client =
      ddk::Device<void>::DdkConnectFidlProtocol<fuchsia_hardware_platform_device::Service::Device>(
          parent);
  if (client.is_error()) {
    return;
  }
  pdev_ = fidl::WireSyncClient(std::move(client.value()));
}

PDevFidl::PDevFidl(zx_device_t* parent, const char* fragment_name) {
  zx::result client = ddk::Device<void>::DdkConnectFragmentFidlProtocol<
      fuchsia_hardware_platform_device::Service::Device>(parent, fragment_name);
  if (client.is_error()) {
    return;
  }
  pdev_ = fidl::WireSyncClient(std::move(client.value()));
}

PDevFidl::PDevFidl(fidl::ClientEnd<fuchsia_hardware_platform_device::Device> client)
    : pdev_(std::move(client)) {}

zx::result<PDevFidl> PDevFidl::Create(zx_device_t* parent) {
  zx::result client =
      ddk::Device<void>::DdkConnectFidlProtocol<fuchsia_hardware_platform_device::Service::Device>(
          parent);
  if (client.is_error()) {
    return client.take_error();
  }
  return zx::ok(PDevFidl(std::move(client.value())));
}

zx::result<PDevFidl> PDevFidl::Create(zx_device_t* parent, const char* fragment_name) {
  zx::result client = ddk::Device<void>::DdkConnectFragmentFidlProtocol<
      fuchsia_hardware_platform_device::Service::Device>(parent, fragment_name);
  if (client.is_error()) {
    return client.take_error();
  }
  return zx::ok(PDevFidl(std::move(client.value())));
}

PDevFidl PDevFidl::FromFragment(zx_device_t* parent) { return PDevFidl(parent, kFragmentName); }

zx_status_t PDevFidl::FromFragment(zx_device_t* parent, PDevFidl* out) {
  *out = PDevFidl(parent, kFragmentName);
  if (!out->is_valid()) {
    return ZX_ERR_NO_RESOURCES;
  }
  return ZX_OK;
}

void PDevFidl::ShowInfo() {
  pdev_device_info_t info;
  if (GetDeviceInfo(&info) == ZX_OK) {
    zxlogf(INFO, "VID:PID:DID         = %04x:%04x:%04x", info.vid, info.pid, info.did);
    zxlogf(INFO, "mmio count          = %d", info.mmio_count);
    zxlogf(INFO, "irq count           = %d", info.irq_count);
    zxlogf(INFO, "bti count           = %d", info.bti_count);
  }
}

zx_status_t PDevFidl::MapMmio(uint32_t index, std::optional<fdf::MmioBuffer>* mmio,
                              uint32_t cache_policy) {
  pdev_mmio_t pdev_mmio = {};

  zx_status_t status = GetMmio(index, &pdev_mmio);
  if (status != ZX_OK) {
    return status;
  }
  return PDevMakeMmioBufferWeak(pdev_mmio, mmio, cache_policy);
}

zx_status_t PDevFidl::GetMmio(uint32_t index, pdev_mmio_t* out_mmio) const {
  fidl::WireResult result = pdev_->GetMmioById(index);
  if (result.status() != ZX_OK) {
    return result.status();
  }
  if (!result->is_ok()) {
    return result->error_value();
  }
  if (result->value()->has_offset()) {
    out_mmio->offset = result->value()->offset();
  }
  if (result->value()->has_size()) {
    out_mmio->size = result->value()->size();
  }
  if (result->value()->has_vmo()) {
    out_mmio->vmo = result->value()->vmo().release();
  }
  return ZX_OK;
}

zx_status_t PDevFidl::GetInterrupt(uint32_t index, uint32_t flags, zx::interrupt* out_irq) {
  fidl::WireResult result = pdev_->GetInterruptById(index, flags);
  if (result.status() != ZX_OK) {
    return result.status();
  }
  if (!result->is_ok()) {
    return result->error_value();
  }
  *out_irq = std::move(result->value()->irq);
  return ZX_OK;
}

zx_status_t PDevFidl::GetBti(uint32_t index, zx::bti* out_bti) {
  fidl::WireResult result = pdev_->GetBtiById(index);
  if (result.status() != ZX_OK) {
    return result.status();
  }
  if (!result->is_ok()) {
    return result->error_value();
  }
  *out_bti = std::move(result->value()->bti);
  return ZX_OK;
}

zx_status_t PDevFidl::GetSmc(uint32_t index, zx::resource* out_smc) const {
  fidl::WireResult result = pdev_->GetSmcById(index);
  if (result.status() != ZX_OK) {
    return result.status();
  }
  if (!result->is_ok()) {
    return result->error_value();
  }
  *out_smc = std::move(result->value()->smc);
  return ZX_OK;
}

zx_status_t PDevFidl::GetDeviceInfo(pdev_device_info_t* out_info) {
  fidl::WireResult result = pdev_->GetNodeDeviceInfo();
  if (result.status() != ZX_OK) {
    return result.status();
  }
  if (!result->is_ok()) {
    return result->error_value();
  }

  if (result->value()->has_vid()) {
    out_info->vid = result->value()->vid();
  }
  if (result->value()->has_pid()) {
    out_info->pid = result->value()->pid();
  }
  if (result->value()->has_did()) {
    out_info->did = result->value()->did();
  }
  if (result->value()->has_mmio_count()) {
    out_info->mmio_count = result->value()->mmio_count();
  }
  if (result->value()->has_irq_count()) {
    out_info->irq_count = result->value()->irq_count();
  }
  if (result->value()->has_bti_count()) {
    out_info->bti_count = result->value()->bti_count();
  }
  if (result->value()->has_smc_count()) {
    out_info->smc_count = result->value()->smc_count();
  }
  if (result->value()->has_metadata_count()) {
    out_info->metadata_count = result->value()->metadata_count();
  }
  if (result->value()->has_name()) {
    std::string name = std::string(result->value()->name().get());
    if (name.size() > sizeof(out_info->name)) {
      return ZX_ERR_BUFFER_TOO_SMALL;
    }
    strncpy(out_info->name, name.c_str(), sizeof(out_info->name));
  }

  return ZX_OK;
}

zx_status_t PDevFidl::GetBoardInfo(pdev_board_info_t* out_info) const {
  fidl::WireResult result = pdev_->GetBoardInfo();
  if (result.status() != ZX_OK) {
    return result.status();
  }
  if (!result->is_ok()) {
    return result->error_value();
  }

  if (result->value()->has_vid()) {
    out_info->vid = result->value()->vid();
  }
  if (result->value()->has_pid()) {
    out_info->pid = result->value()->pid();
  }
  if (result->value()->has_board_name()) {
    std::string board_name = std::string(result->value()->board_name().get());
    if (board_name.size() > sizeof(out_info->board_name)) {
      return ZX_ERR_BUFFER_TOO_SMALL;
    }
    strncpy(out_info->board_name, board_name.c_str(), sizeof(out_info->board_name));
  }
  if (result->value()->has_board_revision()) {
    out_info->board_revision = result->value()->board_revision();
  }
  return ZX_OK;
}

}  // namespace ddk