platform-proxy-device.h

// Copyright 2018 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.

#pragma once

#include "platform-proxy-device.h"

#include <ddktl/device.h>
#include <ddktl/protocol/clk.h>
#include <ddktl/protocol/gpio.h>
#include <ddktl/protocol/i2c.h>
#include <ddktl/protocol/platform/device.h>
#include <fbl/ref_ptr.h>
#include <fbl/unique_ptr.h>
#include <fbl/vector.h>
#include <lib/zx/channel.h>
#include <lib/zx/handle.h>

#include "proxy-protocol.h"

namespace platform_bus {

class PlatformProxy;

class ProxyGpio : public ddk::GpioProtocol<ProxyGpio> {
public:
    explicit ProxyGpio(uint32_t device_id, uint32_t index, fbl::RefPtr<PlatformProxy> proxy)
        : device_id_(device_id), index_(index), proxy_(proxy) {}

    // GPIO protocol implementation.
    zx_status_t GpioConfigIn(uint32_t flags);
    zx_status_t GpioConfigOut(uint8_t initial_value);
    zx_status_t GpioSetAltFunction(uint64_t function);
    zx_status_t GpioRead(uint8_t* out_value);
    zx_status_t GpioWrite(uint8_t value);
    zx_status_t GpioGetInterrupt(uint32_t flags, zx::interrupt* out_irq);
    zx_status_t GpioReleaseInterrupt();
    zx_status_t GpioSetPolarity(uint32_t polarity);

    void GetProtocol(gpio_protocol_t* proto) {
        proto->ops = &gpio_protocol_ops_;
        proto->ctx = this;
    }

private:
    uint32_t device_id_;
    uint32_t index_;
    fbl::RefPtr<PlatformProxy> proxy_;
};

class ProxyI2c : public ddk::I2cProtocol<ProxyI2c> {
public:
    explicit ProxyI2c(uint32_t device_id, uint32_t index, fbl::RefPtr<PlatformProxy> proxy)
        : device_id_(device_id), index_(index), proxy_(proxy) {}

    // I2C protocol implementation.
    void I2cTransact(const i2c_op_t* ops, size_t cnt, i2c_transact_callback transact_cb,
                     void* cookie);
    zx_status_t I2cGetMaxTransferSize(size_t* out_size);
    zx_status_t I2cGetInterrupt(uint32_t flags, zx::interrupt* out_irq);

    void GetProtocol(i2c_protocol_t* proto) {
        proto->ops = &i2c_protocol_ops_;
        proto->ctx = this;
    }

private:
    uint32_t device_id_;
    uint32_t index_;
    fbl::RefPtr<PlatformProxy> proxy_;
};

class ProxyClk : public ddk::ClkProtocol<ProxyClk> {
public:
    explicit ProxyClk(uint32_t device_id, fbl::RefPtr<PlatformProxy> proxy)
        : device_id_(device_id), proxy_(proxy) {}

    // Clock protocol implementation.
    zx_status_t ClkEnable(uint32_t index);
    zx_status_t ClkDisable(uint32_t index);

    void GetProtocol(clk_protocol_t* proto) {
        proto->ops = &clk_protocol_ops_;
        proto->ctx = this;
    }

private:
    uint32_t device_id_;
    fbl::RefPtr<PlatformProxy> proxy_;
};

class ProxyDevice;
using ProxyDeviceType = ddk::FullDevice<ProxyDevice>;

class ProxyDevice : public ProxyDeviceType,
                    public ddk::PDevProtocol<ProxyDevice, ddk::base_protocol> {
public:
    explicit ProxyDevice(zx_device_t* parent, uint32_t device_id, fbl::RefPtr<PlatformProxy> proxy)
        : ProxyDeviceType(parent), device_id_(device_id), proxy_(proxy), clk_(device_id, proxy) {}

    // Creates a ProxyDevice to be the root platform device.
    static zx_status_t CreateRoot(zx_device_t* parent, fbl::RefPtr<PlatformProxy> proxy);

    // Creates a ProxyDevice to be a child platform device or a proxy client device.
    static zx_status_t CreateChild(zx_device_t* parent, uint32_t device_id,
                                   fbl::RefPtr<PlatformProxy> proxy, const device_add_args_t* args,
                                   zx_device_t** device);

    // Full device protocol implementation.
    // For child devices, these call through to the device protocol passed via pdev_device_add().
    zx_status_t DdkGetProtocol(uint32_t proto_id, void* out);
    zx_status_t DdkOpen(zx_device_t** dev_out, uint32_t flags);
    zx_status_t DdkOpenAt(zx_device_t** dev_out, const char* path, uint32_t flags);
    zx_status_t DdkClose(uint32_t flags);
    void DdkUnbind();
    void DdkRelease();
    zx_status_t DdkRead(void* buf, size_t count, zx_off_t off, size_t* actual);
    zx_status_t DdkWrite(const void* buf, size_t count, zx_off_t off, size_t* actual);
    zx_off_t DdkGetSize();
    zx_status_t DdkIoctl(uint32_t op, const void* in_buf, size_t in_len, void* out_buf,
                         size_t out_len, size_t* actual);
    zx_status_t DdkSuspend(uint32_t flags);
    zx_status_t DdkResume(uint32_t flags);
    zx_status_t DdkRxrpc(zx_handle_t channel);

    // Platform device protocol implementation.
    zx_status_t PDevGetMmio(uint32_t index, pdev_mmio_t* out_mmio);
    zx_status_t PDevGetInterrupt(uint32_t index, uint32_t flags, zx::interrupt* out_irq);
    zx_status_t PDevGetBti(uint32_t index, zx::bti* out_bti);
    zx_status_t PDevGetSmc(uint32_t index, zx::resource* out_resource);
    zx_status_t PDevGetDeviceInfo(pdev_device_info_t* out_info);
    zx_status_t PDevGetBoardInfo(pdev_board_info_t* out_info);
    zx_status_t PDevDeviceAdd(uint32_t index, const device_add_args_t* args, zx_device_t** device);
    zx_status_t PDevGetProtocol(uint32_t proto_id, uint32_t index, void* out_protocol,
                                size_t protocol_size, size_t* protocol_actual);

private:
    struct Mmio {
        zx_paddr_t base;
        size_t length;
        zx::resource resource;
    };
    struct Irq {
        uint32_t irq;
        // ZX_INTERRUPT_MODE_* flags
        uint32_t mode;
        zx::resource resource;
    };

    zx_status_t InitCommon();
    zx_status_t InitRoot();
    zx_status_t InitChild(const device_add_args_t* args, zx_device_t** device);

    DISALLOW_COPY_ASSIGN_AND_MOVE(ProxyDevice);

    const uint32_t device_id_;
    fbl::RefPtr<PlatformProxy> proxy_;
    fbl::Vector<Mmio> mmios_;
    fbl::Vector<Irq> irqs_;
    fbl::Vector<ProxyGpio> gpios_;
    fbl::Vector<ProxyI2c> i2cs_;
    ProxyClk clk_;

    char name_[ZX_MAX_NAME_LEN];
    uint32_t metadata_count_;

    // These fields are saved values from the device_add_args_t passed to pdev_device_add().
    // These are unused for top level devices created via pbus_device_add().
    void* ctx_ = nullptr;
    zx_protocol_device_t* device_ops_ = nullptr;
    uint32_t proto_id_ = 0;
    void* proto_ops_ = nullptr;
};

} // namespace platform_bus