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
37struct MetaData_t;
38
39namespace overlay {
40class GenericPipe;
41
42class Overlay : utils::NoCopy {
43public:
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_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 };
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
156private:
157    /* Ctor setup */
158    explicit Overlay();
159    /*Validate index range, abort if invalid */
160    void validate(int index);
161    static void setDMAMultiplexingSupported();
162    void dump() const;
163    /* Returns an available pipe based on the type of pipe requested. When ANY
164     * is requested, the first available VG or RGB is returned. If no pipe is
165     * available for the display "dpy" then INV is returned. Note: If a pipe is
166     * assigned to a certain display, then it cannot be assigned to another
167     * display without being garbage-collected once. To add if a pipe is
168     * asisgned to a mixer within a display it cannot be reused for another
169     * mixer without being UNSET once*/
170    utils::eDest nextPipe(utils::eMdpPipeType, int dpy, int mixer);
171    /* Helpers that enfore target specific policies while returning pipes */
172    utils::eDest getPipe_8x26(const PipeSpecs& pipeSpecs);
173    utils::eDest getPipe_8x16(const PipeSpecs& pipeSpecs);
174    utils::eDest getPipe_8x39(const PipeSpecs& pipeSpecs);
175
176    /* Returns the handle to libscale.so's programScale function */
177    static int (*getFnProgramScale())(struct mdp_overlay_list *);
178    /* Creates a scalar object using libscale.so */
179    static void initScalar();
180    /* Destroys the scalar object using libscale.so */
181    static void destroyScalar();
182    /* Sets the pipe type RGB/VG/DMA*/
183    void setPipeType(utils::eDest pipeIndex, const utils::eMdpPipeType pType);
184
185    /* Just like a Facebook for pipes, but much less profile info */
186    struct PipeBook {
187        void init();
188        void destroy();
189        /* Check if pipe exists and return true, false otherwise */
190        bool valid();
191
192        /* Hardware pipe wrapper */
193        GenericPipe *mPipe;
194        /* Display using this pipe. Refer to enums above */
195        int mDisplay;
196        /* Mixer within a split display this pipe is attached to */
197        int mMixer;
198
199        /* operations on bitmap */
200        static bool pipeUsageUnchanged();
201        static void setUse(int index);
202        static void resetUse(int index);
203        static bool isUsed(int index);
204        static bool isNotUsed(int index);
205        static void save();
206
207        static void setAllocation(int index);
208        static void resetAllocation(int index);
209        static bool isAllocated(int index);
210        static bool isNotAllocated(int index);
211
212        static utils::eMdpPipeType getPipeType(utils::eDest dest);
213        static const char* getDestStr(utils::eDest dest);
214
215        static int NUM_PIPES;
216        static utils::eMdpPipeType pipeTypeLUT[utils::OV_MAX];
217        /* Session for reserved pipes */
218        enum Session {
219            NONE,
220            START,
221            END
222        };
223        Session mSession;
224
225    private:
226        //usage tracks if a successful commit happened. So a pipe could be
227        //allocated to a display, but it may not end up using it for various
228        //reasons. If one display actually uses a pipe then it amy not be
229        //used by another display, without an UNSET in between.
230        static int sPipeUsageBitmap;
231        static int sLastUsageBitmap;
232        //Tracks which pipe objects are allocated. This does not imply that they
233        //will actually be used. For example, a display might choose to acquire
234        //3 pipe objects in one shot and proceed with config only if it gets all
235        //3. The bitmap helps allocate different pipe objects on each request.
236        static int sAllocatedBitmap;
237    };
238
239    PipeBook mPipeBook[utils::OV_INVALID]; //Used as max
240
241    /* Dump string */
242    char mDumpStr[1024];
243
244    /* Singleton Instance*/
245    static Overlay *sInstance;
246    static int sDpyFbMap[DPY_MAX];
247    static int sDMAMode;
248    static bool sDMAMultiplexingSupported;
249    static void *sLibScaleHandle;
250    static int (*sFnProgramScale)(struct mdp_overlay_list *);
251
252    friend class MdpCtrl;
253};
254
255inline void Overlay::validate(int index) {
256    OVASSERT(index >=0 && index < PipeBook::NUM_PIPES, \
257        "%s, Index out of bounds: %d", __FUNCTION__, index);
258    OVASSERT(mPipeBook[index].valid(), "Pipe does not exist %s",
259            PipeBook::getDestStr((utils::eDest)index));
260}
261
262inline int Overlay::availablePipes(int dpy, int mixer) {
263    int avail = 0;
264    for(int i = 0; i < PipeBook::NUM_PIPES; i++) {
265        if( (mPipeBook[i].mDisplay == DPY_UNUSED ||
266             mPipeBook[i].mDisplay == dpy) &&
267            (mPipeBook[i].mMixer == MIXER_UNUSED ||
268             mPipeBook[i].mMixer == mixer) &&
269            PipeBook::isNotAllocated(i) &&
270            !(Overlay::getDMAMode() == Overlay::DMA_BLOCK_MODE &&
271              PipeBook::getPipeType((utils::eDest)i) ==
272              utils::OV_MDP_PIPE_DMA)) {
273            avail++;
274        }
275    }
276    return avail;
277}
278
279inline int Overlay::availablePipes(int dpy) {
280    int avail = 0;
281    for(int i = 0; i < PipeBook::NUM_PIPES; i++) {
282        if( (mPipeBook[i].mDisplay == DPY_UNUSED ||
283             mPipeBook[i].mDisplay == dpy) &&
284            PipeBook::isNotAllocated(i) &&
285            !(Overlay::getDMAMode() == Overlay::DMA_BLOCK_MODE &&
286              PipeBook::getPipeType((utils::eDest)i) ==
287              utils::OV_MDP_PIPE_DMA)) {
288            avail++;
289        }
290    }
291    return avail;
292}
293
294inline int Overlay::availablePipes(int dpy, utils::eMdpPipeType type) {
295    int avail = 0;
296    for(int i = 0; i < PipeBook::NUM_PIPES; i++) {
297        if((mPipeBook[i].mDisplay == DPY_UNUSED ||
298            mPipeBook[i].mDisplay == dpy) &&
299            PipeBook::isNotAllocated(i) &&
300            type == PipeBook::getPipeType((utils::eDest)i)) {
301            avail++;
302        }
303    }
304    return avail;
305}
306
307inline void Overlay::setDMAMode(const int& mode) {
308    if(mode == DMA_LINE_MODE || mode == DMA_BLOCK_MODE)
309        sDMAMode = mode;
310}
311
312inline void Overlay::setDMAMultiplexingSupported() {
313    sDMAMultiplexingSupported = false;
314    if(qdutils::MDPVersion::getInstance().is8x26())
315        sDMAMultiplexingSupported = true;
316}
317
318inline bool Overlay::isDMAMultiplexingSupported() {
319    return sDMAMultiplexingSupported;
320}
321
322inline bool Overlay::isUIScalingOnExternalSupported() {
323    if(qdutils::MDPVersion::getInstance().is8x26() or
324       qdutils::MDPVersion::getInstance().is8x16() or
325       qdutils::MDPVersion::getInstance().is8x39()) {
326        return false;
327    }
328    return true;
329}
330
331inline int Overlay::getDMAMode() {
332    return sDMAMode;
333}
334
335inline int Overlay::getFbForDpy(const int& dpy) {
336    OVASSERT(dpy >= 0 && dpy < DPY_MAX, "Invalid dpy %d", dpy);
337    return sDpyFbMap[dpy];
338}
339
340inline int (*Overlay::getFnProgramScale())(struct mdp_overlay_list *) {
341    return sFnProgramScale;
342}
343
344inline bool Overlay::PipeBook::valid() {
345    return (mPipe != NULL);
346}
347
348inline bool Overlay::PipeBook::pipeUsageUnchanged() {
349    return (sPipeUsageBitmap == sLastUsageBitmap);
350}
351
352inline void Overlay::PipeBook::setUse(int index) {
353    sPipeUsageBitmap |= (1 << index);
354}
355
356inline void Overlay::PipeBook::resetUse(int index) {
357    sPipeUsageBitmap &= ~(1 << index);
358}
359
360inline bool Overlay::PipeBook::isUsed(int index) {
361    return sPipeUsageBitmap & (1 << index);
362}
363
364inline bool Overlay::PipeBook::isNotUsed(int index) {
365    return !isUsed(index);
366}
367
368inline void Overlay::PipeBook::save() {
369    sLastUsageBitmap = sPipeUsageBitmap;
370}
371
372inline void Overlay::PipeBook::setAllocation(int index) {
373    sAllocatedBitmap |= (1 << index);
374}
375
376inline void Overlay::PipeBook::resetAllocation(int index) {
377    sAllocatedBitmap &= ~(1 << index);
378}
379
380inline bool Overlay::PipeBook::isAllocated(int index) {
381    return sAllocatedBitmap & (1 << index);
382}
383
384inline bool Overlay::PipeBook::isNotAllocated(int index) {
385    return !isAllocated(index);
386}
387
388inline utils::eMdpPipeType Overlay::PipeBook::getPipeType(utils::eDest dest) {
389    return pipeTypeLUT[(int)dest];
390}
391
392inline void Overlay::startSession(utils::eDest dest) {
393    mPipeBook[(int)dest].mSession = PipeBook::START;
394}
395
396inline bool Overlay::sessionInProgress(utils::eDest dest) {
397    return (mPipeBook[(int)dest].mSession == PipeBook::START);
398}
399
400inline bool Overlay::isSessionEnded(utils::eDest dest) {
401    return (mPipeBook[(int)dest].mSession == PipeBook::END);
402}
403
404inline const char* Overlay::PipeBook::getDestStr(utils::eDest dest) {
405    switch(getPipeType(dest)) {
406        case utils::OV_MDP_PIPE_RGB: return "RGB";
407        case utils::OV_MDP_PIPE_VG: return "VG";
408        case utils::OV_MDP_PIPE_DMA: return "DMA";
409        default: return "Invalid";
410    }
411    return "Invalid";
412}
413
414}; // overlay
415
416#endif // OVERLAY_H
417