diff options
Diffstat (limited to 'tests/test_include/mali_gralloc_buffer.h')
-rw-r--r-- | tests/test_include/mali_gralloc_buffer.h | 271 |
1 files changed, 271 insertions, 0 deletions
diff --git a/tests/test_include/mali_gralloc_buffer.h b/tests/test_include/mali_gralloc_buffer.h new file mode 100644 index 0000000..83f77c2 --- /dev/null +++ b/tests/test_include/mali_gralloc_buffer.h @@ -0,0 +1,271 @@ +// clang-format off +/* + * Copyright (C) 2017 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. + */ +#ifndef MALI_GRALLOC_BUFFER_H_ +#define MALI_GRALLOC_BUFFER_H_ + +#include <errno.h> +#include <sys/types.h> +#include <unistd.h> +#include <sys/mman.h> + +#include "mali_gralloc_private_interface_types.h" + +/* NOTE: + * If your framebuffer device driver is integrated with dma_buf, you will have to + * change this IOCTL definition to reflect your integration with the framebuffer + * device. + * Expected return value is a structure filled with a file descriptor + * backing your framebuffer device memory. + */ +struct fb_dmabuf_export +{ + __u32 fd; + __u32 flags; +}; +#define FBIOGET_DMABUF _IOR('F', 0x21, struct fb_dmabuf_export) + +/* the max string size of GRALLOC_HARDWARE_GPU0 & GRALLOC_HARDWARE_FB0 + * 8 is big enough for "gpu0" & "fb0" currently + */ +#define MALI_GRALLOC_HARDWARE_MAX_STR_LEN 8 +#define NUM_FB_BUFFERS 2 + +/* Define number of shared file descriptors */ +#define GRALLOC_ARM_NUM_FDS 2 + +#define NUM_INTS_IN_PRIVATE_HANDLE ((sizeof(struct private_handle_t) - sizeof(native_handle)) / sizeof(int) - sNumFds) + +#define SZ_4K 0x00001000 +#define SZ_2M 0x00200000 + +struct private_handle_t; + +#ifndef __cplusplus +/* C99 with pedantic don't allow anonymous unions which is used in below struct + * Disable pedantic for C for this struct only. + */ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wpedantic" +#endif + +#ifdef __cplusplus +struct private_handle_t : public native_handle +{ +#else +struct private_handle_t +{ + struct native_handle nativeHandle; +#endif + +#ifdef __cplusplus + /* Never intended to be used from C code */ + enum + { + PRIV_FLAGS_FRAMEBUFFER = 0x00000001, + PRIV_FLAGS_USES_ION_COMPOUND_HEAP = 0x00000002, + PRIV_FLAGS_USES_ION = 0x00000004, + PRIV_FLAGS_USES_ION_DMA_HEAP = 0x00000008 + }; + + enum + { + LOCK_STATE_WRITE = 1 << 31, + LOCK_STATE_MAPPED = 1 << 30, + LOCK_STATE_READ_MASK = 0x3FFFFFFF + }; +#endif + + /* + * Shared file descriptor for dma_buf sharing. This must be the first element in the + * structure so that binder knows where it is and can properly share it between + * processes. + * DO NOT MOVE THIS ELEMENT! + */ + int share_fd; + int share_attr_fd; + + // ints + int magic; + int req_format; + uint64_t internal_format; + int byte_stride; + int flags; + int size; + int width; + int height; + int internalWidth; + int internalHeight; + int stride; + union + { + void *base; + uint64_t padding; + }; + union { + uint64_t consumer_usage; + uint64_t usage; + }; + uint64_t producer_usage; + uint64_t backing_store_id; + int backing_store_size; + int writeOwner; + int allocating_pid; + int remote_pid; + int ref_count; + // locally mapped shared attribute area + union + { + void *attr_base; + uint64_t padding3; + }; + + mali_gralloc_yuv_info yuv_info; + + // Following members is for framebuffer only + int fd; + union + { + off_t offset; + uint64_t padding4; + }; + + /* + * min_pgsz denotes minimum phys_page size used by this buffer. + * if buffer memory is physical contiguous set min_pgsz to buff->size + * if not sure buff's real phys_page size, you can use SZ_4K for safe. + */ + int min_pgsz; +#ifdef __cplusplus + /* + * We track the number of integers in the structure. There are 16 unconditional + * integers (magic - pid, yuv_info, fd and offset). Note that the fd element is + * considered an int not an fd because it is not intended to be used outside the + * surface flinger process. The GRALLOC_ARM_NUM_INTS variable is used to track the + * number of integers that are conditionally included. Similar considerations apply + * to the number of fds. + */ + static const int sNumFds = GRALLOC_ARM_NUM_FDS; + static const int sMagic = 0x3141592; + + private_handle_t(int _flags, int _size, void *_base, uint64_t _consumer_usage, uint64_t _producer_usage, + int fb_file, off_t fb_offset) + : share_fd(-1) + , share_attr_fd(-1) + , magic(sMagic) + , flags(_flags) + , size(_size) + , width(0) + , height(0) + , stride(0) + , base(_base) + , consumer_usage(_consumer_usage) + , producer_usage(_producer_usage) + , backing_store_id(0x0) + , backing_store_size(0) + , writeOwner(0) + , allocating_pid(getpid()) + , remote_pid(-1) + , ref_count(1) + , attr_base(MAP_FAILED) + , yuv_info(MALI_YUV_NO_INFO) + , fd(fb_file) + , offset(fb_offset) + { + version = sizeof(native_handle); + numFds = sNumFds; + numInts = NUM_INTS_IN_PRIVATE_HANDLE; + } + + private_handle_t(int _flags, int _size, int _min_pgsz, uint64_t _consumer_usage, uint64_t _producer_usage, + int _shared_fd, int _req_format, uint64_t _internal_format, int _byte_stride, int _width, + int _height, int _stride, int _internalWidth, int _internalHeight, int _backing_store_size) + : share_fd(_shared_fd) + , share_attr_fd(-1) + , magic(sMagic) + , req_format(_req_format) + , internal_format(_internal_format) + , byte_stride(_byte_stride) + , flags(_flags) + , size(_size) + , width(_width) + , height(_height) + , internalWidth(_internalWidth) + , internalHeight(_internalHeight) + , stride(_stride) + , base(NULL) + , consumer_usage(_consumer_usage) + , producer_usage(_producer_usage) + , backing_store_id(0x0) + , backing_store_size(_backing_store_size) + , writeOwner(0) + , allocating_pid(getpid()) + , remote_pid(-1) + , ref_count(1) + , attr_base(MAP_FAILED) + , yuv_info(MALI_YUV_NO_INFO) + , fd(-1) + , offset(0) + , min_pgsz(_min_pgsz) + { + version = sizeof(native_handle); + numFds = sNumFds; + numInts = NUM_INTS_IN_PRIVATE_HANDLE; + } + + ~private_handle_t() + { + magic = 0; + } + + bool usesPhysicallyContiguousMemory() + { + return (flags & PRIV_FLAGS_FRAMEBUFFER) ? true : false; + } + + static int validate(const native_handle *h) + { + const private_handle_t *hnd = (const private_handle_t *)h; + + if (!h || h->version != sizeof(native_handle) || h->numInts != NUM_INTS_IN_PRIVATE_HANDLE || + h->numFds != sNumFds || hnd->magic != sMagic) + { + return -EINVAL; + } + + return 0; + } + + static private_handle_t *dynamicCast(const native_handle *in) + { + if (validate(in) == 0) + { + return (private_handle_t *)in; + } + + return NULL; + } +#endif +}; +#ifndef __cplusplus +/* Restore previous diagnostic for pedantic */ +#pragma GCC diagnostic pop +#endif + +#endif /* MALI_GRALLOC_BUFFER_H_ */ +// clang-format on |