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