Initial commit: Linux kernel 4.19 for Unplugged OS

This commit is contained in:
ziv committed 2025-10-06 13:52:42 +00:00
commit d30235b04c
80519 files changed
+35800681

No files matched your search

+91
View File
@@ -0,0 +1,91 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# 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.
#
# common driver code for CMDQ
ccflags-y += -I$(srctree)/drivers/misc/mediatek/cmdq/v2/$(MTK_PLATFORM) \
-I$(srctree)/drivers/misc/mediatek/smi/ \
-I$(srctree)/drivers/misc/mediatek/mmp/ \
-I$(srctree)/drivers/misc/mediatek/mdp/ \
-I$(srctree)/drivers/iommu/ \
-I$(srctree)/drivers/misc/mediatek/m4u/$(MTK_PLATFORM) \
-I$(srctree)/drivers/misc/mediatek/mach/$(MTK_PLATFORM)/include
ccflags-y += -I$(srctree)/kernel
# Enable AEE
ccflags-y += -DCMDQ_AEE_READY
# Enable MET
ccflags-y += -DMET_USER_EVENT_SUPPORT
ifeq ($(CONFIG_MTK_ENG_BUILD),y)
ccflags-y += -D_CMDQ_TEST_PROC_
ccflags-y += -D_CMDQ_DEBUG_
endif
# secure path
ifeq ($(strip $(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT)),y)
ifeq ($(strip $(CONFIG_TRUSTONIC_TEE_SUPPORT)),y)
include $(srctree)/drivers/misc/mediatek/gud/Makefile.include
ccflags-y += -I$(srctree)/drivers/misc/mediatek/cmdq/v2/inc/cmdq_sec_dr \
-I$(srctree)/drivers/misc/mediatek/cmdq/v2/inc/cmdq_sec_tl
ccflags-y += -DCMDQ_SECURE_PATH_SUPPORT
ifneq ($(CONFIG_MTK_CMDQ_TAB),y)
ccflags-y += -DCMDQ_SECURE_PATH_NORMAL_IRQ
endif
ccflags-y += -DCMDQ_EVENT_SVP_BACKUP
endif
endif
# platform dependent definition
ccflags-$(CONFIG_MTK_SMI_EXT) += -DCMDQ_CONFIG_SMI
# ifneq (,$(filter $(CONFIG_MTK_PLATFORM), "mt6755"))
# ccflags-$(CONFIG_MTK_MET) += -DCMDQ_MDP_MET_STATUS
# endif
ccflags-y += -DCMDQ_LARGE_MAX_FIRSTERROR_BUFFER
ccflags-y += -DCMDQ_SPECIAL_ESD_PRIORITY
ccflags-y += -D_CMDQ_DISABLE_MARKER_
#ccflags-y += -DCMDQ_PROFILE_MMP
ifneq (,$(filter $(CONFIG_MTK_PLATFORM), "mt8167" "mt8173"))
#ccflags-y += -DCMDQ_USE_LEGACY
ccflags-y += -I$(srctree)/drivers/misc/mediatek/cmdq/v2/inc/cmdq_sec_dr \
-I$(srctree)/drivers/misc/mediatek/cmdq/v2/inc/cmdq_sec_tl \
-I$(srctree)/drivers/misc/mediatek/include/mt-plat/trustzone
ifeq ($(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT),y)
ccflags-y += -DCMDQ_SECURE_PATH_SUPPORT
endif
endif
# driver module
obj-y += cmdq_record.o
obj-y += cmdq_core.o
obj-y += cmdq_virtual.o
obj-y += cmdq_device.o
obj-y += cmdq_driver.o
obj-y += cmdq_mmp.o
obj-y += cmdq_mdp_common.o
obj-y += cmdq_prof.o
obj-y += cmdq_test.o
ifneq (,$(filter $(CONFIG_MTK_PLATFORM), "mt8167" "mt8173"))
obj-y += cmdq_sec.o
else
obj-y += mtee/
endif
obj-y += $(subst ",,$(CONFIG_MTK_PLATFORM))/
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+473
View File
@@ -0,0 +1,473 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_DEF_H__
#define __CMDQ_DEF_H__
#include <linux/kernel.h>
#define CMDQ_DRIVER_DEVICE_NAME "mtk_cmdq"
/* #define CMDQ_COMMON_ENG_SUPPORT */
#ifdef CMDQ_COMMON_ENG_SUPPORT
#include "cmdq_engine_common.h"
#else
#include "cmdq_engine.h"
#endif
#define CMDQ_SPECIAL_SUBSYS_ADDR (99)
#define CMDQ_GPR_SUPPORT
#define CMDQ_PROFILE_MARKER_SUPPORT
#ifdef CMDQ_PROFILE_MARKER_SUPPORT
#define CMDQ_MAX_PROFILE_MARKER_IN_TASK (5)
#endif
#define CMDQ_INVALID_THREAD (-1)
#define CMDQ_MAX_THREAD_COUNT (16)
#define CMDQ_MAX_TASK_IN_THREAD (16)
#define CMDQ_MAX_READ_SLOT_COUNT (4)
#define CMDQ_INIT_FREE_TASK_COUNT (8)
/* Thread that are high-priority (display threads) */
#define CMDQ_MAX_HIGH_PRIORITY_THREAD_COUNT (7)
#define CMDQ_MIN_SECURE_THREAD_ID (12)
#define CMDQ_MAX_SECURE_THREAD_COUNT (3)
#define CMDQ_MAX_ERROR_COUNT (2)
#define CMDQ_MAX_RETRY_COUNT (1)
/* ram optimization related configuration */
#ifdef CONFIG_MTK_GMO_RAM_OPTIMIZE
#define CMDQ_MAX_RECORD_COUNT (100)
#else
#define CMDQ_MAX_RECORD_COUNT (1024)
#endif
#define CMDQ_INITIAL_CMD_BLOCK_SIZE (PAGE_SIZE)
/* instruction is 64-bit */
#define CMDQ_INST_SIZE (2 * sizeof(uint32_t))
#define CMDQ_CMD_BUFFER_SIZE (PAGE_SIZE - 32 * CMDQ_INST_SIZE)
#define CMDQ_MAX_LOOP_COUNT (1000000)
#define CMDQ_MAX_INST_CYCLE (27)
#define CMDQ_MIN_AGE_VALUE (5)
#define CMDQ_MAX_ERROR_SIZE (8 * 1024)
#define CMDQ_MAX_TASK_IN_SECURE_THREAD (10)
/* max value of CMDQ_THR_EXEC_CMD_CNT (value starts from 0) */
#ifdef CMDQ_USE_LARGE_MAX_COOKIE
#define CMDQ_MAX_COOKIE_VALUE (0xFFFFFFFF)
#else
#define CMDQ_MAX_COOKIE_VALUE (0xFFFF)
#endif
#define CMDQ_ARG_A_SUBSYS_MASK (0x001F0000)
#ifdef CONFIG_MTK_FPGA
#define CMDQ_DEFAULT_TIMEOUT_MS (10000)
#else
#define CMDQ_DEFAULT_TIMEOUT_MS (1000)
#endif
#define CMDQ_ACQUIRE_THREAD_TIMEOUT_MS (2000)
#define CMDQ_PREDUMP_TIMEOUT_MS (200)
#define CMDQ_PREDUMP_RETRY_COUNT (5)
#ifdef CONFIG_OF
#define CMDQ_OF_SUPPORT /* enable device tree support */
#else
#undef CMDQ_OF_SUPPORT
#endif
#ifndef CONFIG_MTK_FPGA
#define CMDQ_PWR_AWARE /* FPGA does not have ClkMgr */
#else
#undef CMDQ_PWR_AWARE
#endif
#ifdef CMDQ_SECURE_PATH_HW_LOCK
#undef CMDQ_SECURE_PATH_NORMAL_IRQ
#endif
/* #define CMDQ_DUMP_GIC (0) */
/* #define CMDQ_PROFILE_MMP (0) */
#define CMDQ_DUMP_FIRSTERROR
/* #define CMDQ_INSTRUCTION_COUNT */
enum CMDQ_HW_THREAD_PRIORITY_ENUM {
CMDQ_THR_PRIO_SUPERLOW = 0, /* low priority monitor loop */
CMDQ_THR_PRIO_NORMAL = 1, /* nomral priority */
/* trigger loop (enables display mutex) */
CMDQ_THR_PRIO_DISPLAY_TRIGGER = 2,
/* display ESD check (every 2 secs) */
#ifdef CMDQ_SPECIAL_ESD_PRIORITY
CMDQ_THR_PRIO_DISPLAY_ESD = 3,
#else
CMDQ_THR_PRIO_DISPLAY_ESD = 4,
#endif
/* display config (every frame) */
CMDQ_THR_PRIO_DISPLAY_CONFIG = 4,
/* High priority monitor loop */
CMDQ_THR_PRIO_SUPERHIGH = 5,
/* maximum possible priority */
CMDQ_THR_PRIO_MAX = 7,
};
enum CMDQ_SCENARIO_ENUM {
CMDQ_SCENARIO_JPEG_DEC = 0,
CMDQ_SCENARIO_PRIMARY_DISP = 1,
CMDQ_SCENARIO_PRIMARY_MEMOUT = 2,
CMDQ_SCENARIO_PRIMARY_ALL = 3,
CMDQ_SCENARIO_SUB_DISP = 4,
CMDQ_SCENARIO_SUB_MEMOUT = 5,
CMDQ_SCENARIO_SUB_ALL = 6,
CMDQ_SCENARIO_MHL_DISP = 7,
CMDQ_SCENARIO_RDMA0_DISP = 8,
CMDQ_SCENARIO_RDMA0_COLOR0_DISP = 9,
CMDQ_SCENARIO_RDMA1_DISP = 10,
/* Trigger loop scenario does not enable HWs */
CMDQ_SCENARIO_TRIGGER_LOOP = 11,
/* client from user space, so the cmd buffer is in user space. */
CMDQ_SCENARIO_USER_MDP = 12,
CMDQ_SCENARIO_DEBUG = 13,
CMDQ_SCENARIO_DEBUG_PREFETCH = 14,
/* ESD check */
CMDQ_SCENARIO_DISP_ESD_CHECK = 15,
/* for screen capture to wait for */
/* RDMA-done without blocking config thread */
CMDQ_SCENARIO_DISP_SCREEN_CAPTURE = 16,
/* notifiy there are some tasks exec done in secure path */
CMDQ_SCENARIO_SECURE_NOTIFY_LOOP = 17,
CMDQ_SCENARIO_DISP_PRIMARY_DISABLE_SECURE_PATH = 18,
CMDQ_SCENARIO_DISP_SUB_DISABLE_SECURE_PATH = 19,
/* color path request from kernel */
CMDQ_SCENARIO_DISP_COLOR = 20,
/* color path request from user sapce */
CMDQ_SCENARIO_USER_DISP_COLOR = 21,
/* [phased out]client from user space, */
/* so the cmd buffer is in user space. */
CMDQ_SCENARIO_USER_SPACE = 22,
CMDQ_SCENARIO_DISP_MIRROR_MODE = 23,
CMDQ_SCENARIO_DISP_CONFIG_AAL = 24,
CMDQ_SCENARIO_DISP_CONFIG_PRIMARY_GAMMA = 25,
CMDQ_SCENARIO_DISP_CONFIG_SUB_GAMMA = 26,
CMDQ_SCENARIO_DISP_CONFIG_PRIMARY_DITHER = 27,
CMDQ_SCENARIO_DISP_CONFIG_SUB_DITHER = 28,
CMDQ_SCENARIO_DISP_CONFIG_PRIMARY_PWM = 29,
CMDQ_SCENARIO_DISP_CONFIG_SUB_PWM = 30,
CMDQ_SCENARIO_DISP_CONFIG_PRIMARY_PQ = 31,
CMDQ_SCENARIO_DISP_CONFIG_SUB_PQ = 32,
CMDQ_SCENARIO_DISP_CONFIG_OD = 33,
CMDQ_SCENARIO_RDMA2_DISP = 34,
/* for primary trigger loop enable pre-fetch usage */
CMDQ_SCENARIO_HIGHP_TRIGGER_LOOP = 35,
/* for low priority monitor loop to polling bus status */
CMDQ_SCENARIO_LOWP_TRIGGER_LOOP = 36,
CMDQ_SCENARIO_KERNEL_CONFIG_GENERAL = 37,
CMDQ_MAX_SCENARIO_COUNT /* ALWAYS keep at the end */
};
enum CMDQ_DATA_REGISTER_ENUM {
/* Value Reg, we use 32-bit */
/* Address Reg, we use 64-bit */
/* Note that R0-R15 and P0-P7 actullay share same memory */
/* and R1 cannot be used. */
CMDQ_DATA_REG_JPEG = 0x00, /* R0 */
CMDQ_DATA_REG_JPEG_DST = 0x11, /* P1 */
CMDQ_DATA_REG_PQ_COLOR = 0x04, /* R4 */
CMDQ_DATA_REG_PQ_COLOR_DST = 0x13, /* P3 */
CMDQ_DATA_REG_2D_SHARPNESS_0 = 0x05, /* R5 */
CMDQ_DATA_REG_2D_SHARPNESS_0_DST = 0x14, /* P4 */
CMDQ_DATA_REG_2D_SHARPNESS_1 = 0x0a, /* R10 */
CMDQ_DATA_REG_2D_SHARPNESS_1_DST = 0x16, /* P6 */
CMDQ_DATA_REG_DEBUG = 0x0b, /* R11 */
CMDQ_DATA_REG_DEBUG_DST = 0x17, /* P7 */
/* sentinel value for invalid register ID */
CMDQ_DATA_REG_INVALID = -1,
};
enum CMDQ_MDP_PA_BASE_ENUM {
CMDQ_MDP_PA_BASE_MM_MUTEX,
CMDQ_MAX_MDP_PA_BASE_COUNT, /* ALWAYS keep at the end */
};
struct cmdq_event_table {
u16 event; /* cmdq event enum value */
const char *event_name;
const char *dts_name;
};
/* CMDQ Events */
#undef DECLARE_CMDQ_EVENT
#define DECLARE_CMDQ_EVENT(name_struct, val, dts_name) name_struct = val,
enum CMDQ_EVENT_ENUM {
#include "cmdq_event_common.h"
};
#undef DECLARE_CMDQ_EVENT
#undef DECLARE_CMDQ_EVENT
#define DECLARE_CMDQ_EVENT(event_enum, val, dts_name) \
{event_enum, #event_enum, #dts_name},
static struct cmdq_event_table cmdq_events[] = {
#include "cmdq_event_common.h"
};
#undef DECLARE_CMDQ_EVENT
/* CMDQ subsys */
#undef DECLARE_CMDQ_SUBSYS
#define DECLARE_CMDQ_SUBSYS(name_struct, val, grp, dts_name) name_struct = val,
enum CMDQ_SUBSYS_ENUM {
#include "cmdq_subsys_common.h"
/* ALWAYS keep at the end */
CMDQ_SUBSYS_MAX_COUNT
};
#undef DECLARE_CMDQ_SUBSYS
#define CMDQ_SUBSYS_GRPNAME_MAX (30)
/* GCE subsys information */
struct SubsysStruct {
uint32_t msb;
int32_t subsysID;
uint32_t mask;
char grpName[CMDQ_SUBSYS_GRPNAME_MAX];
};
struct cmdqDTSDataStruct {
/* [Out] GCE event table */
int32_t eventTable[CMDQ_SYNC_TOKEN_MAX];
/* [Out] GCE subsys ID table */
struct SubsysStruct subsys[CMDQ_SUBSYS_MAX_COUNT];
/* [Out] MDP Base address */
uint32_t MDPBaseAddress[CMDQ_MAX_MDP_PA_BASE_COUNT];
};
/* Custom "wide" pointer type for 64-bit job handle (pointer to VA) */
/* typedef unsigned long long cmdqJobHandle_t; */
#define cmdqJobHandle_t unsigned long long
/* Custom "wide" pointer type for 64-bit */
/* compatibility. Always cast from uint32_t*. */
/* typedef unsigned long long cmdqU32Ptr_t; */
#define cmdqU32Ptr_t unsigned long long
#define CMDQ_U32_PTR(x) ((uint32_t *)(unsigned long)x)
struct cmdqReadRegStruct {
uint32_t count; /* number of entries in regAddresses */
/* an array of 32-bit register addresses (uint32_t) */
cmdqU32Ptr_t regAddresses;
};
struct cmdqRegValueStruct {
/* number of entries in result */
uint32_t count;
/* array of 32-bit register values (uint32_t). */
/* in the same order as cmdqReadRegStruct */
cmdqU32Ptr_t regValues;
};
struct cmdqReadAddressStruct {
uint32_t count; /* [IN] number of entries in result. */
/* [IN] array of physical addresses to read. */
/* these value must allocated by CMDQ_IOCTL_ALLOC_WRITE_ADDRESS ioctl */
/* */
/* indeed param dmaAddresses should be */
/* UNSIGNED LONG type for 64 bit kernel. */
/* Considering our plartform supports max */
/* 4GB RAM(upper-32bit don't care for SW) */
/* and consistent common code interface, remain uint32_t type. */
cmdqU32Ptr_t dmaAddresses;
/* [OUT] uint32_t values that dmaAddresses point into */
cmdqU32Ptr_t values;
};
/*
* Secure address metadata:
* According to handle type, translate handle and replace (_d)th instruciton to
* 1. sec_addr = hadnle_sec_base_addr(baseHandle) + offset(_b)
* 2. sec_mva = mva( hadnle_sec_base_addr(baseHandle) + offset(_b) )
* 3. secure world normal mva = map(baseHandle)
* . pass normal mva to parameter baseHandle
* . use case: OVL reads from secure and normal buffers at the same time)
*/
enum CMDQ_SEC_ADDR_METADATA_TYPE {
CMDQ_SAM_H_2_PA = 0, /* sec handle to sec PA */
CMDQ_SAM_H_2_MVA = 1, /* sec handle to sec MVA */
/* map normal MVA to secure world */
CMDQ_SAM_NMVA_2_MVA = 2,
/* DDP register needs to set opposite value when HDCP fail */
CMDQ_SAM_DDP_REG_HDCP = 3,
};
struct cmdqSecAddrMetadataStruct {
/* [IN]_d, index of instruction. Update its */
/* arg_b value to real PA/MVA in secure world */
uint32_t instrIndex;
/*
* Note: Buffer and offset
*
* -------------
* | | |
* -------------
* ^ ^ ^ ^
* A B C D
*
* A: baseHandle
* B: baseHandle + blockOffset
* C: baseHandle + blockOffset + offset
* A~B or B~D: size
*/
uint32_t type; /* [IN] addr handle type */
uint64_t baseHandle; /* [IN]_h, secure address handle */
/* [IN]_b, block offset from handle(PA) to current block(plane) */
uint32_t blockOffset;
uint32_t offset; /* [IN]_b, buffser offset to secure handle */
uint32_t size; /* buffer size */
uint32_t port; /* hw port id (i.e. M4U port id) */
uint32_t sec_id;
uint32_t useSecIdinMeta;
int32_t ionFd;
};
/* tablet use */
enum CMDQ_DISP_MODE {
CMDQ_DISP_NON_SUPPORTED_MODE = 0,
CMDQ_DISP_SINGLE_MODE = 1,
CMDQ_DISP_VIDEO_MODE = 2,
CMDQ_MDP_USER_MODE = 3,
};
struct cmdqSecDataStruct {
bool is_secure; /* [IN]true for secure command */
/* address metadata, used to translate secure */
/* buffer PA related instruction in secure world */
uint32_t addrMetadataCount; /* [IN] count of element in addrList */
/* [IN] array of cmdqSecAddrMetadataStruct */
cmdqU32Ptr_t addrMetadatas;
uint32_t addrMetadataMaxCount; /*[Reserved] */
uint64_t enginesNeedDAPC;
uint64_t enginesNeedPortSecurity;
/* [Reserved] This is for CMDQ driver usage itself. Not for client. */
/* task index in thread's tasklist. -1 for not in tasklist. */
int32_t waitCookie;
bool resetExecCnt; /* reset HW thread in SWd */
uint64_t extension;
#ifdef CONFIG_MTK_CMDQ_TAB
/* tablet use */
enum CMDQ_DISP_MODE secMode;
/* for MDP to copy HDCP version from srcHandle to dstHandle */
/* will remove later */
uint32_t srcHandle;
uint32_t dstHandle;
#endif
};
struct cmdq_v3_replace_struct {
/* [IN] count of element in instr_position */
uint32_t number;
/* [IN] position of instruction */
cmdqU32Ptr_t position;
};
#ifdef CMDQ_PROFILE_MARKER_SUPPORT
struct cmdqProfileMarkerStruct {
uint32_t count;
/* i.e. cmdqBackupSlotHandle, physical start address of backup slot */
long long hSlot;
cmdqU32Ptr_t tag[CMDQ_MAX_PROFILE_MARKER_IN_TASK];
};
#endif
struct cmdqCommandStruct {
/* [IN] deprecated. will remove in the future. */
uint32_t scenario;
/* [IN] task schedule priority. this is NOT HW thread priority. */
uint32_t priority;
/* [IN] bit flag of engines used. */
uint64_t engineFlag;
/* [IN] pointer to instruction buffer. Use 64-bit for compatibility. */
/* This must point to an 64-bit aligned uint32_t array */
cmdqU32Ptr_t pVABase;
/* [IN] size of instruction buffer, in bytes. */
uint32_t blockSize;
/* [IN] request to read register values at the end of command */
struct cmdqReadRegStruct regRequest;
/* [OUT] register values of regRequest */
struct cmdqRegValueStruct regValue;
/* [IN/OUT] physical addresses to read value */
struct cmdqReadAddressStruct readAddress;
/* [IN] secure execution data */
struct cmdqSecDataStruct secData;
/* [IN] set to non-zero to enable register debug dump. */
uint32_t debugRegDump;
/* [Reserved] This is for CMDQ driver usage itself. */
/* Not for client. Do not access this field from User Space */
cmdqU32Ptr_t privateData;
#ifdef CMDQ_PROFILE_MARKER_SUPPORT
struct cmdqProfileMarkerStruct profileMarker;
#endif
cmdqU32Ptr_t userDebugStr;
uint32_t userDebugStrLen;
};
enum CMDQ_CAP_BITS {
/* bit 0: TRUE if WFE instruction support */
/* is ready. FALSE if we need to POLL instead. */
CMDQ_CAP_WFE = 0,
};
/**
* reply struct for cmdq_sec_cancel_error_task
*/
struct cmdqSecCancelTaskResultStruct {
/* [OUT] */
bool throwAEE;
bool hasReset;
int32_t irqFlag;
uint32_t errInstr[2];
uint32_t regValue;
uint32_t pc;
};
#endif /* __CMDQ_DEF_H__ */
+644
View File
@@ -0,0 +1,644 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2020 MediaTek Inc.
*/
#include "cmdq_device.h"
#include "cmdq_core.h"
#include "cmdq_virtual.h"
#ifndef CMDQ_OF_SUPPORT
#include <mach/mt_irq.h>
#endif
#ifdef CONFIG_MTK_CMDQ_TAB
/* CCF */
#ifdef CMDQ_OF_SUPPORT
#include <linux/clk.h>
#include <linux/clk-provider.h>
#endif
#endif
/* device tree */
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/of_address.h>
#include <linux/io.h>
#include <linux/dma-mapping.h>
/* #include <mt-plat/mtk_lpae.h> */
struct CmdqDeviceStruct {
struct device *pDev;
struct clk *clk_gce;
long regBaseVA; /* considering 64 bit kernel, use long */
long regBasePA;
uint32_t irqId;
uint32_t irqSecId;
int32_t dma_mask_result;
};
static struct CmdqDeviceStruct gCmdqDev;
static long gMMSYS_CONFIG_Base_VA;
static long gAPXGPT2Count;
static uint32_t gMMSYSDummyRegOffset;
struct device *cmdq_dev_get(void)
{
return gCmdqDev.pDev;
}
uint32_t cmdq_dev_get_irq_id(void)
{
return gCmdqDev.irqId;
}
uint32_t cmdq_dev_get_irq_secure_id(void)
{
return gCmdqDev.irqSecId;
}
long cmdq_dev_get_module_base_VA_GCE(void)
{
return gCmdqDev.regBaseVA;
}
long cmdq_dev_get_module_base_PA_GCE(void)
{
return gCmdqDev.regBasePA;
}
int32_t cmdq_dev_get_dma_mask_result(void)
{
return gCmdqDev.dma_mask_result;
}
long cmdq_dev_get_module_base_VA_MMSYS_CONFIG(void)
{
return gMMSYS_CONFIG_Base_VA;
}
void cmdq_dev_set_module_base_VA_MMSYS_CONFIG(long value)
{
gMMSYS_CONFIG_Base_VA = value;
}
long cmdq_dev_get_APXGPT2_count(void)
{
return gAPXGPT2Count;
}
uint32_t cmdq_dev_get_mmsys_dummy_reg_offset(void)
{
return gMMSYSDummyRegOffset;
}
void cmdq_dev_init_module_base_VA(void)
{
gMMSYS_CONFIG_Base_VA = 0;
#ifdef CMDQ_OF_SUPPORT
gMMSYS_CONFIG_Base_VA = cmdq_dev_alloc_module_base_VA_by_name(
"mediatek,mmsys_config");
if (gMMSYS_CONFIG_Base_VA == 0)
gMMSYS_CONFIG_Base_VA = cmdq_dev_alloc_module_base_VA_by_name(
"mediatek,MMSYS_CONFIG");
#endif
cmdq_mdp_get_func()->initModuleBaseVA();
}
void cmdq_dev_deinit_module_base_VA(void)
{
#ifdef CMDQ_OF_SUPPORT
cmdq_dev_free_module_base_VA(
cmdq_dev_get_module_base_VA_MMSYS_CONFIG());
#else
/* do nothing, registers' IOMAP will be destroyed by platform */
#endif
cmdq_mdp_get_func()->deinitModuleBaseVA();
}
long cmdq_dev_alloc_module_base_VA_by_name(const char *name)
{
unsigned long VA = 0L;
struct device_node *node = NULL;
node = of_find_compatible_node(NULL, NULL, name);
if (node != NULL)
VA = (unsigned long)of_iomap(node, 0);
CMDQ_LOG("DEV: VA(%s): 0x%lx\n", name, VA);
return VA;
}
void cmdq_dev_free_module_base_VA(const long VA)
{
iounmap((void *)VA);
}
long cmdq_dev_get_gce_node_PA(struct device_node *node, int index)
{
struct resource res;
int status;
long regBasePA = 0L;
do {
status = of_address_to_resource(node, index, &res);
if (status < 0)
break;
regBasePA = (0L | res.start);
} while (0);
return regBasePA;
}
struct CmdqModuleClock {
struct clk *clk_SMI_COMMON;
struct clk *clk_SMI_LARB0;
struct clk *clk_MTCMOS_DIS;
};
static struct CmdqModuleClock gCmdqModuleClock;
#define IMP_ENABLE_HW_CLOCK(FN_NAME, HW_NAME) \
uint32_t cmdq_dev_enable_clock_##FN_NAME(bool enable) \
{ \
return cmdq_dev_enable_device_clock(enable, \
gCmdqModuleClock.clk_##HW_NAME, #HW_NAME "-clk"); \
}
void cmdq_dev_get_module_clock_by_dev(struct device *dev,
const char *clkName,
struct clk **clk_module)
{
*clk_module = devm_clk_get(dev, clkName);
if (IS_ERR(*clk_module)) {
/* error status print */
CMDQ_ERR("DEV: cannot get module clock: %s\n", clkName);
} else {
/* message print */
CMDQ_MSG("DEV: get module clock: %s\n", clkName);
}
}
void cmdq_dev_get_module_clock_by_name(const char *name,
const char *clkName,
struct clk **clk_module)
{
struct device_node *node = NULL;
node = of_find_compatible_node(NULL, NULL, name);
*clk_module = of_clk_get_by_name(node, clkName);
if (IS_ERR(*clk_module)) {
/* error status print */
CMDQ_ERR("DEV: byName: cannot get module clock: %s\n", clkName);
} else {
/* message print */
CMDQ_MSG("DEV: byName: get module clock: %s\n", clkName);
}
}
uint32_t cmdq_dev_enable_device_clock(bool enable,
struct clk *clk_module, const char *clkName)
{
int result = 0;
if (IS_ERR(clk_module))
return PTR_ERR(clk_module);
if (enable) {
result = clk_prepare_enable(clk_module);
CMDQ_MSG("enable clock with module: %s, result: %d\n",
clkName, result);
} else {
clk_disable_unprepare(clk_module);
CMDQ_MSG("disable clock with module: %s\n", clkName);
}
return result;
}
#ifdef CONFIG_MTK_CMDQ_TAB
bool cmdq_dev_gce_clock_is_on(void)
{
if (__clk_get_enable_count(gCmdqDev.clk_gce) > 0)
return 1;
else
return 0;
}
#endif
bool cmdq_dev_device_clock_is_enable(struct clk *clk_module)
{
return true;
}
/* special handle for MTCMOS */
uint32_t cmdq_dev_enable_clock_SMI_COMMON(bool enable)
{
if (enable) {
cmdq_dev_enable_device_clock(enable,
gCmdqModuleClock.clk_MTCMOS_DIS,
"MTCMOS_DIS-clk");
cmdq_dev_enable_device_clock(enable,
gCmdqModuleClock.clk_SMI_COMMON,
"SMI_COMMON-clk");
} else {
cmdq_dev_enable_device_clock(enable,
gCmdqModuleClock.clk_SMI_COMMON,
"SMI_COMMON-clk");
cmdq_dev_enable_device_clock(enable,
gCmdqModuleClock.clk_MTCMOS_DIS,
"MTCMOS_DIS-clk");
}
return 0;
}
IMP_ENABLE_HW_CLOCK(SMI_LARB0, SMI_LARB0);
#undef IMP_ENABLE_HW_CLOCK
/* Common Clock Framework */
void cmdq_dev_init_module_clk(void)
{
#if defined(CMDQ_OF_SUPPORT)
cmdq_dev_get_module_clock_by_name("mediatek,smi_common", "smi-common",
&gCmdqModuleClock.clk_SMI_COMMON);
cmdq_dev_get_module_clock_by_name("mediatek,smi_common", "smi-larb0",
&gCmdqModuleClock.clk_SMI_LARB0);
cmdq_dev_get_module_clock_by_name("mediatek,smi_common", "mtcmos-dis",
&gCmdqModuleClock.clk_MTCMOS_DIS);
#ifdef CMDQ_USE_LEGACY
cmdq_mdp_get_func()->mdpInitModuleClkMutex32K();
#endif
#endif
cmdq_mdp_get_func()->initModuleCLK();
}
void cmdq_dev_enable_gce_clock(bool enable)
{
cmdq_dev_enable_device_clock(enable, gCmdqDev.clk_gce, "gce-clk");
}
bool cmdq_dev_gce_clock_is_enable(void)
{
return cmdq_dev_device_clock_is_enable(gCmdqDev.clk_gce);
}
void cmdq_dev_get_module_PA(const char *name, int index,
long *startPA, long *endPA)
{
int status;
struct device_node *node = NULL;
struct resource res;
do {
node = of_find_compatible_node(NULL, NULL, name);
if (node == NULL)
break;
status = of_address_to_resource(node, index, &res);
if (status < 0)
break;
*startPA = res.start;
*endPA = res.end;
CMDQ_MSG("DEV: PA(%s): start = 0x%lx, end = 0x%lx\n",
name, *startPA, *endPA);
} while (0);
}
/* Get MDP base address to user space */
void cmdq_dev_init_MDP_PA(struct device_node *node)
{
#ifdef CMDQ_OF_SUPPORT
int status;
uint32_t gceDispMutex[2] = {0, 0};
uint32_t *pMDPBaseAddress =
cmdq_core_get_whole_DTS_Data()->MDPBaseAddress;
long module_pa_start = 0;
long module_pa_end = 0;
cmdq_dev_get_module_PA("mediatek,mm_mutex", 0,
&module_pa_start,
&module_pa_end);
if (module_pa_start == 0)
cmdq_mdp_get_func()->mdpGetModulePa(&module_pa_start,
&module_pa_end);
if (module_pa_start == 0) {
CMDQ_ERR("DEV: init mm_mutex PA fail!!\n");
do {
status = of_property_read_u32_array(node,
"disp_mutex_reg",
gceDispMutex, ARRAY_SIZE(gceDispMutex));
if (status < 0)
break;
pMDPBaseAddress[CMDQ_MDP_PA_BASE_MM_MUTEX] =
gceDispMutex[0];
} while (0);
} else {
pMDPBaseAddress[CMDQ_MDP_PA_BASE_MM_MUTEX] = module_pa_start;
}
CMDQ_MSG("MM_MUTEX PA: start = 0x%x\n",
pMDPBaseAddress[CMDQ_MDP_PA_BASE_MM_MUTEX]);
#endif
}
#ifdef CMDQ_OF_SUPPORT
void cmdq_dev_get_subsys_by_name(struct device_node *node,
enum CMDQ_SUBSYS_ENUM subsys,
const char *grp_name, const char *dts_name)
{
int status;
uint32_t gceSubsys[3] = { 0, 0, 0 };
struct SubsysStruct *gceSubsysStruct = NULL;
do {
if (subsys < 0 || subsys >= CMDQ_SUBSYS_MAX_COUNT)
break;
gceSubsysStruct = cmdq_core_get_whole_DTS_Data()->subsys;
status = of_property_read_u32_array(node, dts_name, gceSubsys,
ARRAY_SIZE(gceSubsys));
if (status < 0) {
gceSubsysStruct[subsys].subsysID = -1;
break;
}
gceSubsysStruct[subsys].msb = gceSubsys[0] & gceSubsys[2];
gceSubsysStruct[subsys].subsysID = gceSubsys[1];
gceSubsysStruct[subsys].mask = gceSubsys[2];
strncpy(gceSubsysStruct[subsys].grpName, grp_name,
CMDQ_SUBSYS_GRPNAME_MAX-1);
} while (0);
}
void cmdq_dev_test_subsys_correctness_impl(
enum CMDQ_SUBSYS_ENUM subsys)
{
struct SubsysStruct *gceSubsysStruct = NULL;
if (subsys >= 0 && subsys < CMDQ_SUBSYS_MAX_COUNT) {
gceSubsysStruct = cmdq_core_get_whole_DTS_Data()->subsys;
if (gceSubsysStruct[subsys].subsysID != -1) {
/* print subsys information from device tree */
CMDQ_LOG("(%s), msb: 0x%08x, %d, 0x%08x\n",
gceSubsysStruct[subsys].grpName,
gceSubsysStruct[subsys].msb,
gceSubsysStruct[subsys].subsysID,
gceSubsysStruct[subsys].mask);
}
}
}
#endif
void cmdq_dev_init_subsys(struct device_node *node)
{
#ifdef CMDQ_OF_SUPPORT
#undef DECLARE_CMDQ_SUBSYS
#define DECLARE_CMDQ_SUBSYS(name, val, grp, dts_name) \
{ \
cmdq_dev_get_subsys_by_name(node, val, #grp, #dts_name); \
}
#include "cmdq_subsys_common.h"
#undef DECLARE_CMDQ_SUBSYS
#endif
}
#ifdef CMDQ_OF_SUPPORT
void cmdq_dev_get_event_value_by_name(struct device_node *node,
enum CMDQ_EVENT_ENUM event, const char *dts_name)
{
int status;
uint32_t event_value;
do {
if (event < 0 || event >= CMDQ_MAX_HW_EVENT_COUNT)
break;
status = of_property_read_u32(node, dts_name, &event_value);
if (status < 0)
break;
cmdq_core_set_event_table(event, event_value);
} while (0);
}
void cmdq_dev_test_event_correctness_impl(enum CMDQ_EVENT_ENUM event,
const char *event_name)
{
int32_t eventValue = cmdq_core_get_event_value(event);
if (eventValue >= 0 && eventValue < CMDQ_SYNC_TOKEN_MAX) {
/* print event name from device tree */
CMDQ_LOG("%s = %d\n", event_name, eventValue);
}
}
#endif
struct cmdq_event_table *cmdq_event_get_table(void)
{
return cmdq_events;
}
u32 cmdq_event_get_table_size(void)
{
return ARRAY_SIZE(cmdq_events);
}
void cmdq_dev_init_event_table(struct device_node *node)
{
#ifdef CMDQ_OF_SUPPORT
struct cmdq_event_table *events = cmdq_event_get_table();
u32 table_size = cmdq_event_get_table_size();
u32 i = 0;
for (i = 0; i < table_size; i++) {
if (events[i].event == (u32)CMDQ_MAX_HW_EVENT_COUNT)
break;
cmdq_dev_get_event_value_by_name(node, events[i].event,
events[i].dts_name);
}
#endif
}
void cmdq_dev_test_dts_correctness(void)
{
#ifdef CMDQ_OF_SUPPORT
#undef DECLARE_CMDQ_EVENT
#define DECLARE_CMDQ_EVENT(name, val, dts_name) \
{ \
cmdq_dev_test_event_correctness_impl(val, #name); \
}
#include "cmdq_event_common.h"
#undef DECLARE_CMDQ_EVENT
#undef DECLARE_CMDQ_SUBSYS
#define DECLARE_CMDQ_SUBSYS(name, val, grp, dts_name) \
{ \
cmdq_dev_test_subsys_correctness_impl(val); \
}
#include "cmdq_subsys_common.h"
#undef DECLARE_CMDQ_SUBSYS
CMDQ_LOG("APXGPT2_Count = 0x%08lx\n", gAPXGPT2Count);
#endif
}
void cmdq_dev_get_dts_setting(struct cmdq_dts_setting *dts_setting)
{
int status;
do {
status = of_property_read_u32(gCmdqDev.pDev->of_node,
"max_prefetch_cnt",
&dts_setting->prefetch_thread_count);
if (status < 0)
break;
status = of_property_read_u32_array(gCmdqDev.pDev->of_node,
"prefetch_size",
dts_setting->prefetch_size,
dts_setting->prefetch_thread_count);
if (status < 0)
break;
} while (0);
}
void cmdq_dev_init_resource(CMDQ_DEV_INIT_RESOURCE_CB init_cb)
{
int status, index;
uint32_t count;
do {
status = of_property_read_u32(gCmdqDev.pDev->of_node,
"sram_share_cnt", &count);
if (status < 0)
break;
for (index = 0; index < count; index++) {
uint32_t engine, event;
status = of_property_read_u32_index(
gCmdqDev.pDev->of_node, "sram_share_engine",
index, &engine);
if (status < 0)
break;
status = of_property_read_u32_index(
gCmdqDev.pDev->of_node, "sram_share_event",
index, &event);
if (status < 0)
break;
if (init_cb != NULL)
init_cb(engine, event);
}
} while (0);
}
void cmdq_dev_init_device_tree(struct device_node *node)
{
int status;
uint32_t apxgpt2_count_value = 0;
uint32_t mmsys_dummy_reg_offset_value = 0;
gAPXGPT2Count = 0;
gMMSYSDummyRegOffset = 0;
cmdq_core_init_DTS_data();
#ifdef CMDQ_OF_SUPPORT
/* init GCE subsys */
cmdq_dev_init_subsys(node);
/* init event table */
cmdq_dev_init_event_table(node);
/* init MDP PA address */
cmdq_dev_init_MDP_PA(node);
status = of_property_read_u32(node, "apxgpt2_count",
&apxgpt2_count_value);
if (status >= 0)
gAPXGPT2Count = apxgpt2_count_value;
/* read dummy register offset from device tree,
* usually DUMMY_3 because DUMMY_0/1 is CLKMGR SW.
*/
status = of_property_read_u32(node, "mmsys_dummy_reg_offset",
&mmsys_dummy_reg_offset_value);
if (status < 0) {
/* in legency chip (before mt6757) */
/* dummy register offset fixed */
#ifdef CMDQ_USE_LEGACY
mmsys_dummy_reg_offset_value = 0x890;
#else
mmsys_dummy_reg_offset_value = 0x89C;
#endif
}
gMMSYSDummyRegOffset = mmsys_dummy_reg_offset_value;
#endif
}
void cmdq_dev_init(struct platform_device *pDevice)
{
struct device_node *node = pDevice->dev.of_node;
/* init cmdq device dependent data */
do {
memset(&gCmdqDev, 0x0, sizeof(struct CmdqDeviceStruct));
gCmdqDev.pDev = &pDevice->dev;
#ifdef CMDQ_OF_SUPPORT
gCmdqDev.regBaseVA = (unsigned long)of_iomap(node, 0);
gCmdqDev.regBasePA = cmdq_dev_get_gce_node_PA(node, 0);
gCmdqDev.irqId = irq_of_parse_and_map(node, 0);
gCmdqDev.irqSecId = irq_of_parse_and_map(node, 1);
gCmdqDev.clk_gce = devm_clk_get(&pDevice->dev, "GCE");
if (IS_ERR(gCmdqDev.clk_gce))
gCmdqDev.clk_gce = devm_clk_get(&pDevice->dev,
"MT_CG_INFRA_GCE");
#endif
CMDQ_LOG("[CMDQ] platform_dev: dev: %p, PA: %lx, VA: %lx\n",
gCmdqDev.pDev, gCmdqDev.regBasePA,
gCmdqDev.regBaseVA);
CMDQ_LOG("[CMDQ] irqId: %d, irqSecId:%d\n",
gCmdqDev.irqId,
gCmdqDev.irqSecId);
} while (0);
if (!enable_4G()) {
/* Not special 4GB case, use dma_mask to */
/* restrict dma memory to low 4GB address */
gCmdqDev.dma_mask_result = dma_set_coherent_mask(
&pDevice->dev, DMA_BIT_MASK(32));
CMDQ_LOG("set dma mask result: %d\n", gCmdqDev.dma_mask_result);
}
/* init module VA */
cmdq_dev_init_module_base_VA();
/* init module clock */
cmdq_dev_init_module_clk();
/* init module PA for instruction count */
cmdq_get_func()->initModulePAStat();
/* init load HW information from device tree */
cmdq_dev_init_device_tree(node);
}
void cmdq_dev_deinit(void)
{
cmdq_dev_deinit_module_base_VA();
/* deinit cmdq device dependent data */
do {
#ifdef CMDQ_OF_SUPPORT
cmdq_dev_free_module_base_VA(cmdq_dev_get_module_base_VA_GCE());
gCmdqDev.regBaseVA = 0;
#else
/* do nothing */
#endif
} while (0);
}
@@ -0,0 +1,81 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_DEVICE_H__
#define __CMDQ_DEVICE_H__
#include <linux/platform_device.h>
#include <linux/device.h>
#include "cmdq_def.h"
#include "cmdq_mdp_common.h"
#include <linux/clk.h>
#define DECLARE_ENABLE_HW_CLOCK(HW_NAME) \
uint32_t cmdq_dev_enable_clock_##HW_NAME(bool enable)
DECLARE_ENABLE_HW_CLOCK(SMI_COMMON);
DECLARE_ENABLE_HW_CLOCK(SMI_LARB0);
#ifdef CMDQ_USE_LEGACY
DECLARE_ENABLE_HW_CLOCK(MUTEX_32K);
#endif
#undef DECLARE_ENABLE_HW_CLOCK
void cmdq_dev_get_module_clock_by_name(const char *name,
const char *clkName,
struct clk **clk_module);
uint32_t cmdq_dev_enable_device_clock(bool enable,
struct clk *clk_module, const char *clkName);
#ifdef CONFIG_MTK_CMDQ_TAB
bool cmdq_dev_gce_clock_is_on(void);
#endif
bool cmdq_dev_device_clock_is_enable(struct clk *clk_module);
/* For test case used */
void testcase_clkmgr_impl(enum CMDQ_ENG_ENUM engine,
char *name,
const unsigned long testWriteReg,
const uint32_t testWriteValue,
const unsigned long testReadReg,
const bool verifyWriteResult);
struct device *cmdq_dev_get(void);
/* interrupt index */
uint32_t cmdq_dev_get_irq_id(void);
uint32_t cmdq_dev_get_irq_secure_id(void);
/* GCE clock */
void cmdq_dev_enable_gce_clock(bool enable);
bool cmdq_dev_gce_clock_is_enable(void);
/* virtual address */
long cmdq_dev_get_module_base_VA_GCE(void);
long cmdq_dev_get_module_base_VA_MMSYS_CONFIG(void);
void cmdq_dev_set_module_base_VA_MMSYS_CONFIG(long value);
long cmdq_dev_alloc_module_base_VA_by_name(const char *name);
/* Other modules information */
void cmdq_dev_free_module_base_VA(const long VA);
long cmdq_dev_get_APXGPT2_count(void);
uint32_t cmdq_dev_get_mmsys_dummy_reg_offset(void);
/* physical address */
void cmdq_dev_get_module_PA(const char *name, int index,
long *startPA, long *endPA);
long cmdq_dev_get_module_base_PA_GCE(void);
/* GCE event */
void cmdq_dev_init_event_table(struct device_node *node);
void cmdq_dev_test_dts_correctness(void);
/* device initialization / deinitialization */
void cmdq_dev_init(struct platform_device *pDevice);
void cmdq_dev_deinit(void);
/* dma_set_mask result, to show in status */
int32_t cmdq_dev_get_dma_mask_result(void);
struct cmdq_dts_setting {
uint32_t prefetch_thread_count;
uint32_t prefetch_size[CMDQ_MAX_THREAD_COUNT];
};
/* callback when read resource from device tree */
typedef void(*CMDQ_DEV_INIT_RESOURCE_CB) (uint32_t engineFlag,
enum CMDQ_EVENT_ENUM resourceEvent);
void cmdq_dev_get_dts_setting(struct cmdq_dts_setting *dts_setting);
void cmdq_dev_init_resource(CMDQ_DEV_INIT_RESOURCE_CB init_cb);
#endif /* __CMDQ_DEVICE_H__ */
File diff suppressed because it is too large. Load diff
+107
View File
@@ -0,0 +1,107 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_DRIVER_H__
#define __CMDQ_DRIVER_H__
#include <linux/kernel.h>
#include <linux/fs.h>
#include "cmdq_def.h"
struct cmdqUsageInfoStruct {
/* [OUT] current engine ref count */
uint32_t count[CMDQ_MAX_ENGINE_COUNT];
};
struct cmdqJobStruct {
struct cmdqCommandStruct command; /* [IN] the job to perform */
cmdqJobHandle_t hJob; /* [OUT] handle to resulting job */
};
struct cmdqJobResultStruct {
/* [IN] Job handle from CMDQ_IOCTL_ASYNC_JOB_EXEC */
cmdqJobHandle_t hJob;
/* [OUT] engine flag passed down originally */
uint64_t engineFlag;
/* [IN/OUT] read register values, if any. */
/* as input, the "count" field must represent */
/* buffer space pointed by "regValues". */
/* Upon return, CMDQ driver fills "count" with */
/* actual requested register count. */
/* However, if the input "count" is too small, */
/* -ENOMEM is returned, and "count" is filled */
/* with requested register count. */
struct cmdqRegValueStruct regValue;
/* [IN/OUT] physical address to read */
struct cmdqReadAddressStruct readAddress;
};
struct cmdqWriteAddressStruct {
/* [IN] count of the writable buffer */
/* (unit is # of uint32_t, NOT in byte) */
uint32_t count;
/* [OUT] When Alloc, this is the resulting PA. */
/* It is guaranteed to be continuous. */
/* [IN] When Free, please pass returned address down to ioctl. */
/* */
/* indeed param startPA should be */
/* UNSIGNED LONG type for 64 bit kernel. */
/* Considering our plartform supports max */
/* 4GB RAM(upper-32bit don't care for SW) */
/* and consistent common code interface, remain uint32_t type. */
uint32_t startPA;
};
#define CMDQ_IOCTL_MAGIC_NUMBER 'x'
#define CMDQ_IOCTL_LOCK_MUTEX _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 1, int)
#define CMDQ_IOCTL_UNLOCK_MUTEX _IOR(CMDQ_IOCTL_MAGIC_NUMBER, 2, int)
#define CMDQ_IOCTL_EXEC_COMMAND _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 3, \
struct cmdqCommandStruct)
#define CMDQ_IOCTL_QUERY_USAGE _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 4, \
struct cmdqUsageInfoStruct)
/* */
/* Async operations */
/* */
#define CMDQ_IOCTL_ASYNC_JOB_EXEC _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 5, \
struct cmdqJobStruct)
#define CMDQ_IOCTL_ASYNC_JOB_WAIT_AND_CLOSE _IOR(CMDQ_IOCTL_MAGIC_NUMBER, 6, \
struct cmdqJobResultStruct)
#define CMDQ_IOCTL_ALLOC_WRITE_ADDRESS _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 7, \
struct cmdqWriteAddressStruct)
#define CMDQ_IOCTL_FREE_WRITE_ADDRESS _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 8, \
struct cmdqWriteAddressStruct)
#define CMDQ_IOCTL_READ_ADDRESS_VALUE _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 9, \
struct cmdqReadAddressStruct)
/* */
/* Chip capability query. output parameter is a bit field. */
/* Bit definition is CMDQ_CAP_BITS. */
/* */
#define CMDQ_IOCTL_QUERY_CAP_BITS _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 10, int)
/* */
/* HW info. from DTS */
/* */
#define CMDQ_IOCTL_QUERY_DTS _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 11, \
struct cmdqDTSDataStruct)
/* */
/* Notify MDP will use specified engine before really use. */
/* input int is same as EngineFlag. */
/* */
#define CMDQ_IOCTL_NOTIFY_ENGINE _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 12, uint64_t)
s32 cmdq_driver_ioctl_query_usage(struct file *pf, unsigned long param);
s32 cmdq_driver_ioctl_query_cap_bits(unsigned long param);
s32 cmdq_driver_ioctl_query_dts(unsigned long param);
s32 cmdq_driver_ioctl_notify_engine(unsigned long param);
void cmdq_driver_dump_readback(u32 *addrs, u32 count, u32 *values);
#endif /* __CMDQ_DRIVER_H__ */
@@ -0,0 +1,75 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_ENGINE_COMMON_H__
#define __CMDQ_ENGINE_COMMON_H__
enum CMDQ_ENG_ENUM {
/* ISP */
CMDQ_ENG_ISP_IMGI = 0,
CMDQ_ENG_ISP_IMGO, /* 1 */
CMDQ_ENG_ISP_IMG2O, /* 2 */
/* MDP */
CMDQ_ENG_MDP_CAMIN, /* 3 */
CMDQ_ENG_MDP_RDMA0, /* 4 */
CMDQ_ENG_MDP_RDMA1, /* 5 */
CMDQ_ENG_MDP_RSZ0, /* 6 */
CMDQ_ENG_MDP_RSZ1, /* 7 */
CMDQ_ENG_MDP_RSZ2, /* 8 */
CMDQ_ENG_MDP_TDSHP0, /* 9 */
CMDQ_ENG_MDP_TDSHP1, /* 10 */
CMDQ_ENG_MDP_COLOR0, /* 11 */
CMDQ_ENG_MDP_MOUT0, /* 12 */
CMDQ_ENG_MDP_MOUT1, /* 13 */
CMDQ_ENG_MDP_WROT0, /* 14 */
CMDQ_ENG_MDP_WROT1, /* 15 */
CMDQ_ENG_MDP_WDMA, /* 16 */
/* JPEG & VENC */
CMDQ_ENG_JPEG_ENC, /* 17 */
CMDQ_ENG_VIDEO_ENC, /* 18 */
CMDQ_ENG_JPEG_DEC, /* 19 */
CMDQ_ENG_JPEG_REMDC, /* 20 */
/* DISP */
CMDQ_ENG_DISP_UFOE, /* 21 */
CMDQ_ENG_DISP_AAL, /* 22 */
CMDQ_ENG_DISP_COLOR0, /* 23 */
CMDQ_ENG_DISP_COLOR1, /* 24 */
CMDQ_ENG_DISP_RDMA0, /* 25 */
CMDQ_ENG_DISP_RDMA1, /* 26 */
CMDQ_ENG_DISP_RDMA2, /* 27 */
CMDQ_ENG_DISP_WDMA0, /* 28 */
CMDQ_ENG_DISP_WDMA1, /* 29 */
CMDQ_ENG_DISP_OVL0, /* 30 */
CMDQ_ENG_DISP_OVL1, /* 31 */
CMDQ_ENG_DISP_OVL2, /* 32 */
CMDQ_ENG_DISP_2L_OVL0, /* 33 */
CMDQ_ENG_DISP_2L_OVL1, /* 34 */
CMDQ_ENG_DISP_2L_OVL2, /* 35 */
CMDQ_ENG_DISP_GAMMA, /* 36 */
CMDQ_ENG_DISP_MERGE, /* 37 */
CMDQ_ENG_DISP_SPLIT0, /* 38 */
CMDQ_ENG_DISP_SPLIT1, /* 39 */
CMDQ_ENG_DISP_DSI0_VDO, /* 40 */
CMDQ_ENG_DISP_DSI1_VDO, /* 41 */
CMDQ_ENG_DISP_DSI0_CMD, /* 42 */
CMDQ_ENG_DISP_DSI1_CMD, /* 43 */
CMDQ_ENG_DISP_DSI0, /* 44 */
CMDQ_ENG_DISP_DSI1, /* 45 */
CMDQ_ENG_DISP_DPI, /* 46 */
/* DPE */
CMDQ_ENG_DPE, /* 47 */
/* temp: CMDQ internal usage */
CMDQ_ENG_CMDQ,
CMDQ_ENG_DISP_MUTEX,
CMDQ_ENG_MMSYS_CONFIG,
CMDQ_MAX_ENGINE_COUNT /* ALWAYS keep at the end */
};
#endif /* __CMDQ_ENGINE_COMMON_H__ */
@@ -0,0 +1,500 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
/* MDP start frame */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RDMA0_SOF, 0, mdp_rdma0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RDMA1_SOF, 1, mdp_rdma1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RSZ0_SOF, 2, mdp_rsz0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RSZ1_SOF, 3, mdp_rsz1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RSZ2_SOF, 4, mdp_rsz2_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_TDSHP_SOF, 5, mdp_tdshp_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_TDSHP0_SOF, 6, mdp_tdshp0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_TDSHP1_SOF, 7, mdp_tdshp1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WDMA_SOF, 8, mdp_wdma_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT_SOF, 9, mdp_wrot_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT0_SOF, 10, mdp_wrot0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT1_SOF, 11, mdp_wrot1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_COLOR_SOF, 12, mdp_color_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_MVW_SOF, 13, mdp_mvw_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_CROP_SOF, 14, mdp_crop_sof)
/* Display start frame */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_OVL0_SOF, 15, disp_ovl0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_OVL1_SOF, 16, disp_ovl1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_2L_OVL0_SOF, 17, disp_2l_ovl0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_2L_OVL1_SOF, 18, disp_2l_ovl1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA0_SOF, 19, disp_rdma0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA1_SOF, 20, disp_rdma1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA2_SOF, 21, disp_rdma2_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_WDMA0_SOF, 22, disp_wdma0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_WDMA1_SOF, 23, disp_wdma1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_COLOR_SOF, 24, disp_color_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_COLOR0_SOF, 25, disp_color0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_COLOR1_SOF, 26, disp_color1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_CCORR_SOF, 27, disp_ccorr_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_CCORR0_SOF, 28, disp_ccorr0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_CCORR1_SOF, 29, disp_ccorr1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_AAL_SOF, 30, disp_aal_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_AAL0_SOF, 31, disp_aal0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_AAL1_SOF, 32, disp_aal1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_GAMMA_SOF, 33, disp_gamma_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_GAMMA0_SOF, 34, disp_gamma0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_GAMMA1_SOF, 35, disp_gamma1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_DITHER_SOF, 36, disp_dither_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_DITHER0_SOF, 37, disp_dither0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_DITHER1_SOF, 38, disp_dither1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_UFOE_SOF, 39, disp_ufoe_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_PWM0_SOF, 40, disp_pwm0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_PWM1_SOF, 41, disp_pwm1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_OD_SOF, 42, disp_od_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_DSC_SOF, 43, disp_dsc_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_UFOD_RAMA0_L0_SOF, 44, ufod_rdma0_l0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_UFOD_RAMA0_L1_SOF, 45, ufod_rdma0_l1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_UFOD_RAMA0_L2_SOF, 46, ufod_rdma0_l2_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_UFOD_RAMA0_L3_SOF, 47, ufod_rdma0_l3_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_UFOD_RAMA1_L0_SOF, 48, ufod_rdma1_l0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_UFOD_RAMA1_L1_SOF, 49, ufod_rdma1_l1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_UFOD_RAMA1_L2_SOF, 50, ufod_rdma1_l2_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_UFOD_RAMA1_L3_SOF, 51, ufod_rdma1_l3_sof)
/* MDP frame done */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RDMA0_EOF, 52, mdp_rdma0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RDMA1_EOF, 53, mdp_rdma1_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RSZ0_EOF, 54, mdp_rsz0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RSZ1_EOF, 55, mdp_rsz1_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RSZ2_EOF, 56, mdp_rsz2_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_TDSHP_EOF, 57, mdp_tdshp_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_TDSHP0_EOF, 58, mdp_tdshp0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_TDSHP1_EOF, 59, mdp_tdshp1_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WDMA_EOF, 60, mdp_wdma_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT_WRITE_EOF, 61,
mdp_wrot_write_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT_READ_EOF, 62,
mdp_wrot_read_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT0_WRITE_EOF, 63,
mdp_wrot0_write_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT0_READ_EOF, 64,
mdp_wrot0_read_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT1_WRITE_EOF, 65,
mdp_wrot1_write_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT1_READ_EOF, 66,
mdp_wrot1_read_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT0_W_EOF, 67, mdp_wrot0_write_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT0_R_EOF, 68, mdp_wrot0_read_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT1_W_EOF, 69, mdp_wrot1_write_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT1_R_EOF, 70, mdp_wrot1_read_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_COLOR_EOF, 71, mdp_color_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_CROP_EOF, 72, mdp_crop_frame_done)
/* Display frame done */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_OVL0_EOF, 73, disp_ovl0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_OVL1_EOF, 74, disp_ovl1_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_2L_OVL0_EOF, 75, disp_2l_ovl0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_2L_OVL1_EOF, 76, disp_2l_ovl1_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA0_EOF, 77, disp_rdma0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA1_EOF, 78, disp_rdma1_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA2_EOF, 79, disp_rdma2_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_WDMA0_EOF, 80, disp_wdma0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_WDMA1_EOF, 81, disp_wdma1_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_COLOR_EOF, 82, disp_color_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_COLOR0_EOF, 83, disp_color0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_COLOR1_EOF, 84, disp_color1_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_CCORR_EOF, 85, disp_ccorr_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_CCORR0_EOF, 86, disp_ccorr0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_CCORR1_EOF, 87, disp_ccorr1_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_AAL_EOF, 88, disp_aal_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_AAL0_EOF, 89, disp_aal0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_AAL1_EOF, 90, disp_aal1_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_GAMMA_EOF, 91, disp_gamma_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_GAMMA0_EOF, 92, disp_gamma0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_GAMMA1_EOF, 93, disp_gamma1_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_DITHER_EOF, 94, disp_dither_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_DITHER0_EOF, 95, disp_dither0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_DITHER1_EOF, 96, disp_dither1_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_UFOE_EOF, 97, disp_ufoe_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_OD_EOF, 98, disp_od_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_OD_RDMA_EOF, 99, disp_od_rdma_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_OD_WDMA_EOF, 100, disp_od_wdma_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_DSC_EOF, 101, disp_dsc_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_DSI0_EOF, 102, disp_dsi0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_DSI1_EOF, 103, disp_dsi1_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_DPI0_EOF, 104, disp_dpi0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_UFOD_RAMA0_L0_EOF, 105, ufod_rdma0_l0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_UFOD_RAMA0_L1_EOF, 106, ufod_rdma0_l1_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_UFOD_RAMA0_L2_EOF, 107, ufod_rdma0_l2_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_UFOD_RAMA0_L3_EOF, 108, ufod_rdma0_l3_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_UFOD_RAMA1_L0_EOF, 109, ufod_rdma1_l0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_UFOD_RAMA1_L1_EOF, 110, ufod_rdma1_l1_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_UFOD_RAMA1_L2_EOF, 111, ufod_rdma1_l2_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_UFOD_RAMA1_L3_EOF, 112, ufod_rdma1_l3_frame_done)
/* Mutex frame done */
/* DISPSYS */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX0_STREAM_EOF, 113, stream_done_0)
/* DISPSYS */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX1_STREAM_EOF, 114, stream_done_1)
/* DISPSYS */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX2_STREAM_EOF, 115, stream_done_2)
/* DISPSYS */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX3_STREAM_EOF, 116, stream_done_3)
/* DISPSYS, please refer to disp_hal.h */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX4_STREAM_EOF, 117, stream_done_4)
/* DpFramework */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX5_STREAM_EOF, 118, stream_done_5)
/* DpFramework */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX6_STREAM_EOF, 119, stream_done_6)
/* DpFramework */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX7_STREAM_EOF, 120, stream_done_7)
/* DpFramework */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX8_STREAM_EOF, 121, stream_done_8)
/* DpFramework via CMDQ_IOCTL_LOCK_MUTEX */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX9_STREAM_EOF, 122, stream_done_9)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX10_STREAM_EOF, 123, stream_done_10)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX11_STREAM_EOF, 124, stream_done_11)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX12_STREAM_EOF, 125, stream_done_12)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX13_STREAM_EOF, 126, stream_done_13)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX14_STREAM_EOF, 127, stream_done_14)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MUTEX15_STREAM_EOF, 128, stream_done_15)
/* Display underrun */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA0_UNDERRUN, 129, buf_underrun_event_0)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA1_UNDERRUN, 130, buf_underrun_event_1)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_RDMA2_UNDERRUN, 131, buf_underrun_event_2)
/* Display TE */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DSI_TE, 132, dsi0_te_event)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DSI0_TE, 133, dsi0_te_event)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DSI1_TE, 134, dsi1_te_event)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_DSI0_TE_SOF, 135, mdp_dsi0_te_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_DSI1_TE_SOF, 136, mdp_dsi1_te_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_DSI0_SOF, 137, disp_dsi0_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_DSI1_SOF, 138, disp_dsi1_sof)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DSI0_TO_GCE_MMCK0, 139, dsi0_to_gce_mmck0)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DSI0_TO_GCE_MMCK1, 140, dsi0_to_gce_mmck1)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DSI0_TO_GCE_MMCK2, 141, dsi0_to_gce_mmck2)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DSI0_TO_GCE_MMCK3, 142, dsi0_to_gce_mmck3)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DSI0_TO_GCE_MMCK4, 143, dsi0_to_gce_mmck4)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DSI1_TO_GCE_MMCK0, 144, dsi1_to_gce_mmck0)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DSI1_TO_GCE_MMCK1, 145, dsi1_to_gce_mmck1)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DSI1_TO_GCE_MMCK2, 146, dsi1_to_gce_mmck2)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DSI1_TO_GCE_MMCK3, 147, dsi1_to_gce_mmck3)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DSI1_TO_GCE_MMCK4, 148, dsi1_to_gce_mmck4)
/* Reset Event */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_WDMA0_RST_DONE, 149, disp_wdma0_rst_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_WDMA1_RST_DONE, 150, disp_wdma1_rst_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT0_RST_DONE, 151, mdp_wrot0_rst_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WROT1_RST_DONE, 152, mdp_wrot1_rst_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_WDMA_RST_DONE, 153, mdp_wdma_rst_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RDMA0_RST_DONE, 154, mdp_rdma0_rst_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_MDP_RDMA1_RST_DONE, 155, mdp_rdma1_rst_done)
/* Display Mutex */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD0, 156,
disp_mutex_all_module_upd0)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD1, 157,
disp_mutex_all_module_upd1)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD2, 158,
disp_mutex_all_module_upd2)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD3, 159,
disp_mutex_all_module_upd3)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD4, 160,
disp_mutex_all_module_upd4)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD5, 161,
disp_mutex_all_module_upd5)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD6, 162,
disp_mutex_all_module_upd6)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD7, 163,
disp_mutex_all_module_upd7)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD8, 164,
disp_mutex_all_module_upd8)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD9, 165,
disp_mutex_all_module_upd9)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD10, 166,
disp_mutex_all_module_upd10)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD11, 167,
disp_mutex_all_module_upd11)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD12, 168,
disp_mutex_all_module_upd12)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD13, 169,
disp_mutex_all_module_upd13)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD14, 170,
disp_mutex_all_module_upd14)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD15, 171,
disp_mutex_all_module_upd15)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE0, 172,
disp_mutex_reg_upd_for_module0)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE1, 173,
disp_mutex_reg_upd_for_module1)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE2, 174,
disp_mutex_reg_upd_for_module2)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE3, 175,
disp_mutex_reg_upd_for_module3)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE4, 176,
disp_mutex_reg_upd_for_module4)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE5, 177,
disp_mutex_reg_upd_for_module5)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE6, 178,
disp_mutex_reg_upd_for_module6)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE7, 179,
disp_mutex_reg_upd_for_module7)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE8, 180,
disp_mutex_reg_upd_for_module8)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE9, 181,
disp_mutex_reg_upd_for_module9)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE10, 182,
disp_mutex_reg_upd_for_module10)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE11, 183,
disp_mutex_reg_upd_for_module11)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE12, 184,
disp_mutex_reg_upd_for_module12)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE13, 185,
disp_mutex_reg_upd_for_module13)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE14, 186,
disp_mutex_reg_upd_for_module14)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE15, 187,
disp_mutex_reg_upd_for_module15)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE16, 188,
disp_mutex_reg_upd_for_module16)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE17, 189,
disp_mutex_reg_upd_for_module17)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE18, 190,
disp_mutex_reg_upd_for_module18)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE19, 191,
disp_mutex_reg_upd_for_module19)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE20, 192,
disp_mutex_reg_upd_for_module20)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE21, 193,
disp_mutex_reg_upd_for_module21)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE22, 194,
disp_mutex_reg_upd_for_module22)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE23, 195,
disp_mutex_reg_upd_for_module23)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE24, 196,
disp_mutex_reg_upd_for_module24)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE25, 197,
disp_mutex_reg_upd_for_module25)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE26, 198,
disp_mutex_reg_upd_for_module26)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE27, 199,
disp_mutex_reg_upd_for_module27)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE28, 200,
disp_mutex_reg_upd_for_module28)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE29, 201,
disp_mutex_reg_upd_for_module29)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE30, 202,
disp_mutex_reg_upd_for_module30)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE31, 203,
disp_mutex_reg_upd_for_module31)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE32, 204,
disp_mutex_reg_upd_for_module32)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE33, 205,
disp_mutex_reg_upd_for_module33)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE34, 206,
disp_mutex_reg_upd_for_module34)
/* ISP frame done */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_PASS2_2_EOF, 207, isp_frame_done_p2_2)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_PASS2_1_EOF, 208, isp_frame_done_p2_1)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_PASS2_0_EOF, 209, isp_frame_done_p2_0)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_PASS1_1_EOF, 210, isp_frame_done_p1_1)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_PASS1_0_EOF, 211, isp_frame_done_p1_0)
/* ISP (IMGSYS) frame done */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DIP_CQ_THREAD0_EOF, 212,
dip_cq_thread0_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DIP_CQ_THREAD1_EOF, 213,
dip_cq_thread1_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DIP_CQ_THREAD2_EOF, 214,
dip_cq_thread2_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DIP_CQ_THREAD3_EOF, 215,
dip_cq_thread3_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DIP_CQ_THREAD4_EOF, 216,
dip_cq_thread4_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DIP_CQ_THREAD5_EOF, 217,
dip_cq_thread5_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DIP_CQ_THREAD6_EOF, 218,
dip_cq_thread6_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DIP_CQ_THREAD7_EOF, 219,
dip_cq_thread7_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DIP_CQ_THREAD8_EOF, 220,
dip_cq_thread8_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DIP_CQ_THREAD9_EOF, 221,
dip_cq_thread9_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DIP_CQ_THREAD10_EOF, 222,
dip_cq_thread10_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DIP_CQ_THREAD11_EOF, 223,
dip_cq_thread11_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DIP_CQ_THREAD12_EOF, 224,
dip_cq_thread12_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DIP_CQ_THREAD13_EOF, 225,
dip_cq_thread13_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DIP_CQ_THREAD14_EOF, 226,
dip_cq_thread14_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DPE_EOF, 227, dpe_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DVE_EOF, 228, dve_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_WMF_EOF, 229, wmf_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_GEPF_EOF, 230, gepf_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_GEPF_TEMP_EOF, 231, gepf_temp_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_GEPF_BYPASS_EOF, 232, gepf_bypass_frame_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_RSC_EOF, 233, rsc_frame_done)
/* ISP (IMGSYS) engine events */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_SENINF_CAM1_2_3_FULL, 234,
seninf_cam1_2_3_fifo_full)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_SENINF_CAM0_FULL, 235, seninf_cam0_fifo_full)
/* VENC frame done */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_VENC_EOF, 236, venc_done)
/* JPEG frame done */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_JPEG_ENC_EOF, 237, jpgenc_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_JPEG_ENC_PASS2_EOF, 238, jpgenc_pass2_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_JPEG_ENC_PASS1_EOF, 239, jpgenc_pass1_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_JPEG_DEC_EOF, 240, jpgdec_done)
/* VENC engine events */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_VENC_MB_DONE, 241, venc_mb_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_VENC_128BYTE_CNT_DONE, 242, venc_128byte_cnt_done)
/* ISP (CAMSYS) frame done */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_FRAME_DONE_A, 243, isp_frame_done_a)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_FRAME_DONE_B, 244, isp_frame_done_b)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_CAMSV_0_PASS1_DONE, 245, camsv_0_pass1_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_CAMSV_1_PASS1_DONE, 246, camsv_1_pass1_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_CAMSV_2_PASS1_DONE, 247, camsv_2_pass1_done)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_ISP_TSF_DONE, 248, tsf_done)
/* ISP (CAMSYS) engine events */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_SENINF_0_FIFO_FULL, 249, seninf_0_fifo_full)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_SENINF_1_FIFO_FULL, 250, seninf_1_fifo_full)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_SENINF_2_FIFO_FULL, 251, seninf_2_fifo_full)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_SENINF_3_FIFO_FULL, 252, seninf_3_fifo_full)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_SENINF_4_FIFO_FULL, 253, seninf_4_fifo_full)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_SENINF_5_FIFO_FULL, 254, seninf_5_fifo_full)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_SENINF_6_FIFO_FULL, 255, seninf_6_fifo_full)
DECLARE_CMDQ_EVENT(CMDQ_EVENT_SENINF_7_FIFO_FULL, 256, seninf_7_fifo_full)
/* DPI1 frame done */
DECLARE_CMDQ_EVENT(CMDQ_EVENT_DISP_DPI1_EOF, 257, disp_dpi1_frame_done)
/* Keep this at the end of HW events */
DECLARE_CMDQ_EVENT(CMDQ_MAX_HW_EVENT_COUNT, 400, hw_event_conunt)
/* SW Sync Tokens (Pre-defined) */
/* Config thread notify trigger thread */
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_CONFIG_DIRTY, 401, sw_token)
/* Trigger thread notify config thread */
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_STREAM_EOF, 402, sw_token)
/* Block Trigger thread until the ESD check finishes. */
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_ESD_EOF, 403, sw_token)
/* check CABC setup finish */
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_CABC_EOF, 404, sw_token)
/* Block Trigger thread until the path freeze finishes */
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_FREEZE_EOF, 405, sw_token)
/* Pass-2 notifies VENC frame is ready to be encoded */
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_VENC_INPUT_READY, 406, sw_token)
/* VENC notifies Pass-2 encode done so next frame may start */
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_VENC_EOF, 407, sw_token)
/* Notify normal CMDQ there are some secure task done */
DECLARE_CMDQ_EVENT(CMDQ_SYNC_SECURE_THR_EOF, 408, sw_token)
/* Lock WSM resource */
DECLARE_CMDQ_EVENT(CMDQ_SYNC_SECURE_WSM_LOCK, 409, sw_token)
/* SW Sync Tokens (User-defined) */
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_USER_0, 410, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_USER_1, 411, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_POLL_MONITOR, 412, sw_token)
/* Secure video path notify SW token */
DECLARE_CMDQ_EVENT(CMDQ_SYNC_DISP_OVL0_2NONSEC_END, 420, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_DISP_OVL1_2NONSEC_END, 421, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_DISP_2LOVL0_2NONSEC_END, 422, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_DISP_2LOVL1_2NONSEC_END, 423, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_DISP_RDMA0_2NONSEC_END, 424, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_DISP_RDMA1_2NONSEC_END, 425, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_DISP_WDMA0_2NONSEC_END, 426, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_DISP_WDMA1_2NONSEC_END, 427, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_DISP_EXT_STREAM_EOF, 428, sw_token)
/**
* Event for CMDQ to block executing command when append command
* Plz sync CMDQ_SYNC_TOKEN_APPEND_THR(id) in cmdq_core source file.
*/
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR0, 432, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR1, 433, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR2, 434, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR3, 435, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR4, 436, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR5, 437, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR6, 438, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR7, 439, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR8, 440, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR9, 441, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR10, 442, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR11, 443, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR12, 444, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR13, 445, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR14, 446, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR15, 447, sw_token)
/* GPR access tokens (for hardware 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, 450, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_1, 451, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_2, 452, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_3, 453, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_4, 454, sw_token)
/* Resource lock event to control resource in GCE thread */
DECLARE_CMDQ_EVENT(CMDQ_SYNC_RESOURCE_WROT0, 460, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_RESOURCE_WROT1, 461, sw_token)
/**
* Event for CMDQ delay implement
* Plz sync CMDQ_SYNC_TOKEN_DELAY_THR(id) in cmdq_core source file.
*/
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR0, 470, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR1, 471, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR2, 472, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR3, 473, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR4, 474, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR5, 475, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR6, 476, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR7, 477, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR8, 478, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR9, 479, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR10, 480, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR11, 481, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR12, 482, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR13, 483, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR14, 484, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR15, 485, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR16, 486, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR17, 487, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR18, 488, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR19, 489, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR20, 490, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR21, 491, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR22, 492, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR23, 493, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR24, 494, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR25, 495, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR26, 496, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR27, 497, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR28, 498, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR29, 499, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR30, 500, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_DELAY_THR31, 501, sw_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_TIMER, 502, sw_token)
/* event id is 9 bit */
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_MAX, (0x1FF), max_token)
DECLARE_CMDQ_EVENT(CMDQ_SYNC_TOKEN_INVALID, (-1), invalid_token)
@@ -0,0 +1,18 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
/* id HW_OP MASK_EN cycle name */
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_WRI, CMDQ_CODE_WRITE, 4, WRI)
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_WRI_WITH_MASK, CMDQ_CODE_WRITE, 36,
WRI_W_MASK) /* 32 for read, 4 for write */
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_POLL, CMDQ_CODE_POLL, 32, POLL)
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_MOVE, CMDQ_CODE_MOVE, 1, MOVE)
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_READ, CMDQ_CODE_READ, 32, READ)
/* need wait event */
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_WFE, CMDQ_CODE_WFE, 3, WAIT)
/* no need wait event and update event */
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_SYNC, CMDQ_CODE_WFE, 3, SYNC)
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_JUMP, CMDQ_CODE_JUMP, 1, JUMP)
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_EOC, CMDQ_CODE_EOC, 1, MARKER)
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,199 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_MDP_COMMON_H__
#define __CMDQ_MDP_COMMON_H__
#include "cmdq_def.h"
#include "cmdq_core.h"
#include "cmdq_virtual.h"
#include <linux/types.h>
#if defined(CMDQ_USE_LEGACY)
#include <linux/clk.h>
#endif
/* VENC callback function */
typedef int32_t(*CmdqVEncDumpInfo) (uint64_t engineFlag, int level);
/* query MDP clock is on */
typedef bool(*CmdqMdpClockIsOn) (enum CMDQ_ENG_ENUM engine);
/* enable MDP clock */
typedef void (*CmdqEnableMdpClock) (bool enable, enum CMDQ_ENG_ENUM engine);
/* Common Clock Framework */
typedef void (*CmdqMdpInitModuleClk) (void);
/* MDP callback function */
typedef int32_t(*CmdqMdpClockOn) (uint64_t engineFlag);
typedef int32_t(*CmdqMdpDumpInfo) (uint64_t engineFlag, int level);
typedef int32_t(*CmdqMdpResetEng) (uint64_t engineFlag);
typedef int32_t(*CmdqMdpClockOff) (uint64_t engineFlag);
/* MDP Initialization setting */
typedef void(*CmdqMdpInitialSet) (void);
/* Initialization & de-initialization MDP base VA */
typedef void (*CmdqMdpInitModuleBaseVA) (void);
typedef void (*CmdqMdpDeinitModuleBaseVA) (void);
/* MDP engine dump */
typedef void (*CmdqMdpDumpRSZ) (const unsigned long base, const char *label);
typedef void (*CmdqMdpDumpTDSHP) (const unsigned long base, const char *label);
/* test MDP clock function */
typedef uint32_t(*CmdqMdpRdmaGetRegOffsetSrcAddr) (void);
typedef uint32_t(*CmdqMdpWrotGetRegOffsetDstAddr) (void);
typedef uint32_t(*CmdqMdpWdmaGetRegOffsetDstAddr) (void);
typedef void (*CmdqTestcaseClkmgrMdp) (void);
typedef const char*(*CmdqDispatchModule) (uint64_t engineFlag);
typedef void (*CmdqTrackTask) (const struct TaskStruct *pTask);
#if defined(CMDQ_USE_LEGACY)
typedef void (*CmdqMdpInitModuleClkMutex32K) (void);
#endif
#ifdef CONFIG_MTK_CMDQ_TAB
typedef void (*CmdqMdpSmiLarbEnableClock) (bool enable);
#endif
#ifdef CMDQ_OF_SUPPORT
typedef void (*CmdqMdpGetModulePa) (long *startPA, long *endPA);
#endif
#ifdef CMDQ_USE_LEGACY
typedef void (*CmdqMdpEnableClockMutex32k) (bool enable);
#endif
struct cmdqMDPFuncStruct {
CmdqDumpMMSYSConfig dumpMMSYSConfig;
CmdqVEncDumpInfo vEncDumpInfo;
CmdqMdpInitModuleBaseVA initModuleBaseVA;
CmdqMdpDeinitModuleBaseVA deinitModuleBaseVA;
CmdqMdpClockIsOn mdpClockIsOn;
CmdqEnableMdpClock enableMdpClock;
CmdqMdpInitModuleClk initModuleCLK;
CmdqMdpDumpRSZ mdpDumpRsz;
CmdqMdpDumpTDSHP mdpDumpTdshp;
CmdqMdpClockOn mdpClockOn;
CmdqMdpDumpInfo mdpDumpInfo;
CmdqMdpResetEng mdpResetEng;
CmdqMdpClockOff mdpClockOff;
CmdqMdpInitialSet mdpInitialSet;
CmdqMdpRdmaGetRegOffsetSrcAddr rdmaGetRegOffsetSrcAddr;
CmdqMdpWrotGetRegOffsetDstAddr wrotGetRegOffsetDstAddr;
CmdqMdpWdmaGetRegOffsetDstAddr wdmaGetRegOffsetDstAddr;
CmdqTestcaseClkmgrMdp testcaseClkmgrMdp;
CmdqDispatchModule dispatchModule;
CmdqTrackTask trackTask;
#if defined(CMDQ_USE_LEGACY)
CmdqMdpInitModuleClkMutex32K mdpInitModuleClkMutex32K;
#endif
#ifdef CONFIG_MTK_CMDQ_TAB
CmdqMdpSmiLarbEnableClock mdpSmiLarbEnableClock;
#endif
#ifdef CMDQ_OF_SUPPORT
CmdqMdpGetModulePa mdpGetModulePa;
#endif
#ifdef CMDQ_USE_LEGACY
CmdqMdpEnableClockMutex32k mdpEnableClockMutex32k;
#endif
};
/* track MDP task */
#define DEBUG_STR_LEN 1024 /* debug str length */
#define MDP_MAX_TASK_NUM 5 /* num of tasks to be keep */
#define MDP_MAX_PLANE_NUM 3 /* max color format plane num */
/* each plane has 2 info address and size */
#define MDP_PORT_BUF_INFO_NUM (MDP_MAX_PLANE_NUM * 2)
#define MDP_BUF_INFO_STR_LEN 8 /* each buf info length */
/* dispatch key format is MDP_(ThreadName) */
#define MDP_DISPATCH_KEY_STR_LEN (TASK_COMM_LEN + 5)
struct cmdqMDPTaskStruct {
char callerName[TASK_COMM_LEN];
char userDebugStr[DEBUG_STR_LEN];
};
#ifdef __cplusplus
extern "C" {
#endif
void cmdq_mdp_virtual_function_setting(void);
struct cmdqMDPFuncStruct *cmdq_mdp_get_func(void);
void cmdq_mdp_enable(uint64_t engineFlag,
enum CMDQ_ENG_ENUM engine);
int cmdq_mdp_loop_reset(enum CMDQ_ENG_ENUM engine,
const unsigned long resetReg,
const unsigned long resetStateReg,
const uint32_t resetMask,
const uint32_t resetValue,
const bool pollInitResult);
void cmdq_mdp_loop_off(enum CMDQ_ENG_ENUM engine,
const unsigned long resetReg,
const unsigned long resetStateReg,
const uint32_t resetMask,
const uint32_t resetValue,
const bool pollInitResult);
const char *cmdq_mdp_get_rsz_state(const uint32_t state);
void cmdq_mdp_dump_venc(const unsigned long base,
const char *label);
void cmdq_mdp_dump_rdma(const unsigned long base,
const char *label);
void cmdq_mdp_dump_rot(const unsigned long base,
const char *label);
void cmdq_mdp_dump_color(const unsigned long base,
const char *label);
void cmdq_mdp_dump_wdma(const unsigned long base,
const char *label);
void cmdq_mdp_check_TF_address(unsigned int mva,
char *module);
/******************************************/
/********* Platform dependent function ******/
/***********************************************************/
int32_t cmdqMdpClockOn(uint64_t engineFlag);
int32_t cmdqMdpDumpInfo(uint64_t engineFlag, int level);
int32_t cmdqVEncDumpInfo(uint64_t engineFlag, int level);
int32_t cmdqMdpResetEng(uint64_t engineFlag);
int32_t cmdqMdpClockOff(uint64_t engineFlag);
uint32_t cmdq_mdp_rdma_get_reg_offset_src_addr(void);
uint32_t cmdq_mdp_wrot_get_reg_offset_dst_addr(void);
uint32_t cmdq_mdp_wdma_get_reg_offset_dst_addr(void);
void testcase_clkmgr_mdp(void);
u32 cmdq_mdp_get_hw_reg(enum MDP_ENG_BASE base, u16 offset);
u32 cmdq_mdp_get_hw_port(enum MDP_ENG_BASE base);
/* Platform virtual function setting */
void cmdq_mdp_platform_function_setting(void);
#ifdef __cplusplus
}
#endif
#endif /* __CMDQ_MDP_COMMON_H__ */
+68
View File
@@ -0,0 +1,68 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2020 MediaTek Inc.
*/
#include "cmdq_mmp.h"
static struct CMDQ_MMP_events_t CMDQ_MMP_events;
struct CMDQ_MMP_events_t *cmdq_mmp_get_event(void)
{
return &CMDQ_MMP_events;
}
void cmdq_mmp_init(void)
{
#ifdef CMDQ_PROFILE_MMP
mmprofile_enable(1);
if (CMDQ_MMP_events.CMDQ == 0) {
CMDQ_MMP_events.CMDQ = mmprofile_register_event(
MMP_ROOT_EVENT, "CMDQ");
CMDQ_MMP_events.thread_en =
mmprofile_register_event(CMDQ_MMP_events.CMDQ,
"thread_en");
CMDQ_MMP_events.CMDQ_IRQ = mmprofile_register_event(
CMDQ_MMP_events.CMDQ, "CMDQ_IRQ");
CMDQ_MMP_events.warning = mmprofile_register_event(
CMDQ_MMP_events.CMDQ, "warning");
CMDQ_MMP_events.loopBeat = mmprofile_register_event(
CMDQ_MMP_events.CMDQ, "loopIRQ");
CMDQ_MMP_events.autoRelease_add =
mmprofile_register_event(CMDQ_MMP_events.CMDQ,
"autoRelease_add");
CMDQ_MMP_events.autoRelease_done =
mmprofile_register_event(CMDQ_MMP_events.CMDQ,
"autoRelease_done");
CMDQ_MMP_events.consume_add =
mmprofile_register_event(CMDQ_MMP_events.CMDQ,
"consume_add");
CMDQ_MMP_events.consume_done =
mmprofile_register_event(CMDQ_MMP_events.CMDQ,
"consume_done");
CMDQ_MMP_events.alloc_task =
mmprofile_register_event(CMDQ_MMP_events.CMDQ,
"alloc_task");
CMDQ_MMP_events.wait_task =
mmprofile_register_event(CMDQ_MMP_events.CMDQ,
"wait_task");
CMDQ_MMP_events.wait_thread =
mmprofile_register_event(CMDQ_MMP_events.CMDQ,
"wait_thread");
CMDQ_MMP_events.MDP_reset =
mmprofile_register_event(CMDQ_MMP_events.CMDQ,
"MDP_reset");
CMDQ_MMP_events.thread_suspend =
mmprofile_register_event(CMDQ_MMP_events.CMDQ,
"thread_suspend");
CMDQ_MMP_events.thread_resume =
mmprofile_register_event(CMDQ_MMP_events.CMDQ,
"thread_resume");
mmprofile_enable_event_recursive(CMDQ_MMP_events.CMDQ, 1);
}
mmprofile_start(1);
#endif
}
+38
View File
@@ -0,0 +1,38 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_MMP_H__
#define __CMDQ_MMP_H__
#ifdef CMDQ_PROFILE_MMP
#include "mmprofile.h"
#include "mmprofile_function.h"
#include "cmdq_core.h"
#endif
struct CMDQ_MMP_events_t {
#ifdef CMDQ_PROFILE_MMP
mmp_event CMDQ;
mmp_event CMDQ_IRQ;
mmp_event thread_en;
mmp_event warning;
mmp_event loopBeat;
mmp_event autoRelease_add;
mmp_event autoRelease_done;
mmp_event consume_add;
mmp_event consume_done;
mmp_event alloc_task;
mmp_event wait_task;
mmp_event wait_thread;
mmp_event MDP_reset;
mmp_event thread_suspend;
mmp_event thread_resume;
#endif
};
void cmdq_mmp_init(void);
struct CMDQ_MMP_events_t *cmdq_mmp_get_event(void);
#endif /* __CMDQ_MMP_H__ */
+157
View File
@@ -0,0 +1,157 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2020 MediaTek Inc.
*/
#include "cmdq_prof.h"
#include "cmdq_core.h"
/* expect no EMI latency, GCE spends 80 ns per 4 cycle*/
#define CMDQ_HW_EXEC_NS(hw_cycle) (hw_cycle * (80 / 4))
enum CMDQ_OP_STATISTIC_ENUM {
CMDQ_STA_READ = 0,
CMDQ_STA_MOVE,
CMDQ_STA_WRI,
CMDQ_STA_WRI_WITH_MASK,
CMDQ_STA_POLL,
CMDQ_STA_JUMP,
CMDQ_STA_WFE, /* wait for event */
CMDQ_STA_SYNC, /* sync op and no wait for event */
CMDQ_STA_EOC,
CMDQ_STA_MAX_COUNT, /* always keep at the end */
};
const char *cmdq_prof_get_statistic_id_name(
const enum CMDQ_OP_STATISTIC_ENUM statisticId)
{
const char *IDName = "UNKNOWN";
#undef DECLARE_CMDQ_INSTR_CYCLE
#define DECLARE_CMDQ_INSTR_CYCLE(id, hw_op, cycle, name) \
{ if (id == statisticId) {IDName = #name; break; } }
do {
#include "cmdq_instr_cycle.h"
} while (0);
#undef DECLARE_CMDQ_INSTR_CYCLE
return IDName;
}
uint32_t cmdq_prof_get_statistic_id(const uint32_t *pCmd)
{
const uint32_t arg_b = pCmd[0];
const uint32_t arg_a = pCmd[1];
const uint32_t op = arg_a >> 24;
uint32_t addr;
uint32_t maskEn = 0;
switch (op) {
case CMDQ_CODE_WRITE:
/* check address */
if (arg_a & (1 << 23)) {
/* address is GPR */
return CMDQ_STA_WRI;
}
addr = cmdq_core_subsys_to_reg_addr(arg_a);
maskEn = (addr & 0x1);
if (maskEn)
return CMDQ_STA_WRI_WITH_MASK;
else
return CMDQ_STA_WRI;
case CMDQ_CODE_WFE:
/* check waiting flag */
if ((arg_b >> 15) & 0x1)
return CMDQ_STA_WFE;
else
return CMDQ_STA_SYNC;
case CMDQ_CODE_READ:
return CMDQ_STA_READ;
case CMDQ_CODE_MOVE:
return CMDQ_STA_MOVE;
case CMDQ_CODE_POLL:
return CMDQ_STA_POLL;
case CMDQ_CODE_JUMP:
return CMDQ_STA_JUMP;
case CMDQ_CODE_EOC:
return CMDQ_STA_EOC;
default:
CMDQ_ERR("unknown op, arg_a: 0x%08x\n", arg_a);
return 0;
}
CMDQ_ERR("unknown op, arg_a: 0x%08x\n", arg_a);
return 0;
}
uint32_t cmdq_prof_calculate_HW_cycle(
const enum CMDQ_OP_STATISTIC_ENUM statisticId,
const uint32_t count)
{
uint32_t hwCycle = -1;
#undef DECLARE_CMDQ_INSTR_CYCLE
#define DECLARE_CMDQ_INSTR_CYCLE(id, hw_op, cycle, name) { \
if (id == statisticId) { \
hwCycle = (count * cycle); \
break; \
} \
}
do {
#include "cmdq_instr_cycle.h"
} while (0);
#undef DECLARE_CMDQ_INSTR_CYCLE
if (-1 == hwCycle) {
/* Error message dump */
CMDQ_ERR("unknown statisticId: %d\n", statisticId);
}
return hwCycle;
}
int32_t cmdq_prof_estimate_command_exe_time(const uint32_t *pCmd,
uint32_t commandSize)
{
uint32_t statistic[CMDQ_STA_MAX_COUNT] = { 0 };
int i;
uint32_t statisticId = 0;
uint32_t cycle = 0;
uint32_t totalCycle = 0;
uint32_t totalNS = 0;
if (pCmd == NULL)
return -EFAULT;
/* gather statistic */
for (i = 0; i < commandSize; i += CMDQ_INST_SIZE, pCmd += 2) {
statisticId = cmdq_prof_get_statistic_id(pCmd);
statistic[statisticId] += 1;
}
CMDQ_LOG("NAME, COUNT, least HW exec cycle\n");
/* calculate execution time */
for (i = 0; i < CMDQ_STA_MAX_COUNT; i++) {
cycle = cmdq_prof_calculate_HW_cycle(i, statistic[i]);
totalCycle += cycle;
CMDQ_LOG("%d:%11s, %d, %3d\n",
i, cmdq_prof_get_statistic_id_name(i),
statistic[i], cycle);
}
totalNS = CMDQ_HW_EXEC_NS(totalCycle);
CMDQ_LOG("=====================================\n");
CMDQ_LOG("estimated least HW exec time(ns): %6d\n", totalNS);
CMDQ_LOG("***each HW cycle spends time(ns): %6d\n",
CMDQ_HW_EXEC_NS(1));
/* ***Real exec time will be longer when POLL/WAIT */
/* instr cannot pass their condition immediately. */
return totalNS;
}
+14
View File
@@ -0,0 +1,14 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_PROF_H__
#define __CMDQ_PROF_H__
#include <linux/types.h>
int32_t cmdq_prof_estimate_command_exe_time(const uint32_t *pCmd,
uint32_t commandSize);
#endif /* __CMDQ_PROF_H__ */
File diff suppressed because it is too large. Load diff
+775
View File
@@ -0,0 +1,775 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_RECORD_H__
#define __CMDQ_RECORD_H__
#include <linux/types.h>
#include <linux/uaccess.h>
#include "cmdq_def.h"
#include "cmdq_core.h"
struct TaskStruct;
typedef uint64_t CMDQ_VARIABLE;
struct task_private {
void *node_private_data;
bool internal; /* internal used only task */
bool ignore_timeout; /* timeout is expected */
};
struct cmdqRecStruct {
uint64_t engineFlag;
int32_t scenario;
uint32_t blockSize; /* command size */
void *pBuffer;
uint32_t bufferSize; /* allocated buffer size */
/* running task after flush() or startLoop() */
struct TaskStruct *pRunningTask;
/* setting high priority. This implies Prefetch ENABLE. */
enum CMDQ_HW_THREAD_PRIORITY_ENUM priority;
bool finalized; /* set to true after flush() or startLoop() */
uint32_t prefetchCount; /* maintenance prefetch instruction */
/* register backup at end of task */
u32 reg_count;
u32 *reg_values;
dma_addr_t reg_values_pa;
/* user space data */
u32 user_reg_count;
u32 user_token;
struct TaskStruct *mdp_meta_task;
bool get_meta_task;
struct cmdqSecDataStruct secData; /* secure execution data */
/* Readback slot protection */
s32 slot_ids[8];
/* profile marker */
#ifdef CMDQ_PROFILE_MARKER_SUPPORT
struct cmdqProfileMarkerStruct profileMarker;
#endif
};
/* typedef dma_addr_t cmdqBackupSlotHandle; */
#define cmdqBackupSlotHandle dma_addr_t
#ifdef __cplusplus
extern "C" {
#endif
/**
* Create command queue recorder handle
* Parameter:
* pHandle: pointer to retrieve the handle
* Return:
* 0 for success; else the error code is returned
*/
int32_t cmdq_task_create(enum CMDQ_SCENARIO_ENUM scenario,
struct cmdqRecStruct **pHandle);
int32_t cmdqRecCreate(enum CMDQ_SCENARIO_ENUM scenario,
struct cmdqRecStruct **pHandle);
/**
* Set engine flag for command queue picking HW thread
* Parameter:
* pHandle: pointer to retrieve the handle
* engineFlag: Flag use to identify which HW module can be accessed
* Return:
* 0 for success; else the error code is returned
*/
int32_t cmdq_task_set_engine(struct cmdqRecStruct *handle,
uint64_t engineFlag);
int32_t cmdqRecSetEngine(struct cmdqRecStruct *handle,
uint64_t engineFlag);
/**
* Reset command queue recorder commands
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
int32_t cmdq_task_reset(struct cmdqRecStruct *handle);
int32_t cmdqRecReset(struct cmdqRecStruct *handle);
/**
* Configure as secure task
* Parameter:
* handle: the command queue recorder handle
* is_secure: true, execute the command in secure world
* Return:
* 0 for success; else the error code is returned
*
* Note:
* a. Secure CMDQ support when t-base enabled only
* b. By default struct cmdqRecStruct records a normal command,
* please call cmdq_task_set_secure to set
* command as SECURE after cmdq_task_reset
*/
int32_t cmdq_task_set_secure(struct cmdqRecStruct *handle,
const bool is_secure);
int32_t cmdqRecSetSecure(struct cmdqRecStruct *handle,
const bool is_secure);
/**
* query handle is secure task or not
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for false (not secure) and 1 for true (is secure)
*/
int32_t cmdq_task_is_secure(struct cmdqRecStruct *handle);
int32_t cmdqRecIsSecure(struct cmdqRecStruct *handle);
/**
* Add DPAC protection flag
* Parameter:
* Note:
* a. Secure CMDQ support when t-base enabled only
* b. after reset handle, user have to specify protection flag again
*/
int32_t cmdq_task_secure_enable_dapc(
struct cmdqRecStruct *handle,
const uint64_t engineFlag);
int32_t cmdqRecSecureEnableDAPC(
struct cmdqRecStruct *handle,
const uint64_t engineFlag);
/**
* Add flag for M4U security ports
* Parameter:
* Note:
* a. Secure CMDQ support when t-base enabled only
* b. after reset handle, user have to specify protection flag again
*/
int32_t cmdq_task_secure_enable_port_security(
struct cmdqRecStruct *handle,
const uint64_t engineFlag);
int32_t cmdqRecSecureEnablePortSecurity(
struct cmdqRecStruct *handle,
const uint64_t engineFlag);
/**
* Append mark command to the recorder
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
int32_t cmdqRecMark(struct cmdqRecStruct *handle);
/**
* Append mark command to enable prefetch
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
int32_t cmdqRecEnablePrefetch(struct cmdqRecStruct *handle);
/**
* Append mark command to disable prefetch
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
int32_t cmdqRecDisablePrefetch(struct cmdqRecStruct *handle);
/**
* Append write command to the recorder
* Parameter:
* handle: the command queue recorder handle
* addr: the specified target register physical address
* argument / value: the specified target register value
* mask: the specified target register mask
* Return:
* 0 for success; else the error code is returned
*/
int32_t cmdq_op_write_reg(struct cmdqRecStruct *handle,
uint32_t addr,
CMDQ_VARIABLE argument, uint32_t mask);
int32_t cmdqRecWrite(struct cmdqRecStruct *handle,
uint32_t addr, uint32_t value, uint32_t mask);
/**
* Append write command to the update secure buffer address in secure path
* Parameter:
* handle: the command queue recorder handle
* addr: the specified register physical address
* about module src/dst buffer address
* type: base handle type
* base handle: secure handle of a secure mememory
* offset: offset related to base handle
* (secure buffer = addr(base_handle) + offset)
* size: secure buffer size
* mask: 0xFFFF_FFFF
* Return:
* 0 for success; else the error code is returned
* Note:
* support only when secure OS enabled
*/
int32_t cmdq_op_write_reg_secure(struct cmdqRecStruct *handle,
uint32_t addr,
enum CMDQ_SEC_ADDR_METADATA_TYPE type, uint64_t baseHandle,
uint32_t offset, uint32_t size, uint32_t port);
int32_t cmdqRecWriteSecure(struct cmdqRecStruct *handle,
uint32_t addr,
enum CMDQ_SEC_ADDR_METADATA_TYPE type,
uint64_t baseHandle,
uint32_t offset, uint32_t size, uint32_t port);
/* tablet use */
/*
* Record and memorize the index of write command to trust zone in secure path
* Parameter:
* handle: the command queue recorder handle
* addr: the specified target register physical address
* type: base handle type
* value: the specified target register value
* mask: the specified target register mask
* Return:
* 0 for success; else the error code is returned
* Note:
* support only when secure OS enabled
*/
#ifdef CONFIG_MTK_CMDQ_TAB
int32_t cmdq_op_write_reg_secure_mask(
struct cmdqRecStruct *handle, uint32_t addr,
enum CMDQ_SEC_ADDR_METADATA_TYPE type,
uint32_t value, uint32_t mask);
int32_t cmdqRecWriteSecureMask(struct cmdqRecStruct *handle,
uint32_t addr,
enum CMDQ_SEC_ADDR_METADATA_TYPE type,
uint32_t value, uint32_t mask);
#endif
/**
* Append poll command to the recorder
* Parameter:
* handle: the command queue recorder handle
* addr: the specified register physical address
* value: the required register value
* mask: the required register mask
* Return:
* 0 for success; else the error code is returned
*/
int32_t cmdq_op_poll(struct cmdqRecStruct *handle,
uint32_t addr, uint32_t value, uint32_t mask);
int32_t cmdqRecPoll(struct cmdqRecStruct *handle,
uint32_t addr, uint32_t value, uint32_t mask);
/**
* Append wait command to the recorder
* Parameter:
* handle: the command queue recorder handle
* event: the desired event type to "wait and CLEAR"
* Return:
* 0 for success; else the error code is returned
*/
int32_t cmdq_op_wait(struct cmdqRecStruct *handle,
enum CMDQ_EVENT_ENUM event);
int32_t cmdqRecWait(struct cmdqRecStruct *handle,
enum CMDQ_EVENT_ENUM event);
/**
* like cmdq_op_wait, but won't clear the event after
* leaving wait state.
*
* Parameter:
* handle: the command queue recorder handle
* event: the desired event type wait for
* Return:
* 0 for success; else the error code is returned
*/
int32_t cmdq_op_wait_no_clear(struct cmdqRecStruct *handle,
enum CMDQ_EVENT_ENUM event);
int32_t cmdqRecWaitNoClear(struct cmdqRecStruct *handle,
enum CMDQ_EVENT_ENUM event);
/**
* Unconditionally set to given event to 0.
* Parameter:
* handle: the command queue recorder handle
* event: the desired event type to set
* Return:
* 0 for success; else the error code is returned
*/
int32_t cmdq_op_clear_event(struct cmdqRecStruct *handle,
enum CMDQ_EVENT_ENUM event);
int32_t cmdqRecClearEventToken(struct cmdqRecStruct *handle,
enum CMDQ_EVENT_ENUM event);
/**
* Unconditionally set to given event to 1.
* Parameter:
* handle: the command queue recorder handle
* event: the desired event type to set
* Return:
* 0 for success; else the error code is returned
*/
int32_t cmdq_op_set_event(struct cmdqRecStruct *handle,
enum CMDQ_EVENT_ENUM event);
int32_t cmdqRecSetEventToken(struct cmdqRecStruct *handle,
enum CMDQ_EVENT_ENUM event);
/**
* Read a register value to a CMDQ general purpose register(GPR)
* Parameter:
* handle: the command queue recorder handle
* hw_addr: register address to read from
* dst_data_reg: CMDQ GPR to write to
* Return:
* 0 for success; else the error code is returned
*/
int32_t cmdq_op_read_to_data_register(
struct cmdqRecStruct *handle, uint32_t hw_addr,
enum CMDQ_DATA_REGISTER_ENUM dst_data_reg);
int32_t cmdqRecReadToDataRegister(
struct cmdqRecStruct *handle, uint32_t hw_addr,
enum CMDQ_DATA_REGISTER_ENUM dst_data_reg);
/**
* Write a register value from a CMDQ general purpose register(GPR)
* Parameter:
* handle: the command queue recorder handle
* src_data_reg: CMDQ GPR to read from
* hw_addr: register address to write to
* Return:
* 0 for success; else the error code is returned
*/
int32_t cmdq_op_write_from_data_register(
struct cmdqRecStruct *handle,
enum CMDQ_DATA_REGISTER_ENUM src_data_reg,
uint32_t hw_addr);
int32_t cmdqRecWriteFromDataRegister(
struct cmdqRecStruct *handle,
enum CMDQ_DATA_REGISTER_ENUM src_data_reg,
uint32_t hw_addr);
/**
* Allocate 32-bit register backup slot
*
*/
int32_t cmdq_alloc_mem(cmdqBackupSlotHandle *p_h_backup_slot,
uint32_t slotCount);
int32_t cmdqBackupAllocateSlot(
cmdqBackupSlotHandle *p_h_backup_slot,
uint32_t slotCount);
/**
* Read 32-bit register backup slot by index
*
*/
int32_t cmdq_cpu_read_mem(cmdqBackupSlotHandle h_backup_slot,
uint32_t slot_index,
uint32_t *value);
int32_t cmdqBackupReadSlot(cmdqBackupSlotHandle h_backup_slot,
uint32_t slot_index,
uint32_t *value);
/**
* Use CPU to write value into 32-bit register backup slot by index directly.
*
*/
int32_t cmdq_cpu_write_mem(cmdqBackupSlotHandle h_backup_slot,
uint32_t slot_index,
uint32_t value);
int32_t cmdqBackupWriteSlot(cmdqBackupSlotHandle h_backup_slot,
uint32_t slot_index,
uint32_t value);
/**
* Free allocated backup slot. DO NOT free them before corresponding
* task finishes. Becareful on AsyncFlush use cases.
*
*/
int32_t cmdq_free_mem(cmdqBackupSlotHandle h_backup_slot);
int32_t cmdqBackupFreeSlot(cmdqBackupSlotHandle h_backup_slot);
/**
* Insert instructions to backup given 32-bit HW register
* to a backup slot.
* You can use cmdq_cpu_read_mem() to retrieve the result
* AFTER cmdq_task_flush() returns, or INSIDE
* the callback of cmdq_task_flush_async_callback().
*
*/
int32_t cmdq_op_read_reg_to_mem(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot,
uint32_t slot_index, uint32_t addr);
int32_t cmdqRecBackupRegisterToSlot(
struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot,
uint32_t slot_index, uint32_t addr);
/**
* Insert instructions to write 32-bit HW register
* from a backup slot.
* You can use cmdq_cpu_read_mem() to retrieve the result
* AFTER cmdq_task_flush() returns, or INSIDE the callback
* of cmdq_task_flush_async_callback().
*
*/
int32_t cmdq_op_read_mem_to_reg(
struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot,
uint32_t slot_index, uint32_t addr);
int32_t cmdqRecBackupWriteRegisterFromSlot(
struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot,
uint32_t slot_index, uint32_t addr);
/**
* Insert instructions to update slot with given 32-bit value
* You can use cmdq_cpu_read_mem() to retrieve the result
* AFTER cmdq_task_flush() returns, or INSIDE
* the callback of cmdq_task_flush_async_callback().
*
*/
int32_t cmdq_op_write_mem(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot,
uint32_t slot_index, uint32_t value);
int32_t cmdqRecBackupUpdateSlot(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot,
uint32_t slot_index, uint32_t value);
/**
* Trigger CMDQ to execute the recorded commands
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
* Note:
* This is a synchronous function. When the function
* returned, the recorded commands have been done.
*/
int32_t cmdq_task_flush(struct cmdqRecStruct *handle);
int32_t cmdqRecFlush(struct cmdqRecStruct *handle);
/**
* Flush the command; Also at the end of the command, backup registers
* appointed by addrArray.
*
*/
int32_t cmdq_task_flush_and_read_register(
struct cmdqRecStruct *handle, uint32_t regCount,
uint32_t *addrArray, uint32_t *valueArray);
int32_t cmdqRecFlushAndReadRegister(
struct cmdqRecStruct *handle, uint32_t regCount,
uint32_t *addrArray, uint32_t *valueArray);
/**
* Trigger CMDQ to asynchronously execute the recorded commands
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for successfully start execution; else the error code is returned
* Note:
* This is an ASYNC function. When the function
* returned, it may or may not be finished.
* There is no way to retrieve the result.
*/
int32_t cmdq_task_flush_async(struct cmdqRecStruct *handle);
int32_t cmdqRecFlushAsync(struct cmdqRecStruct *handle);
int32_t cmdq_task_flush_async_callback(
struct cmdqRecStruct *handle, CmdqAsyncFlushCB callback,
uint32_t userData);
int32_t cmdqRecFlushAsyncCallback(
struct cmdqRecStruct *handle, CmdqAsyncFlushCB callback,
uint32_t userData);
/**
* Trigger CMDQ to execute the recorded commands in loop.
* each loop completion generates callback in interrupt context.
*
* Parameter:
* handle: the command queue recorder handle
* irqCallback: this CmdqInterruptCB callback
* is called after each loop completion.
* data: user data, this will pass back to irqCallback
* hLoop: output, a handle used to stop this loop.
*
* Return:
* 0 for success; else the error code is returned
*
* Note:
* This is an asynchronous function. When the function
* returned, the thread has started. Return -1 in irqCallback to stop it.
*/
int32_t cmdq_task_start_loop(struct cmdqRecStruct *handle);
int32_t cmdqRecStartLoop(struct cmdqRecStruct *handle);
int32_t cmdq_task_start_loop_callback(
struct cmdqRecStruct *handle, CmdqInterruptCB loopCB,
unsigned long loopData);
int32_t cmdqRecStartLoopWithCallback(
struct cmdqRecStruct *handle, CmdqInterruptCB loopCB,
unsigned long loopData);
/**
* Unconditionally stops the loop thread.
* Must call after cmdq_task_start_loop().
*/
int32_t cmdq_task_stop_loop(struct cmdqRecStruct *handle);
int32_t cmdqRecStopLoop(struct cmdqRecStruct *handle);
/**
* returns current count of instructions in given handle
*/
int32_t cmdq_task_get_instruction_count(
struct cmdqRecStruct *handle);
int32_t cmdqRecGetInstructionCount(
struct cmdqRecStruct *handle);
/**
* Record timestamp while CMDQ HW executes here
* This is for prfiling purpose.
*
* Return:
* 0 for success; else the error code is returned
*
* Note:
* Please define CMDQ_PROFILE_MARKER_SUPPORT in cmdq_def.h
* to enable profile marker.
*/
int32_t cmdq_op_profile_marker(struct cmdqRecStruct *handle,
const char *tag);
int32_t cmdqRecProfileMarker(struct cmdqRecStruct *handle,
const char *tag);
/**
* Dump command buffer to kernel log
* This is for debugging purpose.
*/
int32_t cmdq_task_dump_command(struct cmdqRecStruct *handle);
int32_t cmdqRecDumpCommand(struct cmdqRecStruct *handle);
/**
* Estimate command execu time.
* This is for debugging purpose.
*
* Note this estimation supposes all POLL/WAIT condition pass immediately
*/
int32_t cmdq_task_estimate_command_exec_time(
const struct cmdqRecStruct *handle);
int32_t cmdqRecEstimateCommandExecTime(
const struct cmdqRecStruct *handle);
/**
* Destroy command queue recorder handle
* Parameter:
* handle: the command queue recorder handle
*/
int32_t cmdq_task_destroy(struct cmdqRecStruct *handle);
void cmdqRecDestroy(struct cmdqRecStruct *handle);
/**
* Change instruction of index to NOP instruction
* Current NOP is [JUMP + 8]
*
* Parameter:
* handle: the command queue recorder handle
* index: the index of replaced instruction (start from 0)
* Return:
* > 0 (index) for success; else the error code is returned
*/
int32_t cmdq_op_set_nop(struct cmdqRecStruct *handle,
uint32_t index);
int32_t cmdqRecSetNOP(struct cmdqRecStruct *handle,
uint32_t index);
/**
* Query offset of instruction by instruction name
*
* Parameter:
* handle: the command queue recorder handle
* startIndex: Query offset from "startIndex" of instruction (start from 0)
* opCode: instruction name, you can use the following 6 instruction names:
* CMDQ_CODE_WFE: create via cmdq_op_wait()
* CMDQ_CODE_SET_TOKEN: create via cmdq_op_set_event()
* CMDQ_CODE_WAIT_NO_CLEAR: create via cmdq_op_wait_no_clear()
* CMDQ_CODE_CLEAR_TOKEN: create via cmdq_op_clear_event()
* CMDQ_CODE_PREFETCH_ENABLE: create via cmdqRecEnablePrefetch()
* CMDQ_CODE_PREFETCH_DISABLE: create via cmdqRecDisablePrefetch()
* event: the desired event type to set, clear, or wait
* Return:
* > 0 (index) for offset of instruction; else the error code is returned
*/
int32_t cmdq_task_query_offset(struct cmdqRecStruct *handle,
uint32_t startIndex,
const enum CMDQ_CODE_ENUM opCode,
enum CMDQ_EVENT_ENUM event);
int32_t cmdqRecQueryOffset(struct cmdqRecStruct *handle,
uint32_t startIndex,
const enum CMDQ_CODE_ENUM opCode,
enum CMDQ_EVENT_ENUM event);
/**
* acquire resource by resourceEvent
* Parameter:
* handle: the command queue recorder handle
* resourceEvent: the event of resource to control in GCE thread
* Return:
* 0 for success; else the error code is returned
* Note:
* mutex protected, be careful
*/
int32_t cmdq_resource_acquire(struct cmdqRecStruct *handle,
enum CMDQ_EVENT_ENUM resourceEvent);
int32_t cmdqRecAcquireResource(struct cmdqRecStruct *handle,
enum CMDQ_EVENT_ENUM resourceEvent);
/**
* acquire resource by resourceEvent and ALSO
* ADD write instruction to use resource
* Parameter:
* handle: the command queue recorder handle
* resourceEvent: the event of resource to control in GCE thread
* addr, value, mask: same as cmdq_op_write_reg
* Return:
* 0 for success; else the error code is returned
* Note:
* mutex protected, be careful
* Order: CPU clear resourceEvent at first, then add write instruction
*/
int32_t cmdq_resource_acquire_and_write(
struct cmdqRecStruct *handle,
enum CMDQ_EVENT_ENUM resourceEvent,
uint32_t addr, uint32_t value, uint32_t mask);
int32_t cmdqRecWriteForResource(
struct cmdqRecStruct *handle,
enum CMDQ_EVENT_ENUM resourceEvent,
uint32_t addr, uint32_t value, uint32_t mask);
/**
* Release resource by ADD INSTRUCTION to set event
* Parameter:
* handle: the command queue recorder handle
* resourceEvent: the event of resource to control in GCE thread
* Return:
* 0 for success; else the error code is returned
* Note:
* mutex protected, be careful
* Remember to flush handle after this API to release resource via GCE
*/
int32_t cmdq_resource_release(struct cmdqRecStruct *handle,
enum CMDQ_EVENT_ENUM resourceEvent);
int32_t cmdqRecReleaseResource(struct cmdqRecStruct *handle,
enum CMDQ_EVENT_ENUM resourceEvent);
/**
* Release resource by ADD INSTRUCTION to set event
* Parameter:
* handle: the command queue recorder handle
* resourceEvent: the event of resource to control in GCE thread
* addr, value, mask: same as cmdq_op_write_reg
* Return:
* 0 for success; else the error code is returned
* Note:
* mutex protected, be careful
* Order: Add add write instruction at first,
* then set resourceEvent instruction
* Remember to flush handle after this API to release resource via GCE
*/
int32_t cmdq_resource_release_and_write(
struct cmdqRecStruct *handle,
enum CMDQ_EVENT_ENUM resourceEvent,
uint32_t addr, uint32_t value, uint32_t mask);
int32_t cmdqRecWriteAndReleaseResource(
struct cmdqRecStruct *handle,
enum CMDQ_EVENT_ENUM resourceEvent,
uint32_t addr, uint32_t value, uint32_t mask);
/* MDP META use */
struct op_meta;
struct mdp_submit;
struct cmdq_command_buffer {
void *va_base;
u32 cmd_buf_size;
u32 avail_buf_size;
};
s32 cmdq_op_poll_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, u32 addr,
CMDQ_VARIABLE value, u32 mask);
s32 cmdq_op_read_reg_to_mem_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 addr);
s32 cmdq_op_write_reg_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, u32 addr,
CMDQ_VARIABLE value, u32 mask);
s32 cmdq_op_wait_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, enum CMDQ_EVENT_ENUM event);
s32 cmdq_op_wait_no_clear_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, enum CMDQ_EVENT_ENUM event);
s32 cmdq_op_clear_event_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, enum CMDQ_EVENT_ENUM event);
s32 cmdq_op_set_event_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, enum CMDQ_EVENT_ENUM event);
s32 cmdq_op_acquire_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, enum CMDQ_EVENT_ENUM event);
s32 cmdq_op_write_from_reg_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, u32 write_reg, u32 from_reg);
s32 cmdq_handle_flush_cmd_buf(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf);
s32 cmdq_alloc_write_addr(u32 count, dma_addr_t *paStart,
u32 clt, void *fp);
s32 cmdq_free_write_addr(dma_addr_t paStart, u32 clt);
s32 cmdq_free_write_addr_by_node(u32 clt, void *fp);
s32 cmdq_mdp_handle_create(struct cmdqRecStruct **handle_out);
s32 cmdq_mdp_handle_flush(struct cmdqRecStruct *handle);
s32 cmdq_mdp_wait(struct cmdqRecStruct *handle, void *temp);
s32 cmdq_mdp_handle_sec_setup(struct cmdqSecDataStruct *secData,
struct cmdqRecStruct *handle);
void cmdq_mdp_release_task_by_file_node(void *file_node);
void cmdqCoreReadWriteAddressBatch(u32 *addrs, u32 count, u32 *val_out);
s32 cmdq_mdp_update_sec_addr_index(struct cmdqRecStruct *handle,
u32 sec_handle, u32 index, u32 instr_index);
u32 cmdq_mdp_handle_get_instr_count(struct cmdqRecStruct *handle);
void cmdq_mdp_meta_replace_sec_addr(struct op_meta *metas,
struct mdp_submit *user_job, struct cmdqRecStruct *handle);
void cmdq_mdp_op_readback(struct cmdqRecStruct *handle, u16 engine,
dma_addr_t addr, u32 param);
#define CMDQ_CLT_MDP 0
#define CMDQ_MAX_USER_PROP_SIZE (1024)
#define MDP_META_IN_LEGACY_V2
#define CMDQ_SYSTRACE_BEGIN(fmt, args...) do { \
} while (0)
#define CMDQ_SYSTRACE_END() do { \
} while (0)
/* tablet use */
/*
* Set secure mode to prevent m4u translation fault
* Parameter:
* handle: the command queue recorder handle
* mode: secure mode type
* Return:
* 0 for success; else the error code is returned
* Note:
* mutex protected, be careful
* Remember to flush handle after this API to release resource via GCE
*/
#ifdef CONFIG_MTK_CMDQ_TAB
int32_t cmdq_task_set_secure_mode(
struct cmdqRecStruct *handle,
enum CMDQ_DISP_MODE mode);
int32_t cmdqRecSetSecureMode(struct cmdqRecStruct *handle,
enum CMDQ_DISP_MODE mode);
#endif
#ifdef __cplusplus
}
#endif
#endif /* __CMDQ_RECORD_H__ */
@@ -0,0 +1,34 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_RECORD_PRIVATE_H__
#define __CMDQ_RECORD_PRIVATE_H__
#include "cmdq_record.h"
#ifdef __cplusplus
extern "C" {
#endif
int32_t cmdq_append_command(struct cmdqRecStruct *handle,
enum CMDQ_CODE_ENUM code,
uint32_t arg_a, uint32_t arg_b,
uint32_t arg_a_type, uint32_t arg_b_type);
int32_t cmdq_op_finalize_command(struct cmdqRecStruct *handle,
bool loop);
int32_t
cmdq_setup_sec_data_of_command_desc_by_rec_handle(
struct cmdqCommandStruct *pDesc,
struct cmdqRecStruct *handle);
int32_t cmdq_rec_setup_profile_marker_data(
struct cmdqCommandStruct *pDesc,
struct cmdqRecStruct *handle);
#ifdef __cplusplus
}
#endif
#endif /* __CMDQ_RECORD_PRIVATE_H__ */
+82
View File
@@ -0,0 +1,82 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_REG_H__
#define __CMDQ_REG_H__
#include <mt-plat/sync_write.h>
#include <linux/io.h>
#include "cmdq_core.h"
#include "cmdq_device.h"
#define MMSYS_CONFIG_BASE cmdq_dev_get_module_base_VA_MMSYS_CONFIG()
#define GCE_BASE_PA cmdq_dev_get_module_base_PA_GCE()
#define GCE_BASE_VA cmdq_dev_get_module_base_VA_GCE()
#define CMDQ_CORE_WARM_RESET (GCE_BASE_VA + 0x000)
#define CMDQ_CURR_IRQ_STATUS (GCE_BASE_VA + 0x010)
#define CMDQ_SECURE_IRQ_STATUS (GCE_BASE_VA + 0x014)
#define CMDQ_CURR_LOADED_THR (GCE_BASE_VA + 0x018)
#define CMDQ_THR_SLOT_CYCLES (GCE_BASE_VA + 0x030)
#define CMDQ_THR_EXEC_CYCLES (GCE_BASE_VA + 0x034)
#define CMDQ_THR_TIMEOUT_TIMER (GCE_BASE_VA + 0x038)
#define CMDQ_BUS_CONTROL_TYPE (GCE_BASE_VA + 0x040)
#define CMDQ_CURR_INST_ABORT (GCE_BASE_VA + 0x020)
#define CMDQ_CURR_REG_ABORT (GCE_BASE_VA + 0x050)
#define CMDQ_SECURITY_STA(id) (GCE_BASE_VA + (0x030 * id) + 0x024)
#define CMDQ_SECURITY_SET(id) (GCE_BASE_VA + (0x030 * id) + 0x028)
#define CMDQ_SECURITY_CLR(id) (GCE_BASE_VA + (0x030 * id) + 0x02C)
#define CMDQ_SYNC_TOKEN_ID (GCE_BASE_VA + 0x060)
#define CMDQ_SYNC_TOKEN_VAL (GCE_BASE_VA + 0x064)
#define CMDQ_SYNC_TOKEN_UPD (GCE_BASE_VA + 0x068)
#define CMDQ_PREFETCH_GSIZE (GCE_BASE_VA + 0x0C0)
#define CMDQ_GPR_R32(id) (GCE_BASE_VA + (0x004 * id) + 0x80)
#define CMDQ_GPR_R32_PA(id) (GCE_BASE_PA + (0x004 * id) + 0x80)
#define CMDQ_THR_WARM_RESET(id) (GCE_BASE_VA + (0x080 * id) + 0x100)
#define CMDQ_THR_ENABLE_TASK(id) (GCE_BASE_VA + (0x080 * id) + 0x104)
#define CMDQ_THR_SUSPEND_TASK(id) (GCE_BASE_VA + (0x080 * id) + 0x108)
#define CMDQ_THR_CURR_STATUS(id) (GCE_BASE_VA + (0x080 * id) + 0x10C)
#define CMDQ_THR_IRQ_STATUS(id) (GCE_BASE_VA + (0x080 * id) + 0x110)
#define CMDQ_THR_IRQ_ENABLE(id) (GCE_BASE_VA + (0x080 * id) + 0x114)
#define CMDQ_THR_SECURITY(id) (GCE_BASE_VA + (0x080 * id) + 0x118)
#define CMDQ_THR_CURR_ADDR(id) (GCE_BASE_VA + (0x080 * id) + 0x120)
#define CMDQ_THR_END_ADDR(id) (GCE_BASE_VA + (0x080 * id) + 0x124)
#define CMDQ_THR_EXEC_CNT(id) (GCE_BASE_VA + (0x080 * id) + 0x128)
#define CMDQ_THR_WAIT_TOKEN(id) (GCE_BASE_VA + (0x080 * id) + 0x130)
#define CMDQ_THR_CFG(id) (GCE_BASE_VA + (0x080 * id) + 0x140)
#define CMDQ_THR_PREFETCH(id) (GCE_BASE_VA + (0x080 * id) + 0x144)
#define CMDQ_THR_INST_CYCLES(id) (GCE_BASE_VA + (0x080 * id) + 0x150)
#define CMDQ_THR_INST_THRESX(id) (GCE_BASE_VA + (0x080 * id) + 0x154)
#define CMDQ_THR_EXEC_CNT_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x128)
#define CMDQ_GCE_END_ADDR_PA (GCE_BASE_PA + 0xC00)
#define CMDQ_THR_FIX_END_ADDR(id) (CMDQ_GCE_END_ADDR_PA | (id << 4))
#define CMDQ_IS_END_ADDR(addr) ((addr & CMDQ_GCE_END_ADDR_PA) == \
CMDQ_GCE_END_ADDR_PA)
#define CMDQ_APXGPT2_COUNT (cmdq_dev_get_APXGPT2_count())
#define CMDQ_REG_GET32(addr) (readl((void *)addr) & 0xFFFFFFFF)
#define CMDQ_REG_GET16(addr) (readl((void *)addr) & 0x0000FFFF)
#define CMDQ_REG_GET64_GPR_PX(id) cmdq_core_get_GPR64(id)
#define CMDQ_REG_SET64_GPR_PX(id, value) cmdq_core_set_GPR64(id, value)
#define CMDQ_GET_GPR_PX2RX_LOW(id) ((id & 0xf) * 2)
#define CMDQ_GET_GPR_PX2RX_HIGH(id) ((id & 0xf) * 2 + 1)
#define CMDQ_REG_SET32(addr, val) mt_reg_sync_writel(val, (addr))
#endif /* __CMDQ_REG_H__ */
File diff suppressed because it is too large. Load diff
+206
View File
@@ -0,0 +1,206 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_SEC_H__
#define __CMDQ_SEC_H__
#include "cmdq_core.h"
#ifndef CONFIG_MTK_CMDQ_TAB
#if defined(CMDQ_SECURE_PATH_SUPPORT)
#include "mobicore_driver_api.h"
#include "cmdq_sec_iwc_common.h"
#endif
#else
#include "cmdq_sec_iwc_common.h"
#ifdef CMDQ_SECURE_PATH_SUPPORT
#include "trustzone/kree/system.h"
#include "trustzone/kree/mem.h"
#endif
#endif
/**
* error code for CMDQ
*/
#define CMDQ_ERR_NULL_SEC_CTX_HANDLE (6000)
#define CMDQ_ERR_SEC_CTX_SETUP (6001)
#define CMDQ_ERR_SEC_CTX_TEARDOWN (6002)
/**
* inter-world communication state
*/
enum CMDQ_IWC_STATE_ENUM {
IWC_INIT = 0,
IWC_MOBICORE_OPENED = 1,
IWC_WSM_ALLOCATED = 2,
IWC_SES_OPENED = 3,
IWC_SES_MSG_PACKAGED = 4,
IWC_SES_TRANSACTED = 5,
IWC_SES_ON_TRANSACTED = 6,
IWC_END_OF_ENUM = 7,
};
/**
* CMDQ secure context struct
* note it is not global data, each process has its own CMDQ sec context
*/
struct cmdqSecContextStruct {
struct list_head listEntry;
/* basic info */
uint32_t tgid; /* tgid of process context */
uint32_t referCount; /* reference count for open cmdq device node */
/* iwc state */
enum CMDQ_IWC_STATE_ENUM state;
/* iwc information */
void *iwcMessage; /* message buffer */
#ifndef CONFIG_MTK_CMDQ_TAB
#if defined(CMDQ_SECURE_PATH_SUPPORT)
/* Universally Unique Identifier of secure tl/dr */
struct mc_uuid_t uuid;
struct mc_session_handle sessionHandle; /* session handle */
#endif
/* true if someone has opened mobicore */
/* device in this prpocess context */
uint32_t openMobicoreByOther;
#else
#if defined(CMDQ_SECURE_PATH_SUPPORT)
KREE_SESSION_HANDLE sessionHandle;
KREE_SESSION_HANDLE memSessionHandle;
#endif
#endif
};
int32_t cmdq_sec_init_allocate_resource_thread(void *data);
/**
* Create and destroy non-cachable shared memory,
* used to share data for CMDQ driver between NWd and SWd
*
* Be careful that we should not disvlose
* any information about secure buffer address of
*/
int32_t cmdq_sec_create_shared_memory(
struct cmdqSecSharedMemoryStruct **pHandle,
const uint32_t size);
int32_t cmdq_sec_destroy_shared_memory(
struct cmdqSecSharedMemoryStruct *handle);
/**
* Callback to fill message buffer for secure task
*
* Params:
* init32_t command id
* void* pornter of TaskStruct
* int32_t CMDQ HW thread id
* void* the inter-world communication buffer
* Return:
* >=0 for success;
*/
#ifndef CONFIG_MTK_CMDQ_TAB
typedef int32_t(*CmdqSecFillIwcCB) (int32_t, void *, int32_t, void *);
#else
typedef int32_t(*CmdqSecFillIwcCB) (struct iwcCmdqMessage_t *_pIwc,
uint32_t iwcCommand,
struct TaskStruct *_pTask, int32_t thread);
#endif
/**
* Entry secure world to handle secure path jobs
* .submit task
* .cancel error task
*/
int32_t cmdq_sec_exec_task_async_unlocked(
struct TaskStruct *pTask, int32_t thread);
int32_t cmdq_sec_cancel_error_task_unlocked(
struct TaskStruct *pTask, int32_t thread,
struct cmdqSecCancelTaskResultStruct *pResult);
int32_t cmdq_sec_allocate_path_resource_unlocked(bool throwAEE);
/**
* secure path control
*/
void cmdq_sec_lock_secure_path(void);
void cmdq_sec_unlock_secure_path(void);
void cmdqSecInitialize(void);
void cmdqSecDeInitialize(void);
void cmdqSecEnableProfile(const bool enable);
/* function declaretion */
struct cmdqSecContextStruct *cmdq_sec_context_handle_create(
uint32_t tgid);
#ifdef CONFIG_MTK_CMDQ_TAB
int32_t cmdq_sec_submit_to_secure_world_async_unlocked(
uint32_t iwcCommand,
struct TaskStruct *pTask,
int32_t thread,
CmdqSecFillIwcCB iwcFillCB, void *data, bool throwAEE);
struct cmdqSecContextStruct *cmdq_sec_acquire_context_handle(
uint32_t tgid);
int32_t cmdq_sec_release_context_handle(uint32_t tgid);
void cmdq_sec_dump_context_list(void);
int cmdq_sec_init_secure_path(void *data);
void cmdq_sec_set_commandId(uint32_t cmdId);
const uint32_t cmdq_sec_get_commandId(void);
int32_t cmdq_sec_init_share_memory(void);
void cmdq_debug_set_sw_copy(int32_t value);
int32_t cmdq_debug_get_sw_copy(void);
void cmdq_sec_set_sec_print_count(uint32_t count, bool bPrint);
uint32_t cmdq_sec_get_sec_print_count(void);
int32_t cmdq_sec_get_log_level(void);
/* add for universal communicate with TEE */
struct transmitBufferStruct {
void *pBuffer; /* the share memory */
uint32_t size; /* share memory size */
#ifdef CMDQ_SECURE_PATH_SUPPORT
KREE_SHAREDMEM_HANDLE shareMemHandle;
KREE_SESSION_HANDLE cmdqHandle;
KREE_SESSION_HANDLE memSessionHandle;
#endif
};
#if defined(CMDQ_SECURE_PATH_SUPPORT)
/* the session to communicate with TA */
KREE_SESSION_HANDLE cmdq_session_handle(void);
KREE_SESSION_HANDLE cmdq_mem_session_handle(void);
int32_t cmdq_sec_create_shared_memory(
struct cmdqSecSharedMemoryStruct **pHandle,
const uint32_t size);
int32_t cmdq_sec_destroy_shared_memory(
struct cmdqSecSharedMemoryStruct *handle);
int32_t cmdqSecRegisterSecureBuffer(
struct transmitBufferStruct *pSecureData);
int32_t cmdqSecServiceCall(
struct transmitBufferStruct *pSecureData, int32_t cmd);
int32_t cmdqSecUnRegisterSecureBuffer(
struct transmitBufferStruct *pSecureData);
void cmdq_sec_register_secure_irq(void);
#endif
#endif
#endif /* __DDP_CMDQ_SEC_H__ */
@@ -0,0 +1,19 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_STRUCT_H__
#define __CMDQ_STRUCT_H__
#include <linux/list.h>
#include <linux/spinlock.h>
struct cmdqFileNodeStruct {
pid_t userPID;
pid_t userTGID;
struct list_head taskList;
spinlock_t nodeLock;
};
#endif /* __CMDQ_STRUCT_H__ */
@@ -0,0 +1,52 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
/* GCE subsys */
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_G3D_CONFIG_BASE, 0, MFG, g3d_config_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_MMSYS_CONFIG, 1, MMSYS, mmsys_config_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_DISP_DITHER, 2, MMSYS, disp_dither_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_NA, 3, MMSYS, mm_na_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_IMGSYS, 4, CAM, imgsys_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_VDEC_GCON, 5, VDEC, vdec_gcon_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_VENC_GCON, 6, VENC, venc_gcon_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_CONN_PERIPHERALS, 7, PERISYS, conn_peri_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_TOPCKGEN, 8, TOP_AO_3, topckgen_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_KP, 9, INFRA_AO, kp_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_SCP_SRAM, 10, INFRA_AO, scp_sram_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_INFRA_NA3, 11, NA, infra_na3_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_INFRA_NA4, 12, NA, infra_na4_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_SCP, 13, SCP, scp_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_MCUCFG, 14, INFRASYS, mcucfg_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_GCPU, 15, INFRASYS, gcpu_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_USB0, 16, PERISYS, usb0_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_USB_SIF, 17, PERISYS, usb_sif_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_AUDIO, 18, PERISYS, audio_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_MSDC0, 19, PERISYS, msdc0_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_MSDC1, 20, PERISYS, msdc1_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_MSDC2, 21, PERISYS, msdc2_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_MSDC3, 22, PERISYS, msdc3_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_AP_DMA, 23, INFRASYS, ap_dma_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_GCE, 24, GCE, gce_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_VDEC, 25, VDEC, vdec_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_VDEC1, 26, VDEC, vdec1_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_VDEC2, 27, VDEC, vdec2_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_VDEC3, 28, VDEC, vdec3_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_CAMSYS, 29, CAMSYS, camsys_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_CAMSYS1, 30, CAMSYS, camsys1_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_CAMSYS2, 31, CAMSYS, camsys2_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_CAMSYS3, 32, CAMSYS, camsys3_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_IMGSYS1, 33, IMGSYS, imgsys1_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_SMI_LAB1, 34, SMI_LAB1, smi_larb1_base)
/* Special subsys */
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_PWM_SW, 35, SPECIAL, pwm_sw_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_PWM1_SW, 36, SPECIAL, pwm1_sw_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_DIP_A0_SW, 37, SPECIAL, dip_a0_sw_base)
DECLARE_CMDQ_SUBSYS(CMDQ_SUBSYS_IMGSYS_CONFIG, 38, SPECIAL, imgsys_config)
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,150 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_CORE_VIRTUAL_H__
#define __CMDQ_CORE_VIRTUAL_H__
#include "cmdq_def.h"
/* get subsys LSB in arg_a */
typedef uint32_t(*CmdqGetSubsysLSBArgA) (void);
/* is a secure thread */
typedef bool(*CmdqIsSecureThread) (const int32_t thread);
/* is valid notify thread for secure path */
typedef bool(*CmdqIsValidNotifyThread) (const int32_t thread);
/* is display scenario */
typedef bool(*CmdqIsDispScenario) (const enum CMDQ_SCENARIO_ENUM scenario);
/* should enable prefetch */
typedef bool(*CmdqShouldEnablePrefetch) (
const enum CMDQ_SCENARIO_ENUM scenario);
/* should profile */
typedef bool(*CmdqShouldProfile) (const enum CMDQ_SCENARIO_ENUM scenario);
/* display thread index from scenario */
typedef int (*CmdqDispThread) (enum CMDQ_SCENARIO_ENUM scenario);
/* get thread index from scenario and secure */
typedef int (*CmdqGetThreadID) (enum CMDQ_SCENARIO_ENUM scenario,
const bool secure);
/* priority from scenario */
typedef enum CMDQ_HW_THREAD_PRIORITY_ENUM(*CmdqPriority) (
enum CMDQ_SCENARIO_ENUM scenario);
/* force loop IRQ from scenario */
typedef bool(*cmdq_force_loop_irq) (enum CMDQ_SCENARIO_ENUM scenario);
/* is disp loop */
typedef bool(*cmdq_is_disp_loop) (enum CMDQ_SCENARIO_ENUM scenario);
/* get register index from hwflag */
typedef void(*CmdqGetRegID) (uint64_t hwflag,
enum CMDQ_DATA_REGISTER_ENUM *valueRegId,
enum CMDQ_DATA_REGISTER_ENUM *destRegId,
enum CMDQ_EVENT_ENUM *regAccessToken);
/* module from event index */
typedef const char *(*CmdqModuleFromEvent) (const int32_t event,
struct CmdqCBkStruct *groupCallback, uint64_t engineFlag);
/* parse module from register addr */
typedef const char *(*CmdqParseModule) (uint32_t reg_addr);
/* can module entry suspend */
typedef int32_t(*CmdqModuleEntrySuspend) (struct EngineStruct *engineList);
/* print status clock */
typedef ssize_t(*CmdqPrintStatusClock) (char *buf);
/* print seq status clock */
typedef void (*CmdqPrintStatusSeqClock) (struct seq_file *m);
/* enable common clock locked */
typedef void (*CmdqEnableCommonClockLocked) (bool enable);
/* enable GCE clock locked */
typedef void (*CmdqEnableGCEClockLocked) (bool enable);
/* parse error module by hwflag */
typedef const char *(*CmdqParseErrorModule) (const struct TaskStruct *pTask);
/* dump mmsys config */
typedef void (*CmdqDumpMMSYSConfig) (void);
/* dump clock gating */
typedef void (*CmdqDumpClockGating) (void);
/* dump SMI */
typedef int (*CmdqDumpSMI) (const int showSmiDump);
/* dump GPR */
typedef void (*CmdqDumpGPR) (void);
/* flag from scenario */
typedef uint64_t(*CmdqFlagFromScenario) (enum CMDQ_SCENARIO_ENUM scenario);
/* evet backup */
typedef void (*CmdqEventBackup) (void);
/* evet restore */
typedef void (*CmdqEventRestore) (void);
/* test setup */
typedef void (*CmdqTestSetup) (void);
/* test cleanup */
typedef void (*CmdqTestCleanup) (void);
/* test for instruction statistic */
typedef void (*CmdqInitModulePAStat) (void);
struct cmdqCoreFuncStruct {
CmdqGetSubsysLSBArgA getSubsysLSBArgA;
CmdqIsSecureThread isSecureThread;
CmdqIsValidNotifyThread isValidNotifyThread;
CmdqIsDispScenario isDispScenario;
CmdqShouldEnablePrefetch shouldEnablePrefetch;
CmdqShouldProfile shouldProfile;
CmdqDispThread dispThread;
CmdqGetThreadID getThreadID;
CmdqPriority priority;
cmdq_force_loop_irq force_loop_irq;
cmdq_is_disp_loop is_disp_loop;
CmdqGetRegID getRegID;
CmdqModuleFromEvent moduleFromEvent;
CmdqParseModule parseModule;
CmdqModuleEntrySuspend moduleEntrySuspend;
CmdqPrintStatusClock printStatusClock;
CmdqPrintStatusSeqClock printStatusSeqClock;
CmdqEnableCommonClockLocked enableCommonClockLocked;
CmdqEnableGCEClockLocked enableGCEClockLocked;
CmdqParseErrorModule parseErrorModule;
CmdqDumpMMSYSConfig dumpMMSYSConfig;
CmdqDumpClockGating dumpClockGating;
CmdqDumpSMI dumpSMI;
CmdqDumpGPR dumpGPR;
CmdqFlagFromScenario flagFromScenario;
CmdqEventBackup eventBackup;
CmdqEventRestore eventRestore;
CmdqTestSetup testSetup;
CmdqTestCleanup testCleanup;
CmdqInitModulePAStat initModulePAStat;
};
#ifdef __cplusplus
extern "C" {
#endif
void cmdq_virtual_function_setting(void);
struct cmdqCoreFuncStruct *cmdq_get_func(void);
#ifdef __cplusplus
}
#endif
#endif /* __CMDQ_CORE_VIRTUAL_H__ */
@@ -0,0 +1,236 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_SEC_IWC_COMMON_H__
#define __CMDQ_SEC_IWC_COMMON_H__
/* shared DRAM */
/* bit x = 1 means thread x raise IRQ */
#define CMDQ_SEC_SHARED_IRQ_RAISED_OFFSET (0x0)
#define CMDQ_SEC_SHARED_THR_CNT_OFFSET (0x100)
#define CMDQ_SEC_SHARED_TASK_VA_OFFSET (0x200)
#define CMDQ_SEC_SHARED_OP_OFFSET (0x300)
/* commanad buffer & metadata */
#define CMDQ_TZ_CMD_BLOCK_SIZE (32 * 1024)
#define CMDQ_IWC_MAX_CMD_LENGTH (32 * 1024 / 4)
#define CMDQ_IWC_MAX_ADDR_LIST_LENGTH (20)
#define CMDQ_IWC_CLIENT_NAME (16)
#define CMDQ_SEC_MESSAGE_INST_LEN (8)
#define CMDQ_SEC_DISPATCH_LEN (8)
enum CMDQ_IWC_ADDR_METADATA_TYPE {
CMDQ_IWC_H_2_PA = 0, /* sec handle to sec PA */
CMDQ_IWC_H_2_MVA = 1, /* sec handle to sec MVA */
CMDQ_IWC_NMVA_2_MVA = 2, /* map normal MVA to secure world */
/* DDP register needs to set opposite value when HDCP fail */
CMDQ_IWC_DDP_REG_HDCP = 3,
};
/* */
/* IWC message */
/* */
struct iwcCmdqAddrMetadata_t {
/* [IN]_d, index of instruction. Update its arg_b */
/* value to real PA/MVA in secure world */
uint32_t instrIndex;
/*
* Note: Buffer and offset
*
* -------------
* | | |
* -------------
* ^ ^ ^ ^
* A B C D
*
* A: baseHandle
* B: baseHandle + blockOffset
* C: baseHandle + blockOffset + offset
* A~B or B~D: size
*/
uint32_t type; /* [IN] addr handle type*/
uint64_t baseHandle; /* [IN]_h, secure address handle */
/* [IN]_b, block offset from handle(PA) to current block(plane) */
uint32_t blockOffset;
uint32_t offset; /* [IN]_b, buffser offset to secure handle */
uint32_t size; /* buffer size */
uint32_t port; /* hw port id (i.e. M4U port id)*/
uint32_t sec_id;
uint32_t useSecIdinMeta;
int32_t ionFd;
};
struct iwcCmdqDebugConfig_t {
int32_t logLevel;
int32_t enableProfile;
};
struct iwcCmdqSecStatus_t {
uint32_t step;
int32_t status;
uint32_t args[4];
uint32_t sec_inst[CMDQ_SEC_MESSAGE_INST_LEN];
uint32_t inst_index;
char dispatch[CMDQ_SEC_DISPATCH_LEN];
};
struct iwcCmdqSystraceLog_t {
uint64_t startTime; /* start timestamp */
uint64_t endTime; /* end timestamp */
};
/* tablet use */
enum CMDQ_IWC_DISP_MODE {
CMDQ_IWC_DISP_NON_SUPPORTED_MODE = 0,
CMDQ_IWC_DISP_SINGLE_MODE = 1,
CMDQ_IWC_DISP_VIDEO_MODE = 2,
CMDQ_IWC_MDP_USER_MODE = 3,
};
struct iwcCmdqMetadata_t {
uint32_t addrListLength;
struct iwcCmdqAddrMetadata_t addrList[CMDQ_IWC_MAX_ADDR_LIST_LENGTH];
uint64_t enginesNeedDAPC;
uint64_t enginesNeedPortSecurity;
#ifdef CONFIG_MTK_CMDQ_TAB
enum CMDQ_IWC_DISP_MODE secMode;
/* for MDP to copy HDCP version from srcHandle to dstHandle */
/* will remove later */
uint32_t srcHandle;
uint32_t dstHandle;
#endif
};
struct iwcCmdqSectraceBuffer_t {
uint32_t addr; /* pass VA for TCI cases, and pass PA for DCI case */
uint32_t size;
};
struct iwcCmdqPathResource_t {
/* use long long for 64 bit compatible support */
long long shareMemoyPA;
uint32_t size;
bool useNormalIRQ; /* use normal IRQ in SWd */
};
struct iwcCmdqCancelTask_t {
/* [IN] */
int32_t thread;
uint32_t waitCookie;
/* [OUT] */
bool throwAEE;
bool hasReset;
int32_t irqStatus; /* global secure IRQ flag */
int32_t irqFlag; /* thread IRQ flag */
uint32_t errInstr[2]; /* errInstr[0] = instB, errInstr[1] = instA */
uint32_t regValue;
uint32_t pc;
};
struct iwcCmdqCommand_t {
/* basic execution data */
uint32_t thread;
uint32_t scenario;
uint32_t priority;
uint32_t commandSize;
uint64_t engineFlag;
uint32_t pVABase[CMDQ_IWC_MAX_CMD_LENGTH];
/* exec order data */
/* [IN] index in thread's task list, it should be (nextCookie - 1) */
uint32_t waitCookie;
bool resetExecCnt; /* [IN] reset HW thread */
/* client info */
int32_t callerPid;
char callerName[CMDQ_IWC_CLIENT_NAME];
/* metadata */
struct iwcCmdqMetadata_t metadata;
/* debug */
uint64_t hNormalTask; /* handle to reference task in normal world*/
};
/* */
/* linex kernel and mobicore has their own MMU tables, */
/* the latter's is used to map world shared memory and physical address */
/* so mobicore dose not understand linux virtual address mapping. */
/* */
/* if we want to transact a large buffer in TCI/DCI, */
/* there are 2 method (both need 1 copy): */
/* 1. use mc_map, to map normal world buffer to WSM, */
/* and pass secure_virt_addr in TCI/DCI buffer */
/* note mc_map implies a memcopy to copy */
/* content from normal world to WSM */
/* 2. declare a fixed length array in */
/* TCI/DCI struct, and its size must be < 1M */
/* */
struct iwcCmdqMessage_t {
union {
uint32_t cmd; /* [IN] command id */
int32_t rsp; /* [OUT] 0 for success, < 0 for error */
};
union {
struct iwcCmdqCommand_t command;
struct iwcCmdqCancelTask_t cancelTask;
struct iwcCmdqPathResource_t pathResource;
struct iwcCmdqSectraceBuffer_t sectracBuffer;
};
struct iwcCmdqDebugConfig_t debug;
struct iwcCmdqSecStatus_t secStatus;
};
/* */
/* ERROR code number (ERRNO) */
/* note the error result returns negative value, i.e, -(ERRNO) */
/* */
#define CMDQ_ERR_NOMEM (12) /* out of memory */
#define CMDQ_ERR_FAULT (14) /* bad address */
#define CMDQ_ERR_ADDR_CONVERT_HANDLE_2_PA (1000)
#define CMDQ_ERR_ADDR_CONVERT_ALLOC_MVA (1100)
#define CMDQ_ERR_ADDR_CONVERT_ALLOC_MVA_N2S (1101)
#define CMDQ_ERR_ADDR_CONVERT_FREE_MVA (1200)
#define CMDQ_ERR_PORT_CONFIG (1300)
/* param check */
#define CMDQ_ERR_UNKNOWN_ADDR_METADATA_TYPE (1400)
#define CMDQ_ERR_TOO_MANY_SEC_HANDLE (1401)
/* security check */
#define CMDQ_ERR_SECURITY_INVALID_INSTR (1500)
#define CMDQ_ERR_SECURITY_INVALID_SEC_HANDLE (1501)
#define CMDQ_ERR_SECURITY_INVALID_DAPC_FALG (1502)
#define CMDQ_ERR_INSERT_DAPC_INSTR_FAILED (1503)
#define CMDQ_ERR_INSERT_PORT_SECURITY_INSTR_FAILED (1504)
#define CMDQ_ERR_INVALID_SECURITY_THREAD (1505)
#define CMDQ_ERR_PATH_RESOURCE_NOT_READY (1506)
#define CMDQ_ERR_NULL_TASK (1507)
/* secure access error */
#define CMDQ_ERR_MAP_ADDRESS_FAILED (2001)
#define CMDQ_ERR_UNMAP_ADDRESS_FAILED (2002)
#define CMDQ_ERR_RESUME_WORKER_FAILED (2003)
#define CMDQ_ERR_SUSPEND_WORKER_FAILED (2004)
/* HW error */
#define CMDQ_ERR_SUSPEND_HW_FAILED (4001)
#define CMDQ_ERR_RESET_HW_FAILED (4002)
#define CMDQ_TL_ERR_UNKNOWN_IWC_CMD (5000)
#define CMDQ_ERR_DR_IPC_EXECUTE_SESSION (5001)
#define CMDQ_ERR_DR_IPC_CLOSE_SESSION (5002)
#define CMDQ_ERR_DR_EXEC_FAILED (5003)
#endif /* __CMDQ_SEC_TLAPI_H__ */
@@ -0,0 +1,59 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQSECTL_API_H__
#define __CMDQSECTL_API_H__
/**
* Command IDs for normal world(TLC or linux kernel) to Trustlet
*/
#define CMD_CMDQ_TL_SUBMIT_TASK 1
/* (not used)release resource in secure path per session */
#define CMD_CMDQ_TL_RES_RELEASE 2
#define CMD_CMDQ_TL_CANCEL_TASK 3
/* create global resource for secure path */
#define CMD_CMDQ_TL_PATH_RES_ALLOCATE 4
/* destroy globacl resource for secure path */
#define CMD_CMDQ_TL_PATH_RES_RELEASE 5
/* create shared memory in Normal and Secure world */
#define CMD_CMDQ_TL_INIT_SHARED_MEMORY 6
/* register secure irq */
#define CMD_CMDQ_TL_REGISTER_SECURE_IRQ 8
#define CMD_CMDQ_TL_DUMP_SMI_LARB 9
/* entry cmdqSecTl, and do nothing */
#define CMD_CMDQ_TL_TEST_HELLO_TL (4000)
/* entry cmdqSecTl and cmdqSecDr, and do nothing */
#define CMD_CMDQ_TL_TEST_DUMMY (4001)
#define CMD_CMDQ_TL_TEST_SMI_DUMP (4002)
#define CMD_CMDQ_TL_TRAP_DR_INFINITELY (4004)
#define CMD_CMDQ_TL_DUMP (4005)
#define CMD_CMDQ_TL_SECTRACE_MAP (3000)
#define CMD_CMDQ_TL_SECTRACE_UNMAP (3001)
#define CMD_CMDQ_TL_SECTRACE_TRANSACT (3002)
/**
* Termination codes
*/
#define EXIT_ERROR ((uint32_t)(-1))
/**
* TCI message data: see cmdq_sec_iwc_common.h
*/
/**
* Trustlet UUID:
* filename of output bin is {TL_UUID}.tlbin
*/
#ifndef CONFIG_MTK_CMDQ_TAB
#define TL_CMDQ_UUID { { 9, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
#else
#define TZ_TA_CMDQ_NAME "CMDQ_TA"
#define TZ_TA_CMDQ_UUID "5c071864-505d-11e4-9e35-164230d1df67"
#endif
#endif /*__CMDQSECTEST_API_H__*/
@@ -0,0 +1,38 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# 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.
#
# drivers/cmdq
ccflags-y += -I$(srctree)/drivers/misc/mediatek/cmdq/v2 \
-I$(srctree)/drivers/misc/mediatek/m4u/$(MTK_PLATFORM)
# Enable MET
ccflags-y += -DMET_USER_EVENT_SUPPORT
ifeq ($(CONFIG_MTK_CMDQ_TAB), y)
ccflags-y += -DCMDQ_USE_LEGACY
endif
ifeq ($(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT),y)
ccflags-y += -DCMDQ_SECURE_PATH_SUPPORT
endif
ccflags-y += -I$(srctree)/include
ccflags-y += -I$(srctree)/include/trustzone
ccflags-y += -I$(srctree)/drivers/misc/mediatek/cmdq/v2/$(MTK_PLATFORM)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/cmdq/v2/mtee
ccflags-y += -I$(srctree)/drivers/misc/mediatek/cmdq/v2/inc/cmdq_sec_dr \
-I$(srctree)/drivers/misc/mediatek/cmdq/v2/inc/cmdq_sec_tl \
-I$(srctree)/drivers/misc/mediatek/mach/$(MTK_PLATFORM)/include \
-I$(srctree)/drivers/misc/mediatek/include/mt-plat/trustzone
obj-y += cmdq_sec.o
File diff suppressed because it is too large. Load diff