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 
37 namespace overlay {
38 using namespace utils;
39 
Overlay()40 Overlay::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 
~Overlay()49 Overlay::~Overlay() {
50     for(int i = 0; i < PipeBook::NUM_PIPES; i++) {
51         mPipeBook[i].destroy();
52     }
53 }
54 
configBegin()55 void 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 
configDone()64 void 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 
nextPipe(eMdpPipeType type,int dpy)84 eDest 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 
commit(utils::eDest dest)122 bool 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 
queueBuffer(int fd,uint32_t offset,utils::eDest dest)140 bool 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 
setCrop(const utils::Dim & d,utils::eDest dest)152 void 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 
setPosition(const utils::Dim & d,utils::eDest dest)159 void 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 
setTransform(const int orient,utils::eDest dest)166 void 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 
setSource(const utils::PipeArgs args,utils::eDest dest)177 void 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 
setVisualParams(const MetaData_t & metadata,utils::eDest dest)198 void 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 
getInstance()204 Overlay* 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.
initOverlay()213 int 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 
dump() const272 void Overlay::dump() const {
273     if(strlen(mDumpStr)) { //dump only on state change
274         ALOGD_IF(PIPE_DEBUG, "%s\n", mDumpStr);
275     }
276 }
277 
getDump(char * buf,size_t len)278 void 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 
init()296 void Overlay::PipeBook::init() {
297     mPipe = NULL;
298     mDisplay = DPY_UNUSED;
299 }
300 
destroy()301 void Overlay::PipeBook::destroy() {
302     if(mPipe) {
303         delete mPipe;
304         mPipe = NULL;
305     }
306     mDisplay = DPY_UNUSED;
307 }
308 
309 Overlay* Overlay::sInstance = 0;
310 int Overlay::sExtFbIndex = 1;
311 int Overlay::PipeBook::NUM_PIPES = 0;
312 int Overlay::PipeBook::sPipeUsageBitmap = 0;
313 int Overlay::PipeBook::sLastUsageBitmap = 0;
314 int Overlay::PipeBook::sAllocatedBitmap = 0;
315 utils::eMdpPipeType Overlay::PipeBook::pipeTypeLUT[utils::OV_MAX] =
316     {utils::OV_MDP_PIPE_ANY};
317 
318 }; // namespace overlay
319