You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
270 lines
6.8 KiB
270 lines
6.8 KiB
/*
|
|
* 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_ */
|