1 /* 2 * Copyright (c) 2011-2013, 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 "overlay.h" 31 #include "pipes/overlayGenPipe.h" 32 #include "mdp_version.h" 33 #include "qdMetaData.h" 34 35 #define PIPE_DEBUG 0 36 37 namespace overlay { 38 using namespace utils; 39 40 Overlay::Overlay() { 41 PipeBook::NUM_PIPES = qdutils::MDPVersion::getInstance().getTotalPipes(); 42 for(int i = 0; i < PipeBook::NUM_PIPES; i++) { 43 mPipeBook[i].init(); 44 } 45 46 mDumpStr[0] = '\0'; 47 } 48 49 Overlay::~Overlay() { 50 for(int i = 0; i < PipeBook::NUM_PIPES; i++) { 51 mPipeBook[i].destroy(); 52 } 53 } 54 55 void Overlay::configBegin() { 56 for(int i = 0; i < PipeBook::NUM_PIPES; i++) { 57 //Mark as available for this round. 58 PipeBook::resetUse(i); 59 PipeBook::resetAllocation(i); 60 } 61 mDumpStr[0] = '\0'; 62 } 63 64 void Overlay::configDone() { 65 if(PipeBook::pipeUsageUnchanged()) return; 66 67 for(int i = 0; i < PipeBook::NUM_PIPES; i++) { 68 if(PipeBook::isNotUsed(i)) { 69 //Forces UNSET on pipes, flushes rotator memory and session, closes 70 //fds 71 if(mPipeBook[i].valid()) { 72 char str[32]; 73 sprintf(str, "Unset pipe=%s dpy=%d; ", 74 PipeBook::getDestStr((eDest)i), mPipeBook[i].mDisplay); 75 strncat(mDumpStr, str, strlen(str)); 76 } 77 mPipeBook[i].destroy(); 78 } 79 } 80 dump(); 81 PipeBook::save(); 82 } 83 84 eDest Overlay::nextPipe(eMdpPipeType type, int dpy) { 85 eDest dest = OV_INVALID; 86 87 for(int i = 0; i < PipeBook::NUM_PIPES; i++) { 88 //Match requested pipe type 89 if(type == OV_MDP_PIPE_ANY || type == PipeBook::getPipeType((eDest)i)) { 90 //If the pipe is not allocated to any display or used by the 91 //requesting display already in previous round. 92 if((mPipeBook[i].mDisplay == PipeBook::DPY_UNUSED || 93 mPipeBook[i].mDisplay == dpy) && 94 PipeBook::isNotAllocated(i)) { 95 dest = (eDest)i; 96 PipeBook::setAllocation(i); 97 break; 98 } 99 } 100 } 101 102 if(dest != OV_INVALID) { 103 int index = (int)dest; 104 //If the pipe is not registered with any display OR if the pipe is 105 //requested again by the same display using it, then go ahead. 106 mPipeBook[index].mDisplay = dpy; 107 if(not mPipeBook[index].valid()) { 108 mPipeBook[index].mPipe = new GenericPipe(dpy); 109 char str[32]; 110 snprintf(str, 32, "Set pipe=%s dpy=%d; ", 111 PipeBook::getDestStr(dest), dpy); 112 strncat(mDumpStr, str, strlen(str)); 113 } 114 } else { 115 ALOGD_IF(PIPE_DEBUG, "Pipe unavailable type=%d display=%d", 116 (int)type, dpy); 117 } 118 119 return dest; 120 } 121 122 bool Overlay::commit(utils::eDest dest) { 123 bool ret = false; 124 int index = (int)dest; 125 validate(index); 126 127 if(mPipeBook[index].mPipe->commit()) { 128 ret = true; 129 PipeBook::setUse((int)dest); 130 } else { 131 PipeBook::resetUse((int)dest); 132 int dpy = mPipeBook[index].mDisplay; 133 for(int i = 0; i < PipeBook::NUM_PIPES; i++) 134 if (mPipeBook[i].mDisplay == dpy) 135 PipeBook::resetAllocation(i); 136 } 137 return ret; 138 } 139 140 bool Overlay::queueBuffer(int fd, uint32_t offset, 141 utils::eDest dest) { 142 int index = (int)dest; 143 bool ret = false; 144 validate(index); 145 //Queue only if commit() has succeeded (and the bit set) 146 if(PipeBook::isUsed((int)dest)) { 147 ret = mPipeBook[index].mPipe->queueBuffer(fd, offset); 148 } 149 return ret; 150 } 151 152 void Overlay::setCrop(const utils::Dim& d, 153 utils::eDest dest) { 154 int index = (int)dest; 155 validate(index); 156 mPipeBook[index].mPipe->setCrop(d); 157 } 158 159 void Overlay::setPosition(const utils::Dim& d, 160 utils::eDest dest) { 161 int index = (int)dest; 162 validate(index); 163 mPipeBook[index].mPipe->setPosition(d); 164 } 165 166 void Overlay::setTransform(const int orient, 167 utils::eDest dest) { 168 int index = (int)dest; 169 validate(index); 170 171 utils::eTransform transform = 172 static_cast<utils::eTransform>(orient); 173 mPipeBook[index].mPipe->setTransform(transform); 174 175 } 176 177 void Overlay::setSource(const utils::PipeArgs args, 178 utils::eDest dest) { 179 int index = (int)dest; 180 validate(index); 181 182 PipeArgs newArgs(args); 183 if(PipeBook::getPipeType(dest) == OV_MDP_PIPE_VG) { 184 setMdpFlags(newArgs.mdpFlags, OV_MDP_PIPE_SHARE); 185 } else { 186 clearMdpFlags(newArgs.mdpFlags, OV_MDP_PIPE_SHARE); 187 } 188 189 if(PipeBook::getPipeType(dest) == OV_MDP_PIPE_DMA) { 190 setMdpFlags(newArgs.mdpFlags, OV_MDP_PIPE_FORCE_DMA); 191 } else { 192 clearMdpFlags(newArgs.mdpFlags, OV_MDP_PIPE_FORCE_DMA); 193 } 194 195 mPipeBook[index].mPipe->setSource(newArgs); 196 } 197 198 void Overlay::setVisualParams(const MetaData_t& metadata, utils::eDest dest) { 199 int index = (int)dest; 200 validate(index); 201 mPipeBook[index].mPipe->setVisualParams(metadata); 202 } 203 204 Overlay* Overlay::getInstance() { 205 if(sInstance == NULL) { 206 sInstance = new Overlay(); 207 } 208 return sInstance; 209 } 210 211 // Clears any VG pipes allocated to the fb devices 212 // Generates a LUT for pipe types. 213 int Overlay::initOverlay() { 214 int mdpVersion = qdutils::MDPVersion::getInstance().getMDPVersion(); 215 int numPipesXType[OV_MDP_PIPE_ANY] = {0}; 216 numPipesXType[OV_MDP_PIPE_RGB] = 217 qdutils::MDPVersion::getInstance().getRGBPipes(); 218 numPipesXType[OV_MDP_PIPE_VG] = 219 qdutils::MDPVersion::getInstance().getVGPipes(); 220 numPipesXType[OV_MDP_PIPE_DMA] = 221 qdutils::MDPVersion::getInstance().getDMAPipes(); 222 223 int index = 0; 224 for(int X = 0; X < (int)OV_MDP_PIPE_ANY; X++) { //iterate over types 225 for(int j = 0; j < numPipesXType[X]; j++) { //iterate over num 226 PipeBook::pipeTypeLUT[index] = (utils::eMdpPipeType)X; 227 index++; 228 } 229 } 230 231 if (mdpVersion < qdutils::MDSS_V5) { 232 msmfb_mixer_info_req req; 233 mdp_mixer_info *minfo = NULL; 234 char name[64]; 235 int fd = -1; 236 for(int i = 0; i < NUM_FB_DEVICES; i++) { 237 snprintf(name, 64, FB_DEVICE_TEMPLATE, i); 238 ALOGD("initoverlay:: opening the device:: %s", name); 239 fd = ::open(name, O_RDWR, 0); 240 if(fd < 0) { 241 ALOGE("cannot open framebuffer(%d)", i); 242 return -1; 243 } 244 //Get the mixer configuration */ 245 req.mixer_num = i; 246 if (ioctl(fd, MSMFB_MIXER_INFO, &req) == -1) { 247 ALOGE("ERROR: MSMFB_MIXER_INFO ioctl failed"); 248 close(fd); 249 return -1; 250 } 251 minfo = req.info; 252 for (int j = 0; j < req.cnt; j++) { 253 ALOGD("ndx=%d num=%d z_order=%d", minfo->pndx, minfo->pnum, 254 minfo->z_order); 255 // clear any pipe connected to mixer including base pipe. 256 int index = minfo->pndx; 257 ALOGD("Unset overlay with index: %d at mixer %d", index, i); 258 if(ioctl(fd, MSMFB_OVERLAY_UNSET, &index) == -1) { 259 ALOGE("ERROR: MSMFB_OVERLAY_UNSET failed"); 260 close(fd); 261 return -1; 262 } 263 minfo++; 264 } 265 close(fd); 266 fd = -1; 267 } 268 } 269 return 0; 270 } 271 272 void Overlay::dump() const { 273 if(strlen(mDumpStr)) { //dump only on state change 274 ALOGD_IF(PIPE_DEBUG, "%s\n", mDumpStr); 275 } 276 } 277 278 void Overlay::getDump(char *buf, size_t len) { 279 int totalPipes = 0; 280 const char *str = "\nOverlay State\n==========================\n"; 281 strncat(buf, str, strlen(str)); 282 for(int i = 0; i < PipeBook::NUM_PIPES; i++) { 283 if(mPipeBook[i].valid()) { 284 mPipeBook[i].mPipe->getDump(buf, len); 285 char str[64] = {'\0'}; 286 snprintf(str, 64, "Attached to dpy=%d\n\n", mPipeBook[i].mDisplay); 287 strncat(buf, str, strlen(str)); 288 totalPipes++; 289 } 290 } 291 char str_pipes[64] = {'\0'}; 292 snprintf(str_pipes, 64, "Pipes used=%d\n\n", totalPipes); 293 strncat(buf, str_pipes, strlen(str_pipes)); 294 } 295 296 void Overlay::PipeBook::init() { 297 mPipe = NULL; 298 mDisplay = DPY_UNUSED; 299 } 300 301 void Overlay::PipeBook::destroy() { 302 if(mPipe) { 303 delete mPipe; 304 mPipe = NULL; 305 } 306 mDisplay = DPY_UNUSED; 307 } 308 309 Overlay* Overlay::sInstance = 0; 310 int Overlay::sExtFbIndex = 1; 311 int Overlay::PipeBook::NUM_PIPES = 0; 312 int Overlay::PipeBook::sPipeUsageBitmap = 0; 313 int Overlay::PipeBook::sLastUsageBitmap = 0; 314 int Overlay::PipeBook::sAllocatedBitmap = 0; 315 utils::eMdpPipeType Overlay::PipeBook::pipeTypeLUT[utils::OV_MAX] = 316 {utils::OV_MDP_PIPE_ANY}; 317 318 }; // namespace overlay 319
