/*
 * Copyright@ Samsung Electronics Co. LTD
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

//#define LOG_NDEBUG 0
//#define LOG_TAG "libhdmi"
#include <cutils/log.h>

#if defined(BOARD_USE_V4L2_ION)
#include "ion.h"
#endif

#include "SecHdmi.h"
#include "SecHdmiV4L2Utils.h"

#define CHECK_GRAPHIC_LAYER_TIME (0)

namespace android {

extern unsigned int output_type;
#if defined(BOARD_USE_V4L2)
extern unsigned int g_preset_id;
#endif
extern v4l2_std_id t_std_id;
extern int g_hpd_state;
extern unsigned int g_hdcp_en;

#if !defined(BOARD_USE_V4L2)
extern int fp_tvout;
extern int fp_tvout_v;
extern int fp_tvout_g0;
extern int fp_tvout_g1;
#endif

#if defined(BOARD_USES_FIMGAPI)
extern unsigned int g2d_reserved_memory[HDMI_G2D_OUTPUT_BUF_NUM];
extern unsigned int g2d_reserved_memory_size;
extern unsigned int cur_g2d_address;
extern unsigned int g2d_buf_index;
#endif

#if defined(BOARD_USES_CEC)
SecHdmi::CECThread::~CECThread()
{
#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("%s", __func__);
#endif
    mFlagRunning = false;
}

bool SecHdmi::CECThread::threadLoop()
{
    unsigned char buffer[CEC_MAX_FRAME_SIZE];
    int size;
    unsigned char lsrc, ldst, opcode;

    {
        Mutex::Autolock lock(mThreadLoopLock);
        mFlagRunning = true;

        size = CECReceiveMessage(buffer, CEC_MAX_FRAME_SIZE, 100000);

        if (!size) // no data available or ctrl-c
            return true;

        if (size == 1)
            return true; // "Polling Message"

        lsrc = buffer[0] >> 4;

        /* ignore messages with src address == mLaddr*/
        if (lsrc == mLaddr)
            return true;

        opcode = buffer[1];

        if (CECIgnoreMessage(opcode, lsrc)) {
            ALOGE("### ignore message coming from address 15 (unregistered)\n");
            return true;
        }

        if (!CECCheckMessageSize(opcode, size)) {
            ALOGE("### invalid message size: %d(opcode: 0x%x) ###\n", size, opcode);
            return true;
        }

        /* check if message broadcasted/directly addressed */
        if (!CECCheckMessageMode(opcode, (buffer[0] & 0x0F) == CEC_MSG_BROADCAST ? 1 : 0)) {
            ALOGE("### invalid message mode (directly addressed/broadcast) ###\n");
            return true;
        }

        ldst = lsrc;

        //TODO: macroses to extract src and dst logical addresses
        //TODO: macros to extract opcode

        switch (opcode) {
        case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS:
            /* responce with "Report Physical Address" */
            buffer[0] = (mLaddr << 4) | CEC_MSG_BROADCAST;
            buffer[1] = CEC_OPCODE_REPORT_PHYSICAL_ADDRESS;
            buffer[2] = (mPaddr >> 8) & 0xFF;
            buffer[3] = mPaddr & 0xFF;
            buffer[4] = mDevtype;
            size = 5;
            break;

        case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
            ALOGD("[CEC_OPCODE_REQUEST_ACTIVE_SOURCE]\n");
            /* responce with "Active Source" */
            buffer[0] = (mLaddr << 4) | CEC_MSG_BROADCAST;
            buffer[1] = CEC_OPCODE_ACTIVE_SOURCE;
            buffer[2] = (mPaddr >> 8) & 0xFF;
            buffer[3] = mPaddr & 0xFF;
            size = 4;
            ALOGD("Tx : [CEC_OPCODE_ACTIVE_SOURCE]\n");
            break;

        case CEC_OPCODE_ABORT:
        case CEC_OPCODE_FEATURE_ABORT:
        default:
            /* send "Feature Abort" */
            buffer[0] = (mLaddr << 4) | ldst;
            buffer[1] = CEC_OPCODE_FEATURE_ABORT;
            buffer[2] = CEC_OPCODE_ABORT;
            buffer[3] = 0x04; // "refused"
            size = 4;
            break;
        }

        if (CECSendMessage(buffer, size) != size)
            ALOGE("CECSendMessage() failed!!!\n");

    }
    return true;
}

bool SecHdmi::CECThread::start()
{
#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("%s", __func__);
#endif

    Mutex::Autolock lock(mThreadControlLock);
    if (exitPending()) {
        if (requestExitAndWait() == WOULD_BLOCK) {
            ALOGE("mCECThread.requestExitAndWait() == WOULD_BLOCK");
            return false;
        }
    }

#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("EDIDGetCECPhysicalAddress");
#endif
    /* set to not valid physical address */
    mPaddr = CEC_NOT_VALID_PHYSICAL_ADDRESS;

    if (!EDIDGetCECPhysicalAddress(&mPaddr)) {
        ALOGE("Error: EDIDGetCECPhysicalAddress() failed.\n");
        return false;
    }

#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("CECOpen");
#endif
    if (!CECOpen()) {
        ALOGE("CECOpen() failed!!!\n");
        return false;
    }

    /* a logical address should only be allocated when a device \
       has a valid physical address, at all other times a device \
       should take the 'Unregistered' logical address (15)
       */

    /* if physical address is not valid device should take \
       the 'Unregistered' logical address (15)
       */

#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("CECAllocLogicalAddress");
#endif
    mLaddr = CECAllocLogicalAddress(mPaddr, mDevtype);

    if (!mLaddr) {
        ALOGE("CECAllocLogicalAddress() failed!!!\n");
        if (!CECClose())
            ALOGE("CECClose() failed!\n");
        return false;
    }

#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("request to run CECThread");
#endif

    status_t ret = run("SecHdmi::CECThread", PRIORITY_DISPLAY);
    if (ret != NO_ERROR) {
        ALOGE("%s fail to run thread", __func__);
        return false;
    }
    return true;
}

bool SecHdmi::CECThread::stop()
{
#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("%s request Exit", __func__);
#endif
    Mutex::Autolock lock(mThreadControlLock);
    if (requestExitAndWait() == WOULD_BLOCK) {
        ALOGE("mCECThread.requestExitAndWait() == WOULD_BLOCK");
        return false;
    }

    if (!CECClose())
        ALOGE("CECClose() failed!\n");

    mFlagRunning = false;
    return true;
}
#endif

SecHdmi::SecHdmi():
#if defined(BOARD_USES_CEC)
    mCECThread(NULL),
#endif
    mFlagCreate(false),
    mFlagConnected(false),
    mHdmiDstWidth(0),
    mHdmiDstHeight(0),
    mHdmiSrcYAddr(0),
    mHdmiSrcCbCrAddr(0),
    mHdmiOutputMode(DEFAULT_OUPUT_MODE),
    mHdmiResolutionValue(DEFAULT_HDMI_RESOLUTION_VALUE), // V4L2_STD_480P_60_4_3
    mCompositeStd(DEFAULT_COMPOSITE_STD),
    mHdcpMode(false),
    mAudioMode(2),
    mUIRotVal(0),
    mG2DUIRotVal(0),
    mCurrentHdmiOutputMode(-1),
    mCurrentHdmiResolutionValue(0), // 1080960
    mCurrentHdcpMode(false),
    mCurrentAudioMode(-1),
    mHdmiInfoChange(true),
    mFimcDstColorFormat(0),
    mFimcCurrentOutBufIndex(0),
    mFBaddr(NULL),
    mFBsize(0),
    mFBionfd(-1),
    mFBIndex(0),
    mDefaultFBFd(-1),
    mDisplayWidth(DEFALULT_DISPLAY_WIDTH),
    mDisplayHeight(DEFALULT_DISPLAY_HEIGHT)
{
#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("%s", __func__);
#endif
    for (int i = 0; i < HDMI_LAYER_MAX; i++) {
        mFlagLayerEnable[i] = false;
        mFlagHdmiStart[i] = false;

        mSrcWidth      [i] = 0;
        mSrcHeight     [i] = 0;
        mSrcColorFormat[i] = 0;
        mHdmiResolutionWidth  [i] = 0;
        mHdmiResolutionHeight [i] = 0;
        mHdmiFd[i] = -1;
        mDstWidth  [i] = 0;
        mDstHeight [i] = 0;
        mPrevDstWidth  [i] = 0;
        mPrevDstHeight [i] = 0;
    }

    mHdmiPresetId = DEFAULT_HDMI_PRESET_ID;
    mHdmiStdId = DEFAULT_HDMI_STD_ID;

    //All layer is on
    mFlagLayerEnable[HDMI_LAYER_VIDEO] = true;
    mFlagLayerEnable[HDMI_LAYER_GRAPHIC_0] = true;
    mFlagLayerEnable[HDMI_LAYER_GRAPHIC_1] = true;

    mHdmiSizeOfResolutionValueList = 14;

    mHdmiResolutionValueList[0]  = 1080960;
    mHdmiResolutionValueList[1]  = 1080950;
    mHdmiResolutionValueList[2]  = 1080930;
    mHdmiResolutionValueList[3]  = 1080924;
    mHdmiResolutionValueList[4]  = 1080160;
    mHdmiResolutionValueList[5]  = 1080150;
    mHdmiResolutionValueList[6]  = 720960;
    mHdmiResolutionValueList[7]  = 7209601;
    mHdmiResolutionValueList[8]  = 720950;
    mHdmiResolutionValueList[9]  = 7209501;
    mHdmiResolutionValueList[10] = 5769501;
    mHdmiResolutionValueList[11] = 5769502;
    mHdmiResolutionValueList[12] = 4809601;
    mHdmiResolutionValueList[13] = 4809602;

#if defined(BOARD_USES_CEC)
    mCECThread = new CECThread(this);
#endif

    SecBuffer zeroBuf;
    for (int i = 0; i < HDMI_FIMC_OUTPUT_BUF_NUM; i++)
        mFimcReservedMem[i] = zeroBuf;
#if defined(BOARD_USE_V4L2)
    for (int i = 0; i < HDMI_LAYER_MAX; i++)
        for (int j = 0; j < MAX_BUFFERS_MIXER; j++)
            mMixerBuffer[i][j] = zeroBuf;
#endif

    memset(&mDstRect, 0 , sizeof(struct v4l2_rect));
}

