libhdmi/hdmi.cpp

/*
 * Copyright (C) 2010 The Android Open Source Project
 * Copyright (C) 2012-2015, The Linux Foundation. All rights reserved.
 *
 * Not a Contribution, Apache license notifications and license are
 * retained for attribution purposes only.
 *
 * 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 DEBUG 0
#include <fcntl.h>
#include <linux/msm_mdp.h>
#include <linux/fb.h>
#include <sys/ioctl.h>
#include <cutils/properties.h>
#include "hwc_utils.h"
#include "hdmi.h"
#include "overlayUtils.h"
#include "overlay.h"
#include "qd_utils.h"

using namespace android;
using namespace qdutils;

namespace qhwc {
#define UNKNOWN_STRING                  "unknown"
#define SPD_NAME_LENGTH                 16

int HDMIDisplay::configure() {
    if(!openFrameBuffer()) {
        ALOGE("%s: Failed to open FB: %d", __FUNCTION__, mFbNum);
        return -1;
    }
    readCEUnderscanInfo();
    readResolution();
    /* Used for changing the resolution
     * getUserConfig will get the preferred
     * config index set thru adb shell */
    mActiveConfig = getUserConfig();
    if (mActiveConfig == -1) {
        //Get the best mode and set
        mActiveConfig = getBestConfig();
    }

    // Read the system property to determine if downscale feature is enabled.
    char value[PROPERTY_VALUE_MAX];
    mMDPDownscaleEnabled = false;
    if(property_get("sys.hwc.mdp_downscale_enabled", value, "false")
            && !strcmp(value, "true")) {
        mMDPDownscaleEnabled = true;
    }

    // Set the mode corresponding to the active index
    mCurrentMode = mEDIDModes[mActiveConfig];
    setAttributes();
    // set system property
    property_set("hw.hdmiON", "1");

    // XXX: A debug property can be used to enable resolution change for
    // testing purposes: debug.hwc.enable_resolution_change
    mEnableResolutionChange = false;
    if(property_get("debug.hwc.enable_resolution_change", value, "false")
            && !strcmp(value, "true")) {
        mEnableResolutionChange = true;
    }
    return 0;
}

void HDMIDisplay::getAttributes(uint32_t& width, uint32_t& height) {
    uint32_t refresh = 0, fps = 0;
    getAttrForConfig(mActiveConfig, width, height, refresh, fps);
}

int HDMIDisplay::teardown() {
    closeFrameBuffer();
    resetInfo();
    // unset system property
    property_set("hw.hdmiON", "0");
    return 0;
}

HDMIDisplay::HDMIDisplay():mFd(-1),
    mCurrentMode(-1), mModeCount(0), mPrimaryWidth(0), mPrimaryHeight(0),
    mUnderscanSupported(false), mMDPDownscaleEnabled(false)
{
    memset(&mVInfo, 0, sizeof(mVInfo));
    mFbNum = qdutils::getHDMINode();

    mDisplayId = HWC_DISPLAY_EXTERNAL;
    // Update the display if HDMI is connected as primary
    if (isHDMIPrimaryDisplay()) {
        mDisplayId = HWC_DISPLAY_PRIMARY;
    }

    // Disable HPD at start if HDMI is external, it will be enabled later
    // when the display powers on
    // This helps for framework reboot or adb shell stop/start
    if (mDisplayId) {
        writeHPDOption(0);
    }

    if(mFbNum != -1) {
        // Update the Source Product Information
        // Vendor Name
        setSPDInfo("vendor_name", "ro.product.manufacturer");
        // Product Description
        setSPDInfo("product_description", "ro.product.name");
    }

    ALOGD_IF(DEBUG, "%s mDisplayId(%d) mFbNum(%d)",
            __FUNCTION__, mDisplayId, mFbNum);
}
/* gets the product manufacturer and product name and writes it
 * to the sysfs node, so that the driver can get that information
 * Used to show QCOM 8974 instead of Input 1 for example
 */
void HDMIDisplay::setSPDInfo(const char* node, const char* property) {
    char info[PROPERTY_VALUE_MAX];
    ssize_t err = -1;
    int spdFile = openDeviceNode(node, O_RDWR);
    if (spdFile >= 0) {
        memset(info, 0, sizeof(info));
        property_get(property, info, UNKNOWN_STRING);
        ALOGD_IF(DEBUG, "In %s: %s = %s",
                __FUNCTION__, property, info);
        if (strncmp(info, UNKNOWN_STRING, SPD_NAME_LENGTH)) {
            err = write(spdFile, info, strlen(info));
            if (err <= 0) {
                ALOGE("%s: file write failed for '%s'"
                      "err no = %d", __FUNCTION__, node, errno);
            }
        } else {
            ALOGD_IF(DEBUG, "%s: property_get failed for SPD %s",
                         __FUNCTION__, node);
        }
        close(spdFile);
    }
}

