1 /*
2 * Copyright (c) 2013-15, 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 CLIENTS; 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 <hwc_qclient.h>
31 #include <IQService.h>
32 #include <hwc_utils.h>
33 #include <mdp_version.h>
34 #include <hwc_mdpcomp.h>
35 #include <hwc_virtual.h>
36 #include <overlay.h>
37 #include <display_config.h>
38 #include <hwc_qdcm.h>
39
40 #define QCLIENT_DEBUG 0
41
42 using namespace android;
43 using namespace qService;
44 using namespace qhwc;
45 using namespace overlay;
46 using namespace qdutils;
47 using namespace qQdcm;
48
49 namespace qClient {
50
51 // ----------------------------------------------------------------------------
QClient(hwc_context_t * ctx)52 QClient::QClient(hwc_context_t *ctx) : mHwcContext(ctx),
53 mMPDeathNotifier(new MPDeathNotifier(ctx))
54 {
55 ALOGD_IF(QCLIENT_DEBUG, "QClient Constructor invoked");
56 }
57
~QClient()58 QClient::~QClient()
59 {
60 ALOGD_IF(QCLIENT_DEBUG,"QClient Destructor invoked");
61 }
62
securing(hwc_context_t * ctx,uint32_t startEnd)63 static void securing(hwc_context_t *ctx, uint32_t startEnd) {
64 //The only way to make this class in this process subscribe to media
65 //player's death.
66 IMediaDeathNotifier::getMediaPlayerService();
67
68 ctx->mDrawLock.lock();
69 ctx->mSecuring = startEnd;
70 //We're done securing
71 if(startEnd == IQService::END)
72 ctx->mSecureMode = true;
73 ctx->mDrawLock.unlock();
74
75 if(ctx->proc)
76 ctx->proc->invalidate(ctx->proc);
77 }
78
unsecuring(hwc_context_t * ctx,uint32_t startEnd)79 static void unsecuring(hwc_context_t *ctx, uint32_t startEnd) {
80 ctx->mDrawLock.lock();
81 ctx->mSecuring = startEnd;
82 //We're done unsecuring
83 if(startEnd == IQService::END)
84 ctx->mSecureMode = false;
85 ctx->mDrawLock.unlock();
86
87 if(ctx->proc)
88 ctx->proc->invalidate(ctx->proc);
89 }
90
died()91 void QClient::MPDeathNotifier::died() {
92 mHwcContext->mDrawLock.lock();
93 ALOGD_IF(QCLIENT_DEBUG, "Media Player died");
94 mHwcContext->mSecuring = false;
95 mHwcContext->mSecureMode = false;
96 mHwcContext->mDrawLock.unlock();
97 if(mHwcContext->proc)
98 mHwcContext->proc->invalidate(mHwcContext->proc);
99 }
100
screenRefresh(hwc_context_t * ctx)101 static android::status_t screenRefresh(hwc_context_t *ctx) {
102 status_t result = NO_INIT;
103 if(ctx->proc) {
104 ctx->proc->invalidate(ctx->proc);
105 result = NO_ERROR;
106 }
107 return result;
108 }
109
setExtOrientation(hwc_context_t * ctx,uint32_t orientation)110 static void setExtOrientation(hwc_context_t *ctx, uint32_t orientation) {
111 ctx->mExtOrientation = orientation;
112 }
113
isExternalConnected(hwc_context_t * ctx,Parcel * outParcel)114 static void isExternalConnected(hwc_context_t* ctx, Parcel* outParcel) {
115 int connected;
116 connected = ctx->dpyAttr[HWC_DISPLAY_EXTERNAL].connected ? 1 : 0;
117 outParcel->writeInt32(connected);
118 }
119
getDisplayAttributes(hwc_context_t * ctx,const Parcel * inParcel,Parcel * outParcel)120 static void getDisplayAttributes(hwc_context_t* ctx, const Parcel* inParcel,
121 Parcel* outParcel) {
122 int dpy = inParcel->readInt32();
123 outParcel->writeInt32(ctx->dpyAttr[dpy].vsync_period);
124 if (ctx->dpyAttr[dpy].customFBSize) {
125 outParcel->writeInt32(ctx->dpyAttr[dpy].xres_new);
126 outParcel->writeInt32(ctx->dpyAttr[dpy].yres_new);
127 } else {
128 outParcel->writeInt32(ctx->dpyAttr[dpy].xres);
129 outParcel->writeInt32(ctx->dpyAttr[dpy].yres);
130 }
131 outParcel->writeFloat(ctx->dpyAttr[dpy].xdpi);
132 outParcel->writeFloat(ctx->dpyAttr[dpy].ydpi);
133 //XXX: Need to check what to return for HDMI
134 outParcel->writeInt32(ctx->mMDP.panel);
135 }
setHSIC(const Parcel * inParcel)136 static void setHSIC(const Parcel* inParcel) {
137 int dpy = inParcel->readInt32();
138 ALOGD_IF(0, "In %s: dpy = %d", __FUNCTION__, dpy);
139 HSICData_t hsic_data;
140 hsic_data.hue = inParcel->readInt32();
141 hsic_data.saturation = inParcel->readFloat();
142 hsic_data.intensity = inParcel->readInt32();
143 hsic_data.contrast = inParcel->readFloat();
144 //XXX: Actually set the HSIC data through ABL lib
145 }
146
147
setBufferMirrorMode(hwc_context_t * ctx,uint32_t enable)148 static void setBufferMirrorMode(hwc_context_t *ctx, uint32_t enable) {
149 ctx->mBufferMirrorMode = enable;
150 }
151
getDisplayVisibleRegion(hwc_context_t * ctx,int dpy,Parcel * outParcel)152 static status_t getDisplayVisibleRegion(hwc_context_t* ctx, int dpy,
153 Parcel* outParcel) {
154 // Get the info only if the dpy is valid
155 if(dpy >= HWC_DISPLAY_PRIMARY && dpy <= HWC_DISPLAY_VIRTUAL) {
156 Locker::Autolock _sl(ctx->mDrawLock);
157 if(dpy && (ctx->mExtOrientation || ctx->mBufferMirrorMode)) {
158 // Return the destRect on external, if external orienation
159 // is enabled
160 outParcel->writeInt32(ctx->dpyAttr[dpy].mDstRect.left);
161 outParcel->writeInt32(ctx->dpyAttr[dpy].mDstRect.top);
162 outParcel->writeInt32(ctx->dpyAttr[dpy].mDstRect.right);
163 outParcel->writeInt32(ctx->dpyAttr[dpy].mDstRect.bottom);
164 } else {
165 outParcel->writeInt32(ctx->mViewFrame[dpy].left);
166 outParcel->writeInt32(ctx->mViewFrame[dpy].top);
167 outParcel->writeInt32(ctx->mViewFrame[dpy].right);
168 outParcel->writeInt32(ctx->mViewFrame[dpy].bottom);
169 }
170 return NO_ERROR;
171 } else {
172 ALOGE("In %s: invalid dpy index %d", __FUNCTION__, dpy);
173 return BAD_VALUE;
174 }
175 }
176
177 // USed for setting the secondary(hdmi/wfd) status
setSecondaryDisplayStatus(hwc_context_t * ctx,const Parcel * inParcel)178 static void setSecondaryDisplayStatus(hwc_context_t *ctx,
179 const Parcel* inParcel) {
180 uint32_t dpy = inParcel->readInt32();
181 uint32_t status = inParcel->readInt32();
182 ALOGD_IF(QCLIENT_DEBUG, "%s: dpy = %d status = %s", __FUNCTION__,
183 dpy, getExternalDisplayState(status));
184
185 if(dpy > HWC_DISPLAY_PRIMARY && dpy <= HWC_DISPLAY_VIRTUAL) {
186 if(dpy == HWC_DISPLAY_VIRTUAL && status == qdutils::EXTERNAL_OFFLINE) {
187 ctx->mWfdSyncLock.lock();
188 ctx->mWfdSyncLock.signal();
189 ctx->mWfdSyncLock.unlock();
190 } else if(status == qdutils::EXTERNAL_PAUSE) {
191 handle_pause(ctx, dpy);
192 } else if(status == qdutils::EXTERNAL_RESUME) {
193 handle_resume(ctx, dpy);
194 }
195 } else {
196 ALOGE("%s: Invalid dpy %d", __FUNCTION__, dpy);
197 return;
198 }
199 }
200
201
setViewFrame(hwc_context_t * ctx,const Parcel * inParcel)202 static status_t setViewFrame(hwc_context_t* ctx, const Parcel* inParcel) {
203 int dpy = inParcel->readInt32();
204 if(dpy >= HWC_DISPLAY_PRIMARY && dpy <= HWC_DISPLAY_VIRTUAL) {
205 Locker::Autolock _sl(ctx->mDrawLock);
206 ctx->mViewFrame[dpy].left = inParcel->readInt32();
207 ctx->mViewFrame[dpy].top = inParcel->readInt32();
208 ctx->mViewFrame[dpy].right = inParcel->readInt32();
209 ctx->mViewFrame[dpy].bottom = inParcel->readInt32();
210 ALOGD_IF(QCLIENT_DEBUG, "%s: mViewFrame[%d] = [%d %d %d %d]",
211 __FUNCTION__, dpy,
212 ctx->mViewFrame[dpy].left, ctx->mViewFrame[dpy].top,
213 ctx->mViewFrame[dpy].right, ctx->mViewFrame[dpy].bottom);
214 return NO_ERROR;
215 } else {
216 ALOGE("In %s: invalid dpy index %d", __FUNCTION__, dpy);
217 return BAD_VALUE;
218 }
219 }
220
toggleDynamicDebug(hwc_context_t * ctx,const Parcel * inParcel)221 static void toggleDynamicDebug(hwc_context_t* ctx, const Parcel* inParcel) {
222 int debug_type = inParcel->readInt32();
223 bool enable = !!inParcel->readInt32();
224 ALOGD("%s: debug_type: %d enable:%d",
225 __FUNCTION__, debug_type, enable);
226 Locker::Autolock _sl(ctx->mDrawLock);
227 switch (debug_type) {
228 //break is ignored for DEBUG_ALL to toggle all of them at once
229 case IQService::DEBUG_ALL:
230 case IQService::DEBUG_MDPCOMP:
231 qhwc::MDPComp::dynamicDebug(enable);
232 if (debug_type != IQService::DEBUG_ALL)
233 break;
234 case IQService::DEBUG_VSYNC:
235 ctx->vstate.debug = enable;
236 if (debug_type != IQService::DEBUG_ALL)
237 break;
238 case IQService::DEBUG_VD:
239 HWCVirtualVDS::dynamicDebug(enable);
240 if (debug_type != IQService::DEBUG_ALL)
241 break;
242 case IQService::DEBUG_PIPE_LIFECYCLE:
243 Overlay::debugPipeLifecycle(enable);
244 if (debug_type != IQService::DEBUG_ALL)
245 break;
246 }
247 }
248
setIdleTimeout(hwc_context_t * ctx,const Parcel * inParcel)249 static void setIdleTimeout(hwc_context_t* ctx, const Parcel* inParcel) {
250 uint32_t timeout = (uint32_t)inParcel->readInt32();
251 ALOGD("%s :%u ms", __FUNCTION__, timeout);
252 Locker::Autolock _sl(ctx->mDrawLock);
253 MDPComp::setIdleTimeout(timeout);
254 }
255
configureDynRefreshRate(hwc_context_t * ctx,const Parcel * inParcel)256 static void configureDynRefreshRate(hwc_context_t* ctx,
257 const Parcel* inParcel) {
258 uint32_t op = (uint32_t)inParcel->readInt32();
259 uint32_t refresh_rate = (uint32_t)inParcel->readInt32();
260 MDPVersion& mdpHw = MDPVersion::getInstance();
261 uint32_t dpy = HWC_DISPLAY_PRIMARY;
262
263 if(mdpHw.isDynFpsSupported()) {
264 Locker::Autolock _sl(ctx->mDrawLock);
265
266 switch (op) {
267 case DISABLE_METADATA_DYN_REFRESH_RATE:
268 ctx->mUseMetaDataRefreshRate = false;
269 setRefreshRate(ctx, dpy, ctx->dpyAttr[dpy].refreshRate);
270 break;
271 case ENABLE_METADATA_DYN_REFRESH_RATE:
272 ctx->mUseMetaDataRefreshRate = true;
273 setRefreshRate(ctx, dpy, ctx->dpyAttr[dpy].refreshRate);
274 break;
275 case SET_BINDER_DYN_REFRESH_RATE:
276 if(ctx->mUseMetaDataRefreshRate)
277 ALOGW("%s: Ignoring binder request to change refresh-rate",
278 __FUNCTION__);
279 else {
280 uint32_t rate = roundOff(refresh_rate);
281 if((rate >= mdpHw.getMinFpsSupported() &&
282 rate <= mdpHw.getMaxFpsSupported())) {
283 setRefreshRate(ctx, dpy, rate);
284 } else {
285 ALOGE("%s: Requested refresh-rate should be between \
286 (%d) and (%d). Given (%d)", __FUNCTION__,
287 mdpHw.getMinFpsSupported(),
288 mdpHw.getMaxFpsSupported(), rate);
289 }
290 }
291 break;
292 default:
293 ALOGE("%s: Invalid op %d",__FUNCTION__,op);
294 }
295 }
296 }
297
setPartialUpdateState(hwc_context_t * ctx,uint32_t state)298 static status_t setPartialUpdateState(hwc_context_t *ctx, uint32_t state) {
299 ALOGD("%s: state: %d", __FUNCTION__, state);
300 switch(state) {
301 case IQService::PREF_PARTIAL_UPDATE:
302 if(qhwc::MDPComp::setPartialUpdatePref(ctx, true) < 0)
303 return NO_INIT;
304 return NO_ERROR;
305 case IQService::PREF_POST_PROCESSING:
306 if(qhwc::MDPComp::setPartialUpdatePref(ctx, false) < 0)
307 return NO_INIT;
308 qhwc::MDPComp::enablePartialUpdate(false);
309 return NO_ERROR;
310 case IQService::ENABLE_PARTIAL_UPDATE:
311 qhwc::MDPComp::enablePartialUpdate(true);
312 return NO_ERROR;
313 default:
314 ALOGE("%s: Invalid state", __FUNCTION__);
315 return NO_ERROR;
316 };
317 }
318
toggleScreenUpdate(hwc_context_t * ctx,uint32_t on)319 static void toggleScreenUpdate(hwc_context_t* ctx, uint32_t on) {
320 ALOGD("%s: toggle update: %d", __FUNCTION__, on);
321 if (on == 0) {
322 ctx->mDrawLock.lock();
323 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].isPause = true;
324 ctx->mOverlay->configBegin();
325 ctx->mOverlay->configDone();
326 ctx->mRotMgr->clear();
327 if(!Overlay::displayCommit(ctx->dpyAttr[0].fd)) {
328 ALOGE("%s: Display commit failed", __FUNCTION__);
329 }
330 ctx->mDrawLock.unlock();
331 } else {
332 ctx->mDrawLock.lock();
333 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].isPause = false;
334 ctx->mDrawLock.unlock();
335 ctx->proc->invalidate(ctx->proc);
336 }
337 }
338
notifyCallback(uint32_t command,const Parcel * inParcel,Parcel * outParcel)339 status_t QClient::notifyCallback(uint32_t command, const Parcel* inParcel,
340 Parcel* outParcel) {
341 status_t ret = NO_ERROR;
342
343 switch(command) {
344 case IQService::SECURING:
345 securing(mHwcContext, inParcel->readInt32());
346 break;
347 case IQService::UNSECURING:
348 unsecuring(mHwcContext, inParcel->readInt32());
349 break;
350 case IQService::SCREEN_REFRESH:
351 return screenRefresh(mHwcContext);
352 break;
353 case IQService::EXTERNAL_ORIENTATION:
354 setExtOrientation(mHwcContext, inParcel->readInt32());
355 break;
356 case IQService::BUFFER_MIRRORMODE:
357 setBufferMirrorMode(mHwcContext, inParcel->readInt32());
358 break;
359 case IQService::GET_DISPLAY_VISIBLE_REGION:
360 ret = getDisplayVisibleRegion(mHwcContext, inParcel->readInt32(),
361 outParcel);
362 break;
363 case IQService::CHECK_EXTERNAL_STATUS:
364 isExternalConnected(mHwcContext, outParcel);
365 break;
366 case IQService::GET_DISPLAY_ATTRIBUTES:
367 getDisplayAttributes(mHwcContext, inParcel, outParcel);
368 break;
369 case IQService::SET_HSIC_DATA:
370 setHSIC(inParcel);
371 break;
372 case IQService::SET_SECONDARY_DISPLAY_STATUS:
373 setSecondaryDisplayStatus(mHwcContext, inParcel);
374 break;
375 case IQService::SET_VIEW_FRAME:
376 setViewFrame(mHwcContext, inParcel);
377 break;
378 case IQService::DYNAMIC_DEBUG:
379 toggleDynamicDebug(mHwcContext, inParcel);
380 break;
381 case IQService::SET_IDLE_TIMEOUT:
382 setIdleTimeout(mHwcContext, inParcel);
383 break;
384 case IQService::SET_PARTIAL_UPDATE:
385 ret = setPartialUpdateState(mHwcContext, inParcel->readInt32());
386 break;
387 case IQService::CONFIGURE_DYN_REFRESH_RATE:
388 configureDynRefreshRate(mHwcContext, inParcel);
389 case IQService::QDCM_SVC_CMDS:
390 qdcmCmdsHandler(mHwcContext, inParcel, outParcel);
391 break;
392 case IQService::TOGGLE_SCREEN_UPDATE:
393 toggleScreenUpdate(mHwcContext, inParcel->readInt32());
394 break;
395 default:
396 ret = NO_ERROR;
397 }
398 return ret;
399 }
400
401 }
402