SecHdmi::~SecHdmi()
{
#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("%s", __func__);
#endif
    if (mFlagCreate == true)
        ALOGE("%s::this is not Destroyed fail", __func__);
    else
        disconnect();
}

bool SecHdmi::create(int width, int height)
{
    Mutex::Autolock lock(mLock);
    unsigned int fimc_buf_size = 0;
    unsigned int gralloc_buf_size = 0;
    mFimcCurrentOutBufIndex = 0;
    int stride;
    int vstride;
    int BufNum = 0;
#if defined(BOARD_USE_V4L2_ION)
    int IonClient = -1;
    int IonFd = -1;
    void *ion_base_addr = NULL;
#endif

/*
 * Video plaback (I420): output buffer size of FIMC3 is (1920 x 1088 x 1.5)
 * Video plaback (NV12): FIMC3 is not used.
 * Camera preview (YV12): output buffer size of FIMC3 is (640 x 480 x 1.5)
 * UI mode (ARGB8888) : output buffer size of FIMC3 is (480 x 800 x 1.5)
 */
#ifndef SUPPORT_1080P_FIMC_OUT
    setDisplaySize(width, height);
#endif

    stride = ALIGN(HDMI_MAX_WIDTH, 16);
    vstride = ALIGN(HDMI_MAX_HEIGHT, 16);

    fimc_buf_size = stride * vstride * HDMI_FIMC_BUFFER_BPP_SIZE;
    gralloc_buf_size = GRALLOC_BUF_SIZE * SIZE_1K;
#if defined(BOARD_USES_FIMGAPI)
    g2d_reserved_memory_size = stride * vstride * HDMI_G2D_BUFFER_BPP_SIZE;
#endif

#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

    if (mFlagCreate == true) {
        ALOGE("%s::Already Created fail", __func__);
        goto CREATE_FAIL;
    }

    if (mDefaultFBFd <= 0) {
        if ((mDefaultFBFd = fb_open(DEFAULT_FB)) < 0) {
            ALOGE("%s:Failed to open default FB", __func__);
            return false;
        }
    }

#ifdef BOARD_USE_V4L2
    BufNum = HDMI_FIMC_OUTPUT_BUF_NUM;
#else
    BufNum = 1;
#endif

    if (mSecFimc.create(SecFimc::DEV_3, SecFimc::MODE_SINGLE_BUF, BufNum) == false) {
        ALOGE("%s::SecFimc create() fail", __func__);
        goto CREATE_FAIL;
    }

#if defined(BOARD_USE_V4L2_ION)
    IonClient = ion_client_create();
    if (IonClient < 0) {
        ALOGE("%s::ion_client_create() failed", __func__);
        goto CREATE_FAIL;
    }
#if defined(BOARD_USES_FIMGAPI)
    IonFd = ion_alloc(IonClient, g2d_reserved_memory_size * HDMI_G2D_OUTPUT_BUF_NUM, 0, ION_HEAP_EXYNOS_MASK);

    if (IonFd < 0) {
        ALOGE("%s::ION memory allocation failed", __func__);
    } else {
        ion_base_addr = ion_map(IonFd, ALIGN(g2d_reserved_memory_size * HDMI_G2D_OUTPUT_BUF_NUM, PAGE_SIZE), 0);
        if (ion_base_addr == MAP_FAILED)
            ALOGE("%s::ION mmap failed", __func__);
    }

    for (int i = 0; i < HDMI_G2D_OUTPUT_BUF_NUM; i++)
        g2d_reserved_memory[i] = (unsigned int)ion_base_addr + (g2d_reserved_memory_size * i);
#endif
#else
#ifndef BOARD_USE_V4L2
    for (int i = 0; i < HDMI_FIMC_OUTPUT_BUF_NUM; i++)
        mFimcReservedMem[i].phys.p = mSecFimc.getMemAddr()->phys.p + gralloc_buf_size + (fimc_buf_size * i);
#endif

#if defined(BOARD_USES_FIMGAPI)
#if defined(BOARD_USES_HDMI_SUBTITLES)
    for (int i = 0; i < HDMI_G2D_OUTPUT_BUF_NUM; i++)
        g2d_reserved_memory[i] = mFimcReservedMem[HDMI_FIMC_OUTPUT_BUF_NUM - 1].phys.p + fimc_buf_size + (g2d_reserved_memory_size * i);
#else
    for (int i = 0; i < HDMI_G2D_OUTPUT_BUF_NUM; i++)
        g2d_reserved_memory[i] = mSecFimc.getMemAddr()->phys.p + gralloc_buf_size + (g2d_reserved_memory_size * i);
#endif
#endif
#endif

    v4l2_std_id std_id;

#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("%s::mHdmiOutputMode(%d) \n", __func__, mHdmiOutputMode);
#endif
    if (mHdmiOutputMode == COMPOSITE_OUTPUT_MODE) {
        std_id = composite_std_2_v4l2_std_id(mCompositeStd);
        if ((int)std_id < 0) {
            ALOGE("%s::composite_std_2_v4l2_std_id(%d) fail\n", __func__, mCompositeStd);
            goto CREATE_FAIL;
        }
        if (m_setCompositeResolution(mCompositeStd) == false) {
            ALOGE("%s::m_setCompositeResolution(%d) fail\n", __func__, mCompositeStd);
            goto CREATE_FAIL;
        }
    } else if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
            mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
#if defined(BOARD_USE_V4L2)
        unsigned int preset_id;

        if (hdmi_resolution_2_preset_id(mHdmiResolutionValue, &mHdmiDstWidth, &mHdmiDstHeight, &preset_id) < 0) {
            ALOGE("%s::hdmi_resolution_2_preset_id(%d) fail\n", __func__, mHdmiResolutionValue);
            goto CREATE_FAIL;
        }
#else
        if (hdmi_resolution_2_std_id(mHdmiResolutionValue, &mHdmiDstWidth, &mHdmiDstHeight, &std_id) < 0) {
            ALOGE("%s::hdmi_resolution_2_std_id(%d) fail\n", __func__, mHdmiResolutionValue);
            goto CREATE_FAIL;
        }
#endif
    }

    mFlagCreate = true;

    return true;

CREATE_FAIL :

    if (mSecFimc.flagCreate() == true &&
       mSecFimc.destroy()    == false)
        ALOGE("%s::fimc destory fail", __func__);

    return false;
}

bool SecHdmi::destroy(void)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

    Mutex::Autolock lock(mLock);

    if (mFlagCreate == false) {
        ALOGE("%s::Already Destroyed fail \n", __func__);
        goto DESTROY_FAIL;
    }

    for (int layer = HDMI_LAYER_BASE + 1; layer <= HDMI_LAYER_GRAPHIC_0; layer++) {
        if (mFlagHdmiStart[layer] == true && m_stopHdmi(layer) == false) {
            ALOGE("%s::m_stopHdmi: layer[%d] fail \n", __func__, layer);
            goto DESTROY_FAIL;
        }

        if (hdmi_deinit_layer(layer) < 0) {
            ALOGE("%s::hdmi_deinit_layer(%d) fail \n", __func__, layer);
            goto DESTROY_FAIL;
        }
    }

