// 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 <assert.h>
#include <hwreg/bitfields.h>
#include <hwreg/mmio.h>

namespace registers {
class VdIfGenReg : public hwreg::RegisterBase<VdIfGenReg, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a50;

    DEF_BIT(31, enable_free_clock);
    DEF_BIT(30, sw_reset);
    DEF_BIT(29, reset_on_go_field);
    DEF_BIT(28, urgent_chroma);
    DEF_BIT(27, urgent_luma);
    DEF_BIT(26, chroma_end_at_last_line);
    DEF_BIT(25, luma_end_at_last_line);
    DEF_FIELD(24, 19, hold_lines);
    DEF_BIT(18, last_line);
    DEF_BIT(17, busy);
    DEF_BIT(16, demux_mode);
    DEF_FIELD(15, 14, bytes_per_pixel);
    DEF_FIELD(13, 12, ddr_burst_size_cr);
    DEF_FIELD(11, 10, ddr_burst_size_cb);
    DEF_FIELD(9, 8, ddr_burst_size_y);
    DEF_BIT(7, manual_start_frame);
    DEF_BIT(6, chro_rpt_lastl_ctrl);
    // This seems to do a 128-bit endianness conversion, which isn't very useful. The canvas should
    // be used to do the conversion instead.
    DEF_BIT(4, little_endian);
    DEF_BIT(3, chroma_hz_avg);
    DEF_BIT(2, luma_hz_avg);
    DEF_BIT(1, separate_en);
    DEF_BIT(0, enable);
};

class VdIfCanvas0 : public hwreg::RegisterBase<VdIfCanvas0, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a51;
};

class VdIfLumaX0 : public hwreg::RegisterBase<VdIfLumaX0, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a53;
    DEF_FIELD(30, 16, end);
    DEF_FIELD(14, 0, start);
};

class VdIfLumaY0 : public hwreg::RegisterBase<VdIfLumaY0, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a54;
    DEF_FIELD(28, 16, end);
    DEF_FIELD(12, 0, start);
};

class VdIfChromaX0 : public hwreg::RegisterBase<VdIfChromaX0, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a55;
    DEF_FIELD(30, 16, end);
    DEF_FIELD(14, 0, start);
};

class VdIfChromaY0 : public hwreg::RegisterBase<VdIfChromaY0, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a56;
    DEF_FIELD(28, 16, end);
    DEF_FIELD(12, 0, start);
};

class VdIfGenReg2 : public hwreg::RegisterBase<VdIfGenReg2, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a6d;

    DEF_FIELD(1, 0, color_map);
};

class VdFmtCtrl : public hwreg::RegisterBase<VdFmtCtrl, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a68;

    DEF_BIT(31, gate_clk_en);
    DEF_BIT(30, soft_rst);
    DEF_BIT(28, horizontal_repeat);
    DEF_FIELD(27, 24, horizontal_initial_phase);
    DEF_BIT(23, horizontal_repeat_pixel0);
    DEF_FIELD(22, 21, horizontal_yc_ratio);
    DEF_BIT(20, horizontal_enable);
    DEF_BIT(19, virtual_phase0_only);
    DEF_BIT(18, disable_vertical_chroma_repeat);
    DEF_BIT(17, disable_vertical_repeat_line);
    DEF_BIT(16, vertical_repeat_line0);
    DEF_FIELD(15, 12, vertical_skip_line_num);
    DEF_FIELD(11, 8, vertical_initial_phase);
    DEF_FIELD(7, 1, vertical_phase_step);
    DEF_BIT(0, vertical_enable);
};

class VdFmtW : public hwreg::RegisterBase<VdFmtW, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a69;
    DEF_FIELD(27, 16, horizontal_width);
    DEF_FIELD(11, 0, vertical_width);
};

class VdIfRptLoop : public hwreg::RegisterBase<VdIfRptLoop, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a5b;
};

class VdIfLuma0RptPat : public hwreg::RegisterBase<VdIfLuma0RptPat, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a5c;
};

class VdIfChroma0RptPat : public hwreg::RegisterBase<VdIfChroma0RptPat, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a5d;
};

class VdIfLumaPsel : public hwreg::RegisterBase<VdIfLumaPsel, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a60;
};

class VdIfChromaPsel : public hwreg::RegisterBase<VdIfChromaPsel, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a61;
};

class Vd {
public:
    // 0-based index
    Vd(uint32_t index) : index_(index) { assert(index < 2); }

