overlay.cpp 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#include "overlay.h"
31#include "pipes/overlayGenPipe.h"
32#include "mdp_version.h"
33#include "qdMetaData.h"
34
35#define PIPE_DEBUG 0
36
37namespace overlay {
38using namespace utils;
39
40Overlay::Overlay() {
41    PipeBook::NUM_PIPES = qdutils::MDPVersion::getInstance().getTotalPipes();
42    for(int i = 0; i < PipeBook::NUM_PIPES; i++) {
43        mPipeBook[i].init();
44    }
45
46    mDumpStr[0] = '\0';
47}
48
49Overlay::~Overlay() {
50    for(int i = 0; i < PipeBook::NUM_PIPES; i++) {
51        mPipeBook[i].destroy();
52    }
53}
54
55void Overlay::configBegin() {
56    for(int i = 0; i < PipeBook::NUM_PIPES; i++) {
57        //Mark as available for this round.
58        PipeBook::resetUse(i);
59        PipeBook::resetAllocation(i);
60    }
61    mDumpStr[0] = '\0';
62}
63
64void Overlay::configDone() {
65    if(PipeBook::pipeUsageUnchanged()) return;
66
67    for(int i = 0; i < PipeBook::NUM_PIPES; i++) {
68        if(PipeBook::isNotUsed(i)) {
69            //Forces UNSET on pipes, flushes rotator memory and session, closes
70            //fds
71            if(mPipeBook[i].valid()) {
72                char str[32];
73                sprintf(str, "Unset pipe=%s dpy=%d; ",
74                        PipeBook::getDestStr((eDest)i), mPipeBook[i].mDisplay);
75                strncat(mDumpStr, str, strlen(str));
76            }
77            mPipeBook[i].destroy();
78        }
79    }
80    dump();
81    PipeBook::save();
82}
83
84eDest Overlay::nextPipe(eMdpPipeType type, int dpy) {
85    eDest dest = OV_INVALID;
86
87    for(int i = 0; i < PipeBook::NUM_PIPES; i++) {
88        //Match requested pipe type
89        if(type == OV_MDP_PIPE_ANY || type == PipeBook::getPipeType((eDest)i)) {
90            //If the pipe is not allocated to any display or used by the
91            //requesting display already in previous round.
92            if((mPipeBook[i].mDisplay == PipeBook::DPY_UNUSED ||
93                    mPipeBook[i].mDisplay == dpy) &&
94                    PipeBook::isNotAllocated(i)) {
95                dest = (eDest)i;
96                PipeBook::setAllocation(i);
97                break;
98            }
99        }
100    }
101
102    if(dest != OV_INVALID) {
103        int index = (int)dest;
104        //If the pipe is not registered with any display OR if the pipe is
105        //requested again by the same display using it, then go ahead.
106        mPipeBook[index].mDisplay = dpy;
107        if(not mPipeBook[index].valid()) {
108            mPipeBook[index].mPipe = new GenericPipe(dpy);
109            char str[32];
110            snprintf(str, 32, "Set pipe=%s dpy=%d; ",
111                     PipeBook::getDestStr(dest), dpy);
112            strncat(mDumpStr, str, strlen(str));
113        }
114    } else {
115        ALOGD_IF(PIPE_DEBUG, "Pipe unavailable type=%d display=%d",
116                (int)type, dpy);
117    }
118
119    return dest;
120}
121
122bool Overlay::commit(utils::eDest dest) {
123    bool ret = false;
124    int index = (int)dest;
125    validate(index);
126
127    if(mPipeBook[index].mPipe->commit()) {
128        ret = true;
129        PipeBook::setUse((int)dest);
130    } else {
131        PipeBook::resetUse((int)dest);
132        int dpy = mPipeBook[index].mDisplay;
133        for(int i = 0; i < PipeBook::NUM_PIPES; i++)
134            if (mPipeBook[i].mDisplay == dpy)
135                PipeBook::resetAllocation(i);
136    }
137    return ret;
138}
139
140bool Overlay::queueBuffer(int fd, uint32_t offset,
141        utils::eDest dest) {
142    int index = (int)dest;
143    bool ret = false;
144    validate(index);
145    //Queue only if commit() has succeeded (and the bit set)
146    if(PipeBook::isUsed((int)dest)) {
147        ret = mPipeBook[index].mPipe->queueBuffer(fd, offset);
148    }
149    return ret;
150}
151
152void Overlay::setCrop(const utils::Dim& d,
153        utils::eDest dest) {
154    int index = (int)dest;
155    validate(index);
156    mPipeBook[index].mPipe->setCrop(d);
157}
158
159void Overlay::setPosition(const utils::Dim& d,
160        utils::eDest dest) {
161    int index = (int)dest;
162    validate(index);
163    mPipeBook[index].mPipe->setPosition(d);
164}
165
166void Overlay::setTransform(const int orient,
167        utils::eDest dest) {
168    int index = (int)dest;
169    validate(index);
170
171    utils::eTransform transform =
172            static_cast<utils::eTransform>(orient);
173    mPipeBook[index].mPipe->setTransform(transform);
174
175}
176
177void Overlay::setSource(const utils::PipeArgs args,
178        utils::eDest dest) {
179    int index = (int)dest;
180    validate(index);
181
182    PipeArgs newArgs(args);
183    if(PipeBook::getPipeType(dest) == OV_MDP_PIPE_VG) {
184        setMdpFlags(newArgs.mdpFlags, OV_MDP_PIPE_SHARE);
185    } else {
186        clearMdpFlags(newArgs.mdpFlags, OV_MDP_PIPE_SHARE);
187    }
188
189    if(PipeBook::getPipeType(dest) == OV_MDP_PIPE_DMA) {
190        setMdpFlags(newArgs.mdpFlags, OV_MDP_PIPE_FORCE_DMA);
191    } else {
192        clearMdpFlags(newArgs.mdpFlags, OV_MDP_PIPE_FORCE_DMA);
193    }
194
195    mPipeBook[index].mPipe->setSource(newArgs);
196}
197
198void Overlay::setVisualParams(const MetaData_t& metadata, utils::eDest dest) {
199    int index = (int)dest;
200    validate(index);
201    mPipeBook[index].mPipe->setVisualParams(metadata);
202}
203
204Overlay* Overlay::getInstance() {
205    if(sInstance == NULL) {
206        sInstance = new Overlay();
207    }
208    return sInstance;
209}
210
211// Clears any VG pipes allocated to the fb devices
212// Generates a LUT for pipe types.
213int Overlay::initOverlay() {
214    int mdpVersion = qdutils::MDPVersion::getInstance().getMDPVersion();
215    int numPipesXType[OV_MDP_PIPE_ANY] = {0};
216    numPipesXType[OV_MDP_PIPE_RGB] =
217            qdutils::MDPVersion::getInstance().getRGBPipes();
218    numPipesXType[OV_MDP_PIPE_VG] =
219            qdutils::MDPVersion::getInstance().getVGPipes();
220    numPipesXType[OV_MDP_PIPE_DMA] =
221            qdutils::MDPVersion::getInstance().getDMAPipes();
222
223    int index = 0;
224    for(int X = 0; X < (int)OV_MDP_PIPE_ANY; X++) { //iterate over types
225        for(int j = 0; j < numPipesXType[X]; j++) { //iterate over num
226            PipeBook::pipeTypeLUT[index] = (utils::eMdpPipeType)X;
227            index++;
228        }
229    }
230
231    if (mdpVersion < qdutils::MDSS_V5) {
232        msmfb_mixer_info_req  req;
233        mdp_mixer_info *minfo = NULL;
234        char name[64];
235        int fd = -1;
236        for(int i = 0; i < NUM_FB_DEVICES; i++) {
237            snprintf(name, 64, FB_DEVICE_TEMPLATE, i);
238            ALOGD("initoverlay:: opening the device:: %s", name);
239            fd = ::open(name, O_RDWR, 0);
240            if(fd < 0) {
241                ALOGE("cannot open framebuffer(%d)", i);
242                return -1;
243            }
244            //Get the mixer configuration */
245            req.mixer_num = i;
246            if (ioctl(fd, MSMFB_MIXER_INFO, &req) == -1) {
247                ALOGE("ERROR: MSMFB_MIXER_INFO ioctl failed");
248                close(fd);
249                return -1;
250            }
251            minfo = req.info;
252            for (int j = 0; j < req.cnt; j++) {
253                ALOGD("ndx=%d num=%d z_order=%d", minfo->pndx, minfo->pnum,
254                      minfo->z_order);
255                // clear any pipe connected to mixer including base pipe.
256                int index = minfo->pndx;
257                ALOGD("Unset overlay with index: %d at mixer %d", index, i);
258                if(ioctl(fd, MSMFB_OVERLAY_UNSET, &index) == -1) {
259                    ALOGE("ERROR: MSMFB_OVERLAY_UNSET failed");
260                    close(fd);
261                    return -1;
262                }
263                minfo++;
264            }
265            close(fd);
266            fd = -1;
267        }
268    }
269    return 0;
270}
271
272void Overlay::dump() const {
273    if(strlen(mDumpStr)) { //dump only on state change
274        ALOGD_IF(PIPE_DEBUG, "%s\n", mDumpStr);
275    }
276}
277
278void Overlay::getDump(char *buf, size_t len) {
279    int totalPipes = 0;
280    const char *str = "\nOverlay State\n==========================\n";
281    strncat(buf, str, strlen(str));
282    for(int i = 0; i < PipeBook::NUM_PIPES; i++) {
283        if(mPipeBook[i].valid()) {
284            mPipeBook[i].mPipe->getDump(buf, len);
285            char str[64] = {'\0'};
286            snprintf(str, 64, "Attached to dpy=%d\n\n", mPipeBook[i].mDisplay);
287            strncat(buf, str, strlen(str));
288            totalPipes++;
289        }
290    }
291    char str_pipes[64] = {'\0'};
292    snprintf(str_pipes, 64, "Pipes used=%d\n\n", totalPipes);
293    strncat(buf, str_pipes, strlen(str_pipes));
294}
295
296void Overlay::PipeBook::init() {
297    mPipe = NULL;
298    mDisplay = DPY_UNUSED;
299}
300
301void Overlay::PipeBook::destroy() {
302    if(mPipe) {
303        delete mPipe;
304        mPipe = NULL;
305    }
306    mDisplay = DPY_UNUSED;
307}
308
309Overlay* Overlay::sInstance = 0;
310int Overlay::sExtFbIndex = 1;
311int Overlay::PipeBook::NUM_PIPES = 0;
312int Overlay::PipeBook::sPipeUsageBitmap = 0;
313int Overlay::PipeBook::sLastUsageBitmap = 0;
314int Overlay::PipeBook::sAllocatedBitmap = 0;
315utils::eMdpPipeType Overlay::PipeBook::pipeTypeLUT[utils::OV_MAX] =
316    {utils::OV_MDP_PIPE_ANY};
317
318}; // namespace overlay
319