#if !defined(BOARD_USE_V4L2)
    tvout_deinit();
#endif

    if (mSecFimc.flagCreate() == true && mSecFimc.destroy() == false) {
        ALOGE("%s::fimc destory fail \n", __func__);
        goto DESTROY_FAIL;
    }

#ifdef USE_LCD_ADDR_IN_HERE
    {
        if (0 < mDefaultFBFd) {
            close(mDefaultFBFd);
            mDefaultFBFd = -1;
        }
    }
#endif //USE_LCD_ADDR_IN_HERE

#if defined(BOARD_USE_V4L2_ION)
    if (mFBaddr != NULL)
        ion_unmap((void *)mFBaddr, ALIGN(mFBsize * 4 * 2, PAGE_SIZE));

    if (mFBionfd > 0)
        ion_free(mFBionfd);

    mFBaddr = NULL;
    mFBionfd = -1;
    mFBsize = 0;
#endif

#if defined(BOARD_USE_V4L2_ION) && defined(BOARD_USES_FIMGAPI)
    ion_unmap((void *)g2d_reserved_memory[0], ALIGN(g2d_reserved_memory_size * HDMI_G2D_OUTPUT_BUF_NUM, PAGE_SIZE));
#endif

    mFlagCreate = false;

    return true;

DESTROY_FAIL :

    return false;
}

bool SecHdmi::connect(void)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

    {
        Mutex::Autolock lock(mLock);

        if (mFlagCreate == false) {
            ALOGE("%s::Not Yet Created \n", __func__);
            return false;
        }

        if (mFlagConnected == true) {
            ALOGD("%s::Already Connected.. \n", __func__);
            return true;
        }

        if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
                mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
            if (m_flagHWConnected() == false) {
                ALOGD("%s::m_flagHWConnected() fail \n", __func__);
                return false;
            }

#if defined(BOARD_USES_EDID)
            if (!EDIDOpen())
                ALOGE("EDIDInit() failed!\n");

            if (!EDIDRead()) {
                ALOGE("EDIDRead() failed!\n");
                if (!EDIDClose())
                    ALOGE("EDIDClose() failed!\n");
            }
#endif

#if defined(BOARD_USES_CEC)
            if (!(mCECThread->mFlagRunning))
                mCECThread->start();
#endif
        }
    }

    if (this->setHdmiOutputMode(mHdmiOutputMode, true) == false)
        ALOGE("%s::setHdmiOutputMode(%d) fail \n", __func__, mHdmiOutputMode);

    if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
            mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
        if (this->setHdmiResolution(mHdmiResolutionValue, true) == false)
            ALOGE("%s::setHdmiResolution(%d) fail \n", __func__, mHdmiResolutionValue);

        if (this->setHdcpMode(mHdcpMode, false) == false)
            ALOGE("%s::setHdcpMode(%d) fail \n", __func__, mHdcpMode);

        mHdmiInfoChange = true;
        mFlagConnected = true;

#if defined(BOARD_USES_EDID)
        // show display..
        display_menu();
#endif
    }

    return true;
}

bool SecHdmi::disconnect(void)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

    Mutex::Autolock lock(mLock);

    if (mFlagCreate == false) {
        ALOGE("%s::Not Yet Created \n", __func__);
        return false;
    }

    if (mFlagConnected == false) {
        ALOGE("%s::Already Disconnected.. \n", __func__);
        return true;
    }

    if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
        mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
#if defined(BOARD_USES_CEC)
        if (mCECThread->mFlagRunning)
            mCECThread->stop();
#endif

#if defined(BOARD_USES_EDID)
        if (!EDIDClose()) {
            ALOGE("EDIDClose() failed!\n");
            return false;
        }
#endif
    }

    for (int layer = SecHdmi::HDMI_LAYER_BASE + 1; layer <= SecHdmi::HDMI_LAYER_GRAPHIC_0; layer++) {
        if (mFlagHdmiStart[layer] == true && m_stopHdmi(layer) == false) {
            ALOGE("%s::hdmiLayer(%d) layer fail \n", __func__, layer);
            return false;
        }
    }

#if defined(BOARD_USE_V4L2)
    for (int layer = HDMI_LAYER_BASE + 1; layer < HDMI_LAYER_MAX; layer++) {
        if (hdmi_deinit_layer(layer) < 0)
            ALOGE("%s::hdmi_deinit_layer(%d) fail", __func__, layer);
    }
#else
    tvout_deinit();
#endif

    mFlagConnected = false;

    mHdmiOutputMode = DEFAULT_OUPUT_MODE;
    mHdmiResolutionValue = DEFAULT_HDMI_RESOLUTION_VALUE;
#if defined(BOARD_USE_V4L2)
    mHdmiPresetId = DEFAULT_HDMI_PRESET_ID;
#else
    mHdmiStdId = DEFAULT_HDMI_STD_ID;
#endif
    mCompositeStd = DEFAULT_COMPOSITE_STD;
    mAudioMode = 2;
    mCurrentHdmiOutputMode = -1;
    mCurrentHdmiResolutionValue = 0;
    mCurrentAudioMode = -1;
    mFimcCurrentOutBufIndex = 0;

    return true;
}

bool SecHdmi::flagConnected(void)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

    Mutex::Autolock lock(mLock);

    if (mFlagCreate == false) {
        ALOGE("%s::Not Yet Created \n", __func__);
        return false;
    }

    return mFlagConnected;
}

bool SecHdmi::flush(int srcW, int srcH, int srcColorFormat,
        unsigned int srcYAddr, unsigned int srcCbAddr, unsigned int srcCrAddr,
        int dstX, int dstY,
        int hdmiLayer,
        int num_of_hwc_layer)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s [srcW=%d, srcH=%d, srcColorFormat=0x%x, srcYAddr=0x%x, srcCbAddr=0x%x, srcCrAddr=0x%x, dstX=%d, dstY=%d, hdmiLayer=%d]",
            __func__, srcW, srcH, srcColorFormat, srcYAddr, srcCbAddr, srcCrAddr, dstX, dstY, hdmiLayer);
#endif

    Mutex::Autolock lock(mLock);

    if (mFlagCreate == false) {
        ALOGE("%s::Not Yet Created \n", __func__);
        return false;
    }

#if defined(BOARD_USE_V4L2)
    if (hdmiLayer == HDMI_LAYER_VIDEO) {
        mDstWidth[hdmiLayer] = mHdmiDstWidth;
        mDstHeight[hdmiLayer] = mHdmiDstHeight;
   } else {
        if (num_of_hwc_layer == 0) {
            struct v4l2_rect rect;
            int tempSrcW, tempSrcH;

            if (mG2DUIRotVal == 0 || mG2DUIRotVal == 180) {
                tempSrcW = srcW;
                tempSrcH = srcH;
            } else {
                tempSrcW = srcH;
                tempSrcH = srcW;
            }

            hdmi_cal_rect(tempSrcW, tempSrcH, mHdmiDstWidth, mHdmiDstHeight, &rect);
            mDstWidth[hdmiLayer] = rect.width;
            mDstHeight[hdmiLayer] = rect.height;
            mDstWidth[HDMI_LAYER_VIDEO] = 0;
            mDstHeight[HDMI_LAYER_VIDEO] = 0;
        } else {
            mDstWidth[hdmiLayer] = mHdmiDstWidth;
            mDstHeight[hdmiLayer] = mHdmiDstHeight;
        }
   }
#ifdef DEBUG_MSG_ENABLE
    ALOGE("m_reset param(%d, %d, %d, %d)",
        mDstWidth[hdmiLayer], mDstHeight[hdmiLayer], \
        mPrevDstWidth[hdmiLayer], mPrevDstHeight[hdmiLayer]);
