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