gralloc960/mali_gralloc_buffer.h - device/linaro/hikey960 - Gitiles

 /*
  * 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_ */
	/*
	* 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_ */