void HDMIDisplay::setHPD(uint32_t value) {
    ALOGD_IF(DEBUG,"HPD enabled=%d", value);
    writeHPDOption(value);
}

void HDMIDisplay::setActionSafeDimension(int w, int h) {
    ALOGD_IF(DEBUG,"ActionSafe w=%d h=%d", w, h);
    char actionsafeWidth[PROPERTY_VALUE_MAX];
    char actionsafeHeight[PROPERTY_VALUE_MAX];
    snprintf(actionsafeWidth, sizeof(actionsafeWidth), "%d", w);
    property_set("persist.sys.actionsafe.width", actionsafeWidth);
    snprintf(actionsafeHeight, sizeof(actionsafeHeight), "%d", h);
    property_set("persist.sys.actionsafe.height", actionsafeHeight);
}

int HDMIDisplay::getModeCount() const {
    ALOGD_IF(DEBUG,"HPD mModeCount=%d", mModeCount);
    return mModeCount;
}

void HDMIDisplay::readCEUnderscanInfo()
{
    int hdmiScanInfoFile = -1;
    ssize_t len = -1;
    char scanInfo[17];
    char *ce_info_str = NULL;
    char *save_ptr;
    const char token[] = ", \n";
    int ce_info = -1;

    memset(scanInfo, 0, sizeof(scanInfo));
    hdmiScanInfoFile = openDeviceNode("scan_info", O_RDONLY);
    if (hdmiScanInfoFile < 0) {
        return;
    } else {
        len = read(hdmiScanInfoFile, scanInfo, sizeof(scanInfo)-1);
        ALOGD("%s: Scan Info string: %s length = %zu",
                 __FUNCTION__, scanInfo, len);
        if (len <= 0) {
            close(hdmiScanInfoFile);
            ALOGE("%s: Scan Info file empty", __FUNCTION__);
            return;
        }
        scanInfo[len] = '\0';  /* null terminate the string */
        close(hdmiScanInfoFile);
    }

    /*
     * The scan_info contains the three fields
     * PT - preferred video format
     * IT - video format
     * CE video format - containing the underscan support information
     */

    /* PT */
    ce_info_str = strtok_r(scanInfo, token, &save_ptr);
    if (ce_info_str) {
        /* IT */
        ce_info_str = strtok_r(NULL, token, &save_ptr);
        if (ce_info_str) {
            /* CE */
            ce_info_str = strtok_r(NULL, token, &save_ptr);
            if (ce_info_str)
                ce_info = atoi(ce_info_str);
        }
    }

    if (ce_info_str) {
        // ce_info contains the underscan information
        if (ce_info == HDMI_SCAN_ALWAYS_UNDERSCANED ||
            ce_info == HDMI_SCAN_BOTH_SUPPORTED)
            // if TV supported underscan, then driver will always underscan
            // hence no need to apply action safe rectangle
            mUnderscanSupported = true;
    } else {
        ALOGE("%s: scan_info string error", __FUNCTION__);
    }

    // Store underscan support info in a system property
    const char* prop = (mUnderscanSupported) ? "1" : "0";
    property_set("hw.underscan_supported", prop);
    return;
}

HDMIDisplay::~HDMIDisplay()
{
    closeFrameBuffer();
}

/*
 * sets the fb_var_screeninfo from the hdmi_mode_timing_info
 */
void setDisplayTiming(struct fb_var_screeninfo &info,
                                const msm_hdmi_mode_timing_info* mode)
{
    info.reserved[0] = 0;
    info.reserved[1] = 0;
    info.reserved[2] = 0;
#ifndef FB_METADATA_VIDEO_INFO_CODE_SUPPORT
    info.reserved[3] = (info.reserved[3] & 0xFFFF) |
              (mode->video_format << 16);
#endif
    info.xoffset = 0;
    info.yoffset = 0;
    info.xres = mode->active_h;
    info.yres = mode->active_v;

    info.pixclock = (mode->pixel_freq)*1000;
    info.vmode = mode->interlaced ?
                    FB_VMODE_INTERLACED : FB_VMODE_NONINTERLACED;

    info.right_margin = mode->front_porch_h;
    info.hsync_len = mode->pulse_width_h;
    info.left_margin = mode->back_porch_h;
    info.lower_margin = mode->front_porch_v;
    info.vsync_len = mode->pulse_width_v;
    info.upper_margin = mode->back_porch_v;
}

