zircon/system/dev/display/mt8167s-display/dither.cpp

// Copyright 2019 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 "dither.h"
#include <fbl/alloc_checker.h>

namespace mt8167s_display {

namespace {
constexpr uint32_t kDitherReg0Default = 0x00000001;
constexpr uint32_t kDitherReg5Default = 0x00000000;
constexpr uint32_t kDitherReg6Default = 0x00003004;
constexpr uint32_t kDitherReg7Default = 0x00000000;
constexpr uint32_t kDitherReg8Default = 0x00000000;
constexpr uint32_t kDitherReg9Default = 0x00000000;
constexpr uint32_t kDitherReg10Default = 0x00000000;
constexpr uint32_t kDitherReg11Default = 0x00000000;
constexpr uint32_t kDitherReg12Default = 0x00000011;
constexpr uint32_t kDitherReg13Default = 0x00000000;
constexpr uint32_t kDitherReg14Default = 0x00000000;
constexpr uint32_t kDitherReg15Default = 0x20200001;
constexpr uint32_t kDitherReg16Default = 0x20202020;
} // namespace

zx_status_t Dither::Init(zx_device_t* parent) {
    if (initialized_) {
        return ZX_OK;
    }

    zx_status_t status = device_get_protocol(parent, ZX_PROTOCOL_PDEV, &pdev_);
    if (status != ZX_OK) {
        return status;
    }

    // Map Sys Config MMIO
    mmio_buffer_t mmio;
    status = pdev_map_mmio_buffer(&pdev_, MMIO_DISP_DITHER, ZX_CACHE_POLICY_UNCACHED_DEVICE,
                                  &mmio);
    if (status != ZX_OK) {
        DISP_ERROR("Could not map DITHER mmio\n");
        return status;
    }
    fbl::AllocChecker ac;
    dither_mmio_ = fbl::make_unique_checked<ddk::MmioBuffer>(&ac, mmio);
    if (!ac.check()) {
        DISP_ERROR("Could not map DITHER mmio\n");
        return ZX_ERR_NO_MEMORY;
    }

    // DITHER is ready to be used
    initialized_ = true;
    return ZX_OK;
}
zx_status_t Dither::Config() {
    ZX_DEBUG_ASSERT(initialized_);

    DitherDReg::Get(5).FromValue(kDitherReg5Default).WriteTo(&(*dither_mmio_));
    DitherDReg::Get(6).FromValue(kDitherReg6Default).WriteTo(&(*dither_mmio_));
    DitherDReg::Get(7).FromValue(kDitherReg7Default).WriteTo(&(*dither_mmio_));
    DitherDReg::Get(8).FromValue(kDitherReg8Default).WriteTo(&(*dither_mmio_));
    DitherDReg::Get(9).FromValue(kDitherReg9Default).WriteTo(&(*dither_mmio_));
    DitherDReg::Get(10).FromValue(kDitherReg10Default).WriteTo(&(*dither_mmio_));
    DitherDReg::Get(11).FromValue(kDitherReg11Default).WriteTo(&(*dither_mmio_));
    DitherDReg::Get(12).FromValue(kDitherReg12Default).WriteTo(&(*dither_mmio_));
    DitherDReg::Get(13).FromValue(kDitherReg13Default).WriteTo(&(*dither_mmio_));
    DitherDReg::Get(14).FromValue(kDitherReg14Default).WriteTo(&(*dither_mmio_));
    DitherDReg::Get(15).FromValue(kDitherReg15Default).WriteTo(&(*dither_mmio_));
    DitherDReg::Get(16).FromValue(kDitherReg16Default).WriteTo(&(*dither_mmio_));
    DitherDReg::Get(0).FromValue(kDitherReg0Default).WriteTo(&(*dither_mmio_));

    // Set to bypass mode
    DitherEnReg::Get()
        .ReadFrom(&(*dither_mmio_))
        .set_enable(1)
        .WriteTo(&(*dither_mmio_));
    DitherSizeReg::Get()
        .ReadFrom(&(*dither_mmio_))
        .set_vsize(height_)
        .set_hsize(width_)
        .WriteTo(&(*dither_mmio_));
    DitherCfgReg::Get()
        .ReadFrom(&(*dither_mmio_))
        .set_dither_engine_en(1)
        .set_relay(1)
        .WriteTo(&(*dither_mmio_));
    return ZX_OK;
}

void Dither::PrintRegisters() {
    ZX_DEBUG_ASSERT(initialized_);
    zxlogf(INFO, "Dumping Dither Registers\n");
    zxlogf(INFO, "######################\n\n");
    zxlogf(INFO, "DITHER_EN = 0x%x\n", dither_mmio_->Read32(DITHER_EN));
    zxlogf(INFO, "DITHER_CFG = 0x%x\n", dither_mmio_->Read32(DITHER_CFG));
    zxlogf(INFO, "DITHER_SIZE = 0x%x\n", dither_mmio_->Read32(DITHER_SIZE));
    zxlogf(INFO, "DISP_REG_DITHER_0 = 0x%x\n", dither_mmio_->Read32(DISP_REG_DITHER(0)));
    zxlogf(INFO, "DISP_REG_DITHER_5 = 0x%x\n", dither_mmio_->Read32(DISP_REG_DITHER(5)));
    zxlogf(INFO, "DISP_REG_DITHER_6 = 0x%x\n", dither_mmio_->Read32(DISP_REG_DITHER(6)));
    zxlogf(INFO, "DISP_REG_DITHER_7 = 0x%x\n", dither_mmio_->Read32(DISP_REG_DITHER(7)));
    zxlogf(INFO, "DISP_REG_DITHER_8 = 0x%x\n", dither_mmio_->Read32(DISP_REG_DITHER(8)));
    zxlogf(INFO, "DISP_REG_DITHER_9 = 0x%x\n", dither_mmio_->Read32(DISP_REG_DITHER(9)));
    zxlogf(INFO, "DISP_REG_DITHER_10 = 0x%x\n", dither_mmio_->Read32(DISP_REG_DITHER(10)));
    zxlogf(INFO, "DISP_REG_DITHER_11 = 0x%x\n", dither_mmio_->Read32(DISP_REG_DITHER(11)));
    zxlogf(INFO, "DISP_REG_DITHER_12 = 0x%x\n", dither_mmio_->Read32(DISP_REG_DITHER(12)));
    zxlogf(INFO, "DISP_REG_DITHER_13 = 0x%x\n", dither_mmio_->Read32(DISP_REG_DITHER(13)));
    zxlogf(INFO, "DISP_REG_DITHER_14 = 0x%x\n", dither_mmio_->Read32(DISP_REG_DITHER(14)));
    zxlogf(INFO, "DISP_REG_DITHER_15 = 0x%x\n", dither_mmio_->Read32(DISP_REG_DITHER(15)));
    zxlogf(INFO, "DISP_REG_DITHER_16 = 0x%x\n", dither_mmio_->Read32(DISP_REG_DITHER(16)));
    zxlogf(INFO, "DISP_REG_DITHER_17 = 0x%x\n", dither_mmio_->Read32(DISP_REG_DITHER(17)));
    zxlogf(INFO, "######################\n\n");
}

} // namespace mt8167s_display