1 /*
2 * Copyright (c) 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 "overlayWriteback.h"
32 #include "mdpWrapper.h"
33
34 #define SIZE_1M 0x00100000
35
36 namespace overlay {
37
38 //=========== class WritebackMem ==============================================
manageMem(uint32_t size,bool isSecure)39 bool WritebackMem::manageMem(uint32_t size, bool isSecure) {
40 if(mBuf.bufSz() == size) {
41 return true;
42 }
43 if(mBuf.valid()) {
44 if(!mBuf.close()) {
45 ALOGE("%s error closing mem", __func__);
46 return false;
47 }
48 }
49 return alloc(size, isSecure);
50 }
51
alloc(uint32_t size,bool isSecure)52 bool WritebackMem::alloc(uint32_t size, bool isSecure) {
53 if(!mBuf.open(NUM_BUFS, size, isSecure)){
54 ALOGE("%s: Failed to open", __func__);
55 mBuf.close();
56 return false;
57 }
58
59 OVASSERT(MAP_FAILED != mBuf.addr(), "MAP failed");
60 OVASSERT(mBuf.getFD() != -1, "getFd is -1");
61
62 mCurrOffsetIndex = 0;
63 for (uint32_t i = 0; i < NUM_BUFS; i++) {
64 mOffsets[i] = i * size;
65 }
66 return true;
67 }
68
dealloc()69 bool WritebackMem::dealloc() {
70 bool ret = true;
71 if(mBuf.valid()) {
72 ret = mBuf.close();
73 }
74 return ret;
75 }
76
77 //=========== class Writeback =================================================
Writeback()78 Writeback::Writeback() : mXres(0), mYres(0), mOpFmt(-1), mSecure(false) {
79 int fbNum = Overlay::getFbForDpy(Overlay::DPY_WRITEBACK);
80 if(!utils::openDev(mFd, fbNum, Res::fbPath, O_RDWR)) {
81 ALOGE("%s failed to init %s", __func__, Res::fbPath);
82 return;
83 }
84 startSession();
85 }
86
~Writeback()87 Writeback::~Writeback() {
88 stopSession();
89 if (!mFd.close()) {
90 ALOGE("%s error closing fd", __func__);
91 }
92 }
93
startSession()94 bool Writeback::startSession() {
95 if(!mdp_wrapper::wbInitStart(mFd.getFD())) {
96 ALOGE("%s failed", __func__);
97 return false;
98 }
99 return true;
100 }
101
stopSession()102 bool Writeback::stopSession() {
103 if(mFd.valid()) {
104 if(!mdp_wrapper::wbStopTerminate(mFd.getFD())) {
105 ALOGE("%s failed", __func__);
106 return false;
107 }
108 } else {
109 ALOGE("%s Invalid fd", __func__);
110 return false;
111 }
112 return true;
113 }
114
configureDpyInfo(int xres,int yres)115 bool Writeback::configureDpyInfo(int xres, int yres) {
116 if(mXres != xres || mYres != yres) {
117 fb_var_screeninfo vinfo;
118 memset(&vinfo, 0, sizeof(fb_var_screeninfo));
119 if(!mdp_wrapper::getVScreenInfo(mFd.getFD(), vinfo)) {
120 ALOGE("%s failed", __func__);
121 return false;
122 }
123 vinfo.xres = xres;
124 vinfo.yres = yres;
125 vinfo.xres_virtual = xres;
126 vinfo.yres_virtual = yres;
127 vinfo.xoffset = 0;
128 vinfo.yoffset = 0;
129 if(!mdp_wrapper::setVScreenInfo(mFd.getFD(), vinfo)) {
130 ALOGE("%s failed", __func__);
131 return false;
132 }
133 mXres = xres;
134 mYres = yres;
135 }
136 return true;
137 }
138
configureMemory(uint32_t size)139 bool Writeback::configureMemory(uint32_t size) {
140 if(!mWbMem.manageMem(size, mSecure)) {
141 ALOGE("%s failed, memory failure", __func__);
142 return false;
143 }
144 return true;
145 }
146
queueBuffer(int opFd,uint32_t opOffset)147 bool Writeback::queueBuffer(int opFd, uint32_t opOffset) {
148 memset(&mFbData, 0, sizeof(struct msmfb_data));
149 //Queue
150 mFbData.offset = opOffset;
151 mFbData.memory_id = opFd;
152 mFbData.id = 0;
153 mFbData.flags = 0;
154 if(!mdp_wrapper::wbQueueBuffer(mFd.getFD(), mFbData)) {
155 ALOGE("%s: queuebuffer failed", __func__);
156 return false;
157 }
158 return true;
159 }
160
dequeueBuffer()161 bool Writeback::dequeueBuffer() {
162 //Dequeue
163 mFbData.flags = MSMFB_WRITEBACK_DEQUEUE_BLOCKING;
164 if(!mdp_wrapper::wbDequeueBuffer(mFd.getFD(), mFbData)) {
165 ALOGE("%s: dequeuebuffer failed", __func__);
166 return false;
167 }
168 return true;
169 }
170
writeSync(int opFd,uint32_t opOffset)171 bool Writeback::writeSync(int opFd, uint32_t opOffset) {
172 if(!queueBuffer(opFd, opOffset)) {
173 return false;
174 }
175 if(!Overlay::displayCommit(mFd.getFD())) {
176 return false;
177 }
178 if(!dequeueBuffer()) {
179 return false;
180 }
181 return true;
182 }
183
writeSync()184 bool Writeback::writeSync() {
185 mWbMem.useNextBuffer();
186 return writeSync(mWbMem.getDstFd(), mWbMem.getOffset());
187 }
188
setOutputFormat(int mdpFormat)189 bool Writeback::setOutputFormat(int mdpFormat) {
190 if(mdpFormat != mOpFmt) {
191 struct msmfb_metadata metadata;
192 memset(&metadata, 0 , sizeof(metadata));
193 metadata.op = metadata_op_wb_format;
194 metadata.data.mixer_cfg.writeback_format = mdpFormat;
195 if (ioctl(mFd.getFD(), MSMFB_METADATA_SET, &metadata) < 0) {
196 ALOGE("Error setting MDP Writeback format");
197 return false;
198 }
199 mOpFmt = mdpFormat;
200 }
201 return true;
202 }
203
getOutputFormat()204 int Writeback::getOutputFormat() {
205 if(mOpFmt < 0) {
206 struct msmfb_metadata metadata;
207 memset(&metadata, 0 , sizeof(metadata));
208 metadata.op = metadata_op_wb_format;
209 if (ioctl(mFd.getFD(), MSMFB_METADATA_GET, &metadata) < 0) {
210 ALOGE("Error retrieving MDP Writeback format");
211 return -1;
212 }
213 mOpFmt = metadata.data.mixer_cfg.writeback_format;
214 }
215 return mOpFmt;
216 }
217
setSecure(bool isSecure)218 bool Writeback::setSecure(bool isSecure) {
219 if(isSecure != mSecure) {
220 // Call IOCTL to set WB interface as secure
221 struct msmfb_metadata metadata;
222 memset(&metadata, 0 , sizeof(metadata));
223 metadata.op = metadata_op_wb_secure;
224 metadata.data.secure_en = isSecure;
225 if (ioctl(mFd.getFD(), MSMFB_METADATA_SET, &metadata) < 0) {
226 ALOGE("Error setting MDP WB secure");
227 return false;
228 }
229 mSecure = isSecure;
230 }
231 return true;
232 }
233
234 //static
235
getInstance()236 Writeback *Writeback::getInstance() {
237 if(sWb == NULL) {
238 sWb = new Writeback();
239 }
240 sUsed = true;
241 return sWb;
242 }
243
configDone()244 void Writeback::configDone() {
245 if(sUsed == false && sWb) {
246 delete sWb;
247 sWb = NULL;
248 }
249 }
250
clear()251 void Writeback::clear() {
252 sUsed = false;
253 if(sWb) {
254 delete sWb;
255 sWb = NULL;
256 }
257 }
258
getDump(char * buf,size_t len)259 bool Writeback::getDump(char *buf, size_t len) {
260 if(sWb) {
261 utils::getDump(buf, len, "WBData", sWb->mFbData);
262 char str[4] = {'\0'};
263 snprintf(str, 4, "\n");
264 strlcat(buf, str, len);
265 return true;
266 }
267 return false;
268 }
269
270 Writeback *Writeback::sWb = 0;
271 bool Writeback::sUsed = false;
272
273 } //namespace overlay
274