Merge remote-tracking branch 'aosp/master' into HEADlinaro-android-pie-treble

The FULL_TREBLE support was merged in June. The current
pie-dev branch were create in May from Master.

This update will make sure the next minor Android update
will include hikey with full treble support.

This also gives developers using stable Android codebase on
HiKey/HiKey960 will be able to make use of latest changes.

Change-Id: I90595c3229281938bc6b69b2160556bbf0366aca

1 files changed, 451 insertions, 0 deletions

diff --git a/gralloc960/mali_gralloc_public_interface.cpp b/gralloc960/mali_gralloc_public_interface.cpp
new file mode 100644
index 00000000..9475d827
--- /dev/null
+++ b/gralloc960/mali_gralloc_public_interface.cpp
@@ -0,0 +1,451 @@
+/*
+ * Copyright (C) 2016 ARM Limited. All rights reserved.
+ *
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <hardware/hardware.h>
+#include <hardware/gralloc1.h>
+
+#include "mali_gralloc_module.h"
+
+#include "mali_gralloc_private_interface.h"
+#include "mali_gralloc_buffer.h"
+#include "mali_gralloc_ion.h"
+#include "mali_gralloc_bufferdescriptor.h"
+#include "mali_gralloc_bufferallocation.h"
+#include "mali_gralloc_reference.h"
+#include "mali_gralloc_bufferaccess.h"
+#include "framebuffer_device.h"
+#include "gralloc_buffer_priv.h"
+#include "mali_gralloc_debug.h"
+
+typedef struct mali_gralloc_func
+{
+	gralloc1_function_descriptor_t desc;
+	gralloc1_function_pointer_t func;
+} mali_gralloc_func;
+
+static void mali_gralloc_dump(gralloc1_device_t *device, uint32_t *outSize, char *outBuffer)
+{
+	if (NULL == outSize)
+	{
+		ALOGE("Invalid pointer to outSize and return");
+		return;
+	}
+
+	mali_gralloc_dump_internal(outSize, outBuffer);
+	GRALLOC_UNUSED(device);
+}
+
+static int32_t mali_gralloc_create_descriptor(gralloc1_device_t *device, gralloc1_buffer_descriptor_t *outDescriptor)
+{
+	int ret = 0;
+	ret = mali_gralloc_create_descriptor_internal(outDescriptor);
+	GRALLOC_UNUSED(device);
+	return ret;
+}
+
+static int32_t mali_gralloc_destroy_descriptor(gralloc1_device_t *device, gralloc1_buffer_descriptor_t descriptor)
+{
+	int ret = 0;
+	ret = mali_gralloc_destroy_descriptor_internal(descriptor);
+	GRALLOC_UNUSED(device);
+	return ret;
+}
+
+static int32_t mali_gralloc_set_consumer_usage(gralloc1_device_t *device, gralloc1_buffer_descriptor_t descriptor,
+                                               /*uint64_t */ gralloc1_consumer_usage_t usage)
+{
+	int ret = 0;
+	ret = mali_gralloc_set_consumerusage_internal(descriptor, usage);
+	GRALLOC_UNUSED(device);
+	return ret;
+}
+
+static int32_t mali_gralloc_set_dimensions(gralloc1_device_t *device, gralloc1_buffer_descriptor_t descriptor,
+                                           uint32_t width, uint32_t height)
+{
+	int ret = 0;
+	ret = mali_gralloc_set_dimensions_internal(descriptor, width, height);
+	GRALLOC_UNUSED(device);
+	return ret;
+}
+
+static int32_t mali_gralloc_set_format(gralloc1_device_t *device, gralloc1_buffer_descriptor_t descriptor,
+                                       /*int32_t*/ android_pixel_format_t format)
+{
+	int ret = 0;
+	ret = mali_gralloc_set_format_internal(descriptor, format);
+	GRALLOC_UNUSED(device);
+	return ret;
+}
+
+static int32_t mali_gralloc_set_producer_usage(gralloc1_device_t *device, gralloc1_buffer_descriptor_t descriptor,
+                                               /*uint64_t */ gralloc1_producer_usage_t usage)
+{
+	int ret = 0;
+	ret = mali_gralloc_set_producerusage_internal(descriptor, usage);
+	GRALLOC_UNUSED(device);
+	return ret;
+}
+
+static int32_t mali_gralloc_get_backing_store(gralloc1_device_t *device, buffer_handle_t buffer,
+                                              gralloc1_backing_store_t *outStore)
+{
+	int ret = 0;
+	ret = mali_gralloc_get_backing_store_internal(buffer, outStore);
+	GRALLOC_UNUSED(device);
+	return ret;
+}
+
+static int32_t mali_gralloc_get_consumer_usage(gralloc1_device_t *device, buffer_handle_t buffer,
+                                               uint64_t * /*gralloc1_consumer_usage_t*/ outUsage)
+{
+	int ret = 0;
+	ret = mali_gralloc_get_consumer_usage_internal(buffer, outUsage);
+	GRALLOC_UNUSED(device);
+	return ret;
+}
+
+static int32_t mali_gralloc_get_dimensions(gralloc1_device_t *device, buffer_handle_t buffer, uint32_t *outWidth,
+                                           uint32_t *outHeight)
+{
+	int ret = 0;
+	ret = mali_gralloc_get_dimensions_internal(buffer, outWidth, outHeight);
+	GRALLOC_UNUSED(device);
+	return ret;
+}
+
+static int32_t mali_gralloc_get_format(gralloc1_device_t *device, buffer_handle_t buffer, int32_t *outFormat)
+{
+	int ret = 0;
+	ret = mali_gralloc_get_format_internal(buffer, outFormat);
+	GRALLOC_UNUSED(device);
+	return ret;
+}
+
+static int32_t mali_gralloc_get_producer_usage(gralloc1_device_t *device, buffer_handle_t buffer,
+                                               uint64_t * /*gralloc1_producer_usage_t*/ outUsage)
+{
+	int ret = 0;
+	ret = mali_gralloc_get_producer_usage_internal(buffer, outUsage);
+	GRALLOC_UNUSED(device);
+	return ret;
+}
+
+static int32_t mali_gralloc_get_stride(gralloc1_device_t *device, buffer_handle_t buffer, uint32_t *outStride)
+{
+	GRALLOC_UNUSED(device);
+
+	int stride;
+
+	if (mali_gralloc_query_getstride(buffer, &stride) < 0)
+	{
+		return GRALLOC1_ERROR_UNSUPPORTED;
+	}
+
+	*outStride = (uint32_t)stride;
+
+	return GRALLOC1_ERROR_NONE;
+}
+
+static int32_t mali_gralloc_allocate(gralloc1_device_t *device, uint32_t numDescriptors,
+                                     const gralloc1_buffer_descriptor_t *descriptors, buffer_handle_t *outBuffers)
+{
+	mali_gralloc_module *m;
+	m = reinterpret_cast<private_module_t *>(device->common.module);
+	buffer_descriptor_t *bufDescriptor = (buffer_descriptor_t *)(*descriptors);
+	uint64_t usage;
+	bool shared = false;
+
+	usage = bufDescriptor->producer_usage | bufDescriptor->consumer_usage;
+
+#if DISABLE_FRAMEBUFFER_HAL != 1
+
+	if (usage & GRALLOC_USAGE_HW_FB)
+	{
+		int byte_stride;
+		int pixel_stride;
+		int width, height;
+		uint64_t format;
+
+		format = bufDescriptor->hal_format;
+		width = bufDescriptor->width;
+		height = bufDescriptor->height;
+
+#if GRALLOC_FB_SWAP_RED_BLUE == 1
+#ifdef GRALLOC_16_BITS
+		format = HAL_PIXEL_FORMAT_RGB_565;
+#else
+		format = HAL_PIXEL_FORMAT_BGRA_8888;
+#endif
+#endif
+
+		if (fb_alloc_framebuffer(m, bufDescriptor->consumer_usage, bufDescriptor->producer_usage, outBuffers,
+		                         &pixel_stride, &byte_stride) < 0)
+		{
+			return GRALLOC1_ERROR_NO_RESOURCES;
+		}
+		else
+		{
+			private_handle_t *hnd = (private_handle_t *)*outBuffers;
+
+			/* Allocate a meta-data buffer for framebuffer too. fbhal
+			 * ones wont need it but for hwc they will.
+			 *
+			 * Explicitly ignore allocation errors since it is not critical to have
+			 */
+			(void)gralloc_buffer_attr_allocate(hnd);
+
+			hnd->req_format = format;
+			hnd->yuv_info = MALI_YUV_BT601_NARROW;
+			hnd->internal_format = format;
+			hnd->byte_stride = byte_stride;
+			hnd->width = width;
+			hnd->height = height;
+			hnd->stride = pixel_stride;
+			hnd->internalWidth = width;
+			hnd->internalHeight = height;
+		}
+	}
+	else
+#endif
+	{
+		if (mali_gralloc_buffer_allocate(m, (gralloc_buffer_descriptor_t *)descriptors, numDescriptors, outBuffers,
+		                                 &shared) < 0)
+		{
+			ALOGE("Failed to allocate buffer.");
+			return GRALLOC1_ERROR_NO_RESOURCES;
+		}
+
+		if (!shared && 1 != numDescriptors)
+		{
+			return GRALLOC1_ERROR_NOT_SHARED;
+		}
+	}
+
+	return GRALLOC1_ERROR_NONE;
+}
+
+static int32_t mali_gralloc_retain(gralloc1_device_t *device, buffer_handle_t buffer)
+{
+	mali_gralloc_module *m;
+	m = reinterpret_cast<private_module_t *>(device->common.module);
+
+	if (private_handle_t::validate(buffer) < 0)
+	{
+		return GRALLOC1_ERROR_BAD_HANDLE;
+	}
+
+	if (mali_gralloc_reference_retain(m, buffer) < 0)
+	{
+		return GRALLOC1_ERROR_NO_RESOURCES;
+	}
+
+	return GRALLOC1_ERROR_NONE;
+}
+
+static int32_t mali_gralloc_release(gralloc1_device_t *device, buffer_handle_t buffer)
+{
+	mali_gralloc_module *m;
+	m = reinterpret_cast<private_module_t *>(device->common.module);
+
+	if (mali_gralloc_reference_release(m, buffer, true) < 0)
+	{
+		return GRALLOC1_ERROR_BAD_HANDLE;
+	}
+
+	return GRALLOC1_ERROR_NONE;
+}
+
+static int32_t mali_gralloc1_get_num_flex_planes(gralloc1_device_t *device, buffer_handle_t buffer,
+                                                 uint32_t *outNumPlanes)
+{
+	mali_gralloc_module *m;
+	m = reinterpret_cast<private_module_t *>(device->common.module);
+
+	if (private_handle_t::validate(buffer) < 0)
+	{
+		return GRALLOC1_ERROR_BAD_HANDLE;
+	}
+
+	if (mali_gralloc_get_num_flex_planes(m, buffer, outNumPlanes) < 0)
+	{
+		return GRALLOC1_ERROR_UNSUPPORTED;
+	}
+
+	return GRALLOC1_ERROR_NONE;
+}
+
+static int32_t mali_gralloc1_lock_async(gralloc1_device_t *device, buffer_handle_t buffer,
+                                        uint64_t /*gralloc1_producer_usage_t*/ producerUsage,
+                                        uint64_t /*gralloc1_consumer_usage_t*/ consumerUsage,
+                                        const gralloc1_rect_t *accessRegion, void **outData, int32_t acquireFence)
+{
+	mali_gralloc_module *m;
+	m = reinterpret_cast<private_module_t *>(device->common.module);
+
+	if (private_handle_t::validate(buffer) < 0)
+	{
+		return GRALLOC1_ERROR_BAD_HANDLE;
+	}
+
+	if (!((producerUsage | consumerUsage) & (GRALLOC_USAGE_SW_READ_MASK | GRALLOC_USAGE_SW_WRITE_MASK)))
+	{
+		return GRALLOC1_ERROR_BAD_VALUE;
+	}
+
+	if (mali_gralloc_lock_async(m, buffer, producerUsage | consumerUsage, accessRegion->left, accessRegion->top,
+	                            accessRegion->width, accessRegion->height, outData, acquireFence) < 0)
+	{
+		return GRALLOC1_ERROR_UNSUPPORTED;
+	}
+
+	return GRALLOC1_ERROR_NONE;
+}
+
+static int32_t mali_gralloc1_lock_flex_async(gralloc1_device_t *device, buffer_handle_t buffer,
+                                             uint64_t /*gralloc1_producer_usage_t*/ producerUsage,
+                                             uint64_t /*gralloc1_consumer_usage_t*/ consumerUsage,
+                                             const gralloc1_rect_t *accessRegion,
+                                             struct android_flex_layout *outFlexLayout, int32_t acquireFence)
+{
+	mali_gralloc_module *m;
+	m = reinterpret_cast<private_module_t *>(device->common.module);
+
+	if (private_handle_t::validate(buffer) < 0)
+	{
+		return GRALLOC1_ERROR_BAD_HANDLE;
+	}
+
+	if (!((producerUsage | consumerUsage) & (GRALLOC_USAGE_SW_READ_MASK | GRALLOC_USAGE_SW_WRITE_MASK)))
+	{
+		return GRALLOC1_ERROR_BAD_VALUE;
+	}
+
+	if (mali_gralloc_lock_flex_async(m, buffer, producerUsage | consumerUsage, accessRegion->left, accessRegion->top,
+	                                 accessRegion->width, accessRegion->height, outFlexLayout, acquireFence) < 0)
+	{
+		return GRALLOC1_ERROR_UNSUPPORTED;
+	}
+
+	return GRALLOC1_ERROR_NONE;
+}
+
+static int32_t mali_gralloc1_unlock_async(gralloc1_device_t *device, buffer_handle_t buffer, int32_t *outReleaseFence)
+{
+	mali_gralloc_module *m;
+	m = reinterpret_cast<private_module_t *>(device->common.module);
+
+	if (private_handle_t::validate(buffer) < 0)
+	{
+		return GRALLOC1_ERROR_BAD_HANDLE;
+	}
+
+	mali_gralloc_unlock_async(m, buffer, outReleaseFence);
+	return GRALLOC1_ERROR_NONE;
+}
+
+static const mali_gralloc_func mali_gralloc_func_list[] = {
+	{ GRALLOC1_FUNCTION_DUMP, (gralloc1_function_pointer_t)mali_gralloc_dump },
+	{ GRALLOC1_FUNCTION_CREATE_DESCRIPTOR, (gralloc1_function_pointer_t)mali_gralloc_create_descriptor },
+	{ GRALLOC1_FUNCTION_DESTROY_DESCRIPTOR, (gralloc1_function_pointer_t)mali_gralloc_destroy_descriptor },
+	{ GRALLOC1_FUNCTION_SET_CONSUMER_USAGE, (gralloc1_function_pointer_t)mali_gralloc_set_consumer_usage },
+	{ GRALLOC1_FUNCTION_SET_DIMENSIONS, (gralloc1_function_pointer_t)mali_gralloc_set_dimensions },
+	{ GRALLOC1_FUNCTION_SET_FORMAT, (gralloc1_function_pointer_t)mali_gralloc_set_format },
+	{ GRALLOC1_FUNCTION_SET_PRODUCER_USAGE, (gralloc1_function_pointer_t)mali_gralloc_set_producer_usage },
+	{ GRALLOC1_FUNCTION_GET_BACKING_STORE, (gralloc1_function_pointer_t)mali_gralloc_get_backing_store },
+	{ GRALLOC1_FUNCTION_GET_CONSUMER_USAGE, (gralloc1_function_pointer_t)mali_gralloc_get_consumer_usage },
+	{ GRALLOC1_FUNCTION_GET_DIMENSIONS, (gralloc1_function_pointer_t)mali_gralloc_get_dimensions },
+	{ GRALLOC1_FUNCTION_GET_FORMAT, (gralloc1_function_pointer_t)mali_gralloc_get_format },
+	{ GRALLOC1_FUNCTION_GET_PRODUCER_USAGE, (gralloc1_function_pointer_t)mali_gralloc_get_producer_usage },
+	{ GRALLOC1_FUNCTION_GET_STRIDE, (gralloc1_function_pointer_t)mali_gralloc_get_stride },
+	{ GRALLOC1_FUNCTION_ALLOCATE, (gralloc1_function_pointer_t)mali_gralloc_allocate },
+	{ GRALLOC1_FUNCTION_RETAIN, (gralloc1_function_pointer_t)mali_gralloc_retain },
+	{ GRALLOC1_FUNCTION_RELEASE, (gralloc1_function_pointer_t)mali_gralloc_release },
+	{ GRALLOC1_FUNCTION_GET_NUM_FLEX_PLANES, (gralloc1_function_pointer_t)mali_gralloc1_get_num_flex_planes },
+	{ GRALLOC1_FUNCTION_LOCK, (gralloc1_function_pointer_t)mali_gralloc1_lock_async },
+	{ GRALLOC1_FUNCTION_LOCK_FLEX, (gralloc1_function_pointer_t)mali_gralloc1_lock_flex_async },
+	{ GRALLOC1_FUNCTION_UNLOCK, (gralloc1_function_pointer_t)mali_gralloc1_unlock_async },
+
+	/* GRALLOC1_FUNCTION_INVALID has to be the last descriptor on the list. */
+	{ GRALLOC1_FUNCTION_INVALID, NULL }
+};
+
+static void mali_gralloc_getCapabilities(gralloc1_device_t *dev, uint32_t *outCount, int32_t *outCapabilities)
+{
+	GRALLOC_UNUSED(dev);
+	GRALLOC_UNUSED(outCapabilities);
+
+	if (outCount != NULL)
+	{
+		*outCount = 0;
+	}
+}
+
+static gralloc1_function_pointer_t mali_gralloc_getFunction(gralloc1_device_t *dev, int32_t descriptor)
+{
+	GRALLOC_UNUSED(dev);
+	gralloc1_function_pointer_t rval = NULL;
+	uint32_t pos = 0;
+
+	while (mali_gralloc_func_list[pos].desc != GRALLOC1_FUNCTION_INVALID)
+	{
+		if (mali_gralloc_func_list[pos].desc == descriptor)
+		{
+			rval = mali_gralloc_func_list[pos].func;
+			break;
+		}
+
+		pos++;
+	}
+
+	if (rval == NULL)
+	{
+		rval = mali_gralloc_private_interface_getFunction(descriptor);
+	}
+
+	return rval;
+}
+
+int mali_gralloc_device_open(hw_module_t const *module, const char *name, hw_device_t **device)
+{
+	gralloc1_device_t *dev;
+
+	GRALLOC_UNUSED(name);
+
+	dev = new gralloc1_device_t;
+
+	if (NULL == dev)
+	{
+		return -1;
+	}
+
+	/* initialize our state here */
+	memset(dev, 0, sizeof(*dev));
+
+	/* initialize the procs */
+	dev->common.tag = HARDWARE_DEVICE_TAG;
+	dev->common.version = 0;
+	dev->common.module = const_cast<hw_module_t *>(module);
+	dev->common.close = mali_gralloc_ion_device_close;
+
+	dev->getCapabilities = mali_gralloc_getCapabilities;
+	dev->getFunction = mali_gralloc_getFunction;
+
+	*device = &dev->common;
+
+	return 0;
+}