1 /*
2 * Copyright (C) 2008 The Android Open Source Project
3 * Copyright (c) 2010-2013, The Linux Foundation. All rights reserved.
4 * Not a Contribution, Apache license notifications and license are retained
5 * for attribution purposes only.
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 */
19
20 #include "overlayUtils.h"
21 #include "overlayRotator.h"
22
23 #ifdef VENUS_COLOR_FORMAT
24 #include <media/msm_media_info.h>
25 #else
26 #define VENUS_BUFFER_SIZE(args...) 0
27 #endif
28
29 #ifndef MDSS_MDP_ROT_ONLY
30 #define MDSS_MDP_ROT_ONLY 0x80
31 #endif
32
33 #define SIZE_1M 0x00100000
34 #define MDSS_ROT_MASK (MDP_ROT_90 | MDP_FLIP_UD | MDP_FLIP_LR)
35
36 namespace ovutils = overlay::utils;
37
38 namespace overlay {
MdssRot()39 MdssRot::MdssRot() {
40 reset();
41 init();
42 }
43
~MdssRot()44 MdssRot::~MdssRot() { close(); }
45
enabled() const46 bool MdssRot::enabled() const { return mEnabled; }
47
setRotations(uint32_t flags)48 void MdssRot::setRotations(uint32_t flags) { mRotInfo.flags |= flags; }
49
getDstMemId() const50 int MdssRot::getDstMemId() const {
51 return mRotData.dst_data.memory_id;
52 }
53
getDstOffset() const54 uint32_t MdssRot::getDstOffset() const {
55 return mRotData.dst_data.offset;
56 }
57
getDstFormat() const58 uint32_t MdssRot::getDstFormat() const {
59 //For mdss src and dst formats are same
60 return mRotInfo.src.format;
61 }
62
getSessId() const63 uint32_t MdssRot::getSessId() const { return mRotInfo.id; }
64
init()65 bool MdssRot::init() {
66 if(!utils::openDev(mFd, 0, Res::fbPath, O_RDWR)) {
67 ALOGE("MdssRot failed to init fb0");
68 return false;
69 }
70 return true;
71 }
72
setSource(const overlay::utils::Whf & awhf)73 void MdssRot::setSource(const overlay::utils::Whf& awhf) {
74 utils::Whf whf(awhf);
75
76 mRotInfo.src.format = whf.format;
77
78 mRotInfo.src.width = whf.w;
79 mRotInfo.src.height = whf.h;
80
81 mRotInfo.src_rect.w = whf.w;
82 mRotInfo.src_rect.h = whf.h;
83
84 mRotInfo.dst_rect.w = whf.w;
85 mRotInfo.dst_rect.h = whf.h;
86 }
87
setSource(const overlay::utils::Whf & awhf,const overlay::utils::Whf & owhf)88 void MdssRot::setSource(const overlay::utils::Whf& awhf,
89 const overlay::utils::Whf& owhf) {
90 setSource(awhf);
91 }
92
setDownscale(int ds)93 void MdssRot::setDownscale(int ds) {}
94
setFlags(const utils::eMdpFlags & flags)95 void MdssRot::setFlags(const utils::eMdpFlags& flags) {
96 mRotInfo.flags |= flags;
97 }
98
setTransform(const utils::eTransform & rot)99 void MdssRot::setTransform(const utils::eTransform& rot)
100 {
101 // reset rotation flags to avoid stale orientation values
102 mRotInfo.flags &= ~MDSS_ROT_MASK;
103 int flags = utils::getMdpOrient(rot);
104 if (flags != -1)
105 setRotations(flags);
106 //getMdpOrient will switch the flips if the source is 90 rotated.
107 //Clients in Android dont factor in 90 rotation while deciding the flip.
108 mOrientation = static_cast<utils::eTransform>(flags);
109 ALOGE_IF(DEBUG_OVERLAY, "%s: rot=%d", __FUNCTION__, flags);
110 }
111
doTransform()112 void MdssRot::doTransform() {
113 if(mOrientation & utils::OVERLAY_TRANSFORM_ROT_90)
114 utils::swap(mRotInfo.dst_rect.w, mRotInfo.dst_rect.h);
115 }
116
commit()117 bool MdssRot::commit() {
118 doTransform();
119 mRotInfo.flags |= MDSS_MDP_ROT_ONLY;
120 mEnabled = true;
121 if(!overlay::mdp_wrapper::setOverlay(mFd.getFD(), mRotInfo)) {
122 ALOGE("MdssRot commit failed!");
123 dump();
124 return (mEnabled = false);
125 }
126 mRotData.id = mRotInfo.id;
127 return true;
128 }
129
queueBuffer(int fd,uint32_t offset)130 bool MdssRot::queueBuffer(int fd, uint32_t offset) {
131 if(enabled()) {
132 mRotData.data.memory_id = fd;
133 mRotData.data.offset = offset;
134
135 remap(RotMem::Mem::ROT_NUM_BUFS);
136 OVASSERT(mMem.curr().m.numBufs(), "queueBuffer numbufs is 0");
137
138 mRotData.dst_data.offset =
139 mMem.curr().mRotOffset[mMem.curr().mCurrOffset];
140 mMem.curr().mCurrOffset =
141 (mMem.curr().mCurrOffset + 1) % mMem.curr().m.numBufs();
142
143 if(!overlay::mdp_wrapper::play(mFd.getFD(), mRotData)) {
144 ALOGE("MdssRot play failed!");
145 dump();
146 return false;
147 }
148
149 // if the prev mem is valid, we need to close
150 if(mMem.prev().valid()) {
151 // FIXME if no wait for vsync the above
152 // play will return immediatly and might cause
153 // tearing when prev.close is called.
154 if(!mMem.prev().close()) {
155 ALOGE("%s error in closing prev rot mem", __FUNCTION__);
156 return false;
157 }
158 }
159 }
160 return true;
161 }
162
open_i(uint32_t numbufs,uint32_t bufsz)163 bool MdssRot::open_i(uint32_t numbufs, uint32_t bufsz)
164 {
165 OvMem mem;
166 OVASSERT(MAP_FAILED == mem.addr(), "MAP failed in open_i");
167 bool isSecure = mRotInfo.flags & utils::OV_MDP_SECURE_OVERLAY_SESSION;
168
169 if(!mem.open(numbufs, bufsz, isSecure)){
170 ALOGE("%s: Failed to open", __func__);
171 mem.close();
172 return false;
173 }
174
175 OVASSERT(MAP_FAILED != mem.addr(), "MAP failed");
176 OVASSERT(mem.getFD() != -1, "getFd is -1");
177
178 mRotData.dst_data.memory_id = mem.getFD();
179 mRotData.dst_data.offset = 0;
180 mMem.curr().m = mem;
181 return true;
182 }
183
remap(uint32_t numbufs)184 bool MdssRot::remap(uint32_t numbufs) {
185 // Calculate the size based on rotator's dst format, w and h.
186 uint32_t opBufSize = calcOutputBufSize();
187 // If current size changed, remap
188 if(opBufSize == mMem.curr().size()) {
189 ALOGE_IF(DEBUG_OVERLAY, "%s: same size %d", __FUNCTION__, opBufSize);
190 return true;
191 }
192
193 ALOGE_IF(DEBUG_OVERLAY, "%s: size changed - remapping", __FUNCTION__);
194 OVASSERT(!mMem.prev().valid(), "Prev should not be valid");
195
196 // ++mMem will make curr to be prev, and prev will be curr
197 ++mMem;
198 if(!open_i(numbufs, opBufSize)) {
199 ALOGE("%s Error could not open", __FUNCTION__);
200 return false;
201 }
202 for (uint32_t i = 0; i < numbufs; ++i) {
203 mMem.curr().mRotOffset[i] = i * opBufSize;
204 }
205 return true;
206 }
207
close()208 bool MdssRot::close() {
209 bool success = true;
210 if(mFd.valid() && (getSessId() != (uint32_t) MSMFB_NEW_REQUEST)) {
211 if(!mdp_wrapper::unsetOverlay(mFd.getFD(), getSessId())) {
212 ALOGE("MdssRot::close unsetOverlay failed, fd=%d sessId=%d",
213 mFd.getFD(), getSessId());
214 success = false;
215 }
216 }
217
218 if (!mFd.close()) {
219 ALOGE("Mdss Rot error closing fd");
220 success = false;
221 }
222 if (!mMem.close()) {
223 ALOGE("Mdss Rot error closing mem");
224 success = false;
225 }
226 reset();
227 return success;
228 }
229
reset()230 void MdssRot::reset() {
231 ovutils::memset0(mRotInfo);
232 ovutils::memset0(mRotData);
233 mRotData.data.memory_id = -1;
234 mRotInfo.id = MSMFB_NEW_REQUEST;
235 ovutils::memset0(mMem.curr().mRotOffset);
236 ovutils::memset0(mMem.prev().mRotOffset);
237 mMem.curr().mCurrOffset = 0;
238 mMem.prev().mCurrOffset = 0;
239 mOrientation = utils::OVERLAY_TRANSFORM_0;
240 }
241
dump() const242 void MdssRot::dump() const {
243 ALOGE("== Dump MdssRot start ==");
244 mFd.dump();
245 mMem.curr().m.dump();
246 mdp_wrapper::dump("mRotInfo", mRotInfo);
247 mdp_wrapper::dump("mRotData", mRotData);
248 ALOGE("== Dump MdssRot end ==");
249 }
250
calcOutputBufSize()251 uint32_t MdssRot::calcOutputBufSize() {
252 uint32_t opBufSize = 0;
253 ovutils::Whf destWhf(mRotInfo.dst_rect.w, mRotInfo.dst_rect.h,
254 mRotInfo.src.format); //mdss src and dst formats are same.
255
256 opBufSize = Rotator::calcOutputBufSize(destWhf);
257
258 if (mRotInfo.flags & utils::OV_MDP_SECURE_OVERLAY_SESSION)
259 opBufSize = utils::align(opBufSize, SIZE_1M);
260
261 return opBufSize;
262 }
263
getDump(char * buf,size_t len) const264 void MdssRot::getDump(char *buf, size_t len) const {
265 ovutils::getDump(buf, len, "MdssRotCtrl(mdp_overlay)", mRotInfo);
266 ovutils::getDump(buf, len, "MdssRotData(msmfb_overlay_data)", mRotData);
267 }
268
269 } // namespace overlay
270