path: root/hwc2/common/devices/PhysicalDevice.cpp (plain)
blob: 699c4e202fff034ed57afcbd9c0bf122ae0cbd99

1	/*
2	// Copyright (c) 2014 Intel Corporation
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	// This file is modified by Amlogic, Inc. 2017.01.17.
17	*/
18
19	#include <fcntl.h>
20	#include <inttypes.h>
21	#include <HwcTrace.h>
22	#include <PhysicalDevice.h>
23	#include <Hwcomposer.h>
24	#include <sys/ioctl.h>
25	#include <sync/sync.h>
26	#include <Utils.h>
27	#include <HwcFenceControl.h>
28	#include <cutils/properties.h>
29	#include <tvp/OmxUtil.h>
30	#include <sys/utsname.h>
31	#define FBIOPUT_OSD_CURSOR 0x451a
32
33	static int Amvideo_Handle = 0;
34
35	#include <vendor/amlogic/hardware/systemcontrol/1.0/ISystemControl.h>
36
37	using ::vendor::amlogic::hardware::systemcontrol::V1_0::ISystemControl;
38	using ::vendor::amlogic::hardware::systemcontrol::V1_0::Result;
39
40	namespace android {
41	namespace amlogic {
42
43	PhysicalDevice::PhysicalDevice(hwc2_display_t id, Hwcomposer& hwc, DeviceControlFactory* controlFactory)
44	: mId(id),
45	mHwc(hwc),
46	mControlFactory(controlFactory),
47	mVsyncObserver(NULL),
48	mIsConnected(false),
49	mSecure(false),
50	mFramebufferHnd(NULL),
51	mSystemControl(NULL),
52	mFbSlot(0),
53	mComposer(NULL),
54	mPriorFrameRetireFence(-1),
55	mClientTargetHnd(NULL),
56	mTargetAcquireFence(-1),
57	mRenderMode(GLES_COMPOSE_MODE),
58	mIsValidated(false),
59	mIsContinuousBuf(true),
60	mDirectRenderLayerId(0),
61	mVideoOverlayLayerId(0),
62	mGE2DClearVideoRegionCount(0),
63	mGE2DComposeFrameCount(0),
64	mDirectComposeFrameCount(0),
65	mInitialized(false)
66	{
67	CTRACE();
68
69	switch (id) {
70	case DEVICE_PRIMARY:
71	mName = "Primary";
72	break;
73	case DEVICE_EXTERNAL:
74	mName = "External";
75	break;
76	default:
77	mName = "Unknown";
78	}
79
80	mHdrCapabilities.init = false;
81	// init Display here.
82	initDisplay();
83
84	// set capacity of layers, layer's changed type, layer's changed request.
85	// mHwcLayersChangeType.setCapacity(LAYER_MAX_NUM_CHANGE_TYPE);
86	// mHwcLayersChangeRequest.setCapacity(LAYER_MAX_NUM_CHANGE_REQUEST);
87	// mHwcGlesLayers.setCapacity(LAYER_MAX_NUM_CHANGE_TYPE);
88	// mHwcLayers.setCapacity(LAYER_MAX_NUM_SUPPORT);
89	#ifdef HWC_ENABLE_SECURE_LAYER
90	// mHwcSecureLayers.setCapacity(LAYER_MAX_NUM_SECURE_PROTECTED);
91	mHwcSecureLayers.clear();
92	#endif
93
94	// clear layers vectors.
95	mHwcLayersChangeType.clear();
96	mHwcLayersChangeRequest.clear();
97	mHwcGlesLayers.clear();
98	mHwcLayers.clear();
99
100	// mGE2DRenderSortedLayerIds.setCapacity(HWC2_MAX_LAYERS);
101	mGE2DRenderSortedLayerIds.clear();
102
103	mHwcCurReleaseFences = mHwcPriorReleaseFences = NULL;
104
105	int major = 0, minor = 0;
106	struct utsname info;
107	if (uname(&info) || sscanf(info.release, "%d.%d", &major, &minor) <= 0) {
108	ETRACE("Could not get linux version: %s", strerror(errno));
109	}
110	// from kernel 4.9 use FBIOPUT_OSD_CURSOR instead of FBIO_CURSOR
111	mUsingPutCurosr = major > 4 || (major == 4 && minor >= 9);
112	}
113
114	PhysicalDevice::~PhysicalDevice()
115	{
116	WARN_IF_NOT_DEINIT();
117	clearFenceList(mHwcCurReleaseFences);
118	clearFenceList(mHwcPriorReleaseFences);
119	}
120
121	bool PhysicalDevice::initialize() {
122	CTRACE();
123
124	if (mId != DEVICE_PRIMARY && mId != DEVICE_EXTERNAL) {
125	ETRACE("invalid device type");
126	return false;
127	}
128
129	// create vsync event observer, we only have soft vsync now...
130	mVsyncObserver = new SoftVsyncObserver(*this);
131	if (!mVsyncObserver || !mVsyncObserver->initialize()) {
132	DEINIT_AND_RETURN_FALSE("failed to create vsync observer");
133	}
134
135	mDisplayHdmi = new DisplayHdmi(mId);
136	mDisplayHdmi->initialize();
137	UeventObserver *observer = Hwcomposer::getInstance().getUeventObserver();
138	if (observer) {
139	observer->registerListener(
140	Utils::getHdcpUeventEnvelope(),
141	hdcpEventListener,
142	this);
143	} else {
144	ETRACE("PhysicalDevice::Uevent observer is NULL");
145	}
146
147	mInitialized = true;
148	return true;
149	}
150
151	void PhysicalDevice::hdcpEventListener(void *data, bool status)
152	{
153	PhysicalDevice *pThis = (PhysicalDevice*)data;
154	if (pThis) {
155	pThis->setSecureStatus(status);
156	}
157	}
158
159	void PhysicalDevice::setSecureStatus(bool status)
160	{
161	DTRACE("hdcp event: %d", status);
162	mSecure = status;
163	}
164
165	void PhysicalDevice::deinitialize() {
166	Mutex::Autolock _l(mLock);
167
168	DEINIT_AND_DELETE_OBJ(mVsyncObserver);
169	DEINIT_AND_DELETE_OBJ(mDisplayHdmi);
170	DEINIT_AND_DELETE_OBJ(mComposer);
171
172	if (mFramebufferContext != NULL) {
173	delete mFramebufferContext;
174	mFramebufferContext = NULL;
175	}
176
177	if (mCursorContext != NULL) {
178	delete mCursorContext;
179	mCursorContext = NULL;
180	}
181
182	mInitialized = false;
183	}
184
185	HwcLayer* PhysicalDevice::getLayerById(hwc2_layer_t layerId) {
186	HwcLayer* layer = NULL;
187	ssize_t index = mHwcLayers.indexOfKey(layerId);
188
189	if (index >= 0) {
190	layer = mHwcLayers.valueFor(layerId);
191	}
192
193	if (!layer) {
194	DTRACE("getLayerById %lld error!", layerId);
195	}
196	return layer;
197	}
198
199	int32_t PhysicalDevice::acceptDisplayChanges() {
200	HwcLayer* layer = NULL;
201
202	for (uint32_t i=0; i<mHwcLayersChangeType.size(); i++) {
203	hwc2_layer_t layerId = mHwcLayersChangeType.keyAt(i);
204	layer = mHwcLayersChangeType.valueAt(i);
205	if (layer) {
206	#ifdef HWC_ENABLE_SECURE_LAYER
207	// deal non secure display.
208	if (!mSecure && !mHwcSecureLayers.isEmpty()) {
209	for (uint32_t j=0; j<mHwcSecureLayers.size(); j++) {
210	hwc2_layer_t secureLayerId = mHwcSecureLayers.keyAt(j);
211	HwcLayer* secureLayer = mHwcSecureLayers.valueAt(j);
212	// deal secure layers release fence and composition type on non secure display.
213	addReleaseFence(secureLayerId, secureLayer->getDuppedAcquireFence());
214	if (layerId == secureLayerId) {
215	if (layer->getCompositionType() != HWC2_COMPOSITION_DEVICE) {
216	layer->setCompositionType(HWC2_COMPOSITION_DEVICE);
217	continue;
218	}
219	}
220	}
221	}
222	#endif
223	if (layer->getCompositionType() == HWC2_COMPOSITION_DEVICE
224	|| layer->getCompositionType() == HWC2_COMPOSITION_SOLID_COLOR) {
225	layer->setCompositionType(HWC2_COMPOSITION_CLIENT);
226	} else if (layer->getCompositionType() == HWC2_COMPOSITION_SIDEBAND) {
227	layer->setCompositionType(HWC2_COMPOSITION_DEVICE);
228	}
229	}
230	}
231	// reset layer changed or requested size to zero.
232	mHwcLayersChangeType.clear();
233	mHwcLayersChangeRequest.clear();
234
235	#ifdef HWC_ENABLE_SECURE_LAYER
236	// deal non secure display device.
237	if (!mHwcSecureLayers.isEmpty()) {
238	mHwcSecureLayers.clear();
239	}
240	#endif
241
242	return HWC2_ERROR_NONE;
243	}
244
245	bool PhysicalDevice::createLayer(hwc2_layer_t* outLayer) {
246	HwcLayer* layer = new HwcLayer(mId);
247
248	if (layer == NULL || !layer->initialize()) {
249	ETRACE("createLayer: failed !");
250	return false;
251	}
252
253	hwc2_layer_t layerId = reinterpret_cast<hwc2_layer_t>(layer);
254	mHwcLayers.add(layerId, layer);
255	*outLayer = layerId;
256	DTRACE("::createLayer layerId %lld, size: [%d].\n", layerId, mHwcLayers.size());
257
258	return true;
259	}
260
261	bool PhysicalDevice::destroyLayer(hwc2_layer_t layerId) {
262	HwcLayer* layer = mHwcLayers.valueFor(layerId);
263	DTRACE("::destroyLayer layerId %lld, size: [%d].\n", layerId, mHwcLayers.size());
264
265	if (layer == NULL) {
266	ETRACE("destroyLayer: no Hwclayer found (%d)", layerId);
267	return false;
268	}
269
270	for (int i = 0; i < 2; i++) {
271	ssize_t idx = mLayerReleaseFences[i].indexOfKey(layerId);
272	if (idx >= 0) {
273	HwcFenceControl::closeFd(mLayerReleaseFences[i].valueAt(idx));
274	mLayerReleaseFences[i].removeItemsAt(idx);
275	DTRACE("destroyLayer remove layer %lld from cur release list %p\n", layerId, &(mLayerReleaseFences[i]));
276	}
277	}
278
279	mHwcLayers.removeItem(layerId);
280	DEINIT_AND_DELETE_OBJ(layer);
281	return true;
282	}
283
284	int32_t PhysicalDevice::getActiveConfig(
285	hwc2_config_t* outConfig) {
286	Mutex::Autolock _l(mLock);
287
288	return mDisplayHdmi->getActiveConfig(outConfig);
289	}
290
291	int32_t PhysicalDevice::getChangedCompositionTypes(
292	uint32_t* outNumElements,
293	hwc2_layer_t* outLayers,
294	int32_t* /*hwc2_composition_t*/ outTypes) {
295	HwcLayer* layer = NULL;
296
297	// if outLayers or outTypes were NULL, the number of layers and types which would have been returned.
298	if (NULL == outLayers || NULL == outTypes) {
299	*outNumElements = mHwcLayersChangeType.size();
300	} else {
301	for (uint32_t i=0; i<mHwcLayersChangeType.size(); i++) {
302	hwc2_layer_t layerId = mHwcLayersChangeType.keyAt(i);
303	layer = mHwcLayersChangeType.valueAt(i);
304	if (layer) {
305	#ifdef HWC_ENABLE_SECURE_LAYER
306	// deal non secure display.
307	if (!mSecure && !mHwcSecureLayers.isEmpty()) {
308	for (uint32_t j=0; j<mHwcSecureLayers.size(); j++) {
309	hwc2_layer_t secureLayerId = mHwcSecureLayers.keyAt(j);
310	if (layerId == secureLayerId) {
311	if (layer->getCompositionType() != HWC2_COMPOSITION_DEVICE) {
312	outLayers[i] = layerId;
313	outTypes[i] = HWC2_COMPOSITION_DEVICE;
314	continue;
315	}
316	}
317	}
318	}
319	#endif
320
321	if (layer->getCompositionType() == HWC2_COMPOSITION_DEVICE
322	|| layer->getCompositionType() == HWC2_COMPOSITION_SOLID_COLOR) {
323	// change all other device type to client.
324	outLayers[i] = layerId;
325	outTypes[i] = HWC2_COMPOSITION_CLIENT;
326	continue;
327	}
328
329	// sideband stream.
330	if (layer->getCompositionType() == HWC2_COMPOSITION_SIDEBAND
331	&& layer->getSidebandStream()) {
332	// TODO: we just transact SIDEBAND to OVERLAY for now;
333	DTRACE("get HWC_SIDEBAND layer, just change to overlay");
334	outLayers[i] = layerId;
335	outTypes[i] = HWC2_COMPOSITION_DEVICE;
336	continue;
337	}
338	}
339	}
340
341	if (mHwcLayersChangeType.size() > 0) {
342	DTRACE("There are %d layers type has changed.", mHwcLayersChangeType.size());
343	*outNumElements = mHwcLayersChangeType.size();
344	} else {
345	DTRACE("No layers compositon type changed.");
346	}
347	}
348
349	return HWC2_ERROR_NONE;
350	}
351
352	int32_t PhysicalDevice::getClientTargetSupport(
353	uint32_t width,
354	uint32_t height,
355	int32_t /*android_pixel_format_t*/ format,
356	int32_t /*android_dataspace_t*/ dataspace) {
357	framebuffer_info_t* fbInfo = mFramebufferContext->getInfo();
358
359	if (width == fbInfo->info.xres
360	&& height == fbInfo->info.yres
361	&& format == HAL_PIXEL_FORMAT_RGBA_8888
362	&& dataspace == HAL_DATASPACE_UNKNOWN) {
363	return HWC2_ERROR_NONE;
364	}
365
366	DTRACE("fbinfo: [%d x %d], client: [%d x %d]"
367	"format: %d, dataspace: %d",
368	fbInfo->info.xres,
369	fbInfo->info.yres,
370	width, height, format, dataspace);
371
372	// TODO: ?
373	return HWC2_ERROR_UNSUPPORTED;
374	}
375
376	int32_t PhysicalDevice::getColorModes(
377	uint32_t* outNumModes,
378	int32_t* /*android_color_mode_t*/ outModes) {
379
380	if (NULL == outModes) {
381	*outNumModes = 1;
382	} else {
383	*outModes = HAL_COLOR_MODE_NATIVE;
384	}
385
386	return HWC2_ERROR_NONE;
387	}
388
389	int32_t PhysicalDevice::getDisplayAttribute(
390	hwc2_config_t config,
391	int32_t /*hwc2_attribute_t*/ attribute,
392	int32_t* outValue) {
393	Mutex::Autolock _l(mLock);
394
395	if (!mIsConnected) {
396	ETRACE("display %d is not connected.", mId);
397	}
398
399	int ret = mDisplayHdmi->getDisplayAttribute(config, attribute, outValue);
400	if (ret < 0)
401	return HWC2_ERROR_BAD_CONFIG;
402
403	return HWC2_ERROR_NONE;
404	}
405
406	int32_t PhysicalDevice::getDisplayConfigs(
407	uint32_t* outNumConfigs,
408	hwc2_config_t* outConfigs) {
409	Mutex::Autolock _l(mLock);
410
411	return mDisplayHdmi->getDisplayConfigs(outNumConfigs, outConfigs);
412	}
413
414	int32_t PhysicalDevice::getDisplayName(
415	uint32_t* outSize,
416	char* outName) {
417	return HWC2_ERROR_NONE;
418	}
419
420	int32_t PhysicalDevice::getDisplayRequests(
421	int32_t* /*hwc2_display_request_t*/ outDisplayRequests,
422	uint32_t* outNumElements,
423	hwc2_layer_t* outLayers,
424	int32_t* /*hwc2_layer_request_t*/ outLayerRequests) {
425
426	// if outLayers or outTypes were NULL, the number of layers and types which would have been returned.
427	if (NULL == outLayers || NULL == outLayerRequests) {
428	*outNumElements = mHwcLayersChangeRequest.size();
429	} else {
430	for (uint32_t i=0; i<mHwcLayersChangeRequest.size(); i++) {
431	hwc2_layer_t layerId = mHwcLayersChangeRequest.keyAt(i);
432	HwcLayer *layer = mHwcLayersChangeRequest.valueAt(i);
433	if (layer->getCompositionType() == HWC2_COMPOSITION_DEVICE) {
434	// video overlay.
435	if (layerId == mVideoOverlayLayerId) {
436	outLayers[i] = layerId;
437	outLayerRequests[i] = HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET;
438	}
439	/* if (layer->getBufferHandle()) {
440	private_handle_t const* hnd =
441	reinterpret_cast<private_handle_t const*>(layer->getBufferHandle());
442	if (hnd->flags & private_handle_t::PRIV_FLAGS_VIDEO_OVERLAY) {
443	outLayers[i] = layerId;
444	outLayerRequests[i] = HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET;
445	continue;
446	}
447	} */
448	}
449
450	// sideband stream.
451	if ((layer->getCompositionType() == HWC2_COMPOSITION_SIDEBAND && layer->getSidebandStream())
452	//|| layer->getCompositionType() == HWC2_COMPOSITION_SOLID_COLOR
453	|| layer->getCompositionType() == HWC2_COMPOSITION_CURSOR) {
454	// TODO: we just transact SIDEBAND to OVERLAY for now;
455	DTRACE("get HWC_SIDEBAND layer, just change to overlay");
456	outLayers[i] = layerId;
457	outLayerRequests[i] = HWC2_LAYER_REQUEST_CLEAR_CLIENT_TARGET;
458	continue;
459	}
460	}
461
462	if (mHwcLayersChangeRequest.size() > 0) {
463	DTRACE("There are %d layer requests.", mHwcLayersChangeRequest.size());
464	*outNumElements = mHwcLayersChangeRequest.size();
465	} else {
466	DTRACE("No layer requests.");
467	}
468	}
469
470	return HWC2_ERROR_NONE;
471	}
472
473	int32_t PhysicalDevice::getDisplayType(
474	int32_t* /*hwc2_display_type_t*/ outType) {
475
476	*outType = HWC2_DISPLAY_TYPE_PHYSICAL;
477	return HWC2_ERROR_NONE;
478	}
479
480	int32_t PhysicalDevice::getDozeSupport(
481	int32_t* outSupport) {
482	return HWC2_ERROR_NONE;
483	}
484
485	int32_t PhysicalDevice::getHdrCapabilities(
486	uint32_t* outNumTypes,
487	int32_t* /*android_hdr_t*/ outTypes,
488	float* outMaxLuminance,
489	float* outMaxAverageLuminance,
490	float* outMinLuminance) {
491
492	Mutex::Autolock _l(mLock);
493	if (!mIsConnected) {
494	ETRACE("disp: %llu is not connected", mId);
495	return HWC2_ERROR_BAD_DISPLAY;
496	}
497
498	if (!mHdrCapabilities.init) {
499	parseHdrCapabilities();
500	mHdrCapabilities.init = true;
501	}
502
503	if (NULL == outTypes) {
504	int num = 0;
505	if (mHdrCapabilities.dvSupport) num++;
506	if (mHdrCapabilities.hdrSupport) num++;
507
508	*outNumTypes = num;
509	} else {
510	if (mHdrCapabilities.dvSupport) *outTypes++ = HAL_HDR_DOLBY_VISION;
511	if (mHdrCapabilities.hdrSupport) *outTypes++ = HAL_HDR_HDR10;
512
513	*outMaxLuminance = mHdrCapabilities.maxLuminance;
514	*outMaxAverageLuminance = mHdrCapabilities.avgLuminance;
515	*outMinLuminance = mHdrCapabilities.minLuminance;
516	}
517
518	return HWC2_ERROR_NONE;
519	}
520
521	void PhysicalDevice::swapReleaseFence() {
522	//dumpFenceList(mHwcCurReleaseFences);
523
524	if (mHwcCurReleaseFences == NULL || mHwcPriorReleaseFences == NULL) {
525	if (mHwcCurReleaseFences) {
526	clearFenceList(mHwcPriorReleaseFences);
527	}
528
529	if (mHwcPriorReleaseFences) {
530	clearFenceList(mHwcPriorReleaseFences);
531	}
532
533	mHwcCurReleaseFences = &(mLayerReleaseFences[0]);
534	mHwcPriorReleaseFences = &(mLayerReleaseFences[1]);
535	} else {
536	KeyedVector<hwc2_layer_t, int32_t> * tmp = mHwcCurReleaseFences;
537	clearFenceList(mHwcPriorReleaseFences);
538	mHwcCurReleaseFences = mHwcPriorReleaseFences;
539	mHwcPriorReleaseFences = tmp;
540	}
541	}
542
543
544	void PhysicalDevice::addReleaseFence(hwc2_layer_t layerId, int32_t fenceFd) {
545	ssize_t idx = mHwcCurReleaseFences->indexOfKey(layerId);
546	if (idx >= 0 && idx < mHwcCurReleaseFences->size()) {
547	int32_t oldFence = mHwcCurReleaseFences->valueAt(idx);
548	String8 mergeName("hwc-release");
549	int32_t newFence = HwcFenceControl::merge(mergeName, oldFence, fenceFd);
550	mHwcCurReleaseFences->replaceValueAt(idx, newFence);
551	HwcFenceControl::closeFd(oldFence);
552	HwcFenceControl::closeFd(fenceFd);
553	ETRACE("addReleaseFence:(%d, %d) + %d -> (%d,%d)\n", idx, oldFence, fenceFd, idx, newFence);
554	dumpFenceList(mHwcCurReleaseFences);
555	} else {
556	mHwcCurReleaseFences->add(layerId, fenceFd);
557	}
558	}
559
560	void PhysicalDevice::clearFenceList(KeyedVector<hwc2_layer_t, int32_t> * fenceList) {
561	if (!fenceList || !fenceList->size())
562	return;
563
564	for (int i = 0; i < fenceList->size(); i++) {
565	int32_t fenceFd = fenceList->valueAt(i);
566	HwcFenceControl::closeFd(fenceFd);
567	DTRACE("clearFenceList close fd %d\n", fenceFd);
568	fenceList->replaceValueAt(i, -1);
569	}
570	fenceList->clear();
571	}
572
573	void PhysicalDevice::dumpFenceList(KeyedVector<hwc2_layer_t, int32_t> * fenceList) {
574	if (!fenceList || fenceList->isEmpty())
575	return;
576
577	String8 resultStr("dumpFenceList: ");
578	for (int i = 0; i < fenceList->size(); i++) {
579	hwc2_layer_t layerId = fenceList->keyAt(i);
580	int32_t fenceFd = fenceList->valueAt(i);
581	resultStr.appendFormat("(%lld, %d), ", layerId, fenceFd);
582	}
583
584	ETRACE("%s", resultStr.string());
585	}
586
587	int32_t PhysicalDevice::getReleaseFences(
588	uint32_t* outNumElements,
589	hwc2_layer_t* outLayers,
590	int32_t* outFences) {
591	*outNumElements = mHwcPriorReleaseFences->size();
592
593	if (outLayers && outFences) {
594	for (uint32_t i=0; i<mHwcPriorReleaseFences->size(); i++) {
595	outLayers[i] = mHwcPriorReleaseFences->keyAt(i);
596	outFences[i] = HwcFenceControl::dupFence(mHwcPriorReleaseFences->valueAt(i));
597	}
598	}
599
600	return HWC2_ERROR_NONE;
601	}
602
603	void PhysicalDevice::directCompose(framebuffer_info_t * fbInfo) {
604	HwcLayer* layer = NULL;
605	ssize_t idx = mHwcLayers.indexOfKey(mDirectRenderLayerId);
606	if (idx >= 0) {
607	layer = mHwcLayers.valueAt(idx);
608	if (mTargetAcquireFence > -1) {
609	ETRACE("ERROR:directCompose with mTargetAcquireFence %d\n", mTargetAcquireFence);
610	HwcFenceControl::closeFd(mTargetAcquireFence);
611	}
612
613	mTargetAcquireFence = layer->getDuppedAcquireFence();
614	mClientTargetHnd = layer->getBufferHandle();
615	DTRACE("Hit only one non video overlay layer, handle: %08" PRIxPTR ", fence: %d",
616	intptr_t(mClientTargetHnd), mTargetAcquireFence);
617
618	// fill up fb sync request struct.
619	hwc_frect_t srcCrop = layer->getSourceCrop();
620	hwc_rect_t displayFrame = layer->getDisplayFrame();
621	mFbSyncRequest.xoffset = (unsigned int)srcCrop.left;
622	mFbSyncRequest.yoffset = (unsigned int)srcCrop.top;
623	mFbSyncRequest.width = (unsigned int)(srcCrop.right - srcCrop.left);
624	mFbSyncRequest.height = (unsigned int)(srcCrop.bottom - srcCrop.top);
625	mFbSyncRequest.dst_x = displayFrame.left;
626	mFbSyncRequest.dst_y = displayFrame.top;
627	mFbSyncRequest.dst_w = displayFrame.right - displayFrame.left;
628	mFbSyncRequest.dst_h = displayFrame.bottom - displayFrame.top;
629	return;
630	}
631
632	ETRACE("Didn't find direct compose layer!");
633	}
634
635	#ifdef ENABLE_AML_GE2D_COMPOSER
636	void PhysicalDevice::ge2dCompose(framebuffer_info_t * fbInfo, bool hasVideoOverlay) {
637	if (mGE2DRenderSortedLayerIds.size() > 0) {
638	DTRACE("GE2D compose mFbSlot: %d", mFbSlot);
639	if (hasVideoOverlay) {
640	if (mGE2DClearVideoRegionCount < 3) {
641	mComposer->setVideoOverlayLayerId(mVideoOverlayLayerId);
642	}
643	}
644	if (mTargetAcquireFence > -1) {
645	ETRACE("ERROR:GE2D compose with mTargetAcquireFence %d\n", mTargetAcquireFence);
646	HwcFenceControl::closeFd(mTargetAcquireFence);
647	}
648	mTargetAcquireFence = mComposer->startCompose(mGE2DRenderSortedLayerIds, &mFbSlot, mGE2DComposeFrameCount);
649	for (uint32_t i=0; i<mGE2DRenderSortedLayerIds.size(); i++) {
650	addReleaseFence(mGE2DRenderSortedLayerIds.itemAt(i), HwcFenceControl::dupFence(mTargetAcquireFence));
651	}
652	// HwcFenceControl::traceFenceInfo(mTargetAcquireFence);
653	// dumpLayers(mGE2DRenderSortedLayerIds);
654	if (mGE2DComposeFrameCount < 3) {
655	mGE2DComposeFrameCount++;
656	}
657	mClientTargetHnd = mComposer->getBufHnd();
658	fbInfo->yOffset = mFbSlot;
659	return;
660	}
661
662	ETRACE("Didn't find ge2d compose layers!");
663	}
664	#endif
665
666	int32_t PhysicalDevice::postFramebuffer(int32_t* outRetireFence, bool hasVideoOverlay) {
667	HwcLayer* layer = NULL;
668	void *cbuffer;
669
670	#if PLATFORM_SDK_VERSION >= 26
671	bool bUseHwcPost = true;
672	#else
673	bool bUseHwcPost = mIsContinuousBuf;
674	#endif
675
676	// deal physical display's client target layer
677	framebuffer_info_t fbInfo = *(mFramebufferContext->getInfo());
678	framebuffer_info_t* cbInfo = mCursorContext->getInfo();
679	bool cursorShow = false;
680	bool haveCursorLayer = false;
681	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
682	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
683	layer = mHwcLayers.valueAt(i);
684	if (layer && layer->getCompositionType()== HWC2_COMPOSITION_CURSOR) {
685	private_handle_t *hnd = (private_handle_t *)(layer->getBufferHandle());
686	if (private_handle_t::validate(hnd) < 0) {
687	ETRACE("invalid cursor layer handle.");
688	break;
689	}
690	haveCursorLayer = true;
691	DTRACE("This is a Sprite, hnd->stride is %d, hnd->height is %d", hnd->stride, hnd->height);
692	if (cbInfo->info.xres != (uint32_t)hnd->stride || cbInfo->info.yres != (uint32_t)hnd->height) {
693	ETRACE("disp: %d cursor need to redrew", mId);
694	update_cursor_buffer_locked(cbInfo, hnd->stride, hnd->height);
695	cbuffer = mmap(NULL, hnd->size, PROT_READ|PROT_WRITE, MAP_SHARED, cbInfo->fd, 0);
696	if (cbuffer != MAP_FAILED) {
697	memcpy(cbuffer, hnd->base, hnd->size);
698	munmap(cbuffer, hnd->size);
699	DTRACE("setCursor ok");
700	} else {
701	ETRACE("buffer mmap fail");
702	}
703	}
704	cursorShow = true;
705	break;
706	}
707	}
708
709	if (mRenderMode == GLES_COMPOSE_MODE) {
710	//if no layers to compose, post blank op to osd.
711	if (mHwcGlesLayers.size() == 0) {
712	mClientTargetHnd = NULL;
713	}
714	} else if (mRenderMode == DIRECT_COMPOSE_MODE) { // if only one layer exists, let hwc do her work.
715	directCompose(&fbInfo);
716	}
717	#ifdef ENABLE_AML_GE2D_COMPOSER
718	else if (mRenderMode == GE2D_COMPOSE_MODE) {
719	ge2dCompose(&fbInfo, hasVideoOverlay);
720	}
721	#endif
722	mFbSyncRequest.type = mRenderMode;
723
724	bool needBlankFb0 = false;
725	uint32_t layerNum = mHwcLayers.size();
726	if (hasVideoOverlay && (layerNum == 1 || (layerNum == 2 && haveCursorLayer)))
727	needBlankFb0 = true;
728
729	if (bUseHwcPost) {
730	// bit 0 is osd blank flag.
731	if (needBlankFb0) {
732	mFbSyncRequest.op |= OSD_BLANK_OP_BIT;
733	} else {
734	mFbSyncRequest.op &= ~(OSD_BLANK_OP_BIT);
735	}
736	mFramebufferContext->setStatus(needBlankFb0);
737	} else {
738	setOSD0Blank(needBlankFb0);
739	}
740
741	if (!mClientTargetHnd || private_handle_t::validate(mClientTargetHnd) < 0 || mPowerMode == HWC2_POWER_MODE_OFF) {
742	ETRACE("Post blank to screen, mClientTargetHnd(%p, %d), mTargetAcquireFence(%d)",
743	mClientTargetHnd, private_handle_t::validate(mClientTargetHnd), mTargetAcquireFence);
744	*outRetireFence = HwcFenceControl::merge(String8("ScreenBlank"), mPriorFrameRetireFence, mPriorFrameRetireFence);
745	HwcFenceControl::closeFd(mTargetAcquireFence);
746	mTargetAcquireFence = -1;
747	HwcFenceControl::closeFd(mPriorFrameRetireFence);
748	mPriorFrameRetireFence = -1;
749	//for nothing to display, post blank to osd which will signal the last retire fence.
750	mFbSyncRequest.type = DIRECT_COMPOSE_MODE;
751	mFbSyncRequest.op |= OSD_BLANK_OP_BIT;
752	mFramebufferContext->setStatus(true);
753	mPriorFrameRetireFence = hwc_fb_post_with_fence_locked(&fbInfo, &mFbSyncRequest, NULL);
754	#if PLATFORM_SDK_VERSION >= 26 //TEMP, will remove later.
755	HwcFenceControl::wait(*outRetireFence, -1);
756	HwcFenceControl::closeFd(*outRetireFence);
757	*outRetireFence = -1;
758	#endif
759	} else {
760	*outRetireFence = HwcFenceControl::dupFence(mPriorFrameRetireFence);
761	if (*outRetireFence >= 0) {
762	DTRACE("Get prior frame's retire fence %d", *outRetireFence);
763	} else {
764	ETRACE("No valid prior frame's retire returned. %d ", *outRetireFence);
765	// -1 means no fence, less than -1 is some error
766	*outRetireFence = -1;
767	}
768	HwcFenceControl::closeFd(mPriorFrameRetireFence);
769	mPriorFrameRetireFence = -1;
770
771	// real post framebuffer here.
772	DTRACE("render type: %d", mFbSyncRequest.type);
773
774	#if PLATFORM_SDK_VERSION >= 26 //TEMP, will remove later.
775	HwcFenceControl::wait(mTargetAcquireFence, -1);
776	HwcFenceControl::closeFd(mTargetAcquireFence);
777	mTargetAcquireFence = -1;
778	#endif
779
780	if (!bUseHwcPost) {
781	mPriorFrameRetireFence = fb_post_with_fence_locked(&fbInfo, mClientTargetHnd, mTargetAcquireFence);
782	} else {
783	// acquire fence.
784	mFbSyncRequest.in_fen_fd = mTargetAcquireFence;
785	mPriorFrameRetireFence = hwc_fb_post_with_fence_locked(&fbInfo, &mFbSyncRequest, mClientTargetHnd);
786	}
787	mTargetAcquireFence = -1;
788
789	if (mRenderMode == GE2D_COMPOSE_MODE) {
790	mComposer->mergeRetireFence(mFbSlot, HwcFenceControl::dupFence(mPriorFrameRetireFence));
791	} else {
792	if (mComposer && mGE2DComposeFrameCount != 0) {
793	mComposer->removeRetireFence(mFbSlot);
794	}
795
796	if (mRenderMode == DIRECT_COMPOSE_MODE) {
797	addReleaseFence(mDirectRenderLayerId, HwcFenceControl::dupFence(mPriorFrameRetireFence));
798	}
799	}
800
801	// finally we need to update cursor's blank status.
802	if (cbInfo->fd > 0 && cursorShow != mCursorContext->getStatus()) {
803	mCursorContext->setStatus(cursorShow);
804	DTRACE("UPDATE FB1 status to %d", !cursorShow);
805	ioctl(cbInfo->fd, FBIOBLANK, !cursorShow);
806	}
807
808	#if PLATFORM_SDK_VERSION >= 26 //TEMP, will remove later.
809	if (*outRetireFence >= 0) {
810	HwcFenceControl::wait(*outRetireFence, -1);
811	HwcFenceControl::closeFd(*outRetireFence);
812	*outRetireFence = -1;
813	}
814	#endif
815	}
816
817	if (mRenderMode != GE2D_COMPOSE_MODE) {
818	mGE2DComposeFrameCount = 0;
819	}
820
821	return HWC2_ERROR_NONE;
822	}
823
824	// TODO: need add fence wait.
825	int32_t PhysicalDevice::setOSD0Blank(bool blank) {
826	framebuffer_info_t* fbInfo = mFramebufferContext->getInfo();
827
828	if (fbInfo->fd > 0 && blank != mFramebufferContext->getStatus()) {
829	mFramebufferContext->setStatus(blank);
830	DTRACE("UPDATE FB0 status to %d", blank);
831	ioctl(fbInfo->fd, FBIOBLANK, blank);
832	}
833
834	return HWC2_ERROR_NONE;
835	}
836
837	int32_t PhysicalDevice::presentDisplay(int32_t* outRetireFence) {
838	int32_t err = HWC2_ERROR_NONE;
839	HwcLayer* layer = NULL;
840	bool hasVideoOverlay = false;
841
842	if (mIsValidated) {
843	// TODO: need improve the way to set video axis.
844	#if WITH_LIBPLAYER_MODULE
845	ssize_t index = mHwcLayers.indexOfKey(mVideoOverlayLayerId);
846	if (index >= 0) {
847	layer = mHwcLayers.valueFor(mVideoOverlayLayerId);
848	if (layer != NULL) {
849	layer->presentOverlay();
850	hasVideoOverlay = true;
851	if (mGE2DClearVideoRegionCount < 3) {
852	mGE2DClearVideoRegionCount++;
853	}
854	}
855	} else {
856	mGE2DClearVideoRegionCount = 0;
857	}
858	#endif
859	err = postFramebuffer(outRetireFence, hasVideoOverlay);
860	} else { // display not validate yet.
861	err = HWC2_ERROR_NOT_VALIDATED;
862	}
863
864	// reset layers' acquire fence.
865	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
866	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
867	layer = mHwcLayers.valueAt(i);
868	if (layer != NULL) {
869	layer->resetAcquireFence();
870	}
871	}
872
873	mClientTargetHnd = NULL;
874
875	ALOGE("presentDisplay return err %d", err);
876	return err;
877	}
878
879	int32_t PhysicalDevice::setActiveConfig(
880	hwc2_config_t config) {
881	Mutex::Autolock _l(mLock);
882
883	int32_t err = mDisplayHdmi->setActiveConfig(config);
884	if (err == HWC2_ERROR_NONE)
885	mVsyncObserver->setRefreshRate(mDisplayHdmi->getActiveRefreshRate());
886
887	return err;
888	}
889
890	int32_t PhysicalDevice::setClientTarget(
891	buffer_handle_t target,
892	int32_t acquireFence,
893	int32_t /*android_dataspace_t*/ dataspace,
894	hwc_region_t damage) {
895
896	if (target && private_handle_t::validate(target) < 0) {
897	return HWC2_ERROR_BAD_PARAMETER;
898	}
899
900	if (NULL != target) {
901	mClientTargetHnd = target;
902	mClientTargetDamageRegion = damage;
903	mTargetAcquireFence = acquireFence;
904	DTRACE("setClientTarget %p, %d", target, acquireFence);
905	// TODO: HWC2_ERROR_BAD_PARAMETER && dataspace && damage.
906	} else {
907	DTRACE("client target is null!, no need to update this frame.");
908	}
909
910	return HWC2_ERROR_NONE;
911	}
912
913	int32_t PhysicalDevice::setColorMode(
914	int32_t /*android_color_mode_t*/ mode) {
915	return HWC2_ERROR_NONE;
916	}
917
918	int32_t PhysicalDevice::setColorTransform(
919	const float* matrix,
920	int32_t /*android_color_transform_t*/ hint) {
921	return HWC2_ERROR_NONE;
922	}
923
924	int32_t PhysicalDevice::setPowerMode(
925	int32_t /*hwc2_power_mode_t*/ mode){
926
927	mPowerMode = mode;
928	return HWC2_ERROR_NONE;
929	}
930
931	bool PhysicalDevice::vsyncControl(bool enabled) {
932	RETURN_FALSE_IF_NOT_INIT();
933
934	ATRACE("disp = %d, enabled = %d", mId, enabled);
935	return mVsyncObserver->control(enabled);
936	}
937
938	void PhysicalDevice::dumpLayers(Vector < hwc2_layer_t > layerIds) {
939	for (uint32_t x=0; x<layerIds.size(); x++) {
940	HwcLayer* layer = getLayerById(layerIds.itemAt(x));
941	static char const* compositionTypeName[] = {
942	"UNKNOWN",
943	"GLES",
944	"HWC",
945	"SOLID",
946	"HWC_CURSOR",
947	"SIDEBAND"};
948	ETRACE(" %11s | %12" PRIxPTR " | %10d | %02x | %1.2f | %02x | %04x |%7.1f,%7.1f,%7.1f,%7.1f |%5d,%5d,%5d,%5d \n",
949	compositionTypeName[layer->getCompositionType()],
950	intptr_t(layer->getBufferHandle()), layer->getZ(), layer->getDataspace(),
951	layer->getPlaneAlpha(), layer->getTransform(), layer->getBlendMode(),
952	layer->getSourceCrop().left, layer->getSourceCrop().top, layer->getSourceCrop().right, layer->getSourceCrop().bottom,
953	layer->getDisplayFrame().left, layer->getDisplayFrame().top, layer->getDisplayFrame().right, layer->getDisplayFrame().bottom);
954	}
955	}
956
957	void PhysicalDevice::dumpLayers(KeyedVector<hwc2_layer_t, HwcLayer*> layers) {
958	for (uint32_t x=0; x<layers.size(); x++) {
959	HwcLayer* layer = layers.valueAt(x);
960	static char const* compositionTypeName[] = {
961	"UNKNOWN",
962	"GLES",
963	"HWC",
964	"SOLID",
965	"HWC_CURSOR",
966	"SIDEBAND"};
967	ETRACE(" %11s | %12" PRIxPTR " | %10d | %02x | %1.2f | %02x | %04x |%7.1f,%7.1f,%7.1f,%7.1f |%5d,%5d,%5d,%5d \n",
968	compositionTypeName[layer->getCompositionType()],
969	intptr_t(layer->getBufferHandle()), layer->getZ(), layer->getDataspace(),
970	layer->getPlaneAlpha(), layer->getTransform(), layer->getBlendMode(),
971	layer->getSourceCrop().left, layer->getSourceCrop().top, layer->getSourceCrop().right, layer->getSourceCrop().bottom,
972	layer->getDisplayFrame().left, layer->getDisplayFrame().top, layer->getDisplayFrame().right, layer->getDisplayFrame().bottom);
973	}
974	}
975
976	bool PhysicalDevice::layersStateCheck(int32_t renderMode,
977	KeyedVector<hwc2_layer_t, HwcLayer*> & composeLayers) {
978	bool ret = false;
979	uint32_t layerNum = composeLayers.size();
980	hwc_frect_t sourceCrop[HWC2_MAX_LAYERS];
981	HwcLayer* layer[HWC2_MAX_LAYERS] = { NULL };
982	private_handle_t const* hnd[HWC2_MAX_LAYERS] = { NULL };
983	hwc_rect_t displayFrame[HWC2_MAX_LAYERS];
984
985	for (int32_t i=0; i<layerNum; i++) {
986	layer[i] = composeLayers.valueAt(i);
987	sourceCrop[i] = layer[i]->getSourceCrop();
988	displayFrame[i] = layer[i]->getDisplayFrame();
989	hnd[i] = reinterpret_cast<private_handle_t const*>(layer[i]->getBufferHandle());
990	if (hnd[i] == NULL) return false; // no buffer to process.
991	if (hnd[i]->share_fd == -1) return false; // no buffer to process.
992	DTRACE("layer[%d] zorder: %d, blend: %d, PlaneAlpha: %f, "
993	"mColor: [%d, %d, %d, %d], mDataSpace: %d, format hnd[%d]: %x",
994	i, layer[i]->getZ(), layer[i]->getBlendMode(), layer[i]->getPlaneAlpha(),
995	layer[i]->getColor().r, layer[i]->getColor().g, layer[i]->getColor().b,
996	layer[i]->getColor().a, layer[i]->getDataspace(), i, hnd[i]->format);
997	}
998
999	if (renderMode == DIRECT_COMPOSE_MODE) {
1000	switch (hnd[0]->format) {
1001	case HAL_PIXEL_FORMAT_RGBA_8888:
1002	case HAL_PIXEL_FORMAT_RGBX_8888:
1003	case HAL_PIXEL_FORMAT_RGB_888:
1004	case HAL_PIXEL_FORMAT_RGB_565:
1005	case HAL_PIXEL_FORMAT_BGRA_8888:
1006	DTRACE("Layer format match direct composer.");
1007	ret = true;
1008	break;
1009	default:
1010	DTRACE("Layer format not support by direct compose");
1011	return false;
1012	break;
1013	}
1014	if (layer[0]->isCropped()
1015	|| layer[0]->isScaled()
1016	|| layer[0]->isOffset()) {
1017	DTRACE("direct compose can not process!");
1018	return false;
1019	}
1020	}
1021	#ifdef ENABLE_AML_GE2D_COMPOSER
1022	else if (renderMode == GE2D_COMPOSE_MODE) {
1023	bool yuv420Sp = false;
1024	for (int32_t i=0; i<layerNum; i++) {
1025	switch (hnd[i]->format) {
1026	case HAL_PIXEL_FORMAT_YCrCb_420_SP:
1027	yuv420Sp = true;
1028	case HAL_PIXEL_FORMAT_RGBA_8888:
1029	case HAL_PIXEL_FORMAT_RGBX_8888:
1030	case HAL_PIXEL_FORMAT_RGB_888:
1031	case HAL_PIXEL_FORMAT_RGB_565:
1032	case HAL_PIXEL_FORMAT_BGRA_8888:
1033	case HAL_PIXEL_FORMAT_YV12:
1034	case HAL_PIXEL_FORMAT_Y8:
1035	case HAL_PIXEL_FORMAT_YCbCr_422_SP:
1036	case HAL_PIXEL_FORMAT_YCbCr_422_I:
1037	DTRACE("Layer format match ge2d composer.");
1038	ret = true;
1039	break;
1040	default:
1041	DTRACE("Layer format not support by ge2d");
1042	return false;
1043	break;
1044	}
1045	if (layer[i]->havePlaneAlpha()
1046	|| layer[i]->haveColor()
1047	|| layer[i]->haveDataspace()
1048	|| (layer[i]->isBlended()
1049	&& layer[i]->isScaled())) {
1050	DTRACE("ge2d compose can not process!");
1051	return false;
1052	}
1053	}
1054	#if 0
1055	if (yuv420Sp && HWC2_TWO_LAYERS == layerNum) {
1056	if (Utils::compareRect(sourceCrop[0], sourceCrop[1])
1057	&& Utils::compareRect(sourceCrop[0], displayFrame[0])
1058	&& Utils::compareRect(sourceCrop[1], displayFrame[1])) {
1059	DTRACE("2 layers is same size and have yuv420sp format ge2d compose can not process!");
1060	return false;
1061	}
1062	}
1063	#endif
1064	if (HWC2_TWO_LAYERS == layerNum
1065	&& (!Utils::compareSize(sourceCrop[0], sourceCrop[1])
1066	|| !Utils::compareSize(displayFrame[0], displayFrame[1]))) {
1067	DTRACE("when 2 layer's size is difference, ge2d compose can not process!");
1068	return false;
1069	}
1070	}
1071	#endif
1072
1073	return ret;
1074	}
1075
1076	/*************************************************************
1077	* For direct framebuffer composer:
1078	* 1) only support one layer.
1079	* 2) layer format: rgba, rgbx,rgb565,bgra;
1080	* 3) layer no need scale to display;
1081	* 4) layer has no offset to display;
1082
1083	* For ge2d composer:
1084	* 1) support layer format that direct composer can't support.
1085	* 2) support 2 layers blending.
1086	* 3) support scale and rotation etc.
1087	**************************************************************/
1088	int32_t PhysicalDevice::composersFilter(
1089	KeyedVector<hwc2_layer_t, HwcLayer*> & composeLayers) {
1090
1091	// direct Composer.
1092	if (composeLayers.size() == HWC2_ONE_LAYER) {
1093	// if only one layer exists, do direct framebuffer composer.
1094	bool directCompose = layersStateCheck(DIRECT_COMPOSE_MODE, composeLayers);
1095	if (directCompose) {
1096	if (mDirectComposeFrameCount >= 3) {
1097	hwc2_layer_t layerGlesLayerId = composeLayers.keyAt(0);
1098	composeLayers.clear();
1099	mDirectRenderLayerId = layerGlesLayerId;
1100	return DIRECT_COMPOSE_MODE;
1101	}
1102	mDirectComposeFrameCount++;
1103	return GLES_COMPOSE_MODE;
1104	}
1105	}
1106
1107	#ifdef ENABLE_AML_GE2D_COMPOSER
1108	// if direct composer can't work, try this.
1109	if (composeLayers.size() > HWC2_NO_LAYER
1110	&& composeLayers.size() < HWC2_MAX_LAYERS) {
1111	bool ge2dCompose = layersStateCheck(GE2D_COMPOSE_MODE, composeLayers);
1112	if (!ge2dCompose) return GLES_COMPOSE_MODE;
1113	mGE2DRenderSortedLayerIds.clear();
1114	for (uint32_t i=0; i<composeLayers.size(); i++) {
1115	hwc2_layer_t layerGlesLayerId = composeLayers.keyAt(i);
1116	HwcLayer* layer = getLayerById(layerGlesLayerId);
1117	if (0 == i) {
1118	mGE2DRenderSortedLayerIds.push_front(layerGlesLayerId);
1119	continue;
1120	}
1121	for (uint32_t j=0; j<i; j++) {
1122	HwcLayer* layer1 = getLayerById(mGE2DRenderSortedLayerIds.itemAt(j));
1123	HwcLayer* layer2 = getLayerById(layerGlesLayerId);
1124	if (layer1 != NULL && layer2 != NULL) {
1125	uint32_t z1 = layer1->getZ();
1126	uint32_t z2 = layer2->getZ();
1127	if (layer1->getZ() > layer2->getZ()) {
1128	mGE2DRenderSortedLayerIds.insertAt(layerGlesLayerId, j, 1);
1129	break;
1130	}
1131	if (j == i-1) mGE2DRenderSortedLayerIds.push_back(layerGlesLayerId);
1132	} else {
1133	ETRACE("Layer1 or Layer2 is NULL!!!");
1134	}
1135	}
1136	}
1137
1138	// Vector < hwc2_layer_t > layerIds;
1139	if (!mComposer) {
1140	// create ge2d composer...
1141	mComposer = mControlFactory->createComposer(*this);
1142	if (!mComposer || !mComposer->initialize(mFramebufferContext->getInfo())) {
1143	DEINIT_AND_DELETE_OBJ(mComposer);
1144	return GLES_COMPOSE_MODE;
1145	}
1146	}
1147	composeLayers.clear();
1148	return GE2D_COMPOSE_MODE;
1149	}
1150	#endif
1151
1152	return GLES_COMPOSE_MODE;
1153	}
1154
1155	int32_t PhysicalDevice::validateDisplay(uint32_t* outNumTypes,
1156	uint32_t* outNumRequests) {
1157	HwcLayer* layer = NULL;
1158	bool istvp = false;
1159	KeyedVector<hwc2_layer_t, HwcLayer*> composeLayers;
1160	composeLayers.clear();
1161
1162	mRenderMode = GLES_COMPOSE_MODE;
1163	mVideoOverlayLayerId = 0;
1164	mIsContinuousBuf = true;
1165	swapReleaseFence();
1166	memset(&mFbSyncRequest, 0, sizeof(mFbSyncRequest));
1167	mHwcGlesLayers.clear();
1168	mIsValidated = false;
1169
1170	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
1171	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
1172	layer = mHwcLayers.valueAt(i);
1173	if (layer != NULL) {
1174	// Physical Display.
1175	private_handle_t const* hnd =
1176	reinterpret_cast<private_handle_t const*>(layer->getBufferHandle());
1177	if (hnd) {
1178	// continous buffer.
1179	if (!(hnd->flags & private_handle_t::PRIV_FLAGS_CONTINUOUS_BUF
1180	|| hnd->flags & private_handle_t::PRIV_FLAGS_VIDEO_OVERLAY)) {
1181	DTRACE("continous buffer flag is not set, bufhnd: 0x%" PRIxPTR "", intptr_t(layer->getBufferHandle()));
1182	mIsContinuousBuf = false;
1183	}
1184	#ifdef HWC_ENABLE_SECURE_LAYER
1185	// secure or protected layer.
1186	if (!mSecure && (hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_PROTECTED)) {
1187	ETRACE("layer's secure or protected buffer flag is set!");
1188	if (layer->getCompositionType() != HWC2_COMPOSITION_DEVICE) {
1189	mHwcLayersChangeType.add(layerId, layer);
1190	}
1191	mHwcSecureLayers.add(layerId, layer);
1192	continue;
1193	}
1194	#endif
1195	if (layer->getCompositionType() == HWC2_COMPOSITION_DEVICE) {
1196	// video overlay.
1197	if (hnd->flags & private_handle_t::PRIV_FLAGS_VIDEO_OMX) {
1198	set_omx_pts((char*)hnd->base, &Amvideo_Handle);
1199	istvp = true;
1200	}
1201	if (hnd->flags & private_handle_t::PRIV_FLAGS_VIDEO_OVERLAY) {
1202	DTRACE("PRIV_FLAGS_VIDEO_OVERLAY!!!!");
1203	mVideoOverlayLayerId = layerId;
1204	mHwcLayersChangeRequest.add(layerId, layer);
1205	continue;
1206	}
1207
1208	composeLayers.add(layerId, layer);
1209	continue;
1210	}
1211	}
1212
1213	// cursor layer.
1214	if (layer->getCompositionType() == HWC2_COMPOSITION_CURSOR) {
1215	DTRACE("This is a Cursor layer!");
1216	mHwcLayersChangeRequest.add(layerId, layer);
1217	continue;
1218	}
1219
1220	// sideband stream.
1221	if (layer->getCompositionType() == HWC2_COMPOSITION_SIDEBAND
1222	&& layer->getSidebandStream()) {
1223	// TODO: we just transact SIDEBAND to OVERLAY for now;
1224	DTRACE("get HWC_SIDEBAND layer, just change to overlay");
1225	mHwcLayersChangeRequest.add(layerId, layer);
1226	mHwcLayersChangeType.add(layerId, layer);
1227	mVideoOverlayLayerId = layerId;
1228	continue;
1229	}
1230
1231	// solid color.
1232	if (layer->getCompositionType() == HWC2_COMPOSITION_SOLID_COLOR) {
1233	DTRACE("This is a Solid Color layer!");
1234	// mHwcLayersChangeRequest.add(layerId, layer);
1235	// mHwcLayersChangeType.add(layerId, layer);
1236	composeLayers.add(layerId, layer);
1237	continue;
1238	}
1239
1240	if (layer->getCompositionType() == HWC2_COMPOSITION_CLIENT) {
1241	mHwcGlesLayers.add(layerId, layer);
1242	DTRACE("Meet a client layer!");
1243	}
1244	}
1245	}
1246
1247	bool noDevComp = Utils::checkBoolProp("sys.sf.debug.nohwc");
1248	#ifndef USE_CONTINOUS_BUFFER_COMPOSER
1249	DTRACE("No continous buffer composer!");
1250	noDevComp = true;
1251	mIsContinuousBuf = false;
1252	#endif
1253
1254	if (mHwcLayers.size() == 0) {
1255	mIsContinuousBuf = false;
1256	}
1257
1258	// dumpLayers(mHwcLayers);
1259	if (mIsContinuousBuf && !noDevComp && (mHwcGlesLayers.size() == 0)) {
1260	mRenderMode = composersFilter(composeLayers);
1261	} else {
1262	mDirectComposeFrameCount = 0;
1263	}
1264
1265	//DEVICE_COMPOSE layers set to CLIENT_COMPOSE layers.
1266	for (int i=0; i<composeLayers.size(); i++) {
1267	mHwcLayersChangeType.add(composeLayers.keyAt(i), composeLayers.valueAt(i));
1268	mHwcGlesLayers.add(composeLayers.keyAt(i), composeLayers.valueAt(i));
1269	}
1270
1271	if (istvp == false && Amvideo_Handle!=0) {
1272	closeamvideo();
1273	Amvideo_Handle = 0;
1274	}
1275
1276	if (mHwcLayersChangeRequest.size() > 0) {
1277	DTRACE("There are %d layer requests.", mHwcLayersChangeRequest.size());
1278	*outNumRequests = mHwcLayersChangeRequest.size();
1279	}
1280
1281	mIsValidated = true;
1282
1283	if (mHwcLayersChangeType.size() > 0) {
1284	DTRACE("there are %d layer types has changed.", mHwcLayersChangeType.size());
1285	*outNumTypes = mHwcLayersChangeType.size();
1286	return HWC2_ERROR_HAS_CHANGES;
1287	}
1288
1289	return HWC2_ERROR_NONE;
1290	}
1291
1292	int32_t PhysicalDevice::setCursorPosition(hwc2_layer_t layerId, int32_t x, int32_t y) {
1293	HwcLayer* layer = getLayerById(layerId);
1294	if (layer && HWC2_COMPOSITION_CURSOR == layer->getCompositionType()) {
1295	framebuffer_info_t* cbInfo = mCursorContext->getInfo();
1296	fb_cursor cinfo;
1297	if (cbInfo->fd < 0) {
1298	ETRACE("setCursorPosition fd=%d", cbInfo->fd );
1299	}else {
1300	cinfo.hot.x = x;
1301	cinfo.hot.y = y;
1302	DTRACE("setCursorPosition x_pos=%d, y_pos=%d", cinfo.hot.x, cinfo.hot.y);
1303
1304	// from kernel 4.9 use FBIOPUT_OSD_CURSOR instead of FBIO_CURSOR
1305	if (mUsingPutCurosr)
1306	ioctl(cbInfo->fd, FBIOPUT_OSD_CURSOR, &cinfo);
1307	else
1308	ioctl(cbInfo->fd, FBIO_CURSOR, &cinfo);
1309	}
1310	} else {
1311	ETRACE("setCursorPosition bad layer.");
1312	return HWC2_ERROR_BAD_LAYER;
1313	}
1314
1315	return HWC2_ERROR_NONE;
1316	}
1317
1318
1319	/*
1320	Operater of framebuffer
1321	*/
1322	int32_t PhysicalDevice::initDisplay() {
1323	if (mIsConnected) return 0;
1324
1325	Mutex::Autolock _l(mLock);
1326
1327	if (!mFramebufferHnd) {
1328	// init framebuffer context.
1329	mFramebufferContext = new FBContext();
1330	framebuffer_info_t* fbInfo = mFramebufferContext->getInfo();
1331	// init information from osd.
1332	fbInfo->displayType = mId;
1333	fbInfo->fbIdx = getOsdIdx(mId);
1334	int32_t err = init_frame_buffer_locked(fbInfo);
1335	int32_t bufferSize = fbInfo->finfo.line_length
1336	* fbInfo->info.yres;
1337	DTRACE("init_frame_buffer get fbinfo->fbIdx (%d) "
1338	"fbinfo->info.xres (%d) fbinfo->info.yres (%d)",
1339	fbInfo->fbIdx, fbInfo->info.xres,
1340	fbInfo->info.yres);
1341	int32_t usage = 0;
1342
1343	#if PLATFORM_SDK_VERSION < 26
1344	private_module_t *grallocModule = Hwcomposer::getInstance().getGrallocModule();
1345	if (mId == HWC_DISPLAY_PRIMARY) {
1346	grallocModule->fb_primary.fb_info = *(fbInfo);
1347	} else if (mId == HWC_DISPLAY_EXTERNAL) {
1348	grallocModule->fb_external.fb_info = *(fbInfo);
1349	usage |= GRALLOC_USAGE_EXTERNAL_DISP;
1350	}
1351	fbInfo->grallocModule = grallocModule;
1352	#endif
1353
1354	//Register the framebuffer to gralloc module
1355	mFramebufferHnd = new private_handle_t(
1356	private_handle_t::PRIV_FLAGS_FRAMEBUFFER,
1357	usage, fbInfo->fbSize, 0,
1358	0, fbInfo->fd, bufferSize, 0);
1359	#if PLATFORM_SDK_VERSION < 26
1360	grallocModule->base.registerBuffer(&(grallocModule->base), mFramebufferHnd);
1361	#endif
1362
1363	DTRACE("init_frame_buffer get frame size %d usage %d",
1364	bufferSize, usage);
1365	}
1366
1367	mIsConnected = true;
1368
1369	// init cursor framebuffer
1370	mCursorContext = new FBContext();
1371	framebuffer_info_t* cbInfo = mCursorContext->getInfo();
1372	cbInfo->fd = -1;
1373
1374	//init information from cursor framebuffer.
1375	cbInfo->fbIdx = mId*2+1;
1376	if (1 != cbInfo->fbIdx && 3 != cbInfo->fbIdx) {
1377	ETRACE("invalid fb index: %d, need to check!",
1378	cbInfo->fbIdx);
1379	return 0;
1380	}
1381	int32_t err = init_cursor_buffer_locked(cbInfo);
1382	if (err != 0) {
1383	ETRACE("init_cursor_buffer_locked failed, need to check!");
1384	return 0;
1385	}
1386	ITRACE("init_cursor_buffer get cbinfo->fbIdx (%d) "
1387	"cbinfo->info.xres (%d) cbinfo->info.yres (%d)",
1388	cbInfo->fbIdx,
1389	cbInfo->info.xres,
1390	cbInfo->info.yres);
1391
1392	if ( cbInfo->fd >= 0) {
1393	DTRACE("init_cursor_buffer success!");
1394	}else{
1395	DTRACE("init_cursor_buffer fail!");
1396	}
1397
1398	return 0;
1399	}
1400
1401	bool PhysicalDevice::updateDisplayConfigs() {
1402	Mutex::Autolock _l(mLock);
1403	bool ret;
1404
1405	if (!mIsConnected) {
1406	ETRACE("disp: %llu is not connected", mId);
1407	return false;
1408	}
1409
1410	framebuffer_info_t* fbinfo = mFramebufferContext->getInfo();
1411	ret = Utils::checkVinfo(fbinfo);
1412	if (!ret) {
1413	ETRACE("checkVinfo fail");
1414	return false;
1415	}
1416
1417	mDisplayHdmi->updateHotplug(mIsConnected, fbinfo, mFramebufferHnd);
1418	if (mIsConnected)
1419	mVsyncObserver->setRefreshRate(mDisplayHdmi->getActiveRefreshRate());
1420	//ETRACE("updateDisplayConfigs rate:%d", mDisplayHdmi->getActiveRefreshRate());
1421
1422	// check hdcp authentication status when hotplug is happen.
1423	int status = 0;
1424	bool trebleSystemControlEnable = property_get_bool("persist.system_control.treble", true);
1425	sp<ISystemControl> trebleSystemControl;
1426	if (trebleSystemControlEnable) {
1427	ITRACE("ISystemControl::getService");
1428	trebleSystemControl = ISystemControl::getService();
1429	if (trebleSystemControl != NULL) {
1430	ITRACE("Link to system service death notification successful");
1431
1432	Result ret = trebleSystemControl->isHDCPTxAuthSuccess();
1433	if (Result::OK == ret) {
1434	status = 1;
1435	}
1436	}
1437	else
1438	ETRACE("ISystemControl::getService fail");
1439	}
1440	else {
1441	sp<IServiceManager> sm = defaultServiceManager();
1442	if (sm == NULL) {
1443	ETRACE("Couldn't get default ServiceManager\n");
1444	return NULL;
1445	}
1446	sp<IBinder> binder = sm->getService(String16("system_control"));
1447	sp<ISystemControlService> sc = interface_cast<ISystemControlService>(binder);
1448	sc->isHDCPTxAuthSuccess(status);
1449	}
1450
1451	DTRACE("hdcp status: %d", status);
1452	mSecure = (status == 1) ? true : false;
1453
1454	return true;
1455	}
1456
1457	sp<ISystemControlService> PhysicalDevice::getSystemControlService()
1458	{
1459	sp<IServiceManager> sm = defaultServiceManager();
1460	if (sm == NULL) {
1461	ETRACE("Couldn't get default ServiceManager\n");
1462	return NULL;
1463	}
1464	sp<IBinder> binder = sm->getService(String16("system_control"));
1465	sp<ISystemControlService> sc = interface_cast<ISystemControlService>(binder);
1466
1467	return sc;
1468	}
1469
1470	void PhysicalDevice::onVsync(int64_t timestamp) {
1471	RETURN_VOID_IF_NOT_INIT();
1472	ATRACE("timestamp = %lld", timestamp);
1473
1474	if (!mIsConnected)
1475	return;
1476
1477	// notify hwc
1478	mHwc.vsync(mId, timestamp);
1479	}
1480
1481	int32_t PhysicalDevice::createVirtualDisplay(
1482	uint32_t width,
1483	uint32_t height,
1484	int32_t* /*android_pixel_format_t*/ format,
1485	hwc2_display_t* outDisplay) {
1486
1487	return HWC2_ERROR_NONE;
1488	}
1489
1490	int32_t PhysicalDevice::destroyVirtualDisplay(
1491	hwc2_display_t display) {
1492
1493	return HWC2_ERROR_NONE;
1494	}
1495
1496	int32_t PhysicalDevice::setOutputBuffer(
1497	buffer_handle_t buffer, int32_t releaseFence) {
1498	// Virtual Display Only.
1499	return HWC2_ERROR_NONE;
1500	}
1501
1502	void PhysicalDevice::updateHotplugState(bool connected) {
1503	Mutex::Autolock _l(mLock);
1504
1505	mIsConnected = connected;
1506	//if plug out, need reinit
1507	if (!connected)
1508	mHdrCapabilities.init = false;
1509	}
1510
1511	int32_t PhysicalDevice::getLineValue(const char *lineStr, const char *magicStr) {
1512	int len = 0;
1513	char value[100] = {0};
1514	char *pos = NULL;
1515
1516	if ((NULL == lineStr) || (NULL == magicStr)) {
1517	ETRACE("line string: %s, magic string: %s\n", lineStr, magicStr);
1518	return 0;
1519	}
1520
1521	if (NULL != (pos = strstr((char *)lineStr, magicStr))) {
1522	pos = pos + strlen(magicStr);
1523	char* start = pos;
1524	while (*start != '\n' && (strlen(start) > 0))
1525	start++;
1526
1527	len = start - pos;
1528	strncpy(value, pos, len);
1529	value[len] = '\0';
1530	return atoi(value);
1531	}
1532
1533	return 0;
1534	}
1535
1536	/*
1537	cat /sys/class/amhdmitx/amhdmitx0/hdr_cap
1538	Supported EOTF:
1539	Traditional SDR: 1
1540	Traditional HDR: 0
1541	SMPTE ST 2084: 1
1542	Future EOTF: 0
1543	Supported SMD type1: 1
1544	Luminance Data
1545	Max: 0
1546	Avg: 0
1547	Min: 0
1548	cat /sys/class/amhdmitx/amhdmitx0/dv_cap
1549	DolbyVision1 RX support list:
1550	2160p30hz: 1
1551	global dimming
1552	colorimetry
1553	IEEEOUI: 0x00d046
1554	DM Ver: 1
1555	*/
1556	int32_t PhysicalDevice::parseHdrCapabilities() {
1557	//DolbyVision1
1558	const char *DV_PATH = "/sys/class/amhdmitx/amhdmitx0/dv_cap";
1559	//HDR
1560	const char *HDR_PATH = "/sys/class/amhdmitx/amhdmitx0/hdr_cap";
1561
1562	char buf[1024+1] = {0};
1563	char* pos = buf;
1564	int fd, len;
1565
1566	memset(&mHdrCapabilities, 0, sizeof(hdr_capabilities_t));
1567	if ((fd = open(DV_PATH, O_RDONLY)) < 0) {
1568	ETRACE("open %s fail.", DV_PATH);
1569	goto exit;
1570	}
1571
1572	len = read(fd, buf, 1024);
1573	if (len < 0) {
1574	ETRACE("read error: %s, %s\n", DV_PATH, strerror(errno));
1575	goto exit;
1576	}
1577	close(fd);
1578
1579	if ((NULL != strstr(pos, "2160p30hz")) || (NULL != strstr(pos, "2160p60hz")))
1580	mHdrCapabilities.dvSupport = true;
1581	//dobly version parse end
1582
1583	memset(buf, 0, 1024);
1584	if ((fd = open(HDR_PATH, O_RDONLY)) < 0) {
1585	ETRACE("open %s fail.", HDR_PATH);
1586	goto exit;
1587	}
1588
1589	len = read(fd, buf, 1024);
1590	if (len < 0) {
1591	ETRACE("read error: %s, %s\n", HDR_PATH, strerror(errno));
1592	goto exit;
1593	}
1594
1595	pos = strstr(pos, "SMPTE ST 2084: ");
1596	if ((NULL != pos) && ('1' == *(pos + strlen("SMPTE ST 2084: ")))) {
1597	mHdrCapabilities.hdrSupport = true;
1598
1599	mHdrCapabilities.maxLuminance = getLineValue(pos, "Max: ");
1600	mHdrCapabilities.avgLuminance = getLineValue(pos, "Avg: ");
1601	mHdrCapabilities.minLuminance = getLineValue(pos, "Min: ");
1602	}
1603
1604	ITRACE("dolby version support:%d, hdr support:%d max:%d, avg:%d, min:%d\n",
1605	mHdrCapabilities.dvSupport?1:0, mHdrCapabilities.hdrSupport?1:0, mHdrCapabilities.maxLuminance, mHdrCapabilities.avgLuminance, mHdrCapabilities.minLuminance);
1606	exit:
1607	close(fd);
1608	return HWC2_ERROR_NONE;
1609	}
1610
1611	void PhysicalDevice::dump(Dump& d) {
1612	Mutex::Autolock _l(mLock);
1613	d.append("-------------------------------------------------------------"
1614	"----------------------------------------------------------------\n");
1615	d.append("Device Name: %s (%s)\n", mName,
1616	mIsConnected ? "connected" : "disconnected");
1617	mDisplayHdmi->dump(d);
1618
1619	// dump layer list
1620	d.append(" Layers state:\n");
1621	d.append(" numLayers=%zu\n", mHwcLayers.size());
1622	// d.append(" numChangedTypeLayers=%zu\n", mHwcLayersChangeType.size());
1623	// d.append(" numChangedRequestLayers=%zu\n", mHwcLayersChangeRequest.size());
1624
1625	if (mHwcLayers.size() > 0) {
1626	d.append(
1627	" type | handle | zorder | ds | alpa | tr | blnd |"
1628	" source crop (l,t,r,b) | frame \n"
1629	" -------------+--------------+------------+----+------+----+------+"
1630	"--------------------------------+------------------------\n");
1631	for (uint32_t i=0; i<mHwcLayers.size(); i++) {
1632	hwc2_layer_t layerId = mHwcLayers.keyAt(i);
1633	HwcLayer *layer = mHwcLayers.valueAt(i);
1634	if (layer) layer->dump(d);
1635	}
1636	}
1637
1638	// HDR info
1639	d.append(" HDR Capabilities:\n");
1640	d.append(" DolbyVision1=%zu\n", mHdrCapabilities.dvSupport?1:0);
1641	d.append(" HDR10=%zu, maxLuminance=%zu, avgLuminance=%zu, minLuminance=%zu\n",
1642	mHdrCapabilities.hdrSupport?1:0, mHdrCapabilities.maxLuminance, mHdrCapabilities.avgLuminance, mHdrCapabilities.minLuminance);
1643	}
1644
1645	} // namespace amlogic
1646	} // namespace android
1647