• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "utils/threads.h"
35 
36 struct MetaData_t;
37 
38 namespace overlay {
39 class GenericPipe;
40 
41 class Overlay : utils::NoCopy {
42 public:
43     enum { DMA_BLOCK_MODE, DMA_LINE_MODE };
44     //Abstract Display types. Each backed by a LayerMixer,
45     //represented by a fb node.
46     //High res panels can be backed by 2 layer mixers and a single fb node.
47     enum { DPY_PRIMARY, DPY_EXTERNAL, DPY_WRITEBACK, DPY_UNUSED };
48     enum { DPY_MAX = DPY_UNUSED };
49     enum { MIXER_LEFT, MIXER_RIGHT, MIXER_UNUSED };
50     enum { MIXER_DEFAULT = MIXER_LEFT, MIXER_MAX = MIXER_UNUSED };
51     enum { MAX_FB_DEVICES = DPY_MAX };
52 
53     /* dtor close */
54     ~Overlay();
55 
56     /* Marks the beginning of a drawing round, resets usage bits on pipes
57      * Should be called when drawing begins before any pipe config is done.
58      */
59     void configBegin();
60 
61     /* Marks the end of config for this drawing round
62      * Will do garbage collection of pipe objects and thus calling UNSETs,
63      * closing FDs, removing rotator objects and memory, if allocated.
64      * Should be called after all pipe configs are done.
65      */
66     void configDone();
67 
68     /* Returns an available pipe based on the type of pipe requested. When ANY
69      * is requested, the first available VG or RGB is returned. If no pipe is
70      * available for the display "dpy" then INV is returned. Note: If a pipe is
71      * assigned to a certain display, then it cannot be assigned to another
72      * display without being garbage-collected once. To add if a pipe is
73      * asisgned to a mixer within a display it cannot be reused for another
74      * mixer without being UNSET once*/
75     utils::eDest nextPipe(utils::eMdpPipeType, int dpy, int mixer);
76 
77     void setSource(const utils::PipeArgs args, utils::eDest dest);
78     void setCrop(const utils::Dim& d, utils::eDest dest);
79     void setTransform(const int orientation, utils::eDest dest);
80     void setPosition(const utils::Dim& dim, utils::eDest dest);
81     void setVisualParams(const MetaData_t& data, utils::eDest dest);
82     bool commit(utils::eDest dest);
83     bool queueBuffer(int fd, uint32_t offset, utils::eDest dest);
84 
85     /* Returns available ("unallocated") pipes for a display's mixer */
86     int availablePipes(int dpy, int mixer);
87     /* Returns if any of the requested pipe type is attached to any of the
88      * displays
89      */
90     bool isPipeTypeAttached(utils::eMdpPipeType type);
91     /* Returns pipe dump. Expects a NULL terminated buffer of big enough size
92      * to populate.
93      */
94     void getDump(char *buf, size_t len);
95     /* Reset usage and allocation bits on all pipes for given display */
96     void clear(int dpy);
97     /* Marks the display, whose pipes need to be forcibaly configured */
98     void forceSet(const int& dpy);
99 
100     /* Closes open pipes, called during startup */
101     static int initOverlay();
102     /* Returns the singleton instance of overlay */
103     static Overlay* getInstance();
104     static void setDMAMode(const int& mode);
105     static int getDMAMode();
106     /* Returns the framebuffer node backing up the display */
107     static int getFbForDpy(const int& dpy);
108     static bool displayCommit(const int& fd);
109 
110 private:
111     /* Ctor setup */
112     explicit Overlay();
113     /*Validate index range, abort if invalid */
114     void validate(int index);
115     void dump() const;
116 
117     /* Just like a Facebook for pipes, but much less profile info */
118     struct PipeBook {
119         void init();
120         void destroy();
121         /* Check if pipe exists and return true, false otherwise */
122         bool valid();
123 
124         /* Hardware pipe wrapper */
125         GenericPipe *mPipe;
126         /* Display using this pipe. Refer to enums above */
127         int mDisplay;
128         /* Mixer within a split display this pipe is attached to */
129         int mMixer;
130 
131         /* operations on bitmap */
132         static bool pipeUsageUnchanged();
133         static void setUse(int index);
134         static void resetUse(int index);
135         static bool isUsed(int index);
136         static bool isNotUsed(int index);
137         static void save();
138 
139         static void setAllocation(int index);
140         static void resetAllocation(int index);
141         static bool isAllocated(int index);
142         static bool isNotAllocated(int index);
143 
144         static utils::eMdpPipeType getPipeType(utils::eDest dest);
145         static const char* getDestStr(utils::eDest dest);
146 
147         static int NUM_PIPES;
148         static utils::eMdpPipeType pipeTypeLUT[utils::OV_MAX];
149 
150 
151     private:
152         //usage tracks if a successful commit happened. So a pipe could be
153         //allocated to a display, but it may not end up using it for various
154         //reasons. If one display actually uses a pipe then it amy not be
155         //used by another display, without an UNSET in between.
156         static int sPipeUsageBitmap;
157         static int sLastUsageBitmap;
158         //Tracks which pipe objects are allocated. This does not imply that they
159         //will actually be used. For example, a display might choose to acquire
160         //3 pipe objects in one shot and proceed with config only if it gets all
161         //3. The bitmap helps allocate different pipe objects on each request.
162         static int sAllocatedBitmap;
163     };
164 
165     PipeBook mPipeBook[utils::OV_INVALID]; //Used as max
166 
167     /* Dump string */
168     char mDumpStr[1024];
169 
170     /* Singleton Instance*/
171     static Overlay *sInstance;
172     static int sDpyFbMap[DPY_MAX];
173     static int sDMAMode;
174     static int sForceSetBitmap;
175 };
176 
validate(int index)177 inline void Overlay::validate(int index) {
178     OVASSERT(index >=0 && index < PipeBook::NUM_PIPES, \
179         "%s, Index out of bounds: %d", __FUNCTION__, index);
180     OVASSERT(mPipeBook[index].valid(), "Pipe does not exist %s",
181             PipeBook::getDestStr((utils::eDest)index));
182 }
183 
availablePipes(int dpy,int mixer)184 inline int Overlay::availablePipes(int dpy, int mixer) {
185     int avail = 0;
186     for(int i = 0; i < PipeBook::NUM_PIPES; i++) {
187         if( (mPipeBook[i].mDisplay == DPY_UNUSED ||
188              mPipeBook[i].mDisplay == dpy) &&
189             (mPipeBook[i].mMixer == MIXER_UNUSED ||
190              mPipeBook[i].mMixer == mixer) &&
191             PipeBook::isNotAllocated(i) &&
192             !(Overlay::getDMAMode() == Overlay::DMA_BLOCK_MODE &&
193               PipeBook::getPipeType((utils::eDest)i) ==
194               utils::OV_MDP_PIPE_DMA)) {
195             avail++;
196         }
197     }
198     return avail;
199 }
200 
setDMAMode(const int & mode)201 inline void Overlay::setDMAMode(const int& mode) {
202     if(mode == DMA_LINE_MODE || mode == DMA_BLOCK_MODE)
203         sDMAMode = mode;
204 }
205 
getDMAMode()206 inline int Overlay::getDMAMode() {
207     return sDMAMode;
208 }
209 
getFbForDpy(const int & dpy)210 inline int Overlay::getFbForDpy(const int& dpy) {
211     OVASSERT(dpy >= 0 && dpy < DPY_MAX, "Invalid dpy %d", dpy);
212     return sDpyFbMap[dpy];
213 }
214 
forceSet(const int & dpy)215 inline void Overlay::forceSet(const int& dpy) {
216     sForceSetBitmap |= (1 << dpy);
217 }
218 
valid()219 inline bool Overlay::PipeBook::valid() {
220     return (mPipe != NULL);
221 }
222 
pipeUsageUnchanged()223 inline bool Overlay::PipeBook::pipeUsageUnchanged() {
224     return (sPipeUsageBitmap == sLastUsageBitmap);
225 }
226 
setUse(int index)227 inline void Overlay::PipeBook::setUse(int index) {
228     sPipeUsageBitmap |= (1 << index);
229 }
230 
resetUse(int index)231 inline void Overlay::PipeBook::resetUse(int index) {
232     sPipeUsageBitmap &= ~(1 << index);
233 }
234 
isUsed(int index)235 inline bool Overlay::PipeBook::isUsed(int index) {
236     return sPipeUsageBitmap & (1 << index);
237 }
238 
isNotUsed(int index)239 inline bool Overlay::PipeBook::isNotUsed(int index) {
240     return !isUsed(index);
241 }
242 
save()243 inline void Overlay::PipeBook::save() {
244     sLastUsageBitmap = sPipeUsageBitmap;
245 }
246 
setAllocation(int index)247 inline void Overlay::PipeBook::setAllocation(int index) {
248     sAllocatedBitmap |= (1 << index);
249 }
250 
resetAllocation(int index)251 inline void Overlay::PipeBook::resetAllocation(int index) {
252     sAllocatedBitmap &= ~(1 << index);
253 }
254 
isAllocated(int index)255 inline bool Overlay::PipeBook::isAllocated(int index) {
256     return sAllocatedBitmap & (1 << index);
257 }
258 
isNotAllocated(int index)259 inline bool Overlay::PipeBook::isNotAllocated(int index) {
260     return !isAllocated(index);
261 }
262 
getPipeType(utils::eDest dest)263 inline utils::eMdpPipeType Overlay::PipeBook::getPipeType(utils::eDest dest) {
264     return pipeTypeLUT[(int)dest];
265 }
266 
getDestStr(utils::eDest dest)267 inline const char* Overlay::PipeBook::getDestStr(utils::eDest dest) {
268     switch(getPipeType(dest)) {
269         case utils::OV_MDP_PIPE_RGB: return "RGB";
270         case utils::OV_MDP_PIPE_VG: return "VG";
271         case utils::OV_MDP_PIPE_DMA: return "DMA";
272         default: return "Invalid";
273     }
274     return "Invalid";
275 }
276 
277 }; // overlay
278 
279 #endif // OVERLAY_H
280