1/* 2* Copyright (c) 2013-2014 The Linux Foundation. All rights reserved. 3* 4* Redistribution and use in source and binary forms, with or without 5* modification, are permitted provided that the following conditions are 6* met: 7* * Redistributions of source code must retain the above copyright 8* notice, this list of conditions and the following disclaimer. 9* * Redistributions in binary form must reproduce the above 10* copyright notice, this list of conditions and the following 11* disclaimer in the documentation and/or other materials provided 12* with the distribution. 13* * Neither the name of The Linux Foundation. nor the names of its 14* contributors may be used to endorse or promote products derived 15* from this software without specific prior written permission. 16* 17* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED 18* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT 20* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 21* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 22* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 23* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 24* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 25* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 26* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28*/ 29 30#include <unistd.h> 31#include <overlay.h> 32#include <overlayUtils.h> 33#include <overlayWriteback.h> 34#include <mdp_version.h> 35#include "hwc_ad.h" 36#include "hwc_utils.h" 37#include "external.h" 38 39#define DEBUG 0 40using namespace overlay; 41using namespace overlay::utils; 42namespace qhwc { 43 44//Helper to write data to ad node 45static void adWrite(const int& value) { 46 const int wbFbNum = Overlay::getFbForDpy(Overlay::DPY_WRITEBACK); 47 char wbFbPath[256]; 48 snprintf (wbFbPath, sizeof(wbFbPath), 49 "/sys/class/graphics/fb%d/ad", wbFbNum); 50 int adFd = open(wbFbPath, O_WRONLY); 51 if(adFd >= 0) { 52 char opStr[4] = ""; 53 snprintf(opStr, sizeof(opStr), "%d", value); 54 ssize_t ret = write(adFd, opStr, strlen(opStr)); 55 if(ret < 0) { 56 ALOGE("%s: Failed to write %d with error %s", 57 __func__, value, strerror(errno)); 58 } else if (ret == 0){ 59 ALOGE("%s Nothing written to ad", __func__); 60 } else { 61 ALOGD_IF(DEBUG, "%s: Wrote %d to ad", __func__, value); 62 } 63 close(adFd); 64 } else { 65 ALOGE("%s: Failed to open /sys/class/graphics/fb%d/ad with error %s", 66 __func__, wbFbNum, strerror(errno)); 67 } 68} 69 70//Helper to read data from ad node 71static int adRead() { 72 const int wbFbNum = Overlay::getFbForDpy(Overlay::DPY_WRITEBACK); 73 int ret = -1; 74 char wbFbPath[256]; 75 snprintf (wbFbPath, sizeof(wbFbPath), 76 "/sys/class/graphics/fb%d/ad", wbFbNum); 77 int adFd = open(wbFbPath, O_RDONLY); 78 if(adFd >= 0) { 79 char opStr[4] = {'\0'}; 80 if(read(adFd, opStr, strlen(opStr)) >= 0) { 81 //Should return -1, 0 or 1 82 ret = atoi(opStr); 83 ALOGD_IF(DEBUG, "%s: Read %d from ad", __func__, ret); 84 } else { 85 ALOGE("%s: Read from ad node failed with error %s", __func__, 86 strerror(errno)); 87 } 88 close(adFd); 89 } else { 90 ALOGD("%s: /sys/class/graphics/fb%d/ad could not be opened : %s", 91 __func__, wbFbNum, strerror(errno)); 92 } 93 return ret; 94} 95 96AssertiveDisplay::AssertiveDisplay(hwc_context_t *ctx) : 97 mTurnedOff(true), mFeatureEnabled(false), 98 mDest(overlay::utils::OV_INVALID) 99{ 100 //Values in ad node: 101 //-1 means feature is disabled on device 102 // 0 means feature exists but turned off, will be turned on by hwc 103 // 1 means feature is turned on by hwc 104 // Plus, we do this feature only on split primary displays. 105 // Plus, we do this feature only if ro.qcom.ad=2 106 107 char property[PROPERTY_VALUE_MAX]; 108 const int ENABLED = 2; 109 int val = 0; 110 111 if(property_get("ro.qcom.ad", property, "0") > 0) { 112 val = atoi(property); 113 } 114 115 if(adRead() >= 0 && isDisplaySplit(ctx, HWC_DISPLAY_PRIMARY) && 116 val == ENABLED) { 117 ALOGD_IF(DEBUG, "Assertive display feature supported"); 118 mFeatureEnabled = true; 119 // If feature exists but is turned off, set mTurnedOff to true 120 mTurnedOff = adRead() > 0 ? false : true; 121 } 122} 123 124void AssertiveDisplay::markDoable(hwc_context_t *ctx, 125 const hwc_display_contents_1_t* list) { 126 mDoable = false; 127 if(mFeatureEnabled && 128 !isSecondaryConnected(ctx) && 129 ctx->listStats[HWC_DISPLAY_PRIMARY].yuvCount == 1) { 130 int nYuvIndex = ctx->listStats[HWC_DISPLAY_PRIMARY].yuvIndices[0]; 131 const hwc_layer_1_t* layer = &list->hwLayers[nYuvIndex]; 132 private_handle_t *hnd = (private_handle_t *)layer->handle; 133 if(hnd && hnd->width <= qdutils::MAX_DISPLAY_DIM) { 134 mDoable = true; 135 } 136 } 137} 138 139void AssertiveDisplay::turnOffAD() { 140 if(mFeatureEnabled) { 141 if(!mTurnedOff) { 142 const int off = 0; 143 adWrite(off); 144 mTurnedOff = true; 145 } 146 } 147 mDoable = false; 148} 149 150bool AssertiveDisplay::prepare(hwc_context_t *ctx, 151 const hwc_rect_t& crop, 152 const Whf& whf, 153 const private_handle_t *hnd) { 154 if(!isDoable()) { 155 //Cleanup one time during this switch 156 turnOffAD(); 157 return false; 158 } 159 160 Overlay::PipeSpecs pipeSpecs; 161 pipeSpecs.formatClass = Overlay::FORMAT_YUV; 162 pipeSpecs.dpy = overlay::Overlay::DPY_WRITEBACK; 163 pipeSpecs.fb = false; 164 165 ovutils::eDest dest = ctx->mOverlay->getPipe(pipeSpecs); 166 if(dest == OV_INVALID) { 167 ALOGE("%s failed: No VG pipe available", __func__); 168 mDoable = false; 169 return false; 170 } 171 172 overlay::Writeback *wb = overlay::Writeback::getInstance(); 173 174 //Set Security flag on writeback 175 if(isSecureBuffer(hnd)) { 176 if(!wb->setSecure(isSecureBuffer(hnd))) { 177 ALOGE("Failure in setting WB secure flag for ad"); 178 return false; 179 } 180 } 181 182 if(!wb->configureDpyInfo(hnd->width, hnd->height)) { 183 ALOGE("%s: config display failed", __func__); 184 mDoable = false; 185 return false; 186 } 187 188 int tmpW, tmpH; 189 size_t size; 190 int format = ovutils::getHALFormat(wb->getOutputFormat()); 191 if(format < 0) { 192 ALOGE("%s invalid format %d", __func__, format); 193 mDoable = false; 194 return false; 195 } 196 197 size = getBufferSizeAndDimensions(hnd->width, hnd->height, 198 format, tmpW, tmpH); 199 200 if(!wb->configureMemory((uint32_t)size)) { 201 ALOGE("%s: config memory failed", __func__); 202 mDoable = false; 203 return false; 204 } 205 206 eMdpFlags mdpFlags = OV_MDP_FLAGS_NONE; 207 if(isSecureBuffer(hnd)) { 208 ovutils::setMdpFlags(mdpFlags, 209 ovutils::OV_MDP_SECURE_OVERLAY_SESSION); 210 } 211 212 PipeArgs parg(mdpFlags, whf, ZORDER_0, IS_FG_OFF, 213 ROT_FLAGS_NONE); 214 hwc_rect_t dst = crop; //input same as output 215 216 if(configMdp(ctx->mOverlay, parg, OVERLAY_TRANSFORM_0, crop, dst, NULL, 217 dest) < 0) { 218 ALOGE("%s: configMdp failed", __func__); 219 mDoable = false; 220 return false; 221 } 222 223 mDest = dest; 224 int wbFd = wb->getFbFd(); 225 if(mFeatureEnabled && wbFd >= 0 && 226 !ctx->mOverlay->validateAndSet(overlay::Overlay::DPY_WRITEBACK, wbFd)) 227 { 228 ALOGE("%s: Failed to validate and set overlay for dpy %d" 229 ,__FUNCTION__, overlay::Overlay::DPY_WRITEBACK); 230 turnOffAD(); 231 return false; 232 } 233 234 // Only turn on AD if there are no errors during configuration stage 235 // and if it was previously in OFF state. 236 if(mFeatureEnabled && mTurnedOff) { 237 //write to sysfs, one time during this switch 238 const int on = 1; 239 adWrite(on); 240 mTurnedOff = false; 241 } 242 243 return true; 244} 245 246bool AssertiveDisplay::draw(hwc_context_t *ctx, int fd, uint32_t offset) { 247 if(!isDoable()) { 248 return false; 249 } 250 251 if (!ctx->mOverlay->queueBuffer(fd, offset, mDest)) { 252 ALOGE("%s: queueBuffer failed", __func__); 253 return false; 254 } 255 256 overlay::Writeback *wb = overlay::Writeback::getInstance(); 257 if(!wb->writeSync()) { 258 return false; 259 } 260 261 return true; 262} 263 264int AssertiveDisplay::getDstFd() const { 265 overlay::Writeback *wb = overlay::Writeback::getInstance(); 266 return wb->getDstFd(); 267} 268 269uint32_t AssertiveDisplay::getDstOffset() const { 270 overlay::Writeback *wb = overlay::Writeback::getInstance(); 271 return wb->getOffset(); 272} 273 274} 275