    auto IfGenReg() { return GetReg<VdIfGenReg>(); }
    auto IfCanvas0() { return GetReg<VdIfCanvas0>(); }
    auto IfLumaX0() { return GetReg<VdIfLumaX0>(); }
    auto IfLumaY0() { return GetReg<VdIfLumaY0>(); }
    auto IfChromaX0() { return GetReg<VdIfChromaX0>(); }
    auto IfChromaY0() { return GetReg<VdIfChromaY0>(); }
    auto IfGenReg2() { return GetReg<VdIfGenReg2>(); }
    auto FmtCtrl() { return GetReg<VdFmtCtrl>(); }
    auto FmtW() { return GetReg<VdFmtW>(); }
    auto IfRptLoop() { return GetReg<VdIfRptLoop>(); }
    auto IfLuma0RptPat() { return GetReg<VdIfLuma0RptPat>(); }
    auto IfChroma0RptPat() { return GetReg<VdIfChroma0RptPat>(); }
    auto IfLumaPsel() { return GetReg<VdIfLumaPsel>(); }
    auto IfChromaPsel() { return GetReg<VdIfChromaPsel>(); }

private:
    template <class RegType> hwreg::RegisterAddr<RegType> GetReg() {
        return hwreg::RegisterAddr<RegType>((RegType::kBaseAddr + 0x20 * index_) * 4);
    }
    uint32_t index_;
};

class VpuVppMisc : public hwreg::RegisterBase<VpuVppMisc, uint32_t> {
public:
    static auto Get() { return hwreg::RegisterAddr<VpuVppMisc>(0x1d26 * 4); }

    DEF_BIT(13, osd2_enable_postblend);
    DEF_BIT(12, osd1_enable_postblend);
    DEF_BIT(11, vd2_enable_postblend);
    DEF_BIT(10, vd1_enable_postblend);
};

class VpuVppOsdScCtrl0 : public hwreg::RegisterBase<VpuVppOsdScCtrl0, uint32_t> {
public:
    static auto Get() { return hwreg::RegisterAddr<VpuVppOsdScCtrl0>(0x1dc8 * 4); }

    enum {
        kSelectOsd1 = 0,
        kSelectOsd2 = 1,
        kSelectVd1 = 2,
        kSelectVd2 = 3,
    };

    DEF_BIT(3, enable);
    DEF_FIELD(1, 0, osd_sc_sel);
};

class VpuVppOsdScoHStartEnd : public hwreg::RegisterBase<VpuVppOsdScoHStartEnd, uint32_t> {
public:
    static auto Get() { return hwreg::RegisterAddr<VpuVppOsdScoHStartEnd>(0x1dca * 4); }
    DEF_FIELD(27, 16, output_horizontal_start);
    DEF_FIELD(11, 0, output_horizontal_end);
};

class VpuVppOsdScoVStartEnd : public hwreg::RegisterBase<VpuVppOsdScoVStartEnd, uint32_t> {
public:
    static auto Get() { return hwreg::RegisterAddr<VpuVppOsdScoVStartEnd>(0x1dcb * 4); }
    DEF_FIELD(27, 16, output_vertial_start);
    DEF_FIELD(11, 0, output_vertical_end);
};

class VpuVppOsdSciWhM1 : public hwreg::RegisterBase<VpuVppOsdSciWhM1, uint32_t> {
public:
    static auto Get() { return hwreg::RegisterAddr<VpuVppOsdSciWhM1>(0x1dc9 * 4); }
    DEF_FIELD(28, 16, input_width_minus1);
    DEF_FIELD(12, 0, input_height_minus1);
};

class VpuVppPostblendHSize : public hwreg::RegisterBase<VpuVppPostblendHSize, uint32_t> {
public:
    static auto Get() { return hwreg::RegisterAddr<VpuVppPostblendHSize>(0x1d21 * 4); }
    DEF_FIELD(11, 0, horizontal_size);
};

class VpuViuOsdBlk0CfgW0 : public hwreg::RegisterBase<VpuViuOsdBlk0CfgW0, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a1b;

    enum {
        kColorMatrix655 = 0,
        kColorMatrix844 = 1,
        kColorMatrix565 = 2,

        kColorMatrixRGBA8888 = 0,
        kColorMatrixARGB8888 = 1,
        kColorMatrixABGR8888 = 2,
        kColorMatrixBGRA8888 = 3,

        kColorMatrixRGB888 = 0,
        kColorMatrixBGR888 = 5,
    };
    enum {
        kBlockMode422 = 3,
        kBlockMode16Bit = 4,
        kBlockMode32Bit = 5,
        kBlockMode24Bit = 7,
    };


    DEF_BIT(29, y_rev);
    DEF_BIT(28, x_rev);
    DEF_FIELD(23, 16, tbl_addr);
    DEF_BIT(15, little_endian);
    DEF_BIT(14, rpt_y);
    DEF_FIELD(13, 12, interp_ctrl);
    DEF_FIELD(11, 8, block_mode);
    DEF_BIT(7, rgb_en);
    DEF_BIT(6, tx_alpha_en);
    DEF_FIELD(5, 2, color_matrix);
    DEF_BIT(1, interlace_en);
    DEF_BIT(0, interlace_sel_odd);
};