#endif
#endif

    if (srcW != mSrcWidth[hdmiLayer] ||
        srcH != mSrcHeight[hdmiLayer] ||
        srcColorFormat != mSrcColorFormat[hdmiLayer] ||
        mHdmiDstWidth != mHdmiResolutionWidth[hdmiLayer] ||
        mHdmiDstHeight != mHdmiResolutionHeight[hdmiLayer] ||
#if defined(BOARD_USE_V4L2)
        mDstWidth[hdmiLayer] != mPrevDstWidth[hdmiLayer] ||
        mDstHeight[hdmiLayer] != mPrevDstHeight[hdmiLayer] ||
#endif
        mHdmiInfoChange == true) {
#ifdef DEBUG_MSG_ENABLE
        ALOGD("m_reset param(%d, %d, %d, %d, %d, %d, %d)",
            srcW, mSrcWidth[hdmiLayer], \
            srcH, mSrcHeight[hdmiLayer], \
            srcColorFormat,mSrcColorFormat[hdmiLayer], \
            hdmiLayer);
#endif

        if (m_reset(srcW, srcH, srcColorFormat, hdmiLayer, num_of_hwc_layer) == false) {
            ALOGE("%s::m_reset(%d, %d, %d, %d, %d) fail", __func__, srcW, srcH, srcColorFormat, hdmiLayer, num_of_hwc_layer);
            return false;
        }
    }

    if (srcYAddr == 0) {
#if defined(BOARD_USE_V4L2_ION)
        unsigned int FB_size = ALIGN(srcW, 16) * ALIGN(srcH, 16) * HDMI_FB_BPP_SIZE;
        void *virFBAddr = 0;
        struct s3c_fb_user_ion_client ion_handle;

        if (mFBaddr != NULL) {
            ion_unmap((void *)mFBaddr, ALIGN(mFBsize * 2, PAGE_SIZE));
            ion_free(mFBionfd);
        }

        // get framebuffer virtual address for LCD
        if (ioctl(mDefaultFBFd, S3CFB_GET_ION_USER_HANDLE, &ion_handle) < 0) {
            ALOGE("%s:ioctl(S3CFB_GET_ION_USER_HANDLE) fail", __func__);
            return false;
        }

        virFBAddr = ion_map(ion_handle.fd, ALIGN(FB_size * 2, PAGE_SIZE), 0);
        if (virFBAddr == MAP_FAILED) {
            ALOGE("%s::ion_map fail", __func__);
            ion_free(ion_handle.fd);
            mFBaddr = NULL;
            return false;
        }

        if ((mFBIndex % 2) == 0)
            srcYAddr = (unsigned int)virFBAddr;
        else
            srcYAddr = (unsigned int)virFBAddr + FB_size;

        srcCbAddr = srcYAddr;

        mFBIndex++;
        mFBaddr = virFBAddr;
        mFBsize = FB_size;
        mFBionfd = ion_handle.fd;
#else
        unsigned int phyFBAddr = 0;

        // get physical framebuffer address for LCD
        if (ioctl(mDefaultFBFd, S3CFB_GET_FB_PHY_ADDR, &phyFBAddr) == -1) {
            ALOGE("%s:ioctl(S3CFB_GET_FB_PHY__ADDR) fail", __func__);
            return false;
        }

        /*
         * when early suspend, FIMD IP off.
         * so physical framebuffer address for LCD is 0x00000000
         * so JUST RETURN.
         */
        if (phyFBAddr == 0) {
            ALOGE("%s::S3CFB_GET_FB_PHY_ADDR fail", __func__);
            return true;
        }
        srcYAddr = phyFBAddr;
        srcCbAddr = srcYAddr;
#endif
    }

    if (hdmiLayer == HDMI_LAYER_VIDEO) {
        if (srcColorFormat == HAL_PIXEL_FORMAT_YCbCr_420_SP ||
            srcColorFormat == HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP) {
#if defined(BOARD_USE_V4L2)
            mMixerBuffer[hdmiLayer][0].virt.extP[0] = (char *)srcYAddr;
            mMixerBuffer[hdmiLayer][0].virt.extP[1] = (char *)srcCbAddr;
#else
            hdmi_set_v_param(hdmiLayer,
                    srcW, srcH, V4L2_PIX_FMT_NV12,
                    srcYAddr, srcCbAddr,
                    mHdmiDstWidth, mHdmiDstHeight);
#endif
        } else if (srcColorFormat == HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED) {
#if defined(BOARD_USE_V4L2)
            mMixerBuffer[hdmiLayer][0].virt.extP[0] = (char *)srcYAddr;
            mMixerBuffer[hdmiLayer][0].virt.extP[1] = (char *)srcCbAddr;
#else
            hdmi_set_v_param(hdmiLayer,
                            srcW, srcH, V4L2_PIX_FMT_NV12T,
                            srcYAddr, srcCbAddr,
                            mHdmiDstWidth, mHdmiDstHeight);
#endif
        } else if (srcColorFormat == HAL_PIXEL_FORMAT_YCrCb_420_SP ||
                 srcColorFormat == HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP) {
#if defined(BOARD_USE_V4L2)
            mMixerBuffer[hdmiLayer][0].virt.extP[0] = (char *)srcYAddr;
            mMixerBuffer[hdmiLayer][0].virt.extP[1] = (char *)srcCbAddr;
#else
            hdmi_set_v_param(hdmiLayer,
                    srcW, srcH, V4L2_PIX_FMT_NV21,
                    srcYAddr, srcCbAddr,
                    mHdmiDstWidth, mHdmiDstHeight);
#endif
        } else {
            if (mSecFimc.setSrcAddr(srcYAddr, srcCbAddr, srcCrAddr, srcColorFormat) == false) {
                ALOGE("%s::setSrcAddr(%d, %d, %d) fail",
                        __func__, srcYAddr, srcCbAddr, srcCrAddr);
                return false;
            }

            int  y_size = 0;
            if (mUIRotVal == 0 || mUIRotVal == 180)
                y_size =  ALIGN(ALIGN(srcW,128) * ALIGN(srcH, 32), SZ_8K);
            else
                y_size =  ALIGN(ALIGN(srcH,128) * ALIGN(srcW, 32), SZ_8K);

            mHdmiSrcYAddr    = mFimcReservedMem[mFimcCurrentOutBufIndex].phys.extP[0];
#ifdef BOARD_USE_V4L2
            mHdmiSrcCbCrAddr = mFimcReservedMem[mFimcCurrentOutBufIndex].phys.extP[1];
#else
            mHdmiSrcCbCrAddr = mFimcReservedMem[mFimcCurrentOutBufIndex].phys.extP[0] + y_size;
#endif
            if (mSecFimc.setDstAddr(mHdmiSrcYAddr, mHdmiSrcCbCrAddr, 0, mFimcCurrentOutBufIndex) == false) {
                ALOGE("%s::mSecFimc.setDstAddr(%d, %d) fail \n",
                        __func__, mHdmiSrcYAddr, mHdmiSrcCbCrAddr);
                return false;
            }

            if (mSecFimc.draw(0, mFimcCurrentOutBufIndex) == false) {
                ALOGE("%s::mSecFimc.draw() fail \n", __func__);
                return false;
            }
#if defined(BOARD_USE_V4L2)
            mMixerBuffer[hdmiLayer][0].virt.extP[0] = (char *)mHdmiSrcYAddr;
            mMixerBuffer[hdmiLayer][0].virt.extP[1] = (char *)mHdmiSrcCbCrAddr;
#else
            if (mUIRotVal == 0 || mUIRotVal == 180)
                hdmi_set_v_param(hdmiLayer,
                        srcW, srcH, V4L2_PIX_FMT_NV12T,
                        mHdmiSrcYAddr, mHdmiSrcCbCrAddr,
                        mHdmiDstWidth, mHdmiDstHeight);
            else
                hdmi_set_v_param(hdmiLayer,
                        srcH, srcW, V4L2_PIX_FMT_NV12T,
                        mHdmiSrcYAddr, mHdmiSrcCbCrAddr,
                        mHdmiDstWidth, mHdmiDstHeight);
#endif
            mFimcCurrentOutBufIndex++;
            if (mFimcCurrentOutBufIndex >= HDMI_FIMC_OUTPUT_BUF_NUM)
                mFimcCurrentOutBufIndex = 0;
        }

    } else {
        if (srcColorFormat != HAL_PIXEL_FORMAT_BGRA_8888 &&
            srcColorFormat != HAL_PIXEL_FORMAT_RGBA_8888 &&
            srcColorFormat != HAL_PIXEL_FORMAT_RGB_565) {
            if (mSecFimc.setSrcAddr(srcYAddr, srcCbAddr, srcCrAddr, srcColorFormat) == false) {
                ALOGE("%s::setSrcAddr(%d, %d, %d) fail",
                     __func__, srcYAddr, srcCbAddr, srcCrAddr);
                return false;
            }

            if (mSecFimc.draw(0, mFimcCurrentOutBufIndex) == false) {
                ALOGE("%s::mSecFimc.draw() failed", __func__);
                return false;
            }
#if defined(BOARD_USE_V4L2)
            if (hdmi_set_g_scaling(hdmiLayer,
                            HAL_PIXEL_FORMAT_BGRA_8888,
                            mDstRect.width, mDstRect.height,
                            mHdmiSrcYAddr, &mMixerBuffer[hdmiLayer][0],
                            mDstRect.left , mDstRect.top,
                            mHdmiDstWidth, mHdmiDstHeight,
                            mG2DUIRotVal,
                            num_of_hwc_layer) < 0)
                return false;
#else
            if (hdmi_gl_set_param(hdmiLayer,
                            HAL_PIXEL_FORMAT_BGRA_8888,
                            mDstRect.width, mDstRect.height,
                            mHdmiSrcYAddr, mHdmiSrcCbCrAddr,
                            mDstRect.left , mDstRect.top,
                            mHdmiDstWidth, mHdmiDstHeight,
                            mG2DUIRotVal) < 0)
#endif
                return false;
        } else {
#if CHECK_GRAPHIC_LAYER_TIME
            nsecs_t start, end;
            start = systemTime();
#endif
            if (num_of_hwc_layer == 0) { /* UI only mode */
                struct v4l2_rect rect;

                if (mG2DUIRotVal == 0 || mG2DUIRotVal == 180)
                    hdmi_cal_rect(srcW, srcH, mHdmiDstWidth, mHdmiDstHeight, &rect);
                else
                    hdmi_cal_rect(srcH, srcW, mHdmiDstWidth, mHdmiDstHeight, &rect);

                rect.left = ALIGN(rect.left, 16);

#if defined(BOARD_USE_V4L2)
                if (hdmi_set_g_scaling(hdmiLayer,
                                srcColorFormat,
                                srcW, srcH,
                                srcYAddr, &mMixerBuffer[hdmiLayer][0],
                                rect.left, rect.top,
                                rect.width, rect.height,
                                mG2DUIRotVal,
                                num_of_hwc_layer) < 0)
                    return false;
#else
                if (hdmi_gl_set_param(hdmiLayer,
                                srcColorFormat,
                                srcW, srcH,
                                srcYAddr, srcCbAddr,
                                rect.left, rect.top,
                                rect.width, rect.height,
                                mG2DUIRotVal) < 0)
                    return false;
#endif
            } else { /* Video Playback Mode */
#if defined(BOARD_USE_V4L2)
                if (hdmi_set_g_scaling(hdmiLayer,
                                srcColorFormat,
                                srcW, srcH,
                                srcYAddr, &mMixerBuffer[hdmiLayer][0],
                                dstX, dstY,
                                mHdmiDstWidth, mHdmiDstHeight,
                                mG2DUIRotVal,
                                num_of_hwc_layer) < 0)
                    return false;
#else
                if (hdmi_gl_set_param(hdmiLayer,
                                srcColorFormat,
                                srcW, srcH,
                                srcYAddr, srcCbAddr,
                                dstX, dstY,
                                mHdmiDstWidth, mHdmiDstHeight,
                                mG2DUIRotVal) < 0)
                    return false;
#endif
            }
#if CHECK_GRAPHIC_LAYER_TIME
            end = systemTime();
            ALOGD("[UI] hdmi_gl_set_param[end-start] = %ld ms", long(ns2ms(end)) - long(ns2ms(start)));
#endif
        }
    }

    if (mFlagConnected) {
#if defined(BOARD_USE_V4L2)
        unsigned int num_of_plane;

        if (hdmi_get_src_plane(srcColorFormat, &num_of_plane) < 0) {
            ALOGE("%s::hdmi_get_src_plane(%d) fail", __func__, srcColorFormat);
            return false;
        }

        if (mFlagHdmiStart[hdmiLayer] == false && m_startHdmi(hdmiLayer, num_of_plane) == false) {
            ALOGE("%s::hdmiLayer(%d) fail", __func__, hdmiLayer);
            return false;
        }
#else
        if (mFlagHdmiStart[hdmiLayer] == false && m_startHdmi(hdmiLayer) == false) {
            ALOGE("%s::hdmiLayer(%d) fail", __func__, hdmiLayer);
            return false;
        }
#endif
    }

    return true;
}

