blob: 14cb07a886077e9bd3a88a16b822d99112c66479 [file] [log] [blame]
/*
* Copyright (C) 2010 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 GRALLOC_PRIV_H_
#define GRALLOC_PRIV_H_
#include <stdint.h>
#include <pthread.h>
#include <errno.h>
#include <linux/fb.h>
#include <sys/types.h>
#include <unistd.h>
#include <hardware/gralloc.h>
#include <cutils/native_handle.h>
#include "alloc_device.h"
#include <utils/Log.h>
#ifdef MALI_600
#define GRALLOC_ARM_UMP_MODULE 0
#define GRALLOC_ARM_DMA_BUF_MODULE 1
#else
/* NOTE:
* If your framebuffer device driver is integrated with UMP, you will have to
* change this IOCTL definition to reflect your integration with the framebuffer
* device.
* Expected return value is a UMP secure id backing your framebuffer device memory.
*/
/*#define IOCTL_GET_FB_UMP_SECURE_ID _IOR('F', 311, unsigned int)*/
#define GRALLOC_ARM_UMP_MODULE 0
#define GRALLOC_ARM_DMA_BUF_MODULE 1
/* 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.
*/
#if GRALLOC_ARM_DMA_BUF_MODULE
struct fb_dmabuf_export
{
__u32 fd;
__u32 flags;
};
/* Un-comment this line to use dma_buf framebuffer */
/*#define FBIOGET_DMABUF _IOR('F', 0x21, struct fb_dmabuf_export)*/
#if PLATFORM_SDK_VERSION >= 21
typedef int ion_user_handle_t;
#define ION_INVALID_HANDLE 0
#else
typedef struct ion_handle *ion_user_handle_t;
#define ION_INVALID_HANDLE NULL
#endif /* new libion */
#endif /* GRALLOC_ARM_DMA_BUF_MODULE */
#endif
/* 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
#if GRALLOC_ARM_UMP_MODULE
#include <ump/ump.h>
#endif
#define MALI_IGNORE(x) (void)x
typedef enum
{
MALI_YUV_NO_INFO,
MALI_YUV_BT601_NARROW,
MALI_YUV_BT601_WIDE,
MALI_YUV_BT709_NARROW,
MALI_YUV_BT709_WIDE,
} mali_gralloc_yuv_info;
struct private_handle_t;
struct private_module_t
{
gralloc_module_t base;
private_handle_t *framebuffer;
uint32_t flags;
uint32_t numBuffers;
uint32_t bufferMask;
pthread_mutex_t lock;
buffer_handle_t currentBuffer;
int ion_client;
int system_heap_id;
int cma_heap_id;
bool gralloc_legacy_ion;
struct fb_var_screeninfo info;
struct fb_fix_screeninfo finfo;
float xdpi;
float ydpi;
float fps;
enum
{
// flag to indicate we'll post this buffer
PRIV_USAGE_LOCKED_FOR_POST = 0x80000000
};
/* default constructor */
private_module_t();
};
#ifdef __cplusplus
struct private_handle_t : public native_handle
{
#else
struct private_handle_t
{
struct native_handle nativeHandle;
#endif
enum
{
PRIV_FLAGS_FRAMEBUFFER = 0x00000001,
PRIV_FLAGS_USES_UMP = 0x00000002,
PRIV_FLAGS_USES_ION = 0x00000004,
};
enum
{
LOCK_STATE_WRITE = 1 << 31,
LOCK_STATE_MAPPED = 1 << 30,
LOCK_STATE_UNREGISTERED = 1 << 29,
LOCK_STATE_READ_MASK = 0x3FFFFFFF
};
// ints
#if GRALLOC_ARM_DMA_BUF_MODULE
/*shared file descriptor for dma_buf sharing*/
int share_fd;
#endif
int magic;
int flags;
int usage;
int size;
int width;
int height;
union {
int format;
int req_format; /* same name as gralloc960 */
/*unused but referenced in drm_hwc */
int internal_format;
};
int stride;
union
{
void *base;
uint64_t padding;
};
int lockState;
int writeOwner;
int pid;
mali_gralloc_yuv_info yuv_info;
// Following members are for UMP memory only
#if GRALLOC_ARM_UMP_MODULE
int ump_id;
int ump_mem_handle;
#endif
// Following members is for framebuffer only
int fd; //Shallow copy, DO NOT duplicate
int offset;
union
{
void *fb_paddr;
uint64_t fb_paddr_padding;
};
int byte_stride;
#if GRALLOC_ARM_DMA_BUF_MODULE
ion_user_handle_t ion_hnd;
#endif
#if GRALLOC_ARM_DMA_BUF_MODULE
#define GRALLOC_ARM_NUM_FDS 1
#else
#define GRALLOC_ARM_NUM_FDS 0
#endif
#ifdef __cplusplus
static const int sNumFds = GRALLOC_ARM_NUM_FDS;
static const int sMagic = 0x3141592;
#if GRALLOC_ARM_UMP_MODULE
private_handle_t(int flags, int usage, int size, void *base, int lock_state, ump_secure_id secure_id, ump_handle handle):
#if GRALLOC_ARM_DMA_BUF_MODULE
share_fd(-1),
#endif
magic(sMagic),
flags(flags),
usage(usage),
size(size),
width(0),
height(0),
format(0),
stride(0),
base(base),
lockState(lock_state),
writeOwner(0),
pid(getpid()),
yuv_info(MALI_YUV_NO_INFO),
ump_id((int)secure_id),
ump_mem_handle((int)handle),
fd(0),
offset(0),
fb_paddr(NULL)
#if GRALLOC_ARM_DMA_BUF_MODULE
,
ion_hnd(ION_INVALID_HANDLE)
#endif
{
version = sizeof(native_handle);
numFds = sNumFds;
numInts = (sizeof(private_handle_t) - sizeof(native_handle)) / sizeof(int) - sNumFds;
}
#endif
#if GRALLOC_ARM_DMA_BUF_MODULE
private_handle_t(int flags, int usage, int size, void *base, int lock_state):
share_fd(-1),
magic(sMagic),
flags(flags),
usage(usage),
size(size),
width(0),
height(0),
format(0),
stride(0),
base(base),
lockState(lock_state),
writeOwner(0),
pid(getpid()),
yuv_info(MALI_YUV_NO_INFO),
#if GRALLOC_ARM_UMP_MODULE
ump_id((int)UMP_INVALID_SECURE_ID),
ump_mem_handle((int)UMP_INVALID_MEMORY_HANDLE),
#endif
fd(0),
offset(0),
fb_paddr(NULL),
ion_hnd(ION_INVALID_HANDLE)
{
version = sizeof(native_handle);
numFds = sNumFds;
numInts = (sizeof(private_handle_t) - sizeof(native_handle)) / sizeof(int) - sNumFds;
}
#endif
private_handle_t(int flags, int usage, int size, void *base, int lock_state, int fb_file, int fb_offset, void *fb_paddr):
#if GRALLOC_ARM_DMA_BUF_MODULE
share_fd(-1),
#endif
magic(sMagic),
flags(flags),
usage(usage),
size(size),
width(0),
height(0),
format(0),
stride(0),
base(base),
lockState(lock_state),
writeOwner(0),
pid(getpid()),
yuv_info(MALI_YUV_NO_INFO),
#if GRALLOC_ARM_UMP_MODULE
ump_id((int)UMP_INVALID_SECURE_ID),
ump_mem_handle((int)UMP_INVALID_MEMORY_HANDLE),
#endif
fd(fb_file),
offset(fb_offset),
fb_paddr(fb_paddr)
#if GRALLOC_ARM_DMA_BUF_MODULE
,
ion_hnd(ION_INVALID_HANDLE)
#endif
{
version = sizeof(native_handle);
numFds = sNumFds;
numInts = (sizeof(private_handle_t) - sizeof(native_handle)) / sizeof(int) - sNumFds;
}
~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 (!hnd || hnd->version != sizeof(native_handle) || hnd->magic != sMagic)
{
return -EINVAL;
}
int numFds = sNumFds;
int numInts = (sizeof(private_handle_t) - sizeof(native_handle)) / sizeof(int) - sNumFds;
#if GRALLOC_ARM_DMA_BUF_MODULE
if (hnd->share_fd < 0)
{
numFds--;
numInts++;
}
#endif
if (hnd->numFds != numFds || hnd->numInts != numInts)
{
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
};
#endif /* GRALLOC_PRIV_H_ */