int HDMIDisplay::parseResolution(char* edidStr)
{
    char delim = ',';
    int count = 0;
    char *start, *end;
    // EDIDs are string delimited by ','
    // Ex: 16,4,5,3,32,34,1
    // Parse this string to get mode(int)
    start = (char*) edidStr;
    end = &delim;
    while(*end == delim) {
        mEDIDModes[count] = (int) strtol(start, &end, 10);
        start = end+1;
        count++;
    }
    ALOGD_IF(DEBUG, "In %s: count = %d", __FUNCTION__, count);
    for (int i = 0; i < count; i++)
        ALOGD_IF(DEBUG, "Mode[%d] = %d", i, mEDIDModes[i]);
    return count;
}

bool HDMIDisplay::readResolution()
{
    ssize_t len = -1;
    char edidStr[PAGE_SIZE] = {'\0'};

    int hdmiEDIDFile = openDeviceNode("edid_modes", O_RDONLY);
    if (hdmiEDIDFile < 0) {
        return false;
    } else {
        len = read(hdmiEDIDFile, edidStr, sizeof(edidStr)-1);
        ALOGD_IF(DEBUG, "%s: EDID string: %s length = %zu",
                 __FUNCTION__, edidStr, len);
        if (len <= 0) {
            ALOGE("%s: edid_modes file empty", __FUNCTION__);
            edidStr[0] = '\0';
        }
        else {
            while (len > 1 && isspace(edidStr[len-1])) {
                --len;
            }
            edidStr[len] = '\0';
        }
        close(hdmiEDIDFile);
    }
    if(len > 0) {
        // Get EDID modes from the EDID strings
        mModeCount = parseResolution(edidStr);
        ALOGD_IF(DEBUG, "%s: mModeCount = %d", __FUNCTION__,
                 mModeCount);
    }
    // Populate the internal data structure with the timing information
    // for each edid mode read from the driver
    if (mModeCount > 0) {
        mDisplayConfigs = new msm_hdmi_mode_timing_info[mModeCount];
        readConfigs();
    } else {
        // If we fail to read from EDID when HDMI is connected, then
        // mModeCount will be 0 and bestConfigIndex will be invalid.
        // In this case, we populate the mEDIDModes structure with
        // a default mode at config index 0.
        uint32_t defaultConfigIndex = 0;
        mModeCount = 1;
        mEDIDModes[defaultConfigIndex] = HDMI_VFRMT_640x480p60_4_3;
        struct msm_hdmi_mode_timing_info defaultMode =
                HDMI_VFRMT_640x480p60_4_3_TIMING;
        mDisplayConfigs = new msm_hdmi_mode_timing_info[mModeCount];
        mDisplayConfigs[defaultConfigIndex] = defaultMode;
        ALOGD("%s Defaulting to HDMI_VFRMT_640x480p60_4_3", __FUNCTION__);
    }

    return (len > 0);
}

bool HDMIDisplay::openFrameBuffer()
{
    if (mFd == -1) {
        char strDevPath[MAX_SYSFS_FILE_PATH];
        snprintf(strDevPath, MAX_SYSFS_FILE_PATH, "/dev/graphics/fb%d", mFbNum);
        mFd = open(strDevPath, O_RDWR);
        if (mFd < 0)
            ALOGE("%s: %s is not available", __FUNCTION__, strDevPath);
    }
    return (mFd > 0);
}

bool HDMIDisplay::closeFrameBuffer()
{
    int ret = 0;
    if(mFd >= 0) {
        ret = close(mFd);
        mFd = -1;
    }
    return (ret == 0);
}

// clears the vinfo, edid, best modes
void HDMIDisplay::resetInfo()
{
    memset(&mVInfo, 0, sizeof(mVInfo));
    memset(mEDIDModes, 0, sizeof(mEDIDModes));
    mModeCount = 0;
    mCurrentMode = -1;
    mUnderscanSupported = false;
    mXres = 0;
    mYres = 0;
    mVsyncPeriod = 0;
    mMDPScalingMode = false;
    if (mDisplayConfigs) {
        delete [] mDisplayConfigs;
        mDisplayConfigs = 0;
    }
    // Reset the underscan supported system property
    const char* prop = "0";
    property_set("hw.underscan_supported", prop);
}