bool SecHdmi::clear(int hdmiLayer)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s || hdmiLayer = %d", __func__, hdmiLayer);
#endif

    Mutex::Autolock lock(mLock);

    if (mFlagCreate == false) {
        ALOGE("%s::Not Yet Created \n", __func__);
        return false;
    }
    if (mFlagHdmiStart[hdmiLayer] == true && m_stopHdmi(hdmiLayer) == false) {
        ALOGE("%s::m_stopHdmi: layer[%d] fail \n", __func__, hdmiLayer);
        return false;
    }
    return true;
}

bool SecHdmi::setHdmiOutputMode(int hdmiOutputMode, bool forceRun)
{
#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("%s::hdmiOutputMode = %d, forceRun = %d", __func__, hdmiOutputMode, forceRun);
#endif

    Mutex::Autolock lock(mLock);

    if (mFlagCreate == false) {
        ALOGE("%s::Not Yet Created \n", __func__);
        return false;
    }

    if (forceRun == false && mHdmiOutputMode == hdmiOutputMode) {
#ifdef DEBUG_HDMI_HW_LEVEL
        ALOGD("%s::same hdmiOutputMode(%d) \n", __func__, hdmiOutputMode);
#endif
        return true;
    }

    int newHdmiOutputMode = hdmiOutputMode;

    int v4l2OutputType = hdmi_outputmode_2_v4l2_output_type(hdmiOutputMode);
    if (v4l2OutputType < 0) {
        ALOGD("%s::hdmi_outputmode_2_v4l2_output_type(%d) fail\n", __func__, hdmiOutputMode);
        return false;
    }

#if defined(BOARD_USES_EDID)
    int newV4l2OutputType = hdmi_check_output_mode(v4l2OutputType);
    if (newV4l2OutputType != v4l2OutputType) {
        newHdmiOutputMode = hdmi_v4l2_output_type_2_outputmode(newV4l2OutputType);
        if (newHdmiOutputMode < 0) {
            ALOGD("%s::hdmi_v4l2_output_type_2_outputmode(%d) fail\n", __func__, newV4l2OutputType);
            return false;
        }

        ALOGD("%s::calibration mode(%d -> %d)... \n", __func__, hdmiOutputMode, newHdmiOutputMode);
        mHdmiInfoChange = true;
    }
#endif

    if (mHdmiOutputMode != newHdmiOutputMode) {
        mHdmiOutputMode = newHdmiOutputMode;
        mHdmiInfoChange = true;
    }

    return true;
}

bool SecHdmi::setHdmiResolution(unsigned int hdmiResolutionValue, bool forceRun)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s:: hdmiResolutionValue = %d, forceRun = %d", __func__, hdmiResolutionValue, forceRun);
#endif

    Mutex::Autolock lock(mLock);

    if (mFlagCreate == false) {
        ALOGE("%s::Not Yet Created \n", __func__);
        return false;
    }

    if (forceRun == false && mHdmiResolutionValue == hdmiResolutionValue) {
#ifdef DEBUG_HDMI_HW_LEVEL
        ALOGD("%s::same hdmiResolutionValue(%d) \n", __func__, hdmiResolutionValue);
#endif
        return true;
    }

    unsigned int newHdmiResolutionValue = hdmiResolutionValue;
    int w = 0;
    int h = 0;

#if defined(BOARD_USES_EDID)
    // find perfect resolutions..
#if defined(BOARD_USE_V4L2)
    unsigned int preset_id;
    if (hdmi_resolution_2_preset_id(newHdmiResolutionValue, &w, &h, &preset_id) < 0 ||
        hdmi_check_resolution(preset_id) < 0) {
        bool flagFoundIndex = false;
        int resolutionValueIndex = m_resolutionValueIndex(newHdmiResolutionValue);

        for (int i = resolutionValueIndex + 1; i < mHdmiSizeOfResolutionValueList; i++) {
            if (hdmi_resolution_2_preset_id(mHdmiResolutionValueList[i], &w, &h, &preset_id) == 0 &&
                hdmi_check_resolution(preset_id) == 0) {
                newHdmiResolutionValue = mHdmiResolutionValueList[i];
                flagFoundIndex = true;
                break;
            }
        }

        if (flagFoundIndex == false) {
            ALOGE("%s::hdmi cannot control this resolution(%d) fail \n", __func__, hdmiResolutionValue);
            // Set resolution to 480P
            newHdmiResolutionValue = mHdmiResolutionValueList[mHdmiSizeOfResolutionValueList-2];
        } else {
            ALOGD("%s::HDMI resolutions size is calibrated(%d -> %d)..\n", __func__, hdmiResolutionValue, newHdmiResolutionValue);
        }
    }
#else
    v4l2_std_id std_id;
    if (hdmi_resolution_2_std_id(newHdmiResolutionValue, &w, &h, &std_id) < 0 ||
        hdmi_check_resolution(std_id) < 0) {
        bool flagFoundIndex = false;
        int resolutionValueIndex = m_resolutionValueIndex(newHdmiResolutionValue);

        for (int i = resolutionValueIndex + 1; i < mHdmiSizeOfResolutionValueList; i++) {
            if (hdmi_resolution_2_std_id(mHdmiResolutionValueList[i], &w, &h, &std_id) == 0 &&
                hdmi_check_resolution(std_id) == 0) {
                newHdmiResolutionValue = mHdmiResolutionValueList[i];
                flagFoundIndex = true;
                break;
            }
        }

        if (flagFoundIndex == false) {
            ALOGE("%s::hdmi cannot control this resolution(%d) fail \n", __func__, hdmiResolutionValue);
            // Set resolution to 480P
            newHdmiResolutionValue = mHdmiResolutionValueList[mHdmiSizeOfResolutionValueList-2];
        } else {
            ALOGD("%s::HDMI resolutions size is calibrated(%d -> %d)..\n", __func__, hdmiResolutionValue, newHdmiResolutionValue);
        }
    }
