908 lines
31 KiB
C++
908 lines
31 KiB
C++
/*
|
|
* Copyright (C) 2010 The Android Open Source Project
|
|
* Copyright (C) 2012-2016, 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::getPluggableNode();
|
|
|
|
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 = %zd",
|
|
__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 = %zd",
|
|
__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];
|
|
edidMode = mEDIDModes[configIndex];
|
|
|
|
if (!isValidMode(edidMode)) {
|
|
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=%zu 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 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) {
|
|
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 (%zu)", __FUNCTION__, *numConfigs);
|
|
return -EINVAL;
|
|
}
|
|
*numConfigs = mModeCount;
|
|
for (int configIndex = 0; configIndex < mModeCount; configIndex++) {
|
|
configs[configIndex] = (uint32_t)configIndex;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
};
|