/// Returns the index of the user mode set(if any) using adb shell
int HDMIDisplay::getUserConfig() {
    /* Based on the property set the resolution */
    char property_value[PROPERTY_VALUE_MAX];
    property_get("hw.hdmi.resolution", property_value, "-1");
    int mode = atoi(property_value);
    if(isValidMode(mode)) {
        ALOGD_IF(DEBUG, "%s: setting the HDMI mode = %d", __FUNCTION__, mode);
        return getModeIndex(mode);
    }
    return -1;
}

// Get the index of the best mode for the current HD TV
int HDMIDisplay::getBestConfig() {
    int bestConfigIndex = 0;
    int edidMode = -1;
    struct msm_hdmi_mode_timing_info currentModeInfo = {0};
    struct msm_hdmi_mode_timing_info bestModeInfo = {0};
    bestModeInfo.video_format = 0;
    bestModeInfo.active_v = 0;
    bestModeInfo.active_h = 0;
    bestModeInfo.refresh_rate = 0;
    bestModeInfo.ar = HDMI_RES_AR_INVALID;

    // for all the timing info read, get the best config
    for (int configIndex = 0; configIndex < mModeCount; configIndex++) {
        currentModeInfo = mDisplayConfigs[configIndex];

        if (!currentModeInfo.supported) {
            ALOGD("%s EDID Mode %d is not supported", __FUNCTION__, edidMode);
            continue;
        }

        ALOGD_IF(DEBUG, "%s Best (%d) : (%dx%d) @ %d;"
                " Current (%d) (%dx%d) @ %d",
                __FUNCTION__, bestConfigIndex, bestModeInfo.active_h,
                bestModeInfo.active_v, bestModeInfo.refresh_rate, configIndex,
                currentModeInfo.active_h, currentModeInfo.active_v,
                currentModeInfo.refresh_rate);

        // Compare two HDMI modes in order of height, width, refresh rate and
        // aspect ratio.
        if (currentModeInfo.active_v > bestModeInfo.active_v) {
            bestConfigIndex = configIndex;
        } else if (currentModeInfo.active_v == bestModeInfo.active_v) {
            if (currentModeInfo.active_h > bestModeInfo.active_h) {
                bestConfigIndex = configIndex;
            } else if (currentModeInfo.active_h == bestModeInfo.active_h) {
                if (currentModeInfo.refresh_rate > bestModeInfo.refresh_rate) {
                    bestConfigIndex = configIndex;
                } else if (currentModeInfo.refresh_rate ==
                        bestModeInfo.refresh_rate) {
                    if (currentModeInfo.ar > bestModeInfo.ar) {
                        bestConfigIndex = configIndex;
                    }
                }
            }
        }
        if (bestConfigIndex == configIndex) {
            bestModeInfo = mDisplayConfigs[bestConfigIndex];
        }
    }
    return bestConfigIndex;
}

// Utility function used to request HDMI driver to write a new page of timing
// info into res_info node
void HDMIDisplay::requestNewPage(int pageNumber) {
    char pageString[PAGE_SIZE];
    int fd = openDeviceNode("res_info", O_WRONLY);
    if (fd >= 0) {
        snprintf(pageString, sizeof(pageString), "%d", pageNumber);
        ALOGD_IF(DEBUG, "%s: page=%s", __FUNCTION__, pageString);
        ssize_t err = write(fd, pageString, sizeof(pageString));
        if (err <= 0) {
            ALOGE("%s: Write to res_info failed (%d)", __FUNCTION__, errno);
        }
        close(fd);
    }
}

// Reads the contents of res_info node into a buffer if the file is not empty
bool HDMIDisplay::readResFile(char * configBuffer) {
    bool fileRead = false;
    size_t bytesRead = 0;
    int fd = openDeviceNode("res_info", O_RDONLY);
    if (fd >= 0 && (bytesRead = read(fd, configBuffer, PAGE_SIZE)) != 0) {
        fileRead = true;
    }
    close(fd);
    ALOGD_IF(DEBUG, "%s: bytesRead=%d fileRead=%d",
            __FUNCTION__, bytesRead, fileRead);
    return fileRead;
}

