// Copyright 2017 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 "platform-bus.h"

#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <ddk/binding.h>
#include <ddk/debug.h>
#include <ddk/device.h>
#include <ddk/driver.h>
#include <ddk/metadata.h>
#include <ddk/platform-defs.h>
#include <fbl/algorithm.h>
#include <fbl/auto_lock.h>
#include <fbl/unique_ptr.h>
#include <fuchsia/boot/c/fidl.h>
#include <fuchsia/sysinfo/c/fidl.h>
#include <zircon/boot/driver-config.h>
#include <zircon/process.h>
#include <zircon/syscalls/iommu.h>

#include "cpu-trace.h"
#include "platform-composite-device.h"

namespace platform_bus {

zx_status_t PlatformBus::IommuGetBti(uint32_t iommu_index, uint32_t bti_id,
                                     zx::bti* out_bti) {
    if (iommu_index != 0) {
        return ZX_ERR_OUT_OF_RANGE;
    }
    return zx::bti::create(iommu_handle_, 0, bti_id, out_bti);
}

zx_status_t PlatformBus::PBusRegisterProtocol(uint32_t proto_id, const void* protocol,
                                              size_t protocol_size) {
    if (!protocol || protocol_size < sizeof(ddk::AnyProtocol)) {
        return ZX_ERR_INVALID_ARGS;
    }

    switch (proto_id) {
    case ZX_PROTOCOL_GPIO_IMPL: {
        gpio_ = ddk::GpioImplProtocolClient(static_cast<const gpio_impl_protocol_t*>(protocol));
        break;
    }
    case ZX_PROTOCOL_CLOCK_IMPL: {
        clk_ = ddk::ClockImplProtocolClient(static_cast<const clock_impl_protocol_t*>(protocol));
        break;
    }
    case ZX_PROTOCOL_POWER_IMPL: {
        power_ = ddk::PowerImplProtocolClient(static_cast<const power_impl_protocol_t*>(protocol));
        break;
    }
    case ZX_PROTOCOL_IOMMU: {
        iommu_ = ddk::IommuProtocolClient(static_cast<const iommu_protocol_t*>(protocol));
        break;
    }
    case ZX_PROTOCOL_SYSMEM: {
        sysmem_ = ddk::SysmemProtocolClient(static_cast<const sysmem_protocol_t*>(protocol));
        break;
    }
    case ZX_PROTOCOL_AMLOGIC_CANVAS: {
        canvas_ = ddk::AmlogicCanvasProtocolClient(
                                        static_cast<const amlogic_canvas_protocol_t*>(protocol));
        break;
    }
    default:
        return ZX_ERR_NOT_SUPPORTED;
    }

    fbl::AutoLock lock(&proto_completion_mutex_);
    sync_completion_signal(&proto_completion_);
    return ZX_OK;
}

zx_status_t PlatformBus::PBusDeviceAdd(const pbus_dev_t* pdev) {
    if (!pdev->name) {
        return ZX_ERR_INVALID_ARGS;
    }

    zx_device_t* parent_dev;
    if (pdev->vid == PDEV_VID_GENERIC && pdev->pid == PDEV_PID_GENERIC &&
        pdev->did == PDEV_DID_KPCI) {
        // Add PCI root at top level.
        parent_dev = parent();
    } else {
        parent_dev = zxdev();
    }

    fbl::unique_ptr<platform_bus::PlatformDevice> dev;
    auto status = PlatformDevice::Create(pdev, parent_dev, this, &dev);
    if (status != ZX_OK) {
        return status;
    }

    status = dev->Start();
    if (status != ZX_OK) {
        return status;
    }

    // devmgr is now in charge of the device.
    __UNUSED auto* dummy = dev.release();
    return ZX_OK;
}

zx_status_t PlatformBus::PBusProtocolDeviceAdd(uint32_t proto_id, const pbus_dev_t* pdev) {
    if (!pdev->name) {
        return ZX_ERR_INVALID_ARGS;
    }

    fbl::unique_ptr<platform_bus::ProtocolDevice> dev;
    auto status = ProtocolDevice::Create(pdev, zxdev(), this, &dev);
    if (status != ZX_OK) {
        return status;
    }

    // Protocol devices run in our devhost.
    status = dev->Start();
    if (status != ZX_OK) {
        return status;
    }

    // devmgr is now in charge of the device.
    __UNUSED auto* dummy = dev.release();

    // Wait for protocol implementation driver to register its protocol.
    ddk::AnyProtocol dummy_proto;

    proto_completion_mutex_.Acquire();
    while (DdkGetProtocol(proto_id, &dummy_proto) == ZX_ERR_NOT_SUPPORTED) {
        sync_completion_reset(&proto_completion_);
        proto_completion_mutex_.Release();
        zx_status_t status = sync_completion_wait(&proto_completion_, ZX_SEC(10));
        if (status != ZX_OK) {
            zxlogf(ERROR, "%s sync_completion_wait(protocol %08x) failed: %d\n", __FUNCTION__,
                   proto_id, status);
            return status;
        }
        proto_completion_mutex_.Acquire();
    }
    proto_completion_mutex_.Release();
    return ZX_OK;
}

zx_status_t PlatformBus::PBusGetBoardInfo(pdev_board_info_t* out_info) {
    memcpy(out_info, &board_info_, sizeof(board_info_));
    return ZX_OK;
}

zx_status_t PlatformBus::PBusSetBoardInfo(const pbus_board_info_t* info) {
    board_info_.board_revision = info->board_revision;
    return ZX_OK;
}

zx_status_t PlatformBus::PBusRegisterSysSuspendCallback(const pbus_sys_suspend_t* suspend_cbin) {
    suspend_cb_ = *suspend_cbin;
    return ZX_OK;
}

zx_status_t PlatformBus::PBusCompositeDeviceAdd(const pbus_dev_t* pdev,
                                                const device_component_t* components_list,
                                                size_t components_count,
                                                uint32_t coresident_device_index) {
    if (!pdev || !pdev->name) {
        return ZX_ERR_INVALID_ARGS;
    }
    if (coresident_device_index == 0) {
        zxlogf(ERROR, "%s: coresident_device_index cannot be zero\n", __func__);
        return ZX_ERR_INVALID_ARGS;
    }

    fbl::unique_ptr<platform_bus::CompositeDevice> dev;
    auto status = CompositeDevice::Create(pdev, zxdev(), this, &dev);
    if (status != ZX_OK) {
        return status;
    }

    status = dev->Start();
    if (status != ZX_OK) {
        return status;
    }

    // devmgr is now in charge of the device.
    __UNUSED auto* dummy = dev.release();

    device_component_t components[components_count + 1];
    memcpy(&components[1], components_list, components_count * sizeof(components[1]));

    constexpr zx_bind_inst_t root_match[] = {
        BI_MATCH(),
    };
    const zx_bind_inst_t pdev_match[]  = {
        BI_ABORT_IF(NE, BIND_PROTOCOL, ZX_PROTOCOL_PDEV),
        BI_ABORT_IF(NE, BIND_PLATFORM_DEV_VID, pdev->vid),
        BI_ABORT_IF(NE, BIND_PLATFORM_DEV_PID, pdev->pid),
        BI_MATCH_IF(EQ, BIND_PLATFORM_DEV_DID, pdev->did),
    };
    const device_component_part_t pdev_component[] = {
        { countof(root_match), root_match },
        { countof(pdev_match), pdev_match },
    };

    components[0].parts_count = fbl::count_of(pdev_component);
    components[0].parts = pdev_component;

    const zx_device_prop_t props[] = {
        { BIND_PLATFORM_DEV_VID, 0, pdev->vid },
        { BIND_PLATFORM_DEV_PID, 0, pdev->pid },
        { BIND_PLATFORM_DEV_DID, 0, pdev->did },
    };

    return DdkAddComposite(pdev->name, props, fbl::count_of(props), components,
                           components_count + 1, coresident_device_index);
}

zx_status_t PlatformBus::DdkGetProtocol(uint32_t proto_id, void* out) {
    switch (proto_id) {
    case ZX_PROTOCOL_PBUS: {
        auto proto = static_cast<pbus_protocol_t*>(out);
        proto->ctx = this;
        proto->ops = &pbus_protocol_ops_;
        return ZX_OK;
    }
    case ZX_PROTOCOL_GPIO_IMPL:
        if (gpio_) {
            gpio_->GetProto(static_cast<gpio_impl_protocol_t*>(out));
            return ZX_OK;
        }
        break;
    case ZX_PROTOCOL_POWER_IMPL:
        if (power_) {
            power_->GetProto(static_cast<power_impl_protocol_t*>(out));
            return ZX_OK;
        }
        break;
    case ZX_PROTOCOL_CLOCK_IMPL:
        if (clk_) {
            clk_->GetProto(static_cast<clock_impl_protocol_t*>(out));
            return ZX_OK;
        }
        break;
    case ZX_PROTOCOL_SYSMEM:
        if (sysmem_) {
            sysmem_->GetProto(static_cast<sysmem_protocol_t*>(out));
            return ZX_OK;
        }
        break;
    case ZX_PROTOCOL_AMLOGIC_CANVAS:
        if (canvas_) {
            canvas_->GetProto(static_cast<amlogic_canvas_protocol_t*>(out));
            return ZX_OK;
        }
        break;
    case ZX_PROTOCOL_IOMMU:
        if (iommu_) {
            iommu_->GetProto(static_cast<iommu_protocol_t*>(out));
        } else {
            // return default implementation
            auto proto = static_cast<iommu_protocol_t*>(out);
            proto->ctx = this;
            proto->ops = &iommu_protocol_ops_;
            return ZX_OK;
        }
        break;
    }

    return ZX_ERR_NOT_SUPPORTED;
}

zx_status_t PlatformBus::GetBootItem(uint32_t type, uint32_t extra, zx::vmo* vmo,
                                     uint32_t* length) {
    return fuchsia_boot_ItemsGet(items_svc_.get(), type, extra, vmo->reset_and_get_address(),
                                 length);
}

zx_status_t PlatformBus::GetBootItem(uint32_t type, uint32_t extra, fbl::Array<uint8_t>* out) {
    zx::vmo vmo;
    uint32_t length;
    zx_status_t status = GetBootItem(type, extra, &vmo, &length);
    if (status != ZX_OK) {
        return status;
    }
    if (vmo.is_valid()) {
        fbl::Array<uint8_t> data(new uint8_t[length], length);
        status = vmo.read(data.get(), 0, data.size());
        if (status != ZX_OK) {
            return status;
        }
        *out = std::move(data);
    }
    return ZX_OK;
}

void PlatformBus::DdkRelease() {
    delete this;
}

typedef struct {
    void* pbus_instance;
} sysdev_suspend_t;

static zx_status_t sys_device_suspend(void* ctx, uint32_t flags) {
    auto* p = reinterpret_cast<sysdev_suspend_t*>(ctx);
    auto* pbus = reinterpret_cast<class PlatformBus*>(p->pbus_instance);

    if (pbus != nullptr) {
        pbus_sys_suspend_t suspend_cb = pbus->suspend_cb();
        if (suspend_cb.callback != nullptr) {
            return suspend_cb.callback(suspend_cb.ctx, flags);
        }
    }
    return ZX_ERR_NOT_SUPPORTED;
}

static void sys_device_release(void* ctx) {
    auto* p = reinterpret_cast<sysdev_suspend_t*>(ctx);
    delete p;
}

// cpu-trace provides access to the cpu's tracing and performance counters.
// As such the "device" is the cpu itself.
static zx_status_t InitCpuTrace(zx_device_t* parent, zx_handle_t dummy_iommu_handle) {
    zx_handle_t cpu_trace_bti;
    zx_status_t status = zx_bti_create(dummy_iommu_handle, 0, CPU_TRACE_BTI_ID, &cpu_trace_bti);
    if (status != ZX_OK) {
        zxlogf(ERROR, "platform-bus: error %d in bti_create(cpu_trace_bti)\n", status);
        return status;
    }

    status = publish_cpu_trace(cpu_trace_bti, parent);
    if (status != ZX_OK) {
        // This is not fatal.
        zxlogf(INFO, "publish_cpu_trace returned %d\n", status);
    }
    return status;
}

static zx_protocol_device_t sys_device_proto = []() {
    zx_protocol_device_t result;

    result.version = DEVICE_OPS_VERSION;
    result.suspend = sys_device_suspend;
    result.release = sys_device_release;
    return result;
}();

zx_status_t PlatformBus::Create(zx_device_t* parent, const char* name, zx::channel items_svc) {
    // This creates the "sys" device.
    sys_device_proto.version = DEVICE_OPS_VERSION;

    // The suspend op needs to get access to the PBus instance, to be able to
    // callback the ACPI suspend hook. Introducing a level of indirection here
    // to allow us to update the PBus instance in the device context after creating
    // the device.
    fbl::AllocChecker ac;
    fbl::unique_ptr<uint8_t[]> ptr(new (&ac) uint8_t[sizeof(sysdev_suspend_t)]);
    if (!ac.check()) {
        return ZX_ERR_NO_MEMORY;
    }
    auto* suspend_buf = reinterpret_cast<sysdev_suspend_t*>(ptr.get());
    suspend_buf->pbus_instance = nullptr;

    device_add_args_t args = {};
    args.version = DEVICE_ADD_ARGS_VERSION;
    args.name = "sys";
    args.ops = &sys_device_proto;
    args.flags = DEVICE_ADD_NON_BINDABLE;
    args.ctx = suspend_buf;

    // Create /dev/sys.
    zx_device_t* sys_root;
    auto status = device_add(parent, &args, &sys_root);
    if (status != ZX_OK) {
        return status;
    } else {
        __UNUSED auto* dummy = ptr.release();
    }

    // Add child of sys for the board driver to bind to.
    fbl::unique_ptr<platform_bus::PlatformBus> bus(
        new (&ac) platform_bus::PlatformBus(sys_root, std::move(items_svc)));
    if (!ac.check()) {
        return ZX_ERR_NO_MEMORY;
    }
    suspend_buf->pbus_instance = bus.get();

    status = bus->Init();
    if (status != ZX_OK) {
        return status;
    }

    // Create /dev/sys/cpu-trace.
    // But only do so if we have an iommu handle. Normally we do, but tests
    // may create us without a root resource, and thus without the iommu
    // handle.
    if (bus->iommu_handle_.is_valid()) {
        status = InitCpuTrace(sys_root, bus->iommu_handle_.get());
        if (status != ZX_OK) {
            // This is not fatal. Error message already printed.
        }
    }

    // devmgr is now in charge of the device.
    __UNUSED auto* dummy = bus.release();
    return ZX_OK;
}

PlatformBus::PlatformBus(zx_device_t* parent, zx::channel items_svc)
    : PlatformBusType(parent), items_svc_(std::move(items_svc)) {
    sync_completion_reset(&proto_completion_);
}

zx_status_t PlatformBus::Init() {
    zx_status_t status;
    // Set up a dummy IOMMU protocol to use in the case where our board driver
    // does not set a real one.
    zx_iommu_desc_dummy_t desc;
    // Please do not use get_root_resource() in new code. See ZX-1467.
    zx::unowned_resource root_resource(get_root_resource());
    if (root_resource->is_valid()) {
        status = zx::iommu::create(*root_resource, ZX_IOMMU_TYPE_DUMMY, &desc, sizeof(desc),
                                   &iommu_handle_);
        if (status != ZX_OK) {
            return status;
        }
    }

    // Read kernel driver.
    zx::vmo vmo;
    uint32_t length;
    uint8_t interrupt_controller_type = fuchsia_sysinfo_InterruptControllerType_UNKNOWN;
#if __x86_64__
    interrupt_controller_type = fuchsia_sysinfo_InterruptControllerType_APIC;
#else
    status = GetBootItem(ZBI_TYPE_KERNEL_DRIVER, KDRV_ARM_GIC_V2, &vmo, &length);
    if (status != ZX_OK) {
        return status;
    }
    if (vmo.is_valid()) {
        interrupt_controller_type = fuchsia_sysinfo_InterruptControllerType_GIC_V2;
    }
    status = GetBootItem(ZBI_TYPE_KERNEL_DRIVER, KDRV_ARM_GIC_V3, &vmo, &length);
    if (status != ZX_OK) {
        return status;
    }
    if (vmo.is_valid()) {
        interrupt_controller_type = fuchsia_sysinfo_InterruptControllerType_GIC_V3;
    }
#endif
    // Publish interrupt controller type to sysinfo driver
    status = device_publish_metadata(
        parent(), "/dev/misc/sysinfo", DEVICE_METADATA_INTERRUPT_CONTROLLER_TYPE,
        &interrupt_controller_type, sizeof(interrupt_controller_type));
    if (status != ZX_OK) {
        zxlogf(ERROR, "device_publish_metadata(interrupt_controller_type) failed: %d\n", status);
        return status;
    }

    // Read platform ID.
    status = GetBootItem(ZBI_TYPE_PLATFORM_ID, 0, &vmo, &length);
    if (status != ZX_OK) {
        return status;
    }
    if (vmo.is_valid()) {
        zbi_platform_id_t platform_id;
        status = vmo.read(&platform_id, 0, sizeof(platform_id));
        if (status != ZX_OK) {
            return status;
        }
        zxlogf(INFO, "platform bus: VID: %u PID: %u board: \"%s\"\n", platform_id.vid,
               platform_id.pid, platform_id.board_name);
        board_info_.vid = platform_id.vid;
        board_info_.pid = platform_id.pid;
        memcpy(board_info_.board_name, platform_id.board_name, sizeof(board_info_.board_name));
        // Publish board name to sysinfo driver
        status = device_publish_metadata(parent(), "/dev/misc/sysinfo", DEVICE_METADATA_BOARD_NAME,
                                         platform_id.board_name, sizeof(platform_id.board_name));
        if (status != ZX_OK) {
            zxlogf(ERROR, "device_publish_metadata(board_name) failed: %d\n", status);
            return status;
        }
    } else {
#if __x86_64__
        // For x86_64, we might not find the ZBI_TYPE_PLATFORM_ID, old bootloaders
        // won't support this, for example. If this is the case, cons up the VID/PID here
        // to allow the acpi board driver to load and bind.
        board_info_.vid = PDEV_VID_INTEL;
        board_info_.pid = PDEV_PID_X86;
        strncpy(board_info_.board_name, "x86_64", sizeof(board_info_.board_name));
        // Publish board name to sysinfo driver
        status = device_publish_metadata(parent(), "/dev/misc/sysinfo", DEVICE_METADATA_BOARD_NAME,
                                         "x86_64", sizeof("x86_64"));
        if (status != ZX_OK) {
            zxlogf(ERROR, "device_publish_metadata(board_name) failed: %d\n", status);
            return status;
        }
#else
        zxlogf(ERROR, "platform_bus: ZBI_TYPE_PLATFORM_ID not found\n");
        return ZX_ERR_INTERNAL;
#endif
    }
    // This is optionally set later by the board driver.
    board_info_.board_revision = 0;

    // Then we attach the platform-bus device below it.
    zx_device_prop_t props[] = {
        {BIND_PLATFORM_DEV_VID, 0, board_info_.vid},
        {BIND_PLATFORM_DEV_PID, 0, board_info_.pid},
    };
    status = DdkAdd("platform", DEVICE_ADD_INVISIBLE, props, fbl::count_of(props));
    if (status != ZX_OK) {
        return status;
    }
    fbl::Array<uint8_t> board_data;
    status = GetBootItem(ZBI_TYPE_DRV_BOARD_PRIVATE, 0, &board_data);
    if (status != ZX_OK) {
        return status;
    }
    if (board_data) {
        status = DdkAddMetadata(DEVICE_METADATA_BOARD_PRIVATE, board_data.get(), board_data.size());
        if (status != ZX_OK) {
            return status;
        }
    }
    DdkMakeVisible();
    return ZX_OK;
}

zx_status_t platform_bus_create(void* ctx, zx_device_t* parent, const char* name,
                                const char* args, zx_handle_t handle) {
    return platform_bus::PlatformBus::Create(parent, name, zx::channel(handle));
}

static zx_driver_ops_t driver_ops = []() {
    zx_driver_ops_t ops;
    ops.version = DRIVER_OPS_VERSION;
    ops.create = platform_bus_create;
    return ops;
}();

} // namespace platform_bus

ZIRCON_DRIVER_BEGIN(platform_bus, platform_bus::driver_ops, "zircon", "0.1", 1)
    // devmgr loads us directly, so we need no binding information here
    BI_ABORT_IF_AUTOBIND,
ZIRCON_DRIVER_END(platform_bus)