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

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