// Populates the internal timing info structure with the timing info obtained
// from the HDMI driver
void HDMIDisplay::readConfigs() {
    int configIndex = 0;
    int pageNumber = MSM_HDMI_INIT_RES_PAGE;
    long unsigned int size = sizeof(msm_hdmi_mode_timing_info);

    while (true) {
        char configBuffer[PAGE_SIZE] = {0};
        msm_hdmi_mode_timing_info *info =
                (msm_hdmi_mode_timing_info*) configBuffer;

        if (!readResFile(configBuffer))
            break;

        while (info->video_format && size < PAGE_SIZE) {
            mDisplayConfigs[configIndex] = *info;
            size += sizeof(msm_hdmi_mode_timing_info);
            info++;
            ALOGD_IF(DEBUG, "%s: Config=%d Mode %d: (%dx%d) @ %d",
                    __FUNCTION__, configIndex,
                    mDisplayConfigs[configIndex].video_format,
                    mDisplayConfigs[configIndex].active_h,
                    mDisplayConfigs[configIndex].active_v,
                    mDisplayConfigs[configIndex].refresh_rate);
            configIndex++;
        }
        size = sizeof(msm_hdmi_mode_timing_info);
        // Request HDMI driver to populate res_info with more
        // timing information
        pageNumber++;
        requestNewPage(pageNumber);
    }
}

inline bool HDMIDisplay::isValidMode(int ID)
{
    bool valid = false;
    int modeIndex = getModeIndex(ID);
    if (ID <= 0 || modeIndex < 0 || modeIndex > mModeCount) {
        return false;
    }
    struct msm_hdmi_mode_timing_info* mode = &mDisplayConfigs[modeIndex];
    // We dont support interlaced modes
    if (mode->supported && !mode->interlaced) {
        valid = true;
    }
    return valid;
}

// Does a put_vscreen info on the HDMI interface which will update
// the configuration (resolution, timing info) to match mCurrentMode
void HDMIDisplay::activateDisplay()
{
    int ret = 0;
    ret = ioctl(mFd, FBIOGET_VSCREENINFO, &mVInfo);
    if(ret < 0) {
        ALOGD("In %s: FBIOGET_VSCREENINFO failed Err Str = %s", __FUNCTION__,
                                                            strerror(errno));
    }
    ALOGD_IF(DEBUG, "%s: GET Info<ID=%d %dx%d (%d,%d,%d),"
            "(%d,%d,%d) %dMHz>", __FUNCTION__,
            mVInfo.reserved[3], mVInfo.xres, mVInfo.yres,
            mVInfo.right_margin, mVInfo.hsync_len, mVInfo.left_margin,
            mVInfo.lower_margin, mVInfo.vsync_len, mVInfo.upper_margin,
            mVInfo.pixclock/1000/1000);

    struct msm_hdmi_mode_timing_info *mode = &mDisplayConfigs[mActiveConfig];
    setDisplayTiming(mVInfo, mode);
    ALOGD_IF(DEBUG, "%s: SET Info<ID=%d => Info<ID=%d %dx %d"
            "(%d,%d,%d), (%d,%d,%d) %dMHz>", __FUNCTION__, mCurrentMode,
            mode->video_format, mVInfo.xres, mVInfo.yres,
            mVInfo.right_margin, mVInfo.hsync_len, mVInfo.left_margin,
            mVInfo.lower_margin, mVInfo.vsync_len, mVInfo.upper_margin,
            mVInfo.pixclock/1000/1000);
#ifdef FB_METADATA_VIDEO_INFO_CODE_SUPPORT
    struct msmfb_metadata metadata;
    memset(&metadata, 0 , sizeof(metadata));
    metadata.op = metadata_op_vic;
    metadata.data.video_info_code = mode->video_format;
    if (ioctl(mFd, MSMFB_METADATA_SET, &metadata) == -1) {
        ALOGD("In %s: MSMFB_METADATA_SET failed Err Str = %s",
                __FUNCTION__, strerror(errno));
    }
#endif
    mVInfo.activate = FB_ACTIVATE_NOW | FB_ACTIVATE_ALL | FB_ACTIVATE_FORCE;
    ret = ioctl(mFd, FBIOPUT_VSCREENINFO, &mVInfo);
    if(ret < 0) {
        ALOGD("In %s: FBIOPUT_VSCREENINFO failed Err Str = %s",
                __FUNCTION__, strerror(errno));
    }
}

