display: Create QService binder interface.
Add QService binder interface to enable communication
to display by the mediaserver for Securing/Unsecuring start and end
notifications.
Create separate lib for external.
Clear reserved field before applying format.
Change-Id: I463c9c6deac7587bd0c4e0b84513b5d0b5dd7e98
diff --git a/libexternal/external.cpp b/libexternal/external.cpp
new file mode 100644
index 0000000..2142125
--- /dev/null
+++ b/libexternal/external.cpp
@@ -0,0 +1,486 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ * Copyright (C) 2012, 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 <ctype.h>
+#include <fcntl.h>
+#include <media/IAudioPolicyService.h>
+#include <media/AudioSystem.h>
+#include <utils/threads.h>
+#include <utils/Errors.h>
+#include <utils/Log.h>
+
+#include <linux/msm_mdp.h>
+#include <linux/fb.h>
+#include <sys/ioctl.h>
+#include <sys/poll.h>
+#include <sys/resource.h>
+#include <cutils/properties.h>
+#include "hwc_utils.h"
+#include "external.h"
+#include "overlayUtils.h"
+
+using namespace android;
+
+namespace qhwc {
+
+
+#define DEVICE_ROOT "/sys/devices/virtual/graphics"
+#define DEVICE_NODE "fb1"
+
+#define SYSFS_EDID_MODES DEVICE_ROOT "/" DEVICE_NODE "/edid_modes"
+#define SYSFS_HPD DEVICE_ROOT "/" DEVICE_NODE "/hpd"
+
+
+ExternalDisplay::ExternalDisplay(hwc_context_t* ctx):mFd(-1),
+ mCurrentMode(-1), mExternalDisplay(0), mModeCount(0), mHwcContext(ctx)
+{
+ memset(&mVInfo, 0, sizeof(mVInfo));
+ //Enable HPD for HDMI
+ writeHPDOption(1);
+}
+
+void ExternalDisplay::setEDIDMode(int resMode) {
+ ALOGD_IF(DEBUG,"resMode=%d ", resMode);
+ int extDispType;
+ {
+ Mutex::Autolock lock(mExtDispLock);
+ extDispType = mExternalDisplay;
+ setExternalDisplay(0);
+ setResolution(resMode);
+ }
+ setExternalDisplay(extDispType);
+}
+
+void ExternalDisplay::setHPD(uint32_t startEnd) {
+ ALOGD_IF(DEBUG,"HPD enabled=%d", startEnd);
+ writeHPDOption(startEnd);
+}
+
+void ExternalDisplay::setActionSafeDimension(int w, int h) {
+ ALOGD_IF(DEBUG,"ActionSafe w=%d h=%d", w, h);
+ Mutex::Autolock lock(mExtDispLock);
+ overlay::utils::ActionSafe::getInstance()->setDimension(w, h);
+ setExternalDisplay(mExternalDisplay);
+}
+
+int ExternalDisplay::getModeCount() const {
+ ALOGD_IF(DEBUG,"HPD mModeCount=%d", mModeCount);
+ Mutex::Autolock lock(mExtDispLock);
+ return mModeCount;
+}
+
+void ExternalDisplay::getEDIDModes(int *out) const {
+ Mutex::Autolock lock(mExtDispLock);
+ for(int i = 0;i < mModeCount;i++) {
+ out[i] = mEDIDModes[i];
+ }
+}
+
+int ExternalDisplay::getExternalDisplay() const {
+ Mutex::Autolock lock(mExtDispLock);
+ return mExternalDisplay;
+}
+
+ExternalDisplay::~ExternalDisplay()
+{
+ closeFrameBuffer();
+}
+
+struct disp_mode_timing_type {
+ int video_format;
+
+ int active_h;
+ int active_v;
+
+ int front_porch_h;
+ int pulse_width_h;
+ int back_porch_h;
+
+ int front_porch_v;
+ int pulse_width_v;
+ int back_porch_v;
+
+ int pixel_freq;
+ bool interlaced;
+
+ void set_info(struct fb_var_screeninfo &info) const;
+};
+
+void disp_mode_timing_type::set_info(struct fb_var_screeninfo &info) const
+{
+ info.reserved[0] = 0;
+ info.reserved[1] = 0;
+ info.reserved[2] = 0;
+ info.reserved[3] = (info.reserved[3] & 0xFFFF) | (video_format << 16);
+
+ info.xoffset = 0;
+ info.yoffset = 0;
+ info.xres = active_h;
+ info.yres = active_v;
+
+ info.pixclock = pixel_freq*1000;
+ info.vmode = interlaced ? FB_VMODE_INTERLACED : FB_VMODE_NONINTERLACED;
+
+ info.right_margin = front_porch_h;
+ info.hsync_len = pulse_width_h;
+ info.left_margin = back_porch_h;
+ info.lower_margin = front_porch_v;
+ info.vsync_len = pulse_width_v;
+ info.upper_margin = back_porch_v;
+}
+
+/* Video formates supported by the HDMI Standard */
+/* Indicates the resolution, pix clock and the aspect ratio */
+#define m640x480p60_4_3 1
+#define m720x480p60_4_3 2
+#define m720x480p60_16_9 3
+#define m1280x720p60_16_9 4
+#define m1920x1080i60_16_9 5
+#define m1440x480i60_4_3 6
+#define m1440x480i60_16_9 7
+#define m1920x1080p60_16_9 16
+#define m720x576p50_4_3 17
+#define m720x576p50_16_9 18
+#define m1280x720p50_16_9 19
+#define m1440x576i50_4_3 21
+#define m1440x576i50_16_9 22
+#define m1920x1080p50_16_9 31
+#define m1920x1080p24_16_9 32
+#define m1920x1080p25_16_9 33
+#define m1920x1080p30_16_9 34
+
+static struct disp_mode_timing_type supported_video_mode_lut[] = {
+ {m640x480p60_4_3, 640, 480, 16, 96, 48, 10, 2, 33, 25200, false},
+ {m720x480p60_4_3, 720, 480, 16, 62, 60, 9, 6, 30, 27030, false},
+ {m720x480p60_16_9, 720, 480, 16, 62, 60, 9, 6, 30, 27030, false},
+ {m1280x720p60_16_9, 1280, 720, 110, 40, 220, 5, 5, 20, 74250, false},
+ {m1920x1080i60_16_9, 1920, 540, 88, 44, 148, 2, 5, 5, 74250, false},
+ {m1440x480i60_4_3, 1440, 240, 38, 124, 114, 4, 3, 15, 27000, true},
+ {m1440x480i60_16_9, 1440, 240, 38, 124, 114, 4, 3, 15, 27000, true},
+ {m1920x1080p60_16_9, 1920, 1080, 88, 44, 148, 4, 5, 36, 148500, false},
+ {m720x576p50_4_3, 720, 576, 12, 64, 68, 5, 5, 39, 27000, false},
+ {m720x576p50_16_9, 720, 576, 12, 64, 68, 5, 5, 39, 27000, false},
+ {m1280x720p50_16_9, 1280, 720, 440, 40, 220, 5, 5, 20, 74250, false},
+ {m1440x576i50_4_3, 1440, 288, 24, 126, 138, 2, 3, 19, 27000, true},
+ {m1440x576i50_16_9, 1440, 288, 24, 126, 138, 2, 3, 19, 27000, true},
+ {m1920x1080p50_16_9, 1920, 1080, 528, 44, 148, 4, 5, 36, 148500, false},
+ {m1920x1080p24_16_9, 1920, 1080, 638, 44, 148, 4, 5, 36, 74250, false},
+ {m1920x1080p25_16_9, 1920, 1080, 528, 44, 148, 4, 5, 36, 74250, false},
+ {m1920x1080p30_16_9, 1920, 1080, 88, 44, 148, 4, 5, 36, 74250, false},
+};
+
+int ExternalDisplay::parseResolution(char* edidStr, int* edidModes)
+{
+ 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) {
+ edidModes[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, edidModes[i]);
+ return count;
+}
+
+bool ExternalDisplay::readResolution()
+{
+ int hdmiEDIDFile = open(SYSFS_EDID_MODES, O_RDONLY, 0);
+ int len = -1;
+
+ if (hdmiEDIDFile < 0) {
+ ALOGE("%s: edid_modes file '%s' not found",
+ __FUNCTION__, SYSFS_EDID_MODES);
+ return false;
+ } else {
+ len = read(hdmiEDIDFile, mEDIDs, sizeof(mEDIDs)-1);
+ ALOGD_IF(DEBUG, "%s: EDID string: %s length = %d",
+ __FUNCTION__, mEDIDs, len);
+ if ( len <= 0) {
+ ALOGE("%s: edid_modes file empty '%s'",
+ __FUNCTION__, SYSFS_EDID_MODES);
+ }
+ else {
+ while (len > 1 && isspace(mEDIDs[len-1]))
+ --len;
+ mEDIDs[len] = 0;
+ }
+ }
+ close(hdmiEDIDFile);
+ if(len > 0) {
+ // GEt EDID modes from the EDID strings
+ mModeCount = parseResolution(mEDIDs, mEDIDModes);
+ ALOGD_IF(DEBUG, "%s: mModeCount = %d", __FUNCTION__,
+ mModeCount);
+ }
+
+ return (strlen(mEDIDs) > 0);
+}
+
+bool ExternalDisplay::openFramebuffer()
+{
+ if (mFd == -1) {
+ mFd = open("/dev/graphics/fb1", O_RDWR);
+ if (mFd < 0)
+ ALOGE("%s: /dev/graphics/fb1 not available", __FUNCTION__);
+ }
+ return (mFd > 0);
+}
+
+bool ExternalDisplay::closeFrameBuffer()
+{
+ int ret = 0;
+ if(mFd > 0) {
+ ret = close(mFd);
+ mFd = -1;
+ }
+ return (ret == 0);
+}
+
+// clears the vinfo, edid, best modes
+void ExternalDisplay::resetInfo()
+{
+ memset(&mVInfo, 0, sizeof(mVInfo));
+ memset(mEDIDs, 0, sizeof(mEDIDs));
+ memset(mEDIDModes, 0, sizeof(mEDIDModes));
+ mModeCount = 0;
+ mCurrentMode = -1;
+}
+
+int ExternalDisplay::getModeOrder(int mode)
+{
+ switch (mode) {
+ default:
+ case m1440x480i60_4_3:
+ return 1; // 480i 4:3
+ case m1440x480i60_16_9:
+ return 2; // 480i 16:9
+ case m1440x576i50_4_3:
+ return 3; // i576i 4:3
+ case m1440x576i50_16_9:
+ return 4; // 576i 16:9
+ case m640x480p60_4_3:
+ return 5; // 640x480 4:3
+ case m720x480p60_4_3:
+ return 6; // 480p 4:3
+ case m720x480p60_16_9:
+ return 7; // 480p 16:9
+ case m720x576p50_4_3:
+ return 8; // 576p 4:3
+ case m720x576p50_16_9:
+ return 9; // 576p 16:9
+ case m1920x1080i60_16_9:
+ return 10; // 1080i 16:9
+ case m1280x720p50_16_9:
+ return 11; // 720p@50Hz
+ case m1280x720p60_16_9:
+ return 12; // 720p@60Hz
+ case m1920x1080p24_16_9:
+ return 13; //1080p@24Hz
+ case m1920x1080p25_16_9:
+ return 14; //108-p@25Hz
+ case m1920x1080p30_16_9:
+ return 15; //1080p@30Hz
+ case m1920x1080p50_16_9:
+ return 16; //1080p@50Hz
+ case m1920x1080p60_16_9:
+ return 17; //1080p@60Hz
+ }
+}
+
+// Get the best mode for the current HD TV
+int ExternalDisplay::getBestMode() {
+ int bestOrder = 0;
+ int bestMode = m640x480p60_4_3;
+ Mutex::Autolock lock(mExtDispLock);
+ // for all the edid read, get the best mode
+ for(int i = 0; i < mModeCount; i++) {
+ int mode = mEDIDModes[i];
+ int order = getModeOrder(mode);
+ if (order > bestOrder) {
+ bestOrder = order;
+ bestMode = mode;
+ }
+ }
+ return bestMode;
+}
+
+inline bool ExternalDisplay::isValidMode(int ID)
+{
+ return ((ID >= m640x480p60_4_3) && (ID <= m1920x1080p30_16_9));
+}
+
+void ExternalDisplay::setResolution(int ID)
+{
+ struct fb_var_screeninfo info;
+ int ret = 0;
+ if (!openFramebuffer())
+ return;
+ 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);
+ //If its a valid mode and its a new ID - update var_screeninfo
+ if ((isValidMode(ID)) && mCurrentMode != ID) {
+ const struct disp_mode_timing_type *mode =
+ &supported_video_mode_lut[0];
+ unsigned count = sizeof(supported_video_mode_lut)/sizeof
+ (*supported_video_mode_lut);
+ for (unsigned int i = 0; i < count; ++i) {
+ const struct disp_mode_timing_type *cur =
+ &supported_video_mode_lut[i];
+ if (cur->video_format == ID)
+ mode = cur;
+ }
+ mode->set_info(mVInfo);
+ ALOGD_IF(DEBUG, "%s: SET Info<ID=%d => Info<ID=%d %dx %d"
+ "(%d,%d,%d), (%d,%d,%d) %dMHz>", __FUNCTION__, ID,
+ 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);
+ 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));
+ }
+ mCurrentMode = ID;
+ }
+ //Powerup
+ ret = ioctl(mFd, FBIOBLANK, FB_BLANK_UNBLANK);
+ if(ret < 0) {
+ ALOGD("In %s: FBIOBLANK failed Err Str = %s", __FUNCTION__,
+ strerror(errno));
+ }
+ ret = ioctl(mFd, FBIOGET_VSCREENINFO, &mVInfo);
+ if(ret < 0) {
+ ALOGD("In %s: FBIOGET_VSCREENINFO failed Err Str = %s", __FUNCTION__,
+ strerror(errno));
+ }
+ //Pan_Display
+ ret = ioctl(mFd, FBIOPAN_DISPLAY, &mVInfo);
+ if(ret < 0) {
+ ALOGD("In %s: FBIOPAN_DISPLAY failed Err Str = %s", __FUNCTION__,
+ strerror(errno));
+ }
+}
+
+void ExternalDisplay::setExternalDisplay(int connected)
+{
+
+ hwc_context_t* ctx = mHwcContext;
+ if(ctx) {
+ ALOGD_IF(DEBUG, "%s: status = %d", __FUNCTION__,
+ connected);
+ if(connected) {
+ readResolution();
+ //Get the best mode and set
+ // TODO: DO NOT call this for WFD
+ setResolution(getBestMode());
+ //enable hdmi vsync
+ enableHDMIVsync(connected);
+ } else {
+ // Disable the hdmi vsync
+ enableHDMIVsync(connected);
+ closeFrameBuffer();
+ resetInfo();
+ }
+ // Store the external display
+ mExternalDisplay = connected;
+ const char* prop = (connected) ? "1" : "0";
+ // set system property
+ property_set("hw.hdmiON", prop);
+ /* Trigger redraw */
+ ALOGD_IF(DEBUG, "%s: Invalidate !!", __FUNCTION__);
+ ctx->proc->invalidate(ctx->proc);
+ }
+ return;
+}
+
+bool ExternalDisplay::writeHPDOption(int userOption) const
+{
+ bool ret = true;
+ int hdmiHPDFile = open(SYSFS_HPD,O_RDWR, 0);
+ if (hdmiHPDFile < 0) {
+ ALOGE("%s: state file '%s' not found : ret%d"
+ "err str: %s", __FUNCTION__, SYSFS_HPD, hdmiHPDFile,
+ strerror(errno));
+ ret = false;
+ } else {
+ int 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 '%s'",
+ __FUNCTION__, SYSFS_HPD);
+ ret = false;
+ }
+ close(hdmiHPDFile);
+ }
+ return ret;
+}
+
+bool ExternalDisplay::commit()
+{
+ if(mFd == -1) {
+ return false;
+ } else if(ioctl(mFd, FBIOPUT_VSCREENINFO, &mVInfo) == -1) {
+ ALOGE("%s: FBIOPUT_VSCREENINFO failed, str: %s", __FUNCTION__,
+ strerror(errno));
+ return false;
+ }
+ return true;
+}
+
+int ExternalDisplay::enableHDMIVsync(int enable)
+{
+ if(mFd > 0) {
+ int ret = ioctl(mFd, MSMFB_OVERLAY_VSYNC_CTRL, &enable);
+ if (ret<0) {
+ ALOGE("%s: enabling HDMI vsync failed, str: %s", __FUNCTION__,
+ strerror(errno));
+ }
+ }
+ return -errno;
+}
+
+};
+