class VpuViuOsdBlk0CfgW1 : public hwreg::RegisterBase<VpuViuOsdBlk0CfgW1, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a1c;

    DEF_FIELD(28, 16, virtual_canvas_x_end);
    DEF_FIELD(12, 0, virtual_canvas_x_start);
};

class VpuViuOsdBlk0CfgW2 : public hwreg::RegisterBase<VpuViuOsdBlk0CfgW2, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a1d;

    DEF_FIELD(28, 16, virtual_canvas_y_end);
    DEF_FIELD(12, 0, virtual_canvas_y_start);
};

class VpuViuOsdBlk0CfgW3 : public hwreg::RegisterBase<VpuViuOsdBlk0CfgW3, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a1e;

    DEF_FIELD(28, 16, display_h_end);
    DEF_FIELD(12, 0, display_h_start);
};

class VpuViuOsdBlk0CfgW4 : public hwreg::RegisterBase<VpuViuOsdBlk0CfgW4, uint32_t> {
public:
    static constexpr uint32_t kBaseAddresses[2] = {0x1a13, 0x1a64};
    DEF_FIELD(28, 16, display_v_end);
    DEF_FIELD(12, 0, display_v_start);
};

class VpuViuOsdCtrlStat2 : public hwreg::RegisterBase<VpuViuOsdCtrlStat2, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a2d;

    DEF_BIT(15, osd_dpath_sel);
    DEF_BIT(14, replaced_alpha_en);
    DEF_FIELD(13, 6, replaced_alpha);
    DEF_FIELD(5, 4, hold_fifo_lines);
    DEF_BIT(3, rgbyuv_full_range);
    DEF_BIT(2, alpha_9b_mode);
    DEF_BIT(0, color_expand_mode);
};

class VpuViuOsdCtrlStat : public hwreg::RegisterBase<VpuViuOsdCtrlStat, uint32_t> {
public:
    static constexpr uint32_t kBaseAddr = 0x1a10;

    DEF_BIT(30, enable_free_clock);
    DEF_BIT(28, osd_done);
    DEF_FIELD(27, 24, osd_blk_mode);
    DEF_FIELD(23, 22, osd_blk_ptr);
    DEF_BIT(21, osd_enable);
    DEF_FIELD(20, 12, global_alpha);
    DEF_FIELD(8, 5, ctrl_mtch_y);
    DEF_BIT(4, ctrl_422to444);
    DEF_BIT(0, osd_blk_enable);
};

class Osd {
public:
    // 0-based OSD index
    Osd(uint32_t index)
        : index_(index) { assert(index_ < 2); }

    auto CtrlStat() { return GetReg<registers::VpuViuOsdCtrlStat>(); }
    auto CtrlStat2() { return GetReg<registers::VpuViuOsdCtrlStat2>(); }

    auto Blk0CfgW0() { return GetReg<registers::VpuViuOsdBlk0CfgW0>(); }
    auto Blk0CfgW1() { return GetReg<registers::VpuViuOsdBlk0CfgW1>(); }
    auto Blk0CfgW2() { return GetReg<registers::VpuViuOsdBlk0CfgW2>(); }
    auto Blk0CfgW3() { return GetReg<registers::VpuViuOsdBlk0CfgW3>(); }
    auto Blk0CfgW4() { return GetRegNonstandard<registers::VpuViuOsdBlk0CfgW4>(); }

private:
    template <class RegType>
    hwreg::RegisterAddr<RegType> GetReg() {
        return hwreg::RegisterAddr<RegType>((RegType::kBaseAddr + 0x20 * index_) * 4);
    }

    template <class RegType>
    hwreg::RegisterAddr<RegType> GetRegNonstandard() {
        ZX_DEBUG_ASSERT(index_ < countof(RegType::kBaseAddresses));
        return hwreg::RegisterAddr<RegType>(RegType::kBaseAddresses[index_] * 4);
    }

    const uint32_t index_;
};
}  // namespace registers