bool HDMIDisplay::writeHPDOption(int userOption) const
{
    bool ret = true;
    if(mFbNum != -1) {
        int hdmiHPDFile = openDeviceNode("hpd", O_RDWR);
        if (hdmiHPDFile >= 0) {
            ssize_t err = -1;
            ALOGD_IF(DEBUG, "%s: option = %d",
                    __FUNCTION__, userOption);
            if(userOption)
                err = write(hdmiHPDFile, "1", 2);
            else
                err = write(hdmiHPDFile, "0" , 2);
            if (err <= 0) {
                ALOGE("%s: file write failed 'hpd'", __FUNCTION__);
                ret = false;
            }
            close(hdmiHPDFile);
        }
    }
    return ret;
}


void HDMIDisplay::setAttributes() {
    uint32_t refresh = 0, fps = 0;
    // Always set dpyAttr res to mVInfo res
    getAttrForConfig(mActiveConfig, mXres, mYres, refresh, fps);
    mMDPScalingMode = false;

    if(overlay::Overlay::getInstance()->isUIScalingOnExternalSupported()
        && mMDPDownscaleEnabled) {
        // if primary resolution is more than the hdmi resolution
        // configure dpy attr to primary resolution and set MDP
        // scaling mode
        // Restrict this upto 1080p resolution max, if target does not
        // support source split feature.
        uint32_t primaryArea = mPrimaryWidth * mPrimaryHeight;
        if(((primaryArea) > (mXres * mYres)) &&
            (((primaryArea) <= SUPPORTED_DOWNSCALE_AREA) ||
                qdutils::MDPVersion::getInstance().isSrcSplit())) {
            // tmpW and tmpH will hold the primary dimensions before we
            // update the aspect ratio if necessary.
            int tmpW = mPrimaryWidth;
            int tmpH = mPrimaryHeight;
            // HDMI is always in landscape, so always assign the higher
            // dimension to hdmi's xres
            if(mPrimaryHeight > mPrimaryWidth) {
                tmpW = mPrimaryHeight;
                tmpH = mPrimaryWidth;
            }
            // The aspect ratios of the external and primary displays
            // can be different. As a result, directly assigning primary
            // resolution could lead to an incorrect final image.
            // We get around this by calculating a new resolution by
            // keeping aspect ratio intact.
            hwc_rect r = {0, 0, 0, 0};
            qdutils::getAspectRatioPosition(tmpW, tmpH, mXres, mYres, r);
            uint32_t newExtW = r.right - r.left;
            uint32_t newExtH = r.bottom - r.top;
            uint32_t alignedExtW;
            uint32_t alignedExtH;
            // On 8994 and below targets MDP supports only 4X downscaling,
            // Restricting selected external resolution to be exactly 4X
            // greater resolution than actual external resolution
            uint32_t maxMDPDownScale =
                    qdutils::MDPVersion::getInstance().getMaxMDPDownscale();
            if((mXres * mYres * maxMDPDownScale) < (newExtW * newExtH)) {
                float upScaleFactor = (float)maxMDPDownScale / 2.0f;
                newExtW = (int)((float)mXres * upScaleFactor);
                newExtH = (int)((float)mYres * upScaleFactor);
            }
            // Align it down so that the new aligned resolution does not
            // exceed the maxMDPDownscale factor
            alignedExtW = overlay::utils::aligndown(newExtW, 4);
            alignedExtH = overlay::utils::aligndown(newExtH, 4);
            mXres = alignedExtW;
            mYres = alignedExtH;
            // Set External Display MDP Downscale mode indicator
            mMDPScalingMode = true;
        }
    }
    ALOGD_IF(DEBUG_MDPDOWNSCALE, "Selected external resolution [%d X %d] "
            "maxMDPDownScale %d mMDPScalingMode %d srcSplitEnabled %d "
            "MDPDownscale feature %d",
            mXres, mYres,
            qdutils::MDPVersion::getInstance().getMaxMDPDownscale(),
            mMDPScalingMode, qdutils::MDPVersion::getInstance().isSrcSplit(),
            mMDPDownscaleEnabled);
    mVsyncPeriod = (int) 1000000000l / fps;
    ALOGD_IF(DEBUG, "%s xres=%d, yres=%d", __FUNCTION__, mXres, mYres);
}