#endif
    else {
#ifdef DEBUG_HDMI_HW_LEVEL
        ALOGD("%s::find resolutions(%d) at once\n", __func__, hdmiResolutionValue);
#endif
    }
#endif

    if (mHdmiResolutionValue != newHdmiResolutionValue) {
        mHdmiResolutionValue = newHdmiResolutionValue;
        mHdmiInfoChange = true;
    }

    return true;
}

bool SecHdmi::setHdcpMode(bool hdcpMode, bool forceRun)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

    Mutex::Autolock lock(mLock);

    if (mFlagCreate == false) {
        ALOGE("%s::Not Yet Created \n", __func__);
        return false;
    }

    if (forceRun == false && mHdcpMode == hdcpMode) {
#ifdef DEBUG_HDMI_HW_LEVEL
        ALOGD("%s::same hdcpMode(%d) \n", __func__, hdcpMode);
#endif
        return true;
    }

    mHdcpMode = hdcpMode;
    mHdmiInfoChange = true;

    return true;
}

bool SecHdmi::setUIRotation(unsigned int rotVal, unsigned int hwcLayer)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

    Mutex::Autolock lock(mLock);

    if (mFlagCreate == false) {
        ALOGE("%s::Not Yet Created \n", __func__);
        return false;
    }

    if (rotVal % 90 != 0) {
        ALOGE("%s::Invalid rotation value(%d)", __func__, rotVal);
        return false;
    }

    /* G2D rotation */
    if (rotVal != mG2DUIRotVal) {
        mG2DUIRotVal = rotVal;
        mHdmiInfoChange = true;
    }

    /* FIMC rotation */
    if (hwcLayer == 0) { /* Rotate in UI only mode */
        if (rotVal != mUIRotVal) {
            mSecFimc.setRotVal(rotVal);
            mUIRotVal = rotVal;
            mHdmiInfoChange = true;
        }
    } else { /* Don't rotate video layer when video is played. */
        rotVal = 0;
        if (rotVal != mUIRotVal) {
            mSecFimc.setRotVal(rotVal);
            mUIRotVal = rotVal;
            mHdmiInfoChange = true;
        }
    }

    return true;
}

bool SecHdmi::setDisplaySize(int width, int height)
{
    mDisplayWidth = width;
    mDisplayHeight = height;

    return true;
}

bool SecHdmi::m_reset(int w, int h, int colorFormat, int hdmiLayer, int hwcLayer)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("### %s called", __func__);
#endif
    v4l2_std_id std_id = 0;
    mFimcCurrentOutBufIndex = 0;

    int srcW = w;
    int srcH = h;

#if defined(BOARD_USE_V4L2)
    if (mFlagHdmiStart[hdmiLayer] == true && m_stopHdmi(hdmiLayer) == false) {
        ALOGE("%s::m_stopHdmi: layer[%d] fail", __func__, hdmiLayer);
        return false;
    }
#else
    // stop all..
    for (int layer = HDMI_LAYER_BASE + 1; layer < HDMI_LAYER_MAX; layer++) {
        if (mFlagHdmiStart[layer] == true && m_stopHdmi(layer) == false) {
            ALOGE("%s::m_stopHdmi: layer[%d] fail", __func__, layer);
            return false;
        }
    }
#endif

#if defined(BOARD_USE_V4L2)
    if (hdmi_deinit_layer(hdmiLayer) < 0)
        ALOGE("%s::hdmi_deinit_layer(%d) fail", __func__, hdmiLayer);

    mHdmiFd[hdmiLayer] = hdmi_init_layer(hdmiLayer);
    if (mHdmiFd[hdmiLayer] < 0)
        ALOGE("%s::hdmi_init_layer(%d) fail", __func__, hdmiLayer);

    if (tvout_std_v4l2_init(mHdmiFd[hdmiLayer], mHdmiPresetId) < 0)
        ALOGE("%s::tvout_std_v4l2_init fail", __func__);
#endif

    if (w != mSrcWidth [hdmiLayer] ||
        h != mSrcHeight [hdmiLayer] ||
        mHdmiDstWidth != mHdmiResolutionWidth[hdmiLayer] ||
        mHdmiDstHeight != mHdmiResolutionHeight[hdmiLayer] ||
#if defined(BOARD_USE_V4L2)
        mDstWidth[hdmiLayer] != mPrevDstWidth[hdmiLayer] ||
        mDstHeight[hdmiLayer] != mPrevDstHeight[hdmiLayer] ||
#endif
        colorFormat != mSrcColorFormat[hdmiLayer]) {
        int preVideoSrcColorFormat = mSrcColorFormat[hdmiLayer];
        int videoSrcColorFormat = colorFormat;

        if (preVideoSrcColorFormat != HAL_PIXEL_FORMAT_YCbCr_420_SP &&
            preVideoSrcColorFormat != HAL_PIXEL_FORMAT_YCrCb_420_SP &&
            preVideoSrcColorFormat != HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP &&
            preVideoSrcColorFormat != HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP &&
            preVideoSrcColorFormat != HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED) {
                ALOGI("%s: Unsupported preVideoSrcColorFormat = 0x%x\n", __func__, preVideoSrcColorFormat);
                preVideoSrcColorFormat = HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED;
        }

        if (hdmiLayer == HDMI_LAYER_VIDEO) {
            if (colorFormat != HAL_PIXEL_FORMAT_YCbCr_420_SP &&
                colorFormat != HAL_PIXEL_FORMAT_YCrCb_420_SP &&
                colorFormat != HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP &&
                colorFormat != HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP &&
                colorFormat != HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED) {
#ifdef DEBUG_HDMI_HW_LEVEL
                ALOGD("### %s  call mSecFimc.setSrcParams\n", __func__);
#endif
                unsigned int full_wdith = ALIGN(w, 16);
                unsigned int full_height = ALIGN(h, 2);

                if (mSecFimc.setSrcParams(full_wdith, full_height, 0, 0,
                            (unsigned int*)&w, (unsigned int*)&h, colorFormat, true) == false) {
                    ALOGE("%s::mSecFimc.setSrcParams(%d, %d, %d) fail \n",
                            __func__, w, h, colorFormat);
                    return false;
                }

                mFimcDstColorFormat = HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED;

#ifdef DEBUG_HDMI_HW_LEVEL
                ALOGD("### %s  call mSecFimc.setDstParams\n", __func__);
#endif
                if (mUIRotVal == 0 || mUIRotVal == 180) {
                    if (mSecFimc.setDstParams((unsigned int)w, (unsigned int)h, 0, 0,
                                (unsigned int*)&w, (unsigned int*)&h, mFimcDstColorFormat, true) == false) {
                        ALOGE("%s::mSecFimc.setDstParams(%d, %d, %d) fail \n",
                                __func__, w, h, mFimcDstColorFormat);
                        return false;
                    }
#if defined(BOARD_USE_V4L2)
                    hdmi_set_v_param(mHdmiFd[hdmiLayer], hdmiLayer,
                                    mFimcDstColorFormat, srcW, srcH,
                                    &mMixerBuffer[hdmiLayer][0],
                                    0, 0, mHdmiDstWidth, mHdmiDstHeight);
#endif
                } else {
                    if (mSecFimc.setDstParams((unsigned int)h, (unsigned int)w, 0, 0,
                                (unsigned int*)&h, (unsigned int*)&w, mFimcDstColorFormat, true) == false) {
                        ALOGE("%s::mSecFimc.setDstParams(%d, %d, %d) fail \n",
                                __func__, w, h, mFimcDstColorFormat);
                        return false;
                    }
#if defined(BOARD_USE_V4L2)
                    hdmi_set_v_param(mHdmiFd[hdmiLayer], hdmiLayer,
                                    mFimcDstColorFormat, srcH, srcW,
                                    &mMixerBuffer[hdmiLayer][0],
                                    0, 0, mHdmiDstWidth, mHdmiDstHeight);
#endif
                }
            }
#if defined(BOARD_USE_V4L2)
            else {
                hdmi_set_v_param(mHdmiFd[hdmiLayer], hdmiLayer,
                                colorFormat, srcW, srcH,
                                &mMixerBuffer[hdmiLayer][0],
                                0, 0, mHdmiDstWidth, mHdmiDstHeight);
            }
#endif
            mPrevDstWidth[hdmiLayer] = mHdmiDstWidth;
            mPrevDstHeight[hdmiLayer] = mHdmiDstHeight;
        } else {
#if defined(BOARD_USE_V4L2)
            struct v4l2_rect rect;
            int tempSrcW, tempSrcH;

            if (mG2DUIRotVal == 0 || mG2DUIRotVal == 180) {
                tempSrcW = srcW;
                tempSrcH = srcH;
            } else {
                tempSrcW = srcH;
                tempSrcH = srcW;
            }

            hdmi_cal_rect(tempSrcW, tempSrcH, mHdmiDstWidth, mHdmiDstHeight, &rect);
            rect.left = ALIGN(rect.left, 16);

            if (hwcLayer == 0) { /* UI only mode */
                hdmi_set_g_param(mHdmiFd[hdmiLayer], hdmiLayer,
                                colorFormat, srcW, srcH,
                                &mMixerBuffer[hdmiLayer][0],
                                rect.left, rect.top, rect.width, rect.height);
                mPrevDstWidth[hdmiLayer] = rect.width;
                mPrevDstHeight[hdmiLayer] = rect.height;
                mPrevDstWidth[HDMI_LAYER_VIDEO] = 0;
                mPrevDstHeight[HDMI_LAYER_VIDEO] = 0;
            } else { /* Video Playback + UI Mode */
                hdmi_set_g_param(mHdmiFd[hdmiLayer], hdmiLayer,
                                colorFormat, srcW, srcH,
                                &mMixerBuffer[hdmiLayer][0],
                                0, 0, mHdmiDstWidth, mHdmiDstHeight);
                mPrevDstWidth[hdmiLayer] = mHdmiDstWidth;
                mPrevDstHeight[hdmiLayer] = mHdmiDstHeight;
            }
#endif
        }

        if (preVideoSrcColorFormat != videoSrcColorFormat)
            mHdmiInfoChange = true;

        mSrcWidth[hdmiLayer] = srcW;
        mSrcHeight[hdmiLayer] = srcH;
        mSrcColorFormat[hdmiLayer] = colorFormat;

        mHdmiResolutionWidth[hdmiLayer] = mHdmiDstWidth;
        mHdmiResolutionHeight[hdmiLayer] = mHdmiDstHeight;

#ifdef DEBUG_MSG_ENABLE
        ALOGD("m_reset saved param(%d, %d, %d, %d, %d, %d, %d) \n",
            srcW, mSrcWidth[hdmiLayer], \
            srcH, mSrcHeight[hdmiLayer], \
            colorFormat,mSrcColorFormat[hdmiLayer], \
            hdmiLayer);
#endif
    }

    if (mHdmiInfoChange == true) {
#ifdef DEBUG_HDMI_HW_LEVEL
        ALOGD("mHdmiInfoChange: %d\n", mHdmiInfoChange);
#endif
        // stop all..
#if defined(BOARD_USES_CEC)
        if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
            mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
            if (mCECThread->mFlagRunning)
                mCECThread->stop();
        }
