1 /*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <stdint.h>
18 #include <sys/types.h>
19
20 #include <utils/Errors.h>
21 #include <utils/RefBase.h>
22 #include <utils/Timers.h>
23
24 #include <binder/Parcel.h>
25 #include <binder/IInterface.h>
26
27 #include "IExynosHWC.h"
28
29 namespace android {
30
31 enum {
32 ADD_VIRTUAL_DISPLAY_DEVICE = 0,
33 DESTROY_VIRTUAL_DISPLAY_DEVICE,
34 SET_WFD_MODE,
35 GET_WFD_MODE,
36 SEND_WFD_COMMAND,
37 SET_SECURE_VDS_MODE,
38 SET_WFD_OUTPUT_RESOLUTION,
39 GET_WFD_OUTPUT_RESOLUTION,
40 SET_PRESENTATION_MODE,
41 GET_PRESENTATION_MODE,
42 SET_VDS_GLES_FORMAT,
43 HWC_CONTROL,
44 SET_BOOT_FINISHED,
45 SET_VIRTUAL_HPD,
46 GET_EXTERNAL_DISPLAY_CONFIG,
47 SET_EXTERNAL_DISPLAY_CONFIG,
48 ENABLE_MPP,
49 SET_EXTERNAL_VSYNC,
50 SET_DDISCALER,
51 GET_EXTERNAL_HDR_CAPA,
52 SET_SCALE_DOWN_RATIO,
53 SET_HWC_DEBUG = 105,
54 GET_HWC_DEBUG = 106,
55 SET_HWC_FENCE_DEBUG = 107,
56 GET_HWC_FENCE_DEBUG = 108,
57 SET_DISPLAY_DEVICE_MODE = 1000,
58 SET_PANEL_GAMMA_TABLE_SOURCE = 1001,
59 SET_DISPLAY_BRIGHTNESS = 1002,
60 SET_DISPLAY_LHBM = 1003,
61 SET_LBE_CTRL = 1004,
62 SET_MIN_IDLE_REFRESH_RATE = 1005,
63 SET_REFRESH_RATE_THROTTLE = 1006,
64 SET_DISPLAY_RCDLAYER_ENABLED = 1007,
65 TRIGGER_DISPLAY_IDLE_ENTER = 1008,
66 SET_DISPLAY_DBM = 1009,
67 };
68
69 class BpExynosHWCService : public BpInterface<IExynosHWCService> {
70 public:
BpExynosHWCService(const sp<IBinder> & impl)71 BpExynosHWCService(const sp<IBinder>& impl)
72 : BpInterface<IExynosHWCService>(impl)
73 {
74 }
75
addVirtualDisplayDevice()76 virtual int addVirtualDisplayDevice()
77 {
78 Parcel data, reply;
79 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
80 int result = remote()->transact(ADD_VIRTUAL_DISPLAY_DEVICE, data, &reply);
81 if (result == NO_ERROR)
82 result = reply.readInt32();
83 else
84 ALOGE("ADD_VIRTUAL_DISPLAY_DEVICE transact error(%d)", result);
85 return result;
86 }
87
destroyVirtualDisplayDevice()88 virtual int destroyVirtualDisplayDevice()
89 {
90 Parcel data, reply;
91 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
92 int result = remote()->transact(DESTROY_VIRTUAL_DISPLAY_DEVICE, data, &reply);
93 if (result == NO_ERROR)
94 result = reply.readInt32();
95 else
96 ALOGE("DESTROY_VIRTUAL_DISPLAY_DEVICE transact error(%d)", result);
97 return result;
98 }
99
setWFDMode(unsigned int mode)100 virtual int setWFDMode(unsigned int mode)
101 {
102 Parcel data, reply;
103 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
104 data.writeInt32(mode);
105 int result = remote()->transact(SET_WFD_MODE, data, &reply);
106 if (result == NO_ERROR)
107 result = reply.readInt32();
108 else
109 ALOGE("SET_WFD_MODE transact error(%d)", result);
110 return result;
111 }
112
getWFDMode()113 virtual int getWFDMode()
114 {
115 Parcel data, reply;
116 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
117 int result = remote()->transact(GET_WFD_MODE, data, &reply);
118 if (result == NO_ERROR)
119 result = reply.readInt32();
120 else
121 ALOGE("GET_WFD_MODE transact error(%d)", result);
122 return result;
123 }
124
sendWFDCommand(int32_t cmd,int32_t ext1,int32_t ext2)125 virtual int sendWFDCommand(int32_t cmd, int32_t ext1, int32_t ext2)
126 {
127 Parcel data, reply;
128 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
129 data.writeInt32(cmd);
130 data.writeInt32(ext1);
131 data.writeInt32(ext2);
132 int result = remote()->transact(SEND_WFD_COMMAND, data, &reply);
133 if (result == NO_ERROR)
134 result = reply.readInt32();
135 else
136 ALOGE("SEND_WFD_COMMAND transact error(%d)", result);
137 return result;
138 }
139
setSecureVDSMode(unsigned int mode)140 virtual int setSecureVDSMode(unsigned int mode)
141 {
142 Parcel data, reply;
143 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
144 data.writeInt32(mode);
145 int result = remote()->transact(SET_SECURE_VDS_MODE, data, &reply);
146 if (result == NO_ERROR)
147 result = reply.readInt32();
148 else
149 ALOGE("SET_SECURE_VDS_MODE transact error(%d)", result);
150 return result;
151 }
152
setWFDOutputResolution(unsigned int width,unsigned int height)153 virtual int setWFDOutputResolution(unsigned int width, unsigned int height)
154 {
155 Parcel data, reply;
156 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
157 data.writeInt32(width);
158 data.writeInt32(height);
159 int result = remote()->transact(SET_WFD_OUTPUT_RESOLUTION, data, &reply);
160 if (result == NO_ERROR)
161 result = reply.readInt32();
162 else
163 ALOGE("SET_WFD_OUTPUT_RESOLUTION transact error(%d)", result);
164 return result;
165 }
166
getWFDOutputResolution(unsigned int * width,unsigned int * height)167 virtual void getWFDOutputResolution(unsigned int *width, unsigned int *height)
168 {
169 Parcel data, reply;
170 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
171 int result = remote()->transact(GET_WFD_OUTPUT_RESOLUTION, data, &reply);
172 if (result == NO_ERROR) {
173 *width = reply.readInt32();
174 *height = reply.readInt32();
175 } else
176 ALOGE("GET_WFD_OUTPUT_RESOLUTION transact error(%d)", result);
177 }
178
setPresentationMode(bool use)179 virtual void setPresentationMode(bool use)
180 {
181 Parcel data, reply;
182 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
183 data.writeInt32(use);
184 int result = remote()->transact(SET_PRESENTATION_MODE, data, &reply);
185 if (result != NO_ERROR)
186 ALOGE("SET_PRESENTATION_MODE transact error(%d)", result);
187 }
188
getPresentationMode(void)189 virtual int getPresentationMode(void)
190 {
191 Parcel data, reply;
192 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
193 int result = remote()->transact(GET_PRESENTATION_MODE, data, &reply);
194 if (result == NO_ERROR)
195 result = reply.readInt32();
196 else
197 ALOGE("GET_PRESENTATION_MODE transact error(%d)", result);
198 return result;
199 }
200
setVDSGlesFormat(int format)201 virtual int setVDSGlesFormat(int format)
202 {
203 Parcel data, reply;
204 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
205 data.writeInt32(format);
206 int result = remote()->transact(SET_VDS_GLES_FORMAT, data, &reply);
207 if (result == NO_ERROR)
208 result = reply.readInt32();
209 else
210 ALOGE("SET_VDS_GLES_FORMAT transact error(%d)", result);
211 return result;
212 }
213
getExternalDisplayConfigs()214 virtual int getExternalDisplayConfigs()
215 {
216 Parcel data, reply;
217 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
218 int result = remote()->transact(GET_EXTERNAL_DISPLAY_CONFIG, data, &reply);
219 if (result == NO_ERROR)
220 result = reply.readInt32();
221 else
222 ALOGE("GET_EXTERNAL_DISPLAY_CONFIG transact error(%d)", result);
223 return result;
224 }
225
setExternalDisplayConfig(unsigned int index)226 virtual int setExternalDisplayConfig(unsigned int index)
227 {
228 Parcel data, reply;
229 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
230 data.writeInt32(index);
231 int result = remote()->transact(SET_EXTERNAL_DISPLAY_CONFIG, data, &reply);
232 if (result == NO_ERROR)
233 result = reply.readInt32();
234 else
235 ALOGE("SET_EXTERNAL_DISPLAY_CONFIG transact error(%d)", result);
236 return result;
237 }
238
setExternalVsyncEnabled(unsigned int index)239 virtual int setExternalVsyncEnabled(unsigned int index)
240 {
241 Parcel data, reply;
242 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
243 data.writeInt32(index);
244 int result = remote()->transact(SET_EXTERNAL_VSYNC, data, &reply);
245 if (result == NO_ERROR)
246 result = reply.readInt32();
247 else
248 ALOGE("SET_EXTERNAL_VSYNC transact error(%d)", result);
249 return result;
250 }
251
getExternalHdrCapabilities()252 virtual int getExternalHdrCapabilities()
253 {
254 Parcel data, reply;
255 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
256 int result = remote()->transact(GET_EXTERNAL_HDR_CAPA, data, &reply);
257 if (result == NO_ERROR)
258 result = reply.readInt32();
259 else
260 ALOGE("GET_EXTERNAL_HDR_CAPA transact error(%d)", result);
261
262 return result;
263 }
264
setBootFinished()265 virtual void setBootFinished()
266 {
267 Parcel data, reply;
268 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
269 int result = remote()->transact(SET_BOOT_FINISHED, data, &reply);
270 if (result != NO_ERROR)
271 ALOGE("SET_BOOT_FINISHED transact error(%d)", result);
272 }
273
enableMPP(uint32_t physicalType,uint32_t physicalIndex,uint32_t logicalIndex,uint32_t enable)274 virtual void enableMPP(uint32_t physicalType, uint32_t physicalIndex, uint32_t logicalIndex, uint32_t enable)
275 {
276 Parcel data, reply;
277 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
278 data.writeInt32(physicalType);
279 data.writeInt32(physicalIndex);
280 data.writeInt32(logicalIndex);
281 data.writeInt32(enable);
282 int result = remote()->transact(ENABLE_MPP, data, &reply);
283 if (result != NO_ERROR)
284 ALOGE("ENABLE_MPP transact error(%d)", result);
285 }
286
setScaleDownRatio(uint32_t physicalType,uint32_t physicalIndex,uint32_t logicalIndex,uint32_t scaleDownRatio)287 virtual void setScaleDownRatio(uint32_t physicalType, uint32_t physicalIndex,
288 uint32_t logicalIndex, uint32_t scaleDownRatio)
289 {
290 Parcel data, reply;
291 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
292 data.writeInt32(physicalType);
293 data.writeInt32(physicalIndex);
294 data.writeInt32(logicalIndex);
295 data.writeInt32(scaleDownRatio);
296 int result = remote()->transact(SET_SCALE_DOWN_RATIO, data, &reply);
297 if (result != NO_ERROR)
298 ALOGE("SET_SCALE_DOWN_RATIO transact error(%d)", result);
299 }
300
setLbeCtrl(uint32_t display_id,uint32_t state,uint32_t lux)301 virtual void setLbeCtrl(uint32_t display_id, uint32_t state, uint32_t lux) {
302 Parcel data, reply;
303 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
304 data.writeInt32(display_id);
305 data.writeInt32(state);
306 data.writeInt32(lux);
307 int result = remote()->transact(SET_LBE_CTRL, data, &reply);
308 if (result != NO_ERROR) ALOGE("SET_LBE_CTRL transact error(%d)", result);
309 }
310
setHWCDebug(int debug)311 virtual void setHWCDebug(int debug)
312 {
313 Parcel data, reply;
314 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
315 data.writeInt32(debug);
316 int result = remote()->transact(SET_HWC_DEBUG, data, &reply);
317 if (result != NO_ERROR)
318 ALOGE("SET_HWC_DEBUG transact error(%d)", result);
319 }
320
getHWCDebug()321 virtual uint32_t getHWCDebug()
322 {
323 Parcel data, reply;
324 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
325 int result = remote()->transact(GET_HWC_DEBUG, data, &reply);
326 if (result == NO_ERROR)
327 result = reply.readInt32();
328 else {
329 ALOGE("GET_HWC_DEBUG transact error(%d)", result);
330 }
331 return result;
332 }
333
setHWCFenceDebug(uint32_t fenceNum,uint32_t ipNum,uint32_t mode)334 virtual void setHWCFenceDebug(uint32_t fenceNum, uint32_t ipNum, uint32_t mode)
335 {
336 Parcel data, reply;
337 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
338 data.writeInt32(fenceNum);
339 data.writeInt32(ipNum);
340 data.writeInt32(mode);
341 remote()->transact(SET_HWC_FENCE_DEBUG, data, &reply);
342 }
343
getHWCFenceDebug()344 virtual void getHWCFenceDebug()
345 {
346 Parcel data, reply;
347 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
348 remote()->transact(GET_HWC_FENCE_DEBUG, data, &reply);
349 }
350
setHWCCtl(uint32_t display,uint32_t ctrl,int32_t val)351 virtual int setHWCCtl(uint32_t display, uint32_t ctrl, int32_t val) {
352 Parcel data, reply;
353 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
354 data.writeInt32(display);
355 data.writeInt32(ctrl);
356 data.writeInt32(val);
357 int result = remote()->transact(HWC_CONTROL, data, &reply);
358 if (result == NO_ERROR)
359 result = reply.readInt32();
360 else
361 ALOGE("HWC_CONTROL transact error(%d)", result);
362 return result;
363 };
364
setDDIScaler(uint32_t displayId,uint32_t width,uint32_t height)365 virtual int setDDIScaler(uint32_t displayId, uint32_t width, uint32_t height) {
366 Parcel data, reply;
367 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
368 data.writeUint32(displayId);
369 data.writeUint32(width);
370 data.writeUint32(height);
371 int result = remote()->transact(SET_DDISCALER, data, &reply);
372 if (result == NO_ERROR)
373 result = reply.readInt32();
374 else
375 ALOGE("SET_DDISCALER transact error(%d)", result);
376 return result;
377 }
378
setDisplayDeviceMode(int32_t display_id,int32_t mode)379 int32_t setDisplayDeviceMode(int32_t display_id, int32_t mode)
380 {
381 ALOGD("null func: %s(%d %d)", __func__, display_id, mode);
382 return NO_ERROR;
383 }
384
setPanelGammaTableSource(int32_t display_id,int32_t type,int32_t source)385 virtual int32_t setPanelGammaTableSource(int32_t display_id, int32_t type, int32_t source) {
386 ALOGD("null func: %s(%d %d %d)", __func__, display_id, type, source);
387 return NO_ERROR;
388 }
389
setDisplayBrightness(int32_t display_id,float brightness)390 virtual int32_t setDisplayBrightness(int32_t display_id, float brightness) {
391 Parcel data, reply;
392 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
393 data.writeInt32(display_id);
394 data.writeFloat(brightness);
395 int result = remote()->transact(SET_DISPLAY_BRIGHTNESS, data, &reply);
396 if (result)
397 ALOGE("SET_DISPLAY_BRIGHTNESS transact error(%d)", result);
398 return result;
399 }
400
setDisplayLhbm(int32_t display_id,uint32_t on)401 virtual int32_t setDisplayLhbm(int32_t display_id, uint32_t on) {
402 Parcel data, reply;
403 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
404 data.writeInt32(display_id);
405 data.writeInt32(on);
406 int result = remote()->transact(SET_DISPLAY_LHBM, data, &reply);
407 if (result) ALOGE("SET_DISPLAY_LHBM transact error(%d)", result);
408 return result;
409 }
410
setMinIdleRefreshRate(uint32_t display_id,int32_t fps)411 virtual int32_t setMinIdleRefreshRate(uint32_t display_id, int32_t fps) {
412 Parcel data, reply;
413 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
414 data.writeUint32(display_id);
415 data.writeInt32(fps);
416 int result = remote()->transact(SET_MIN_IDLE_REFRESH_RATE, data, &reply);
417 if (result) ALOGE("SET_MIN_IDLE_REFRESH_RATE transact error(%d)", result);
418 return result;
419 }
420
setRefreshRateThrottle(uint32_t display_id,int32_t delay_ms)421 virtual int32_t setRefreshRateThrottle(uint32_t display_id, int32_t delay_ms) {
422 Parcel data, reply;
423 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
424 data.writeUint32(display_id);
425 data.writeInt32(delay_ms);
426 int result = remote()->transact(SET_REFRESH_RATE_THROTTLE, data, &reply);
427 if (result) ALOGE("SET_REFRESH_RATE_THROTTLE transact error(%d)", result);
428 return result;
429 }
430
setDisplayRCDLayerEnabled(uint32_t displayIndex,bool enable)431 int32_t setDisplayRCDLayerEnabled(uint32_t displayIndex, bool enable) override {
432 Parcel data, reply;
433 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
434 data.writeUint32(displayIndex);
435 data.writeInt32(enable);
436
437 auto result = remote()->transact(SET_DISPLAY_RCDLAYER_ENABLED, data, &reply);
438 ALOGE_IF(result != NO_ERROR, "SET_DISPLAY_RCDLAYER_ENABLED transact error(%d)", result);
439 return result;
440 }
441
triggerDisplayIdleEnter(uint32_t displayIndex,uint32_t idleTeRefreshRate)442 int32_t triggerDisplayIdleEnter(uint32_t displayIndex, uint32_t idleTeRefreshRate) override {
443 Parcel data, reply;
444 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
445 data.writeUint32(displayIndex);
446 data.writeUint32(idleTeRefreshRate);
447
448 auto result = remote()->transact(SET_DISPLAY_RCDLAYER_ENABLED, data, &reply);
449 ALOGE_IF(result != NO_ERROR, "TRIGGER_DISPLAY_IDLE_ENTER transact error(%d)", result);
450 return result;
451 }
452
setDisplayDbm(int32_t display_id,uint32_t on)453 virtual int32_t setDisplayDbm(int32_t display_id, uint32_t on) {
454 Parcel data, reply;
455 data.writeInterfaceToken(IExynosHWCService::getInterfaceDescriptor());
456 data.writeInt32(display_id);
457 data.writeInt32(on);
458 int result = remote()->transact(SET_DISPLAY_DBM, data, &reply);
459 if (result) ALOGE("SET_DISPLAY_DBM transact error(%d)", result);
460 return result;
461 }
462 };
463
464 IMPLEMENT_META_INTERFACE(ExynosHWCService, "android.hal.ExynosHWCService");
465
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)466 status_t BnExynosHWCService::onTransact(
467 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
468 {
469 switch(code) {
470 case ADD_VIRTUAL_DISPLAY_DEVICE: {
471 CHECK_INTERFACE(IExynosHWCService, data, reply);
472 int res = addVirtualDisplayDevice();
473 reply->writeInt32(res);
474 return NO_ERROR;
475 } break;
476 case DESTROY_VIRTUAL_DISPLAY_DEVICE: {
477 CHECK_INTERFACE(IExynosHWCService, data, reply);
478 int res = destroyVirtualDisplayDevice();
479 reply->writeInt32(res);
480 return NO_ERROR;
481 } break;
482 case SET_WFD_MODE: {
483 CHECK_INTERFACE(IExynosHWCService, data, reply);
484 int mode = data.readInt32();
485 int res = setWFDMode(mode);
486 reply->writeInt32(res);
487 return NO_ERROR;
488 } break;
489 case GET_WFD_MODE: {
490 CHECK_INTERFACE(IExynosHWCService, data, reply);
491 int res = getWFDMode();
492 reply->writeInt32(res);
493 return NO_ERROR;
494 } break;
495 case SEND_WFD_COMMAND: {
496 CHECK_INTERFACE(IExynosHWCService, data, reply);
497 int cmd = data.readInt32();
498 int ext1 = data.readInt32();
499 int ext2 = data.readInt32();
500 int res = sendWFDCommand(cmd, ext1, ext2);
501 reply->writeInt32(res);
502 return NO_ERROR;
503 } break;
504 case SET_SECURE_VDS_MODE: {
505 CHECK_INTERFACE(IExynosHWCService, data, reply);
506 int mode = data.readInt32();
507 int res = setSecureVDSMode(mode);
508 reply->writeInt32(res);
509 return NO_ERROR;
510 } break;
511 case SET_WFD_OUTPUT_RESOLUTION: {
512 CHECK_INTERFACE(IExynosHWCService, data, reply);
513 int width = data.readInt32();
514 int height = data.readInt32();
515 int res = setWFDOutputResolution(width, height);
516 reply->writeInt32(res);
517 return NO_ERROR;
518 } break;
519 case GET_WFD_OUTPUT_RESOLUTION: {
520 CHECK_INTERFACE(IExynosHWCService, data, reply);
521 uint32_t width, height;
522 getWFDOutputResolution(&width, &height);
523 reply->writeInt32(width);
524 reply->writeInt32(height);
525 return NO_ERROR;
526 } break;
527 case SET_PRESENTATION_MODE: {
528 CHECK_INTERFACE(IExynosHWCService, data, reply);
529 int use = data.readInt32();
530 setPresentationMode(use);
531 return NO_ERROR;
532 } break;
533 case GET_PRESENTATION_MODE: {
534 CHECK_INTERFACE(IExynosHWCService, data, reply);
535 int res = getPresentationMode();
536 reply->writeInt32(res);
537 return NO_ERROR;
538 } break;
539 case SET_VDS_GLES_FORMAT: {
540 CHECK_INTERFACE(IExynosHWCService, data, reply);
541 int format = data.readInt32();
542 int res = setVDSGlesFormat(format);
543 reply->writeInt32(res);
544 return NO_ERROR;
545 } break;
546 case HWC_CONTROL: {
547 CHECK_INTERFACE(IExynosHWCService, data, reply);
548 int display = data.readInt32();
549 int ctrl = data.readInt32();
550 int value = data.readInt32();
551 int res = setHWCCtl(display, ctrl, value);
552 reply->writeInt32(res);
553 return NO_ERROR;
554 } break;
555 case GET_EXTERNAL_DISPLAY_CONFIG: {
556 CHECK_INTERFACE(IExynosHWCService, data, reply);
557 int res = getExternalDisplayConfigs();
558 reply->writeInt32(res);
559 return NO_ERROR;
560 } break;
561 case SET_EXTERNAL_DISPLAY_CONFIG: {
562 CHECK_INTERFACE(IExynosHWCService, data, reply);
563 int index = data.readInt32();
564 int res = setExternalDisplayConfig(index);
565 reply->writeInt32(res);
566 return NO_ERROR;
567 } break;
568 case SET_EXTERNAL_VSYNC: {
569 CHECK_INTERFACE(IExynosHWCService, data, reply);
570 int index = data.readInt32();
571 int res = setExternalVsyncEnabled(index);
572 reply->writeInt32(res);
573 return NO_ERROR;
574 } break;
575 case GET_EXTERNAL_HDR_CAPA: {
576 CHECK_INTERFACE(IExynosHWCService, data, reply);
577 int res = getExternalHdrCapabilities();
578 reply->writeInt32(res);
579 return NO_ERROR;
580 } break;
581 case SET_BOOT_FINISHED: {
582 CHECK_INTERFACE(IExynosHWCService, data, reply);
583 setBootFinished();
584 return NO_ERROR;
585 } break;
586 case ENABLE_MPP: {
587 CHECK_INTERFACE(IExynosHWCService, data, reply);
588 uint32_t type = data.readInt32();
589 uint32_t physicalIdx = data.readInt32();
590 uint32_t logicalIdx = data.readInt32();
591 uint32_t enable = data.readInt32();
592 enableMPP(type, physicalIdx, logicalIdx, enable);
593 return NO_ERROR;
594 } break;
595 case SET_SCALE_DOWN_RATIO: {
596 CHECK_INTERFACE(IExynosHWCService, data, reply);
597 uint32_t type = data.readInt32();
598 uint32_t physicalIdx = data.readInt32();
599 uint32_t logicalIdx = data.readInt32();
600 uint32_t scaleDownRatio = data.readInt32();
601 setScaleDownRatio(type, physicalIdx, logicalIdx, scaleDownRatio);
602 return NO_ERROR;
603 } break;
604 case SET_HWC_DEBUG: {
605 CHECK_INTERFACE(IExynosHWCService, data, reply);
606 int debug = data.readInt32();
607 setHWCDebug(debug);
608 reply->writeInt32(debug);
609 return NO_ERROR;
610 } break;
611 case GET_HWC_DEBUG: {
612 CHECK_INTERFACE(IExynosHWCService, data, reply);
613 int debugFlag = getHWCDebug();
614 reply->writeInt32(debugFlag);
615 return NO_ERROR;
616 } break;
617 case SET_HWC_FENCE_DEBUG: {
618 CHECK_INTERFACE(IExynosHWCService, data, reply);
619 uint32_t fenceNum = data.readInt32();
620 uint32_t ipNum = data.readInt32();
621 uint32_t mode = data.readInt32();
622 setHWCFenceDebug(fenceNum, ipNum, mode);
623 return NO_ERROR;
624 } break;
625 case SET_DDISCALER: {
626 CHECK_INTERFACE(IExynosHWCService, data, reply);
627 uint32_t display_id = data.readUint32();
628 uint32_t width = data.readUint32();
629 uint32_t height = data.readUint32();
630 int error = setDDIScaler(display_id, width, height);
631 reply->writeInt32(error);
632 return NO_ERROR;
633 } break;
634 case SET_DISPLAY_DEVICE_MODE: {
635 CHECK_INTERFACE(IExynosHWCService, data, reply);
636 int32_t display_id = data.readInt32();
637 int32_t mode = data.readInt32();
638 int32_t error = setDisplayDeviceMode(display_id, mode);
639 reply->writeInt32(error);
640 return NO_ERROR;
641 } break;
642 case SET_PANEL_GAMMA_TABLE_SOURCE: {
643 CHECK_INTERFACE(IExynosHWCService, data, reply);
644 int32_t display_id = data.readInt32();
645 int32_t type = data.readInt32();
646 int32_t source = data.readInt32();
647 int32_t error = setPanelGammaTableSource(display_id, type, source);
648 reply->writeInt32(error);
649 return NO_ERROR;
650 } break;
651
652 case SET_DISPLAY_BRIGHTNESS: {
653 CHECK_INTERFACE(IExynosHWCService, data, reply);
654 int32_t display_id = data.readInt32();
655 float brightness = data.readFloat();
656 int32_t error = setDisplayBrightness(display_id, brightness);
657 reply->writeInt32(error);
658 return NO_ERROR;
659 } break;
660
661 case SET_DISPLAY_LHBM: {
662 CHECK_INTERFACE(IExynosHWCService, data, reply);
663 int32_t display_id = data.readInt32();
664 uint32_t on = data.readInt32();
665 int32_t error = setDisplayLhbm(display_id, on);
666 reply->writeInt32(error);
667 return NO_ERROR;
668 } break;
669
670 case SET_LBE_CTRL: {
671 CHECK_INTERFACE(IExynosHWCService, data, reply);
672 uint32_t display_id = data.readInt32();
673 uint32_t state = data.readInt32();
674 uint32_t lux = data.readInt32();
675 setLbeCtrl(display_id, state, lux);
676 return NO_ERROR;
677 } break;
678
679 case SET_MIN_IDLE_REFRESH_RATE: {
680 CHECK_INTERFACE(IExynosHWCService, data, reply);
681 uint32_t display_id = data.readUint32();
682 int32_t fps = data.readInt32();
683 return setMinIdleRefreshRate(display_id, fps);
684 } break;
685
686 case SET_REFRESH_RATE_THROTTLE: {
687 CHECK_INTERFACE(IExynosHWCService, data, reply);
688 uint32_t display_id = data.readUint32();
689 int32_t delay_ms = data.readInt32();
690 return setRefreshRateThrottle(display_id, delay_ms);
691 } break;
692
693 case SET_DISPLAY_RCDLAYER_ENABLED: {
694 CHECK_INTERFACE(IExynosHWCService, data, reply);
695 uint32_t displayIndex = data.readUint32();
696 bool enable = data.readInt32();
697 return setDisplayRCDLayerEnabled(displayIndex, enable);
698 } break;
699
700 case TRIGGER_DISPLAY_IDLE_ENTER: {
701 CHECK_INTERFACE(IExynosHWCService, data, reply);
702 uint32_t displayIndex = data.readUint32();
703 uint32_t idleTeRefreshRate = data.readUint32();
704 return triggerDisplayIdleEnter(displayIndex, idleTeRefreshRate);
705 } break;
706
707 case SET_DISPLAY_DBM: {
708 CHECK_INTERFACE(IExynosHWCService, data, reply);
709 int32_t display_id = data.readInt32();
710 uint32_t on = data.readInt32();
711 int32_t error = setDisplayDbm(display_id, on);
712 reply->writeInt32(error);
713 return NO_ERROR;
714 } break;
715
716 default:
717 return BBinder::onTransact(code, data, reply, flags);
718 }
719 }
720 } // namespace android
721