/* returns the fd related to the node specified*/
int HDMIDisplay::openDeviceNode(const char* node, int fileMode) const {
    char sysFsFilePath[MAX_SYSFS_FILE_PATH];
    memset(sysFsFilePath, 0, sizeof(sysFsFilePath));
    snprintf(sysFsFilePath , sizeof(sysFsFilePath),
            "/sys/devices/virtual/graphics/fb%d/%s",
            mFbNum, node);

    int fd = open(sysFsFilePath, fileMode, 0);

    if (fd < 0) {
        ALOGE("%s: file '%s' not found : ret = %d err str: %s",
                __FUNCTION__, sysFsFilePath, fd, strerror(errno));
    }
    return fd;
}

bool HDMIDisplay::isHDMIPrimaryDisplay() {
    return (mFbNum == HWC_DISPLAY_PRIMARY);
}

int HDMIDisplay::getConnectedState() {
    int ret = -1;
    int mFbNum = qdutils::getHDMINode();
    int connectedNode = openDeviceNode("connected", O_RDONLY);
    if(connectedNode >= 0) {
        char opStr[4];
        ssize_t bytesRead = read(connectedNode, opStr, sizeof(opStr) - 1);
        if(bytesRead > 0) {
            opStr[bytesRead] = '\0';
            ret = atoi(opStr);
            ALOGD_IF(DEBUG, "%s: Read %d from connected", __FUNCTION__, ret);
        } else if(bytesRead == 0) {
            ALOGE("%s: HDMI connected node empty", __FUNCTION__);
        } else {
            ALOGE("%s: Read from HDMI connected node failed with error %s",
                    __FUNCTION__, strerror(errno));
        }
        close(connectedNode);
    } else {
        ALOGD("%s: /sys/class/graphics/fb%d/connected could not be opened : %s",
                __FUNCTION__, mFbNum, strerror(errno));
    }
    return ret;
}

void HDMIDisplay::setPrimaryAttributes(uint32_t primaryWidth,
        uint32_t primaryHeight) {
    mPrimaryHeight = primaryHeight;
    mPrimaryWidth = primaryWidth;
}

int HDMIDisplay::setActiveConfig(int newConfig) {
    if(newConfig < 0 || newConfig > mModeCount) {
        ALOGE("%s Invalid configuration %d", __FUNCTION__, newConfig);
        return -EINVAL;
    }

    // XXX: Currently, we only support a change in frame rate.
    // We need to validate the new config before proceeding.
    if (!isValidConfigChange(newConfig)) {
        ALOGE("%s Invalid configuration %d", __FUNCTION__, newConfig);
        return -EINVAL;
    }

    mCurrentMode =  mEDIDModes[newConfig];
    mActiveConfig = newConfig;
    activateDisplay();
    ALOGD("%s config(%d) mode(%d)", __FUNCTION__, mActiveConfig, mCurrentMode);
    return 0;
}

static const char* getS3DStringFromMode(int s3dMode) {
    const char* ret ;
    switch(s3dMode) {
    case HDMI_S3D_NONE:
        ret = "None";
        break;
    case HDMI_S3D_SIDE_BY_SIDE:
        ret = "SSH";
        break;
    case HDMI_S3D_TOP_AND_BOTTOM:
        ret = "TAB";
        break;
    //FP (FramePacked) mode is not supported in the HAL
    default:
        ALOGD("%s: Unsupported s3d mode: %d", __FUNCTION__, s3dMode);
        ret = NULL;
    }
    return ret;
}

bool HDMIDisplay::isS3DModeSupported(int s3dMode) {
    if(s3dMode == HDMI_S3D_NONE)
        return true;

    char s3dEdidStr[PAGE_SIZE] = {'\0'};

    const char *s3dModeString = getS3DStringFromMode(s3dMode);

    if(s3dModeString == NULL)
        return false;

    int s3dEdidNode = openDeviceNode("edid_3d_modes", O_RDONLY);
    if(s3dEdidNode >= 0) {
        ssize_t len = read(s3dEdidNode, s3dEdidStr, sizeof(s3dEdidStr)-1);
        if (len > 0) {
            ALOGI("%s: s3dEdidStr: %s mCurrentMode:%d", __FUNCTION__,
                    s3dEdidStr, mCurrentMode);
            //Three level inception!
            //The string looks like 16=SSH,4=FP:TAB:SSH,5=FP:SSH,32=FP:TAB:SSH
            char *saveptr_l1, *saveptr_l2, *saveptr_l3;
            char *l1, *l2, *l3;
            int mode = 0;
            l1 = strtok_r(s3dEdidStr,",", &saveptr_l1);
            while (l1 != NULL) {
                l2 = strtok_r(l1, "=", &saveptr_l2);
                if (l2 != NULL)
                    mode = atoi(l2);
                while (l2 != NULL) {
                    if (mode != mCurrentMode) {
                        break;
                    }
                    l3 = strtok_r(l2, ":", &saveptr_l3);
                    while (l3 != NULL) {
                        if (strncmp(l3, s3dModeString,
                                    strlen(s3dModeString)) == 0) {
                            close(s3dEdidNode);
                            return true;
                        }
                        l3 = strtok_r(NULL, ":", &saveptr_l3);
                    }
                    l2 = strtok_r(NULL, "=", &saveptr_l2);
                }
                l1 = strtok_r(NULL, ",", &saveptr_l1);
            }

        }
    } else {
        ALOGI("%s: /sys/class/graphics/fb%d/edid_3d_modes could not be opened : %s",
                __FUNCTION__, mFbNum, strerror(errno));
    }
    close(s3dEdidNode);
    return false;
}

