diff options
Diffstat (limited to 'kernel-headers/linux')
35 files changed, 4534 insertions, 0 deletions
diff --git a/kernel-headers/linux/almk_drv.h b/kernel-headers/linux/almk_drv.h new file mode 100644 index 0000000..1c1cc6c --- /dev/null +++ b/kernel-headers/linux/almk_drv.h @@ -0,0 +1,31 @@ +#include <linux/ioctl.h> + +#ifndef __ALMK_DRV_H__ +#define __ALMK_DRV_H__ + + +typedef struct +{ + unsigned int pid; + unsigned int *maxSafeSize; + //unsigned int *result; + +} ALMK_DRV_DATA; + + + + +#define ALMK_IOCTL_MAGIC 'x' + +//#define JPEG_DEC_IOCTL_INIT _IO (ALMK_IOCTL_MAGIC, 1) +//#define JPEG_DEC_IOCTL_CONFIG _IOW (ALMK_IOCTL_MAGIC, 2, JPEG_DEC_DRV_IN) +//#define JPEG_DEC_IOCTL_START _IO (ALMK_IOCTL_MAGIC, 3) +//#define JPEG_DEC_IOCTL_WAIT _IOWR(ALMK_IOCTL_MAGIC, 6, JPEG_DEC_DRV_OUT) +//#define JPEG_DEC_IOCTL_DEINIT _IO (ALMK_IOCTL_MAGIC, 8) + +#define ALMK_IOCTL_CMD_INIT _IO (ALMK_IOCTL_MAGIC, 11) +#define ALMK_IOCTL_CMD_GET_MAX_SIZE _IOWR(ALMK_IOCTL_MAGIC, 12, ALMK_DRV_DATA) +#define ALMK_IOCTL_CMD_DEINIT _IO (ALMK_IOCTL_MAGIC, 13) + +#endif + diff --git a/kernel-headers/linux/cache.h b/kernel-headers/linux/cache.h new file mode 100644 index 0000000..dca5a3c --- /dev/null +++ b/kernel-headers/linux/cache.h @@ -0,0 +1,58 @@ +/**************************************************************************** + **************************************************************************** + *** + *** This header was automatically generated from a Linux kernel header + *** of the same name, to make information necessary for userspace to + *** call into the kernel available to libc. It contains only constants, + *** structures, and macros generated from the original header, and thus, + *** contains no copyrightable information. + *** + *** To edit the content of this header, modify the corresponding + *** source file (e.g. under external/kernel-headers/original/) then + *** run bionic/libc/kernel/tools/update_all.py + *** + *** Any manual change here will be lost the next time this script will + *** be run. You've been warned! + *** + **************************************************************************** + ****************************************************************************/ +#ifndef __LINUX_CACHE_H +#define __LINUX_CACHE_H +#include <linux/kernel.h> +#include <asm/cache.h> +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#ifndef L1_CACHE_ALIGN +#define L1_CACHE_ALIGN(x) ALIGN(x, L1_CACHE_BYTES) +#endif +#ifndef SMP_CACHE_BYTES +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define SMP_CACHE_BYTES L1_CACHE_BYTES +#endif +#ifndef __read_mostly +#define __read_mostly +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#endif +#ifndef ____cacheline_aligned +#define ____cacheline_aligned __attribute__((__aligned__(SMP_CACHE_BYTES))) +#endif +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#ifndef ____cacheline_aligned_in_smp +#define ____cacheline_aligned_in_smp +#endif +#ifndef __cacheline_aligned +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#define __cacheline_aligned __attribute__((__aligned__(SMP_CACHE_BYTES), __section__(".data.cacheline_aligned"))) +#endif +#ifndef __cacheline_aligned_in_smp +#define __cacheline_aligned_in_smp +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#endif +#ifndef INTERNODE_CACHE_SHIFT +#define INTERNODE_CACHE_SHIFT L1_CACHE_SHIFT +#endif +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +#ifndef ____cacheline_internodealigned_in_smp +#define ____cacheline_internodealigned_in_smp +#endif +#endif +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ diff --git a/kernel-headers/linux/ccci_ipc_task_ID.h b/kernel-headers/linux/ccci_ipc_task_ID.h new file mode 100644 index 0000000..3f9909e --- /dev/null +++ b/kernel-headers/linux/ccci_ipc_task_ID.h @@ -0,0 +1,40 @@ +#ifndef __CCCI_IPC_TASK_ID_H__ +#define __CCCI_IPC_TASK_ID_H__ +// Priority --> Local module ID --> External ID --> Max sent message +// X_IPC_MODULE_CONF(1,M_SSDBG1,0,1) //TASK_ID_1 +// X_IPC_MODULE_CONF(1,AP_SSDBG2,1,1) //TASK_ID_2 +#ifdef __IPC_ID_TABLE +#define X_IPC_MODULE_CONF(a,b,c,d) {c,b}, +#else +#define X_IPC_MODULE_CONF(a,b,c,d) +#endif + + +#define AP_UNIFY_ID_FLAG (1<<31) +#define MD_UNIFY_ID_FLAG (0<<31) + +//---------------------------------------------------------- +#define AGPS_MD_MOD_L4C 0 +#define AGPS_MD_MOD_L4C_2 1 +#define AGPS_MD_MOD_L4C_3 2 +#define AGPS_MD_MOD_L4C_4 3 +//agps MD begin task_id +//Wait to add + +#define AGPS_AP_MOD_MMI 0 +//agps AP begin task_id +//Wait to add +#define GPS_AP_MOD 2 +//-------------------------------------------------------------------------- +X_IPC_MODULE_CONF(1, AGPS_MD_MOD_L4C, MD_UNIFY_ID_FLAG|0, 1) +X_IPC_MODULE_CONF(1, AGPS_MD_MOD_L4C_2, MD_UNIFY_ID_FLAG|1, 1) +X_IPC_MODULE_CONF(1, AGPS_MD_MOD_L4C_3, MD_UNIFY_ID_FLAG|2, 1) +X_IPC_MODULE_CONF(1, AGPS_MD_MOD_L4C_4, MD_UNIFY_ID_FLAG|3, 1) +//Wait to add +//-------------------------------------------------------------------------- +X_IPC_MODULE_CONF(1, AGPS_AP_MOD_MMI, AP_UNIFY_ID_FLAG|0, 1) +X_IPC_MODULE_CONF(1, GPS_AP_MOD, AP_UNIFY_ID_FLAG|2, 1) +//Wait to add +//------------------------------------------------------------------------- + +#endif diff --git a/kernel-headers/linux/cmdq/cmdq_event.h b/kernel-headers/linux/cmdq/cmdq_event.h new file mode 100644 index 0000000..4b71514 --- /dev/null +++ b/kernel-headers/linux/cmdq/cmdq_event.h @@ -0,0 +1,125 @@ + +/* MDP start frame */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RDMA0_SOF, 0) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RDMA1_SOF, 1) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_DSI0_TE_SOF, 2) /* DISPSYS TE event */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_DSI1_TE_SOF, 3) /* DISPSYS TE event */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_MVW_SOF, 4) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_TDSHP0_SOF, 5) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_TDSHP1_SOF, 6) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WDMA_SOF, 7) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT0_SOF, 8) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT1_SOF, 9) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_CROP_SOF, 10) +/* Display start frame */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_OVL0_SOF, 11) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_OVL1_SOF, 12) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA0_SOF, 13) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA1_SOF, 14) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA2_SOF, 15) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_WDMA0_SOF, 16) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_WDMA1_SOF, 17) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_COLOR0_SOF, 18) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_COLOR1_SOF, 19) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_AAL_SOF, 20) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_GAMMA_SOF, 21) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_UFOE_SOF, 22) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_PWM0_SOF, 23) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_PWM1_SOF, 24) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_OD_SOF, 25) +/* MDP frame done */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RDMA0_EOF, 26) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RDMA1_EOF, 27) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RSZ0_EOF, 28) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RSZ1_EOF, 29) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RSZ2_EOF, 30) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_TDSHP0_EOF, 31) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_TDSHP1_EOF, 32) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WDMA_EOF, 33) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT0_W_EOF, 34) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT0_R_EOF, 35) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT1_W_EOF, 36) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT1_R_EOF, 37) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_CROP_EOF, 38) +/* Display frame done */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_OVL0_EOF, 39) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_OVL1_EOF, 40) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA0_EOF, 41) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA1_EOF, 42) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA2_EOF, 43) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_WDMA0_EOF, 44) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_WDMA1_EOF, 45) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_COLOR0_EOF, 46) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_COLOR1_EOF, 47) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_AAL_EOF, 48) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_GAMMA_EOF, 49) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_UFOE_EOF, 50) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_DPI0_EOF, 51) +/* Mutex frame done */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX0_STREAM_EOF, 53) /* DISPSYS */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX1_STREAM_EOF, 54) /* DISPSYS */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX2_STREAM_EOF, 55) /* DISPSYS */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX3_STREAM_EOF, 56) /* DISPSYS */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX4_STREAM_EOF, 57) /* DISPSYS, please refer to disp_hal.h */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX5_STREAM_EOF, 58) /* DpFramework */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX6_STREAM_EOF, 59) /* DpFramework */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX7_STREAM_EOF, 60) /* DpFramework */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX8_STREAM_EOF, 61) /* DpFramework */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX9_STREAM_EOF, 62) +/* DpFramework via CMDQ_IOCTL_LOCK_MUTEX */ +/* Display underrun */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA0_UNDERRUN, 63) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA1_UNDERRUN, 64) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA2_UNDERRUN, 65) +/* ISP frame done */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_PASS2_2_EOF, 129) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_PASS2_1_EOF, 130) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_PASS2_0_EOF, 131) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_PASS1_1_EOF, 132) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_PASS1_0_EOF, 133) +/* Engine events */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_CAMSV_2_PASS1_DONE, 134) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_CAMSV_1_PASS1_DONE, 135) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_SENINF_CAM1_2_3_FULL, 136) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_SENINF_CAM0_FULL, 137) +/* JPEG frame done */ +DECLARE_CMDQ_EVENT(CMDQ_EVENT_JPEG_ENC_PASS2_EOF, 257) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_JPEG_ENC_PASS1_EOF, 258) +DECLARE_CMDQ_EVENT(CMDQ_EVENT_JPEG_DEC_EOF, 259) + +DECLARE_CMDQ_EVENT(CMDQ_MAX_HW_EVENT_COUNT, 260) + + + +/* Keep this at the end of HW events */ +/* SW Sync Tokens (Pre-defined) */ +DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_CONFIG_DIRTY, 261) +/* Config thread notify trigger thread */ +DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_STREAM_EOF, 262) +/* Trigger thread notify config thread */ +/* ESD check state. Trigger thread will be blocked until the check finishes. */ +DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_ESD_EOF, 263) +DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_CABC_EOF, 264) +/* check CABC setup finish */ +/* Block Trigger thread until the path freeze finishes */ +DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_FREEZE_EOF, 265) +/* Pass-2 notifies VENC frame is ready to be encoded */ +DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_VENC_INPUT_READY, 270) +/* VENC notifies Pass-2 encoding completion so next frame may start */ +DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_VENC_EOF, 271) +/* Notify normal CMDQ there are some secure task done */ +DECLARE_CMDQ_EVENT(CMDQ_SYNC_SECURE_THR_EOF, 299) +/* SW Sync Tokens (User-defined) */ +DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_USER_0, 300) +/* SW-defined sync token */ +DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_USER_1, 301) +/* GPR access tokens (for HW register backup) */ +/* There are 15 32-bit GPR, 3 GPR form a set (64-bit for address, 32-bit for value) */ +DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_0, 400) +DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_1, 401) +DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_2, 402) +DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_3, 403) +DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_4, 404) + +DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_MAX, (0x1FF)) /* event id is 9 bit */ +DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_INVALID, (-1)) diff --git a/kernel-headers/linux/cmdq/cmdq_subsys.h b/kernel-headers/linux/cmdq/cmdq_subsys.h new file mode 100644 index 0000000..1bef2d8 --- /dev/null +++ b/kernel-headers/linux/cmdq/cmdq_subsys.h @@ -0,0 +1,25 @@ + +/* msb id group reg-base-name */ +DECLARE_CMDQ_SUBSYS(0x1300, 0, MFG, HAN_BASE) +DECLARE_CMDQ_SUBSYS(0x1400, 1, MMSYS, MMSYS_CONFIG_BASE) +DECLARE_CMDQ_SUBSYS(0x1401, 2, DISP, DISP_RDMA2_BASE) +DECLARE_CMDQ_SUBSYS(0x1402, 3, DISP, MM_MUTEX_BASE) +DECLARE_CMDQ_SUBSYS(0x1500, 4, CAM, IMGSYS_BASE) +DECLARE_CMDQ_SUBSYS(0x1600, 5, VDEC, VDEC_GCON_BASE) +DECLARE_CMDQ_SUBSYS(0x1700, 6, MJC, MJC_CONFIG_BASE) +DECLARE_CMDQ_SUBSYS(0x1800, 7, VENC, VENC_GCON_BASE) +DECLARE_CMDQ_SUBSYS(0x1000, 8, INFRA_AO, CKSYS_BASE) +DECLARE_CMDQ_SUBSYS(0x1001, 9, INFRA_AO, KP_BASE) +DECLARE_CMDQ_SUBSYS(0x1002, 10, MD32, MD32_BASE) +DECLARE_CMDQ_SUBSYS(0x1003, 11, MD32, MD32_BASE) +DECLARE_CMDQ_SUBSYS(0x1004, 12, MD32, MD32_BASE) +DECLARE_CMDQ_SUBSYS(0x1005, 13, MD32, MD32_BASE) +DECLARE_CMDQ_SUBSYS(0x1020, 14, INFRASYS, MCUCFG_BASE) +DECLARE_CMDQ_SUBSYS(0x1021, 15, INFRASYS, GCPU_BASE) +DECLARE_CMDQ_SUBSYS(0x1120, 16, PERISYS, USB0_BASE) +DECLARE_CMDQ_SUBSYS(0x1121, 17, PERISYS, USB_SIF_BASE) +DECLARE_CMDQ_SUBSYS(0x1122, 18, PERISYS, AUDIO_BASE) +DECLARE_CMDQ_SUBSYS(0x1123, 19, PERISYS, MSDC0_BASE) +DECLARE_CMDQ_SUBSYS(0x1124, 20, PERISYS, MSDC1_BASE) +DECLARE_CMDQ_SUBSYS(0x1125, 21, PERISYS, MSDC2_BASE) +DECLARE_CMDQ_SUBSYS(0x1126, 22, PERISYS, MSDC3_BASE) diff --git a/kernel-headers/linux/ddp_od.h b/kernel-headers/linux/ddp_od.h new file mode 100644 index 0000000..8c7ebbe --- /dev/null +++ b/kernel-headers/linux/ddp_od.h @@ -0,0 +1,39 @@ +#ifndef __DDP_OD_H__ +#define __DDP_OD_H__ + +#include <linux/ioctl.h> + +/* OD */ +typedef struct { + unsigned int size; + unsigned int type; + unsigned int ret; + unsigned int param0; + unsigned int param1; + unsigned int param2; + unsigned int param3; +} DISP_OD_CMD; + +typedef enum{ + OD_CTL_READ_REG, + OD_CTL_WRITE_REG, + OD_CTL_ENABLE_DEMO_MODE, + OD_CTL_RUN_TEST, + OD_CTL_WRITE_TABLE, + OD_CTL_CMD_NUM, + OD_CTL_ENABLE +} DISP_OD_CMD_TYPE; + +typedef enum{ + OD_CTL_ENABLE_OFF, + OD_CTL_ENABLE_ON +} DISP_OD_ENABLE_STAGE; + +#define OD_CTL_ENABLE_DELAY 3 + +/* OD */ +#define DISP_IOCTL_MAGIC 'x' +#define DISP_IOCTL_OD_CTL _IOWR (DISP_IOCTL_MAGIC, 80 , DISP_OD_CMD) +#define DISP_IOCTL_OD_SET_ENABLED _IOWR (DISP_IOCTL_MAGIC, 81 , int) + +#endif diff --git a/kernel-headers/linux/disp_session.h b/kernel-headers/linux/disp_session.h new file mode 100644 index 0000000..5044708 --- /dev/null +++ b/kernel-headers/linux/disp_session.h @@ -0,0 +1,400 @@ +#ifndef __DISP_SESSION_H +#define __DISP_SESSION_H + +#define DISP_SESSION_DEVICE "mtk_disp_mgr" + + +#define DISP_NO_ION_FD ((int)(~0U>>1)) +#define DISP_NO_USE_LAEYR_ID ((int)(~0U>>1)) + +/* sync with define in ddp_ovl.h */ +#define OVL_CASCADE_SUPPORT +#ifdef OVL_CASCADE_SUPPORT +#define MAX_INPUT_CONFIG 8 +#else +#define MAX_INPUT_CONFIG 4 +#endif + +#define MAKE_DISP_FORMAT_ID(id, bpp) (((id) << 8) | (bpp)) +#define DISP_SESSION_MODE(id) (((id)>>24)&0xff) +#define DISP_SESSION_TYPE(id) (((id)>>16)&0xff) +#define DISP_SESSION_DEV(id) ((id)&0xff) +#define MAKE_DISP_SESSION(type, dev) (unsigned int)((type)<<16 | (dev)) + + + +/* /============================================================================= */ +/* structure declarations */ +/* /=========================== */ + +typedef enum { + DISP_IF_TYPE_DBI = 0, + DISP_IF_TYPE_DPI, + DISP_IF_TYPE_DSI0, + DISP_IF_TYPE_DSI1, + DISP_IF_TYPE_DSIDUAL, + DISP_IF_HDMI = 7, + DISP_IF_HDMI_SMARTBOOK, + DISP_IF_MHL, + DISP_IF_EPD +} DISP_IF_TYPE; + +typedef enum { + DISP_IF_FORMAT_RGB565 = 0, + DISP_IF_FORMAT_RGB666, + DISP_IF_FORMAT_RGB888 +} DISP_IF_FORMAT; + +typedef enum { + DISP_IF_MODE_VIDEO = 0, + DISP_IF_MODE_COMMAND +} DISP_IF_MODE; + + +typedef enum { + DISP_ORIENTATION_0 = 0, + DISP_ORIENTATION_90 = 1, + DISP_ORIENTATION_180 = 2, + DISP_ORIENTATION_270 = 3, +} DISP_ORIENTATION; + +typedef enum { + DISP_FORMAT_UNKNOWN = 0, + + DISP_FORMAT_RGB565 = MAKE_DISP_FORMAT_ID(1, 2), + DISP_FORMAT_RGB888 = MAKE_DISP_FORMAT_ID(2, 3), + DISP_FORMAT_BGR888 = MAKE_DISP_FORMAT_ID(3, 3), + DISP_FORMAT_ARGB8888 = MAKE_DISP_FORMAT_ID(4, 4), + DISP_FORMAT_ABGR8888 = MAKE_DISP_FORMAT_ID(5, 4), + DISP_FORMAT_RGBA8888 = MAKE_DISP_FORMAT_ID(6, 4), + DISP_FORMAT_BGRA8888 = MAKE_DISP_FORMAT_ID(7, 4), + DISP_FORMAT_YUV422 = MAKE_DISP_FORMAT_ID(8, 2), + DISP_FORMAT_XRGB8888 = MAKE_DISP_FORMAT_ID(9, 4), + DISP_FORMAT_XBGR8888 = MAKE_DISP_FORMAT_ID(10, 4), + DISP_FORMAT_RGBX8888 = MAKE_DISP_FORMAT_ID(11, 4), + DISP_FORMAT_BGRX8888 = MAKE_DISP_FORMAT_ID(12, 4), + DISP_FORMAT_UYVY = MAKE_DISP_FORMAT_ID(13, 2), + DISP_FORMAT_YUV420_P = MAKE_DISP_FORMAT_ID(14, 2), + DISP_FORMAT_YV12 = MAKE_DISP_FORMAT_ID(16, 1), /* BPP = 1.5 */ + DISP_FORMAT_BPP_MASK = 0xFF, +} DISP_FORMAT; + +typedef enum { + DISP_LAYER_2D = 0, + DISP_LAYER_3D_SBS_0 = 0x1, + DISP_LAYER_3D_SBS_90 = 0x2, + DISP_LAYER_3D_SBS_180 = 0x3, + DISP_LAYER_3D_SBS_270 = 0x4, + DISP_LAYER_3D_TAB_0 = 0x10, + DISP_LAYER_3D_TAB_90 = 0x20, + DISP_LAYER_3D_TAB_180 = 0x30, + DISP_LAYER_3D_TAB_270 = 0x40, +} DISP_LAYER_TYPE; + +typedef enum { + /* normal memory */ + DISP_NORMAL_BUFFER = 0, + /* normal memory but should not be dumpped within screenshot */ + DISP_PROTECT_BUFFER = 1, + /* secure memory */ + DISP_SECURE_BUFFER = 2, + DISP_SECURE_BUFFER_SHIFT = 0x10002 +} DISP_BUFFER_TYPE; + +typedef enum { + /* ion buffer */ + DISP_BUFFER_ION = 0, + /* dim layer, const alpha */ + DISP_BUFFER_ALPHA = 1, + /* mva buffer */ + DISP_BUFFER_MVA = 2, +} DISP_BUFFER_SOURCE; + +typedef enum { + DISP_ALPHA_ONE = 0, + DISP_ALPHA_SRC = 1, + DISP_ALPHA_SRC_INVERT = 2, + DISP_ALPHA_INVALID = 3, +} DISP_ALPHA_TYPE; + +typedef enum { + DISP_SESSION_PRIMARY = 1, + DISP_SESSION_EXTERNAL = 2, + DISP_SESSION_MEMORY = 3 +} DISP_SESSION_TYPE; + +typedef enum { + DISP_YUV_BT601_FULL = 0, + DISP_YUV_BT601 = 1, + DISP_YUV_BT709 = 2 +} DISP_YUV_RANGE_ENUM; + +typedef enum { + DISP_INVALID_SESSION_MODE = 0, + /* single output */ + DISP_SESSION_DIRECT_LINK_MODE = 1, + DISP_SESSION_DECOUPLE_MODE = 2, + + /* two ouputs */ + DISP_SESSION_DIRECT_LINK_MIRROR_MODE = 3, + DISP_SESSION_DECOUPLE_MIRROR_MODE = 4, + + DISP_SESSION_RDMA_MODE, + DISP_SESSION_MODE_NUM, + +} DISP_MODE; + +typedef enum { + SESSION_USER_INVALID = -1, + SESSION_USER_HWC = 0, + SESSION_USER_GUIEXT = 1, + SESSION_USER_AEE = 2, + SESSION_USER_PANDISP = 3, + SESSION_USER_CNT, +} DISP_SESSION_USER; + +typedef enum { + DISP_OUTPUT_UNKNOWN = 0, + DISP_OUTPUT_MEMORY = 1, + DISP_OUTPUT_DECOUPLE = 2, +} DISP_DC_TYPE; + +typedef enum { + TRIGGER_NORMAL, + TRIGGER_SUSPEND, + TRIGGER_RESUME, + + TRIGGER_MODE_MAX_NUM +} EXTD_TRIGGER_MODE; + +typedef struct disp_session_config_t { + DISP_SESSION_TYPE type; + unsigned int device_id; + DISP_MODE mode; + unsigned int session_id; + DISP_SESSION_USER user; + unsigned int present_fence_idx; + DISP_DC_TYPE dc_type; + int need_merge; + EXTD_TRIGGER_MODE tigger_mode; +} disp_session_config; + +typedef struct { + unsigned int session_id; + unsigned int vsync_cnt; + unsigned long long vsync_ts; + int lcm_fps; +} disp_session_vsync_config; + +typedef struct disp_input_config_t { + unsigned int layer_id; + unsigned int layer_enable; + DISP_BUFFER_SOURCE buffer_source; + void *src_base_addr; + void *src_phy_addr; + unsigned int src_direct_link; + DISP_FORMAT src_fmt; + unsigned int src_use_color_key; + unsigned int src_color_key; + unsigned int src_pitch; + unsigned int src_offset_x, src_offset_y; + unsigned int src_width, src_height; + + unsigned int tgt_offset_x, tgt_offset_y; + unsigned int tgt_width, tgt_height; + DISP_ORIENTATION layer_rotation; + DISP_LAYER_TYPE layer_type; + DISP_ORIENTATION video_rotation; + + unsigned int isTdshp; /* set to 1, will go through tdshp first, then layer blending, then to color */ + + unsigned int next_buff_idx; + int identity; + int connected_type; + DISP_BUFFER_TYPE security; + unsigned int alpha_enable; + unsigned int alpha; + unsigned int sur_aen; + DISP_ALPHA_TYPE src_alpha; + DISP_ALPHA_TYPE dst_alpha; + unsigned int frm_sequence; + DISP_YUV_RANGE_ENUM yuv_range; +} disp_input_config; + +typedef struct disp_output_config_t { + void *va; + void *pa; + DISP_FORMAT fmt; + unsigned int x; + unsigned int y; + unsigned int width; + unsigned int height; + unsigned int pitch; + unsigned int pitchUV; + DISP_BUFFER_TYPE security; + unsigned int buff_idx; + unsigned int interface_idx; + unsigned int frm_sequence; +} disp_output_config; + +typedef struct disp_session_input_config_t { + DISP_SESSION_USER setter; + unsigned int session_id; + unsigned int config_layer_num; + disp_input_config config[8]; +} disp_session_input_config; + +typedef struct disp_session_output_config_t { + unsigned int session_id; + disp_output_config config; +} disp_session_output_config; + +typedef struct disp_session_layer_num_config_t { + unsigned int session_id; + unsigned int max_layer_num; +} disp_session_layer_num_config; + +struct disp_frame_cfg_t { + DISP_SESSION_USER setter; + unsigned int session_id; + + /* input config */ + unsigned int input_layer_num; + disp_input_config input_cfg[8]; + unsigned int overlap_layer_num; + + /* constant layer */ + unsigned int const_layer_num; + disp_input_config const_layer[1]; + + /* output config */ + int output_en; + disp_output_config output_cfg; + + /* trigger config */ + DISP_MODE mode; + unsigned int present_fence_idx; + EXTD_TRIGGER_MODE tigger_mode; + DISP_SESSION_USER user; +}; + +typedef struct disp_session_info_t { + unsigned int session_id; + unsigned int maxLayerNum; + unsigned int isHwVsyncAvailable; + DISP_IF_TYPE displayType; + unsigned int displayWidth; + unsigned int displayHeight; + unsigned int displayFormat; + DISP_IF_MODE displayMode; + unsigned int vsyncFPS; + unsigned int physicalWidth; + unsigned int physicalHeight; + unsigned int isConnected; + unsigned int isHDCPSupported; + unsigned int isOVLDisabled; + unsigned int is3DSupport; + unsigned int const_layer_num; + /* updateFPS: fps of HWC trigger display */ + /* notes: for better Accuracy, updateFPS = real_fps*100 */ + unsigned int updateFPS; + unsigned int is_updateFPS_stable; +} disp_session_info; + +typedef struct disp_buffer_info_t { + /* Session */ + unsigned int session_id; + /* Input */ + unsigned int layer_id; + unsigned int layer_en; + int ion_fd; + unsigned int cache_sync; + /* Output */ + unsigned int index; + int fence_fd; + unsigned int interface_index; + int interface_fence_fd; +} disp_buffer_info; + +typedef struct disp_present_fence_info_t { + /* input */ + unsigned int session_id; + /* output */ + unsigned int present_fence_fd; + unsigned int present_fence_index; +} disp_present_fence; + +typedef struct disp_present_fence_t { + /* Session */ + unsigned int session_id; + + /* Output */ + unsigned int index; + int fence_fd; +} disp_present_fence_info; + +typedef enum { + DISP_OUTPUT_CAP_DIRECT_LINK = 0, + DISP_OUTPUT_CAP_DECOUPLE, + DISP_OUTPUT_CAP_SWITCHABLE, +} DISP_CAP_OUTPUT_MODE; + +typedef enum { + DISP_OUTPUT_CAP_SINGLE_PASS = 0, + DISP_OUTPUT_CAP_MULTI_PASS, +} DISP_CAP_OUTPUT_PASS; + +typedef enum { + DISP_FEATURE_TIME_SHARING = 0x00000001, +} DISP_FEATURE; + +typedef struct disp_caps_t { + DISP_CAP_OUTPUT_MODE output_mode; + DISP_CAP_OUTPUT_PASS output_pass; + unsigned int max_layer_num; +#ifdef CONFIG_FOR_SOURCE_PQ + unsigned int max_pq_num; +#endif + unsigned int disp_feature; + int is_support_frame_cfg_ioctl; + int is_output_rotated; +} disp_caps_info; + +typedef struct disp_session_buf_t { + unsigned int session_id; + unsigned int buf_hnd[3]; +} disp_session_buf_info; + +/* IOCTL commands. */ +#define DISP_IOW(num, dtype) _IOW('O', num, dtype) +#define DISP_IOR(num, dtype) _IOR('O', num, dtype) +#define DISP_IOWR(num, dtype) _IOWR('O', num, dtype) +#define DISP_IO(num) _IO('O', num) + + +#define DISP_IOCTL_CREATE_SESSION DISP_IOW(201, disp_session_config) +#define DISP_IOCTL_DESTROY_SESSION DISP_IOW(202, disp_session_config) +#define DISP_IOCTL_TRIGGER_SESSION DISP_IOW(203, disp_session_config) +#define DISP_IOCTL_PREPARE_INPUT_BUFFER DISP_IOW(204, disp_buffer_info) +#define DISP_IOCTL_PREPARE_OUTPUT_BUFFER DISP_IOW(205, disp_buffer_info) +#define DISP_IOCTL_SET_INPUT_BUFFER DISP_IOW(206, disp_session_input_config) +#define DISP_IOCTL_SET_OUTPUT_BUFFER DISP_IOW(207, disp_session_output_config) +#define DISP_IOCTL_GET_SESSION_INFO DISP_IOW(208, disp_session_info) + + +#define DISP_IOCTL_SET_SESSION_MODE DISP_IOW(209, disp_session_config) +#define DISP_IOCTL_GET_SESSION_MODE DISP_IOW(210, disp_session_config) +#define DISP_IOCTL_SET_SESSION_TYPE DISP_IOW(211, disp_session_config) +#define DISP_IOCTL_GET_SESSION_TYPE DISP_IOW(212, disp_session_config) +#define DISP_IOCTL_WAIT_FOR_VSYNC DISP_IOW(213, disp_session_vsync_config) +#define DISP_IOCTL_SET_MAX_LAYER_NUM DISP_IOW(214, disp_session_layer_num_config) +#define DISP_IOCTL_SET_VSYNC_FPS DISP_IOW(215, unsigned int) + +#define DISP_IOCTL_GET_PRESENT_FENCE DISP_IOW(216, disp_present_fence) + +#define DISP_IOCTL_GET_IS_DRIVER_SUSPEND DISP_IOW(217, unsigned int) +#define DISP_IOCTL_GET_DISPLAY_CAPS DISP_IOW(218, disp_caps_info) +#define DISP_IOCTL_INSERT_SESSION_BUFFERS DISP_IOW(219, disp_session_buf_info) +#define DISP_IOCTL_FRAME_CONFIG DISP_IOW(220, disp_session_output_config) + +#endif /* __DISP_SESSION_H */ diff --git a/kernel-headers/linux/disp_svp.h b/kernel-headers/linux/disp_svp.h new file mode 100644 index 0000000..3b8310f --- /dev/null +++ b/kernel-headers/linux/disp_svp.h @@ -0,0 +1,266 @@ +/** + * NOTICE: + * MUST BE consistent with bionic/libc/kernel/common/linux/disp_svp.h + */ +#ifndef __DISP_SVP_H +#define __DISP_SVP_H + +#define DISP_NO_ION_FD ((int)(~0U>>1)) +#define DISP_NO_USE_LAEYR_ID ((int)(~0U>>1)) + +#define MAX_INPUT_CONFIG 4 +#define MAKE_DISP_FORMAT_ID(id, bpp) (((id) << 8) | (bpp)) + +///============================================================================= +// structure declarations +///=========================== + +typedef enum +{ + DISP_IF_TYPE_DBI = 0, + DISP_IF_TYPE_DPI, + DISP_IF_TYPE_DSI0, + DISP_IF_TYPE_DSI1, + DISP_IF_TYPE_DSIDUAL, + DISP_IF_HDMI, + DISP_IF_HDMI_SMARTBOOK +} DISP_IF_TYPE; + +typedef enum +{ + DISP_IF_FORMAT_RGB565 = 0, + DISP_IF_FORMAT_RGB666, + DISP_IF_FORMAT_RGB888 +} DISP_IF_FORMAT; + +typedef enum +{ + DISP_IF_MODE_VIDEO = 0, + DISP_IF_MODE_COMMAND +} DISP_IF_MODE; + + +typedef enum +{ + DISP_ORIENTATION_0 = 0, + DISP_ORIENTATION_90 = 1, + DISP_ORIENTATION_180 = 2, + DISP_ORIENTATION_270 = 3, +} DISP_ORIENTATION; + +typedef enum +{ + DISP_FORMAT_UNKNOWN = 0, + + DISP_FORMAT_RGB565 = MAKE_DISP_FORMAT_ID(1, 2), + DISP_FORMAT_RGB888 = MAKE_DISP_FORMAT_ID(2, 3), + DISP_FORMAT_BGR888 = MAKE_DISP_FORMAT_ID(3, 3), + DISP_FORMAT_ARGB8888 = MAKE_DISP_FORMAT_ID(4, 4), + DISP_FORMAT_ABGR8888 = MAKE_DISP_FORMAT_ID(5, 4), + DISP_FORMAT_RGBA8888 = MAKE_DISP_FORMAT_ID(6, 4), + DISP_FORMAT_BGRA8888 = MAKE_DISP_FORMAT_ID(7, 4), + DISP_FORMAT_XRGB8888 = MAKE_DISP_FORMAT_ID(8, 4), + DISP_FORMAT_XBGR8888 = MAKE_DISP_FORMAT_ID(9, 4), + //Packed YUV Formats + DISP_FORMAT_YUV444 = MAKE_DISP_FORMAT_ID(10, 3), + DISP_FORMAT_YVYU = MAKE_DISP_FORMAT_ID(11, 2), //Same as UYVY, but replace Y/U/V + DISP_FORMAT_VYUY = MAKE_DISP_FORMAT_ID(12, 2), + DISP_FORMAT_UYVY = MAKE_DISP_FORMAT_ID(13, 2), + DISP_FORMAT_Y422 = MAKE_DISP_FORMAT_ID(13, 2), + DISP_FORMAT_YUYV = MAKE_DISP_FORMAT_ID(14, 2), //Same as UYVY but replace U/V + DISP_FORMAT_YUY2 = MAKE_DISP_FORMAT_ID(14, 2), + DISP_FORMAT_YUV422 = MAKE_DISP_FORMAT_ID(14, 2), //Will be removed + DISP_FORMAT_GREY = MAKE_DISP_FORMAT_ID(15, 1), //Single Y plane + DISP_FORMAT_Y800 = MAKE_DISP_FORMAT_ID(15, 1), + DISP_FORMAT_Y8 = MAKE_DISP_FORMAT_ID(15, 1), + //Planar YUV Formats + DISP_FORMAT_YV12 = MAKE_DISP_FORMAT_ID(16, 1), //BPP = 1.5 + DISP_FORMAT_I420 = MAKE_DISP_FORMAT_ID(17, 1), //Same as YV12 but replace U/V + DISP_FORMAT_IYUV = MAKE_DISP_FORMAT_ID(17, 1), + DISP_FORMAT_NV12 = MAKE_DISP_FORMAT_ID(18, 1), //BPP = 1.5 + DISP_FORMAT_NV21 = MAKE_DISP_FORMAT_ID(19, 1), //Same as NV12 but replace U/V + + DISP_FORMAT_BPP_MASK = 0xFFFF, +} DISP_FORMAT; + +typedef enum +{ + DISP_LAYER_2D = 0, + DISP_LAYER_3D_SBS_0 = 0x1, + DISP_LAYER_3D_SBS_90 = 0x2, + DISP_LAYER_3D_SBS_180 = 0x3, + DISP_LAYER_3D_SBS_270 = 0x4, + DISP_LAYER_3D_TAB_0 = 0x10, + DISP_LAYER_3D_TAB_90 = 0x20, + DISP_LAYER_3D_TAB_180 = 0x30, + DISP_LAYER_3D_TAB_270 = 0x40, +} DISP_LAYER_TYPE; + +typedef enum +{ + // normal memory + DISP_NORMAL_BUFFER = 0, + // secure memory + DISP_SECURE_BUFFER = 1, + // normal memory but should not be dumpped within screenshot + DISP_PROTECT_BUFFER = 2, + DISP_SECURE_BUFFER_SHIFT = 0x10001 +} DISP_BUFFER_TYPE; + +typedef enum +{ + DISP_SESSION_PRIMARY = 1, + DISP_SESSION_EXTERNAL = 2, + DISP_SESSION_MEMORY = 3 +}DISP_SESSION_TYPE; + +typedef enum +{ + // single output + DISP_SESSION_DIRECT_LINK_MODE = 1, + DISP_SESSION_DECOUPLE_MODE = 2, + + // two ouputs + DISP_SESSION_DIRECT_LINK_MIRROR_MODE = 3, + DISP_SESSION_DECOUPLE_MIRROR_MODE = 4, +}DISP_MODE; + +typedef struct disp_session_config_t +{ + DISP_SESSION_TYPE type; + unsigned int device_id; + DISP_MODE mode; + unsigned int session_id; +}disp_session_config; + +typedef struct +{ + unsigned int session_id; + unsigned int vsync_cnt; + long int vsync_ts; +}disp_session_vsync_config; + +typedef struct disp_input_config_t +{ + unsigned int layer_id; + unsigned int layer_enable; + + void* src_base_addr; + void* src_phy_addr; + unsigned int src_direct_link; + DISP_FORMAT src_fmt; + unsigned int src_use_color_key; + unsigned int src_color_key; + unsigned int src_pitch; + unsigned int src_offset_x, src_offset_y; + unsigned int src_width, src_height; + + unsigned int tgt_offset_x, tgt_offset_y; + unsigned int tgt_width, tgt_height; + DISP_ORIENTATION layer_rotation; + DISP_LAYER_TYPE layer_type; + DISP_ORIENTATION video_rotation; + + unsigned int isTdshp; // set to 1, will go through tdshp first, then layer blending, then to color + + unsigned int next_buff_idx; + int identity; + int connected_type; + DISP_BUFFER_TYPE security; + unsigned int alpha_enable; + unsigned int alpha; + unsigned int frm_sequence; +}disp_input_config; + + +typedef struct disp_output_config_t +{ + unsigned int va; + unsigned int pa; + DISP_FORMAT fmt; + unsigned int x; + unsigned int y; + unsigned int width; + unsigned int height; + unsigned int pitch; + unsigned int pitchUV; + DISP_BUFFER_TYPE security; + unsigned int buff_idx; + unsigned int frm_sequence; +}disp_output_config; + +#define MAX_INPUT_CONFIG 4 + +typedef struct disp_session_input_config_t +{ + unsigned int session_id; + unsigned int config_layer_num; + disp_input_config config[MAX_INPUT_CONFIG]; +}disp_session_input_config; + +typedef struct disp_session_output_config_t +{ + unsigned int session_id; + disp_output_config config; +}disp_session_output_config; + +typedef struct disp_session_layer_num_config_t +{ + unsigned int session_id; + unsigned int max_layer_num; +}disp_session_layer_num_config; + +typedef struct disp_session_info_t +{ + unsigned int session_id; + unsigned int maxLayerNum; + unsigned int isHwVsyncAvailable; + DISP_IF_TYPE displayType; + unsigned int displayWidth; + unsigned int displayHeight; + unsigned int displayFormat; + DISP_IF_MODE displayMode; + unsigned int vsyncFPS; + unsigned int physicalWidth; + unsigned int physicalHeight; + unsigned int isConnected; +} disp_session_info; + +typedef struct disp_buffer_info_t +{ + // Session + unsigned int session_id; + // Input + unsigned int layer_id; + unsigned int layer_en; + int ion_fd; + unsigned int cache_sync; + // Output + unsigned int index; + int fence_fd; +}disp_buffer_info; +/* IOCTL commands. */ +#define DISP_IOW(num, dtype) _IOW('O', num, dtype) +#define DISP_IOR(num, dtype) _IOR('O', num, dtype) +#define DISP_IOWR(num, dtype) _IOWR('O', num, dtype) +#define DISP_IO(num) _IO('O', num) + + +#define DISP_IOCTL_CREATE_SESSION DISP_IOW(201, disp_session_config) +#define DISP_IOCTL_DESTROY_SESSION DISP_IOW(202, disp_session_config) +#define DISP_IOCTL_TRIGGER_SESSION DISP_IOW(203, disp_session_config) +#define DISP_IOCTL_PREPARE_INPUT_BUFFER DISP_IOW(204, disp_buffer_info) +#define DISP_IOCTL_PREPARE_OUTPUT_BUFFER DISP_IOW(205, disp_buffer_info) +#define DISP_IOCTL_SET_INPUT_BUFFER DISP_IOW(206, disp_session_input_config) +#define DISP_IOCTL_SET_OUTPUT_BUFFER DISP_IOW(207, disp_session_output_config) +#define DISP_IOCTL_GET_SESSION_INFO DISP_IOW(208, disp_session_info) + +#define DISP_IOCTL_SET_SESSION_MODE DISP_IOW(209, disp_session_config) +#define DISP_IOCTL_GET_SESSION_MODE DISP_IOW(210, disp_session_config) +#define DISP_IOCTL_SET_SESSION_TYPE DISP_IOW(211, disp_session_config) +#define DISP_IOCTL_GET_SESSION_TYPE DISP_IOW(212, disp_session_config) +#define DISP_IOCTL_WAIT_FOR_VSYNC DISP_IOW(213, disp_session_vsync_config) +#define DISP_IOCTL_SET_MAX_LAYER_NUM DISP_IOW(214, disp_session_layer_num_config) + + +#endif //__DISP_SVP_H diff --git a/kernel-headers/linux/fm.h b/kernel-headers/linux/fm.h new file mode 100644 index 0000000..91ed0bf --- /dev/null +++ b/kernel-headers/linux/fm.h @@ -0,0 +1,631 @@ +#ifndef __FM_H__ +#define __FM_H__ + +//#define FMDEBUG + +#include <linux/ioctl.h> +#include <linux/time.h> +//fm type define +typedef signed char fm_s8; +typedef signed short fm_s16; +typedef signed int fm_s32; +typedef signed long long fm_s64; +typedef unsigned char fm_u8; +typedef unsigned short fm_u16; +typedef unsigned int fm_u32; +typedef unsigned long long fm_u64; +typedef enum fm_bool { + fm_false = 0, + fm_true = 1 +} fm_bool; + +// scan sort algorithm +enum { + FM_SCAN_SORT_NON = 0, + FM_SCAN_SORT_UP, + FM_SCAN_SORT_DOWN, + FM_SCAN_SORT_MAX +}; + +// scan methods +enum { + FM_SCAN_SEL_HW = 0, // select hardware scan, advantage: fast + FM_SCAN_SEL_SW, // select software scan, advantage: more accurate + FM_SCAN_SEL_MAX +}; + + //***************************************************************************************** +//***********************************FM config for customer *********************************** +//***************************************************************************************** +//RX +#define FMR_RSSI_TH_LONG 0x0301 //FM radio long antenna RSSI threshold(11.375dBuV) +#define FMR_RSSI_TH_SHORT 0x02E0 //FM radio short antenna RSSI threshold(-1dBuV) +#define FMR_CQI_TH 0x00E9 //FM radio Channel quality indicator threshold(0x0000~0x00FF) +#define FMR_SEEK_SPACE 1 //FM radio seek space,1:100KHZ; 2:200KHZ +#define FMR_SCAN_CH_SIZE 80 //FM radio scan max channel size +#define FMR_BAND 1 //FM radio band, 1:87.5MHz~108.0MHz; 2:76.0MHz~90.0MHz; 3:76.0MHz~108.0MHz; 4:special +#define FMR_BAND_FREQ_L 875 //FM radio special band low freq(Default 87.5MHz) +#define FMR_BAND_FREQ_H 1080 //FM radio special band high freq(Default 108.0MHz) +#define FM_SCAN_SORT_SELECT FM_SCAN_SORT_NON +#define FM_SCAN_SELECT FM_SCAN_SEL_HW +#define FM_SCAN_SOFT_MUTE_GAIN_TH 3 //soft-mute threshold when software scan, rang: 0~3, 0 means better audio quality but less channel +#define FM_CHIP_DESE_RSSI_TH (-102) // rang: -102 ~ -72 + +//TX +#define FMTX_PWR_LEVEL_MAX 120 //FM transmitter power level, rang: 85db~120db, default 120db + +//***************************************************************************************** +//***********************************FM config for engineer *********************************** +//***************************************************************************************** +//RX +#define FMR_MR_TH 0x01BD //FM radio MR threshold +#define ADDR_SCAN_TH 0xE0 //scan thrshold register +#define ADDR_CQI_TH 0xE1 //scan CQI register + +//TX +#define FMTX_SCAN_HOLE_LOW 923 //92.3MHz~95.4MHz should not show to user +#define FMTX_SCAN_HOLE_HIGH 954 //92.3MHz~95.4MHz should not show to user +//***************************************************************************************** + +#define FM_NAME "fm" +#define FM_DEVICE_NAME "/dev/fm" + +// errno +#define FM_SUCCESS 0 +#define FM_FAILED 1 +#define FM_EPARM 2 +#define FM_BADSTATUS 3 +#define FM_TUNE_FAILED 4 +#define FM_SEEK_FAILED 5 +#define FM_BUSY 6 +#define FM_SCAN_FAILED 7 + +// band +#define FM_BAND_UNKNOWN 0 +#define FM_BAND_UE 1 // US/Europe band 87.5MHz ~ 108MHz (DEFAULT) +#define FM_BAND_JAPAN 2 // Japan band 76MHz ~ 90MHz +#define FM_BAND_JAPANW 3 // Japan wideband 76MHZ ~ 108MHz +#define FM_BAND_SPECIAL 4 // special band between 76MHZ and 108MHz +#define FM_BAND_DEFAULT FM_BAND_UE + +#define FM_UE_FREQ_MIN 875 +#define FM_UE_FREQ_MAX 1080 +#define FM_JP_FREQ_MIN 760 +#define FM_JP_FREQ_MAX 1080 +#define FM_FREQ_MIN FMR_BAND_FREQ_L +#define FM_FREQ_MAX FMR_BAND_FREQ_H +#define FM_RAIDO_BAND FM_BAND_UE + +// space +#define FM_SPACE_UNKNOWN 0 +#define FM_SPACE_100K 1 +#define FM_SPACE_200K 2 +#define FM_SPACE_50K 5 + +#define FM_SEEK_SPACE FMR_SEEK_SPACE + +// max scan channel num +#define FM_MAX_CHL_SIZE FMR_SCAN_CH_SIZE +// auto HiLo +#define FM_AUTO_HILO_OFF 0 +#define FM_AUTO_HILO_ON 1 + +// seek direction +#define FM_SEEK_UP 0 +#define FM_SEEK_DOWN 1 + +#define FM_CHIP_AR1000 0x1000 +#define FM_CHIP_MT5192 0x91 +#define FM_CHIP_MT5193 0x92 +#define FM_CHIP_MT6616 0x6616 +#define FM_CHIP_MT6620 0x6620 +#define FM_CHIP_MT6626 0x6626 +#define FM_CHIP_MT6628 0x6628 +#define FM_CHIP_MT6627 0x6627 +#define FM_CHIP_MT6580 0x6580 +#define FM_CHIP_MT6630 0x6630 + +#define FM_CHIP_UNSUPPORTED -1 + +// seek threshold +#define FM_SEEKTH_LEVEL_DEFAULT 4 + +struct fm_tune_parm { + uint8_t err; + uint8_t band; + uint8_t space; + uint8_t hilo; + uint16_t freq; // IN/OUT parameter +}; + +struct fm_seek_parm { + uint8_t err; + uint8_t band; + uint8_t space; + uint8_t hilo; + uint8_t seekdir; + uint8_t seekth; + uint16_t freq; // IN/OUT parameter +}; + +struct fm_scan_parm { + uint8_t err; + uint8_t band; + uint8_t space; + uint8_t hilo; + uint16_t freq; // OUT parameter + uint16_t ScanTBL[26]; //need no less than the chip + uint16_t ScanTBLSize; //IN/OUT parameter +}; + +struct fm_ch_rssi { + uint16_t freq; + int rssi; +}; + +enum fm_scan_cmd_t { + FM_SCAN_CMD_INIT = 0, + FM_SCAN_CMD_START, + FM_SCAN_CMD_GET_NUM, + FM_SCAN_CMD_GET_CH, + FM_SCAN_CMD_GET_RSSI, + FM_SCAN_CMD_GET_CH_RSSI, + FM_SCAN_CMD_MAX +}; + +struct fm_scan_t { + enum fm_scan_cmd_t cmd; + int ret; // 0, success; else error code + uint16_t lower; // lower band, Eg, 7600 -> 76.0Mhz + uint16_t upper; // upper band, Eg, 10800 -> 108.0Mhz + int space; // 5: 50KHz, 10: 100Khz, 20: 200Khz + int num; // valid channel number + void *priv; + int sr_size; // scan result buffer size in bytes + union { + uint16_t *ch_buf; // channel buffer + int *rssi_buf; // rssi buffer + struct fm_ch_rssi *ch_rssi_buf; //channel and RSSI buffer + } sr; +}; + +struct fm_seek_t { + int ret; // 0, success; else error code + uint16_t freq; + uint16_t lower; // lower band, Eg, 7600 -> 76.0Mhz + uint16_t upper; // upper band, Eg, 10800 -> 108.0Mhz + int space; // 5: 50KHz, 10: 100Khz, 20: 200Khz + int dir; // 0: up; 1: down + int th; // seek threshold in dbm(Eg, -95dbm) + void *priv; +}; + +struct fm_tune_t { + int ret; // 0, success; else error code + uint16_t freq; + uint16_t lower; // lower band, Eg, 7600 -> 76.0Mhz + uint16_t upper; // upper band, Eg, 10800 -> 108.0Mhz + int space; // 5: 50KHz, 10: 100Khz, 20: 200Khz + void *priv; +}; + +struct fm_softmute_tune_t { + fm_s32 rssi; // RSSI of current channel + fm_u16 freq; // current frequency + fm_bool valid; // current channel is valid(true) or not(false) +}; + +struct fm_rssi_req { + uint16_t num; + uint16_t read_cnt; + struct fm_ch_rssi cr[26*16]; +}; + +struct fm_hw_info { + int chip_id; //chip ID, eg. 6620 + int eco_ver; //chip ECO version, eg. E3 + int rom_ver; //FM DSP rom code version, eg. V2 + int patch_ver; //FM DSP patch version, eg. 1.11 + int reserve; +}; + +struct fm_search_threshold_t { + fm_s32 th_type;// 0, RSSI. 1,desense RSSI. 2,SMG. + fm_s32 th_val; //threshold value + fm_s32 reserve; +}; + +#if 1 +#define NEED_DEF_RDS 1 +#else +#define NEED_DEF_RDS 0 +#endif + +#if NEED_DEF_RDS +//For RDS feature +typedef struct { + uint8_t TP; + uint8_t TA; + uint8_t Music; + uint8_t Stereo; + uint8_t Artificial_Head; + uint8_t Compressed; + uint8_t Dynamic_PTY; + uint8_t Text_AB; + uint32_t flag_status; +} RDSFlag_Struct; + +typedef struct { + uint16_t Month; + uint16_t Day; + uint16_t Year; + uint16_t Hour; + uint16_t Minute; + uint8_t Local_Time_offset_signbit; + uint8_t Local_Time_offset_half_hour; +} CT_Struct; + +typedef struct { + int16_t AF_Num; + int16_t AF[2][25]; //100KHz + uint8_t Addr_Cnt; + uint8_t isMethod_A; + uint8_t isAFNum_Get; +} AF_Info; + +typedef struct { + uint8_t PS[4][8]; + uint8_t Addr_Cnt; +} PS_Info; + +typedef struct { + uint8_t TextData[4][64]; + uint8_t GetLength; + uint8_t isRTDisplay; + uint8_t TextLength; + uint8_t isTypeA; + uint8_t BufCnt; + uint16_t Addr_Cnt; +} RT_Info; + +struct rds_raw_data { + int dirty; //indicate if the data changed or not + int len; //the data len form chip + uint8_t data[146]; +}; + +struct rds_group_cnt { + unsigned int total; + unsigned int groupA[16]; // RDS groupA counter + unsigned int groupB[16]; // RDS groupB counter +}; + +enum rds_group_cnt_opcode { + RDS_GROUP_CNT_READ = 0, + RDS_GROUP_CNT_WRITE, + RDS_GROUP_CNT_RESET, + RDS_GROUP_CNT_MAX +}; + +struct rds_group_cnt_req { + int err; + enum rds_group_cnt_opcode op; + struct rds_group_cnt gc; +}; + +typedef struct { + CT_Struct CT; + RDSFlag_Struct RDSFlag; + uint16_t PI; + uint8_t Switch_TP; + uint8_t PTY; + AF_Info AF_Data; + AF_Info AFON_Data; + uint8_t Radio_Page_Code; + uint16_t Program_Item_Number_Code; + uint8_t Extend_Country_Code; + uint16_t Language_Code; + PS_Info PS_Data; + uint8_t PS_ON[8]; + RT_Info RT_Data; + uint16_t event_status; //will use RDSFlag_Struct RDSFlag->flag_status to check which event, is that ok? + struct rds_group_cnt gc; +} RDSData_Struct; + + +//Need care the following definition. +//valid Rds Flag for notify +typedef enum { + RDS_FLAG_IS_TP = 0x0001, // Program is a traffic program + RDS_FLAG_IS_TA = 0x0002, // Program currently broadcasts a traffic ann. + RDS_FLAG_IS_MUSIC = 0x0004, // Program currently broadcasts music + RDS_FLAG_IS_STEREO = 0x0008, // Program is transmitted in stereo + RDS_FLAG_IS_ARTIFICIAL_HEAD = 0x0010, // Program is an artificial head recording + RDS_FLAG_IS_COMPRESSED = 0x0020, // Program content is compressed + RDS_FLAG_IS_DYNAMIC_PTY = 0x0040, // Program type can change + RDS_FLAG_TEXT_AB = 0x0080 // If this flag changes state, a new radio text string begins +} RdsFlag; + +typedef enum { + RDS_EVENT_FLAGS = 0x0001, // One of the RDS flags has changed state + RDS_EVENT_PI_CODE = 0x0002, // The program identification code has changed + RDS_EVENT_PTY_CODE = 0x0004, // The program type code has changed + RDS_EVENT_PROGRAMNAME = 0x0008, // The program name has changed + RDS_EVENT_UTCDATETIME = 0x0010, // A new UTC date/time is available + RDS_EVENT_LOCDATETIME = 0x0020, // A new local date/time is available + RDS_EVENT_LAST_RADIOTEXT = 0x0040, // A radio text string was completed + RDS_EVENT_AF = 0x0080, // Current Channel RF signal strength too weak, need do AF switch + RDS_EVENT_AF_LIST = 0x0100, // An alternative frequency list is ready + RDS_EVENT_AFON_LIST = 0x0200, // An alternative frequency list is ready + RDS_EVENT_TAON = 0x0400, // Other Network traffic announcement start + RDS_EVENT_TAON_OFF = 0x0800, // Other Network traffic announcement finished. + RDS_EVENT_RDS = 0x2000, // RDS Interrupt had arrived durint timer period + RDS_EVENT_NO_RDS = 0x4000, // RDS Interrupt not arrived durint timer period + RDS_EVENT_RDS_TIMER = 0x8000 // Timer for RDS Bler Check. ---- BLER block error rate +} RdsEvent; +#endif + +struct fm_rds_tx_parm { + uint8_t err; + uint16_t pi; + uint16_t ps[12]; // 4 ps + uint16_t other_rds[87]; // 0~29 other groups + uint8_t other_rds_cnt; // # of other group +}; + +typedef struct fm_rds_tx_req { + unsigned char pty; // 0~31 integer + unsigned char rds_rbds; // 0:RDS, 1:RBDS + unsigned char dyn_pty; // 0:static, 1:dynamic + unsigned short pi_code; // 2-byte hex + unsigned char ps_buf[8]; // hex buf of PS + unsigned char ps_len; // length of PS, must be 0 / 8" + unsigned char af; // 0~204, 0:not used, 1~204:(87.5+0.1*af)MHz + unsigned char ah; // Artificial head, 0:no, 1:yes + unsigned char stereo; // 0:mono, 1:stereo + unsigned char compress; // Audio compress, 0:no, 1:yes + unsigned char tp; // traffic program, 0:no, 1:yes + unsigned char ta; // traffic announcement, 0:no, 1:yes + unsigned char speech; // 0:music, 1:speech +} fm_rds_tx_req; + +#define TX_SCAN_MAX 10 +#define TX_SCAN_MIN 1 +struct fm_tx_scan_parm { + uint8_t err; + uint8_t band; //87.6~108MHz + uint8_t space; + uint8_t hilo; + uint16_t freq; // start freq, if less than band min freq, then will use band min freq + uint8_t scandir; + uint16_t ScanTBL[TX_SCAN_MAX]; //need no less than the chip + uint16_t ScanTBLSize; //IN: desired size, OUT: scan result size +}; + +struct fm_gps_rtc_info { + int err; //error number, 0: success, other: err code + int retryCnt; //GPS mnl can decide retry times + int ageThd; //GPS 3D fix time diff threshold + int driftThd; //GPS RTC drift threshold + struct timeval tvThd; //time value diff threshold + int age; //GPS 3D fix time diff + int drift; //GPS RTC drift + union{ + unsigned long stamp; //time stamp in jiffies + struct timeval tv; //time stamp value in RTC + }; + int flag; //rw flag +}; + +typedef enum { + FM_I2S_ON = 0, + FM_I2S_OFF, + FM_I2S_STATE_ERR +} fm_i2s_state_e; + +typedef enum { + FM_I2S_MASTER = 0, + FM_I2S_SLAVE, + FM_I2S_MODE_ERR +} fm_i2s_mode_e; + +typedef enum { + FM_I2S_32K = 0, + FM_I2S_44K, + FM_I2S_48K, + FM_I2S_SR_ERR +} fm_i2s_sample_e; + +struct fm_i2s_setting { + int onoff; + int mode; + int sample; +}; + +typedef enum { + FM_RX = 0, + FM_TX = 1 +} FM_PWR_T; + +typedef struct fm_i2s_info { + int status; /*0:FM_I2S_ON, 1:FM_I2S_OFF,2:error*/ + int mode; /*0:FM_I2S_MASTER, 1:FM_I2S_SLAVE,2:error*/ + int rate; /*0:FM_I2S_32K:32000,1:FM_I2S_44K:44100,2:FM_I2S_48K:48000,3:error*/ +} fm_i2s_info_t; + +typedef enum { + FM_AUD_ANALOG = 0, + FM_AUD_I2S = 1, + FM_AUD_MRGIF = 2, + FM_AUD_ERR +} fm_audio_path_e; + +typedef enum { + FM_I2S_PAD_CONN = 0, //sco fm chip: e.g.6627 + FM_I2S_PAD_IO = 1, //combo fm chip: e.g.6628 + FM_I2S_PAD_ERR +} fm_i2s_pad_sel_e; + +typedef struct fm_audio_info { + fm_audio_path_e aud_path; + fm_i2s_info_t i2s_info; + fm_i2s_pad_sel_e i2s_pad; +} fm_audio_info_t; + +struct fm_cqi { + int ch; + int rssi; + int reserve; +}; + +struct fm_cqi_req { + uint16_t ch_num; + int buf_size; + char *cqi_buf; +}; + +typedef struct { + int freq; + int rssi; +} fm_desense_check_t; + +typedef struct { + uint16_t lower; // lower band, Eg, 7600 -> 76.0Mhz + uint16_t upper; // upper band, Eg, 10800 -> 108.0Mhz + int space; // 0x1: 50KHz, 0x2: 100Khz, 0x4: 200Khz + int cycle; // repeat times +} fm_full_cqi_log_t; + +typedef struct { + int which; + bool stat; +} fm_status_t; + +// ********** ***********FM IOCTL define start ******************************* + +#define FM_IOC_MAGIC 0xf5 // FIXME: any conflict? +#define FM_IOCTL_POWERUP _IOWR(FM_IOC_MAGIC, 0, struct fm_tune_parm*) +#define FM_IOCTL_POWERDOWN _IOWR(FM_IOC_MAGIC, 1, int32_t*) +#define FM_IOCTL_TUNE _IOWR(FM_IOC_MAGIC, 2, struct fm_tune_parm*) +#define FM_IOCTL_SEEK _IOWR(FM_IOC_MAGIC, 3, struct fm_seek_parm*) +#define FM_IOCTL_SETVOL _IOWR(FM_IOC_MAGIC, 4, uint32_t*) +#define FM_IOCTL_GETVOL _IOWR(FM_IOC_MAGIC, 5, uint32_t*) +#define FM_IOCTL_MUTE _IOWR(FM_IOC_MAGIC, 6, uint32_t*) +#define FM_IOCTL_GETRSSI _IOWR(FM_IOC_MAGIC, 7, int32_t*) +#define FM_IOCTL_SCAN _IOWR(FM_IOC_MAGIC, 8, struct fm_scan_parm*) +#define FM_IOCTL_STOP_SCAN _IO(FM_IOC_MAGIC, 9) + +//IOCTL and struct for test +#define FM_IOCTL_GETCHIPID _IOWR(FM_IOC_MAGIC, 10, uint16_t*) +#define FM_IOCTL_EM_TEST _IOWR(FM_IOC_MAGIC, 11, struct fm_em_parm*) +#define FM_IOCTL_RW_REG _IOWR(FM_IOC_MAGIC, 12, struct fm_ctl_parm*) +#define FM_IOCTL_GETMONOSTERO _IOWR(FM_IOC_MAGIC, 13, uint16_t*) +#define FM_IOCTL_GETCURPAMD _IOWR(FM_IOC_MAGIC, 14, uint16_t*) +#define FM_IOCTL_GETGOODBCNT _IOWR(FM_IOC_MAGIC, 15, uint16_t*) +#define FM_IOCTL_GETBADBNT _IOWR(FM_IOC_MAGIC, 16, uint16_t*) +#define FM_IOCTL_GETBLERRATIO _IOWR(FM_IOC_MAGIC, 17, uint16_t*) + +//IOCTL for RDS +#define FM_IOCTL_RDS_ONOFF _IOWR(FM_IOC_MAGIC, 18, uint16_t*) +#define FM_IOCTL_RDS_SUPPORT _IOWR(FM_IOC_MAGIC, 19, int32_t*) + +#define FM_IOCTL_POWERUP_TX _IOWR(FM_IOC_MAGIC, 20, struct fm_tune_parm*) +#define FM_IOCTL_TUNE_TX _IOWR(FM_IOC_MAGIC, 21, struct fm_tune_parm*) +#define FM_IOCTL_RDS_TX _IOWR(FM_IOC_MAGIC, 22, struct fm_rds_tx_parm*) + +#define FM_IOCTL_RDS_SIM_DATA _IOWR(FM_IOC_MAGIC, 23, uint32_t*) +#define FM_IOCTL_IS_FM_POWERED_UP _IOWR(FM_IOC_MAGIC, 24, uint32_t*) + +//IOCTL for FM Tx +#define FM_IOCTL_TX_SUPPORT _IOWR(FM_IOC_MAGIC, 25, int32_t*) +#define FM_IOCTL_RDSTX_SUPPORT _IOWR(FM_IOC_MAGIC, 26, int32_t*) +#define FM_IOCTL_RDSTX_ENABLE _IOWR(FM_IOC_MAGIC, 27, int32_t*) +#define FM_IOCTL_TX_SCAN _IOWR(FM_IOC_MAGIC, 28, struct fm_tx_scan_parm*) + +//IOCTL for FM over BT +#define FM_IOCTL_OVER_BT_ENABLE _IOWR(FM_IOC_MAGIC, 29, int32_t*) + +//IOCTL for FM ANTENNA SWITCH +#define FM_IOCTL_ANA_SWITCH _IOWR(FM_IOC_MAGIC, 30, int32_t*) +#define FM_IOCTL_GETCAPARRAY _IOWR(FM_IOC_MAGIC, 31, int32_t*) + +//IOCTL for FM compensation by GPS RTC +#define FM_IOCTL_GPS_RTC_DRIFT _IOWR(FM_IOC_MAGIC, 32, struct fm_gps_rtc_info*) + +//IOCTL for FM I2S Setting +#define FM_IOCTL_I2S_SETTING _IOWR(FM_IOC_MAGIC, 33, struct fm_i2s_setting*) + +#define FM_IOCTL_RDS_GROUPCNT _IOWR(FM_IOC_MAGIC, 34, struct rds_group_cnt_req*) +#define FM_IOCTL_RDS_GET_LOG _IOWR(FM_IOC_MAGIC, 35, struct rds_raw_data*) + +#define FM_IOCTL_SCAN_GETRSSI _IOWR(FM_IOC_MAGIC, 36, struct fm_rssi_req*) +#define FM_IOCTL_SETMONOSTERO _IOWR(FM_IOC_MAGIC, 37, int32_t) +#define FM_IOCTL_RDS_BC_RST _IOWR(FM_IOC_MAGIC, 38, int32_t*) +#define FM_IOCTL_CQI_GET _IOWR(FM_IOC_MAGIC, 39, struct fm_cqi_req*) +#define FM_IOCTL_GET_HW_INFO _IOWR(FM_IOC_MAGIC, 40, struct fm_hw_info*) +#define FM_IOCTL_GET_I2S_INFO _IOWR(FM_IOC_MAGIC, 41, fm_i2s_info_t*) +#define FM_IOCTL_IS_DESE_CHAN _IOWR(FM_IOC_MAGIC, 42, int32_t*) +#define FM_IOCTL_TOP_RDWR _IOWR(FM_IOC_MAGIC, 43, struct fm_top_rw_parm*) +#define FM_IOCTL_HOST_RDWR _IOWR(FM_IOC_MAGIC, 44, struct fm_host_rw_parm*) + +#define FM_IOCTL_PRE_SEARCH _IOWR(FM_IOC_MAGIC, 45,int32_t) +#define FM_IOCTL_RESTORE_SEARCH _IOWR(FM_IOC_MAGIC, 46,int32_t) + +#define FM_IOCTL_SET_SEARCH_THRESHOLD _IOWR(FM_IOC_MAGIC, 47, fm_search_threshold_t*) + +#define FM_IOCTL_GET_AUDIO_INFO _IOWR(FM_IOC_MAGIC, 48, fm_audio_info_t*) +#define FM_IOCTL_FM_SET_STATUS _IOWR(FM_IOC_MAGIC, 49, fm_status_t) +#define FM_IOCTL_FM_GET_STATUS _IOWR(FM_IOC_MAGIC, 50, fm_status_t) + +#define FM_IOCTL_SCAN_NEW _IOWR(FM_IOC_MAGIC, 60, struct fm_scan_t*) +#define FM_IOCTL_SEEK_NEW _IOWR(FM_IOC_MAGIC, 61, struct fm_seek_t*) +#define FM_IOCTL_TUNE_NEW _IOWR(FM_IOC_MAGIC, 62, struct fm_tune_t*) + +#define FM_IOCTL_SOFT_MUTE_TUNE _IOWR(FM_IOC_MAGIC, 63, struct fm_softmute_tune_t*)/*for soft mute tune*/ +#define FM_IOCTL_DESENSE_CHECK _IOWR(FM_IOC_MAGIC, 64, fm_desense_check_t*) + +//IOCTL for EM +#define FM_IOCTL_FULL_CQI_LOG _IOWR(FM_IOC_MAGIC, 70, fm_full_cqi_log_t *) + +#define FM_IOCTL_DUMP_REG _IO(FM_IOC_MAGIC, 0xFF) + +// ********** ***********FM IOCTL define end ******************************* + + +enum group_idx { + mono = 0, + stereo, + RSSI_threshold, + HCC_Enable, + PAMD_threshold, + Softmute_Enable, + De_emphasis, + HL_Side, + Demod_BW, + Dynamic_Limiter, + Softmute_Rate, + AFC_Enable, + Softmute_Level, + Analog_Volume, + GROUP_TOTAL_NUMS +}; + +enum item_idx { + Sblend_OFF = 0, + Sblend_ON, + ITEM_TOTAL_NUMS +}; + +struct fm_ctl_parm { + uint8_t err; + uint8_t addr; + uint16_t val; + uint16_t rw_flag;//0:write, 1:read +}; + +struct fm_em_parm { + uint16_t group_idx; + uint16_t item_idx; + uint32_t item_value; +}; +#endif // __FM_H__ diff --git a/kernel-headers/linux/hdmitx.h b/kernel-headers/linux/hdmitx.h new file mode 100644 index 0000000..58103b5 --- /dev/null +++ b/kernel-headers/linux/hdmitx.h @@ -0,0 +1,361 @@ +// --------------------------------------------------------------------------- + +#ifndef HDMITX_H +#define HDMITX_H + + +#define HDMI_DEV_DRV "/dev/hdmitx" + + +typedef enum +{ + HDMI_STATUS_OK = 0, + HDMI_STATUS_NOT_IMPLEMENTED, + HDMI_STATUS_ALREADY_SET, + HDMI_STATUS_ERROR, +} HDMI_STATUS; + +typedef enum +{ + SMART_BOOK_DISCONNECTED = 0, + SMART_BOOK_CONNECTED, +} SMART_BOOK_STATE; + +typedef enum +{ + HDMI_POWER_STATE_OFF = 0, + HDMI_POWER_STATE_ON, + HDMI_POWER_STATE_STANDBY, +} HDMI_POWER_STATE; + +typedef enum +{ + HDMI_MAX_CHANNEL_2 = 0x2, + HDMI_MAX_CHANNEL_3 = 0x3, + HDMI_MAX_CHANNEL_4 = 0x4, + HDMI_MAX_CHANNEL_5 = 0x5, + HDMI_MAX_CHANNEL_6 = 0x6, + HDMI_MAX_CHANNEL_7 = 0x7, + HDMI_MAX_CHANNEL_8 = 0x8, +}AUDIO_MAX_CHANNEL; + +typedef enum +{ + HDMI_MAX_SAMPLERATE_32 = 0x1, + HDMI_MAX_SAMPLERATE_44 = 0x2, + HDMI_MAX_SAMPLERATE_48 = 0x3, + HDMI_MAX_SAMPLERATE_96 = 0x4, + HDMI_MAX_SAMPLERATE_192 = 0x5, +}AUDIO_MAX_SAMPLERATE; + +typedef enum +{ + HDMI_MAX_BITWIDTH_16 = 0x1, + HDMI_MAX_BITWIDTH_24 = 0x2, +}AUDIO_MAX_BITWIDTH; + +typedef enum +{ + HDMI_SCALE_ADJUSTMENT_SUPPORT = 0x01, + HDMI_ONE_RDMA_LIMITATION = 0x02, + HDMI_PHONE_GPIO_REUSAGE = 0x04, +} HDMI_CAPABILITY; + +typedef enum +{ + HDMI_TO_TV = 0x0, + HDMI_TO_SMB, +} hdmi_device_type; + +typedef enum +{ + HDMI_IS_DISCONNECTED = 0, + HDMI_IS_CONNECTED = 1, + HDMI_IS_RES_CHG = 0x11, +} hdmi_connect_status; + +#define MAKE_MTK_HDMI_FORMAT_ID(id, bpp) (((id) << 8) | (bpp)) +typedef enum +{ + MTK_HDMI_FORMAT_UNKNOWN = 0, + + MTK_HDMI_FORMAT_RGB565 = MAKE_MTK_HDMI_FORMAT_ID(1, 2), + MTK_HDMI_FORMAT_RGB888 = MAKE_MTK_HDMI_FORMAT_ID(2, 3), + MTK_HDMI_FORMAT_BGR888 = MAKE_MTK_HDMI_FORMAT_ID(3, 3), + MTK_HDMI_FORMAT_ARGB8888 = MAKE_MTK_HDMI_FORMAT_ID(4, 4), + MTK_HDMI_FORMAT_ABGR8888 = MAKE_MTK_HDMI_FORMAT_ID(5, 4), + MTK_HDMI_FORMAT_YUV422 = MAKE_MTK_HDMI_FORMAT_ID(6, 2), + MTK_HDMI_FORMAT_XRGB8888 = MAKE_MTK_HDMI_FORMAT_ID(7, 4), + MTK_HDMI_FORMAT_XBGR8888 = MAKE_MTK_HDMI_FORMAT_ID(8, 4), + MTK_HDMI_FORMAT_BPP_MASK = 0xFF, +} MTK_HDMI_FORMAT; + +typedef struct +{ + bool is_audio_enabled; + bool is_video_enabled; +} hdmi_device_status; + +typedef struct +{ + void *src_base_addr; + void *src_phy_addr; + int src_fmt; + unsigned int src_pitch; + unsigned int src_offset_x, src_offset_y; + unsigned int src_width, src_height; + + int next_buff_idx; + int identity; + int connected_type; + unsigned int security; + +} hdmi_video_buffer_info; + + +typedef struct +{ + // Input + int ion_fd; + // Output + unsigned int index; //fence count + int fence_fd; //fence fd +} hdmi_buffer_info; + +#define MTK_HDMI_NO_FENCE_FD ((int)(-1)) //((int)(~0U>>1)) +#define MTK_HDMI_NO_ION_FD ((int)(-1)) //((int)(~0U>>1)) + +typedef struct +{ + unsigned int u4Addr; + unsigned int u4Data; +} hdmi_device_write; + +typedef struct +{ + unsigned int u4Data1; + unsigned int u4Data2; +} hdmi_para_setting; + +typedef struct +{ + unsigned char u1Hdcpkey[287]; +} hdmi_hdcp_key; + +typedef struct +{ + unsigned char u1Hdcpkey[384]; +} hdmi_hdcp_drmkey; + +typedef struct +{ + unsigned char u1sendsltdata[15]; +} send_slt_data; + +typedef struct _HDMI_EDID_T +{ + unsigned int ui4_ntsc_resolution;//use EDID_VIDEO_RES_T, there are many resolution + unsigned int ui4_pal_resolution;// use EDID_VIDEO_RES_T + unsigned int ui4_sink_native_ntsc_resolution;//use EDID_VIDEO_RES_T, only one NTSC resolution, Zero means none native NTSC resolution is avaiable + unsigned int ui4_sink_native_pal_resolution; //use EDID_VIDEO_RES_T, only one resolution, Zero means none native PAL resolution is avaiable + unsigned int ui4_sink_cea_ntsc_resolution;//use EDID_VIDEO_RES_T + unsigned int ui4_sink_cea_pal_resolution;//use EDID_VIDEO_RES_T + unsigned int ui4_sink_dtd_ntsc_resolution;//use EDID_VIDEO_RES_T + unsigned int ui4_sink_dtd_pal_resolution;//use EDID_VIDEO_RES_T + unsigned int ui4_sink_1st_dtd_ntsc_resolution;//use EDID_VIDEO_RES_T + unsigned int ui4_sink_1st_dtd_pal_resolution;//use EDID_VIDEO_RES_T + unsigned short ui2_sink_colorimetry;//use EDID_VIDEO_COLORIMETRY_T + unsigned char ui1_sink_rgb_color_bit;//color bit for RGB + unsigned char ui1_sink_ycbcr_color_bit; // color bit for YCbCr + unsigned short ui2_sink_aud_dec;// use EDID_AUDIO_DECODER_T + unsigned char ui1_sink_is_plug_in;//1: Plug in 0:Plug Out + unsigned int ui4_hdmi_pcm_ch_type;//use EDID_A_FMT_CH_TYPE + unsigned int ui4_hdmi_pcm_ch3ch4ch5ch7_type;//use EDID_A_FMT_CH_TYPE1 + unsigned int ui4_dac_pcm_ch_type;//use EDID_A_FMT_CH_TYPE + unsigned char ui1_sink_i_latency_present; + unsigned char ui1_sink_p_audio_latency; + unsigned char ui1_sink_p_video_latency; + unsigned char ui1_sink_i_audio_latency; + unsigned char ui1_sink_i_video_latency; + unsigned char ui1ExtEdid_Revision; + unsigned char ui1Edid_Version; + unsigned char ui1Edid_Revision; + unsigned char ui1_Display_Horizontal_Size; + unsigned char ui1_Display_Vertical_Size; + unsigned int ui4_ID_Serial_Number; + unsigned int ui4_sink_cea_3D_resolution; + unsigned char ui1_sink_support_ai;//0: not support AI, 1:support AI + unsigned short ui2_sink_cec_address; + unsigned short ui1_sink_max_tmds_clock; + unsigned short ui2_sink_3D_structure; + unsigned int ui4_sink_cea_FP_SUP_3D_resolution; + unsigned int ui4_sink_cea_TOB_SUP_3D_resolution; + unsigned int ui4_sink_cea_SBS_SUP_3D_resolution; + unsigned short ui2_sink_ID_manufacturer_name;//(08H~09H) + unsigned short ui2_sink_ID_product_code; //(0aH~0bH) + unsigned int ui4_sink_ID_serial_number; //(0cH~0fH) + unsigned char ui1_sink_week_of_manufacture; //(10H) + unsigned char ui1_sink_year_of_manufacture; //(11H) base on year 1990 +} HDMI_EDID_T; + +typedef struct +{ + unsigned int ui4_sink_FP_SUP_3D_resolution; + unsigned int ui4_sink_TOB_SUP_3D_resolution; + unsigned int ui4_sink_SBS_SUP_3D_resolution; +} MHL_3D_SUPP_T; + +typedef struct +{ + unsigned char ui1_la_num; + unsigned char e_la[3]; + unsigned short ui2_pa; + unsigned short h_cecm_svc; +} CEC_DRV_ADDR_CFG; + +typedef struct +{ + unsigned char destination : 4; + unsigned char initiator : 4; +} CEC_HEADER_BLOCK_IO; + +typedef struct +{ + CEC_HEADER_BLOCK_IO header; + unsigned char opcode; + unsigned char operand[15]; +} CEC_FRAME_BLOCK_IO; + +typedef struct +{ + unsigned char size; + unsigned char sendidx; + unsigned char reTXcnt; + void *txtag; + CEC_FRAME_BLOCK_IO blocks; +} CEC_FRAME_DESCRIPTION_IO; + +typedef struct _CEC_FRAME_INFO +{ + unsigned char ui1_init_addr; + unsigned char ui1_dest_addr; + unsigned short ui2_opcode; + unsigned char aui1_operand[14]; + unsigned int z_operand_size; +} CEC_FRAME_INFO; + +typedef struct _CEC_SEND_MSG +{ + CEC_FRAME_INFO t_frame_info; + unsigned char b_enqueue_ok; +} CEC_SEND_MSG; + +typedef struct +{ + unsigned char ui1_la; + unsigned short ui2_pa; +} CEC_ADDRESS_IO; + +typedef struct +{ + unsigned char u1Size; + unsigned char au1Data[14]; +} CEC_GETSLT_DATA; + +typedef struct +{ + unsigned int u1adress; + unsigned int pu1Data; +} READ_REG_VALUE; + +typedef struct +{ + unsigned char e_hdmi_aud_in; + unsigned char e_iec_frame; + unsigned char e_hdmi_fs; + unsigned char e_aud_code; + unsigned char u1Aud_Input_Chan_Cnt; + unsigned char e_I2sFmt; + unsigned char u1HdmiI2sMclk; + unsigned char bhdmi_LCh_status[5]; + unsigned char bhdmi_RCh_status[5]; +} HDMITX_AUDIO_PARA; + + +#define HDMI_IOW(num, dtype) _IOW('H', num, dtype) +#define HDMI_IOR(num, dtype) _IOR('H', num, dtype) +#define HDMI_IOWR(num, dtype) _IOWR('H', num, dtype) +#define HDMI_IO(num) _IO('H', num) + +#define MTK_HDMI_AUDIO_VIDEO_ENABLE HDMI_IO(1) +#define MTK_HDMI_AUDIO_ENABLE HDMI_IO(2) +#define MTK_HDMI_VIDEO_ENABLE HDMI_IO(3) +#define MTK_HDMI_GET_CAPABILITY HDMI_IOWR(4, HDMI_CAPABILITY) +#define MTK_HDMI_GET_DEVICE_STATUS HDMI_IOWR(5, hdmi_device_status) +#define MTK_HDMI_VIDEO_CONFIG HDMI_IOWR(6, int) +#define MTK_HDMI_AUDIO_CONFIG HDMI_IOWR(7, int) +#define MTK_HDMI_FORCE_FULLSCREEN_ON HDMI_IOWR(8, int) +#define MTK_HDMI_FORCE_FULLSCREEN_OFF HDMI_IOWR(9, int) +#define MTK_HDMI_IPO_POWEROFF HDMI_IOWR(10, int) +#define MTK_HDMI_IPO_POWERON HDMI_IOWR(11, int) +#define MTK_HDMI_POWER_ENABLE HDMI_IOW(12, int) +#define MTK_HDMI_PORTRAIT_ENABLE HDMI_IOW(13, int) +#define MTK_HDMI_FORCE_OPEN HDMI_IOWR(14, int) +#define MTK_HDMI_FORCE_CLOSE HDMI_IOWR(15, int) +#define MTK_HDMI_IS_FORCE_AWAKE HDMI_IOWR(16, int) + +#define MTK_HDMI_POST_VIDEO_BUFFER HDMI_IOW(20, hdmi_video_buffer_info) +#define MTK_HDMI_AUDIO_SETTING HDMI_IOWR(21, HDMITX_AUDIO_PARA) + + +#define MTK_HDMI_FACTORY_MODE_ENABLE HDMI_IOW(30, int) +#define MTK_HDMI_FACTORY_GET_STATUS HDMI_IOWR(31, int) +#define MTK_HDMI_FACTORY_DPI_TEST HDMI_IOWR(32, int) + +#define MTK_HDMI_USBOTG_STATUS HDMI_IOWR(33, int) +#define MTK_HDMI_GET_DRM_ENABLE HDMI_IOWR(34, int) + +#define MTK_HDMI_GET_DEV_INFO HDMI_IOWR(35, mtk_dispif_info_t) +#define MTK_HDMI_PREPARE_BUFFER HDMI_IOW(36, hdmi_buffer_info) +#define MTK_HDMI_SCREEN_CAPTURE HDMI_IOW(37, unsigned long) + +#define MTK_HDMI_WRITE_DEV HDMI_IOWR(52, hdmi_device_write) +#define MTK_HDMI_READ_DEV HDMI_IOWR(53, unsigned int) +#define MTK_HDMI_ENABLE_LOG HDMI_IOWR(54, unsigned int) +#define MTK_HDMI_CHECK_EDID HDMI_IOWR(55, unsigned int) +#define MTK_HDMI_INFOFRAME_SETTING HDMI_IOWR(56, hdmi_para_setting) +#define MTK_HDMI_COLOR_DEEP HDMI_IOWR(57, hdmi_para_setting) +#define MTK_HDMI_ENABLE_HDCP HDMI_IOWR(58, unsigned int) +#define MTK_HDMI_STATUS HDMI_IOWR(59, unsigned int) +#define MTK_HDMI_HDCP_KEY HDMI_IOWR(60, hdmi_hdcp_key) +#define MTK_HDMI_GET_EDID HDMI_IOWR(61, HDMI_EDID_T) +#define MTK_HDMI_SETLA HDMI_IOWR(62, CEC_DRV_ADDR_CFG) +#define MTK_HDMI_GET_CECCMD HDMI_IOWR(63, CEC_FRAME_DESCRIPTION_IO) +#define MTK_HDMI_SET_CECCMD HDMI_IOWR(64, CEC_SEND_MSG) +#define MTK_HDMI_CEC_ENABLE HDMI_IOWR(65, unsigned int) +#define MTK_HDMI_GET_CECADDR HDMI_IOWR(66, CEC_ADDRESS_IO) +#define MTK_HDMI_CECRX_MODE HDMI_IOWR(67, unsigned int) +#define MTK_HDMI_SENDSLTDATA HDMI_IOWR(68, send_slt_data) +#define MTK_HDMI_GET_SLTDATA HDMI_IOWR(69, CEC_GETSLT_DATA) +#define MTK_HDMI_VIDEO_MUTE HDMI_IOWR(70, int) + +#define MTK_HDMI_READ HDMI_IOWR(81, unsigned int) +#define MTK_HDMI_WRITE HDMI_IOWR(82, unsigned int) +#define MTK_HDMI_CMD HDMI_IOWR(83, unsigned int) +#define MTK_HDMI_DUMP HDMI_IOWR(84, unsigned int) +#define MTK_HDMI_DUMP6397 HDMI_IOWR(85, unsigned int) +#define MTK_HDMI_DUMP6397_W HDMI_IOWR(86, unsigned int) +#define MTK_HDMI_CBUS_STATUS HDMI_IOWR(87, unsigned int) +#define MTK_HDMI_CONNECT_STATUS HDMI_IOWR(88, unsigned int) +#define MTK_HDMI_DUMP6397_R HDMI_IOWR(89, unsigned int) +#define MTK_MHL_GET_DCAP HDMI_IOWR(90, unsigned int) +#define MTK_MHL_GET_3DINFO HDMI_IOWR(91, unsigned int) +#define MTK_HDMI_HDCP HDMI_IOWR(92, unsigned int) +#define MTK_HDMI_AUDIO_FORMAT HDMI_IOWR(93, unsigned int) + +#define MTK_HDMI_FACTORY_CHIP_INIT HDMI_IOWR(94, int) +#define MTK_HDMI_FACTORY_JUDGE_CALLBACK HDMI_IOWR(95, int) +#define MTK_HDMI_FACTORY_START_DPI_AND_CONFIG HDMI_IOWR(96, int) +#define MTK_HDMI_FACTORY_DPI_STOP_AND_POWER_OFF HDMI_IOWR(97, int) + +#endif diff --git a/kernel-headers/linux/hwmsensor.h b/kernel-headers/linux/hwmsensor.h new file mode 100644 index 0000000..c14611d --- /dev/null +++ b/kernel-headers/linux/hwmsensor.h @@ -0,0 +1,308 @@ +/* alps + * + * (C) Copyright 2009 + * MediaTek <www.MediaTek.com> + * + * MT6516 Sensor IOCTL & data structure + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef __HWMSENSOR_H__ +#define __HWMSENSOR_H__ + +#include <linux/ioctl.h> + +#define SENSOR_TYPE_ACCELEROMETER 1 +#define SENSOR_TYPE_MAGNETIC_FIELD 2 +#define SENSOR_TYPE_ORIENTATION 3 +#define SENSOR_TYPE_GYROSCOPE 4 +#define SENSOR_TYPE_LIGHT 5 +#define SENSOR_TYPE_PRESSURE 6 +#define SENSOR_TYPE_TEMPERATURE 7 +#define SENSOR_TYPE_PROXIMITY 8 +#define SENSOR_TYPE_GRAVITY 9 +#define SENSOR_TYPE_LINEAR_ACCELERATION 10 +#define SENSOR_TYPE_ROTATION_VECTOR 11 +#define SENSOR_TYPE_HUMIDITY 12 +#define SENSOR_TYPE_GAME_ROTATION_VECTOR 15 +#define SENSOR_TYPE_SIGNIFICANT_MOTION 17 +#define SENSOR_TYPE_STEP_DETECTOR 18 +#define SENSOR_TYPE_STEP_COUNTER 19 + +#define SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR 20 + +#define SENSOR_TYPE_HEART_RATE 21 +#define SENSOR_TYPE_TILT_DETECTOR 22 +#define SENSOR_TYPE_WAKE_GESTURE 23 +#define SENSOR_TYPE_GLANCE_GESTURE 24 +#define SENSOR_TYPE_PICK_UP_GESTURE 25 + +#define SENSOR_TYPE_PEDOMETER (26) +#define SENSOR_STRING_TYPE_PEDOMETER "android.sensor.pedometer" +#define SENSOR_TYPE_IN_POCKET (27) +#define SENSOR_STRING_TYPE_IN_POCKET "android.sensor.in_pocket" +#define SENSOR_TYPE_ACTIVITY (28) +#define SENSOR_STRING_TYPE_ACTIVITY "android.sensor.activity" +#define SENSOR_TYPE_FACE_DOWN (29) +#define SENSOR_STRING_TYPE_FACE_DOWN "android.sensor.face_down" +#define SENSOR_TYPE_SHAKE (30) +#define SENSOR_STRING_TYPE_SHAKE "android.sensor.shake" +#define SENSOR_TYPE_BRINGTOSEE (31) +#define SENSOR_STRING_TYPE_BRINGTOSEE "android.sensor.bring_to_see" + +/*---------------------------------------------------------------------------*/ +#define ID_BASE 0 +#define ID_ORIENTATION (ID_BASE+SENSOR_TYPE_ORIENTATION-1) +#define ID_MAGNETIC (ID_BASE+SENSOR_TYPE_MAGNETIC_FIELD-1) +#define ID_ACCELEROMETER (ID_BASE+SENSOR_TYPE_ACCELEROMETER-1) +#define ID_LINEAR_ACCELERATION (ID_BASE+SENSOR_TYPE_LINEAR_ACCELERATION-1) +#define ID_ROTATION_VECTOR (ID_BASE+SENSOR_TYPE_ROTATION_VECTOR-1) +#define ID_GAME_ROTATION_VECTOR (ID_BASE+SENSOR_TYPE_GAME_ROTATION_VECTOR-1) +#define ID_GRAVITY (ID_BASE+SENSOR_TYPE_GRAVITY-1) +#define ID_GYROSCOPE (ID_BASE+SENSOR_TYPE_GYROSCOPE-1) +#define ID_PROXIMITY (ID_BASE+SENSOR_TYPE_PROXIMITY-1) +#define ID_LIGHT (ID_BASE+SENSOR_TYPE_LIGHT-1) +#define ID_PRESSURE (ID_BASE+SENSOR_TYPE_PRESSURE-1) +#define ID_TEMPRERATURE (ID_BASE+SENSOR_TYPE_TEMPERATURE-1) +#define ID_HUMIDITY (ID_BASE+SENSOR_TYPE_HUMIDITY-1) +#define ID_SIGNIFICANT_MOTION (ID_BASE+SENSOR_TYPE_SIGNIFICANT_MOTION-1) +#define ID_STEP_DETECTOR (ID_BASE+SENSOR_TYPE_STEP_DETECTOR-1) +#define ID_STEP_COUNTER (ID_BASE+SENSOR_TYPE_STEP_COUNTER-1) +#define ID_GEOMAGNETIC_ROTATION_VECTOR (ID_BASE+SENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR-1) +#define ID_HEART_RATE (ID_BASE+SENSOR_TYPE_HEART_RATE-1) +#define ID_TILT_DETECTOR (ID_BASE+SENSOR_TYPE_TILT_DETECTOR-1) +#define ID_WAKE_GESTURE (ID_BASE+SENSOR_TYPE_WAKE_GESTURE-1) +#define ID_GLANCE_GESTURE (ID_BASE+SENSOR_TYPE_GLANCE_GESTURE-1) +#define ID_PICK_UP_GESTURE (ID_BASE+SENSOR_TYPE_PICK_UP_GESTURE-1) +#define ID_PEDOMETER (ID_BASE+SENSOR_TYPE_PEDOMETER-1) +#define ID_ACTIVITY (ID_BASE+SENSOR_TYPE_ACTIVITY-1) +#define ID_IN_POCKET (ID_BASE+SENSOR_TYPE_IN_POCKET-1) +#define ID_FACE_DOWN (ID_BASE+SENSOR_TYPE_FACE_DOWN-1) +#define ID_SHAKE (ID_BASE+SENSOR_TYPE_SHAKE-1) +#define ID_BRINGTOSEE (ID_BASE+SENSOR_TYPE_BRINGTOSEE-1) +#define ID_SENSOR_MAX_HANDLE (ID_BASE+SENSOR_TYPE_BRINGTOSEE) +#define ID_NONE (ID_SENSOR_MAX_HANDLE+1) + +#define ID_OFFSET (1) + +#define MAX_ANDROID_SENSOR_NUM (ID_SENSOR_MAX_HANDLE +1) +#define MAX_SENSOR_DATA_UPDATE_ONCE (20) + +/*---------------------------------------------------------------------------*/ +#define SENSOR_ORIENTATION (1 << ID_ORIENTATION) +#define SENSOR_MAGNETIC (1 << ID_MAGNETIC) +#define SENSOR_ACCELEROMETER (1 << ID_ACCELEROMETER) +#define SENSOR_GYROSCOPE (1 << ID_GYROSCOPE) +#define SENSOR_PROXIMITY (1 << ID_PROXIMITY) +#define SENSOR_LIGHT (1 << ID_LIGHT) +#define SENSOR_PRESSURE (1 << ID_PRESSURE) +#define SENSOR_TEMPRERATURE (1 << ID_TEMPRERATURE) +#define SENSOR_GRAVITY (1 << ID_GRAVITY) +#define SENSOR_LINEAR_ACCELERATION (1 << ID_LINEAR_ACCELERATION) +#define SENSOR_ROTATION_VECTOR (1 << ID_ROTATION_VECTOR) + +#define SENSOR_SIGNIFICANT_MOTION (1 << ID_SIGNIFICANT_MOTION) +#define SENSOR_STEP_DETECTOR (1 << ID_STEP_DETECTOR) +#define SENSOR_STEP_COUNTER (1 << ID_STEP_COUNTER) +#define SENSOR_GEOMAGNETIC_ROTATION_VECTOR (1 << ID_GEOMAGNETIC_ROTATION_VECTOR) + +#define SENSOR_HEART_RATE (1 << ID_HEART_RATE) +#define SENSOR_TILT_DETECTOR (1 << ID_TILT_DETECTOR) +#define SENSOR_WAKE_GESTURE (1 << ID_WAKE_GESTURE) +#define SENSOR_GLANCE_GESTURE (1 << ID_GLANCE_GESTURE) +#define SENSOR_PICK_UP_GESTURE (1 << ID_PICK_UP_GESTURE) + +#define SENSOR_PEDOMETER (1 << ID_PEDOMETER) +#define SENSOR_IN_POCKET (1 << ID_IN_POCKET) +#define SENSOR_ACTIVITY (1 << ID_ACTIVITY) +#define SENSOR_FACE_DOWN (1 << ID_FACE_DOWN) +#define SENSOR_SHAKE (1 << ID_SHAKE) +#define SENSOR_BRINGTOSEE (1 << ID_BRINGTOSEE) + +/*----------------------------------------------------------------------------*/ +#define HWM_INPUTDEV_NAME "hwmdata" +#define HWM_SENSOR_DEV_NAME "hwmsensor" +#define HWM_SENSOR_DEV "/dev/hwmsensor" +#define C_MAX_HWMSEN_EVENT_NUM 4 +/*----------------------------------------------------------------------------*/ +#define ACC_PL_DEV_NAME "m_acc_pl" +#define ACC_INPUTDEV_NAME "m_acc_input" +#define ACC_MISC_DEV_NAME "m_acc_misc" +#define MAG_PL_DEV_NAME "m_mag_pl" +#define MAG_INPUTDEV_NAME "m_mag_input" +#define MAG_MISC_DEV_NAME "m_mag_misc" +#define GYRO_PL_DEV_NAME "m_gyro_pl" +#define GYRO_INPUTDEV_NAME "m_gyro_input" +#define GYRO_MISC_DEV_NAME "m_gyro_misc" +#define ALSPS_PL_DEV_NAME "m_alsps_pl" +#define ALSPS_INPUTDEV_NAME "m_alsps_input" +#define ALSPS_MISC_DEV_NAME "m_alsps_misc" +#define BARO_PL_DEV_NAME "m_baro_pl" +#define BARO_INPUTDEV_NAME "m_baro_input" +#define BARO_MISC_DEV_NAME "m_baro_misc" + +#define STEP_C_PL_DEV_NAME "m_step_c_pl" +#define STEP_C_INPUTDEV_NAME "m_step_c_input" +#define STEP_C_MISC_DEV_NAME "m_step_c_misc" + +#define INPK_PL_DEV_NAME "m_inpk_pl" +#define INPK_INPUTDEV_NAME "m_inpk_input" +#define INPK_MISC_DEV_NAME "m_inpk_misc" + +#define SHK_PL_DEV_NAME "m_shk_pl" +#define SHK_INPUTDEV_NAME "m_shk_input" +#define SHK_MISC_DEV_NAME "m_shk_misc" + +#define FDN_PL_DEV_NAME "m_fdn_pl" +#define FDN_INPUTDEV_NAME "m_fdn_input" +#define FDN_MISC_DEV_NAME "m_fdn_misc" + +#define PKUP_PL_DEV_NAME "m_pkup_pl" +#define PKUP_INPUTDEV_NAME "m_pkup_input" +#define PKUP_MISC_DEV_NAME "m_pkup_misc" + +#define ACT_PL_DEV_NAME "m_act_pl" +#define ACT_INPUTDEV_NAME "m_act_input" +#define ACT_MISC_DEV_NAME "m_act_misc" + +#define PDR_PL_DEV_NAME "m_pdr_pl" +#define PDR_INPUTDEV_NAME "m_pdr_input" +#define PDR_MISC_DEV_NAME "m_pdr_misc" + +#define HRM_PL_DEV_NAME "m_hrm_pl" +#define HRM_INPUTDEV_NAME "m_hrm_input" +#define HRM_MISC_DEV_NAME "m_hrm_misc" + +#define TILT_PL_DEV_NAME "m_tilt_pl" +#define TILT_INPUTDEV_NAME "m_tilt_input" +#define TILT_MISC_DEV_NAME "m_tilt_misc" + +#define WAG_PL_DEV_NAME "m_wag_pl" +#define WAG_INPUTDEV_NAME "m_wag_input" +#define WAG_MISC_DEV_NAME "m_wag_misc" + +#define GLG_PL_DEV_NAME "m_glg_pl" +#define GLG_INPUTDEV_NAME "m_glg_input" +#define GLG_MISC_DEV_NAME "m_glg_misc" + +#define TEMP_PL_DEV_NAME "m_temp_pl" +#define TEMP_INPUTDEV_NAME "m_temp_input" +#define TEMP_MISC_DEV_NAME "m_temp_misc" + +#define BATCH_PL_DEV_NAME "m_batch_pl" +#define BATCH_INPUTDEV_NAME "m_batch_input" +#define BATCH_MISC_DEV_NAME "m_batch_misc" + +#define BTS_PL_DEV_NAME "m_bts_pl" +#define BTS_INPUTDEV_NAME "m_bts_input" +#define BTS_MISC_DEV_NAME "m_bts_misc" + +#define GRV_PL_DEV_NAME "m_grv_pl" +#define GRV_INPUTDEV_NAME "m_grv_input" +#define GRV_MISC_DEV_NAME "m_grv_misc" + +#define GMRV_PL_DEV_NAME "m_gmrv_pl" +#define GMRV_INPUTDEV_NAME "m_gmrv_input" +#define GMRV_MISC_DEV_NAME "m_gmrv_misc" + +#define GRAV_PL_DEV_NAME "m_grav_pl" +#define GRAV_INPUTDEV_NAME "m_grav_input" +#define GRAV_MISC_DEV_NAME "m_grav_misc" + +#define LA_PL_DEV_NAME "m_la_pl" +#define LA_INPUTDEV_NAME "m_la_input" +#define LA_MISC_DEV_NAME "m_la_misc" + +#define RV_PL_DEV_NAME "m_rv_pl" +#define RV_INPUTDEV_NAME "m_rv_input" +#define RV_MISC_DEV_NAME "m_rv_misc" + +#define EVENT_TYPE_SENSOR 0x01 +#define EVENT_TYPE_SENSOR_EXT 0x02 +#define EVENT_SENSOR_ACCELERATION SENSOR_ACCELEROMETER +#define EVENT_SENSOR_MAGNETIC SENSOR_MAGNETIC +#define EVENT_SENSOR_ORIENTATION SENSOR_ORIENTATION +#define EVENT_SENSOR_GYROSCOPE SENSOR_GYROSCOPE +#define EVENT_SENSOR_LIGHT SENSOR_LIGHT +#define EVENT_SENSOR_PRESSURE SENSOR_PRESSURE +#define EVENT_SENSOR_TEMPERATURE SENSOR_TEMPRERATURE +#define EVENT_SENSOR_PROXIMITY SENSOR_PROXIMITY +#define EVENT_SENSOR_GRAVITY SENSOR_PRESSURE +#define EVENT_SENSOR_LINEAR_ACCELERATION SENSOR_TEMPRERATURE +#define EVENT_SENSOR_ROTATION_VECTOR SENSOR_PROXIMITY +/*-----------------------------------------------------------------------------*/ + +enum { + HWM_MODE_DISABLE = 0, + HWM_MODE_ENABLE = 1, +}; + +/*------------sensors data----------------------------------------------------*/ +typedef struct { + /* sensor identifier */ + int sensor; + /* sensor values */ + int values[6]; + /* sensor values divide */ + uint32_t value_divide; + /* sensor accuracy*/ + int8_t status; + /* whether updata? */ + int update; + /* time is in nanosecond */ + int64_t time; + + uint32_t reserved; +}hwm_sensor_data; + +typedef struct { + hwm_sensor_data data[MAX_SENSOR_DATA_UPDATE_ONCE]; + uint64_t data_type; +}hwm_trans_data; + +#define MAX_BATCH_DATA_PER_QUREY 18 +typedef struct { + int numOfDataReturn; + int numOfDataLeft; + hwm_sensor_data data[MAX_BATCH_DATA_PER_QUREY]; +}batch_trans_data; + +/*----------------------------------------------------------------------------*/ +#define HWM_IOC_MAGIC 0x91 + +/* set delay */ +#define HWM_IO_SET_DELAY _IOW(HWM_IOC_MAGIC, 0x01, uint32_t) + +/* wake up */ +#define HWM_IO_SET_WAKE _IO(HWM_IOC_MAGIC, 0x02) + +/* Enable/Disable sensor */ +#define HWM_IO_ENABLE_SENSOR _IOW(HWM_IOC_MAGIC, 0x03, uint32_t) +#define HWM_IO_DISABLE_SENSOR _IOW(HWM_IOC_MAGIC, 0x04, uint32_t) + +/* Enable/Disable sensor */ +#define HWM_IO_ENABLE_SENSOR_NODATA _IOW(HWM_IOC_MAGIC, 0x05, uint32_t) +#define HWM_IO_DISABLE_SENSOR_NODATA _IOW(HWM_IOC_MAGIC, 0x06, uint32_t) +/* Get sensors data */ +#define HWM_IO_GET_SENSORS_DATA _IOWR(HWM_IOC_MAGIC, 0x07, hwm_trans_data) + +/*----------------------------------------------------------------------------*/ +#define BATCH_IOC_MAGIC 0x92 + +/* Get sensor data */ +#define BATCH_IO_GET_SENSORS_DATA _IOWR(BATCH_IOC_MAGIC, 0x01, batch_trans_data) + +#endif // __HWMSENSOR_H__ diff --git a/kernel-headers/linux/ion_debugger.h b/kernel-headers/linux/ion_debugger.h new file mode 100644 index 0000000..e396839 --- /dev/null +++ b/kernel-headers/linux/ion_debugger.h @@ -0,0 +1,193 @@ +#ifndef ION_DEBUGGER_DEF +#define ION_DEBUGGER_DEF +#define BACKTRACE_SIZE 10 +//#include <linux/mutex.h> +typedef enum +{ + ION_FUNCTION_OPEN, + ION_FUNCTION_CLOSE, + ION_FUNCTION_CREATE_CLIENT, + ION_FUNCTION_DESTROY_CLIENT, + ION_FUNCTION_ALLOC, + ION_FUNCTION_ALLOC_MM, + ION_FUNCTION_ALLOC_CONT, + ION_FUNCTION_FREE, + ION_FUNCTION_IMPORT, + ION_FUNCTION_MMAP, + ION_FUNCTION_MUNMAP, + ION_FUNCTION_SHARE, + ION_FUNCTION_SHARE_CLOSE +}ION_FUNCTION_TYPE; + +typedef enum +{ + BUFFER_ALLOCATION_LIST, + BUFFER_FREE_LIST, + ADDRESS_ALLOCATION_LIST, + ADDRESS_FREE_LIST, + FD_ALLOCATION_LIST, + FD_FREE_LIST +}ION_DEBUGGER_LIST_TYPE; +typedef enum +{ + ADDRESS_USER_VIRTUAL, + ADDRESS_KERNEL_VIRTUAL, + ADDRESS_KERNEL_PHYSICAL, + ADDRESS_MAX +}ION_MAPPING_ADDRESS_TYPE; +typedef enum +{ + RECORD_ID, + RECORD_CLIENT, + RECORD_HANDLE, + RECORD_ALLOCATE_BACKTRACE_NUM, + RECORD_FREED_BACKTRACE_NUM, + RECORD_ALLOCATE_MAPPING_NUM, + RECORD_FREED_MAPPING_NUM, + RECORD_FD, + RECORD_ADDRESS, + RECORD_SIZE, + RECORD_NEXT +}ION_DEBUGGDER_RECORD_DATA; +typedef enum +{ + SEARCH_PID, + SEARCH_PID_CLIENT, + SEARCH_PROCESS_PID, + SEARCH_BUFFER, + SEARCH_MAX +}ION_SEARCH_METHOD; +typedef enum +{ + LIST_BUFFER, + LIST_PROCESS, + NODE_BUFFER, + NODE_FD, + NODE_CLIENT, + NODE_MMAP, + NODE_MAX +}ION_RECORD_TYPE; +typedef enum +{ + HASH_NODE_CLIENT, + HASH_NODE_HANDLE, + HASH_NODE_BUFFER, + HASH_NODE_USER_BACKTRACE, + HASH_NODE_KERNEL_BACKTRACE, + HASH_NODE_USER_MAPPING, + HASH_NODE_KERNEL_SYMBOL, + HASH_NODE_MAX +}ION_HASH_NODE_TYPE; +typedef enum +{ + ALLOCATE_BACKTRACE_INFO, + RELEASE_BACKTRACE_INFO, + KERNEL_BACKTRACE, + USER_BACKTRACE, + BACKTRACE_MAX +}BACKTRACE_INFO; +struct mapping +{ + char *name; + unsigned int address; + unsigned int size; +}; +typedef struct ion_sys_record_param +{ + pid_t group_id; + pid_t pid; + unsigned int action; + unsigned int address_type; + unsigned int address; + unsigned int length; + unsigned int backtrace[BACKTRACE_SIZE]; + unsigned int kernel_symbol[BACKTRACE_SIZE]; + struct mapping mapping_record[BACKTRACE_SIZE]; + unsigned int backtrace_num; + struct ion_handle *handle; + struct ion_client *client; + struct ion_buffer *buffer; + int fd; +}ion_sys_record_t; + +typedef struct ion_record_ID +{ + pid_t pid; + pid_t group_pid; + unsigned int client_address; + struct ion_client *client; + union{ + struct ion_buffer_record *buffer; + struct ion_process_record *process_record; +}; +}ion_record_ID_t; +typedef struct ion_record_basic_info +{ + struct ion_record_ID recordID; + unsigned int record_type; + unsigned int from_kernel; + unsigned int allocate_backtrace_type; + unsigned int *allocate_backtrace; + unsigned int *allocate_map; + unsigned int release_backtrace_type; + unsigned int *release_backtrace; + unsigned int *release_map; +}ion_record_basic_info_t; +typedef struct ion_buffer_usage_record +{ + struct ion_buffer_usage_record *next; + struct ion_record_basic_info tracking_info; + struct ion_handle *handle; + unsigned int function_type; +}ion_buffer_usage_record_t; +typedef struct ion_address_usage_record +{ + struct ion_address_usage_record *next; + struct ion_record_basic_info tracking_info; + unsigned int address_type; + unsigned int mapping_address; + unsigned int size; + int fd; + struct ion_buffer *buffer; +}ion_address_usage_record_t; +typedef struct ion_fd_usage_record +{ + struct ion_fd_usage_reocrd *next; + struct ion_record_basic_info tracking_info; + int fd; + struct ion_handle *handle; + struct ion_buffer *buffer; +}ion_fd_usage_record_t; + +typedef struct ion_client_usage_record +{ + struct ion_client_usage_recrod *next; + struct ion_record_basic_info tracking_info; + int fd; +}ion_client_usage_record_t; +#if 0 +struct ion_buffer_record +{ + struct ion_buffer_record *next; + struct ion_buffer *buffer; + unsigned int heap_type; + union{ + void *priv_virt; + unsigned long priv_phys; + }; + struct ion_buffer_usage_record *buffer_using_list; + struct ion_buffer_usage_record *buffer_freed_list; + struct mutex ion_buffer_usage_mutex; + struct ion_address_usage_record *address_using_list; + struct ion_address_usage_record *address_freed_list; + struct mutex ion_address_usage_mutex; + struct ion_fd_usage_record *fd_using_list; + struct ion_fd_usage_record *fd_freed_list; + struct mutex ion_fd_usage_mutex; +}; +extern void *ion_get_list(struct ion_buffer_record *buffer, unsigned int list_type); +extern struct ion_buffer_usage_record *ion_get_inuse_buffer_record(); +extern struct ion_buffer_usage_record *ion_get_freed_buffer_record(); +extern unsigned int ion_get_data_from_record(void *record,unsigned int data_type); +#endif +#endif diff --git a/kernel-headers/linux/ion_drv.h b/kernel-headers/linux/ion_drv.h new file mode 100644 index 0000000..970d0ff --- /dev/null +++ b/kernel-headers/linux/ion_drv.h @@ -0,0 +1,169 @@ +#ifndef __ION_DRV_H__ +#define __ION_DRV_H__ +#include <linux/ion.h> + +#define BACKTRACE_SIZE 10 + +/* Structure definitions */ + +typedef enum { + ION_CMD_SYSTEM, + ION_CMD_MULTIMEDIA, +} ION_CMDS; + +typedef enum { + ION_MM_CONFIG_BUFFER, + ION_MM_SET_DEBUG_INFO, + ION_MM_GET_DEBUG_INFO, + ION_MM_SET_SF_BUF_INFO, + ION_MM_GET_SF_BUF_INFO +} ION_MM_CMDS; + +typedef enum { + ION_SYS_CACHE_SYNC, + ION_SYS_GET_PHYS, + ION_SYS_GET_CLIENT, + ION_SYS_SET_HANDLE_BACKTRACE, + ION_SYS_SET_CLIENT_NAME, + ION_SYS_DMA_OP, +} ION_SYS_CMDS; + +typedef enum { + ION_CACHE_CLEAN_BY_RANGE, + ION_CACHE_INVALID_BY_RANGE, + ION_CACHE_FLUSH_BY_RANGE, + ION_CACHE_CLEAN_BY_RANGE_USE_VA, + ION_CACHE_INVALID_BY_RANGE_USE_VA, + ION_CACHE_FLUSH_BY_RANGE_USE_VA, + ION_CACHE_CLEAN_ALL, + ION_CACHE_INVALID_ALL, + ION_CACHE_FLUSH_ALL +} ION_CACHE_SYNC_TYPE; + +typedef enum { + ION_ERROR_CONFIG_LOCKED = 0x10000 +} ION_ERROR_E; + +typedef struct ion_sys_cache_sync_param { + union { + ion_user_handle_t handle; + void *kernel_handle; + }; + void *va; + unsigned int size; + ION_CACHE_SYNC_TYPE sync_type; +} ion_sys_cache_sync_param_t; + +typedef enum { + ION_DMA_MAP_AREA, + ION_DMA_UNMAP_AREA, + ION_DMA_MAP_AREA_VA, + ION_DMA_UNMAP_AREA_VA, + ION_DMA_CACHE_FLUSH_ALL +} ION_DMA_TYPE; + +typedef enum { + ION_DMA_FROM_DEVICE, + ION_DMA_TO_DEVICE, + ION_DMA_BIDIRECTIONAL, +} ION_DMA_DIR; + +typedef struct ion_dma_param { + union { + ion_user_handle_t handle; + void *kernel_handle; + }; + void *va; + unsigned int size; + ION_DMA_TYPE dma_type; + ION_DMA_DIR dma_dir; +} ion_sys_dma_param_t; + +typedef struct ion_sys_get_phys_param { + union { + ion_user_handle_t handle; + void *kernel_handle; + }; + unsigned int phy_addr; + unsigned long len; +} ion_sys_get_phys_param_t; + +#define ION_MM_DBG_NAME_LEN 16 +#define ION_MM_SF_BUF_INFO_LEN 16 + +typedef struct __ion_sys_client_name { + char name[ION_MM_DBG_NAME_LEN]; +} ion_sys_client_name_t; + +typedef struct ion_sys_get_client_param { + unsigned int client; +} ion_sys_get_client_param_t; + +typedef struct ion_sys_record_param { + pid_t group_id; + pid_t pid; + unsigned int action; + unsigned int address_type; + unsigned int address; + unsigned int length; + unsigned int backtrace[BACKTRACE_SIZE]; + unsigned int backtrace_num; + struct ion_handle *handle; + struct ion_client *client; + struct ion_buffer *buffer; + struct file *file; + int fd; +} ion_sys_record_t; + +typedef struct ion_sys_data { + ION_SYS_CMDS sys_cmd; + union { + ion_sys_cache_sync_param_t cache_sync_param; + ion_sys_get_phys_param_t get_phys_param; + ion_sys_get_client_param_t get_client_param; + ion_sys_client_name_t client_name_param; + ion_sys_record_t record_param; + ion_sys_dma_param_t dma_param; + }; +} ion_sys_data_t; + +typedef struct ion_mm_config_buffer_param { + union { + ion_user_handle_t handle; + void *kernel_handle; + }; + int eModuleID; + unsigned int security; + unsigned int coherent; +} ion_mm_config_buffer_param_t; + +typedef struct __ion_mm_buf_debug_info { + union { + ion_user_handle_t handle; + void *kernel_handle; + }; + char dbg_name[ION_MM_DBG_NAME_LEN]; + unsigned int value1; + unsigned int value2; + unsigned int value3; + unsigned int value4; +} ion_mm_buf_debug_info_t; + +typedef struct __ion_mm_sf_buf_info { + union { + ion_user_handle_t handle; + void *kernel_handle; + }; + unsigned int info[ION_MM_SF_BUF_INFO_LEN]; +} ion_mm_sf_buf_info_t; + +typedef struct ion_mm_data { + ION_MM_CMDS mm_cmd; + union { + ion_mm_config_buffer_param_t config_buffer_param; + ion_mm_buf_debug_info_t buf_debug_info_param; + ion_mm_sf_buf_info_t sf_buf_info_param; + }; +} ion_mm_data_t; + +#endif diff --git a/kernel-headers/linux/kpd.h b/kernel-headers/linux/kpd.h new file mode 100644 index 0000000..7eb1728 --- /dev/null +++ b/kernel-headers/linux/kpd.h @@ -0,0 +1,46 @@ +#ifndef KPD_IO_H +#define KPD_IO_H + +#include <linux/ioctl.h> + +struct kpd_ledctl { + int onoff; + int div; /* 0 ~ 15 */ + int duty; /* 0 ~ 31 */ +}; + +#if 0 +#define PRESS_OK_KEY _IO('k', 1) +#define RELEASE_OK_KEY _IO('k', 2) +#define PRESS_MENU_KEY _IO('k', 3) +#define RELEASE_MENU_KEY _IO('k', 4) +#define PRESS_UP_KEY _IO('k', 5) +#define RELEASE_UP_KEY _IO('k', 6) +#define PRESS_DOWN_KEY _IO('k', 7) +#define RELEASE_DOWN_KEY _IO('k', 8) +#define PRESS_LEFT_KEY _IO('k', 9) +#define RELEASE_LEFT_KEY _IO('k', 10) +#define PRESS_RIGHT_KEY _IO('k', 11) +#define RELEASE_RIGHT_KEY _IO('k', 12) +#define PRESS_HOME_KEY _IO('k', 13) +#define RELEASE_HOME_KEY _IO('k', 14) +#define PRESS_BACK_KEY _IO('k', 15) +#define RELEASE_BACK_KEY _IO('k', 16) +#define PRESS_CALL_KEY _IO('k', 17) +#define RELEASE_CALL_KEY _IO('k', 18) +#define PRESS_ENDCALL_KEY _IO('k', 19) +#define RELEASE_ENDCALL_KEY _IO('k', 20) +#define PRESS_VLUP_KEY _IO('k', 21) +#define RELEASE_VLUP_KEY _IO('k', 22) +#define PRESS_VLDOWN_KEY _IO('k', 23) +#define RELEASE_VLDOWN_KEY _IO('k', 24) +#define PRESS_FOCUS_KEY _IO('k', 25) +#define RELEASE_FOCUS_KEY _IO('k', 26) +#define PRESS_CAMERA_KEY _IO('k', 27) +#define RELEASE_CAMERA_KEY _IO('k', 28) +#endif +#define SET_KPD_BACKLIGHT _IOW('k', 29, struct kpd_ledctl) +#define SET_KPD_KCOL _IO('k', 29) + + +#endif diff --git a/kernel-headers/linux/libmtk_cipher_export.h b/kernel-headers/linux/libmtk_cipher_export.h new file mode 100644 index 0000000..34a85d3 --- /dev/null +++ b/kernel-headers/linux/libmtk_cipher_export.h @@ -0,0 +1,86 @@ +#ifndef _LIBMTK_CIPHER_EXPORT_H +#define _LIBMTK_CIPHER_EXPORT_H + +#define HEVC_BLK_LEN (20480) // bytes +#define HEVC_MOD "HEVC_MOD" +#define HEVC_NANO 1000000000ULL +#define HEVC_CIPHER_LEN (102400) // bytes + + +typedef struct +{ + unsigned char buf[HEVC_BLK_LEN]; + unsigned int len; +} HEVC_BLK; + +typedef enum +{ + VIDEO_ENCRYPT_CODEC_NONE = 0x0, + VIDEO_ENCRYPT_CODEC_HEVC_ENC = 0x1, + VIDEO_ENCRYPT_CODEC_HEVC_DEC = 0x2, + VIDEO_ENCRYPT_CODEC_MAX = 0xffffffff +} VIDEO_ENCRYPT_CODEC_T; + + +typedef int (*hevc_api_funp)(HEVC_BLK *p_hevc_blk); +typedef int (*hevc_api_initk_funp)(unsigned char *key, unsigned int klen); + + +#define SEC_OK 0x0 +#define SEC_FAIL 0x1 + +/* HEVC shared lib*/ +#define ERR_HEVC_NOT_CORRECT_MODE 0x10000 +#define ERR_HEVC_DATA_NOT_ALIGNED 0x10001 +#define ERR_HEVC_ENC_IOCTL_FAIL 0x10002 +#define ERR_HEVC_DEC_IOCTL_FAIL 0x10002 +#define ERR_HEVC_CIPHER_UT_FAIL 0x10003 +#define ERR_HEVC_DATA_IS_NULL 0x10004 +#define ERR_HEVC_DATA_LENGTH_NOT_VALID 0x10005 +#define ERR_HEVC_SW_ENC_ERROR 0x10006 +#define ERR_HEVC_SW_DEC_ERROR 0x10007 +#define ERR_HEVC_INIT_SW_KEY_ERROR 0x10008 + + +/* HEVC sample*/ +#define ERR_HEVC_CIPHER_LIB_NOT_FOUND 0x20001 +#define ERR_HEVC_SW_DEC_BLOCK_SYM_NOT_FOUND 0x20002 +#define ERR_HEVC_HW_ENC_BLOCK_SYM_NOT_FOUND 0x20003 +#define ERR_HEVC_INIT_SW_KEY_SYM_NOT_FOUND 0x20004 +#define ERR_HEVC_INPUT_FILE_NOT_FOUND 0x20005 +#define ERR_HEVC_OUTPUT_FILE_NOT_FOUND 0x20006 +#define ERR_HEVC_SW_DEC_FILE_SYM_NOT_FOUND 0x20007 +#define ERR_HEVC_SW_DEC_FILE_FAILED 0x20008 +#define ERR_HEVC_UNKNOWN 0x2FFFF + + +/* Define LOG LEVEL*/ +#define SEC_LOG_TRACE 0 //For source code trace +#define SEC_LOG_DEBUG 0 //For debug purpose +#define SEC_LOG_ERROR 1 //For critical error dump +#define SEC_LOG_INFO 1 //For information to know when processing in normal + +/* DEBUG MACRO */ +#define SMSG_TRACE(...) \ + do { if (SEC_LOG_TRACE) printf(__VA_ARGS__); } while (0) + +#define SMSG_DEBUG(...) \ + do { if (SEC_LOG_DEBUG) printf(__VA_ARGS__); } while (0) + +#define SMSG_ERROR(...) \ + do { if (SEC_LOG_ERROR) printf(__VA_ARGS__); } while (0) + +#define SMSG_INFO(...) \ + do { if (SEC_LOG_INFO) printf(__VA_ARGS__); } while (0) + + +#define HEVC_ENCRYTP_FILE_PATH "/data/mediaserver" +#define HEVC_ENC_SW_ENCRYPT_FILE_PATH "/system/lib/libhevce_sb.ca7.android.so" +#define HEVC_ENC_HW_ENCRYPT_FILE_PATH "/data/mediaserver/sb.ca7.android_hwenc.so" +#define HEVC_ENC_HW_DECRYPT_FILE_PATH "/data/mediaserver/sb.ca7.android_hwdec.so" +#define HEVC_DEC_SW_ENCRYTP_FILE_PATH "/system/lib/libHEVCdec_sa.ca7.android.so" +#define HEVC_DEC_HW_ENCRYPT_FILE_PATH "/data/mediaserver/dec_sa.ca7.android_hwenc.so" +#define HEVC_DEC_HW_DECRYPT_FILE_PATH "/data/mediaserver/dec_sa.ca7.android_hwdec.so" + +#endif /*_LIBMTK_CIPHER_EXPORT_H*/ + diff --git a/kernel-headers/linux/matv.h b/kernel-headers/linux/matv.h new file mode 100644 index 0000000..dcae5a7 --- /dev/null +++ b/kernel-headers/linux/matv.h @@ -0,0 +1,58 @@ +#ifndef __MATV_H__ +#define __MATV_H__ + +#include <linux/init.h> +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/types.h> +#include <linux/device.h> +#include <linux/kdev_t.h> +#include <linux/fs.h> +#include <linux/cdev.h> +#include <linux/platform_device.h> +#include <linux/dma-mapping.h> +#include <linux/mm_types.h> +#include <linux/mm.h> +#include <linux/jiffies.h> +#include <linux/sched.h> +#include <asm/uaccess.h> +#include <linux/vmalloc.h> +#include <linux/interrupt.h> +#include <mach/irqs.h> +#include <linux/wait.h> +#include <linux/spinlock.h> +#include <linux/delay.h> +#include <linux/semaphore.h> +#include <linux/platform_device.h> +#include <linux/i2c.h> +#include <linux/slab.h> +#include <linux/xlog.h> + +#include "cust_matv.h" + + + +#define MATV_DEVNAME "MATV" +#define MATV_IOC_MAGIC 'a' + +//below is control message +#define TEST_MATV_PRINT _IO(MATV_IOC_MAGIC, 0x00) +#define MATV_READ _IOW(MATV_IOC_MAGIC, 0x01, unsigned int) +#define MATV_WRITE _IOW(MATV_IOC_MAGIC, 0x02, unsigned int) +#define MATV_SET_PWR _IOW(MATV_IOC_MAGIC, 0x03, unsigned int) +#define MATV_SET_RST _IOW(MATV_IOC_MAGIC, 0x04, unsigned int) +#define MATV_SET_STRAP _IOW(MATV_IOC_MAGIC, 0x05, unsigned int) +#define MATV_SLEEP _IOW(MATV_IOC_MAGIC, 0x06, unsigned int) +#define MATV_SET_TP_MODE _IOW(MATV_IOC_MAGIC, 0x07, unsigned int) + +typedef struct matv_i2s_info +{ + int status; + int mode; + int rate; +} matv_i2s_info_t; + +#define MATV_QUERY_I2S_INFO _IOW(MATV_IOC_MAGIC, 0x08, struct matv_i2s_info*) + + +#endif //__MATV_H__ diff --git a/kernel-headers/linux/mman-proprietary.h b/kernel-headers/linux/mman-proprietary.h new file mode 100644 index 0000000..c989967 --- /dev/null +++ b/kernel-headers/linux/mman-proprietary.h @@ -0,0 +1,21 @@ +/* +* Copyright (C) 2011-2014 MediaTek Inc. +* +* 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 __MM_PROPRIETARY_H__ + +#define PROT_NOCACHE 0x10 + +#endif diff --git a/kernel-headers/linux/mmc/sd_misc.h b/kernel-headers/linux/mmc/sd_misc.h new file mode 100644 index 0000000..0668273 --- /dev/null +++ b/kernel-headers/linux/mmc/sd_misc.h @@ -0,0 +1,201 @@ +#ifndef SD_MISC_H +#define SD_MISC_H + +#ifdef __KERNEL__ +#include <linux/bitops.h> +#include <linux/mmc/host.h> +#include <linux/mmc/card.h> +#include <linux/mmc/core.h> +#include <linux/mmc/mmc.h> +#include <linux/mmc/sd.h> +#endif + + + +struct msdc_ioctl { + int opcode; + int host_num; + int iswrite; + int trans_type; + unsigned int total_size; + unsigned int address; + unsigned int *buffer; + int cmd_pu_driving; + int cmd_pd_driving; + int dat_pu_driving; + int dat_pd_driving; + int clk_pu_driving; + int clk_pd_driving; + int ds_pu_driving; + int ds_pd_driving; + int rst_pu_driving; + int rst_pd_driving; + int clock_freq; + int partition; + int hopping_bit; + int hopping_time; + int result; + int sd30_mode; + int sd30_max_current; + int sd30_drive; + int sd30_power_control; +}; + +/**************for msdc_ssc***********************/ +#define AUDPLL_CTL_REG12 (0xF0007070) +#define AUDPLL_CTL_REG01 (0xF00071E0) +#define AUDPLL_CTL_REG02 (0xF100000C) + +#define AUDPLL_TSEL_MASK (1792) /* MASK = 00000111 00000000 */ +#define AUDPLL_TSEL_RESULT1 (0) /* REG = 00000000 00000000 30.5us */ +#define AUDPLL_TSEL_RESULT2 (256) /* REG = 00000001 00000000 61.0us */ +#define AUDPLL_TSEL_RESULT3 (512) /* REG = 00000010 00000000 122.1us */ +#define AUDPLL_TSEL_RESULT4 (768) /* REG = 00000011 00000000 244.1us */ +#define AUDPLL_TSEL_RESULT5 (1024) /* REG = 00000100 00000000 448.3us */ + +#define AUDPLL_BSEL_MASK (7) /* MASK = 00000000 00000111 */ +#define AUDPLL_BSEL_RESULT0 (0) /* REG = 00000000 00000000 REG init val */ +#define AUDPLL_BSEL_RESULT1 (1) /* REG = 00000000 00000001 2.26MHz */ +#define AUDPLL_BSEL_RESULT2 (2) /* REG = 00000000 00000010 4.52MHz */ +#define AUDPLL_BSEL_RESULT3 (4) /* REG = 00000000 00000100 9.04MHz */ + +#define SET_HOP_BIT_NONE (0) +#define SET_HOP_BIT1 (1) +#define SET_HOP_BIT2 (2) +#define SET_HOP_BIT3 (3) + +#define SET_HOP_TIME0 (0) +#define SET_HOP_TIME1 (1) +#define SET_HOP_TIME2 (2) +#define SET_HOP_TIME3 (3) +#define SET_HOP_TIME4 (4) + + +/**************for msdc_ssc***********************/ + +#define MSDC_DRIVING_SETTING (0) +#define MSDC_CLOCK_FREQUENCY (1) +#define MSDC_SINGLE_READ_WRITE (2) +#define MSDC_MULTIPLE_READ_WRITE (3) +#define MSDC_GET_CID (4) +#define MSDC_GET_CSD (5) +#define MSDC_GET_EXCSD (6) +#define MSDC_ERASE_PARTITION (7) +#define MSDC_HOPPING_SETTING (8) + +#define MSDC_REINIT_SDCARD _IOW('r', 9, int) + +#define MSDC_SD30_MODE_SWITCH (10) +#define MSDC_GET_BOOTPART (11) +#define MSDC_SET_BOOTPART (12) +#define MSDC_GET_PARTSIZE (13) +#define MSDC_ERASE_SELECTED_AREA (0x20) +#define MSDC_CARD_DUNM_FUNC (0xff) + +typedef enum { + USER_PARTITION = 0, + BOOT_PARTITION_1, + BOOT_PARTITION_2, + RPMB_PARTITION, + GP_PARTITION_1, + GP_PARTITION_2, + GP_PARTITION_3, + GP_PARTITION_4, +} PARTITON_ACCESS_T; + +typedef enum { + SDHC_HIGHSPEED = 0, /* 0 Host supports HS mode */ + UHS_SDR12, /* 1 Host supports UHS SDR12 mode */ + UHS_SDR25, /* 2 Host supports UHS SDR25 mode */ + UHS_SDR50, /* 3 Host supports UHS SDR50 mode */ + UHS_SDR104, /* 4 Host supports UHS SDR104 mode */ + UHS_DDR50, /* 5 Host supports UHS DDR50 mode */ +} SD3_MODE; + +typedef enum { + DRIVER_TYPE_A = 0, /* 0 Host supports Driver Type A */ + DRIVER_TYPE_B, /* 1 Host supports Driver Type B */ + DRIVER_TYPE_C, /* 2 Host supports Driver Type C */ + DRIVER_TYPE_D, /* 3 Host supports Driver Type D */ +} SD3_DRIVE; + +typedef enum { + MAX_CURRENT_200 = 0, /* 0 Host max current limit is 200mA */ + MAX_CURRENT_400, /* 1 Host max current limit is 400mA */ + MAX_CURRENT_600, /* 2 Host max current limit is 600mA */ + MAX_CURRENT_800, /* 3 Host max current limit is 800mA */ +} SD3_MAX_CURRENT; + +typedef enum { + SDXC_NO_POWER_CONTROL = 0, /* 0 Host not supports >150mA current at 3.3V /3.0V/1.8V */ + SDXC_POWER_CONTROL, /* 1 Host supports >150mA current at 3.3V /3.0V/1.8V */ +} SD3_POWER_CONTROL; + +typedef enum { + DUMP_INTO_BOOT_CARD_IPANIC = 0, + DUMP_INTO_BOOT_CARD_KDUMP = 1, + DUMP_INTO_EXTERN_CARD = 2, +} DUMP_STORAGE_TYPE; + +typedef enum { + EMMC_CARD_BOOT = 0, + SD_CARD_BOOT, + EMMC_CARD, + SD_CARD, +} STORAGE_TPYE; + +#define EXT_CSD_BOOT_SIZE_MULT (226) /* R */ +#define EXT_CSD_HC_ERASE_GRP_SIZE (224) /* RO */ +#define EXT_CSD_HC_WP_GPR_SIZE (221) /* RO */ +#define EXT_CSD_RPMB_SIZE_MULT (168) /* R */ +#define EXT_CSD_GP1_SIZE_MULT (143) /* R/W 3 bytes */ +#define EXT_CSD_GP2_SIZE_MULT (146) /* R/W 3 bytes */ +#define EXT_CSD_GP3_SIZE_MULT (149) /* R/W 3 bytes */ +#define EXT_CSD_GP4_SIZE_MULT (152) /* R/W 3 bytes */ +#define EXT_CSD_PART_CFG (179) /* R/W/E & R/W/E_P */ +#define EXT_CSD_CACHE_FLUSH (32) +#define EXT_CSD_CACHE_CTRL (33) +#define CAPACITY_2G (2 * 1024 * 1024 * 1024ULL) + +typedef enum { + EMMC_BOOT_NO_EN = 0, + EMMC_BOOT1_EN, + EMMC_BOOT2_EN, + EMMC_BOOT_USER = 7, + EMMC_BOOT_END +} BOOT_PARTITION_EN; + +#ifdef CONFIG_MTK_GPT_SCHEME_SUPPORT +typedef enum { + EMMC_PART_UNKNOWN=0 + ,EMMC_PART_BOOT1 + ,EMMC_PART_BOOT2 + ,EMMC_PART_RPMB + ,EMMC_PART_GP1 + ,EMMC_PART_GP2 + ,EMMC_PART_GP3 + ,EMMC_PART_GP4 + ,EMMC_PART_USER + ,EMMC_PART_END +} Region; +#endif + +typedef enum { + CARD_INFO = 0, + DISK_INFO, + EMMC_USER_CAPACITY, + EMMC_CAPACITY, + EMMC_RESERVE, +} GET_STORAGE_INFO; + +struct storage_info { + struct mmc_card *card; + struct gendisk *disk; + unsigned long long emmc_user_capacity; + unsigned long long emmc_capacity; + int emmc_reserve; +}; + +int msdc_get_info(STORAGE_TPYE storage_type, GET_STORAGE_INFO info_type, struct storage_info *info); + +#endif /* end of SD_MISC_H */ diff --git a/kernel-headers/linux/mmprofile.h b/kernel-headers/linux/mmprofile.h new file mode 100644 index 0000000..866022c --- /dev/null +++ b/kernel-headers/linux/mmprofile.h @@ -0,0 +1,102 @@ +#ifndef __MMPROFILE_H__ +#define __MMPROFILE_H__ +#include "mmprofile_static_event.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define MMProfileEventNameMaxLen 31 + +typedef unsigned int MMP_Event; + +typedef enum { + MMProfileFlagStart = 1, + MMProfileFlagEnd = 2, + MMProfileFlagPulse = 4, + MMProfileFlagEventSeparator = 8, + MMProfileFlagSystrace = 0x80000000, + MMProfileFlagMax = 0xFFFFFFFF +} MMP_LogType; + +typedef enum { + MMProfileMetaStringMBS = 1, + MMProfileMetaStringWCS, + MMProfileMetaStructure, + MMProfileMetaBitmap, + MMProfileMetaRaw, + MMProfileMetaUser = 0x10000000, + MMProfileMetaUserM4UReg, + MMProfileMetaMax = 0xFFFFFFFF +} MMP_MetaDataType; + +typedef enum { + MMProfileBitmapRGB565 = 1, + MMProfileBitmapRGB888, + MMProfileBitmapRGBA8888, + MMProfileBitmapBGR888, + MMProfileBitmapBGRA8888, + MMProfileBitmapMax = 0xFFFFFFFF +} MMP_PixelFormat; + +typedef struct { + unsigned int data1; // data1 (user defined) + unsigned int data2; // data2 (user defined) + MMP_MetaDataType data_type; // meta data type + unsigned int size; // meta data size + void *pData; // meta data pointer +} MMP_MetaData_t; + +typedef struct { + unsigned int data1; // data1 (user defined) + unsigned int data2; // data2 (user defined) + unsigned int struct_size; // structure size (bytes) + void *pData; // structure pointer + char struct_name[32]; // structure name +} MMP_MetaDataStructure_t; + +typedef struct { + unsigned int data1; // data1 (user defined) + unsigned int data2; // data2 (user defined) + unsigned int width; // image width + unsigned int height; // image height + MMP_PixelFormat format; // image pixel format + unsigned int start_pos; // start offset of image data (base on pData) + unsigned int bpp; // bits per pixel + int pitch; // image pitch (bytes per line) + unsigned int data_size; // image data size (bytes) + unsigned int down_sample_x; // horizontal down sample rate (>=1) + unsigned int down_sample_y; // vertical down sample rate (>=1) + void *pData; // image buffer address +} MMP_MetaDataBitmap_t; + +MMP_Event MMProfileRegisterEvent(MMP_Event parent, const char *name); +MMP_Event MMProfileFindEvent(MMP_Event parent, const char *name); +void MMProfileEnableEvent(MMP_Event event, long enable); +void MMProfileEnableFTraceEvent(MMP_Event event, long enable, long ftrace); +void MMProfileEnableEventRecursive(MMP_Event event, long enable); +void MMProfileEnableFTraceEventRecursive(MMP_Event event, long enable, long ftrace); +long MMProfileQueryEnable(MMP_Event event); +void MMProfileLog(MMP_Event event, MMP_LogType type); +void MMProfileLogEx(MMP_Event event, MMP_LogType type, unsigned long data1, unsigned long data2); +long MMProfileLogMeta(MMP_Event event, MMP_LogType type, MMP_MetaData_t *pMetaData); +long MMProfileLogMetaString(MMP_Event event, MMP_LogType type, const char *str); +long MMProfileLogMetaStringEx(MMP_Event event, MMP_LogType type, unsigned long data1, unsigned long data2, const char *str); +long MMProfileLogMetaStructure(MMP_Event event, MMP_LogType type, MMP_MetaDataStructure_t *pMetaData); +long MMProfileLogMetaBitmap(MMP_Event event, MMP_LogType type, MMP_MetaDataBitmap_t *pMetaData); + +#define MMProfileLogStructure(event, type, pStruct, struct_type) \ +{ \ + MMP_MetaDataStructure_t MetaData; \ + MetaData.data1 = 0; \ + MetaData.data2 = 0; \ + strcpy(MetaData.struct_name, #struct_type); \ + MetaData.struct_size = sizeof(struct_type); \ + MetaData.pData = (void *)(pStruct); \ + MMProfileLogMetaStructure(event, type, &MetaData); \ +} + +#ifdef __cplusplus +} +#endif +#endif diff --git a/kernel-headers/linux/mmprofile_internal.h b/kernel-headers/linux/mmprofile_internal.h new file mode 100644 index 0000000..9cc6f0f --- /dev/null +++ b/kernel-headers/linux/mmprofile_internal.h @@ -0,0 +1,100 @@ +#ifndef __MMPROFILE_INTERNAL_H__ +#define __MMPROFILE_INTERNAL_H__ + +#include <linux/mmprofile.h> + +#ifdef __cplusplus +extern "C" { +#endif + +#define MMProfileMaxEventCount 1000 + +#define MMP_EVENT_STATE_ENABLED (1 << 0) +#define MMP_EVENT_STATE_FTRACE (1 << 1) + +typedef struct { + unsigned int parentId; + char name[MMProfileEventNameMaxLen + 1]; +} MMProfile_EventInfo_t; + +typedef struct { + unsigned int lock; + unsigned int id; + unsigned int timeLow; + unsigned int timeHigh; + unsigned int flag; +#if 0 //#ifdef MMPROFILE_KERNEL_64 + unsigned long long data1; + unsigned long long data2; + unsigned long long meta_data_cookie; +#else + unsigned int data1; + unsigned int data2; + unsigned int meta_data_cookie; +#endif +} MMProfile_Event_t; + +typedef struct { + unsigned int enable; + unsigned int start; + unsigned int write_pointer; + unsigned int reg_event_index; + unsigned int buffer_size_record; + unsigned int buffer_size_bytes; + unsigned int record_size; + unsigned int meta_buffer_size; + unsigned int new_buffer_size_record; + unsigned int new_meta_buffer_size; + unsigned int selected_buffer; + unsigned int max_event_count; + unsigned int event_state[MMProfileMaxEventCount]; +} MMProfile_Global_t; + +typedef struct { + unsigned int cookie; + MMP_MetaDataType data_type; + unsigned int data_size; + unsigned int data_offset; +} MMProfile_MetaData_t; + +typedef struct { + unsigned int id; + MMP_LogType type; + MMP_MetaData_t meta_data; +} MMProfile_MetaLog_t; + + +#define MMProfileGlobalsSize ((sizeof(MMProfile_Global_t)+(PAGE_SIZE-1))&(~(PAGE_SIZE-1))) + +#define CONFIG_MMPROFILE_PATH "/data/MMProfileConfig.dat" + +#define MMProfilePrimaryBuffer 1 +#define MMProfileGlobalsBuffer 2 +#define MMProfileMetaDataBuffer 3 + +#define MMP_IOC_MAGIC 'M' + +#define MMP_IOC_ENABLE _IOW(MMP_IOC_MAGIC, 1, int) +#define MMP_IOC_START _IOW(MMP_IOC_MAGIC, 2, int) +#define MMP_IOC_TIME _IOW(MMP_IOC_MAGIC, 3, int) +#define MMP_IOC_REGEVENT _IOWR(MMP_IOC_MAGIC, 4, int) +#define MMP_IOC_FINDEVENT _IOWR(MMP_IOC_MAGIC, 5, int) +#define MMP_IOC_ENABLEEVENT _IOW(MMP_IOC_MAGIC, 6, int) +#define MMP_IOC_LOG _IOW(MMP_IOC_MAGIC, 7, int) +#define MMP_IOC_DUMPEVENTINFO _IOR(MMP_IOC_MAGIC, 8, int) +#define MMP_IOC_METADATALOG _IOW(MMP_IOC_MAGIC, 9, int) +#define MMP_IOC_DUMPMETADATA _IOR(MMP_IOC_MAGIC, 10, int) +#define MMP_IOC_SELECTBUFFER _IOW(MMP_IOC_MAGIC, 11, int) +#define MMP_IOC_TRYLOG _IOWR(MMP_IOC_MAGIC, 12, int) +#define MMP_IOC_ISENABLE _IOR(MMP_IOC_MAGIC, 13, int) +#define MMP_IOC_REMOTESTART _IOR(MMP_IOC_MAGIC, 14, int) +#define MMP_IOC_TEST _IOWR(MMP_IOC_MAGIC, 100, int) + +// fix build warning: unused +//static void MMProfileInitBuffer(void); +//static void MMProfileResetBuffer(void); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/kernel-headers/linux/mmprofile_static_event.h b/kernel-headers/linux/mmprofile_static_event.h new file mode 100644 index 0000000..6744bfa --- /dev/null +++ b/kernel-headers/linux/mmprofile_static_event.h @@ -0,0 +1,31 @@ +#ifndef __MMPROFILE_STATIC_EVENT_H__ +#define __MMPROFILE_STATIC_EVENT_H__ + + +typedef enum +{ + MMP_InvalidEvent = 0, + MMP_RootEvent = 1, + // User defined static events begin + MMP_TouchPanelEvent, + // User defined static events end. + MMP_MaxStaticEvent +} MMP_StaticEvents; + +#ifdef MMPROFILE_INTERNAL +typedef struct +{ + MMP_StaticEvents event; + char* name; + MMP_StaticEvents parent; +} MMP_StaticEvent_t; + +static MMP_StaticEvent_t MMProfileStaticEvents[] = +{ + {MMP_RootEvent, "Root_Event", MMP_InvalidEvent}, + {MMP_TouchPanelEvent, "TouchPanel_Event", MMP_RootEvent}, +}; + +#endif + +#endif diff --git a/kernel-headers/linux/mt_sched.h b/kernel-headers/linux/mt_sched.h new file mode 100644 index 0000000..11bf8c2 --- /dev/null +++ b/kernel-headers/linux/mt_sched.h @@ -0,0 +1,21 @@ +#ifndef _MTK_SCHED_H +#define _MTK_SCHED_H + +#define __USE_GNU +#include <linux/ioctl.h> +#include <sched.h> +#include <linux/mt_sched_ioctl.h> + +#ifdef __cplusplus +extern "C"{ +#endif + +int mt_sched_setaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask); +int mt_sched_getaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *mask, cpu_set_t *mt_mask); +int mt_sched_exitaffinity(pid_t pid); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/kernel-headers/linux/mt_sched_ioctl.h b/kernel-headers/linux/mt_sched_ioctl.h new file mode 100644 index 0000000..580caac --- /dev/null +++ b/kernel-headers/linux/mt_sched_ioctl.h @@ -0,0 +1,17 @@ +#ifndef _MT_SCHED_IOCTL_H +#define _MT_SCHED_IOCTL_H + +struct ioctl_arg { + pid_t pid; + unsigned int len; + unsigned long *mask; + unsigned long *mt_mask; +}; + +#define IOC_MAGIC '\x66' + +#define IOCTL_SETAFFINITY _IOW(IOC_MAGIC, 0, struct ioctl_arg) +#define IOCTL_EXITAFFINITY _IOW(IOC_MAGIC, 1, pid_t) +#define IOCTL_GETAFFINITY _IOR(IOC_MAGIC, 2, struct ioctl_arg) + +#endif
\ No newline at end of file diff --git a/kernel-headers/linux/mtcombo.h b/kernel-headers/linux/mtcombo.h new file mode 100644 index 0000000..67dd58e --- /dev/null +++ b/kernel-headers/linux/mtcombo.h @@ -0,0 +1,18 @@ +#ifndef __MTCOMBO_H__ +#define __MTCOMBO_H__ + +#include <linux/ioctl.h> + +typedef enum _ENUM_WMTHWVER_TYPE_T{ + WMTHWVER_MT6620_E1 = 0x0, + WMTHWVER_MT6620_E2 = 0x1, + WMTHWVER_MT6620_E3 = 0x2, + WMTHWVER_MT6620_E4 = 0x3, + WMTHWVER_MT6620_MAX, + WMTHWVER_INVALID = 0xff +} ENUM_WMTHWVER_TYPE_T, *P_ENUM_WMTHWVER_TYPE_T; + +#define COMBO_IOC_MAGIC 0x90 +#define COMBO_IOC_GPS_HWVER 6 + +#endif // __MTCOMBO_H__ diff --git a/kernel-headers/linux/mtgpio.h b/kernel-headers/linux/mtgpio.h new file mode 100644 index 0000000..050a792 --- /dev/null +++ b/kernel-headers/linux/mtgpio.h @@ -0,0 +1,54 @@ +/* alps/ALPS_SW/TRUNK/MAIN/alps/kernel/arch/arm/mach-mt6516/include/mach/fm.h + * + * (C) Copyright 2009 + * MediaTek <www.MediaTek.com> + * William Chung <William.Chung@MediaTek.com> + * + * MT6516 AR10x0 FM Radio Driver + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef __MTGPIO_H__ +#define __MTGPIO_H__ + +#include <linux/ioctl.h> + +#define GPIO_IOC_MAGIC 0x90 + +#define GPIO_IOCQMODE _IOR(GPIO_IOC_MAGIC, 0x01, uint32_t) +#define GPIO_IOCTMODE0 _IOW(GPIO_IOC_MAGIC, 0x02, uint32_t) +#define GPIO_IOCTMODE1 _IOW(GPIO_IOC_MAGIC, 0x03, uint32_t) +#define GPIO_IOCTMODE2 _IOW(GPIO_IOC_MAGIC, 0x04, uint32_t) +#define GPIO_IOCTMODE3 _IOW(GPIO_IOC_MAGIC, 0x05, uint32_t) +#define GPIO_IOCQDIR _IOR(GPIO_IOC_MAGIC, 0x06, uint32_t) +#define GPIO_IOCSDIRIN _IOW(GPIO_IOC_MAGIC, 0x07, uint32_t) +#define GPIO_IOCSDIROUT _IOW(GPIO_IOC_MAGIC, 0x08, uint32_t) +#define GPIO_IOCQPULLEN _IOR(GPIO_IOC_MAGIC, 0x09, uint32_t) +#define GPIO_IOCSPULLENABLE _IOW(GPIO_IOC_MAGIC, 0x0A, uint32_t) +#define GPIO_IOCSPULLDISABLE _IOW(GPIO_IOC_MAGIC, 0x0B, uint32_t) +#define GPIO_IOCQPULL _IOR(GPIO_IOC_MAGIC, 0x0C, uint32_t) +#define GPIO_IOCSPULLDOWN _IOW(GPIO_IOC_MAGIC, 0x0D, uint32_t) +#define GPIO_IOCSPULLUP _IOW(GPIO_IOC_MAGIC, 0x0E, uint32_t) +#define GPIO_IOCQINV _IOR(GPIO_IOC_MAGIC, 0x0F, uint32_t) +#define GPIO_IOCSINVENABLE _IOW(GPIO_IOC_MAGIC, 0x10, uint32_t) +#define GPIO_IOCSINVDISABLE _IOW(GPIO_IOC_MAGIC, 0x11, uint32_t) +#define GPIO_IOCQDATAIN _IOR(GPIO_IOC_MAGIC, 0x12, uint32_t) +#define GPIO_IOCQDATAOUT _IOR(GPIO_IOC_MAGIC, 0x13, uint32_t) +#define GPIO_IOCSDATALOW _IOW(GPIO_IOC_MAGIC, 0x14, uint32_t) +#define GPIO_IOCSDATAHIGH _IOW(GPIO_IOC_MAGIC, 0x15, uint32_t) + + +#endif // __MTGPIO_H__ diff --git a/kernel-headers/linux/mtk_agps_common.h b/kernel-headers/linux/mtk_agps_common.h new file mode 100644 index 0000000..325295a --- /dev/null +++ b/kernel-headers/linux/mtk_agps_common.h @@ -0,0 +1,157 @@ +/***************************************************************************** + * + * Filename: + * --------- + * mtk_agps_common.h + * + * Project: + * -------- + * DUMA + * + * Description: + * ------------ + * Data types used by MTK AGPS + * + * Author: + * ------- + * Chunhui Li(MTK80143) + * + *============================================================================ + * HISTORY + * Below this line, this part is controlled by CC/CQ. DO NOT MODIFY!! + *------------------------------------------------------------------------------ + * $Revision:$ + * $Modtime:$ + * $Log:$ + * + * 12 05 2012 archilis.wang + * [ALPS00393352] Please help analzye the root cause of failed item of ASSET + * Review: http://mtksap20:8080/go?page=NewReview&reviewid=49629 + * + * 04 24 2011 nina.hsu + * [ALPS00043332] [MT6573][AGPS] Add GPS_MNL_PROCESS_STATUS definition + * [MT6573][AGPS] + * Add GPS_MNL_PROCESS_STATUS definition for reporting GPS status + * . + * + * 08 20 2010 qiuhuan.zhao + * [ALPS00123522] [GPS] Android 2.2 porting + * Android 2.2 Gps driver porting. + * + *------------------------------------------------------------------------------ + * Upper this line, this part is controlled by CC/CQ. DO NOT MODIFY!! + *============================================================================ + ****************************************************************************/ + +#ifndef MTK_AGPS_COMMON_H +#define MTK_AGPS_COMMON_H + +#ifdef __cplusplus +extern "C" { +#endif + +#if ( defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 200000 )) +#else +#pragma pack(1) +#endif + +//AGPS socket port +#define MTK_MNL2SUPL "/data/agps_supl/mnl2supl" +#define MTK_PROFILE2MNL "/data/agps_supl/profile2mnl" + +//System_property for SUPL_Enable, SUPL_SI_Enable +#define GPS_MNL_SUPL_NAME "gps.supl.status" +#define GPS_MNL_PROCESS_STATUS "gps.mnl_process.status" + +// AGPS Module Enum +typedef enum +{ + MTK_MOD_GPS = 0, + MTK_MOD_SUPL, + MTK_MOD_WIFI, + MTK_MOD_CELLID, + MTK_MOD_CNT, +} MTK_AGPS_MOD_E; + +// AGPS Msg type +typedef enum +{ + MTK_AGPS_SUPL_ASSIST_REQ= 0, + MTK_AGPS_SUPL_NI_REQ, + MTK_AGPS_SUPL_PMTK_DATA, + MTK_AGPS_SUPL_END, + MTK_AGPS_SUPL_MNL_STATUS, + MTK_AGPS_SUPL_GPEVT, + MTK_AGPS_SUPL_CNT, + MTK_AGPS_AIDING_CELLINFO, + MTK_AGPS_AIDING_WIFIIFNO, + MTK_AGPS_SUPL_RAW_DBG, +} MTK_AGPS_SUPL_MSG_T; + +// GPEVT msg data enum +typedef enum +{ + GPEVT_TYPE_UNKNOWN = 0, // 0 + GPEVT_SUPL_SLP_CONNECT_BEGIN, // 1 + GPEVT_SUPL_SLP_CONNECTED, // 2 + GPEVT_SUPL_SSL_CONNECT_BEGIN, // 3 + GPEVT_SUPL_SSL_CONNECTED, // 4 + GPEVT_SUPL_ASSIST_DATA_RECEIVED, // 5 + GPEVT_SUPL_ASSIST_DATA_VALID, // 6 + GPEVT_SUPL_FIRST_POS_FIX, // 7 + GPEVT_SUPL_MEAS_TIME_OUT, // 8 + GPEVT_SUPL_MEAS_RESPONSE_SENT, // 9 + GPEVT_SUPL_SSL_CLOSED, // 10 + GPEVT_SUPL_SLP_DISCONNECTED, // 11 + + GPEVT_CP_MOLR_SENT, // 12 + GPEVT_CP_MTLR_RECEIVED, // 13 + GPEVT_CP_ASSIST_DATA_RECEIVED, // 14 + GPEVT_CP_ASSIST_DATA_VALID, // 15 + GPEVT_CP_FIRST_POS_FIX, // 16 + GPEVT_CP_MEAS_TIME_OUT, // 17 + GPEVT_CP_MEAS_RESPONSE_SENT, // 18 + + GPEVT_GNSS_HW_START, // 19 + GPEVT_GNSS_HW_STOP, // 20 + GPEVT_GNSS_RESET_STORED_SATELLITE_DATA, // 21 + + GPEVT_EPO_SERVER_CONNECT_BEGIN, // 22 + GPEVT_EPO_SERVER_CONNECTED, // 23 + GPEVT_EPO_DATA_RECEIVED, // 24 + GPEVT_EPO_SERVER_DISCONNECTED, // 25 + GPEVT_EPO_DATA_VALID, // 26 + + GPEVT_HOT_STILL_DATA_VALID, // 27 + + GPEVT_TYPE_MAX // 28 +}gpevt_type; + +// AGPS data struct +typedef struct +{ + unsigned char srcMod; + unsigned char dstMod; + unsigned short type; + unsigned short length; + char data[1]; +} mtk_agps_msg, *pmtk_agps_msg, MTK_AGPS_MSG_T, *PMTK_AGPS_MSG_T; + +#define MAX_AGPS_MAX_MESSAGES 72 +#define MTK_AGPS_PMTK_MAX_SIZE (256+sizeof(mtk_agps_msg)) +#define MTK_AGPS_PMTK_MAX_LEN (256+sizeof(mtk_agps_msg)) +#define MTK_AGPS_PMTK_HDR_LEN sizeof(MTK_AGPS_MSG_T) +#define MTK_AGPS_MSG_MAX_LEN (MTK_AGPS_PMTK_MAX_LEN + MTK_AGPS_PMTK_HDR_LEN) + +#define MTK_AGPS_SUPLMSG_TIMEOUT 6000 + +#if ( defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 200000 )) +#else +#pragma pack() +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* MTK_AGPS_COMMON_H */ diff --git a/kernel-headers/linux/mtk_ion.h b/kernel-headers/linux/mtk_ion.h new file mode 100644 index 0000000..514701e --- /dev/null +++ b/kernel-headers/linux/mtk_ion.h @@ -0,0 +1,28 @@ +/* +* Copyright (C) 2011-2014 MediaTek Inc. +* +* 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 _MTK_LINUX_ION_H +#define _MTK_LINUX_ION_H +enum mtk_ion_heap_type { + ION_HEAP_TYPE_MULTIMEDIA = 10, + ION_HEAP_TYPE_FB = 11, +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ +}; +#define ION_HEAP_MULTIMEDIA_MASK (1 << ION_HEAP_TYPE_MULTIMEDIA) +#define ION_HEAP_FB_MASK (1 << ION_HEAP_TYPE_FB) +#define ION_NUM_HEAP_IDS sizeof(unsigned int) * 8 +#endif +/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */ diff --git a/kernel-headers/linux/mtkfb.h b/kernel-headers/linux/mtkfb.h new file mode 100644 index 0000000..bbd85ed --- /dev/null +++ b/kernel-headers/linux/mtkfb.h @@ -0,0 +1,389 @@ +#ifndef __MTKFB_H +#define __MTKFB_H + +#include "mtkfb_info.h" + + +/**NOTICE: + * Must be consistent with bionic/libc/kernel/linux/common/mtkfb.h + */ +#define MTK_FB_NO_ION_FD ((int)(~0U>>1)) +#define MTK_FB_NO_USE_LAEYR_ID ((int)(~0U>>1)) +#define FBCAPS_GENERIC_MASK (0x00000fff) +#define FBCAPS_LCDC_MASK (0x00fff000) +#define FBCAPS_PANEL_MASK (0xff000000) +#define FBCAPS_MANUAL_UPDATE (0x00001000) +#define FBCAPS_SET_BACKLIGHT (0x01000000) +#define MTKFB_ERROR_IS_EARLY_SUSPEND (0x12000000) +//--------------------------------------------------------------------------- +/* IOCTL commands. */ +#define MTK_IOW(num, dtype) _IOW('O', num, dtype) +#define MTK_IOR(num, dtype) _IOR('O', num, dtype) +#define MTK_IOWR(num, dtype) _IOWR('O', num, dtype) +#define MTK_IO(num) _IO('O', num) + +#define MTKFB_QUEUE_OVERLAY_CONFIG MTK_IOW(137, struct fb_overlay_config) +// -------------------------------------------------------------------------- +#define MTKFB_SET_OVERLAY_LAYER MTK_IOW(0, struct fb_overlay_layer) +#define MTKFB_TRIG_OVERLAY_OUT MTK_IO(1) +#define MTKFB_SET_VIDEO_LAYERS MTK_IOW(2, struct fb_overlay_layer) +#define MTKFB_CAPTURE_FRAMEBUFFER MTK_IOW(3, unsigned long) +#define MTKFB_CONFIG_IMMEDIATE_UPDATE MTK_IOW(4, unsigned long) +#define MTKFB_SET_MULTIPLE_LAYERS MTK_IOW(5, struct fb_overlay_layer) +#define MTKFB_REGISTER_OVERLAYBUFFER MTK_IOW(6, struct fb_overlay_buffer_info) +#define MTKFB_UNREGISTER_OVERLAYBUFFER MTK_IOW(7, unsigned int) +#define MTKFB_SET_ORIENTATION MTK_IOW(8, unsigned long) +#define MTKFB_FBLAYER_ENABLE MTK_IOW(9,unsigned int) +#define MTKFB_LOCK_FRONT_BUFFER MTK_IO(10) +#define MTKFB_UNLOCK_FRONT_BUFFER MTK_IO(11) +#define MTKFB_POWERON MTK_IO(12) +#define MTKFB_POWEROFF MTK_IO(13) + +// Fence/Ion, OVL decoupling +#define MTKFB_PREPARE_OVERLAY_BUFFER MTK_IOW(14, struct fb_overlay_buffer) + +// S3D control +#define MTKFB_SET_COMPOSING3D MTK_IOW(15, unsigned long) +#define MTKFB_SET_S3D_FTM MTK_IOW(16, unsigned long) + +//FM De-sense for EM and Normal mode +#define MTKFB_GET_DEFAULT_UPDATESPEED MTK_IOR(17, unsigned long) +#define MTKFB_GET_CURR_UPDATESPEED MTK_IOR(18, unsigned long) +#define MTKFB_CHANGE_UPDATESPEED MTK_IOW(19, unsigned long) //for EM, not called change writecycle because DPI change pll ckl +#define MTKFB_GET_INTERFACE_TYPE MTK_IOR(20, unsigned long) ///0 DBI, 1 DPI, 2 MIPI +#define MTKFB_GET_POWERSTATE MTK_IOR(21, unsigned long) ///0: power off 1: power on +#define MTKFB_GET_DISPLAY_IF_INFORMATION MTK_IOR(22, mtk_dispif_info_t) +#define MTKFB_AEE_LAYER_EXIST MTK_IOR(23, unsigned long) //called before SET_OVERLAY each time, if true, hwc will not use FB_LAYER again +#define MTKFB_GET_OVERLAY_LAYER_INFO MTK_IOR(24, struct fb_overlay_layer_info) +#define MTKFB_FACTORY_AUTO_TEST MTK_IOR(25, unsigned long) +#define MTKFB_GET_FRAMEBUFFER_MVA MTK_IOR(26, unsigned int) +#define MTKFB_SLT_AUTO_CAPTURE MTK_IOWR(27, struct fb_slt_catpure) + +/* Wearable */ +#define MTKFB_LCM_ALWAYS_ON_ENABLE MTK_IOW(80, unsigned int) +#define MTKFB_SET_DISPLAY_POWER_MODE MTK_IOW(81, unsigned int) + +//error handling +#define MTKFB_META_RESTORE_SCREEN MTK_IOW(101, unsigned long) +#define MTKFB_ERROR_INDEX_UPDATE_TIMEOUT MTK_IO(103) +#define MTKFB_ERROR_INDEX_UPDATE_TIMEOUT_AEE MTK_IO(104) + +/*restore bootlogo and charater in meta mode*/ +#define MTKFB_META_SHOW_BOOTLOGO MTK_IO(105) + +//Extension FB active option +#define FB_ACTIVATE_NO_UPDATE 512 /* Skip frame update */ + +//---------------------------------------------------------------------- + +// -------------------------------------------------------------------------- +/** + * Just for mt6589 Platform + * @{ + */ +#define MTKFB_GETVFRAMEPHYSICAL MTK_IOW(41, unsigned long) +#define MTKFB_WAIT_OVERLAY_READY MTK_IO(42) +#define MTKFB_GET_OVERLAY_LAYER_COUNT MTK_IOR(43, unsigned long) +#define MTKFB_GET_VIDEOLAYER_SIZE MTK_IOR(44, struct fb_overlay_layer) +#define MTKFB_CAPTURE_VIDEOBUFFER MTK_IOW(45, unsigned long) + +// -------------------------------------------------------------------------- +// Video Playback Mode +#define MTKFB_TV_POST_VIDEO_BUFFER MTK_IOW(46, unsigned long) +#define MTKFB_TV_LEAVE_VIDEO_PLAYBACK_MODE MTK_IOW(47, unsigned long) +// For Factory Mode +#define MTKFB_IS_TV_CABLE_PLUG_IN MTK_IOW(48, unsigned long) + +// -------------------------------------------------------------------------- +#define MTKFB_BOOTANIMATION MTK_IO(49) +#define MTKFB_GETFPS MTK_IOW(50, unsigned long) +#define MTKFB_VSYNC MTK_IO(51) + +//----------------------------------------------------------------------FM De-sense for EM and Normal mode +#define MTKFB_FM_NOTIFY_FREQ MTK_IOW(52, unsigned long) //for Normal mode +#define MTKFB_RESET_UPDATESPEED MTK_IO(53) +#define MTKFB_SET_UI_LAYER_ALPHA MTK_IOW(54, unsigned long) +#define MTKFB_SET_UI_LAYER_SRCKEY MTK_IOW(55, unsigned long) + +#define MTKFB_GET_MAX_DISPLAY_COUNT MTK_IOR(56, unsigned int) +#define MTKFB_SET_FB_LAYER_SECURE MTK_IOW(57, int) +/** + * @} + */ +//---------------------------------------------------------------------- + +// -------------------------------------------------------------------------- + +typedef enum +{ + MTK_FB_ORIENTATION_0 = 0, + MTK_FB_ORIENTATION_90 = 1, + MTK_FB_ORIENTATION_180 = 2, + MTK_FB_ORIENTATION_270 = 3, +} MTK_FB_ORIENTATION; + + +typedef enum +{ + MTK_FB_TV_SYSTEM_NTSC = 0, + MTK_FB_TV_SYSTEM_PAL = 1, +} MTK_FB_TV_SYSTEM; + + +typedef enum +{ + MTK_FB_TV_FMT_RGB565 = 0, + MTK_FB_TV_FMT_YUV420_SEQ = 1, + MTK_FB_TV_FMT_UYUV422 = 2, + MTK_FB_TV_FMT_YUV420_BLK = 3, +} MTK_FB_TV_SRC_FORMAT; + +typedef enum +{ + LAYER_NORMAL_BUFFER = 0, + LAYER_SECURE_BUFFER = 1, + LAYER_PROTECTED_BUFFER = 2, + LAYER_SECURE_BUFFER_WITH_ALIGN = 0x10001, // the higher 16 bits =1 for adding 64 bytes alignment +} MTK_FB_OVL_LAYER_SECURE_MODE; + +typedef struct _disp_dfo_item +{ + char name[32]; + int value; +} disp_dfo_item_t; + +// -------------------------------------------------------------------------- +struct fb_slt_catpure +{ + MTK_FB_FORMAT format; + volatile char* outputBuffer; + unsigned int wdma_width; + unsigned int wdma_height; +}; + +struct fb_scale +{ + unsigned int xscale, yscale; +}; + +struct fb_frame_offset +{ + unsigned int idx; + unsigned long offset; +}; + +struct fb_update_window +{ + unsigned int x, y; + unsigned int width, height; +}; + +typedef enum +{ + LAYER_2D = 0, + LAYER_3D_SBS_0 = 0x1, + LAYER_3D_SBS_90 = 0x2, + LAYER_3D_SBS_180 = 0x3, + LAYER_3D_SBS_270 = 0x4, + LAYER_3D_TAB_0 = 0x10, + LAYER_3D_TAB_90 = 0x20, + LAYER_3D_TAB_180 = 0x30, + LAYER_3D_TAB_270 = 0x40, +} MTK_FB_LAYER_TYPE; + +typedef enum +{ + DISP_DIRECT_LINK_MODE, + DISP_DECOUPLE_MODE +} MTK_DISP_MODE; + +struct fb_overlay_mode +{ + MTK_DISP_MODE mode; +}; + +typedef enum // map sessions to scenairos in kernel driver +{ + DISP_SESSION_LCM = 1<<0, // DSI0 + DISP_SESSION_MEM = 1<<1, // OVL0->WDMA0 + DISP_SESSION_WFD = 1<<2, // Extention mode, Dst buf is provided by user, for Wifi Display or other purpose + DISP_SESSION_MHL = 1<<3, // DPI + DISP_SESSION_LCM1 = 1<<4, // DSI1 + DISP_SESSION_MEM1 = 1<<5, // OVL1->WDMA1 + //TODO:can be extended with other Session Id + SESSION_MASK = 0xff&~(1<<6) +} MTK_DISP_SESSION; + +struct fb_overlay_session +{ + unsigned int session; // one or more @MTK_DISP_SESSION combined +}; + +struct fb_overlay_decouple +{ + MTK_DISP_MODE mode; + unsigned int session; +}; + +struct fb_overlay_buffer +{ + // Input + int layer_id; + unsigned int layer_en; + int ion_fd; + unsigned int cache_sync; + // Output + unsigned int index; + int fence_fd; +}; + +struct fb_overlay_layer +{ + unsigned int layer_id; + unsigned int layer_enable; + + void* src_base_addr; + void* src_phy_addr; + unsigned int src_direct_link; + MTK_FB_FORMAT src_fmt; + unsigned int src_use_color_key; + unsigned int src_color_key; + unsigned int src_pitch; + unsigned int src_offset_x, src_offset_y; + unsigned int src_width, src_height; + + unsigned int tgt_offset_x, tgt_offset_y; + unsigned int tgt_width, tgt_height; + MTK_FB_ORIENTATION layer_rotation; + MTK_FB_LAYER_TYPE layer_type; + MTK_FB_ORIENTATION video_rotation; + + unsigned int isTdshp; // set to 1, will go through tdshp first, then layer blending, then to color + + int next_buff_idx; + int identity; + int connected_type; + unsigned int security; + unsigned int alpha_enable; + unsigned int alpha; + int fence_fd; + int ion_fd; //CL 2340210 +}; + +struct fb_overlay_config +{ + int fence; + int time; + struct fb_overlay_layer layers[4]; +}; + +struct fb_overlay_buffer_info +{ + unsigned int src_vir_addr; + unsigned int size; +}; + +struct fb_overlay_layer_info +{ + unsigned int layer_id; + unsigned int layer_enabled; // TO BE DEL + unsigned int curr_en; + unsigned int next_en; + unsigned int hw_en; + int curr_idx; + int next_idx; + int hw_idx; + int curr_identity; + int next_identity; + int hw_identity; + int curr_conn_type; + int next_conn_type; + int hw_conn_type; + MTK_FB_ORIENTATION layer_rotation; +}; +// -------------------------------------------------------------------------- + +struct fb_post_video_buffer +{ + void* phy_addr; + void* vir_addr; + MTK_FB_TV_SRC_FORMAT format; + unsigned int width, height; +}; + +#ifdef __KERNEL__ + +#include <linux/completion.h> +#include <linux/interrupt.h> +#include <linux/workqueue.h> + +#include <linux/version.h> +#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 10, 0)) +#include <linux/sw_sync.h> +#else +#include <../drivers/staging/android/sw_sync.h> +#endif + + +#define MTKFB_DRIVER "mtkfb" + +enum mtkfb_state +{ + MTKFB_DISABLED = 0, + MTKFB_SUSPENDED = 99, + MTKFB_ACTIVE = 100 +}; + +typedef enum +{ + MTKFB_LAYER_ENABLE_DIRTY = (1 << 0), + MTKFB_LAYER_FORMAT_DIRTY = (1 << 1), + MTKFB_LAYER_SET_DIRTY = (1 << 2), +} MTKFB_LAYER_CONFIG_DIRTY; + +typedef struct +{ + struct work_struct work; + struct list_head list; + struct fb_overlay_config config; + struct sync_fence *fences[4]; + struct ion_handle *ion_handles[4]; + void *dev; +} update_ovls_work_t; + +struct mtkfb_device +{ + int state; + void *fb_va_base; /* MPU virtual address */ + dma_addr_t fb_pa_base; /* Bus physical address */ + unsigned long fb_size_in_byte; + void *ovl_va_base; /* MPU virtual address */ + dma_addr_t ovl_pa_base; /* Bus physical address */ + unsigned long ovl_size_in_byte; + + unsigned long layer_enable; + MTK_FB_FORMAT *layer_format; + unsigned int layer_config_dirty; + + int xscale, yscale, mirror; /* transformations. + rotate is stored in fb_info->var */ + u32 pseudo_palette[17]; + + struct fb_info *fb_info; /* Linux fbdev framework data */ + struct device *dev; + + /* Android native fence support */ + struct workqueue_struct *update_ovls_wq; + struct mutex timeline_lock; + struct sw_sync_timeline *timeline; + int timeline_max; + struct list_head pending_configs; //CL2340210 + struct ion_client *ion_client; +}; + +#endif /* __KERNEL__ */ + +extern long hdmi_handle_cmd(unsigned int cmd, unsigned long arg); + + +#endif /* __MTKFB_H */ diff --git a/kernel-headers/linux/mtkfb_info.h b/kernel-headers/linux/mtkfb_info.h new file mode 100644 index 0000000..574c6fc --- /dev/null +++ b/kernel-headers/linux/mtkfb_info.h @@ -0,0 +1,90 @@ +#ifndef __MTKFB_INFO_H__ +#define __MTKFB_INFO_H__ + +#ifdef __cplusplus +extern "C" { +#endif + + +typedef enum +{ + DISPIF_TYPE_DBI = 0, + DISPIF_TYPE_DPI, + DISPIF_TYPE_DSI, + DISPIF_TYPE_DPI0, + DISPIF_TYPE_DPI1, + DISPIF_TYPE_DSI0, + DISPIF_TYPE_DSI1, + HDMI = 7, + HDMI_SMARTBOOK, + MHL, + DISPIF_TYPE_EPD +} MTKFB_DISPIF_TYPE; + +typedef enum +{ + MTKFB_DISPIF_PRIMARY_LCD = 0, + MTKFB_DISPIF_HDMI, + MTKFB_DISPIF_EPD, + MTKFB_MAX_DISPLAY_COUNT +} MTKFB_DISPIF_DEVICE_TYPE; + +typedef enum +{ + DISPIF_FORMAT_RGB565 = 0, + DISPIF_FORMAT_RGB666, + DISPIF_FORMAT_RGB888 +} MTKFB_DISPIF_FORMAT; + + +typedef enum +{ + DISPIF_MODE_VIDEO = 0, + DISPIF_MODE_COMMAND +} MTKFB_DISPIF_MODE; + +typedef struct mtk_dispif_info { + unsigned int display_id; + unsigned int isHwVsyncAvailable; + MTKFB_DISPIF_TYPE displayType; + unsigned int displayWidth; + unsigned int displayHeight; + unsigned int displayFormat; + MTKFB_DISPIF_MODE displayMode; + unsigned int vsyncFPS; + unsigned int physicalWidth; + unsigned int physicalHeight; + unsigned int isConnected; + unsigned int lcmOriginalWidth; // this value is for DFO Multi-Resolution feature, which stores the original LCM Wdith + unsigned int lcmOriginalHeight; // this value is for DFO Multi-Resolution feature, which stores the original LCM Height +} mtk_dispif_info_t; + +#define MAKE_MTK_FB_FORMAT_ID(id, bpp) (((id) << 8) | (bpp)) + +typedef enum +{ + MTK_FB_FORMAT_UNKNOWN = 0, + + MTK_FB_FORMAT_RGB565 = MAKE_MTK_FB_FORMAT_ID(1, 2), + MTK_FB_FORMAT_RGB888 = MAKE_MTK_FB_FORMAT_ID(2, 3), + MTK_FB_FORMAT_BGR888 = MAKE_MTK_FB_FORMAT_ID(3, 3), + MTK_FB_FORMAT_ARGB8888 = MAKE_MTK_FB_FORMAT_ID(4, 4), + MTK_FB_FORMAT_ABGR8888 = MAKE_MTK_FB_FORMAT_ID(5, 4), + MTK_FB_FORMAT_YUV422 = MAKE_MTK_FB_FORMAT_ID(6, 2), + MTK_FB_FORMAT_XRGB8888 = MAKE_MTK_FB_FORMAT_ID(7, 4), + MTK_FB_FORMAT_XBGR8888 = MAKE_MTK_FB_FORMAT_ID(8, 4), + MTK_FB_FORMAT_UYVY = MAKE_MTK_FB_FORMAT_ID(9, 2), + MTK_FB_FORMAT_YUV420_P = MAKE_MTK_FB_FORMAT_ID(10, 2), + MTK_FB_FORMAT_YUY2 = MAKE_MTK_FB_FORMAT_ID(11, 2), + MTK_FB_FORMAT_BPP_MASK = 0xFF, +} MTK_FB_FORMAT; + +#define GET_MTK_FB_FORMAT_BPP(f) ((f) & MTK_FB_FORMAT_BPP_MASK) + + +#ifdef __cplusplus +} +#endif + +#endif // __DISP_DRV_H__ + diff --git a/kernel-headers/linux/mtkfb_vsync.h b/kernel-headers/linux/mtkfb_vsync.h new file mode 100644 index 0000000..f0802da --- /dev/null +++ b/kernel-headers/linux/mtkfb_vsync.h @@ -0,0 +1,17 @@ +#ifndef __MTKFB_VSYNC_H__ +#define __MTKFB_VSYNC_H__ + + +#define MTKFB_VSYNC_DEVNAME "mtkfb_vsync" + +#define MTKFB_VSYNC_IOCTL_MAGIC 'V' + +typedef enum +{ + MTKFB_VSYNC_SOURCE_LCM = 0, + MTKFB_VSYNC_SOURCE_HDMI = 1, +} vsync_src; + +#define MTKFB_VSYNC_IOCTL _IOW(MTKFB_VSYNC_IOCTL_MAGIC, 1, vsync_src) + +#endif //MTKFB_VSYNC_H diff --git a/kernel-headers/linux/rrc_drv.h b/kernel-headers/linux/rrc_drv.h new file mode 100644 index 0000000..3b7ff83 --- /dev/null +++ b/kernel-headers/linux/rrc_drv.h @@ -0,0 +1,74 @@ +#include <linux/ioctl.h> + +#ifndef __RRC_DRV_H__ +#define __RRC_DRV_H__ + + + +typedef struct { + + unsigned int scenario; + unsigned int enable; + /* unsigned int pid; */ + /* unsigned int *maxSafeSize; */ + /* unsigned int *result; */ + +} RRC_DRV_DATA; + + +typedef enum { + + RRC_DRV_TYPE_NONE = 0, + RRC_DRV_TYPE_CAMERA_PREVIEW , + RRC_DRV_TYPE_CAMERA_ZSD , + RRC_DRV_TYPE_CAMERA_CAPTURE , + RRC_DRV_TYPE_CAMERA_ICFP , + RRC_DRV_TYPE_VIDEO_NORMAL , + RRC_DRV_TYPE_VIDEO_SWDEC_PLAYBACK , + RRC_DRV_TYPE_VIDEO_PLAYBACK , + RRC_DRV_TYPE_VIDEO_TELEPHONY , + RRC_DRV_TYPE_VIDEO_RECORD , + RRC_DRV_TYPE_VIDEO_RECORD_CAMERA , + RRC_DRV_TYPE_VIDEO_RECORD_SLOWMOTION , + RRC_DRV_TYPE_VIDEO_SNAPSHOT , + RRC_DRV_TYPE_VIDEO_LIVE_PHOTO , + RRC_DRV_TYPE_VIDEO_WIFI_DISPLAY , + + /* touch event */ + RRC_DRV_TYPE_TOUCH_EVENT , + + RRC_DRV_TYPE_MAX_SIZE + + +} RRC_DRV_SCENARIO_TYPE; + + +typedef enum { + RRC_DRV_NONE = 0, + RRC_DRV_60Hz , + RRC_DRV_120Hz + + +} RRC_DRV_REFRESH_RATE; + + + + +#define RRC_IOCTL_MAGIC 'x' + +/* #define JPEG_DEC_IOCTL_INIT _IO (ALMK_IOCTL_MAGIC, 1) */ +/* #define JPEG_DEC_IOCTL_CONFIG _IOW (ALMK_IOCTL_MAGIC, 2, JPEG_DEC_DRV_IN) */ +/* #define JPEG_DEC_IOCTL_START _IO (ALMK_IOCTL_MAGIC, 3) */ +/* #define JPEG_DEC_IOCTL_WAIT _IOWR(ALMK_IOCTL_MAGIC, 6, JPEG_DEC_DRV_OUT) */ +/* #define JPEG_DEC_IOCTL_DEINIT _IO (ALMK_IOCTL_MAGIC, 8) */ + +#define RRC_IOCTL_CMD_INIT _IO(RRC_IOCTL_MAGIC, 11) +#define RRC_IOCTL_CMD_SET_SCENARIO_TYPE _IOWR(RRC_IOCTL_MAGIC, 12, RRC_DRV_DATA) +#define RRC_IOCTL_CMD_DEINIT _IO(RRC_IOCTL_MAGIC, 13) + + + + + +#endif + diff --git a/kernel-headers/linux/rtpm_prio.h b/kernel-headers/linux/rtpm_prio.h new file mode 100644 index 0000000..70aa10e --- /dev/null +++ b/kernel-headers/linux/rtpm_prio.h @@ -0,0 +1,83 @@ +#ifndef __KERNEL_RTPM_PRIO__ +#define __KERNEL_RTPM_PRIO__ + +#define CONFIG_MT_RT_MONITOR +#ifdef CONFIG_MT_RT_MONITOR +#define MT_ALLOW_RT_PRIO_BIT 0x10000000 +#else +#define MT_ALLOW_RT_PRIO_BIT 0x0 +#endif + +#define REG_RT_PRIO(x) ((x) | MT_ALLOW_RT_PRIO_BIT) + +/*********************************************************************** + * Processes scheduled under one of the real-time policies (SCHED_FIFO, SCHED_RR) + * have a sched_priority value in the range: + * 1 (low) to 99 (high). +************************************************************************/ +//////////////////////////////////////////////////////////////////////// +//DEFINE MM GROUP PRIORITY +#define RTPM_PRIO_MM_GROUP_BASE (10) +#define RTPM_PRIO_MM_GROUP_A (RTPM_PRIO_MM_GROUP_BASE+0) +#define RTPM_PRIO_MM_GROUP_B (RTPM_PRIO_MM_GROUP_BASE+10) +#define RTPM_PRIO_MM_GROUP_C (RTPM_PRIO_MM_GROUP_BASE+20) +#define RTPM_PRIO_MM_GROUP_D (RTPM_PRIO_MM_GROUP_BASE+30) +#define RTPM_PRIO_MM_GROUP_E (RTPM_PRIO_MM_GROUP_BASE+40) +#define RTPM_PRIO_MM_GROUP_F (RTPM_PRIO_MM_GROUP_BASE+50) +#define RTPM_PRIO_MM_GROUP_G (RTPM_PRIO_MM_GROUP_BASE+60) +#define RTPM_PRIO_MM_GROUP_H (RTPM_PRIO_MM_GROUP_BASE+70) +#define RTPM_PRIO_MM_GROUP_I (RTPM_PRIO_MM_GROUP_BASE+80) + +//////////////////////////////////////////////////////////////////////// +// DEFIN MTK RT PRIORITY + +#define RTPM_PRIO_CPU_CALLBACK REG_RT_PRIO(98) +#define RTPM_PRIO_SWLOCKUP REG_RT_PRIO(98) +#define RTPM_PRIO_AED REG_RT_PRIO(28) +#define RTPM_PRIO_WDT REG_RT_PRIO(99) + +#define RTPM_PRIO_TPD REG_RT_PRIO(4) +#define RTPM_PRIO_KSDIOIRQ REG_RT_PRIO(1) + +#define RTPM_PRIO_AUDIO_PLAYBACK REG_RT_PRIO(RTPM_PRIO_MM_GROUP_I+5) +#define RTPM_PRIO_VIDEO_PLAYBACK_THREAD REG_RT_PRIO(RTPM_PRIO_MM_GROUP_I+5) //TimeEventQueue +#define RTPM_PRIO_SCRN_UPDATE REG_RT_PRIO(RTPM_PRIO_MM_GROUP_I+4) +#define RTPM_PRIO_AUDIO_COMMAND REG_RT_PRIO(RTPM_PRIO_MM_GROUP_I+2) +#define RTPM_PRIO_AUDIO_CCCI_THREAD REG_RT_PRIO(RTPM_PRIO_MM_GROUP_I+2) + +#define RTPM_PRIO_CAMERA_TOPBASE REG_RT_PRIO(RTPM_PRIO_MM_GROUP_I+1) +#define RTPM_PRIO_CAMERA_PREVIEW REG_RT_PRIO(RTPM_PRIO_MM_GROUP_I+1) +#define RTPM_PRIO_CAMERA_COMPRESS REG_RT_PRIO(RTPM_PRIO_MM_GROUP_I+0) + +#define RTPM_PRIO_MATV_AUDIOPLAYER REG_RT_PRIO(RTPM_PRIO_MM_GROUP_I+0) +#define RTPM_PRIO_FM_AUDIOPLAYER REG_RT_PRIO(RTPM_PRIO_MM_GROUP_I+0) +#define RTPM_PRIO_AUDIO_I2S REG_RT_PRIO(RTPM_PRIO_MM_GROUP_I+0) + +#define RTPM_PRIO_CAMERA_DISPLAY REG_RT_PRIO(RTPM_PRIO_MM_GROUP_H+9) +#define RTPM_PRIO_CAMERA_SHUTTER REG_RT_PRIO(RTPM_PRIO_MM_GROUP_H+9) +#define RTPM_PRIO_CAMERA_RECORD REG_RT_PRIO(RTPM_PRIO_MM_GROUP_H+9) +#define RTPM_PRIO_FB_THREAD REG_RT_PRIO(RTPM_PRIO_MM_GROUP_H+7) +#define RTPM_PRIO_VSYNC_THREAD REG_RT_PRIO(RTPM_PRIO_MM_GROUP_H+5) +#define RTPM_PRIO_SURFACEFLINGER REG_RT_PRIO(RTPM_PRIO_MM_GROUP_H+4) + +#define RTPM_PRIO_VIDEO_YUV_BUFFER REG_RT_PRIO(RTPM_PRIO_MM_GROUP_G+8) +#define RTPM_PRIO_AUDIO_RECORD REG_RT_PRIO(RTPM_PRIO_MM_GROUP_G+7) +#define RTPM_PRIO_OMX_AUDIO REG_RT_PRIO(RTPM_PRIO_MM_GROUP_G+6) +#define RTPM_PRIO_OMX_CMD_AUDIO REG_RT_PRIO(RTPM_PRIO_MM_GROUP_G+6) +#define RTPM_PRIO_OMX_VIDEO_ENCODE REG_RT_PRIO(RTPM_PRIO_MM_GROUP_G+5) +#define RTPM_PRIO_OMX_VIDEO REG_RT_PRIO(RTPM_PRIO_MM_GROUP_G+5) +#define RTPM_PRIO_OMX_VIDEO_DECODE REG_RT_PRIO(RTPM_PRIO_MM_GROUP_G+4) + +#define RTPM_PRIO_VIDEO_BS_BUFFER REG_RT_PRIO(RTPM_PRIO_MM_GROUP_G+3) +#define RTPM_PRIO_MIDI_FILE REG_RT_PRIO(RTPM_PRIO_MM_GROUP_C+0) + +#define RTPM_PRIO_AUDIOTRACK_THREAD REG_RT_PRIO(1) +#define RTPM_PRIO_GPS_DRIVER REG_RT_PRIO(1) +// Total +#define RTPM_PRIO_NUM 30 +//////////////////////////////////////////////////////////////////////////////// +//Removed +//#define RTPM_PRIO_FB_THREAD REG_RT_PRIO(87) +//#define RTPM_PRIO_SURFACE_OUT REG_RT_PRIO(80) + +#endif diff --git a/kernel-headers/linux/sensors_io.h b/kernel-headers/linux/sensors_io.h new file mode 100644 index 0000000..a84e5ff --- /dev/null +++ b/kernel-headers/linux/sensors_io.h @@ -0,0 +1,166 @@ +/* +* +* (C) Copyright 2008 +* MediaTek <www.mediatek.com> +* +* Sensors IO command file for MT6516 +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation; either version 2 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ +#ifndef SENSORS_IO_H +#define SENSORS_IO_H + +#include <linux/ioctl.h> + +typedef struct { + unsigned short x; /**< X axis */ + unsigned short y; /**< Y axis */ + unsigned short z; /**< Z axis */ +} GSENSOR_VECTOR3D; + +typedef struct{ + int x; + int y; + int z; +}SENSOR_DATA; + + +#define GSENSOR 0x85 +#define GSENSOR_IOCTL_INIT _IO(GSENSOR, 0x01) +#define GSENSOR_IOCTL_READ_CHIPINFO _IOR(GSENSOR, 0x02, int) +#define GSENSOR_IOCTL_READ_SENSORDATA _IOR(GSENSOR, 0x03, int) +#define GSENSOR_IOCTL_READ_OFFSET _IOR(GSENSOR, 0x04, GSENSOR_VECTOR3D) +#define GSENSOR_IOCTL_READ_GAIN _IOR(GSENSOR, 0x05, GSENSOR_VECTOR3D) +#define GSENSOR_IOCTL_READ_RAW_DATA _IOR(GSENSOR, 0x06, int) +#define GSENSOR_IOCTL_SET_CALI _IOW(GSENSOR, 0x06, SENSOR_DATA) +#define GSENSOR_IOCTL_GET_CALI _IOW(GSENSOR, 0x07, SENSOR_DATA) +#define GSENSOR_IOCTL_CLR_CALI _IO(GSENSOR, 0x08) + + + + +/* IOCTLs for Msensor misc. device library */ +#define MSENSOR 0x83 +#define MSENSOR_IOCTL_INIT _IO(MSENSOR, 0x01) +#define MSENSOR_IOCTL_READ_CHIPINFO _IOR(MSENSOR, 0x02, int) +#define MSENSOR_IOCTL_READ_SENSORDATA _IOR(MSENSOR, 0x03, int) +#define MSENSOR_IOCTL_READ_POSTUREDATA _IOR(MSENSOR, 0x04, int) +#define MSENSOR_IOCTL_READ_CALIDATA _IOR(MSENSOR, 0x05, int) +#define MSENSOR_IOCTL_READ_CONTROL _IOR(MSENSOR, 0x06, int) +#define MSENSOR_IOCTL_SET_CONTROL _IOW(MSENSOR, 0x07, int) +#define MSENSOR_IOCTL_SET_MODE _IOW(MSENSOR, 0x08, int) +#define MSENSOR_IOCTL_SET_POSTURE _IOW(MSENSOR, 0x09, int) +#define MSENSOR_IOCTL_SET_CALIDATA _IOW(MSENSOR, 0x0a, int) +#define MSENSOR_IOCTL_SENSOR_ENABLE _IOW(MSENSOR, 0x51, int) +#define MSENSOR_IOCTL_READ_FACTORY_SENSORDATA _IOW(MSENSOR, 0x52, int) + + +/* IOCTLs for AKM library */ +#define ECS_IOCTL_WRITE _IOW(MSENSOR, 0x0b, char*) +#define ECS_IOCTL_READ _IOWR(MSENSOR, 0x0c, char*) +#define ECS_IOCTL_RESET _IO(MSENSOR, 0x0d) /* NOT used in AK8975 */ +#define ECS_IOCTL_SET_MODE _IOW(MSENSOR, 0x0e, short) +#define ECS_IOCTL_GETDATA _IOR(MSENSOR, 0x0f, char[SENSOR_DATA_SIZE]) +#define ECS_IOCTL_SET_YPR _IOW(MSENSOR, 0x10, short[12]) +#define ECS_IOCTL_GET_OPEN_STATUS _IOR(MSENSOR, 0x11, int) +#define ECS_IOCTL_GET_CLOSE_STATUS _IOR(MSENSOR, 0x12, int) +#define ECS_IOCTL_GET_OSENSOR_STATUS _IOR(MSENSOR, 0x13, int) +#define ECS_IOCTL_GET_DELAY _IOR(MSENSOR, 0x14, short) +#define ECS_IOCTL_GET_PROJECT_NAME _IOR(MSENSOR, 0x15, char[64]) +#define ECS_IOCTL_GET_MATRIX _IOR(MSENSOR, 0x16, short [4][3][3]) +#define ECS_IOCTL_GET_LAYOUT _IOR(MSENSOR, 0x17, int[3]) + +#define ECS_IOCTL_GET_OUTBIT _IOR(MSENSOR, 0x23, char) +#define ECS_IOCTL_GET_ACCEL _IOR(MSENSOR, 0x24, short[3]) +#define MMC31XX_IOC_RM _IO(MSENSOR, 0x25) +#define MMC31XX_IOC_RRM _IO(MSENSOR, 0x26) +/* IOCTLs for akm09911 device */ +#define ECS_IOCTL_GET_INFO _IOR(MSENSOR, 0x27, unsigned char[AKM_SENSOR_INFO_SIZE]) +#define ECS_IOCTL_GET_CONF _IOR(MSENSOR, 0x28, unsigned char[AKM_SENSOR_CONF_SIZE]) +#define ECS_IOCTL_SET_YPR_09911 _IOW(MSENSOR, 0x29, int[26]) +#define ECS_IOCTL_GET_DELAY_09911 _IOR(MSENSOR, 0x30, int64_t[3]) +#define ECS_IOCTL_GET_LAYOUT_09911 _IOR(MSENSOR, 0x31, char) + +/* IOCTLs for MMC31XX device */ +#define MMC31XX_IOC_TM _IO(MSENSOR, 0x18) +#define MMC31XX_IOC_SET _IO(MSENSOR, 0x19) +#define MMC31XX_IOC_RESET _IO(MSENSOR, 0x1a) +#define MMC31XX_IOC_READ _IOR(MSENSOR, 0x1b, int[3]) +#define MMC31XX_IOC_READXYZ _IOR(MSENSOR, 0x1c, int[3]) + +#define ECOMPASS_IOC_GET_DELAY _IOR(MSENSOR, 0x1d, int) +#define ECOMPASS_IOC_GET_MFLAG _IOR(MSENSOR, 0x1e, short) +#define ECOMPASS_IOC_GET_OFLAG _IOR(MSENSOR, 0x1f, short) +#define ECOMPASS_IOC_GET_OPEN_STATUS _IOR(MSENSOR, 0x20, int) +#define ECOMPASS_IOC_SET_YPR _IOW(MSENSOR, 0x21, int[12]) +#define ECOMPASS_IOC_GET_LAYOUT _IOR(MSENSOR, 0X22, int) + + + + +#define ALSPS 0X84 +#define ALSPS_SET_PS_MODE _IOW(ALSPS, 0x01, int) +#define ALSPS_GET_PS_MODE _IOR(ALSPS, 0x02, int) +#define ALSPS_GET_PS_DATA _IOR(ALSPS, 0x03, int) +#define ALSPS_GET_PS_RAW_DATA _IOR(ALSPS, 0x04, int) +#define ALSPS_SET_ALS_MODE _IOW(ALSPS, 0x05, int) +#define ALSPS_GET_ALS_MODE _IOR(ALSPS, 0x06, int) +#define ALSPS_GET_ALS_DATA _IOR(ALSPS, 0x07, int) +#define ALSPS_GET_ALS_RAW_DATA _IOR(ALSPS, 0x08, int) +/*-------------------yucong add-------------------------------------------*/ +#define ALSPS_GET_PS_TEST_RESULT _IOR(ALSPS, 0x09, int) +#define ALSPS_GET_ALS_TEST_RESULT _IOR(ALSPS, 0x0A, int) +#define ALSPS_GET_PS_THRESHOLD_HIGH _IOR(ALSPS, 0x0B, int) +#define ALSPS_GET_PS_THRESHOLD_LOW _IOR(ALSPS, 0x0C, int) +#define ALSPS_GET_ALS_THRESHOLD_HIGH _IOR(ALSPS, 0x0D, int) +#define ALSPS_GET_ALS_THRESHOLD_LOW _IOR(ALSPS, 0x0E, int) +#define ALSPS_IOCTL_CLR_CALI _IOW(ALSPS, 0x0F, int) +#define ALSPS_IOCTL_GET_CALI _IOR(ALSPS, 0x10, int) +#define ALSPS_IOCTL_SET_CALI _IOW(ALSPS, 0x11, int) +#define ALSPS_SET_PS_THRESHOLD _IOW(ALSPS, 0x12, int) +#define ALSPS_SET_ALS_THRESHOLD _IOW(ALSPS, 0x13, int) +#define AAL_SET_ALS_MODE _IOW(ALSPS, 0x14,int) +#define AAL_GET_ALS_MODE _IOR(ALSPS, 0x15,int) +#define AAL_GET_ALS_DATA _IOR(ALSPS, 0x16,int) + +#define GYROSCOPE 0X86 +#define GYROSCOPE_IOCTL_INIT _IO(GYROSCOPE, 0x01) +#define GYROSCOPE_IOCTL_SMT_DATA _IOR(GYROSCOPE, 0x02, int) +#define GYROSCOPE_IOCTL_READ_SENSORDATA _IOR(GYROSCOPE, 0x03, int) +#define GYROSCOPE_IOCTL_SET_CALI _IOW(GYROSCOPE, 0x04, SENSOR_DATA) +#define GYROSCOPE_IOCTL_GET_CALI _IOW(GYROSCOPE, 0x05, SENSOR_DATA) +#define GYROSCOPE_IOCTL_CLR_CALI _IO(GYROSCOPE, 0x06) +#define GYROSCOPE_IOCTL_READ_SENSORDATA_RAW _IOR(GYROSCOPE, 0x07, int) +#define GYROSCOPE_IOCTL_READ_TEMPERATURE _IOR(GYROSCOPE, 0x08, int) +#define GYROSCOPE_IOCTL_GET_POWER_STATUS _IOR(GYROSCOPE, 0x09, int) + +#define BROMETER 0X87 +#define BAROMETER_IOCTL_INIT _IO(BROMETER, 0x01) +#define BAROMETER_GET_PRESS_DATA _IOR(BROMETER, 0x02, int) +#define BAROMETER_GET_TEMP_DATA _IOR(BROMETER, 0x03, int) +#define BAROMETER_IOCTL_READ_CHIPINFO _IOR(BROMETER, 0x04, int) + +#define HEARTMONITOR 0x88 +#define HRM_IOCTL_INIT _IO(HEARTMONITOR, 0x01) +#define HRM_READ_SENSOR_DATA _IOR(HEARTMONITOR, 0x02, int) + +#define HUMIDITY 0X89 +#define HUMIDITY_IOCTL_INIT _IO(HUMIDITY, 0x01) +#define HUMIDITY_GET_HMDY_DATA _IOR(HUMIDITY, 0x02, int) +#define HUMIDITY_GET_TEMP_DATA _IOR(HUMIDITY, 0x03, int) +#define HUMIDITY_IOCTL_READ_CHIPINFO _IOR(HUMIDITY, 0x04, int) + +#endif + diff --git a/kernel-headers/linux/slab.h b/kernel-headers/linux/slab.h new file mode 100644 index 0000000..f3c1408 --- /dev/null +++ b/kernel-headers/linux/slab.h @@ -0,0 +1,21 @@ +/**************************************************************************** + **************************************************************************** + *** + *** This header was automatically generated from a Linux kernel header + *** of the same name, to make information necessary for userspace to + *** call into the kernel available to libc. It contains only constants, + *** structures, and macros generated from the original header, and thus, + *** contains no copyrightable information. + *** + *** To edit the content of this header, modify the corresponding + *** source file (e.g. under external/kernel-headers/original/) then + *** run bionic/libc/kernel/tools/update_all.py + *** + *** Any manual change here will be lost the next time this script will + *** be run. You've been warned! + *** + **************************************************************************** + ****************************************************************************/ +#ifndef _LINUX_SLAB_H +#define _LINUX_SLAB_H +#endif diff --git a/kernel-headers/linux/vow.h b/kernel-headers/linux/vow.h new file mode 100644 index 0000000..4b9a310 --- /dev/null +++ b/kernel-headers/linux/vow.h @@ -0,0 +1,108 @@ +#ifndef __VOW_H__ +#define __VOW_H__ + +/*********************************************************************************** +** VOW Control Message +************************************************************************************/ +#define VOW_DEVNAME "vow" +#define VOW_IOC_MAGIC 'a' + +static char const *const kVOWDeviceName = "/dev/vow"; + +#if 0 +//below is control message +#define TEST_VOW_PRINT _IO(VOW_IOC_MAGIC, 0x00) +#define VOWEINT_GET_BUFSIZE _IOW(VOW_IOC_MAGIC, 0x01, unsigned long) +#define VOW_GET_STATUS _IOW(VOW_IOC_MAGIC, 0x02, unsigned long) +#define VOW_SET_CONTROL _IOW(VOW_IOC_MAGIC, 0x03, unsigned long) +#define VOW_SET_SPEAKER_MODEL _IOW(VOW_IOC_MAGIC, 0x04, unsigned long) +#define VOW_CLR_SPEAKER_MODEL _IOW(VOW_IOC_MAGIC, 0x05, unsigned long) +#define VOW_SET_INIT_MODEL _IOW(VOW_IOC_MAGIC, 0x06, unsigned long) +#define VOW_SET_FIR_MODEL _IOW(VOW_IOC_MAGIC, 0x07, unsigned long) +#define VOW_SET_NOISE_MODEL _IOW(VOW_IOC_MAGIC, 0x08, unsigned long) +#define VOW_SET_APREG_INFO _IOW(VOW_IOC_MAGIC, 0x09, unsigned long) +#define VOW_SET_REG_MODE _IOW(VOW_IOC_MAGIC, 0x0A, unsigned long) +#define VOW_FAKE_WAKEUP _IOW(VOW_IOC_MAGIC, 0x0B, unsigned long) +#else + + +//below is control message +#define TEST_VOW_PRINT 0x00 +#define VOWEINT_GET_BUFSIZE 0x01 +#define VOW_GET_STATUS 0x02 +#define VOW_SET_CONTROL 0x03 +#define VOW_SET_SPEAKER_MODEL 0x04 +#define VOW_CLR_SPEAKER_MODEL 0x05 +#define VOW_SET_INIT_MODEL 0x06 +#define VOW_SET_FIR_MODEL 0x07 +#define VOW_SET_NOISE_MODEL 0x08 +#define VOW_SET_APREG_INFO 0x09 +#define VOW_SET_REG_MODE 0x0A +#define VOW_FAKE_WAKEUP 0x0B + +#endif + + + +/*********************************************************************************** +** Type Define +************************************************************************************/ +enum VOW_Control_Cmd +{ + VOWControlCmd_Init = 0, + VOWControlCmd_ReadVoiceData, + VOWControlCmd_EnableDebug, + VOWControlCmd_DisableDebug, +}; + +typedef enum VOW_REG_MODE_T { + VOW_MODE_MD32_VOW = 0, + VOW_MODE_VOICECOMMAND, + VOW_MODE_MULTIPLE_KEY, + VOW_MODE_MULTIPLE_KEY_VOICECOMMAND +}VOW_REG_MODE_T; + +typedef enum VOW_EINT_STATUS{ + VOW_EINT_DISABLE = -2, + VOW_EINT_FAIL = -1, + VOW_EINT_PASS = 0, + VOW_EINT_RETRY = 1, + NUM_OF_VOW_EINT_STATUS +}VOW_EINT_STATUS; + +typedef enum VOW_FLAG_TYPE{ + VOW_FLAG_DEBUG, + VOW_FLAG_PRE_LEARN, + VOW_FLAG_DMIC_LOWPOWER, + NUM_OF_VOW_FLAG_TYPE +}VOW_FLAG_TYPE; + +typedef enum VOW_PWR_STATUS{ + VOW_PWR_OFF = 0, + VOW_PWR_ON = 1, + NUM_OF_VOW_PWR_STATUS +}VOW_PWR_STATUS; + +typedef enum VOW_IPI_RESULT +{ + VOW_IPI_SUCCESS = 0, + VOW_IPI_CLR_SMODEL_ID_NOTMATCH, + VOW_IPI_SET_SMODEL_NO_FREE_SLOT, +}VOW_IPI_RESULT; +/* +struct VOW_EINT_DATA_STRUCT{ + int size; // size of data section + int eint_status; // eint status + int id; + char *data; // reserved for future extension +}VOW_EINT_DATA_STRUCT; +*/ + +typedef struct{ + long id; + long addr; + long size; + void *data; +}VOW_MODEL_INFO_T; + +#endif //__VOW_H__ |