#endif

        if (m_setHdmiOutputMode(mHdmiOutputMode) == false) {
            ALOGE("%s::m_setHdmiOutputMode() fail \n", __func__);
            return false;
        }
        if (mHdmiOutputMode == COMPOSITE_OUTPUT_MODE) {
            std_id = composite_std_2_v4l2_std_id(mCompositeStd);
            if ((int)std_id < 0) {
                ALOGE("%s::composite_std_2_v4l2_std_id(%d) fail\n", __func__, mCompositeStd);
                return false;
            }
            if (m_setCompositeResolution(mCompositeStd) == false) {
                ALOGE("%s::m_setCompositeRsolution() fail \n", __func__);
                return false;
            }
        } else if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
                   mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
            if (m_setHdmiResolution(mHdmiResolutionValue) == false) {
                ALOGE("%s::m_setHdmiResolution() fail \n", __func__);
                return false;
            }

            if (m_setHdcpMode(mHdcpMode) == false) {
                ALOGE("%s::m_setHdcpMode() fail \n", __func__);
                return false;
            }
#if !defined(BOARD_USE_V4L2)
            std_id = mHdmiStdId;
#endif
        }

#if !defined(BOARD_USE_V4L2)
        fp_tvout = tvout_init(std_id);

        for (int layer = HDMI_LAYER_BASE + 1; layer < HDMI_LAYER_MAX; layer++) {
            if (hdmi_deinit_layer(layer) < 0)
                ALOGE("%s::hdmi_init_layer(%d) fail \n", __func__, layer);
        }

        for (int layer = HDMI_LAYER_BASE + 1; layer < HDMI_LAYER_MAX; layer++) {
            if (hdmi_init_layer(layer) < 0)
                ALOGE("%s::hdmi_init_layer(%d) fail \n", __func__, layer);
        }
#endif

        if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
            mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
#if defined(BOARD_USES_CEC)
            if (!(mCECThread->mFlagRunning))
                mCECThread->start();
#endif

            if (m_setAudioMode(mAudioMode) == false)
                ALOGE("%s::m_setAudioMode() fail \n", __func__);
        }

        mHdmiInfoChange = false;
#ifdef BOARD_USE_V4L2
        for (int i = 0; i < HDMI_FIMC_OUTPUT_BUF_NUM; i++)
            mFimcReservedMem[i] = *(mSecFimc.getMemAddr(i));
#endif
    }

    return true;
}

#if defined(BOARD_USE_V4L2)
bool SecHdmi::m_startHdmi(int hdmiLayer, unsigned int num_of_plane)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

    bool ret = true;
    int buf_index = 0;

#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("### %s: hdmiLayer(%d) called\n", __func__, hdmiLayer);
#endif

    if (mFlagLayerEnable[hdmiLayer]) {
        static unsigned int index = 0;

        if (mFlagHdmiStart[hdmiLayer] == false) {
            index = 0;
            if (tvout_std_v4l2_qbuf(mHdmiFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_USERPTR,
                                    index, num_of_plane, &mMixerBuffer[hdmiLayer][0]) < 0) {
                ALOGE("%s::tvout_std_v4l2_qbuf(index : %d) (mSrcBufNum : %d) failed", __func__, index, HDMI_NUM_MIXER_BUF);
                return false;
            }
            index++;

            if (tvout_std_v4l2_streamon(mHdmiFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) < 0) {
                ALOGE("%s::tvout_std_v4l2_streamon() failed", __func__);
                return false;
            }

            mFlagHdmiStart[hdmiLayer] = true;
        } else {
            if (tvout_std_v4l2_qbuf(mHdmiFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_USERPTR,
                                    index, num_of_plane, &mMixerBuffer[hdmiLayer][0]) < 0) {
                ALOGE("%s::tvout_std_v4l2_qbuf() failed", __func__);
                return false;
            }

            if (tvout_std_v4l2_dqbuf(mHdmiFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_USERPTR, &buf_index, num_of_plane) < 0) {
                ALOGE("%s::tvout_std_v4l2_dqbuf() failed", __func__);
                return false;
            }
            index = buf_index;
        }
    }

    return true;
}
#else
bool SecHdmi::m_startHdmi(int hdmiLayer)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

    bool ret = true;
    int buf_index = 0;

#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("### %s: hdmiLayer(%d) called\n", __func__, hdmiLayer);
#endif

    switch (hdmiLayer) {
    case HDMI_LAYER_VIDEO:
        tvout_v4l2_start_overlay(fp_tvout_v);
        mFlagHdmiStart[hdmiLayer] = true;
        break;
    case HDMI_LAYER_GRAPHIC_0 :
        if (mFlagLayerEnable[hdmiLayer]) {
            if (ioctl(fp_tvout_g0, FBIOBLANK, (void *)FB_BLANK_UNBLANK) != -1)
                mFlagHdmiStart[hdmiLayer] = true;
        }
        break;
    case HDMI_LAYER_GRAPHIC_1 :
        if (mFlagLayerEnable[hdmiLayer]) {
            if (ioctl(fp_tvout_g1, FBIOBLANK, (void *)FB_BLANK_UNBLANK) != -1)
                mFlagHdmiStart[hdmiLayer] = true;
        }
        break;
    default :
        ALOGE("%s::unmathced layer(%d) fail", __func__, hdmiLayer);
        ret = false;
        break;
    }

    return true;
}
#endif

bool SecHdmi::m_stopHdmi(int hdmiLayer)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

    bool ret = true;
    if (mFlagHdmiStart[hdmiLayer] == false) {
        ALOGD("%s::already HDMI(%d layer) stopped.. \n", __func__, hdmiLayer);
        return true;
    }

#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("### %s : layer[%d] called\n", __func__, hdmiLayer);
#endif