bool HDMIDisplay::writeS3DMode(int s3dMode) {
  bool ret = true;
    if(mFbNum != -1) {
        int hdmiS3DModeFile = openDeviceNode("s3d_mode", O_RDWR);
        if(hdmiS3DModeFile >=0 ) {
            char curModeStr[PROPERTY_VALUE_MAX];
            int currentS3DMode = -1;
            size_t len = read(hdmiS3DModeFile, curModeStr, sizeof(curModeStr) - 1);
            if(len > 0) {
                currentS3DMode = atoi(curModeStr);
            } else {
                ret = false;
                ALOGE("%s: Failed to read s3d_mode", __FUNCTION__);
            }

            if (currentS3DMode >=0 && currentS3DMode != s3dMode) {
                ssize_t err = -1;
                ALOGD_IF(DEBUG, "%s: mode = %d",
                        __FUNCTION__, s3dMode);
                char mode[PROPERTY_VALUE_MAX];
                snprintf(mode,sizeof(mode),"%d",s3dMode);
                err = write(hdmiS3DModeFile, mode, sizeof(mode));
                if (err <= 0) {
                    ALOGE("%s: file write failed 's3d_mode'", __FUNCTION__);
                    ret = false;
                }
            }
            close(hdmiS3DModeFile);
        }
    }
    return ret;
}

bool HDMIDisplay::configure3D(int s3dMode) {
    if(isS3DModeSupported(s3dMode)) {
        if(!writeS3DMode(s3dMode))
            return false;
    } else {
        ALOGE("%s: 3D mode: %d is not supported", __FUNCTION__, s3dMode);
        return false;
    }
    return true;
}

// returns false if the xres or yres of the new config do
// not match the current config
bool HDMIDisplay::isValidConfigChange(int newConfig) {
    int newMode = mEDIDModes[newConfig];
    uint32_t width = 0, height = 0, refresh = 0, fps = 0;
    getAttrForConfig(newConfig, width, height, refresh, fps);
    return ((mXres == width) && (mYres == height)) || mEnableResolutionChange;
}

int HDMIDisplay::getModeIndex(int mode) {
    int modeIndex = -1;
    for(int i = 0; i < mModeCount; i++) {
        if(mode == mEDIDModes[i]) {
            modeIndex = i;
            break;
        }
    }
    return modeIndex;
}

int HDMIDisplay::getAttrForConfig(int config, uint32_t& xres,
        uint32_t& yres, uint32_t& refresh, uint32_t& fps) const {
    if(config < 0 || config > mModeCount) {
        ALOGE("%s Invalid configuration %d", __FUNCTION__, config);
        return -EINVAL;
    }

    xres = mDisplayConfigs[config].active_h;
    yres = mDisplayConfigs[config].active_v;
    fps = (mDisplayConfigs[config].refresh_rate / 1000);

    refresh = (uint32_t) 1000000000l / fps;
    ALOGD_IF(DEBUG, "%s xres(%d) yres(%d) fps(%d) refresh(%d)", __FUNCTION__,
            xres, yres, fps, refresh);
    return 0;
}

int HDMIDisplay::getDisplayConfigs(uint32_t* configs,
        size_t* numConfigs) const {
    if (*numConfigs <= 0) {
        ALOGE("%s Invalid number of configs (%d)", __FUNCTION__, *numConfigs);
        return -EINVAL;
    }
    *numConfigs = mModeCount;
    for (int configIndex = 0; configIndex < mModeCount; configIndex++) {
        configs[configIndex] = (uint32_t)configIndex;
    }
    return 0;
}

};