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 40 using namespace overlay; 41 using namespace overlay::utils; 42 namespace qhwc { 43 44 //Helper to write data to ad node 45 static 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 71 static 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 96 AssertiveDisplay::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 124 void 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 139 void 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 150 bool 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 246 bool 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 264 int AssertiveDisplay::getDstFd() const { 265 overlay::Writeback *wb = overlay::Writeback::getInstance(); 266 return wb->getDstFd(); 267 } 268 269 uint32_t AssertiveDisplay::getDstOffset() const { 270 overlay::Writeback *wb = overlay::Writeback::getInstance(); 271 return wb->getOffset(); 272 } 273 274 } 275