#if defined(BOARD_USE_V4L2)
    int fd;

    switch (hdmiLayer) {
    case HDMI_LAYER_VIDEO:
        break;
    case HDMI_LAYER_GRAPHIC_0 :
        break;
    case HDMI_LAYER_GRAPHIC_1 :
#if defined(BOARD_USES_FIMGAPI)
        cur_g2d_address = 0;
        g2d_buf_index = 0;
#endif
        break;
    default :
        ALOGE("%s::unmathced layer(%d) fail", __func__, hdmiLayer);
        ret = false;
        break;
    }

    if (mFlagLayerEnable[hdmiLayer]) {
        if (tvout_std_v4l2_streamoff(mHdmiFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) < 0) {
            ALOGE("%s::tvout_std_v4l2_streamon layer(%d) failed", __func__, hdmiLayer);
            return false;
        }

        /* clear buffer */
        if (tvout_std_v4l2_reqbuf(mHdmiFd[hdmiLayer], V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE, V4L2_MEMORY_USERPTR, 0) < 0) {
            ALOGE("%s::tvout_std_v4l2_reqbuf(buf_num=%d)[graphic layer] failed", __func__, 0);
            return -1;
        }

        mFlagHdmiStart[hdmiLayer] = false;
    }
#else
    switch (hdmiLayer) {
    case HDMI_LAYER_VIDEO:
        tvout_v4l2_stop_overlay(fp_tvout_v);
        mFlagHdmiStart[hdmiLayer] = false;
        break;
    case HDMI_LAYER_GRAPHIC_0 :
        if (mFlagLayerEnable[hdmiLayer]) {
            if (ioctl(fp_tvout_g0, FBIOBLANK, (void *)FB_BLANK_POWERDOWN) != -1)
                mFlagHdmiStart[hdmiLayer] = false;
        }
        break;
    case HDMI_LAYER_GRAPHIC_1 :
#if defined(BOARD_USES_FIMGAPI)
        cur_g2d_address = 0;
        g2d_buf_index = 0;
#endif
        if (mFlagLayerEnable[hdmiLayer]) {
            if (ioctl(fp_tvout_g1, FBIOBLANK, (void *)FB_BLANK_POWERDOWN) != -1)
                mFlagHdmiStart[hdmiLayer] = false;
        }
        break;
    default :
        ALOGE("%s::unmathced layer(%d) fail", __func__, hdmiLayer);
        ret = false;
        break;
    }
#endif

    return true;
}

bool SecHdmi::m_setHdmiOutputMode(int hdmiOutputMode)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

    if (hdmiOutputMode == mCurrentHdmiOutputMode) {
#ifdef DEBUG_HDMI_HW_LEVEL
        ALOGD("%s::same hdmiOutputMode(%d) \n", __func__, hdmiOutputMode);
#endif
        return true;
    }

#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("### %s called\n", __func__);
#endif

    int v4l2OutputType = hdmi_outputmode_2_v4l2_output_type(hdmiOutputMode);
    if (v4l2OutputType < 0) {
        ALOGE("%s::hdmi_outputmode_2_v4l2_output_type(%d) fail\n", __func__, hdmiOutputMode);
        return false;
    }

    output_type = v4l2OutputType;

    mCurrentHdmiOutputMode = hdmiOutputMode;

    return true;
}

bool SecHdmi::m_setCompositeResolution(unsigned int compositeStdId)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("### %s called\n", __func__);
#endif

    int w = 0;
    int h = 0;

    if (mHdmiOutputMode != COMPOSITE_OUTPUT_MODE) {
        ALOGE("%s:: not supported output type \n", __func__);
        return false;
    }

    switch (compositeStdId) {
    case COMPOSITE_STD_NTSC_M:
    case COMPOSITE_STD_NTSC_443:
        w = 704;
        h = 480;
        break;
    case COMPOSITE_STD_PAL_BDGHI:
    case COMPOSITE_STD_PAL_M:
    case COMPOSITE_STD_PAL_N:
    case COMPOSITE_STD_PAL_Nc:
    case COMPOSITE_STD_PAL_60:
        w = 704;
        h = 576;
        break;
    default:
        ALOGE("%s::unmathced composite_std(%d)", __func__, compositeStdId);
        return false;
    }

    t_std_id      = composite_std_2_v4l2_std_id(mCompositeStd);

    mHdmiDstWidth  = w;
    mHdmiDstHeight = h;

    mCurrentHdmiResolutionValue = -1;
    return true;
}

bool SecHdmi::m_setHdmiResolution(unsigned int hdmiResolutionValue)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

    if (hdmiResolutionValue == mCurrentHdmiResolutionValue) {
#ifdef DEBUG_HDMI_HW_LEVEL
        ALOGD("%s::same hdmiResolutionValue(%d) \n", __func__, hdmiResolutionValue);
#endif
        return true;
    }

#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("### %s called\n", __func__);
#endif

    int w = 0;
    int h = 0;

#if defined(BOARD_USE_V4L2)
    unsigned int preset_id;
#else
    v4l2_std_id std_id;
#endif

    if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
        mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
#if defined(BOARD_USE_V4L2)
        if (hdmi_resolution_2_preset_id(hdmiResolutionValue, &w, &h, &preset_id) < 0) {
            ALOGE("%s::hdmi_resolution_2_std_id(%d) fail\n", __func__, hdmiResolutionValue);
            return false;
        }
        mHdmiPresetId    = preset_id;
#else
        if (hdmi_resolution_2_std_id(hdmiResolutionValue, &w, &h, &std_id) < 0) {
            ALOGE("%s::hdmi_resolution_2_std_id(%d) fail\n", __func__, hdmiResolutionValue);
            return false;
        }
        mHdmiStdId    = std_id;
#endif
    } else {
        ALOGE("%s:: not supported output type \n", __func__);
        return false;
    }

#if defined(BOARD_USE_V4L2)
    g_preset_id   = preset_id;
#else
    t_std_id      = std_id;
#endif

    mHdmiDstWidth  = w;
    mHdmiDstHeight = h;

    mCurrentHdmiResolutionValue = hdmiResolutionValue;

#ifdef DEBUG_HDMI_HW_LEVEL
#if defined(BOARD_USE_V4L2)
        ALOGD("%s:: mHdmiDstWidth = %d, mHdmiDstHeight = %d, mHdmiPresetId = 0x%x, hdmiResolutionValue = 0x%x\n",
                __func__,
                mHdmiDstWidth,
                mHdmiDstHeight,
                mHdmiPresetId,
                hdmiResolutionValue);
#else
        ALOGD("%s:: mHdmiDstWidth = %d, mHdmiDstHeight = %d, mHdmiStdId = 0x%x, hdmiResolutionValue = 0x%x\n",
                __func__,
                mHdmiDstWidth,
                mHdmiDstHeight,
                mHdmiStdId,
                hdmiResolutionValue);
#endif
#endif

    return true;
}

bool SecHdmi::m_setHdcpMode(bool hdcpMode)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

    if (hdcpMode == mCurrentHdcpMode) {
#ifdef DEBUG_HDMI_HW_LEVEL
        ALOGD("%s::same hdcpMode(%d) \n", __func__, hdcpMode);
#endif

        return true;
    }

#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("### %s called\n", __func__);
#endif

    if (hdcpMode == true)
        g_hdcp_en = 1;
    else
        g_hdcp_en = 0;

    mCurrentHdcpMode = hdcpMode;

    return true;
}

bool SecHdmi::m_setAudioMode(int audioMode)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

    if (audioMode == mCurrentAudioMode) {
#ifdef DEBUG_HDMI_HW_LEVEL
        ALOGD("%s::same audioMode(%d) \n", __func__, audioMode);
#endif
        return true;
    }

#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("### %s called\n", __func__);
#endif

    if (hdmi_check_audio() < 0) {
        ALOGE("%s::hdmi_check_audio() fail \n", __func__);
        return false;
    }

    mCurrentAudioMode = audioMode;

    return true;
}

int SecHdmi::m_resolutionValueIndex(unsigned int ResolutionValue)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

    int index = -1;

    for (int i = 0; i < mHdmiSizeOfResolutionValueList; i++) {
        if (mHdmiResolutionValueList[i] == ResolutionValue) {
            index = i;
            break;
        }
    }
    return index;
}

bool SecHdmi::m_flagHWConnected(void)
{
#ifdef DEBUG_MSG_ENABLE
    ALOGD("%s", __func__);
#endif

#ifdef DEBUG_HDMI_HW_LEVEL
    ALOGD("### %s called\n", __func__);
#endif

    bool ret = true;
    int hdmiStatus = hdmi_cable_status();

    if (hdmiStatus <= 0) {
#ifdef DEBUG_HDMI_HW_LEVEL
            ALOGD("%s::hdmi_cable_status() fail \n", __func__);
#endif
        ret = false;
    } else {
        ret = true;
    }

    return ret;
}

}; // namespace android