diff options
Diffstat (limited to 'gralloc960/mali_gralloc_public_interface.cpp')
| -rw-r--r-- | gralloc960/mali_gralloc_public_interface.cpp | 451 |
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; +} |