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 #ifndef OVERLAY_H 31 #define OVERLAY_H 32 33 #include "overlayUtils.h" 34 #include "mdp_version.h" 35 #include "utils/threads.h" 36 37 struct MetaData_t; 38 39 namespace overlay { 40 class GenericPipe; 41 42 class Overlay : utils::NoCopy { 43 public: 44 enum { DMA_BLOCK_MODE, DMA_LINE_MODE }; 45 //Abstract Display types. Each backed by a LayerMixer, 46 //represented by a fb node. 47 //High res panels can be backed by 2 layer mixers and a single fb node. 48 enum { DPY_PRIMARY, DPY_EXTERNAL, DPY_TERTIARY, DPY_WRITEBACK, DPY_UNUSED }; 49 enum { DPY_MAX = DPY_UNUSED }; 50 enum { MIXER_LEFT, MIXER_RIGHT, MIXER_UNUSED }; 51 enum { MIXER_DEFAULT = MIXER_LEFT, MIXER_MAX = MIXER_UNUSED }; 52 enum { MAX_FB_DEVICES = DPY_MAX }; 53 enum { FORMAT_YUV, FORMAT_RGB , FORMAT_NONE }; 54 55 struct PipeSpecs { 56 PipeSpecs() : formatClass(FORMAT_RGB), needsScaling(false), fb(false), 57 dpy(DPY_PRIMARY), mixer(MIXER_DEFAULT), numActiveDisplays(1) {} 58 int formatClass; 59 bool needsScaling; 60 bool fb; 61 int dpy; 62 int mixer; 63 int numActiveDisplays; 64 }; 65 66 /* dtor close */ 67 ~Overlay(); 68 69 /* Marks the beginning of a drawing round, resets usage bits on pipes 70 * Should be called when drawing begins before any pipe config is done. 71 */ 72 void configBegin(); 73 74 /* Marks the end of config for this drawing round 75 * Will do garbage collection of pipe objects and thus calling UNSETs, 76 * closing FDs, removing rotator objects and memory, if allocated. 77 * Should be called after all pipe configs are done. 78 */ 79 void configDone(); 80 81 /* Get a pipe that supported the specified format class (yuv, rgb) and has 82 * scaling capabilities. 83 */ 84 utils::eDest getPipe(const PipeSpecs& pipeSpecs); 85 /* Returns the eDest corresponding to an already allocated pipeid. 86 * Useful for the reservation case, when libvpu reserves the pipe at its 87 * end, and expect the overlay to allocate a given pipe for a layer. 88 */ 89 utils::eDest reservePipe(int pipeid); 90 /* getting dest for the given pipeid */ 91 utils::eDest getDest(int pipeid); 92 /* getting overlay.pipeid for the given dest */ 93 int getPipeId(utils::eDest dest); 94 95 void setSource(const utils::PipeArgs args, utils::eDest dest); 96 void setCrop(const utils::Dim& d, utils::eDest dest); 97 void setColor(const uint32_t color, utils::eDest dest); 98 void setTransform(const int orientation, utils::eDest dest); 99 void setPosition(const utils::Dim& dim, utils::eDest dest); 100 void setVisualParams(const MetaData_t& data, utils::eDest dest); 101 bool commit(utils::eDest dest); 102 bool queueBuffer(int fd, uint32_t offset, utils::eDest dest); 103 104 /* pipe reservation session is running */ 105 bool sessionInProgress(utils::eDest dest); 106 /* pipe reservation session has ended*/ 107 bool isSessionEnded(utils::eDest dest); 108 /* start session for the pipe reservation */ 109 void startSession(utils::eDest dest); 110 /* end all started sesisons */ 111 void endAllSessions(); 112 /* Returns available ("unallocated") pipes for a display's mixer */ 113 int availablePipes(int dpy, int mixer); 114 /* Returns available ("unallocated") pipes for a display */ 115 int availablePipes(int dpy); 116 /* Returns available ("unallocated") pipe of given type for a display */ 117 int availablePipes(int dpy, utils::eMdpPipeType type); 118 /* Returns if any of the requested pipe type is attached to any of the 119 * displays 120 */ 121 bool isPipeTypeAttached(utils::eMdpPipeType type); 122 /* Compare pipe priorities and return 123 * 1 if 1st pipe has a higher priority 124 * 0 if both have the same priority 125 *-1 if 2nd pipe has a higher priority 126 */ 127 int comparePipePriority(utils::eDest pipe1Index, utils::eDest pipe2Index); 128 /* Returns pipe dump. Expects a NULL terminated buffer of big enough size 129 * to populate. 130 */ 131 /* Returns if DMA pipe multiplexing is supported by the mdss driver */ 132 static bool isDMAMultiplexingSupported(); 133 /* Returns if UI scaling on external is supported on the targets */ 134 static bool isUIScalingOnExternalSupported(); 135 void getDump(char *buf, size_t len); 136 /* Reset usage and allocation bits on all pipes for given display */ 137 void clear(int dpy); 138 /* Validate the set of pipes for a display and set them in driver */ 139 bool validateAndSet(const int& dpy, const int& fbFd); 140 141 /* Closes open pipes, called during startup */ 142 static int initOverlay(); 143 /* Returns the singleton instance of overlay */ 144 static Overlay* getInstance(); 145 static void setDMAMode(const int& mode); 146 static int getDMAMode(); 147 /* Returns the framebuffer node backing up the display */ 148 static int getFbForDpy(const int& dpy); 149 150 static bool displayCommit(const int& fd); 151 /* Overloads display commit with ROI's of each halves. 152 * Single interface panels will only update left ROI. */ 153 static bool displayCommit(const int& fd, const utils::Dim& lRoi, 154 const utils::Dim& rRoi); 155 /* Logs pipe lifecycle events like set, unset, commit when enabled */ 156 static void debugPipeLifecycle(const bool& enable); 157 /* Returns true if pipe life cycle logging is enabled */ 158 static bool isDebugPipeLifecycle(); 159 160 private: 161 /* Ctor setup */ 162 explicit Overlay(); 163 /*Validate index range, abort if invalid */ 164 void validate(int index); 165 static void setDMAMultiplexingSupported(); 166 /* Returns an available pipe based on the type of pipe requested. When ANY 167 * is requested, the first available VG or RGB is returned. If no pipe is 168 * available for the display "dpy" then INV is returned. Note: If a pipe is 169 * assigned to a certain display, then it cannot be assigned to another 170 * display without being garbage-collected once. To add if a pipe is 171 * asisgned to a mixer within a display it cannot be reused for another 172 * mixer without being UNSET once*/ 173 utils::eDest nextPipe(utils::eMdpPipeType, const PipeSpecs& pipeSpecs); 174 /* Helpers that enfore target specific policies while returning pipes */ 175 utils::eDest getPipe_8x26(const PipeSpecs& pipeSpecs); 176 utils::eDest getPipe_8x16(const PipeSpecs& pipeSpecs); 177 utils::eDest getPipe_8x39(const PipeSpecs& pipeSpecs); 178 utils::eDest getPipe_8994(const PipeSpecs& pipeSpecs); 179 180 /* Returns the handle to libscale.so's programScale function */ 181 static int (*getFnProgramScale())(struct mdp_overlay_list *); 182 /* Creates a scalar object using libscale.so */ 183 static void initScalar(); 184 /* Destroys the scalar object using libscale.so */ 185 static void destroyScalar(); 186 /* Sets the pipe type RGB/VG/DMA*/ 187 void setPipeType(utils::eDest pipeIndex, const utils::eMdpPipeType pType); 188 189 /* Just like a Facebook for pipes, but much less profile info */ 190 struct PipeBook { 191 void init(); 192 void destroy(); 193 /* Check if pipe exists and return true, false otherwise */ 194 bool valid(); 195 196 /* Hardware pipe wrapper */ 197 GenericPipe *mPipe; 198 /* Display using this pipe. Refer to enums above */ 199 int mDisplay; 200 /* Mixer within a split display this pipe is attached to */ 201 int mMixer; 202 /* Format for which this pipe is attached to the mixer*/ 203 int mFormatType; 204 205 /* operations on bitmap */ 206 static bool pipeUsageUnchanged(); 207 static void setUse(int index); 208 static void resetUse(int index); 209 static bool isUsed(int index); 210 static bool isNotUsed(int index); 211 static void save(); 212 213 static void setAllocation(int index); 214 static void resetAllocation(int index); 215 static bool isAllocated(int index); 216 static bool isNotAllocated(int index); 217 218 static utils::eMdpPipeType getPipeType(utils::eDest dest); 219 static const char* getDestStr(utils::eDest dest); 220 221 static int NUM_PIPES; 222 static utils::eMdpPipeType pipeTypeLUT[utils::OV_MAX]; 223 /* Session for reserved pipes */ 224 enum Session { 225 NONE, 226 START, 227 END 228 }; 229 Session mSession; 230 231 private: 232 //usage tracks if a successful commit happened. So a pipe could be 233 //allocated to a display, but it may not end up using it for various 234 //reasons. If one display actually uses a pipe then it amy not be 235 //used by another display, without an UNSET in between. 236 static int sPipeUsageBitmap; 237 static int sLastUsageBitmap; 238 //Tracks which pipe objects are allocated. This does not imply that they 239 //will actually be used. For example, a display might choose to acquire 240 //3 pipe objects in one shot and proceed with config only if it gets all 241 //3. The bitmap helps allocate different pipe objects on each request. 242 static int sAllocatedBitmap; 243 }; 244 245 PipeBook mPipeBook[utils::OV_INVALID]; //Used as max 246 247 /* Singleton Instance*/ 248 static Overlay *sInstance; 249 static int sDpyFbMap[DPY_MAX]; 250 static int sDMAMode; 251 static bool sDMAMultiplexingSupported; 252 static void *sLibScaleHandle; 253 static int (*sFnProgramScale)(struct mdp_overlay_list *); 254 static bool sDebugPipeLifecycle; 255 256 friend class MdpCtrl; 257 }; 258 259 inline void Overlay::validate(int index) { 260 OVASSERT(index >=0 && index < PipeBook::NUM_PIPES, \ 261 "%s, Index out of bounds: %d", __FUNCTION__, index); 262 OVASSERT(mPipeBook[index].valid(), "Pipe does not exist %s", 263 PipeBook::getDestStr((utils::eDest)index)); 264 } 265 266 inline int Overlay::availablePipes(int dpy, int mixer) { 267 int avail = 0; 268 for(int i = 0; i < PipeBook::NUM_PIPES; i++) { 269 if( (mPipeBook[i].mDisplay == DPY_UNUSED || 270 mPipeBook[i].mDisplay == dpy) && 271 (mPipeBook[i].mMixer == MIXER_UNUSED || 272 mPipeBook[i].mMixer == mixer) && 273 PipeBook::isNotAllocated(i) && 274 !(Overlay::getDMAMode() == Overlay::DMA_BLOCK_MODE && 275 PipeBook::getPipeType((utils::eDest)i) == 276 utils::OV_MDP_PIPE_DMA)) { 277 avail++; 278 } 279 } 280 return avail; 281 } 282 283 inline int Overlay::availablePipes(int dpy) { 284 int avail = 0; 285 for(int i = 0; i < PipeBook::NUM_PIPES; i++) { 286 if( (mPipeBook[i].mDisplay == DPY_UNUSED || 287 mPipeBook[i].mDisplay == dpy) && 288 PipeBook::isNotAllocated(i) && 289 !(Overlay::getDMAMode() == Overlay::DMA_BLOCK_MODE && 290 PipeBook::getPipeType((utils::eDest)i) == 291 utils::OV_MDP_PIPE_DMA)) { 292 avail++; 293 } 294 } 295 return avail; 296 } 297 298 inline int Overlay::availablePipes(int dpy, utils::eMdpPipeType type) { 299 int avail = 0; 300 for(int i = 0; i < PipeBook::NUM_PIPES; i++) { 301 if((mPipeBook[i].mDisplay == DPY_UNUSED || 302 mPipeBook[i].mDisplay == dpy) && 303 PipeBook::isNotAllocated(i) && 304 type == PipeBook::getPipeType((utils::eDest)i)) { 305 avail++; 306 } 307 } 308 return avail; 309 } 310 311 inline void Overlay::setDMAMode(const int& mode) { 312 if(mode == DMA_LINE_MODE || mode == DMA_BLOCK_MODE) 313 sDMAMode = mode; 314 } 315 316 inline void Overlay::setDMAMultiplexingSupported() { 317 sDMAMultiplexingSupported = false; 318 if(qdutils::MDPVersion::getInstance().is8x26()) 319 sDMAMultiplexingSupported = true; 320 } 321 322 inline bool Overlay::isDMAMultiplexingSupported() { 323 return sDMAMultiplexingSupported; 324 } 325 326 inline bool Overlay::isUIScalingOnExternalSupported() { 327 if(qdutils::MDPVersion::getInstance().is8x26() or 328 qdutils::MDPVersion::getInstance().is8x16() or 329 qdutils::MDPVersion::getInstance().is8x39()) { 330 return false; 331 } 332 return true; 333 } 334 335 inline int Overlay::getDMAMode() { 336 return sDMAMode; 337 } 338 339 inline int Overlay::getFbForDpy(const int& dpy) { 340 OVASSERT(dpy >= 0 && dpy < DPY_MAX, "Invalid dpy %d", dpy); 341 return sDpyFbMap[dpy]; 342 } 343 344 inline int (*Overlay::getFnProgramScale())(struct mdp_overlay_list *) { 345 return sFnProgramScale; 346 } 347 348 inline void Overlay::debugPipeLifecycle(const bool& enable) { 349 sDebugPipeLifecycle = enable; 350 } 351 352 inline bool Overlay::isDebugPipeLifecycle() { 353 return sDebugPipeLifecycle; 354 } 355 356 inline bool Overlay::PipeBook::valid() { 357 return (mPipe != NULL); 358 } 359 360 inline bool Overlay::PipeBook::pipeUsageUnchanged() { 361 return (sPipeUsageBitmap == sLastUsageBitmap); 362 } 363 364 inline void Overlay::PipeBook::setUse(int index) { 365 sPipeUsageBitmap |= (1 << index); 366 } 367 368 inline void Overlay::PipeBook::resetUse(int index) { 369 sPipeUsageBitmap &= ~(1 << index); 370 } 371 372 inline bool Overlay::PipeBook::isUsed(int index) { 373 return sPipeUsageBitmap & (1 << index); 374 } 375 376 inline bool Overlay::PipeBook::isNotUsed(int index) { 377 return !isUsed(index); 378 } 379 380 inline void Overlay::PipeBook::save() { 381 sLastUsageBitmap = sPipeUsageBitmap; 382 } 383 384 inline void Overlay::PipeBook::setAllocation(int index) { 385 sAllocatedBitmap |= (1 << index); 386 } 387 388 inline void Overlay::PipeBook::resetAllocation(int index) { 389 sAllocatedBitmap &= ~(1 << index); 390 } 391 392 inline bool Overlay::PipeBook::isAllocated(int index) { 393 return sAllocatedBitmap & (1 << index); 394 } 395 396 inline bool Overlay::PipeBook::isNotAllocated(int index) { 397 return !isAllocated(index); 398 } 399 400 inline utils::eMdpPipeType Overlay::PipeBook::getPipeType(utils::eDest dest) { 401 return pipeTypeLUT[(int)dest]; 402 } 403 404 inline void Overlay::startSession(utils::eDest dest) { 405 mPipeBook[(int)dest].mSession = PipeBook::START; 406 } 407 408 inline bool Overlay::sessionInProgress(utils::eDest dest) { 409 return (mPipeBook[(int)dest].mSession == PipeBook::START); 410 } 411 412 inline bool Overlay::isSessionEnded(utils::eDest dest) { 413 return (mPipeBook[(int)dest].mSession == PipeBook::END); 414 } 415 416 inline const char* Overlay::PipeBook::getDestStr(utils::eDest dest) { 417 switch(getPipeType(dest)) { 418 case utils::OV_MDP_PIPE_RGB: return "RGB"; 419 case utils::OV_MDP_PIPE_VG: return "VG"; 420 case utils::OV_MDP_PIPE_DMA: return "DMA"; 421 default: return "Invalid"; 422 } 423 return "Invalid"; 424 } 425 426 }; // overlay 427 428 #endif // OVERLAY_H 429