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

+33
View File
@@ -0,0 +1,33 @@
config MTK_CMDQ_V3
bool "build CMDQ v3 driver"
help
This CMDQ module is used for help multi-media driver,
to control HW engine register in specific timing,
and notify caller configuration is done.
Especially for display/MDP.
config MTK_CMDQ
bool "MediaTek CMDQ Support"
help
Add support for the MediaTek Command Queue (CMDQ)
driver. The CMDQ is used to help read/write registers with critical
time limitation, such as updating display configuration during the
vblank.
config MTK_CMDQ_TAB
bool "enable CMDQ Tablet compatibility"
help
Enable this config to be compatible with Tablet architecture
especially SVP path
This CMDQ module is used for help multi-media driver,
to control HW engine register in specific timing,
and notify caller configuration is done.
config MTK_CMDQ_MBOX_EXT
bool "enable CMDQ mailbox driver extension"
help
This extension enable debug feature, such as cmdq-status,
cmdq-record, pre-dump, timeout error dump, first error buffer
and aee db. Enable performance tools which add instruction
inside packet and profiling. Also enable secure path with
new sec controller which decuple with v3 driver.
+39
View File
@@ -0,0 +1,39 @@
#
# 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.
#
ifeq ($(CONFIG_MACH_MT6781),y)
CMDQ_PLATFORM := "mt6781"
else
CMDQ_PLATFORM := $(CONFIG_MTK_PLATFORM)
endif
# common driver code for CMDQ
ifeq ($(CONFIG_MTK_CMDQ_V3),y)
ifneq (,$(filter $(CMDQ_PLATFORM), "mt6739" "mt6768" "mt6771" "mt8168" "mt6785" "mt6761" "mt6765" "mt6779"))
obj-y += v3/
endif
else ifneq (,$(filter $(CMDQ_PLATFORM), "mt8167" "mt6761" "mt6765" "mt6779"))
obj-y += v2/
endif
ifeq ($(CONFIG_MTK_CMDQ_TAB), y)
obj-y += v2/
endif
obj-$(CONFIG_MTK_CMDQ_MBOX_EXT) += mailbox/
obj-$(CONFIG_MTK_MT6382_BDG) += bridge/
# mdp_sw_sync
ifeq (,$(filter $(CMDQ_PLATFORM), "mt6885" "mt6873" "mt6853" "mt6893" "mt6833" "mt6877" "mt6781"))
obj-y += mdp_sync/
endif
# EOF
@@ -0,0 +1,12 @@
# SPDX-License-Identifier: GPL-2.0
#
# Copyright (c) 2021 MediaTek Inc.
#
ccflags-y += -I$(srctree)/drivers/misc/mediatek/cmdq/v3
ccflags-y += -I$(srctree)/drivers/misc/mediatek/cmdq/v3/$(MTK_PLATFORM)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mmp
ccflags-y += -I$(srctree)/drivers/misc/mediatek/spi_slave_drv
obj-y += cmdq-bdg-mailbox.o
obj-y += cmdq-bdg-test.o
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,428 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <linux/platform_device.h>
#include <linux/completion.h>
#include <linux/debugfs.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/of.h>
#include "cmdq-bdg.h"
#if IS_ENABLED(CONFIG_MTK_CMDQ_MBOX_EXT)
#include <linux/soc/mediatek/mtk-cmdq.h>
#else
#include <cmdq_record.h>
#endif
#define SYSBUF_BASE 0xA000
#define SYSBUF_SIZE 0x2000
#define GCE_BASE 0x10000
#define CMDQ_GPR_R32(base, id) ((base) + (0x4 * (id)) + 0x80)
struct cmdq_bdg_test {
struct device *dev;
struct cmdq_client *clt;
struct cmdq_client *clt2;
u16 token_user0;
u16 token_gpr_set4;
};
enum flush_flag {sync, async, threaded};
#if IS_ENABLED(CONFIG_MTK_CMDQ_MBOX_EXT)
static void cmdq_bdg_test_mbox_async_cb(struct cmdq_cb_data data)
{
struct cmdq_flush_completion *cmplt = data.data;
if (cmplt) {
cmplt->err = data.err;
cmdq_msg("cmplt:%p pkt:%p err:%d", cmplt, cmplt->pkt, data.err);
complete(&cmplt->cmplt);
}
}
static void cmdq_bdg_test_mbox_threaded_cb(struct cmdq_cb_data data)
{
struct cmdq_pkt *pkt = (struct cmdq_pkt *)data.data;
cmdq_msg("pkt:%p err:%d", pkt, data.err);
cmdq_pkt_destroy(pkt);
}
#else
static void cmdq_bdg_test_rec_async_cb(void *data)
{
struct cmdqRecStruct *rec = (struct cmdqRecStruct *)data;
cmdq_msg("%s: rec:%p pkt:%p priority:%d thread:%d",
__func__, rec, rec->pkt, rec->pkt->priority, rec->thread);
cmdqRecDestroy(rec);
}
#endif
static void cmdq_bdg_test_mbox_write(struct cmdq_bdg_test *test,
const u32 count, const bool masked, const bool reuse)
{
#if IS_ENABLED(CONFIG_MTK_CMDQ_MBOX_EXT)
struct cmdq_pkt *pkt;
#else
struct cmdqRecStruct *rec;
#endif
const dma_addr_t pa = CMDQ_GPR_R32(GCE_BASE, CMDQ_GPR_R15);
const u32 pttn = BIT(15) | count;
const u32 mask = masked ? BIT(15) | BIT(7) | BIT(1) : UINT_MAX;
s32 val, i;
spi_write_reg(pa, masked ? 0x0 : 0xdeaddead);
val = spi_read_reg(pa);
cmdq_msg("%s: masked:%d reuse:%d pa:%pa val:%#x pttn:%#x mask:%#x",
__func__, masked, reuse, &pa, val, pttn, mask);
#if IS_ENABLED(CONFIG_MTK_CMDQ_MBOX_EXT)
pkt = cmdq_pkt_create(test->clt);
cmdq_pkt_write(pkt, NULL, pa, pttn, mask);
for (i = 0; i < count; i++)
cmdq_pkt_write(pkt, NULL, pa, BIT(15) | (i + 1), mask);
cmdq_pkt_flush(pkt);
cmdq_pkt_destroy(pkt);
#else
cmdqRecCreate(CMDQ_BDG_SCENARIO_DISP_TEST, &rec);
for (i = 0; i < count; i++)
cmdqRecWrite(rec, pa, BIT(15) | (i + 1), mask);
rec->pkt->reuse = true;
for (i = 0; reuse && i < count; i++) {
cmdq_msg("%s: rec:%p pkt:%p reuse:%d:%d scenario:%d thread:%d",
__func__, rec, rec->pkt, i, rec->pkt->reuse,
rec->scenario, rec->thread);
cmdqRecFlush(rec);
}
rec->pkt->reuse = false;
cmdq_msg("%s: rec:%p pkt:%p reuse:%d:%d scenario:%d thread:%d",
__func__, rec, rec->pkt, i, rec->pkt->reuse,
rec->scenario, rec->thread);
cmdqRecFlush(rec);
cmdqRecDestroy(rec);
#endif
val = spi_read_reg(pa);
if (val != (pttn & mask))
cmdq_err("masked:%d pa:%pa val:%#x ans:%#x",
masked, &pa, val, pttn & mask);
else
cmdq_msg("%s: masked:%d pa:%pa val:%#x ans:%#x",
__func__, masked, &pa, val, pttn & mask);
}
static int cmdq_bdg_test_mbox_token(void *data)
{
struct cmdq_bdg_test *test = (struct cmdq_bdg_test *)data;
spi_write_reg(GCE_BASE + 0x68, BIT(16) | test->token_user0);
return 0;
}
static void cmdq_bdg_test_mbox_tasks(struct cmdq_bdg_test *test,
const enum flush_flag flag, const u32 count, const bool error)
{
#if IS_ENABLED(CONFIG_MTK_CMDQ_MBOX_EXT)
struct cmdq_pkt *pkt[count];
struct cmdq_flush_completion cmplt[count];
#else
struct cmdqRecStruct *rec[count];
#endif
const dma_addr_t pa = CMDQ_GPR_R32(GCE_BASE, CMDQ_GPR_R15);
s32 val, err = UINT_MAX, i;
if (flag == sync) {
cmdq_err("%s: count:%u flag:%d", __func__, count, flag);
return;
}
spi_write_reg(pa, 0xdeaddead);
spi_write_reg(GCE_BASE + 0x68, test->token_user0);
val = spi_read_reg(pa);
cmdq_msg("%s: count:%u flag:%d pa:%pa val:%#x err:%d",
__func__, count, flag, &pa, val, err);
msleep_interruptible(100);
#if IS_ENABLED(CONFIG_MTK_CMDQ_MBOX_EXT)
for (i = 0; i < count; i++) {
pkt[i] = cmdq_pkt_create(test->clt);
pkt[i]->priority = i;
cmdq_msg("%s: i:%d/%d pkt:%p prio:%d",
__func__, i, count, pkt[i], pkt[i]->priority);
cmdq_pkt_wfe(pkt[i], test->token_user0);
cmdq_pkt_write(pkt[i], NULL, pa, count - i, UINT_MAX);
if (flag == async) {
init_completion(&cmplt[i].cmplt);
cmplt[i].pkt = pkt[i];
cmdq_pkt_flush_async(pkt[i],
cmdq_bdg_test_mbox_async_cb, &cmplt[i]);
} else if (flag == threaded)
cmdq_pkt_flush_threaded(pkt[i],
cmdq_bdg_test_mbox_threaded_cb, (void *)pkt[i]);
}
#else
for (i = 0; i < count; i++) {
cmdqRecCreate(CMDQ_BDG_SCENARIO_DISP_TEST, &rec[i]);
rec[i]->pkt->priority = i;
cmdq_msg("%s: i:%d rec:%p pkt:%p priority:%d thread:%d",
__func__, i, rec[i],
rec[i]->pkt, rec[i]->pkt->priority, rec[i]->thread);
cmdqRecWait(rec[i], test->token_user0);
cmdqRecWrite(rec[i], pa, count - i, UINT_MAX);
cmdqRecFlushAsyncCallback(rec[i],
(void *)cmdq_bdg_test_rec_async_cb,
(unsigned long)(void *)rec[i]);
}
#endif
if (!error)
kthread_run(cmdq_bdg_test_mbox_token, test, "cmdq_bdg_token");
#if IS_ENABLED(CONFIG_MTK_CMDQ_MBOX_EXT)
for (i = 0; i < count; i++) {
if (!pkt[i]) {
cmdq_err("pkt:%d is NULL", i);
continue;
}
msleep_interruptible(10);
if (flag == async) {
wait_for_completion(&cmplt[i].cmplt);
err = cmplt[i].err;
cmdq_pkt_destroy(pkt[i]);
}
}
#endif
msleep_interruptible(100);
val = spi_read_reg(pa);
if (val != count)
cmdq_err("count:%u flag:%d pa:%pa val:%#x err:%d ans:%#x",
count, flag, &pa, val, err, count);
else
cmdq_msg("%s: count:%u flag:%d pa:%pa val:%#x err:%d ans:%#x",
__func__, count, flag, &pa, val, err, count);
}
static void cmdq_bdg_test_mbox_threads(struct cmdq_bdg_test *test,
const bool pass)
{
#if IS_ENABLED(CONFIG_MTK_CMDQ_MBOX_EXT)
struct cmdq_pkt *pkt, *pkt2;
#else
struct cmdqRecStruct *rec, *rec2;
#endif
const dma_addr_t pa = CMDQ_GPR_R32(GCE_BASE, CMDQ_GPR_R15);
s32 val, ans = 0xbeafbeaf;
spi_write_reg(pa, 0xdeaddead);
spi_write_reg(GCE_BASE + 0x68, test->token_user0);
val = spi_read_reg(pa);
cmdq_msg("%s: pa:%pa val:%#x", __func__, &pa, val);
msleep_interruptible(100);
#if IS_ENABLED(CONFIG_MTK_CMDQ_MBOX_EXT)
pkt = cmdq_pkt_create(test->clt);
cmdq_pkt_wfe(pkt, test->token_user0);
pkt2 = cmdq_pkt_create(test->clt2);
cmdq_pkt_set_event(pkt2, test->token_user0);
cmdq_pkt_write(pass ? pkt : pkt2, NULL, pa, 0x0, UINT_MAX);
cmdq_pkt_write(pass ? pkt2 : pkt, NULL, pa, ans, UINT_MAX);
cmdq_pkt_flush_threaded(
pkt, cmdq_bdg_test_mbox_threaded_cb, (void *)pkt);
msleep_interruptible(100);
cmdq_pkt_flush_threaded(
pkt2, cmdq_bdg_test_mbox_threaded_cb, (void *)pkt2);
#else
cmdqRecCreate(CMDQ_BDG_SCENARIO_DISP_TEST, &rec);
cmdqRecWait(rec, test->token_user0);
cmdq_msg("%s: rec1:%p pkt:%p scenario:%d thread:%d",
__func__, rec, rec->pkt, rec->scenario, rec->thread);
cmdqRecCreate(CMDQ_BDG_SCENARIO_DISP_TEST2, &rec2);
cmdqRecSetEventToken(rec2, test->token_user0);
cmdq_msg("%s: rec2:%p pkt:%p scenario:%d thread:%d",
__func__, rec2, rec2->pkt, rec2->scenario, rec2->thread);
cmdqRecWrite(pass ? rec : rec2, pa, 0x0, UINT_MAX);
cmdqRecWrite(pass ? rec2 : rec, pa, ans, UINT_MAX);
cmdqRecFlushAsyncCallback(rec, (void *)cmdq_bdg_test_rec_async_cb,
(unsigned long)(void *)rec);
msleep_interruptible(10);
cmdqRecFlushAsyncCallback(rec2, (void *)cmdq_bdg_test_rec_async_cb,
(unsigned long)(void *)rec2);
#endif
msleep_interruptible(100);
val = spi_read_reg(pa);
if (val != ans)
cmdq_err("pa:%pa val:%#x ans:%#x", &pa, val, ans);
else
cmdq_msg("%s: pa:%pa val:%#x ans:%#x", __func__, &pa, val, ans);
}
static ssize_t cmdq_bdg_test_write(struct file *filp, const char *buf,
size_t count, loff_t *offp)
{
struct cmdq_bdg_test *test =
(struct cmdq_bdg_test *)filp->f_inode->i_private;
char str[RTSIG_MAX] = {0};
s32 id, flag;
if (copy_from_user(str, buf, count)) {
cmdq_err("copy_from_user buf:%s count:%ld str:%s failed",
buf, count, str);
return count;
}
str[count] = '\0';
if (sscanf(str, "%d %d", &id, &flag) != 2) {
cmdq_err("sscanf id:%d flag:%d failed", id, flag);
return count;
}
#if IS_ENABLED(CONFIG_MTK_CMDQ_MBOX_EXT)
cmdq_msg("%s:mailbox test:%p id:%d flag:%d", __func__, test, id, flag);
#else
cmdq_msg("%s:record test:%p id:%d flag:%d", __func__, test, id, flag);
#endif
switch (id) {
case 1:
cmdq_bdg_test_mbox_write(test, 1, false, false);
break;
case 2:
cmdq_bdg_test_mbox_write(test, 1, true, false); // masked
break;
case 3:
cmdq_bdg_test_mbox_tasks(test, async, 1, false);
break;
case 4:
cmdq_bdg_test_mbox_tasks(test, threaded, 1, false);
break;
case 5:
cmdq_bdg_test_mbox_write(test, 127, false, false);
break;
case 6:
cmdq_bdg_test_mbox_tasks(test, async, 5, false);
break;
case 7:
cmdq_bdg_test_mbox_tasks(test, threaded, 5, false);
break;
case 8:
cmdq_bdg_test_mbox_tasks(test, async, 1, true); // error
break;
case 9:
cmdq_bdg_test_mbox_threads(test, true);
break;
case 10:
cmdq_bdg_test_mbox_threads(test, false);
break;
case 11:
cmdq_bdg_test_mbox_write(test, 2, false, true); // reuse
break;
}
return count;
}
static const struct file_operations cmdq_bdg_test_fops = {
.write = cmdq_bdg_test_write,
};
static int cmdq_bdg_test_probe(struct platform_device *pdev)
{
struct cmdq_bdg_test *test;
struct dentry *dir, *fs;
s32 ret;
test = devm_kzalloc(&pdev->dev, sizeof(*test), GFP_KERNEL);
if (!test)
return -ENOMEM;
test->dev = &pdev->dev;
test->clt = cmdq_mbox_create(&pdev->dev, 0);
if (IS_ERR(test->clt) || !test->clt)
return -ENXIO;
test->clt2 = cmdq_mbox_create(&pdev->dev, 1);
if (IS_ERR(test->clt2) || !test->clt2)
return -ENXIO;
ret = of_property_read_u16(
pdev->dev.of_node, "token_user0", &test->token_user0);
ret = of_property_read_u16(
pdev->dev.of_node, "token_gpr_set4", &test->token_gpr_set4);
cmdq_msg("%s: dev:%p clt:%p clt2:%p user0:%hu gpr:%hu",
__func__, test->dev, test->clt, test->clt2,
test->token_user0, test->token_gpr_set4);
dir = debugfs_lookup("cmdq", NULL);
if (!dir) {
dir = debugfs_create_dir("cmdq", NULL);
if (IS_ERR(dir) && PTR_ERR(dir) != -EEXIST)
return PTR_ERR(dir);
}
fs = debugfs_create_file(
"cmdq-bdg-test", 0444, dir, test, &cmdq_bdg_test_fops);
if (IS_ERR(fs))
return PTR_ERR(fs);
platform_set_drvdata(pdev, test);
cmdq_msg("%s: dir:%p fs:%p", __func__, dir, fs);
return 0;
}
static int cmdq_bdg_test_remove(struct platform_device *pdev)
{
return 0;
}
static const struct of_device_id cmdq_bdg_test_of_ids[] = {
{.compatible = "mediatek,cmdq-bdg-test",},
{}
};
static struct platform_driver cmdq_bdg_test_drv = {
.probe = cmdq_bdg_test_probe,
.remove = cmdq_bdg_test_remove,
.driver = {
.name = "cmdq-bdg-test",
.of_match_table = cmdq_bdg_test_of_ids,
},
};
module_platform_driver(cmdq_bdg_test_drv);
@@ -0,0 +1,25 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CMDQ_BDG_H__
#define __CMDQ_BDG_H__
struct cmdq_client;
struct cmdqRecStruct;
inline u32 spi_read_reg(const u32 addr);
inline s32 spi_write_reg(const u32 addr, const u32 val);
s32 cmdq_bdg_irq_handler(void);
/* shutdown loop */
void cmdq_bdg_client_shutdown(struct cmdq_client *cl);
void cmdq_bdg_client_get_irq(struct cmdq_client *cl, u32 *irq);
#if IS_ENABLED(CONFIG_MTK_CMDQ_V3)
void cmdq_bdg_dump_handle(struct cmdqRecStruct *rec, const char *tag);
#endif
#endif
@@ -0,0 +1,366 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#ifndef __CMDQ_DEF_H__
#define __CMDQ_DEF_H__
#include <linux/kernel.h>
#include "cmdq_v3_event_common.h"
#include "cmdq_v3_subsys_common.h"
#define CMDQ_DRIVER_DEVICE_NAME "mtk_cmdq"
#define CMDQ_DVENT_FROM_DTS
#include "cmdq_engine.h"
#define CMDQ_SPECIAL_SUBSYS_ADDR (99)
#define CMDQ_MAX_PROFILE_MARKER_IN_TASK (5)
#define CMDQ_MAX_SRAM_OWNER_NAME (32)
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,
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_DISP_VFP_CHANGE = 34,
CMDQ_SCENARIO_RDMA2_DISP = 35,
/* for primary trigger loop enable pre-fetch usage */
CMDQ_SCENARIO_HIGHP_TRIGGER_LOOP = 36,
/* for low priority monitor loop to polling bus status */
CMDQ_SCENARIO_LOWP_TRIGGER_LOOP = 37,
CMDQ_SCENARIO_KERNEL_CONFIG_GENERAL = 38,
CMDQ_SCENARIO_TIMER_LOOP = 39,
CMDQ_SCENARIO_MOVE = 40,
CMDQ_SCENARIO_SRAM_LOOP = 41,
/* debug scenario use mdp flush */
CMDQ_SCENARIO_DEBUG_MDP = 42,
CMDQ_MAX_SCENARIO_COUNT /* ALWAYS keep at the end */
};
/* General Purpose Register */
enum cmdq_gpr_reg {
/* 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 */
};
#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*.
*/
#define cmdqU32Ptr_t unsigned long long
#define CMDQ_U32_PTR(x) ((uint32_t *)(unsigned long)x)
struct cmdqReadRegStruct {
/* number of entries in regAddresses */
uint32_t count;
/* 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 u32 type.
*/
cmdqU32Ptr_t dmaAddresses;
/* [OUT] u32 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 */
CMDQ_SAM_NMVA_2_MVA = 2, /* map normal MVA to secure world */
CMDQ_SAM_PH_2_MVA = 3, /* protected handle to sec MVA */
};
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;
};
struct cmdqMetaBuf {
uint64_t va;
uint64_t size;
};
#define CMDQ_ISP_META_CNT 8
struct cmdqSecIspMeta {
struct cmdqMetaBuf ispBufs[CMDQ_ISP_META_CNT];
uint64_t CqSecHandle;
uint32_t CqSecSize;
uint32_t CqDesOft;
uint32_t CqVirtOft;
uint64_t TpipeSecHandle;
uint32_t TpipeSecSize;
uint32_t TpipeOft;
uint64_t BpciHandle;
uint64_t LsciHandle;
uint64_t LceiHandle;
uint64_t DepiHandle;
uint64_t DmgiHandle;
};
struct cmdqSecDataStruct {
bool isSecure; /* [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;
/* reset HW thread in SWd */
bool resetExecCnt;
/* ISP metadata for secure camera */
struct cmdqSecIspMeta ispMeta;
};
struct cmdq_v3_replace_struct {
/* [IN] count of element in instr_position */
uint32_t number;
/* [IN] position of instruction */
cmdqU32Ptr_t position;
};
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];
};
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] CPR position */
struct cmdq_v3_replace_struct replace_instr;
/* [IN] use SRAM buffer or not */
bool use_sram_buffer;
/* [IN] SRAM buffer owner name */
char sram_owner_name[CMDQ_MAX_SRAM_OWNER_NAME];
/* [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;
/* task property */
uint32_t prop_size;
cmdqU32Ptr_t prop_addr;
struct cmdqProfileMarkerStruct profileMarker;
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__ */
@@ -0,0 +1,102 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#ifndef __CMDQ_DRIVER_H__
#define __CMDQ_DRIVER_H__
#include <linux/kernel.h>
#include "cmdq_v3_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;
uint64_t engineFlag; /* [OUT] engine flag passed down originally */
/* [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 u32, 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 u32 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)
#endif /* __CMDQ_DRIVER_H__ */
@@ -0,0 +1,72 @@
# SPDX-License-Identifier: GPL-2.0
#
# Copyright (c) 2019 MediaTek Inc.
#
ifeq ($(CONFIG_MACH_MT6833),y)
CMDQ_PLATFORM := mt6833
else ifeq ($(CONFIG_MACH_MT6877),y)
CMDQ_PLATFORM := mt6877
else ifeq ($(CONFIG_MACH_MT6781),y)
CMDQ_PLATFORM := mt6781
else
CMDQ_PLATFORM := $(MTK_PLATFORM)
endif
ifeq ($(CONFIG_MACH_MT6833),y)
MDP_PLATFORM := "mt6833"
else ifeq ($(CONFIG_MACH_MT6781),y)
MDP_PLATFORM := mt6781
else
MDP_PLATFORM := $(CONFIG_MTK_PLATFORM)
endif
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mach/$(CMDQ_PLATFORM)/include \
-I$(srctree)/drivers/misc/mediatek/smi/ \
-I$(srctree)/drivers/misc/mediatek/mdp/$(MDP_PLATFORM) \
-I$(srctree)/drivers/misc/mediatek/mmp/
ifeq ($(or $(strip $(CONFIG_MTK_SVP_ON_MTEE_SUPPORT)), $(strip $(CONFIG_MTK_CAM_GENIEZONE_SUPPORT))),y)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat/$(MTK_PLATFORM)/include/trustzone/m4u
ccflags-y += -I$(srctree)/drivers/iommu
endif
ifeq ($(or $(strip $(CONFIG_MTK_SVP_ON_MTEE_SUPPORT)), $(strip $(CONFIG_MTK_CAM_GENIEZONE_SUPPORT))),y)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat/$(MTK_PLATFORM)/include/trustzone/m4u
ccflags-y += -I$(srctree)/drivers/iommu
endif
ifeq ($(or $(strip $(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT)), $(strip $(CONFIG_MTK_CAM_SECURITY_SUPPORT))),y)
ifeq ($(CONFIG_MICROTRUST_TEE_SUPPORT),y)
include $(srctree)/drivers/tee/teei/Makefile.include
endif
ifeq ($(CONFIG_TRUSTONIC_TEE_SUPPORT),y)
include $(srctree)/drivers/tee/gud/Makefile.include
endif
ifeq ($(strip $(CONFIG_MTK_ENABLE_GENIEZONE)),y)
ifeq ($(strip $(CONFIG_MTK_CAM_GENIEZONE_SUPPORT)),y)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/geniezone/public
ccflags-y += -DCMDQ_SECURE_MTEE_SUPPORT
obj-y += cmdq_sec_mtee.o
endif
endif
ifeq ($(strip $(CONFIG_MTK_SVP_ON_MTEE_SUPPORT)),y)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/geniezone/public
ccflags-y += -DCMDQ_SECURE_MTEE_SUPPORT
obj-y += cmdq_sec_mtee.o
endif
ccflags-y += -DCMDQ_SECURE_SUPPORT
obj-y += cmdq-sec-helper.o
obj-y += cmdq-sec-mailbox.o
endif # $(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT) or $(CONFIG_MTK_CAM_SECURITY_SUPPORT)
obj-y += cmdq-test.o
obj-y += cmdq-util.o
obj-y += $(CMDQ_PLATFORM)/cmdq-platform.o
obj-y += cmdq-bw-mon.o
@@ -0,0 +1,391 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2020 MediaTek Inc.
*/
#include <linux/moduleparam.h>
#include <linux/platform_device.h>
#include <linux/of_platform.h>
#include <linux/of_address.h>
#include <linux/module.h>
#include "cmdq-util.h"
#ifdef CONFIG_MTK_SMI_EXT
#include "smi_public.h"
#endif
struct bw_monitor {
struct device *dev;
struct cmdq_client *clt;
struct cmdq_pkt *pkt;
struct {
phys_addr_t base;
} smi[2];
u8 smi_cnt;
u8 timer_gpr;
u32 *result;
dma_addr_t result_pa;
bool enable;
};
static struct bw_monitor bw_mon;
static u32 bw_interval = 16000;
module_param(bw_interval, int, 0644);
static u32 bw_log;
module_param(bw_log, int, 0644);
enum mon_enable_command {
MON_DISABLE_STOP = 0,
MON_ENABLE_START = 1,
};
/* following def and func are platform dependent */
#define SMI_MON_AXI_ENA_MON0 0x1a0
#define SMI_MON_AXI_CLR_MON0 0x1a4
#define SMI_MON_AXI_TYPE_MON0 0x1ac
#define SMI_MON_AXI_CON_MON0 0x1b0
/* following are byte count for #1 #2 #3 #0 */
#define SMI_MON_AXI_ACT_CNT_MON0 0x1c0
#define SMI_MON_AXI_REQ_CNT_MON0 0x1c4
#define SMI_MON_AXI_BEA_CNT_MON0 0x1cc
#define SMI_MON_AXI_BYT_CNT_MON0 0x1d0
#define SMI_MON_EN 0x3
#define SMI_MON_CLR 0x1
#define SMI_MON_AXI_TYPE 0xa
#define SMI_MON_AXI_CON_0 0x55440
#define SMI_MON_AXI_CON_1 0x55440
#if IS_ENABLED(CMDQ_BWMON_SUPPORT)
static int cmdq_bwmon_enable_monitor(struct cmdq_pkt *pkt, u8 id)
{
phys_addr_t base = bw_mon.smi[id].base;
#if IS_ENABLED(CONFIG_MACH_MT6885) || IS_ENABLED(CONFIG_MACH_MT6893)
if (id == 0) {
cmdq_pkt_write_value_addr(pkt, base + SMI_MON_AXI_CLR_MON0,
SMI_MON_CLR, U32_MAX);
cmdq_pkt_write_value_addr(pkt, base + SMI_MON_AXI_TYPE_MON0,
SMI_MON_AXI_TYPE, U32_MAX);
cmdq_pkt_write_value_addr(pkt, base + SMI_MON_AXI_CON_MON0,
SMI_MON_AXI_CON_0, U32_MAX);
cmdq_pkt_write_value_addr(pkt, base + SMI_MON_AXI_ENA_MON0,
SMI_MON_EN, U32_MAX);
return 0;
} else if (id == 1) {
cmdq_pkt_write_value_addr(pkt, base + SMI_MON_AXI_CLR_MON0,
SMI_MON_CLR, U32_MAX);
cmdq_pkt_write_value_addr(pkt, base + SMI_MON_AXI_TYPE_MON0,
SMI_MON_AXI_TYPE, U32_MAX);
cmdq_pkt_write_value_addr(pkt, base + SMI_MON_AXI_CON_MON0,
SMI_MON_AXI_CON_1, U32_MAX);
cmdq_pkt_write_value_addr(pkt, base + SMI_MON_AXI_ENA_MON0,
SMI_MON_EN, U32_MAX);
return 0;
}
#else
cmdq_msg("[bwmon] not support for base:%lx", (unsigned long)base);
#endif
return -EINVAL;
}
static void cmdq_bwmon_read(struct cmdq_pkt *pkt, u8 id, dma_addr_t pa)
{
phys_addr_t base = bw_mon.smi[id].base;
const u8 reg_bw = CMDQ_THR_SPR_IDX3;
cmdq_pkt_write_value_addr(pkt, base + SMI_MON_AXI_ENA_MON0,
0, U32_MAX);
cmdq_pkt_mem_move(pkt, NULL, base + SMI_MON_AXI_BYT_CNT_MON0,
pa, reg_bw);
cmdq_pkt_mem_move(pkt, NULL, base + SMI_MON_AXI_ACT_CNT_MON0,
pa + 4, reg_bw);
cmdq_pkt_mem_move(pkt, NULL, base + SMI_MON_AXI_REQ_CNT_MON0,
pa + 8, reg_bw);
cmdq_pkt_mem_move(pkt, NULL, base + SMI_MON_AXI_BEA_CNT_MON0,
pa + 12, reg_bw);
}
static void cmdq_bwmon_clk_enable(void)
{
#if IS_ENABLED(CONFIG_MACH_MT6885) || IS_ENABLED(CONFIG_MACH_MT6893)
smi_bus_prepare_enable(SMI_LARB4, "BWMon");
smi_bus_prepare_enable(SMI_LARB5, "BWMon");
smi_bus_prepare_enable(SMI_LARB7, "BWMon");
smi_bus_prepare_enable(SMI_LARB8, "BWMon");
#else
cmdq_err("[bwmon] not support");
#endif
}
static void cmdq_bwmon_clk_disable(void)
{
#if IS_ENABLED(CONFIG_MACH_MT6885) || IS_ENABLED(CONFIG_MACH_MT6893)
smi_bus_disable_unprepare(SMI_LARB4, "BWMon");
smi_bus_disable_unprepare(SMI_LARB5, "BWMon");
smi_bus_disable_unprepare(SMI_LARB7, "BWMon");
smi_bus_disable_unprepare(SMI_LARB8, "BWMon");
#else
cmdq_err("[bwmon] not support");
#endif
}
static void cmdq_bwmon_print(u64 total, int err)
{
#if IS_ENABLED(CONFIG_MACH_MT6885) || IS_ENABLED(CONFIG_MACH_MT6893)
u32 *buf = bw_mon.result;
if (bw_log)
cmdq_msg(
"[bwmon] larb5 r:%u w:%u larb7 r:%u w:%u larb4 r:%u w:%u larb8 r:%u w:%u total bw:%llu status:%d",
*buf, *(buf + 1), *(buf + 2), *(buf + 3),
*(buf + 4), *(buf + 5), *(buf + 6), *(buf + 7),
total, err);
cmdq_trace_c("0|SMI_Codec_Bandwidth|%llu\n", total);
#else
cmdq_msg("[bwmon] status:%d bwlog:%d", err, bw_log);
#endif
}
/* following funcs are common code */
static struct cmdq_pkt *cmdq_bwmon_build_pkt(void)
{
const u8 reg_bw = CMDQ_THR_SPR_IDX3;
struct cmdq_pkt *pkt = bw_mon.pkt;
u8 i;
u32 loop_anchor;
int ret;
/* reuse exist one */
if (pkt)
return pkt;
if (!bw_mon.result) {
bw_mon.result = (u32 *)cmdq_mbox_buf_alloc(bw_mon.dev,
&bw_mon.result_pa);
if (!bw_mon.result)
return ERR_PTR(-ENOMEM);
}
pkt = cmdq_pkt_create(bw_mon.clt);
if (!pkt || IS_ERR(pkt)) {
cmdq_err("[bwmon] pkt create fail");
return pkt;
}
bw_mon.pkt = pkt;
/* write smi regs to enable bw monitor */
cmdq_pkt_assign_command(pkt, reg_bw, 0);
for (i = 0; i < bw_mon.smi_cnt; i++) {
ret = cmdq_bwmon_enable_monitor(pkt, i);
if (ret < 0)
return ERR_PTR(ret);
}
loop_anchor = pkt->cmd_buf_size;
cmdq_pkt_sleep(pkt, CMDQ_US_TO_TICK(bw_interval), bw_mon.timer_gpr);
/* read smi register back to result buffer and clear */
for (i = 0; i < bw_mon.smi_cnt; i++)
cmdq_bwmon_read(pkt, i, bw_mon.result_pa + i * 4 * 4);
cmdq_pkt_finalize_loop(pkt);
return pkt;
}
static void cmdq_bwmon_cb(struct cmdq_cb_data data)
{
u8 idx_smi, idx_larb;
u64 total = 0;
u32 *buf = bw_mon.result;
static u64 last_bw;
for (idx_smi = 0; idx_smi < bw_mon.smi_cnt; idx_smi++)
for (idx_larb = 0; idx_larb < 4; idx_larb++) {
total += *buf;
buf++;
}
if (last_bw != total) {
cmdq_bwmon_print(total, data.err);
last_bw = total;
}
}
static int cmdq_bwmon_start(void)
{
struct cmdq_pkt *pkt;
u8 idx_smi, idx_larb;
u32 *buf;
if (!bw_mon.clt) {
cmdq_err("[bwmon] no client to start");
return -EINVAL;
}
pkt = cmdq_bwmon_build_pkt();
if (!pkt || IS_ERR(pkt))
return PTR_ERR(pkt);
buf = bw_mon.result;
for (idx_smi = 0; idx_smi < bw_mon.smi_cnt; idx_smi++)
for (idx_larb = 0; idx_larb < 4; idx_larb++) {
*buf = 0;
buf++;
}
cmdq_bwmon_clk_enable();
cmdq_pkt_flush_async(pkt, cmdq_bwmon_cb, 0);
bw_mon.enable = true;
return 0;
}
static int cmdq_bwmon_stop(void)
{
bw_mon.enable = false;
if (!bw_mon.enable) {
cmdq_msg("[bwmon] monitor not enable");
return 0;
}
if (!bw_mon.pkt || !bw_mon.clt) {
cmdq_err("[bwmon] monitor enable but empty pkt/client %p/%p",
bw_mon.pkt, bw_mon.clt);
return 0;
}
/* stop loop in thread */
cmdq_mbox_stop(bw_mon.clt);
/* still wait to make sure it is done */
cmdq_pkt_wait_complete(bw_mon.pkt);
cmdq_bwmon_clk_disable();
return 0;
}
#endif
static int cmdq_bwmon_set(const char *val, const struct kernel_param *kp)
{
#if IS_ENABLED(CMDQ_BWMON_SUPPORT)
int result, enable;
cmdq_msg("%s [bwmon] in", __func__);
result = kstrtoint(val, 0, &enable);
if (result) {
cmdq_err("[bwmon] monitor enable failed:%d", result);
return result;
}
if (enable == MON_ENABLE_START) {
result = cmdq_bwmon_start();
if (result)
bw_mon.enable = false;
return result;
}
return cmdq_bwmon_stop();
#else
cmdq_msg("%s [bwmon] not support", __func__);
return 0;
#endif
}
static struct kernel_param_ops bw_monitor_ops = {.set = cmdq_bwmon_set};
module_param_cb(bw_monitor, &bw_monitor_ops, NULL, 0644);
static int cmdq_bwmon_parse_larb(struct platform_device *pdev, u8 idx)
{
struct device_node *node;
struct platform_device *node_pdev;
struct resource res;
int ret;
node = of_parse_phandle(pdev->dev.of_node, "smi_mon", idx);
if (!node) {
cmdq_msg("[bwmon] of_parse_phandle smi_mon stop at idx:%hhu",
idx);
return -EINVAL;
}
node_pdev = of_find_device_by_node(node);
of_node_put(node);
if (!node_pdev) {
cmdq_err("[bwmon] of_find_device_by_node to smi_mon failed");
return -EINVAL;
}
ret = of_address_to_resource(node_pdev->dev.of_node, 0, &res);
if (ret) {
cmdq_err(
"[bwmon] of_address_to_resource to mmsys_config failed ret:%d",
ret);
return ret;
}
bw_mon.smi[idx].base = res.start;
cmdq_msg("[bwmon] smi%hhu:%#lx",
idx, (unsigned long)bw_mon.smi[idx].base);
return 0;
}
static int cmdq_bwmon_probe(struct platform_device *pdev)
{
u8 i;
cmdq_msg("%s", __func__);
bw_mon.dev = &pdev->dev;
bw_mon.clt = cmdq_mbox_create(&pdev->dev, 0);
if (!bw_mon.clt || IS_ERR(bw_mon.clt)) {
cmdq_msg("[bwmon] create bw mon client fail:%ld",
PTR_ERR(bw_mon.clt));
bw_mon.clt = NULL;
}
for (i = 0; i < ARRAY_SIZE(bw_mon.smi); i++)
if (cmdq_bwmon_parse_larb(pdev, i))
break;
bw_mon.smi_cnt = i;
of_property_read_u8(pdev->dev.of_node, "bw_mon_gpr",
&bw_mon.timer_gpr);
cmdq_msg("%s end", __func__);
return 0;
}
static int cmdq_bwmon_remove(struct platform_device *pdev)
{
cmdq_mbox_destroy(bw_mon.clt);
cmdq_mbox_buf_free(bw_mon.dev, bw_mon.result, bw_mon.result_pa);
return 0;
}
static const struct of_device_id cmdq_bwmon_of_ids[] = {
{
.compatible = "mediatek,cmdq-bw-mon",
},
{}
};
MODULE_DEVICE_TABLE(of, cmdq_bwmon_of_ids);
static struct platform_driver cmdq_bwmon_drv = {
.probe = cmdq_bwmon_probe,
.remove = cmdq_bwmon_remove,
.driver = {
.name = "cmdq-bw-mon",
.of_match_table = cmdq_bwmon_of_ids,
},
};
module_platform_driver(cmdq_bwmon_drv);
@@ -0,0 +1,193 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/soc/mediatek/mtk-cmdq.h>
#include <linux/math64.h>
#include <linux/sched/clock.h>
#include "cmdq-sec-gp.h"
#define UUID_STR "09010000000000000000000000000000"
void cmdq_sec_setup_tee_context(struct cmdq_sec_tee_context *tee)
{
/* 09010000 0000 0000 0000000000000000 */
tee->uuid = (struct TEEC_UUID) { 0x09010000, 0x0, 0x0,
{ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } };
}
#include <linux/atomic.h>
static atomic_t m4u_init = ATOMIC_INIT(0);
s32 cmdq_sec_init_context(struct cmdq_sec_tee_context *tee)
{
s32 status;
cmdq_msg("[SEC]%s", __func__);
#if defined(CONFIG_MICROTRUST_TEE_SUPPORT)
while (!is_teei_ready()) {
cmdq_msg("[SEC]Microtrust TEE is not ready, wait...");
msleep(1000);
}
#else
while (!is_mobicore_ready()) {
cmdq_msg("[SEC]Trustonic TEE is not ready, wait...");
msleep(1000);
}
#endif
cmdq_log("[SEC]TEE is ready");
/* do m4u sec init */
if (atomic_cmpxchg(&m4u_init, 0, 1) == 0) {
m4u_sec_init();
cmdq_msg("[SEC] M4U_sec_init is called\n");
}
status = TEEC_InitializeContext(NULL, &tee->gp_context);
if (status != TEEC_SUCCESS)
cmdq_err("[SEC]init_context fail: status:0x%x", status);
else
cmdq_msg("[SEC]init_context: status:0x%x", status);
return status;
}
s32 cmdq_sec_deinit_context(struct cmdq_sec_tee_context *tee)
{
TEEC_FinalizeContext(&tee->gp_context);
return 0;
}
s32 cmdq_sec_allocate_wsm(struct cmdq_sec_tee_context *tee,
void **wsm_buffer, u8 idx, u32 size)
{
s32 status;
struct TEEC_SharedMemory *mem = &tee->shared_mem[idx];
if (!wsm_buffer)
return -EINVAL;
cmdq_msg("%s tee:0x%p size:%u idx:%hhu",
__func__, tee, size, idx);
mem->size = size;
mem->flags = TEEC_MEM_INPUT | TEEC_MEM_OUTPUT;
status = TEEC_AllocateSharedMemory(&tee->gp_context, mem);
if (status != TEEC_SUCCESS) {
cmdq_err("[SEC][WARN]allocate_wsm: err:%#x size:%u idx:%hhu",
status, size, idx);
} else {
cmdq_log(
"[SEC]allocate_wsm: status:%#x wsm:0x%p size:%u idx:%hhu",
status, mem->buffer, size, idx);
*wsm_buffer = mem->buffer;
}
return status;
}
s32 cmdq_sec_free_wsm(struct cmdq_sec_tee_context *tee,
void **wsm_buffer, u8 idx)
{
if (!wsm_buffer)
return -EINVAL;
TEEC_ReleaseSharedMemory(&tee->shared_mem[idx]);
*wsm_buffer = NULL;
return 0;
}
s32 cmdq_sec_open_session(struct cmdq_sec_tee_context *tee,
void *wsm_buffer)
{
s32 status, ret_origin = 0;
if (!wsm_buffer) {
cmdq_err("[SEC]open_session: invalid param wsm buffer:0x%p",
wsm_buffer);
return -EINVAL;
}
status = TEEC_OpenSession(&tee->gp_context,
&tee->session, &tee->uuid,
TEEC_LOGIN_PUBLIC, NULL, NULL, &ret_origin);
if (status != TEEC_SUCCESS) {
/* print error message */
cmdq_err(
"[SEC]open_session fail: status:0x%x ret origin:0x%08x",
status, ret_origin);
} else {
cmdq_msg("[SEC]open_session: status:0x%x", status);
}
return status;
}
s32 cmdq_sec_close_session(struct cmdq_sec_tee_context *tee)
{
TEEC_CloseSession(&tee->session);
return 0;
}
s32 cmdq_sec_execute_session(struct cmdq_sec_tee_context *tee,
u32 cmd, s32 timeout_ms, bool mem_ex1, bool mem_ex2)
{
s32 status;
struct TEEC_Operation operation;
u64 ts = sched_clock();
memset(&operation, 0, sizeof(struct TEEC_Operation));
#if defined(CONFIG_TRUSTONIC_TEE_SUPPORT)
operation.param_types = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INOUT,
mem_ex1 ? TEEC_MEMREF_PARTIAL_INOUT : TEEC_NONE,
mem_ex2 ? TEEC_MEMREF_PARTIAL_INOUT : TEEC_NONE,
TEEC_NONE);
#else
operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INOUT,
mem_ex1 ? TEEC_MEMREF_PARTIAL_INOUT : TEEC_NONE,
mem_ex2 ? TEEC_MEMREF_PARTIAL_INOUT : TEEC_NONE,
TEEC_NONE);
#endif
operation.params[0].memref.parent = &tee->shared_mem[0];
operation.params[0].memref.size = tee->shared_mem[0].size;
operation.params[0].memref.offset = 0;
if (mem_ex1) {
operation.params[1].memref.parent = &tee->shared_mem[1];
operation.params[1].memref.size = tee->shared_mem[1].size;
operation.params[1].memref.offset = 0;
}
if (mem_ex2) {
operation.params[2].memref.parent = &tee->shared_mem[2];
operation.params[2].memref.size = tee->shared_mem[2].size;
operation.params[2].memref.offset = 0;
}
status = TEEC_InvokeCommand(&tee->session, cmd, &operation,
NULL);
ts = div_u64(sched_clock() - ts, 1000000);
if (status != TEEC_SUCCESS)
cmdq_err(
"[SEC]execute: TEEC_InvokeCommand:%u err:%d memex:%s memex2:%s cost:%lldus",
cmd, status, mem_ex1 ? "true" : "false",
mem_ex2 ? "true" : "false",
ts);
else if (ts > 15000)
cmdq_msg(
"[SEC]execute: TEEC_InvokeCommand:%u ret:%d memex1:%s memex2:%s cost:%lldus",
cmd, status, mem_ex1 ? "true" : "false",
mem_ex2 ? "true" : "false",
ts);
else
cmdq_log(
"[SEC]execute: TEEC_InvokeCommand:%u ret:%d memex1:%s memex2:%s cost:%lldus",
cmd, status, mem_ex1 ? "true" : "false",
mem_ex2 ? "true" : "false",
ts);
return status;
}
@@ -0,0 +1,39 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CMDQ_SEC_GP_H__
#define __CMDQ_SEC_GP_H__
#include <linux/types.h>
#include <linux/delay.h>
#include "tee_client_api.h"
#if defined(CONFIG_MICROTRUST_TEE_SUPPORT)
#include "teei_client_main.h"
#endif
#if defined(CONFIG_TRUSTONIC_TEE_SUPPORT)
#include "mobicore_driver_api.h"
#endif
/* context for tee vendor */
struct cmdq_sec_tee_context {
/* Universally Unique Identifier of secure tl/dr */
struct TEEC_UUID uuid;
struct TEEC_Context gp_context; /* basic context */
struct TEEC_Session session; /* session handle */
struct TEEC_SharedMemory shared_mem[4]; /* shared memory */
};
void cmdq_sec_setup_tee_context(struct cmdq_sec_tee_context *tee);
s32 cmdq_sec_init_context(struct cmdq_sec_tee_context *tee);
s32 cmdq_sec_allocate_wsm(struct cmdq_sec_tee_context *tee,
void **wsm_buffer, u8 idx, u32 size);
s32 cmdq_sec_open_session(struct cmdq_sec_tee_context *tee, void *wsm_buffer);
s32 cmdq_sec_execute_session(struct cmdq_sec_tee_context *tee,
u32 cmd, s32 timeout_ms, bool mem_ex1, bool mem_ex2);
int m4u_sec_init(void);
#endif /* __CMDQ_SEC_GP_H__ */
@@ -0,0 +1,352 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/soc/mediatek/mtk-cmdq.h>
#include "cmdq-util.h"
#include "cmdq-sec.h"
#include "cmdq-sec-mailbox.h"
#define ADDR_METADATA_MAX_COUNT_ORIGIN (8)
#define CMDQ_IMMEDIATE_VALUE (0)
#define CMDQ_REG_TYPE (1)
#define CMDQ_PREDUMP_TIMEOUT_MS 200
static s32 cmdq_sec_realloc_addr_list(struct cmdq_pkt *pkt, const u32 count)
{
struct cmdq_sec_data *sec_data =
(struct cmdq_sec_data *)pkt->sec_data;
void *prev = (void *)(unsigned long)sec_data->addrMetadatas, *curr;
if (count <= sec_data->addrMetadataMaxCount)
return 0;
curr = kcalloc(count, sizeof(*sec_data), GFP_KERNEL);
if (!curr)
return -ENOMEM;
if (count && sec_data->addrMetadatas)
memcpy(curr, prev,
sizeof(*sec_data) * sec_data->addrMetadataMaxCount);
kfree(prev);
sec_data->addrMetadatas = (u64)curr;
sec_data->addrMetadataMaxCount = count;
return 0;
}
static s32 cmdq_sec_check_sec(struct cmdq_pkt *pkt)
{
struct cmdq_sec_data *sec_data;
if (pkt->sec_data)
return 0;
sec_data = kzalloc(sizeof(*sec_data), GFP_KERNEL);
if (!sec_data)
return -ENOMEM;
pkt->sec_data = (void *)sec_data;
return 0;
}
static s32 cmdq_sec_append_metadata(
struct cmdq_pkt *pkt, const enum CMDQ_IWC_ADDR_METADATA_TYPE type,
const u64 base, const u32 offset, const u32 size, const u32 port, uint32_t sec_id)
{
struct cmdq_sec_data *sec_data;
struct cmdq_sec_addr_meta *meta;
s32 idx, max, ret;
cmdq_log("pkt:%p type:%u base:%#llx offset:%#x size:%#x port:%#x sec_id:%d",
pkt, type, base, offset, size, port, sec_id);
cmdq_msg("%s pkt:%p type:%u base:%#llx offset:%#x size:%#x port:%#x sec_id:%d",
__func__, pkt, type, base, offset, size, port, sec_id);
ret = cmdq_sec_check_sec(pkt);
if (ret < 0)
return ret;
sec_data = (struct cmdq_sec_data *)pkt->sec_data;
idx = sec_data->addrMetadataCount;
if (idx >= CMDQ_IWC_MAX_ADDR_LIST_LENGTH) {
cmdq_err("idx:%u reach over:%u",
idx, CMDQ_IWC_MAX_ADDR_LIST_LENGTH);
return -EFAULT;
}
if (!sec_data->addrMetadataMaxCount)
max = ADDR_METADATA_MAX_COUNT_ORIGIN;
else if (idx >= sec_data->addrMetadataMaxCount)
max = sec_data->addrMetadataMaxCount * 2;
else
max = sec_data->addrMetadataMaxCount;
ret = cmdq_sec_realloc_addr_list(pkt, max);
if (ret)
return ret;
if (!sec_data->addrMetadatas) {
cmdq_log("addrMetadatas is missing");
meta = kzalloc(sizeof(*meta), GFP_KERNEL);
if (!meta)
return -ENOMEM;
sec_data->addrMetadatas = (u64)(void *)meta;
}
meta = (struct cmdq_sec_addr_meta *)
(unsigned long)sec_data->addrMetadatas;
meta[idx].instrIndex = pkt->cmd_buf_size / CMDQ_INST_SIZE - 1;
meta[idx].type = type;
meta[idx].baseHandle = base;
meta[idx].offset = offset;
meta[idx].size = size;
meta[idx].port = port;
meta[idx].useSecIdinMeta = 1;
meta[idx].sec_id = sec_id;
sec_data->addrMetadataCount += 1;
return 0;
}
s32 cmdq_sec_pkt_set_data(struct cmdq_pkt *pkt, const u64 dapc_engine,
const u64 port_sec_engine, const enum CMDQ_SEC_SCENARIO scenario,
const enum cmdq_sec_meta_type meta_type)
{
struct cmdq_sec_data *sec_data;
s32 ret;
if (!pkt) {
cmdq_err("invalid pkt:%p", pkt);
return -EINVAL;
}
ret = cmdq_sec_check_sec(pkt);
if (ret < 0)
return ret;
cmdq_log(
"pkt:%p sec_data:%p dapc:%llu port_sec:%llu scen:%u",
pkt, pkt->sec_data, dapc_engine, port_sec_engine, scenario);
sec_data = (struct cmdq_sec_data *)pkt->sec_data;
sec_data->enginesNeedDAPC |= dapc_engine;
sec_data->enginesNeedPortSecurity |= port_sec_engine;
sec_data->scenario = scenario;
sec_data->client_meta_type = meta_type;
return 0;
}
EXPORT_SYMBOL(cmdq_sec_pkt_set_data);
void cmdq_sec_pkt_set_mtee(struct cmdq_pkt *pkt, const bool enable, const int32_t sec_id)
{
struct cmdq_sec_data *sec_data =
(struct cmdq_sec_data *)pkt->sec_data;
sec_data->mtee = enable;
sec_data->sec_id = sec_id;
cmdq_msg("%s pkt:%p mtee:%d sec_id:%d\n",
__func__, pkt, ((struct cmdq_sec_data *)pkt->sec_data)->mtee,
((struct cmdq_sec_data *)pkt->sec_data)->sec_id);
}
EXPORT_SYMBOL(cmdq_sec_pkt_set_mtee);
void cmdq_sec_pkt_free_data(struct cmdq_pkt *pkt)
{
if (pkt->sec_data == NULL)
return;
kfree((void *)((struct cmdq_sec_data *)pkt->sec_data)->addrMetadatas);
kfree(pkt->sec_data);
}
EXPORT_SYMBOL(cmdq_sec_pkt_free_data);
s32 cmdq_sec_pkt_set_payload(struct cmdq_pkt *pkt, u8 idx,
const u32 meta_size, u32 *meta)
{
struct cmdq_sec_data *sec_data;
s32 ret;
if (idx == 0) {
cmdq_err("not allow set reserved payload 0");
return -EINVAL;
}
if (!meta_size || !meta) {
cmdq_err("not allow empty size or buffer");
return -EINVAL;
}
ret = cmdq_sec_check_sec(pkt);
if (ret < 0)
return ret;
if (idx == CMDQ_IWC_MSG1 &&
meta_size >= sizeof(struct iwcCmdqMessageEx_t)) {
cmdq_err("not enough size payload 1:%u msg size:%zu",
meta_size, sizeof(struct iwcCmdqMessageEx_t));
return -EINVAL;
}
if (idx == CMDQ_IWC_MSG2 &&
meta_size >= sizeof(struct iwcCmdqMessageEx2_t)) {
cmdq_err("not enough size payload 2:%u msg size:%zu",
meta_size, sizeof(struct iwcCmdqMessageEx2_t));
return -EINVAL;
}
sec_data = (struct cmdq_sec_data *)pkt->sec_data;
sec_data->client_meta_size[idx] = meta_size;
sec_data->client_meta[idx] = meta;
return 0;
}
EXPORT_SYMBOL(cmdq_sec_pkt_set_payload);
s32 cmdq_sec_pkt_write_reg(struct cmdq_pkt *pkt, u32 addr, u64 base,
const enum CMDQ_IWC_ADDR_METADATA_TYPE type,
const u32 offset, const u32 size, const u32 port, uint32_t sec_id)
{
s32 ret;
ret = cmdq_pkt_assign_command(pkt, CMDQ_SPR_FOR_TEMP, addr);
if (ret)
return ret;
ret = cmdq_pkt_append_command(pkt,
base & 0xffff, base >> 16, CMDQ_SPR_FOR_TEMP, 0,
CMDQ_IMMEDIATE_VALUE, CMDQ_IMMEDIATE_VALUE, CMDQ_REG_TYPE,
CMDQ_CODE_WRITE_S);
if (ret)
return ret;
/* check boundary size and append at first before append metadata */
if (unlikely(!pkt->avail_buf_size)) {
if (cmdq_pkt_add_cmd_buffer(pkt) < 0)
return -ENOMEM;
}
return cmdq_sec_append_metadata(pkt, type, base, offset, size, port, sec_id);
}
EXPORT_SYMBOL(cmdq_sec_pkt_write_reg);
s32 cmdq_sec_pkt_assign_metadata(struct cmdq_pkt *pkt,
u32 count, void *meta_array)
{
struct cmdq_sec_data *data;
void *pkt_meta_array;
size_t size;
s32 ret;
if (!count)
return -EINVAL;
ret = cmdq_sec_check_sec(pkt);
if (ret < 0)
return ret;
data = (struct cmdq_sec_data *)pkt->sec_data;
size = count * sizeof(struct cmdq_sec_addr_meta);
pkt_meta_array = kzalloc(size, GFP_KERNEL);
if (!pkt_meta_array)
return -ENOMEM;
memcpy(pkt_meta_array, meta_array, size);
data->addrMetadatas = (unsigned long)pkt_meta_array;
data->addrMetadataCount = count;
return 0;
}
EXPORT_SYMBOL(cmdq_sec_pkt_assign_metadata);
void cmdq_sec_dump_secure_data(struct cmdq_pkt *pkt)
{
struct cmdq_sec_data *data;
struct cmdq_sec_addr_meta *meta;
s32 i;
u64 *inst;
if (!pkt || !pkt->sec_data) {
cmdq_msg("pkt without sec_data");
return;
}
data = (struct cmdq_sec_data *)pkt->sec_data;
cmdq_util_msg(
"meta cnt:%u addr:%#llx max:%u scen:%d dapc:%#llx port:%#llx wait:%d reset:%d metatype:%u",
data->addrMetadataCount, data->addrMetadatas,
data->addrMetadataMaxCount, data->scenario,
data->enginesNeedDAPC, data->enginesNeedPortSecurity,
data->waitCookie, data->resetExecCnt,
(u32)data->client_meta_type);
meta = (struct cmdq_sec_addr_meta *)(unsigned long)
data->addrMetadatas;
for (i = 0; i < data->addrMetadataCount; i++) {
inst = cmdq_pkt_get_va_by_offset(pkt,
meta[i].instrIndex * CMDQ_INST_SIZE);
cmdq_util_msg(
"meta:%d instr:%u type:%u base:%#llx block:%u ofst:%u size:%u port:%u inst:%#018llx",
i, meta[i].instrIndex, meta[i].type,
meta[i].baseHandle, meta[i].blockOffset, meta[i].offset,
meta[i].size, meta[i].port,
inst ? *inst : 0);
}
}
EXPORT_SYMBOL(cmdq_sec_dump_secure_data);
int cmdq_sec_pkt_wait_complete(struct cmdq_pkt *pkt)
{
struct cmdq_client *client = pkt->cl;
unsigned long ret;
u8 cnt = 0;
s32 thread_id = cmdq_sec_mbox_chan_id(client->chan);
#if IS_ENABLED(CONFIG_MMPROFILE)
cmdq_sec_mmp_wait(client->chan, pkt);
#endif
cmdq_sec_mbox_enable(client->chan);
do {
ret = wait_for_completion_timeout(&pkt->cmplt,
msecs_to_jiffies(CMDQ_PREDUMP_TIMEOUT_MS));
if (ret)
break;
cmdq_util_dump_lock();
cmdq_msg("===== SW timeout Pre-dump %hhu =====", cnt);
cnt++;
cmdq_dump_core(client->chan);
cmdq_msg("thd:%d Hidden thread info since it's secure",
thread_id);
cmdq_sec_dump_operation(client->chan);
cmdq_sec_dump_secure_thread_cookie(client->chan);
cmdq_dump_pkt(pkt, 0, false);
cmdq_sec_dump_notify_loop(client->chan);
cmdq_util_dump_unlock();
} while (1);
cmdq_sec_mbox_disable(client->chan);
#if IS_ENABLED(CONFIG_MMPROFILE)
cmdq_sec_mmp_wait_done(client->chan, pkt);
#endif
return 0;
}
EXPORT_SYMBOL(cmdq_sec_pkt_wait_complete);
void cmdq_sec_err_dump(struct cmdq_pkt *pkt, struct cmdq_client *client,
u64 **inst, const char **dispatch)
{
cmdq_sec_dump_operation(client->chan);
cmdq_sec_dump_secure_thread_cookie(client->chan);
cmdq_sec_dump_notify_loop(client->chan);
cmdq_sec_dump_secure_data(pkt);
cmdq_sec_dump_response(client->chan, pkt, inst, dispatch);
}
EXPORT_SYMBOL(cmdq_sec_err_dump);
@@ -0,0 +1,407 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 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 0
#define CMDQ_SEC_SHARED_THR_CNT_OFFSET 0x100
#define CMDQ_SEC_SHARED_TASK_VA_OFFSET 0x200
#define CMDQ_SEC_SHARED_OP_OFFSET 0x300
#define CMDQ_SEC_SHARED_SUSPEND_CNT 0x304
#define CMDQ_SEC_SHARED_RESET_CNT 0x308
/* commanad buffer & metadata */
#define CMDQ_IWC_MAX_CMD_LENGTH (5 << 12)
#define CMDQ_IWC_MAX_ADDR_LIST_LENGTH (30)
#define CMDQ_IWC_CLIENT_NAME (16)
#define CMDQ_SEC_MESSAGE_INST_LEN (8)
#define CMDQ_SEC_DISPATCH_LEN (8)
#define CMDQ_SEC_ISP_CQ_SIZE (0x1000) /* 4k */
#define CMDQ_SEC_ISP_VIRT_SIZE (0xC000) /* 24k */
#define CMDQ_SEC_ISP_TILE_SIZE (0x10000) /* 64k */
#define CMDQ_SEC_ISP_BPCI_SIZE (64) /* 64 byte */
#define CMDQ_SEC_ISP_LSCI_SIZE (24576) /* 24576 byte */
#define CMDQ_SEC_ISP_LCEI_SIZE (520200) /* MAX: 510x510x2 byte */
#define CMDQ_SEC_ISP_DEPI_SIZE (924800) /* MAX: 680x680x2 byte */
#define CMDQ_SEC_ISP_DMGI_SIZE (130560) /* MAX: 480x272 byte */
#define CMDQ_IWC_ISP_META_CNT 8
#define CMDQ_SEC_ISP_META_MAX (0x1000) /* 4k */
#define CMDQ_SEC_DATA_SIZE_1 (0x2000) /* 8k */
#define CMDQ_SEC_DATA_SIZE_2 (0x2000) /* 8k */
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 */
CMDQ_IWC_PH_2_MVA = 3, /* protected handle to sec MVA */
};
enum CMDQ_SEC_ENG_ENUM {
/* MDP */
CMDQ_SEC_MDP_RDMA0 = 0,
CMDQ_SEC_MDP_RDMA1, /* 1 */
CMDQ_SEC_MDP_WDMA, /* 2 */
CMDQ_SEC_MDP_WROT0, /* 3 */
CMDQ_SEC_MDP_WROT1, /* 4 */
/* DISP */
CMDQ_SEC_DISP_RDMA0, /* 5 */
CMDQ_SEC_DISP_RDMA1, /* 6 */
CMDQ_SEC_DISP_WDMA0, /* 7 */
CMDQ_SEC_DISP_WDMA1, /* 8 */
CMDQ_SEC_DISP_OVL0, /* 9 */
CMDQ_SEC_DISP_OVL1, /* 10 */
CMDQ_SEC_DISP_OVL2, /* 11 */
CMDQ_SEC_DISP_2L_OVL0, /* 12 */
CMDQ_SEC_DISP_2L_OVL1, /* 13 */
CMDQ_SEC_DISP_2L_OVL2, /* 14 */
/* ISP */
CMDQ_SEC_ISP_IMGI, /* 15 */
CMDQ_SEC_ISP_VIPI, /* 16 */
CMDQ_SEC_ISP_LCEI, /* 17 */
CMDQ_SEC_ISP_IMG2O, /* 18 */
CMDQ_SEC_ISP_IMG3O, /* 19 */
CMDQ_SEC_ISP_SMXIO, /* 20 */
CMDQ_SEC_ISP_DMGI_DEPI, /* 21 */
CMDQ_SEC_ISP_IMGCI, /* 22 */
CMDQ_SEC_ISP_TIMGO, /* 23 */
CMDQ_SEC_DPE, /* 24 */
CMDQ_SEC_OWE, /* 25 */
CMDQ_SEC_WPEI, /* 26 */
CMDQ_SEC_WPEO, /* 27 */
CMDQ_SEC_WPEI2, /* 28 */
CMDQ_SEC_WPEO2, /* 29 */
CMDQ_SEC_FDVT, /* 30 */
CMDQ_SEC_ISP_UFBCI, /* 31 */
CMDQ_SEC_ISP_UFBCO, /* 32 */
CMDQ_SEC_MDP_WROT2, /* 33 */
CMDQ_SEC_MDP_WROT3, /* 34 */
CMDQ_SEC_MDP_RDMA2, /* 35 */
CMDQ_SEC_MDP_RDMA3, /* 36 */
CMDQ_SEC_VENC_BSDMA, /* 37 */
CMDQ_SEC_VENC_CUR_LUMA, /* 38 */
CMDQ_SEC_VENC_CUR_CHROMA, /* 39 */
CMDQ_SEC_VENC_REF_LUMA, /* 40 */
CMDQ_SEC_VENC_REF_CHROMA, /* 41 */
CMDQ_SEC_VENC_REC, /* 42 */
CMDQ_SEC_VENC_SUB_R_LUMA, /* 43 */
CMDQ_SEC_VENC_SUB_W_LUMA, /* 44 */
CMDQ_SEC_VENC_SV_COMV, /* 45 */
CMDQ_SEC_VENC_RD_COMV, /* 46 */
CMDQ_SEC_VENC_NBM_RDMA, /* 47 */
CMDQ_SEC_VENC_NBM_WDMA, /* 48 */
CMDQ_SEC_VENC_NBM_RDMA_LITE,/* 49 */
CMDQ_SEC_VENC_NBM_WDMA_LITE,/* 50 */
CMDQ_SEC_VENC_FCS_NBM_RDMA, /* 51 */
CMDQ_SEC_VENC_FCS_NBM_WDMA, /* 52 */
CMDQ_SEC_MDP_HDR0, /* 53 */
CMDQ_SEC_MDP_HDR1, /* 54 */
CMDQ_SEC_MDP_AAL0, /* 55 */
CMDQ_SEC_MDP_AAL1, /* 56 */
CMDQ_SEC_MDP_AAL2, /* 57 */
CMDQ_SEC_MDP_AAL3, /* 58 */
CMDQ_SEC_MAX_ENG_COUNT /* ALWAYS keep at the end */
};
/* */
/* 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 */
uint32_t blockOffset; /* [IN]_b, block offset from handle(PA) to
* current block(plane)
*/
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 iwcCmdqMetadata_t {
uint32_t addrListLength;
struct iwcCmdqAddrMetadata_t addrList[CMDQ_IWC_MAX_ADDR_LIST_LENGTH];
uint64_t enginesNeedDAPC;
uint64_t enginesNeedPortSecurity;
};
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 iwcCmdqMetaBuf {
uint64_t va;
uint64_t size;
};
struct iwcCmdqSecIspMeta {
/* ISP share memory buffer */
struct iwcCmdqMetaBuf ispBufs[CMDQ_IWC_ISP_META_CNT];
uint64_t CqSecHandle;
uint32_t CqSecSize;
uint32_t CqDesOft;
uint32_t CqVirtOft;
uint64_t TpipeSecHandle;
uint32_t TpipeSecSize;
uint32_t TpipeOft;
uint64_t BpciHandle;
uint64_t LsciHandle;
uint64_t LceiHandle;
uint64_t DepiHandle;
uint64_t DmgiHandle;
};
struct iwcIspMeta {
uint32_t size;
uint32_t data[CMDQ_SEC_ISP_META_MAX / sizeof(uint32_t)];
};
/* extension flag for secure driver, must sync with def */
enum sec_extension_iwc {
IWC_MDP_AAL = 0,
IWC_MDP_TDSHP,
};
#define CMDQ_MAX_READBACK_ENG 8
struct readback_engine {
uint32_t engine;
uint32_t start;
uint32_t count;
uint32_t param;
};
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 */
uint32_t waitCookie; /* [IN] index in thread's task list,
* it should be (nextCookie - 1)
*/
bool resetExecCnt; /* [IN] reset HW thread */
/* client info */
int32_t callerPid;
char callerName[CMDQ_IWC_CLIENT_NAME];
/* metadata */
struct iwcCmdqMetadata_t metadata;
/* client extension bits */
uint64_t extension;
uint64_t readback_pa;
/* debug */
uint64_t hNormalTask; /* handle to reference task in normal world*/
/* SVP HDR */
uint32_t mdp_extension;
struct readback_engine readback_engs[CMDQ_MAX_READBACK_ENG];
uint32_t readback_cnt;
int32_t sec_id;
};
enum cmdq_sec_meta_type {
CMDQ_METAEX_NONE,
CMDQ_METAEX_FD,
CMDQ_METAEX_CQ,
CMDQ_METAEX_VENC,
};
struct iwc_cq_meta {
uint32_t isp_cq_desc[CMDQ_SEC_ISP_CQ_SIZE / sizeof(uint32_t)];
uint32_t isp_cq_desc_size;
uint32_t isp_cq_virt[CMDQ_SEC_ISP_VIRT_SIZE / sizeof(uint32_t)];
uint32_t isp_cq_virt_size;
uint32_t isp_tile[CMDQ_SEC_ISP_TILE_SIZE / sizeof(uint32_t)];
uint32_t isp_tile_size;
uint32_t isp_bpci[CMDQ_SEC_ISP_BPCI_SIZE / sizeof(uint32_t)];
uint32_t isp_bpci_size;
uint32_t isp_lsci[CMDQ_SEC_ISP_LSCI_SIZE / sizeof(uint32_t)];
uint32_t isp_lsci_size;
uint32_t isp_depi[CMDQ_SEC_ISP_DEPI_SIZE / sizeof(uint32_t)];
uint32_t isp_depi_size;
uint32_t isp_dmgi[CMDQ_SEC_ISP_DMGI_SIZE / sizeof(uint32_t)];
uint32_t isp_dmgi_size;
};
struct iwc_cq_meta2 {
struct iwcCmdqSecIspMeta handles;
uint32_t isp_lcei[CMDQ_SEC_ISP_LCEI_SIZE / sizeof(uint32_t)];
uint32_t isp_lcei_size;
};
enum cmdq_iwc_meta_idx {
CMDQ_IWC_MSG = 0,
CMDQ_IWC_MSG1 = 1,
CMDQ_IWC_MSG2 = 2,
};
/* 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 iwcCmdqDebugConfig_t debug;
struct iwcCmdqSecStatus_t secStatus;
uint8_t cmdq_id;
uint8_t iwcex_available;
uint32_t metaex_type;
};
struct iwcCmdqMessageEx_t {
uint32_t size;
union {
uint32_t data[CMDQ_SEC_DATA_SIZE_1 / sizeof(uint32_t)];
struct iwc_cq_meta isp;
};
};
struct iwcCmdqMessageEx2_t {
uint32_t size;
union {
uint32_t data[CMDQ_SEC_DATA_SIZE_2 / sizeof(uint32_t)];
struct iwc_cq_meta2 isp;
};
};
/* */
/* 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)
#define CMDQ_ERR_SECURITY_INVALID_SOP (1508)
#define CMDQ_ERR_SECURITY_INVALID_SEC_PORT_FALG (1511)
/* msee error */
#define CMDQ_ERR_OPEN_IOCTL_FAILED (1600)
/* 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__ */
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,82 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CMDQ_SEC_MAILBOX_H__
#define __CMDQ_SEC_MAILBOX_H__
#define CMDQ_INVALID_THREAD (-1)
#define CMDQ_SEC_IRQ_THREAD (15)
/* Thread that are high-priority (display threads) */
#define CMDQ_MAX_SECURE_THREAD_COUNT (5)
#define CMDQ_MIN_SECURE_THREAD_ID (8)
#define CMDQ_THREAD_SEC_PRIMARY_DISP (CMDQ_MIN_SECURE_THREAD_ID)
#define CMDQ_THREAD_SEC_SUB_DISP (CMDQ_MIN_SECURE_THREAD_ID + 1)
#define CMDQ_THREAD_SEC_MDP (CMDQ_MIN_SECURE_THREAD_ID + 2)
#define CMDQ_THREAD_SEC_ISP (CMDQ_MIN_SECURE_THREAD_ID + 3)
/* 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
/* 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)
#ifdef CMDQ_SECURE_MTEE_SUPPORT
#include "cmdq_sec_mtee.h"
#endif
/*
* inter-world communication state
*/
enum CMDQ_IWC_STATE_ENUM {
IWC_INIT = 0,
IWC_CONTEXT_INITED = 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,
};
void cmdq_sec_mbox_enable(void *chan);
void cmdq_sec_mbox_disable(void *chan);
s32 cmdq_sec_mbox_chan_id(void *chan);
void cmdq_sec_dump_secure_thread_cookie(struct mbox_chan *chan);
void cmdq_sec_dump_thread_all(void *mbox_cmdq);
void cmdq_sec_dump_notify_loop(void *chan);
void cmdq_sec_dump_operation(void *chan);
void cmdq_sec_dump_response(void *chan, struct cmdq_pkt *pkt,
u64 **inst, const char **dispatch);
#ifdef CMDQ_SECURE_MTEE_SUPPORT
void cmdq_sec_mtee_setup_context(struct cmdq_sec_mtee_context *tee);
s32 cmdq_sec_mtee_allocate_shared_memory(struct cmdq_sec_mtee_context *tee,
const dma_addr_t MVABase, const u32 size);
s32 cmdq_sec_mtee_allocate_wsm(struct cmdq_sec_mtee_context *tee,
void **wsm_buffer, u32 size, void **wsm_buf_ex, u32 size_ex,
void **wsm_buf_ex2, u32 size_ex2);
s32 cmdq_sec_mtee_free_wsm(
struct cmdq_sec_mtee_context *tee, void **wsm_buffer);
s32 cmdq_sec_mtee_open_session(
struct cmdq_sec_mtee_context *tee, void *wsm_buffer);
s32 cmdq_sec_mtee_close_session(struct cmdq_sec_mtee_context *tee);
s32 cmdq_sec_mtee_execute_session(struct cmdq_sec_mtee_context *tee,
u32 cmd, s32 timeout_ms, bool share_mem_ex, bool share_mem_ex2);
#endif
#if IS_ENABLED(CONFIG_MMPROFILE)
void cmdq_sec_mmp_wait(struct mbox_chan *chan, void *pkt);
void cmdq_sec_mmp_wait_done(struct mbox_chan *chan, void *pkt);
#endif
#endif
@@ -0,0 +1,42 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 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
/* 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
*/
#define TL_CMDQ_UUID { { 9, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
#endif /*__CMDQSECTEST_API_H__*/
@@ -0,0 +1,137 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CMDQ_SEC_H__
#define __CMDQ_SEC_H__
#include <linux/kernel.h>
#include <linux/soc/mediatek/mtk-cmdq.h>
#include "cmdq-sec-iwc-common.h"
enum CMDQ_SEC_SCENARIO {
CMDQ_SEC_PRIMARY_DISP = 1,
CMDQ_SEC_SUB_DISP = 4,
/* client from user space, so the cmd buffer is in user space. */
CMDQ_SEC_USER_MDP = 12,
CMDQ_SEC_DEBUG = 13,
CMDQ_SEC_DISP_PRIMARY_DISABLE_SECURE_PATH = 18,
CMDQ_SEC_DISP_SUB_DISABLE_SECURE_PATH = 19,
CMDQ_SEC_KERNEL_CONFIG_GENERAL = 38,
/* debug scenario use mdp flush */
CMDQ_SEC_DEBUG_MDP = 42,
/* for ISP kernel driver */
CMDQ_SEC_ISP_RSC = 43,
CMDQ_SEC_ISP_FDVT = 44,
CMDQ_SEC_ISP_DPE = 45,
CMDQ_MAX_SEC_COUNT /* ALWAYS keep at the end */
};
struct cmdq_sec_addr_meta {
/* [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 cmdq_sec_data {
/* 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 cmdq_sec_addr_meta */
uint64_t addrMetadatas;
uint32_t addrMetadataMaxCount; /*[Reserved] */
enum CMDQ_SEC_SCENARIO scenario;
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;
/* reset HW thread in SWd */
bool resetExecCnt;
enum cmdq_sec_meta_type client_meta_type;
u32 client_meta_size[4];
void *client_meta[4];
/* response */
s32 response;
struct iwcCmdqSecStatus_t sec_status;
/* SVP HDR */
uint32_t mdp_extension;
struct readback_engine readback_engs[CMDQ_MAX_READBACK_ENG];
uint32_t readback_cnt;
/* MTEE */
bool mtee;
/* iommu_sec_id */
int32_t sec_id;
};
/* implementation in cmdq-sec-helper.c */
s32 cmdq_sec_pkt_set_data(struct cmdq_pkt *pkt, const u64 dapc_engine,
const u64 port_sec_engine, const enum CMDQ_SEC_SCENARIO scenario,
const enum cmdq_sec_meta_type meta_type);
void cmdq_sec_pkt_free_data(struct cmdq_pkt *pkt);
s32 cmdq_sec_pkt_set_payload(struct cmdq_pkt *pkt, u8 idx,
const u32 meta_size, u32 *meta);
s32 cmdq_sec_pkt_write_reg(struct cmdq_pkt *pkt, u32 addr, u64 base,
const enum CMDQ_IWC_ADDR_METADATA_TYPE type,
const u32 offset, const u32 size, const u32 port, uint32_t sec_id);
s32 cmdq_sec_pkt_assign_metadata(struct cmdq_pkt *pkt,
u32 count, void *meta_array);
void cmdq_sec_dump_secure_data(struct cmdq_pkt *pkt);
int cmdq_sec_pkt_wait_complete(struct cmdq_pkt *pkt);
void cmdq_sec_err_dump(struct cmdq_pkt *pkt, struct cmdq_client *client,
u64 **inst, const char **dispatch);
/* MTEE */
void cmdq_sec_pkt_set_mtee(struct cmdq_pkt *pkt, const bool enable, const int32_t sec_id);
/* implementation in cmdq-sec-mailbox.c */
void cmdq_sec_mbox_switch_normal(struct cmdq_client *cl, const bool mtee);
void cmdq_sec_mbox_stop(struct cmdq_client *cl);
#endif
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,555 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/io.h>
#include <linux/debugfs.h>
#include <linux/sched/clock.h>
#include <linux/soc/mediatek/mtk-cmdq.h>
#include <linux/arm-smccc.h>
#include <mt-plat/mtk_secure_api.h>
#include "cmdq-util.h"
#ifdef CMDQ_SECURE_SUPPORT
#include "cmdq-sec-mailbox.h"
#endif
#ifdef CONFIG_MTK_SMI_EXT
#include "smi_public.h"
#endif
#ifdef CONFIG_MTK_DEVAPC
#include <devapc_public.h>
#endif
#define CMDQ_MBOX_NUM 2
#define CMDQ_HW_MAX 2
#define CMDQ_RECORD_NUM 512
#define CMDQ_FIRST_ERR_SIZE 524288 /* 512k */
#define CMDQ_CURR_IRQ_STATUS 0x10
#define CMDQ_CURR_LOADED_THR 0x18
#define CMDQ_THR_EXEC_CYCLES 0x34
#define CMDQ_THR_TIMEOUT_TIMER 0x38
#define GCE_DBG_CTL 0x3000
#define GCE_DBG0 0x3004
#define GCE_DBG2 0x300C
#define GCE_DBG3 0x3010
#define util_time_to_us(start, end, duration) \
{ \
u64 _duration = end - start; \
do_div(_duration, 1000); \
duration = (s32)_duration; \
}
struct cmdq_util_error {
spinlock_t lock;
bool enable;
char *buffer;
u32 length;
u64 nsec;
struct timeval errtm;
char caller[TASK_COMM_LEN]; // TODO
};
struct cmdq_util_dentry {
struct dentry *status;
struct dentry *record;
struct dentry *log_feature;
u8 bit_feature;
};
struct cmdq_record {
unsigned long pkt;
s32 priority; /* task priority (not thread priority) */
s8 id;
s32 thread; /* allocated thread */
s32 reorder;
u32 size;
bool is_secure; /* true for secure task */
u64 submit; /* epoch time of IOCTL/Kernel API call */
u64 trigger; /* epoch time of enable HW thread */
/* epoch time of start waiting for task completion */
u64 wait;
u64 irq; /* epoch time of IRQ event */
u64 done; /* epoch time of sw leaving wait and task finish */
unsigned long start; /* buffer start address */
unsigned long end; /* command end address */
u64 last_inst; /* last instruction, jump addr */
u32 exec_begin; /* task execute time in hardware thread */
u32 exec_end; /* task execute time in hardware thread */
};
struct cmdq_util {
struct cmdq_util_error err;
struct cmdq_util_dentry fs;
struct cmdq_record record[CMDQ_RECORD_NUM];
u16 record_idx;
void *cmdq_mbox[CMDQ_MBOX_NUM];
void *cmdq_sec_mbox[CMDQ_MBOX_NUM];
u32 mbox_cnt;
u32 mbox_sec_cnt;
const char *first_err_mod[CMDQ_HW_MAX];
};
static struct cmdq_util util;
static DEFINE_MUTEX(cmdq_record_mutex);
static DEFINE_MUTEX(cmdq_dump_mutex);
u32 cmdq_util_get_bit_feature(void)
{
return util.fs.bit_feature;
}
bool cmdq_util_is_feature_en(u8 feature)
{
return (util.fs.bit_feature & BIT(feature)) != 0;
}
void cmdq_util_error_enable(void)
{
if (!util.err.nsec) {
util.err.nsec = sched_clock();
do_gettimeofday(&util.err.errtm);
}
util.err.enable = true;
}
EXPORT_SYMBOL(cmdq_util_error_enable);
void cmdq_util_error_disable(void)
{
util.err.enable = false;
}
EXPORT_SYMBOL(cmdq_util_error_disable);
void cmdq_util_dump_lock(void)
{
mutex_lock(&cmdq_dump_mutex);
}
EXPORT_SYMBOL(cmdq_util_dump_lock);
void cmdq_util_dump_unlock(void)
{
mutex_unlock(&cmdq_dump_mutex);
}
EXPORT_SYMBOL(cmdq_util_dump_unlock);
s32 cmdq_util_error_save_lst(const char *format, va_list args)
{
unsigned long flags;
s32 size;
if (!util.err.enable || !util.err.buffer)
return -EFAULT;
spin_lock_irqsave(&util.err.lock, flags);
size = vsnprintf(util.err.buffer + util.err.length,
CMDQ_FIRST_ERR_SIZE - util.err.length, format, args);
if (size >= CMDQ_FIRST_ERR_SIZE - util.err.length)
cmdq_log("size:%d over buf size:%d",
size, CMDQ_FIRST_ERR_SIZE - util.err.length);
util.err.length += size;
spin_unlock_irqrestore(&util.err.lock, flags);
if (util.err.length >= CMDQ_FIRST_ERR_SIZE) {
cmdq_util_error_disable();
cmdq_err("util.err.length:%u is over CMDQ_FIRST_ERR_SIZE:%u",
util.err.length, CMDQ_FIRST_ERR_SIZE);
}
return 0;
}
EXPORT_SYMBOL(cmdq_util_error_save_lst);
s32 cmdq_util_error_save(const char *format, ...)
{
va_list args;
if (!util.err.enable || !util.err.buffer)
return -EFAULT;
va_start(args, format);
cmdq_util_error_save_lst(format, args);
va_end(args);
return 0;
}
EXPORT_SYMBOL(cmdq_util_error_save);
static int cmdq_util_status_print(struct seq_file *seq, void *data)
{
u64 sec = util.err.nsec;
unsigned long nsec = do_div(sec, 1000000000);
struct tm nowtm;
u32 i;
if (util.err.length) {
time_to_tm(util.err.errtm.tv_sec, sys_tz.tz_minuteswest * 60,
&nowtm);
seq_printf(seq,
"[cmdq] first error kernel time:[%5llu.%06lu] UTC time:[%04ld-%02d-%02d %02d:%02d:%02d.%06ld]\n",
sec, nsec,
nowtm.tm_year + 1900, nowtm.tm_mon + 1,
nowtm.tm_mday, nowtm.tm_hour, nowtm.tm_min,
nowtm.tm_sec, util.err.errtm.tv_usec);
seq_printf(seq, "%s", util.err.buffer);
}
seq_puts(seq, "[cmdq] dump all thread current status\n");
for (i = 0; i < util.mbox_cnt; i++)
cmdq_thread_dump_all_seq(util.cmdq_mbox[i], seq);
return 0;
}
static int cmdq_util_record_print(struct seq_file *seq, void *data)
{
struct cmdq_record *rec;
u32 acq_time, irq_time, begin_wait, exec_time, total_time;
u64 submit_sec, hw_time;
unsigned long submit_rem, hw_time_rem;
s32 i, idx;
mutex_lock(&cmdq_record_mutex);
seq_puts(seq, "index,pkt,task priority,sec,size,gce,thread,");
seq_puts(seq,
"submit,acq_time(us),irq_time(us),begin_wait(us),exec_time(us),total_time(us),start,end,jump,");
seq_puts(seq, "exec begin,exec end,hw_time(us),\n");
idx = util.record_idx;
for (i = 0; i < ARRAY_SIZE(util.record); i++) {
idx--;
if (idx < 0)
idx = ARRAY_SIZE(util.record) - 1;
rec = &util.record[idx];
if (!rec->pkt)
continue;
seq_printf(seq, "%u,%#lx,%d,%d,%u,%hhd,%d,",
idx, rec->pkt, rec->priority, (int)rec->is_secure,
rec->size, rec->id, rec->thread);
submit_sec = rec->submit;
submit_rem = do_div(submit_sec, 1000000000);
util_time_to_us(rec->submit, rec->trigger, acq_time);
util_time_to_us(rec->trigger, rec->irq, irq_time);
util_time_to_us(rec->submit, rec->wait, begin_wait);
util_time_to_us(rec->trigger, rec->done, exec_time);
util_time_to_us(rec->submit, rec->done, total_time);
seq_printf(seq,
"%llu.%06lu,%u,%u,%u,%u,%u,%#lx,%#lx,%#llx,",
submit_sec, submit_rem / 1000, acq_time, irq_time,
begin_wait, exec_time, total_time,
rec->start, rec->end, rec->last_inst);
hw_time = rec->exec_end > rec->exec_begin ?
rec->exec_end - rec->exec_begin :
~rec->exec_begin + 1 + rec->exec_end;
hw_time_rem = (u32)CMDQ_TICK_TO_US(hw_time);
seq_printf(seq, "%u,%u,%llu.%06lu,\n",
rec->exec_begin, rec->exec_end, hw_time, hw_time_rem);
}
mutex_unlock(&cmdq_record_mutex);
return 0;
}
static int cmdq_util_status_open(struct inode *inode, struct file *file)
{
return single_open(file, cmdq_util_status_print, inode->i_private);
}
static int cmdq_util_record_open(struct inode *inode, struct file *file)
{
return single_open(file, cmdq_util_record_print, inode->i_private);
}
static const struct file_operations cmdq_util_status_fops = {
.owner = THIS_MODULE,
.open = cmdq_util_status_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations cmdq_util_record_fops = {
.owner = THIS_MODULE,
.open = cmdq_util_record_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
static int cmdq_util_log_feature_get(void *data, u64 *val)
{
cmdq_msg("data:%p val:%#llx bit_feature:%#x",
data, *val, util.fs.bit_feature);
return util.fs.bit_feature;
}
static int cmdq_util_log_feature_set(void *data, u64 val)
{
if (val == CMDQ_LOG_FEAT_NUM) {
util.fs.bit_feature = 0;
cmdq_msg("data:%p val:%#llx bit_feature:%#x reset",
data, val, util.fs.bit_feature);
return 0;
}
if (val >= CMDQ_LOG_FEAT_NUM) {
cmdq_err("data:%p val:%#llx cannot be over %#x",
data, val, CMDQ_LOG_FEAT_NUM);
return -EINVAL;
}
util.fs.bit_feature |= (1 << val);
cmdq_msg("data:%p val:%#llx bit_feature:%#x",
data, val, util.fs.bit_feature);
return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(cmdq_util_log_feature_fops,
cmdq_util_log_feature_get, cmdq_util_log_feature_set, "%llu");
/* sync with request in atf */
enum cmdq_smc_request {
CMDQ_ENABLE_DEBUG,
};
#if !IS_ENABLED(CONFIG_FPGA_EARLY_PORTING)
static atomic_t cmdq_dbg_ctrl = ATOMIC_INIT(0);
#endif
void cmdq_util_dump_dbg_reg(void *chan)
{
void *base = cmdq_mbox_get_base(chan);
u32 dbg0[3], dbg2[6], dbg3, i;
u32 id;
if (!base) {
cmdq_util_msg("no cmdq dbg since no base");
return;
}
id = cmdq_util_hw_id((u32)cmdq_mbox_get_base_pa(chan));
#if !IS_ENABLED(CONFIG_FPGA_EARLY_PORTING)
if (atomic_cmpxchg(&cmdq_dbg_ctrl, 0, 1) == 0) {
struct arm_smccc_res res;
arm_smccc_smc(MTK_SIP_CMDQ_CONTROL, CMDQ_ENABLE_DEBUG, id,
0, 0, 0, 0, 0, &res);
}
#endif
/* debug select */
for (i = 0; i < 6; i++) {
if (i < 3) {
writel((i << 8) | i, base + GCE_DBG_CTL);
dbg0[i] = readl(base + GCE_DBG0);
} else {
/* only other part */
writel(i << 8, base + GCE_DBG_CTL);
}
dbg2[i] = readl(base + GCE_DBG2);
}
dbg3 = readl(base + GCE_DBG3);
cmdq_util_user_msg(chan,
"id:%u dbg0:%#x %#x %#x dbg2:%#x %#x %#x %#x %#x %#x dbg3:%#x",
id,
dbg0[0], dbg0[1], dbg0[2],
dbg2[0], dbg2[1], dbg2[2], dbg2[3], dbg2[4], dbg2[5],
dbg3);
}
void cmdq_util_track(struct cmdq_pkt *pkt)
{
struct cmdq_record *record;
struct cmdq_client *cl = pkt->cl;
struct cmdq_pkt_buffer *buf;
u64 done = sched_clock();
u32 offset, *perf;
mutex_lock(&cmdq_record_mutex);
record = &util.record[util.record_idx++];
record->pkt = (unsigned long)pkt;
record->priority = pkt->priority;
record->size = pkt->cmd_buf_size;
record->submit = pkt->rec_submit;
record->trigger = pkt->rec_trigger;
record->wait = pkt->rec_wait;
record->irq = pkt->rec_irq;
record->done = done;
if (cl && cl->chan) {
record->thread = cmdq_mbox_chan_id(cl->chan);
record->id = cmdq_util_hw_id((u32)cmdq_mbox_get_base_pa(
cl->chan));
} else {
record->thread = -1;
record->id = -1;
}
#ifdef CMDQ_SECURE_SUPPORT
if (pkt->sec_data)
record->is_secure = true;
#endif
if (util.record_idx >= CMDQ_RECORD_NUM)
util.record_idx = 0;
if (!list_empty(&pkt->buf)) {
buf = list_first_entry(&pkt->buf, typeof(*buf), list_entry);
record->start = buf->pa_base;
buf = list_last_entry(&pkt->buf, typeof(*buf), list_entry);
offset = CMDQ_CMD_BUFFER_SIZE - (pkt->buf_size -
pkt->cmd_buf_size);
record->end = buf->pa_base + offset;
record->last_inst = *(u64 *)(buf->va_base + offset -
CMDQ_INST_SIZE);
perf = cmdq_pkt_get_perf_ret(pkt);
if (perf) {
record->exec_begin = perf[0];
record->exec_end = perf[1];
}
}
mutex_unlock(&cmdq_record_mutex);
}
void cmdq_util_dump_smi(void)
{
#if defined(CONFIG_MTK_SMI_EXT) && !defined(CONFIG_FPGA_EARLY_PORTING) && \
!defined(CONFIG_MTK_SMI_VARIANT)
int smi_hang;
smi_hang = smi_debug_bus_hang_detect(1, "CMDQ");
cmdq_util_err("smi hang:%d", smi_hang);
#else
cmdq_util_err("[WARNING]not enable SMI dump now");
#endif
}
#ifdef CONFIG_MTK_DEVAPC
static void cmdq_util_handle_devapc_vio(void)
{
u32 i;
cmdq_util_msg("%s mbox cnt:%u", __func__, util.mbox_cnt);
for (i = 0; i < util.mbox_cnt; i++)
cmdq_thread_dump_all(util.cmdq_mbox[i]);
#ifdef CMDQ_SECURE_SUPPORT
cmdq_util_msg("%s mbox sec cnt:%u", __func__, util.mbox_sec_cnt);
for (i = 0; i < util.mbox_sec_cnt; i++)
cmdq_sec_dump_thread_all(util.cmdq_sec_mbox[i]);
#endif
}
static struct devapc_vio_callbacks devapc_vio_handle = {
.id = INFRA_SUBSYS_GCE,
.debug_dump = cmdq_util_handle_devapc_vio,
};
#endif
u8 cmdq_util_track_ctrl(void *cmdq, phys_addr_t base, bool sec)
{
cmdq_msg("%s cmdq:%p sec:%s", __func__, cmdq, sec ? "true" : "false");
if (sec)
util.cmdq_sec_mbox[util.mbox_sec_cnt++] = cmdq;
else
util.cmdq_mbox[util.mbox_cnt++] = cmdq;
return (u8)cmdq_util_hw_id((u32)base);
}
void cmdq_util_set_first_err_mod(void *chan, const char *mod)
{
u32 hw_id = cmdq_util_hw_id((u32)cmdq_mbox_get_base_pa(chan));
util.first_err_mod[hw_id] = mod;
}
const char *cmdq_util_get_first_err_mod(void *chan)
{
u32 hw_id = cmdq_util_hw_id((u32)cmdq_mbox_get_base_pa(chan));
return util.first_err_mod[hw_id];
}
static int __init cmdq_util_init(void)
{
struct dentry *dir;
bool exists = false;
cmdq_msg("%s begin", __func__);
spin_lock_init(&util.err.lock);
util.err.buffer = vzalloc(CMDQ_FIRST_ERR_SIZE);
if (!util.err.buffer)
return -ENOMEM;
dir = debugfs_lookup("cmdq", NULL);
if (!dir) {
dir = debugfs_create_dir("cmdq", NULL);
if (!dir) {
cmdq_err("debugfs_create_dir cmdq failed");
return -EINVAL;
}
} else
exists = true;
util.fs.status = debugfs_create_file(
"cmdq-status", 0444, dir, &util, &cmdq_util_status_fops);
if (IS_ERR(util.fs.status)) {
cmdq_err("debugfs_create_file cmdq-status failed:%ld",
PTR_ERR(util.fs.status));
return PTR_ERR(util.fs.status);
}
util.fs.record = debugfs_create_file(
"cmdq-record", 0444, dir, &util, &cmdq_util_record_fops);
if (IS_ERR(util.fs.record)) {
cmdq_err("debugfs_create_file cmdq-record failed:%ld",
PTR_ERR(util.fs.record));
return PTR_ERR(util.fs.record);
}
util.fs.log_feature = debugfs_create_file("cmdq-log-feature",
0444, dir, &util, &cmdq_util_log_feature_fops);
if (IS_ERR(util.fs.log_feature)) {
cmdq_err("debugfs_create_file cmdq-log-feature failed:%ld",
PTR_ERR(util.fs.log_feature));
return PTR_ERR(util.fs.log_feature);
}
if (exists)
dput(dir);
cmdq_util_log_feature_set(NULL, CMDQ_LOG_FEAT_PERF);
#ifdef CONFIG_MTK_DEVAPC
register_devapc_vio_callback(&devapc_vio_handle);
#endif
cmdq_msg("%s end", __func__);
return 0;
}
late_initcall(cmdq_util_init);
@@ -0,0 +1,131 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CMDQ_UTIL_H__
#define __CMDQ_UTIL_H__
#include <linux/kernel.h>
#include <linux/soc/mediatek/mtk-cmdq.h>
#if IS_ENABLED(CONFIG_MTK_AEE_FEATURE)
#include <mt-plat/aee.h>
#endif
enum {
CMDQ_LOG_FEAT_SECURE,
CMDQ_LOG_FEAT_PERF,
CMDQ_LOG_FEAT_NUM,
};
#define cmdq_util_log(feat, fmt, args...) \
do { \
cmdq_util_error_save("[cmdq] "fmt"\n", ##args); \
if (cmdq_util_get_bit_feature() & (1 << feat)) \
cmdq_msg(fmt, ##args); \
} while (0)
#define cmdq_aee(fmt, args...) \
pr_notice("[cmdq][aee] "fmt"\n", ##args)
#define cmdq_util_msg(fmt, args...) \
do { \
cmdq_msg(fmt, ##args); \
cmdq_util_error_save("[cmdq] "fmt"\n", ##args); \
} while (0)
#define cmdq_util_err(fmt, args...) \
do { \
cmdq_dump(fmt, ##args); \
cmdq_util_error_save("[cmdq][err] "fmt"\n", ##args); \
} while (0)
#define cmdq_util_user_msg(chan, fmt, args...) \
do { \
if (chan) { \
u32 gce = cmdq_util_hw_id( \
(u32)cmdq_mbox_get_base_pa(chan)); \
s32 thd = cmdq_mbox_chan_id(chan); \
pr_notice("[%s]<%u>(%d)[cmdq] "fmt"\n", \
cmdq_thread_module_dispatch(gce, thd), \
gce, thd, ##args); \
cmdq_util_error_save("[cmdq] "fmt"\n", ##args); \
} else \
cmdq_util_msg(fmt, ##args); \
} while (0)
#define cmdq_util_user_err(chan, fmt, args...) \
do { \
if (chan) { \
u32 gce = cmdq_util_hw_id( \
(u32)cmdq_mbox_get_base_pa(chan)); \
s32 thd = cmdq_mbox_chan_id(chan); \
pr_notice("[%s]<%u>(%d)[cmdq][err] "fmt"\n", \
cmdq_thread_module_dispatch(gce, thd), \
gce, thd, ##args); \
cmdq_util_error_save("[cmdq][err] "fmt"\n", ##args); \
} else \
cmdq_util_msg(fmt, ##args); \
} while (0)
#define DB_OPT_CMDQ (DB_OPT_DEFAULT | DB_OPT_PROC_CMDQ_INFO | \
DB_OPT_MMPROFILE_BUFFER | DB_OPT_FTRACE | DB_OPT_DUMP_DISPLAY)
#if IS_ENABLED(CONFIG_MTK_AEE_FEATURE)
#define cmdq_util_aee(key, fmt, args...) \
do { \
char tag[LINK_MAX]; \
int len = snprintf(tag, LINK_MAX, "CRDISPATCH_KEY:%s", key); \
if (len >= LINK_MAX) \
pr_debug("len:%d over max:%d\n", \
__func__, __LINE__, len, LINK_MAX); \
cmdq_aee(fmt, ##args); \
cmdq_util_error_save("[cmdq][aee] "fmt"\n", ##args); \
aee_kernel_warning_api(__FILE__, __LINE__, \
DB_OPT_CMDQ, tag, fmt, ##args); \
} while (0)
#else
#define cmdq_util_aee(key, fmt, args...) \
do { \
char tag[LINK_MAX]; \
int len = snprintf(tag, LINK_MAX, "CRDISPATCH_KEY:%s", key); \
if (len >= LINK_MAX) \
pr_debug("len:%d over max:%d\n", \
__func__, __LINE__, len, LINK_MAX); \
cmdq_aee(fmt" (aee not ready)", ##args); \
cmdq_util_error_save("[cmdq][aee] "fmt"\n", ##args); \
} while (0)
#endif
struct cmdq_pkt;
u32 cmdq_util_get_bit_feature(void);
bool cmdq_util_is_feature_en(u8 feature);
void cmdq_util_error_enable(void); // TODO : need be called
void cmdq_util_error_disable(void);
void cmdq_util_dump_lock(void);
void cmdq_util_dump_unlock(void);
s32 cmdq_util_error_save_lst(const char *format, va_list args);
s32 cmdq_util_error_save(const char *format, ...);
void cmdq_util_dump_dbg_reg(void *chan);
void cmdq_util_track(struct cmdq_pkt *pkt);
void cmdq_util_dump_smi(void);
u8 cmdq_util_track_ctrl(void *cmdq, phys_addr_t base, bool sec);
void cmdq_util_set_first_err_mod(void *chan, const char *mod);
const char *cmdq_util_get_first_err_mod(void *chan);
/* function support in platform */
const char *cmdq_thread_module_dispatch(phys_addr_t gce_pa, s32 thread);
const char *cmdq_event_module_dispatch(phys_addr_t gce_pa, const u16 event,
s32 thread);
u32 cmdq_util_hw_id(u32 pa);
const char *cmdq_util_hw_name(void *chan);
#if IS_ENABLED(CONFIG_MACH_MT6873) || IS_ENABLED(CONFIG_MACH_MT6853)
bool cmdq_thread_ddr_user_check(const s32 thread);
#endif
#endif
@@ -0,0 +1,253 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/arm-smccc.h>
#include <linux/soc/mediatek/mtk-cmdq.h>
#include "cmdq_sec_mtee.h"
static bool cmdq_mtee;
void cmdq_sec_mtee_setup_context(struct cmdq_sec_mtee_context *tee)
{
const char ta_uuid[32] = "com.mediatek.geniezone.cmdq";
const char wsm_uuid[32] = "com.mediatek.geniezone.srv.mem";
struct arm_smccc_res res;
memset(tee, 0, sizeof(*tee));
strncpy(tee->ta_uuid, ta_uuid, sizeof(ta_uuid));
strncpy(tee->wsm_uuid, wsm_uuid, sizeof(wsm_uuid));
arm_smccc_smc(0xBC00000B, 1, 0, 0, 0, 0, 0, 0, &res);
if (res.a0 == 1)
cmdq_mtee = true;
cmdq_msg("%s a0:%#lx cmdq_mtee:%d", __func__, res.a0, cmdq_mtee);
}
// TODO
#if 0
s32 cmdq_sec_init_context(struct cmdq_sec_tee_context *tee)
{
s32 status;
cmdq_msg("[SEC] enter %s", __func__);
#if defined(CONFIG_MICROTRUST_TEE_SUPPORT)
while (!is_teei_ready()) {
cmdq_msg("[SEC] Microtrust TEE is not ready, wait...");
msleep(1000);
}
#elif defined(CONFIG_TRUSTONIC_TEE_SUPPORT)
while (!is_mobicore_ready()) {
cmdq_msg("[SEC] Trustonic TEE is not ready, wait...");
msleep(1000);
}
#endif
cmdq_log("[SEC]TEE is ready");
status = TEEC_InitializeContext(NULL, &tee->gp_context);
if (status != TEEC_SUCCESS)
cmdq_err("[SEC]init_context fail: status:0x%x", status);
else
cmdq_msg("[SEC]init_context: status:0x%x", status);
return status;
}
s32 cmdq_sec_deinit_context(struct cmdq_sec_tee_context *tee)
{
TEEC_FinalizeContext(&tee->gp_context);
return 0;
}
#endif
s32 cmdq_sec_mtee_allocate_shared_memory(struct cmdq_sec_mtee_context *tee,
const dma_addr_t MVABase, const u32 size)
{
s32 status;
if (!cmdq_mtee) {
cmdq_msg("%s cmdq_mtee:%d not support", __func__, cmdq_mtee);
return 0;
}
tee->mem_param.size = size;
tee->mem_param.buffer = (void *)(unsigned long)MVABase;
status = KREE_RegisterSharedmem(tee->wsm_pHandle,
&tee->mem_handle, &tee->mem_param);
if (status != TZ_RESULT_SUCCESS)
cmdq_err("%s: session:%#x handle:%#x size:%#x buffer:%p",
__func__, tee->wsm_pHandle, tee->mem_handle,
tee->mem_param.size, tee->mem_param.buffer);
else
cmdq_log("%s: session:%#x handle:%#x size:%#x buffer:%p",
__func__, tee->wsm_pHandle, tee->mem_handle,
tee->mem_param.size, tee->mem_param.buffer);
return status;
}
s32 cmdq_sec_mtee_allocate_wsm(struct cmdq_sec_mtee_context *tee,
void **wsm_buffer, u32 size, void **wsm_buf_ex, u32 size_ex,
void **wsm_buf_ex2, u32 size_ex2)
{
s32 status;
if (!cmdq_mtee) {
cmdq_msg("%s cmdq_mtee:%d not support", __func__, cmdq_mtee);
return 0;
}
if (!wsm_buffer || !wsm_buf_ex || !wsm_buf_ex2)
return -EINVAL;
/* region_id = 0, mapAry = NULL for continuous */
*wsm_buffer = kzalloc(size, GFP_KERNEL);
if (!*wsm_buffer)
return -ENOMEM;
tee->wsm_param.size = size;
tee->wsm_param.buffer = (void *)(u64)virt_to_phys(*wsm_buffer);
status = KREE_RegisterSharedmem(tee->wsm_pHandle,
&tee->wsm_handle, &tee->wsm_param);
if (status != TZ_RESULT_SUCCESS) {
cmdq_err("%s: session:%#x handle:%#x size:%#x buffer:%p:%p",
__func__, tee->wsm_pHandle, tee->wsm_handle,
tee->wsm_param.size, *wsm_buffer, *wsm_buffer);
return status;
}
cmdq_log("%s: session:%#x handle:%#x size:%#x buffer:%p:%p",
__func__, tee->wsm_pHandle, tee->wsm_handle,
tee->wsm_param.size, *wsm_buffer, *wsm_buffer);
*wsm_buf_ex = kzalloc(size_ex, GFP_KERNEL);
if (!*wsm_buf_ex)
return -ENOMEM;
tee->wsm_ex_param.size = size_ex;
tee->wsm_ex_param.buffer = (void *)(u64)virt_to_phys(*wsm_buf_ex);
status = KREE_RegisterSharedmem(tee->wsm_pHandle,
&tee->wsm_ex_handle, &tee->wsm_ex_param);
if (status != TZ_RESULT_SUCCESS)
cmdq_err("%s: session:%#x handle:%#x size:%#x buffer:%p:%p",
__func__, tee->wsm_pHandle, tee->wsm_ex_handle,
tee->wsm_ex_param.size, *wsm_buf_ex, *wsm_buf_ex);
else
cmdq_log("%s: session:%#x handle:%#x size:%#x buffer:%p:%p",
__func__, tee->wsm_pHandle, tee->wsm_ex_handle,
tee->wsm_ex_param.size, *wsm_buf_ex, *wsm_buf_ex);
*wsm_buf_ex2 = kzalloc(size_ex2, GFP_KERNEL);
if (!*wsm_buf_ex2)
return -ENOMEM;
tee->wsm_ex2_param.size = size_ex2;
tee->wsm_ex2_param.buffer = (void *)(u64)virt_to_phys(*wsm_buf_ex2);
status = KREE_RegisterSharedmem(tee->wsm_pHandle,
&tee->wsm_ex2_handle, &tee->wsm_ex2_param);
if (status != TZ_RESULT_SUCCESS)
cmdq_err("%s: session:%#x handle:%#x size:%#x buffer:%p:%p",
__func__, tee->wsm_pHandle, tee->wsm_ex2_handle,
tee->wsm_ex2_param.size, *wsm_buf_ex2, *wsm_buf_ex2);
else
cmdq_log("%s: session:%#x handle:%#x size:%#x buffer:%p:%p",
__func__, tee->wsm_pHandle, tee->wsm_ex2_handle,
tee->wsm_ex2_param.size, *wsm_buf_ex2, *wsm_buf_ex2);
return status;
}
s32 cmdq_sec_mtee_free_wsm(struct cmdq_sec_mtee_context *tee,
void **wsm_buffer)
{
if (!cmdq_mtee) {
cmdq_msg("%s cmdq_mtee:%d not support", __func__, cmdq_mtee);
return 0;
}
if (!wsm_buffer)
return -EINVAL;
KREE_UnregisterSharedmem(tee->wsm_pHandle, tee->wsm_handle);
kfree(*wsm_buffer);
*wsm_buffer = NULL;
return 0;
}
s32 cmdq_sec_mtee_open_session(struct cmdq_sec_mtee_context *tee,
void *wsm_buffer)
{
s32 status;
if (!cmdq_mtee) {
cmdq_msg("%s cmdq_mtee:%d not support", __func__, cmdq_mtee);
return 0;
}
status = KREE_CreateSession(tee->ta_uuid, &tee->pHandle);
if (status != TZ_RESULT_SUCCESS) {
cmdq_err("%s:%s:%d", __func__, tee->ta_uuid, status);
return status;
}
cmdq_log("%s: tee:%p ta_uuid:%s session:%#x",
__func__, tee, tee->ta_uuid, tee->pHandle);
status = KREE_CreateSession(tee->wsm_uuid, &tee->wsm_pHandle);
if (status != TZ_RESULT_SUCCESS) {
cmdq_err("%s:%s:%d", __func__, tee->ta_uuid, status);
return status;
}
cmdq_log("%s: tee:%p ta_uuid:%s session:%#x",
__func__, tee, tee->wsm_uuid, tee->wsm_pHandle);
return status;
}
s32 cmdq_sec_mtee_close_session(struct cmdq_sec_mtee_context *tee)
{
if (!cmdq_mtee) {
cmdq_msg("%s cmdq_mtee:%d not support", __func__, cmdq_mtee);
return 0;
}
KREE_CloseSession(tee->wsm_pHandle);
return KREE_CloseSession(tee->pHandle);
}
s32 cmdq_sec_mtee_execute_session(struct cmdq_sec_mtee_context *tee,
u32 cmd, s32 timeout_ms, bool share_mem_ex, bool share_mem_ex2)
{
s32 status;
u32 types = TZ_ParamTypes4(TZPT_VALUE_INOUT,
share_mem_ex ? TZPT_VALUE_INOUT : TZPT_NONE,
share_mem_ex2 ? TZPT_VALUE_INOUT : TZPT_NONE,
cmd == 4 ? TZPT_VALUE_INOUT : TZPT_NONE); // TODO
union MTEEC_PARAM param[4];
if (!cmdq_mtee) {
cmdq_msg("%s cmdq_mtee:%d not support", __func__, cmdq_mtee);
return 0;
}
param[0].value.a = tee->wsm_handle;
param[0].value.b = tee->wsm_param.size;
param[1].value.a = tee->wsm_ex_handle;
param[1].value.b = tee->wsm_ex_param.size;
param[2].value.a = tee->wsm_ex2_handle;
param[2].value.b = tee->wsm_ex2_param.size;
param[3].value.a = tee->mem_handle;
param[3].value.b = (u32)(unsigned long)tee->mem_param.buffer;
cmdq_log("%s: tee:%p session:%#x cmd:%u timeout:%d",
__func__, tee, tee->pHandle, cmd, timeout_ms);
cmdq_log("%s: mem_ex:%d mem_ex2:%d types:%#x",
__func__, share_mem_ex, share_mem_ex2, types);
cmdq_log("wsm:%#x:%#x ex:%#x:%#x ex2:%#x:%#x mem:%#x:%#x",
param[0].value.a, param[0].value.b,
param[1].value.a, param[1].value.b,
param[2].value.a, param[2].value.b,
param[3].value.a, param[3].value.b);
status = KREE_TeeServiceCallPlus(tee->pHandle, cmd, types, param, 0);
if (status != TZ_RESULT_SUCCESS)
cmdq_err("%s:%d cmd:%u", __func__, status, cmd);
else
cmdq_msg("%s:%d cmd:%u", __func__, status, cmd);
return status;
}
@@ -0,0 +1,50 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CMDQ_SEC_MTEE_H__
#define __CMDQ_SEC_MTEE_H__
#include <linux/types.h>
#include <linux/delay.h>
#include <linux/limits.h>
#include <kree/system.h>
#include <kree/mem.h>
//#include "tee_client_api.h"
#if defined(CONFIG_MICROTRUST_TEE_SUPPORT)
#include "teei_client_main.h"
#endif
#if defined(CONFIG_TRUSTONIC_TEE_SUPPORT)
#include "mobicore_driver_api.h"
#endif
/* context for tee vendor */
struct cmdq_sec_mtee_context {
char ta_uuid[NAME_MAX];
KREE_SESSION_HANDLE pHandle;
char wsm_uuid[NAME_MAX];
KREE_SESSION_HANDLE wsm_pHandle;
KREE_SHAREDMEM_HANDLE wsm_handle;
KREE_SHAREDMEM_PARAM wsm_param;
KREE_SHAREDMEM_HANDLE wsm_ex_handle;
KREE_SHAREDMEM_PARAM wsm_ex_param;
KREE_SHAREDMEM_HANDLE wsm_ex2_handle;
KREE_SHAREDMEM_PARAM wsm_ex2_param;
KREE_SHAREDMEM_HANDLE mem_handle;
KREE_SHAREDMEM_PARAM mem_param;
#if 0
/* Universally Unique Identifier of secure tl/dr */
struct TEEC_UUID uuid;
struct TEEC_Context gp_context; /* basic context */
struct TEEC_Session session; /* session handle */
struct TEEC_SharedMemory wsm_param; /* shared memory */
struct TEEC_SharedMemory wsm_ex_param; /* shared memory */
#endif
};
#endif /* __CMDQ_SEC_MTEE_H__ */
@@ -0,0 +1,95 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <dt-bindings/gce/mt6781-gce.h>
#include "../cmdq-util.h"
const char *cmdq_thread_module_dispatch(phys_addr_t gce_pa, s32 thread)
{
switch (thread) {
case 0 ... 6:
case 8 ... 9:
return "DISP";
case 7:
return "VDEC";
case 10:
case 19 ... 22:
return "MDP";
case 11:
case 13 ... 14:
case 16 ... 18:
return "ISP";
case 12:
return "VENC";
case 15:
return "CMDQ";
case 23:
return "VFMT";
default:
return "CMDQ";
}
}
const char *cmdq_event_module_dispatch(phys_addr_t gce_pa, const u16 event,
s32 thread)
{
switch (event) {
case CMDQ_EVENT_LINE_COUNT_THRESHOLD_INTERRUPT ... CMDQ_EVENT_GCE_CNT_OP_THRESHOLD:
return "VDEC";
case CMDQ_EVENT_VDEC_MINI_MDP_EVENT_0 ... CMDQ_EVENT_VDEC_MINI_MDP_EVENT_15:
return "VFMT";
case CMDQ_EVENT_ISP_FRAME_DONE_A ... CMDQ_EVENT_CQ_VR_SNAP_B_INT:
return "CAM";
case CMDQ_EVENT_VENC_CMDQ_FRAME_DONE ... CMDQ_EVENT_VENC_CMDQ_VPS_DONE:
return "VENC";
case CMDQ_EVENT_FDVT_DONE ... CMDQ_EVENT_DVP_DONE_ASYNC_SHOT:
return "IPE";
case CMDQ_EVENT_GCE_IMG2_EVENT0 ... CMDQ_EVENT_GCE_IMG1_EVENT23:
return "IMG";
case CMDQ_EVENT_MDP_RDMA0_SOF ... CMDQ_EVENT_MDP_RDMA0_SW_RST_DONE_ENG_EVENT:
return "MDP";
case CMDQ_EVENT_DISP_OVL0_SOF ... CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_7:
return "DISP";
default:
return cmdq_thread_module_dispatch(gce_pa, thread);
}
}
EXPORT_SYMBOL(cmdq_event_module_dispatch);
u32 cmdq_util_hw_id(u32 pa)
{
return 0;
}
u32 cmdq_test_get_subsys_list(u32 **regs_out)
{
static u32 regs[] = {
0x14000100, /* mmsys MMSYS_CG_CON0 */
0x112300a0, /* msdc0 SW_DBG_SEL: LSB 16-bit only */
0x1121004c, /* To-do: audio AFE_I2S_CON3_OFFSET */
0x110020bc, /* uart0:LSB 1-bit only */
};
*regs_out = regs;
return ARRAY_SIZE(regs);
}
const char *cmdq_util_hw_name(void *chan)
{
return "GCE";
}
bool cmdq_thread_ddr_user_check(const s32 thread)
{
switch (thread) {
case 0 ... 6:
case 8 ... 9:
case 15:
return false;
default:
return true;
}
}
EXPORT_SYMBOL(cmdq_thread_ddr_user_check);
@@ -0,0 +1,323 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <dt-bindings/gce/mt6833-gce.h>
#include "../cmdq-util.h"
const char *cmdq_thread_module_dispatch(phys_addr_t gce_pa, s32 thread)
{
switch (thread) {
case 0 ... 6:
case 8 ... 9:
return "DISP";
case 7:
return "VDEC";
case 10:
case 19 ... 22:
return "MDP";
case 11:
case 13 ... 14:
case 16 ... 18:
return "ISP";
case 12:
return "VENC";
case 15:
return "CMDQ";
case 23:
return "SMI";
default:
return "CMDQ";
}
}
const char *cmdq_event_module_dispatch(phys_addr_t gce_pa, const u16 event,
s32 thread)
{
switch (event) {
case CMDQ_EVENT_ISP_FRAME_DONE_A:
case CMDQ_EVENT_ISP_FRAME_DONE_B:
return "ISP";
case CMDQ_EVENT_CAMSV1_PASS1_DONE:
case CMDQ_EVENT_CAMSV2_PASS1_DONE:
case CMDQ_EVENT_CAMSV3_PASS1_DONE:
case CMDQ_EVENT_MRAW_0_PASS1_DONE:
case CMDQ_EVENT_SENINF_CAM0_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM1_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM2_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM3_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM4_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM5_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM6_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM7_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM8_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM9_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM10_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM11_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM12_FIFO_FULL:
return "CAM";
case CMDQ_EVENT_TG_OVRUN_A_INT:
case CMDQ_EVENT_DMA_R1_ERROR_A_INT:
case CMDQ_EVENT_TG_OVRUN_B_INT:
case CMDQ_EVENT_DMA_R1_ERROR_B_INT:
case CMDQ_EVENT_TG_OVRUN_M0_INT:
case CMDQ_EVENT_DMA_R1_ERROR_M0_INT:
case CMDQ_EVENT_TG_GRABERR_M0_INT:
case CMDQ_EVENT_TG_GRABERR_A_INT:
case CMDQ_EVENT_CQ_VR_SNAP_A_INT:
case CMDQ_EVENT_TG_GRABERR_B_INT:
case CMDQ_EVENT_CQ_VR_SNAP_B_INT:
return "IMG";
case CMDQ_EVENT_VENC_CMDQ_FRAME_DONE:
case CMDQ_EVENT_VENC_CMDQ_PAUSE_DONE:
case CMDQ_EVENT_JPGENC_CMDQ_DONE:
case CMDQ_EVENT_VENC_CMDQ_MB_DONE:
case CMDQ_EVENT_VENC_CMDQ_128BYTE_CNT_DONE:
case CMDQ_EVENT_VENC_CMDQ_PPS_DONE:
case CMDQ_EVENT_VENC_CMDQ_SPS_DONE:
case CMDQ_EVENT_VENC_CMDQ_VPS_DONE:
return "VENC";
case CMDQ_EVENT_LINE_COUNT_THRESHOLD_INTERRUPT:
case CMDQ_EVENT_VDEC_INT:
case CMDQ_EVENT_VDEC_PAUSE:
case CMDQ_EVENT_VDEC_DEC_ERROR:
case CMDQ_EVENT_MDEC_TIMEOUT:
case CMDQ_EVENT_DRAM_ACCESS_DONE:
case CMDQ_EVENT_INI_FETCH_RDY:
case CMDQ_EVENT_PROCESS_FLAG:
case CMDQ_EVENT_SEARCH_START_CODE_DONE:
case CMDQ_EVENT_REF_REORDER_DONE:
case CMDQ_EVENT_WP_TBLE_DONE:
case CMDQ_EVENT_COUNT_SRAM_CLR_DONE:
case CMDQ_EVENT_GCE_CNT_OP_THRESHOLD:
return "VDEC";
case CMDQ_EVENT_DVP_DONE_ASYNC_SHOT:
case CMDQ_EVENT_DVS_DONE_ASYNC_SHOT:
return "IMG";
case CMDQ_EVENT_RSC_DONE:
return "RSC";
case CMDQ_EVENT_FE_DONE:
case CMDQ_EVENT_FDVT_DONE:
return "FDVT";
case CMDQ_EVENT_GCE_IMG2_EVENT0:
case CMDQ_EVENT_GCE_IMG2_EVENT1:
case CMDQ_EVENT_GCE_IMG2_EVENT2:
case CMDQ_EVENT_GCE_IMG2_EVENT3:
case CMDQ_EVENT_GCE_IMG2_EVENT4:
case CMDQ_EVENT_GCE_IMG2_EVENT5:
case CMDQ_EVENT_GCE_IMG2_EVENT6:
case CMDQ_EVENT_GCE_IMG2_EVENT7:
case CMDQ_EVENT_GCE_IMG2_EVENT8:
case CMDQ_EVENT_GCE_IMG2_EVENT9:
case CMDQ_EVENT_GCE_IMG2_EVENT10:
case CMDQ_EVENT_GCE_IMG2_EVENT11:
case CMDQ_EVENT_GCE_IMG2_EVENT12:
case CMDQ_EVENT_GCE_IMG2_EVENT13:
case CMDQ_EVENT_GCE_IMG2_EVENT14:
case CMDQ_EVENT_GCE_IMG2_EVENT15:
case CMDQ_EVENT_GCE_IMG2_EVENT16:
case CMDQ_EVENT_GCE_IMG2_EVENT17:
case CMDQ_EVENT_GCE_IMG2_EVENT18:
case CMDQ_EVENT_GCE_IMG2_EVENT19:
case CMDQ_EVENT_GCE_IMG2_EVENT20:
case CMDQ_EVENT_GCE_IMG2_EVENT21:
case CMDQ_EVENT_GCE_IMG2_EVENT22:
case CMDQ_EVENT_GCE_IMG2_EVENT23:
case CMDQ_EVENT_GCE_IMG1_EVENT0:
case CMDQ_EVENT_GCE_IMG1_EVENT1:
case CMDQ_EVENT_GCE_IMG1_EVENT2:
case CMDQ_EVENT_GCE_IMG1_EVENT3:
case CMDQ_EVENT_GCE_IMG1_EVENT4:
case CMDQ_EVENT_GCE_IMG1_EVENT5:
case CMDQ_EVENT_GCE_IMG1_EVENT6:
case CMDQ_EVENT_GCE_IMG1_EVENT7:
case CMDQ_EVENT_GCE_IMG1_EVENT8:
case CMDQ_EVENT_GCE_IMG1_EVENT9:
case CMDQ_EVENT_GCE_IMG1_EVENT10:
case CMDQ_EVENT_GCE_IMG1_EVENT11:
case CMDQ_EVENT_GCE_IMG1_EVENT12:
case CMDQ_EVENT_GCE_IMG1_EVENT13:
case CMDQ_EVENT_GCE_IMG1_EVENT14:
case CMDQ_EVENT_GCE_IMG1_EVENT15:
case CMDQ_EVENT_GCE_IMG1_EVENT16:
case CMDQ_EVENT_GCE_IMG1_EVENT17:
case CMDQ_EVENT_GCE_IMG1_EVENT18:
case CMDQ_EVENT_GCE_IMG1_EVENT19:
case CMDQ_EVENT_GCE_IMG1_EVENT20:
case CMDQ_EVENT_GCE_IMG1_EVENT21:
case CMDQ_EVENT_GCE_IMG1_EVENT22:
case CMDQ_EVENT_GCE_IMG1_EVENT23:
return "IMG";
case CMDQ_EVENT_MDP_RDMA0_SOF:
case CMDQ_EVENT_MDP_RDMA1_SOF:
case CMDQ_EVENT_MDP_AAL0_SOF:
case CMDQ_EVENT_MDP_AAL1_SOF:
case CMDQ_EVENT_MDP_HDR0_SOF:
case CMDQ_EVENT_MDP_RSZ0_SOF:
case CMDQ_EVENT_MDP_RSZ1_SOF:
case CMDQ_EVENT_MDP_WROT0_SOF:
case CMDQ_EVENT_MDP_WROT1_SOF:
case CMDQ_EVENT_MDP_TDSHP0_SOF:
case CMDQ_EVENT_MDP_TDSHP1_SOF:
return "MDP";
case CMDQ_EVENT_IMG_DL_RELAY0_SOF:
case CMDQ_EVENT_IMG_DL_RELAY1_SOF:
return "IMG";
case CMDQ_EVENT_MDP_COLOR0_SOF:
case CMDQ_EVENT_MDP_WROT3_FRAME_DONE:
case CMDQ_EVENT_MDP_WROT2_FRAME_DONE:
case CMDQ_EVENT_MDP_WROT1_FRAME_DONE:
case CMDQ_EVENT_MDP_WROT0_FRAME_DONE:
case CMDQ_EVENT_MDP_TDSHP3_FRAME_DONE:
case CMDQ_EVENT_MDP_TDSHP2_FRAME_DONE:
case CMDQ_EVENT_MDP_TDSHP1_FRAME_DONE:
case CMDQ_EVENT_MDP_TDSHP0_FRAME_DONE:
case CMDQ_EVENT_MDP_RSZ3_FRAME_DONE:
case CMDQ_EVENT_MDP_RSZ2_FRAME_DONE:
case CMDQ_EVENT_MDP_RSZ1_FRAME_DONE:
case CMDQ_EVENT_MDP_RSZ0_FRAME_DONE:
case CMDQ_EVENT_MDP_RDMA3_FRAME_DONE:
case CMDQ_EVENT_MDP_RDMA2_FRAME_DONE:
case CMDQ_EVENT_MDP_RDMA1_FRAME_DONE:
case CMDQ_EVENT_MDP_RDMA0_FRAME_DONE:
case CMDQ_EVENT_MDP_HDR1_FRAME_DONE:
case CMDQ_EVENT_MDP_HDR0_FRAME_DONE:
case CMDQ_EVENT_MDP_COLOR0_FRAME_DONE:
case CMDQ_EVENT_MDP_AAL3_FRAME_DONE:
case CMDQ_EVENT_MDP_AAL2_FRAME_DONE:
case CMDQ_EVENT_MDP_AAL1_FRAME_DONE:
case CMDQ_EVENT_MDP_AAL0_FRAME_DONE:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_0:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_1:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_2:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_3:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_4:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_5:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_6:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_7:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_8:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_9:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_10:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_11:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_12:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_13:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_14:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_15:
case CMDQ_EVENT_MDP_WROT3_SW_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_MDP_WROT2_SW_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_MDP_WROT1_SW_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_MDP_WROT0_SW_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_MDP_RDMA3_SW_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_MDP_RDMA2_SW_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_MDP_RDMA1_SW_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_MDP_RDMA0_SW_RST_DONE_ENG_EVENT:
return "MDP";
case CMDQ_EVENT_DISP_OVL0_SOF:
case CMDQ_EVENT_DISP_OVL0_2L_SOF:
case CMDQ_EVENT_DISP_RDMA0_SOF:
case CMDQ_EVENT_DISP_RSZ0_SOF:
case CMDQ_EVENT_DISP_COLOR0_SOF:
case CMDQ_EVENT_DISP_CCORR0_SOF:
case CMDQ_EVENT_DISP_CCORR1_SOF:
case CMDQ_EVENT_DISP_AAL0_SOF:
case CMDQ_EVENT_DISP_GAMMA0_SOF:
case CMDQ_EVENT_DISP_POSTMASK0_SOF:
case CMDQ_EVENT_DISP_DITHER0_SOF:
case CMDQ_EVENT_DISP_CM0_SOF:
case CMDQ_EVENT_DISP_SPR0_SOF:
case CMDQ_EVENT_DISP_DSC_WRAP0_SOF:
case CMDQ_EVENT_DSI0_SOF:
case CMDQ_EVENT_DISP_WDMA0_SOF:
case CMDQ_EVENT_DISP_PWM0_SOF:
case CMDQ_EVENT_DSI0_FRAME_DONE:
case CMDQ_EVENT_DISP_WDMA0_FRAME_DONE:
case CMDQ_EVENT_DISP_SPR0_FRAME_DONE:
case CMDQ_EVENT_DISP_RSZ0_FRAME_DONE:
case CMDQ_EVENT_DISP_RDMA0_FRAME_DONE:
case CMDQ_EVENT_DISP_POSTMASK0_FRAME_DONE:
case CMDQ_EVENT_DISP_OVL0_FRAME_DONE:
case CMDQ_EVENT_DISP_OVL0_2L_FRAME_DONE:
case CMDQ_EVENT_DISP_GAMMA0_FRAME_DONE:
case CMDQ_EVENT_DISP_DSC_WRAP0_CORE1_FRAME_DONE:
case CMDQ_EVENT_DISP_DSC_WRAP0_CORE0_FRAME_DONE:
case CMDQ_EVENT_DISP_DITHER0_FRAME_DONE:
case CMDQ_EVENT_DISP_COLOR0_FRAME_DONE:
case CMDQ_EVENT_DISP_CM0_FRAME_DONE:
case CMDQ_EVENT_DISP_CCORR1_FRAME_DONE:
case CMDQ_EVENT_DISP_CCORR0_FRAME_DONE:
case CMDQ_EVENT_DISP_AAL0_FRAME_DONE:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_0:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_1:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_2:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_3:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_4:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_5:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_6:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_7:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_8:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_9:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_10:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_11:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_12:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_13:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_14:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_15:
case CMDQ_EVENT_DSI0_TE_ENG_EVENT:
case CMDQ_EVENT_DSI0_IRQ_ENG_EVENT:
case CMDQ_EVENT_DSI0_DONE_ENG_EVENT:
case CMDQ_EVENT_DISP_WDMA0_SW_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_DISP_SMIASSERT_ENG_EVENT:
case CMDQ_EVENT_DISP_POSTMASK0_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_DISP_OVL0_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_DISP_OVL0_2L_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_0:
case CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_1:
case CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_2:
case CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_3:
case CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_4:
case CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_5:
case CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_6:
case CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_7:
return "DISP";
default:
return cmdq_thread_module_dispatch(gce_pa, thread);
}
}
EXPORT_SYMBOL(cmdq_event_module_dispatch);
u32 cmdq_util_hw_id(u32 pa)
{
return 0;
}
u32 cmdq_test_get_subsys_list(u32 **regs_out)
{
static u32 regs[] = {
0x14000100, /* mmsys MMSYS_CG_CON0 */
0x112300a0, /* msdc0 SW_DBG_SEL: LSB 16-bit only */
0x1121004c, /* To-do: audio AFE_I2S_CON3_OFFSET */
0x110020bc, /* uart0:LSB 1-bit only */
};
*regs_out = regs;
return ARRAY_SIZE(regs);
}
const char *cmdq_util_hw_name(void *chan)
{
return "GCE";
}
bool cmdq_thread_ddr_user_check(const s32 thread)
{
switch (thread) {
case 0 ... 6:
case 8 ... 9:
case 15:
return false;
default:
return true;
}
}
EXPORT_SYMBOL(cmdq_thread_ddr_user_check);
@@ -0,0 +1,297 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <dt-bindings/gce/mt6853-gce.h>
#include "../cmdq-util.h"
const char *cmdq_thread_module_dispatch(phys_addr_t gce_pa, s32 thread)
{
switch (thread) {
case 0 ... 6:
case 8 ... 9:
return "DISP";
case 7:
return "VDEC";
case 10:
case 19 ... 22:
return "MDP";
case 11:
case 13 ... 14:
case 16 ... 18:
return "ISP";
case 12:
return "VENC";
case 15:
return "CMDQ";
case 23:
return "SMI";
default:
return "CMDQ";
}
}
const char *cmdq_event_module_dispatch(phys_addr_t gce_pa, const u16 event,
s32 thread)
{
switch (event) {
case CMDQ_EVENT_ISP_FRAME_DONE_A:
case CMDQ_EVENT_ISP_FRAME_DONE_B:
return "ISP";
case CMDQ_EVENT_CAMSV1_PASS1_DONE:
case CMDQ_EVENT_CAMSV2_PASS1_DONE:
case CMDQ_EVENT_CAMSV3_PASS1_DONE:
case CMDQ_EVENT_MRAW_0_PASS1_DONE:
case CMDQ_EVENT_SENINF_CAM0_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM1_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM2_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM3_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM4_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM5_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM6_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM7_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM8_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM9_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM10_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM11_FIFO_FULL:
case CMDQ_EVENT_SENINF_CAM12_FIFO_FULL:
return "CAM";
case CMDQ_EVENT_TG_OVRUN_A_INT:
case CMDQ_EVENT_DMA_R1_ERROR_A_INT:
case CMDQ_EVENT_TG_OVRUN_B_INT:
case CMDQ_EVENT_DMA_R1_ERROR_B_INT:
case CMDQ_EVENT_TG_OVRUN_M0_INT:
case CMDQ_EVENT_DMA_R1_ERROR_M0_INT:
case CMDQ_EVENT_TG_GRABERR_M0_INT:
case CMDQ_EVENT_TG_GRABERR_A_INT:
case CMDQ_EVENT_CQ_VR_SNAP_A_INT:
case CMDQ_EVENT_TG_GRABERR_B_INT:
case CMDQ_EVENT_CQ_VR_SNAP_B_INT:
return "IMG";
case CMDQ_EVENT_VENC_CMDQ_FRAME_DONE:
case CMDQ_EVENT_VENC_CMDQ_PAUSE_DONE:
case CMDQ_EVENT_JPGENC_CMDQ_DONE:
case CMDQ_EVENT_VENC_CMDQ_MB_DONE:
case CMDQ_EVENT_VENC_CMDQ_128BYTE_CNT_DONE:
case CMDQ_EVENT_VENC_CMDQ_PPS_DONE:
case CMDQ_EVENT_VENC_CMDQ_SPS_DONE:
case CMDQ_EVENT_VENC_CMDQ_VPS_DONE:
return "VENC";
case CMDQ_EVENT_VDEC_CORE0_SOF_0:
case CMDQ_EVENT_VDEC_CORE0_FRAME_DONE_0:
case CMDQ_EVENT_VDEC_CORE0_FRAME_DONE_1:
case CMDQ_EVENT_VDEC_CORE0_FRAME_DONE_2:
case CMDQ_EVENT_VDEC_CORE0_FRAME_DONE_3:
case CMDQ_EVENT_VDEC_CORE0_FRAME_DONE_4:
case CMDQ_EVENT_VDEC_CORE0_FRAME_DONE_5:
case CMDQ_EVENT_VDEC_CORE0_FRAME_DONE_6:
case CMDQ_EVENT_VDEC_CORE0_ENG_EVENT_0:
case CMDQ_EVENT_VDEC_CORE0_ENG_EVENT_1:
case CMDQ_EVENT_VDEC_CORE0_ENG_EVENT_2:
case CMDQ_EVENT_VDEC_CORE0_ENG_EVENT_3:
case CMDQ_EVENT_VDEC_CORE0_ENG_EVENT_4:
case CMDQ_EVENT_VDEC_CORE0_ENG_EVENT_5:
case CMDQ_EVENT_VDEC_CORE0_ENG_EVENT_6:
case CMDQ_EVENT_VDEC_CORE0_ENG_EVENT_7:
return "VDEC";
case CMDQ_EVENT_FDVT_DONE:
return "FDVT";
case CMDQ_EVENT_RSC_DONE:
return "RSC";
case CMDQ_EVENT_DVS_DONE_ASYNC_SHOT:
case CMDQ_EVENT_DVP_DONE_ASYNC_SHOT:
case CMDQ_EVENT_IMG2_MFB_DONE_LINK_MISC:
case CMDQ_EVENT_IMG2_WPE_A_DONE_LINK_MISC:
case CMDQ_EVENT_IMG2_MSS_DONE_LINK_MISC:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_0:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_1:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_2:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_3:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_4:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_5:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_6:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_7:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_8:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_9:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_10:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_11:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_12:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_13:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_14:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_15:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_16:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_17:
case CMDQ_EVENT_IMG1_DIP_FRAME_DONE_P2_18:
case CMDQ_EVENT_IMG1_DIP_DMA_ERR_EVENT:
return "IMG";
case CMDQ_EVENT_MDP_RDMA0_SOF:
case CMDQ_EVENT_MDP_RDMA1_SOF:
case CMDQ_EVENT_MDP_AAL0_SOF:
case CMDQ_EVENT_MDP_AAL1_SOF:
case CMDQ_EVENT_MDP_HDR0_SOF:
case CMDQ_EVENT_MDP_RSZ0_SOF:
case CMDQ_EVENT_MDP_RSZ1_SOF:
case CMDQ_EVENT_MDP_WROT0_SOF:
case CMDQ_EVENT_MDP_WROT1_SOF:
case CMDQ_EVENT_MDP_TDSHP0_SOF:
case CMDQ_EVENT_MDP_TDSHP1_SOF:
return "MDP";
case CMDQ_EVENT_IMG_DL_RELAY0_SOF:
case CMDQ_EVENT_IMG_DL_RELAY1_SOF:
return "IMG";
case CMDQ_EVENT_MDP_COLOR0_SOF:
case CMDQ_EVENT_MDP_WROT1_FRAME_DONE:
case CMDQ_EVENT_MDP_WROT0_FRAME_DONE:
case CMDQ_EVENT_MDP_TDSHP1_FRAME_DONE:
case CMDQ_EVENT_MDP_TDSHP0_FRAME_DONE:
case CMDQ_EVENT_MDP_RSZ1_FRAME_DONE:
case CMDQ_EVENT_MDP_RSZ0_FRAME_DONE:
case CMDQ_EVENT_MDP_RDMA1_FRAME_DONE:
case CMDQ_EVENT_MDP_RDMA0_FRAME_DONE:
case CMDQ_EVENT_MDP_HDR0_FRAME_DONE:
case CMDQ_EVENT_MDP_COLOR0_FRAME_DONE:
case CMDQ_EVENT_MDP_AAL1_FRAME_DONE:
case CMDQ_EVENT_MDP_AAL0_FRAME_DONE:
return "MDP";
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_0:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_1:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_2:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_3:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_4:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_5:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_6:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_7:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_8:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_9:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_10:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_11:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_12:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_13:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_14:
case CMDQ_EVENT_DISP_STREAM_DONE_ENG_EVENT_15:
return "DISP";
case CMDQ_EVENT_MDP_WROT1_SW_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_MDP_WROT0_SW_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_MDP_RDMA1_SW_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_MDP_RDMA0_SW_RST_DONE_ENG_EVENT:
return "MDP";
case CMDQ_EVENT_DISP_OVL0_SOF:
case CMDQ_EVENT_DISP_OVL0_2L_SOF:
case CMDQ_EVENT_DISP_RDMA0_SOF:
case CMDQ_EVENT_DISP_RSZ0_SOF:
case CMDQ_EVENT_DISP_COLOR0_SOF:
case CMDQ_EVENT_DISP_CCORR0_SOF:
case CMDQ_EVENT_DISP_CCORR1_SOF:
case CMDQ_EVENT_DISP_AAL0_SOF:
case CMDQ_EVENT_DISP_GAMMA0_SOF:
case CMDQ_EVENT_DISP_POSTMASK0_SOF:
case CMDQ_EVENT_DISP_DITHER0_SOF:
case CMDQ_EVENT_DISP_CM0_SOF:
case CMDQ_EVENT_DISP_SPR0_SOF:
case CMDQ_EVENT_DISP_DSC_WRAP0_SOF:
case CMDQ_EVENT_DSI0_SOF:
case CMDQ_EVENT_DISP_WDMA0_SOF:
case CMDQ_EVENT_DISP_PWM0_SOF:
case CMDQ_EVENT_MUTEX_SOF_17:
case CMDQ_EVENT_MUTEX_SOF_18:
case CMDQ_EVENT_MUTEX_SOF_19:
case CMDQ_EVENT_MUTEX_SOF_20:
case CMDQ_EVENT_MUTEX_SOF_21:
case CMDQ_EVENT_MUTEX_SOF_22:
case CMDQ_EVENT_MUTEX_SOF_23:
case CMDQ_EVENT_MUTEX_SOF_24:
case CMDQ_EVENT_MUTEX_SOF_25:
case CMDQ_EVENT_DSI0_FRAME_DONE:
case CMDQ_EVENT_DISP_WDMA0_FRAME_DONE:
case CMDQ_EVENT_DISP_SPR0_FRAME_DONE:
case CMDQ_EVENT_DISP_RSZ0_FRAME_DONE:
case CMDQ_EVENT_DISP_RDMA0_FRAME_DONE:
case CMDQ_EVENT_DISP_POSTMASK0_FRAME_DONE:
case CMDQ_EVENT_DISP_OVL0_FRAME_DONE:
case CMDQ_EVENT_DISP_OVL0_2L_FRAME_DONE:
case CMDQ_EVENT_DISP_GAMMA0_FRAME_DONE:
case CMDQ_EVENT_DISP_DSC_WRAP0_CORE1_FRAME_DONE:
case CMDQ_EVENT_DISP_DSC_WRAP0_CORE0_FRAME_DONE:
case CMDQ_EVENT_DISP_DITHER0_FRAME_DONE:
case CMDQ_EVENT_DISP_COLOR0_FRAME_DONE:
case CMDQ_EVENT_DISP_CM0_FRAME_DONE:
case CMDQ_EVENT_DISP_CCORR1_FRAME_DONE:
case CMDQ_EVENT_DISP_CCORR0_FRAME_DONE:
case CMDQ_EVENT_DISP_AAL0_FRAME_DONE:
return "DISP";
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_0:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_1:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_2:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_3:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_4:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_5:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_6:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_7:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_8:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_9:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_10:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_11:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_12:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_13:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_14:
case CMDQ_EVENT_MDP_STREAM_DONE_ENG_EVENT_15:
return "MDP";
case CMDQ_EVENT_DSI0_TE_ENG_EVENT:
case CMDQ_EVENT_DSI0_IRQ_ENG_EVENT:
case CMDQ_EVENT_DSI0_DONE_ENG_EVENT:
case CMDQ_EVENT_DISP_WDMA0_SW_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_DISP_SMIASSERT_ENG_EVENT:
case CMDQ_EVENT_DISP_POSTMASK0_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_DISP_OVL0_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_DISP_OVL0_2L_RST_DONE_ENG_EVENT:
case CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_0:
case CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_1:
case CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_2:
case CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_3:
case CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_4:
case CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_5:
case CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_6:
case CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_7:
return "DISP";
default:
return cmdq_thread_module_dispatch(gce_pa, thread);
}
}
EXPORT_SYMBOL(cmdq_event_module_dispatch);
u32 cmdq_util_hw_id(u32 pa)
{
return 0;
}
u32 cmdq_test_get_subsys_list(u32 **regs_out)
{
static u32 regs[] = {
0x14000100, /* mmsys MMSYS_CG_CON0 */
0x11f600a0, /* msdc0 SW_DBG_SEL */
0x1121004c, /* audio AFE_I2S_CON3_OFFSET */
0x110020bc, /* uart0 */
};
*regs_out = regs;
return ARRAY_SIZE(regs);
}
const char *cmdq_util_hw_name(void *chan)
{
return "GCE";
}
bool cmdq_thread_ddr_user_check(const s32 thread)
{
switch (thread) {
case 0 ... 6:
case 8 ... 9:
case 15:
return false;
default:
return true;
}
}
EXPORT_SYMBOL(cmdq_thread_ddr_user_check);
@@ -0,0 +1,100 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <dt-bindings/gce/mt6873-gce.h>
#include "../cmdq-util.h"
const char *cmdq_thread_module_dispatch(phys_addr_t gce_pa, s32 thread)
{
switch (thread) {
case 0 ... 6:
case 8 ... 9:
return "DISP";
case 7:
return "VDEC";
case 10:
case 19 ... 22:
return "MDP";
case 11:
case 13 ... 14:
case 16 ... 18:
return "ISP";
case 12:
return "VENC";
case 15:
return "CMDQ";
case 23:
return "SMI";
default:
return "CMDQ";
}
}
const char *cmdq_event_module_dispatch(phys_addr_t gce_pa, const u16 event,
s32 thread)
{
switch (event) {
case CMDQ_EVENT_VDEC_LAT_SOF_0 ... CMDQ_EVENT_VDEC_LAT_ENG_EVENT_7:
case CMDQ_EVENT_VDEC_CORE0_SOF_0 ... CMDQ_EVENT_VDEC_CORE0_ENG_EVENT_7:
return "VDEC";
case CMDQ_EVENT_ISP_FRAME_DONE_A ... CMDQ_EVENT_CQ_VR_SNAP_C_INT:
return "ISP";
case CMDQ_EVENT_VENC_CMDQ_FRAME_DONE ... CMDQ_EVENT_VENC_CMDQ_VPS_DONE:
return "VENC";
case CMDQ_EVENT_FDVT_DONE:
return "FDVT";
case CMDQ_EVENT_RSC_DONE:
return "RSC";
case CMDQ_EVENT_IMG2_DIP_FRAME_DONE_P2_0
... CMDQ_EVENT_IMG1_MSS_DONE_LINK_MISC:
return "DIP";
case CMDQ_EVENT_MDP_RDMA0_SOF
... CMDQ_EVENT_MDP_RDMA0_SW_RST_DONE_ENG_EVENT:
return "MDP";
case CMDQ_EVENT_DISP_OVL0_SOF ... CMDQ_EVENT_BUF_UNDERRUN_ENG_EVENT_7:
case CMDQ_SYNC_TOKEN_CONFIG_DIRTY ... CMDQ_SYNC_TOKEN_CABC_EOF:
return "DISP";
default:
return cmdq_thread_module_dispatch(gce_pa, thread);
}
}
EXPORT_SYMBOL(cmdq_event_module_dispatch);
u32 cmdq_util_hw_id(u32 pa)
{
return 0;
}
u32 cmdq_test_get_subsys_list(u32 **regs_out)
{
static u32 regs[] = {
0x14000100, /* mmsys MMSYS_CG_CON0 */
0x11f600a0, /* msdc0 SW_DBG_SEL */
0x1121004c, /* audio AFE_I2S_CON3_OFFSET */
0x110020bc, /* uart0 */
};
*regs_out = regs;
return ARRAY_SIZE(regs);
}
const char *cmdq_util_hw_name(void *chan)
{
return "GCE";
}
bool cmdq_thread_ddr_user_check(const s32 thread)
{
switch (thread) {
case 0 ... 6:
case 8 ... 9:
case 15:
return false;
default:
return true;
}
}
EXPORT_SYMBOL(cmdq_thread_ddr_user_check);
@@ -0,0 +1,107 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <dt-bindings/gce/mt6877-gce.h>
#include "../cmdq-util.h"
const char *cmdq_thread_module_dispatch(phys_addr_t gce_pa, s32 thread)
{
switch (thread) {
case 0 ... 6:
case 8 ... 9:
return "DISP";
case 7:
return "VDEC";
case 10:
case 19 ... 22:
return "MDP";
case 11:
case 13 ... 14:
case 16 ... 18:
return "ISP";
case 12:
return "VENC";
case 15:
return "CMDQ";
case 23:
return "SMI";
default:
return "CMDQ";
}
}
const char *cmdq_event_module_dispatch(phys_addr_t gce_pa, const u16 event,
s32 thread)
{
switch (event) {
case CMDQ_EVENT_VENC_CMDQ_FRAME_DONE ... CMDQ_EVENT_VENC_CMDQ_VPS_DONE:
return "VENC";
case CMDQ_EVENT_LINE_COUNT_THRESHOLD_INTERRUPT
... CMDQ_EVENT_GCE_CNT_OP_THRESHOLD:
return "VDEC";
case CMDQ_EVENT_FDVT_DONE:
return "FDVT";
case CMDQ_EVENT_RSC_DONE:
return "RSC";
case CMDQ_EVENT_DVS_DONE:
return "DVS";
case CMDQ_EVENT_DVP_DONE:
return "DVP";
case CMDQ_EVENT_MFB_DONE_LINK_MISC:
return "MFB";
case CMDQ_EVENT_WPE_A_DONE_LINE_MISC:
return "WPE";
case CMDQ_EVENT_MSS_DONE_LINK_MISC:
return "MSS";
case CMDQ_EVENT_DIP_FRAME_DONE_P2_0
... CMDQ_EVENT_DIP_DMA_ERR_EVENT:
return "DIP";
case CMDQ_EVENT_MDP_RDMA0_SOF
... CMDQ_EVENT_MDP_RDMA0_SW_RST_DONE_ENG_EVENT:
return "MDP";
case CMDQ_EVENT_DISP_OVL0_SOF
... CMDQ_EVENT_DISP_BUF_UNDERRUN_ENG_EVENT_7:
return "DISP";
default:
return cmdq_thread_module_dispatch(gce_pa, thread);
}
}
EXPORT_SYMBOL(cmdq_event_module_dispatch);
u32 cmdq_util_hw_id(u32 pa)
{
return 0;
}
u32 cmdq_test_get_subsys_list(u32 **regs_out)
{
static u32 regs[] = {
0x14000100, /* mmsys MMSYS_CG_CON0 */
0x112300a0, /* msdc0 SW_DBG_SEL: LSB 16-bit only */
0x1121004c, /* To-do: audio AFE_I2S_CON3_OFFSET */
0x110020bc, /* uart0:LSB 1-bit only */
};
*regs_out = regs;
return ARRAY_SIZE(regs);
}
const char *cmdq_util_hw_name(void *chan)
{
return "GCE";
}
bool cmdq_thread_ddr_user_check(const s32 thread)
{
switch (thread) {
case 0 ... 6:
case 8 ... 9:
case 15:
return false;
default:
return true;
}
}
EXPORT_SYMBOL(cmdq_thread_ddr_user_check);
@@ -0,0 +1,179 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <dt-bindings/gce/mt6885-gce.h>
#include "../cmdq-util.h"
#define GCE_D_PA 0x10228000
#define GCE_M_PA 0x10318000
const char *cmdq_thread_module_dispatch(phys_addr_t gce_pa, s32 thread)
{
if (gce_pa == GCE_D_PA) {
switch (thread) {
case 0 ... 9:
return "DISP";
case 16:
return "VDEC";
case 17 ... 18:
return "VENC";
case 23:
return "CMDQ-TEST";
default:
return "CMDQ";
}
}
return "CMDQ";
}
const char *cmdq_event_module_dispatch(phys_addr_t gce_pa, const u16 event,
s32 thread)
{
switch (event) {
case CMDQ_SYNC_TOKEN_CONFIG_DIRTY:
case CMDQ_SYNC_TOKEN_STREAM_EOF:
case CMDQ_SYNC_TOKEN_ESD_EOF:
case CMDQ_SYNC_TOKEN_STREAM_BLOCK:
case CMDQ_SYNC_TOKEN_CABC_EOF:
return "DISP";
case CMDQ_SYNC_TOKEN_MSS:
return "MSS";
case CMDQ_SYNC_TOKEN_MSF:
return "MSF";
case CMDQ_EVENT_GPR_TIMER ... CMDQ_EVENT_GPR_TIMER+32:
return cmdq_thread_module_dispatch(gce_pa, thread);
}
if (gce_pa == GCE_D_PA) // GCE-D
switch (event) {
case CMDQ_EVENT_DISP_OVL0_SOF ... CMDQ_EVENT_DP_INTF_SOF:
case CMDQ_EVENT_DISP_RDMA4_SOF
... CMDQ_EVENT_DISP_UFBC_WDMA1_SOF:
case CMDQ_EVENT_DSI1_FRAME_DONE
... CMDQ_EVENT_DISP_OVL0_2L_RST_DONE:
case CMDQ_EVENT_DISP_POSTMASK1_RST_DONE
... CMDQ_EVENT_DISP_POSTMASK0_RST_DONE:
return "DISP";
case CMDQ_EVENT_MDP_AAL4_SOF ... CMDQ_EVENT_MDP_TDSHP5_SOF:
case CMDQ_EVENT_MDP_TDSHP5_FRAME_DONE
... CMDQ_EVENT_MDP_AAL4_FRAME_DONE:
return "MDP";
case CMDQ_EVENT_DP_VDE_END ... CMDQ_EVENT_DP_TARGET_LINE:
case CMDQ_EVENT_VDEC_LAT_SOF_0 ... CMDQ_EVENT_VDEC_7:
case CMDQ_EVENT_VDEC_CORE0_SOF_0
... CMDQ_EVENT_VDEC_CORE0_7:
return "VDEC";
case CMDQ_EVENT_VENC_CMDQ_FRAME_DONE_C1
... CMDQ_EVENT_VENC_CMDQ_PAUSE_DONE_C1:
case CMDQ_EVENT_VENC_CMDQ_MB_DONE_C1
... CMDQ_EVENT_VENC_CMDQ_128BYTE_CNT_DONE_C1:
case CMDQ_EVENT_VENC_C0_CMDQ_WP_2ND_STAGE_DONE_C1
... CMDQ_EVENT_VENC_CMDQ_PAUSE_DONE:
case CMDQ_EVENT_VENC_CMDQ_MB_DONE
... CMDQ_EVENT_VENC_CMDQ_128BYTE_CNT_DONE:
case CMDQ_EVENT_VENC_C0_CMDQ_WP_2ND_STAGE_DONE
... CMDQ_EVENT_VENC_C0_CMDQ_WP_3RD_STAGE_DONE:
return "VENC";
case CMDQ_EVENT_JPGENC_CMDQ_DONE_C1:
case CMDQ_EVENT_JPGENC_CMDQ_DONE:
return "JPGENC";
case CMDQ_EVENT_JPGDEC_CMDQ_DONE_C1
... CMDQ_EVENT_JPGDEC_C1_INSUFF_CMDQ_DONE_C1:
case CMDQ_EVENT_JPGDEC_CMDQ_DONE
... CMDQ_EVENT_JPGDEC_C1_INSUFF_CMDQ_DONE:
return "JPGDEC";
default:
return "CMDQ";
}
if (gce_pa == GCE_M_PA) // GCE-M
switch (event) {
case CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_0
... CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_23:
case CMDQ_EVENT_IMG_DL_RELAY0_SOF
... CMDQ_EVENT_IMG_DL_RELAY3_SOF:
return "IMG";
case CMDQ_EVENT_IPE_EVENT_TX_FRAME_DONE_0
... CMDQ_EVENT_IPE_EVENT_TX_FRAME_DONE_4:
return "IPE";
case CMDQ_EVENT_ISP_FRAME_DONE_A
... CMDQ_EVENT_ISP_FRAME_DONE_C:
return "ISP";
case CMDQ_EVENT_CAMSV0_PASS1_DONE
... CMDQ_EVENT_SENINF_CAM12_FIFO_FULL:
return "CAM";
case CMDQ_EVENT_MDP_RDMA0_SOF ... CMDQ_EVENT_MDP_TCC3_SOF:
case CMDQ_EVENT_MDP_WROT3_FRAME_DONE
... CMDQ_EVENT_MDP_RDMA0_SW_RST_DONE:
return "MDP";
default:
return "CMDQ";
}
return "CMDQ";
}
EXPORT_SYMBOL(cmdq_event_module_dispatch);
u32 cmdq_util_hw_id(u32 pa)
{
switch (pa) {
case GCE_D_PA:
return 0;
case GCE_M_PA:
return 1;
default:
cmdq_err("unknown addr:%x", pa);
}
return 0;
}
u32 cmdq_test_get_subsys_list(u32 **regs_out)
{
static u32 regs[] = {
0x1f016f00, /* VIDO_BASE_ADDR */
0x14116100, /* MMSYS_CG_CON0 */
0x1602f10c, /* VDEC_AXI_ASIF_CFG0 */
0x17000104, /* Reserved (venc_top) */
0x17800104, /* Reserved (venc_core1) */
0x1a000370, /* CAMSYS_APB3_SPARE */
0x15020000, /* IMGSYS1 */
0x15820000, /* IMGSYS2 */
0x1B000000, /* IPESYS */
0x112300A0, /* perisys apb msdc0 SW_DBG_SEL */
0x1121004C, /* perisys apb audio0 AFE_I2S_CON3_OFFSET */
0x110020BC, /* perisys apb uart0 UART */
};
*regs_out = regs;
return ARRAY_SIZE(regs);
}
const char *cmdq_util_hw_name(void *chan)
{
u32 hw_id = cmdq_util_hw_id((u32)cmdq_mbox_get_base_pa(chan));
if (hw_id == 0)
return "GCE-D";
if (hw_id == 1)
return "GCE-M";
return "CMDQ";
}
@@ -0,0 +1,179 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <dt-bindings/gce/mt6885-gce.h>
#include "../cmdq-util.h"
#define GCE_D_PA 0x10228000
#define GCE_M_PA 0x10318000
const char *cmdq_thread_module_dispatch(phys_addr_t gce_pa, s32 thread)
{
if (gce_pa == GCE_D_PA) {
switch (thread) {
case 0 ... 9:
return "DISP";
case 16:
return "VDEC";
case 17 ... 18:
return "VENC";
case 23:
return "CMDQ-TEST";
default:
return "CMDQ";
}
}
return "CMDQ";
}
const char *cmdq_event_module_dispatch(phys_addr_t gce_pa, const u16 event,
s32 thread)
{
switch (event) {
case CMDQ_SYNC_TOKEN_CONFIG_DIRTY:
case CMDQ_SYNC_TOKEN_STREAM_EOF:
case CMDQ_SYNC_TOKEN_ESD_EOF:
case CMDQ_SYNC_TOKEN_STREAM_BLOCK:
case CMDQ_SYNC_TOKEN_CABC_EOF:
return "DISP";
case CMDQ_SYNC_TOKEN_MSS:
return "MSS";
case CMDQ_SYNC_TOKEN_MSF:
return "MSF";
case CMDQ_EVENT_GPR_TIMER ... CMDQ_EVENT_GPR_TIMER+32:
return cmdq_thread_module_dispatch(gce_pa, thread);
}
if (gce_pa == GCE_D_PA) // GCE-D
switch (event) {
case CMDQ_EVENT_DISP_OVL0_SOF ... CMDQ_EVENT_DP_INTF_SOF:
case CMDQ_EVENT_DISP_RDMA4_SOF
... CMDQ_EVENT_DISP_UFBC_WDMA1_SOF:
case CMDQ_EVENT_DSI1_FRAME_DONE
... CMDQ_EVENT_DISP_OVL0_2L_RST_DONE:
case CMDQ_EVENT_DISP_POSTMASK1_RST_DONE
... CMDQ_EVENT_DISP_POSTMASK0_RST_DONE:
return "DISP";
case CMDQ_EVENT_MDP_AAL4_SOF ... CMDQ_EVENT_MDP_TDSHP5_SOF:
case CMDQ_EVENT_MDP_TDSHP5_FRAME_DONE
... CMDQ_EVENT_MDP_AAL4_FRAME_DONE:
return "MDP";
case CMDQ_EVENT_DP_VDE_END ... CMDQ_EVENT_DP_TARGET_LINE:
case CMDQ_EVENT_VDEC_LAT_SOF_0 ... CMDQ_EVENT_VDEC_7:
case CMDQ_EVENT_VDEC_CORE0_SOF_0
... CMDQ_EVENT_VDEC_CORE0_7:
return "VDEC";
case CMDQ_EVENT_VENC_CMDQ_FRAME_DONE_C1
... CMDQ_EVENT_VENC_CMDQ_PAUSE_DONE_C1:
case CMDQ_EVENT_VENC_CMDQ_MB_DONE_C1
... CMDQ_EVENT_VENC_CMDQ_128BYTE_CNT_DONE_C1:
case CMDQ_EVENT_VENC_C0_CMDQ_WP_2ND_STAGE_DONE_C1
... CMDQ_EVENT_VENC_CMDQ_PAUSE_DONE:
case CMDQ_EVENT_VENC_CMDQ_MB_DONE
... CMDQ_EVENT_VENC_CMDQ_128BYTE_CNT_DONE:
case CMDQ_EVENT_VENC_C0_CMDQ_WP_2ND_STAGE_DONE
... CMDQ_EVENT_VENC_C0_CMDQ_WP_3RD_STAGE_DONE:
return "VENC";
case CMDQ_EVENT_JPGENC_CMDQ_DONE_C1:
case CMDQ_EVENT_JPGENC_CMDQ_DONE:
return "JPGENC";
case CMDQ_EVENT_JPGDEC_CMDQ_DONE_C1
... CMDQ_EVENT_JPGDEC_C1_INSUFF_CMDQ_DONE_C1:
case CMDQ_EVENT_JPGDEC_CMDQ_DONE
... CMDQ_EVENT_JPGDEC_C1_INSUFF_CMDQ_DONE:
return "JPGDEC";
default:
return "CMDQ";
}
if (gce_pa == GCE_M_PA) // GCE-M
switch (event) {
case CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_0
... CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_23:
case CMDQ_EVENT_IMG_DL_RELAY0_SOF
... CMDQ_EVENT_IMG_DL_RELAY3_SOF:
return "IMG";
case CMDQ_EVENT_IPE_EVENT_TX_FRAME_DONE_0
... CMDQ_EVENT_IPE_EVENT_TX_FRAME_DONE_4:
return "IPE";
case CMDQ_EVENT_ISP_FRAME_DONE_A
... CMDQ_EVENT_ISP_FRAME_DONE_C:
return "ISP";
case CMDQ_EVENT_CAMSV0_PASS1_DONE
... CMDQ_EVENT_SENINF_CAM12_FIFO_FULL:
return "CAM";
case CMDQ_EVENT_MDP_RDMA0_SOF ... CMDQ_EVENT_MDP_TCC3_SOF:
case CMDQ_EVENT_MDP_WROT3_FRAME_DONE
... CMDQ_EVENT_MDP_RDMA0_SW_RST_DONE:
return "MDP";
default:
return "CMDQ";
}
return "CMDQ";
}
EXPORT_SYMBOL(cmdq_event_module_dispatch);
u32 cmdq_util_hw_id(u32 pa)
{
switch (pa) {
case GCE_D_PA:
return 0;
case GCE_M_PA:
return 1;
default:
cmdq_err("unknown addr:%x", pa);
}
return 0;
}
u32 cmdq_test_get_subsys_list(u32 **regs_out)
{
static u32 regs[] = {
0x1f016f00, /* VIDO_BASE_ADDR */
0x14116100, /* MMSYS_CG_CON0 */
0x1602f10c, /* VDEC_AXI_ASIF_CFG0 */
0x17000104, /* Reserved (venc_top) */
0x17800104, /* Reserved (venc_core1) */
0x1a000370, /* CAMSYS_APB3_SPARE */
0x15020000, /* IMGSYS1 */
0x15820000, /* IMGSYS2 */
0x1B000000, /* IPESYS */
0x112300A0, /* perisys apb msdc0 SW_DBG_SEL */
0x1121004C, /* perisys apb audio0 AFE_I2S_CON3_OFFSET */
0x110020BC, /* perisys apb uart0 UART */
};
*regs_out = regs;
return ARRAY_SIZE(regs);
}
const char *cmdq_util_hw_name(void *chan)
{
u32 hw_id = cmdq_util_hw_id((u32)cmdq_mbox_get_base_pa(chan));
if (hw_id == 0)
return "GCE-D";
if (hw_id == 1)
return "GCE-M";
return "CMDQ";
}
@@ -0,0 +1,21 @@
#
# Copyright (C) 2019 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.
#
ifeq ($(CONFIG_MTK_GCOV_KERNEL),y)
GCOV_PROFILE := y
endif
# common driver code for MDP
# driver module
obj-y += mdp_fence.o
@@ -0,0 +1,467 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/sync_file.h>
#include <linux/debugfs.h>
#include <linux/miscdevice.h>
//#include "sync_debug.h"
#define CREATE_TRACE_POINTS
//#include "sync_trace.h"
/*
* MDP SYNC validation framework
*
* A sync object driver that uses a 32bit counter to coordinate
* synchronization. Useful when there is no hardware primitive backing
* the synchronization.
*
* To start the framework just open:
*
* dev/mdp_sync
*
* That will create a sync timeline, all fences created under this timeline
* file descriptor will belong to the this timeline.
*
* The 'mdp_sync' file can be opened many times as to create different
* timelines.
*
* Fences can be created with MDP_SYNC_IOC_CREATE_FENCE ioctl with struct
* mdp_sync_ioctl_create_fence as parameter.
*
* To increment the timeline counter, MDP_SYNC_IOC_INC ioctl should be used
* with the increment as u32. This will update the last signaled value
* from the timeline and signal any fence that has a seqno smaller or equal
* to it.
*
* struct mdp_sync_ioctl_create_fence
* @value: the seqno to initialise the fence with
* @name: the name of the new sync point
* @fence: return the fd of the new sync_file with the created fence
*/
struct mdp_sync_create_fence_data {
__u32 value;
char name[32];
__s32 dma_fence; /* fd of new fence */
};
#define MDP_SYNC_IOC_MAGIC 'W'
#define MDP_SYNC_IOC_CREATE_FENCE _IOWR(MDP_SYNC_IOC_MAGIC, 0,\
struct mdp_sync_create_fence_data)
#define MDP_SYNC_IOC_INC _IOW(MDP_SYNC_IOC_MAGIC, 1, __u32)
/**
* struct sync_timeline - sync object
* @kref: reference count on fence.
* @name: name of the sync_timeline. Useful for debugging
* @lock: lock protecting @pt_list and @value
* @pt_tree: rbtree of active (unsignaled/errored) sync_pts
* @pt_list: list of active (unsignaled/errored) sync_pts
* @sync_timeline_list: membership in global sync_timeline_list
*/
struct sync_timeline {
struct kref kref;
char name[32];
/* protected by lock */
u64 context;
int value;
struct rb_root pt_tree;
struct list_head pt_list;
spinlock_t lock;
struct list_head sync_timeline_list;
};
static inline struct sync_timeline *fence_parent(struct dma_fence *dma_fence)
{
return container_of(dma_fence->lock, struct sync_timeline, lock);
}
/**
* struct sync_pt - sync_pt object
* @base: base dma_fence object
* @link: link on the sync timeline's list
* @node: node in the sync timeline's tree
*/
struct sync_pt {
struct dma_fence base;
struct list_head link;
struct rb_node node;
};
static const struct dma_fence_ops timeline_dma_fence_ops;
static inline struct sync_pt *fence_to_sync_pt(struct dma_fence *dma_fence)
{
if (dma_fence->ops != &timeline_dma_fence_ops)
return NULL;
return container_of(dma_fence, struct sync_pt, base);
}
/**
* mdp_timeline_create() - creates a sync object
* @name: sync_timeline name
*
* Creates a new sync_timeline. Returns the sync_timeline object or NULL in
* case of error.
*/
struct sync_timeline *mdp_timeline_create(const char *name)
{
struct sync_timeline *obj;
obj = kzalloc(sizeof(*obj), GFP_KERNEL);
if (!obj)
return NULL;
kref_init(&obj->kref);
obj->context = dma_fence_context_alloc(1);
strlcpy(obj->name, name, sizeof(obj->name));
obj->pt_tree = RB_ROOT;
INIT_LIST_HEAD(&obj->pt_list);
spin_lock_init(&obj->lock);
//sync_timeline_debug_add(obj);
return obj;
}
static void sync_timeline_free(struct kref *kref)
{
struct sync_timeline *obj =
container_of(kref, struct sync_timeline, kref);
//sync_timeline_debug_remove(obj);
kfree(obj);
}
static void sync_timeline_get(struct sync_timeline *obj)
{
kref_get(&obj->kref);
}
static void sync_timeline_put(struct sync_timeline *obj)
{
kref_put(&obj->kref, sync_timeline_free);
}
static const char *timeline_fence_get_driver_name(struct dma_fence *dma_fence)
{
return "mdp_sync";
}
static const char *timeline_fence_get_timeline_name(struct dma_fence *dma_fence)
{
struct sync_timeline *parent = fence_parent(dma_fence);
return parent->name;
}
static void timeline_fence_release(struct dma_fence *dma_fence)
{
struct sync_pt *pt = fence_to_sync_pt(dma_fence);
struct sync_timeline *parent = fence_parent(dma_fence);
unsigned long flags;
spin_lock_irqsave(dma_fence->lock, flags);
if (pt && !list_empty(&pt->link)) {
list_del(&pt->link);
rb_erase(&pt->node, &parent->pt_tree);
}
spin_unlock_irqrestore(dma_fence->lock, flags);
sync_timeline_put(parent);
dma_fence_free(dma_fence);
}
static bool timeline_fence_signaled(struct dma_fence *dma_fence)
{
struct sync_timeline *parent = fence_parent(dma_fence);
return !__dma_fence_is_later(dma_fence->seqno, parent->value);
}
static bool timeline_fence_enable_signaling(struct dma_fence *dma_fence)
{
return true;
}
static void timeline_fence_value_str(struct dma_fence *dma_fence,
char *str, int size)
{
snprintf(str, size, "%d", dma_fence->seqno);
}
static void timeline_fence_timeline_value_str(struct dma_fence *dma_fence,
char *str, int size)
{
struct sync_timeline *parent = fence_parent(dma_fence);
snprintf(str, size, "%d", parent->value);
}
static const struct dma_fence_ops timeline_dma_fence_ops = {
.get_driver_name = timeline_fence_get_driver_name,
.get_timeline_name = timeline_fence_get_timeline_name,
.enable_signaling = timeline_fence_enable_signaling,
.signaled = timeline_fence_signaled,
.wait = dma_fence_default_wait,
.release = timeline_fence_release,
.fence_value_str = timeline_fence_value_str,
.timeline_value_str = timeline_fence_timeline_value_str,
};
/**
* sync_timeline_signal() - signal a status change on a sync_timeline
* @obj: sync_timeline to signal
* @inc: num to increment on timeline->value
*
* A sync implementation should call this any time one of it's fences
* has signaled or has an error condition.
*/
static void sync_timeline_signal(struct sync_timeline *obj, unsigned int inc)
{
struct sync_pt *pt, *next;
//trace_sync_timeline(obj);
spin_lock_irq(&obj->lock);
obj->value += inc;
list_for_each_entry_safe(pt, next, &obj->pt_list, link) {
if (!timeline_fence_signaled(&pt->base))
break;
list_del_init(&pt->link);
rb_erase(&pt->node, &obj->pt_tree);
/*
* A signal callback may release the last reference to this
* dma_fence, causing it to be freed. That operation has to be
* last to avoid a use after free inside this loop, and must
* be after we remove the dma_fence from the timeline in order to
* prevent deadlocking on timeline->lock inside
* timeline_fence_release().
*/
dma_fence_signal_locked(&pt->base);
}
spin_unlock_irq(&obj->lock);
}
/**
* sync_pt_create() - creates a sync pt
* @parent: dma_fence's parent sync_timeline
* @inc: value of the dma_fence
*
* Creates a new sync_pt as a child of @parent. @size bytes will be
* allocated allowing for implementation specific data to be kept after
* the generic sync_timeline struct. Returns the sync_pt object or
* NULL in case of error.
*/
static struct sync_pt *sync_pt_create(struct sync_timeline *obj,
unsigned int value)
{
struct sync_pt *pt;
pt = kzalloc(sizeof(*pt), GFP_KERNEL);
if (!pt)
return NULL;
sync_timeline_get(obj);
dma_fence_init(&pt->base, &timeline_dma_fence_ops, &obj->lock,
obj->context, value);
INIT_LIST_HEAD(&pt->link);
spin_lock_irq(&obj->lock);
if (!dma_fence_is_signaled_locked(&pt->base)) {
struct rb_node **p = &obj->pt_tree.rb_node;
struct rb_node *parent = NULL;
while (*p) {
struct sync_pt *other;
int cmp;
parent = *p;
other = rb_entry(parent, typeof(*pt), node);
cmp = value - other->base.seqno;
if (cmp > 0) {
p = &parent->rb_right;
} else if (cmp < 0) {
p = &parent->rb_left;
} else {
if (dma_fence_get_rcu(&other->base)) {
sync_timeline_put(obj);
kfree(pt);
pt = other;
goto unlock;
}
p = &parent->rb_left;
}
}
rb_link_node(&pt->node, parent, p);
rb_insert_color(&pt->node, &obj->pt_tree);
parent = rb_next(&pt->node);
list_add_tail(&pt->link,
parent ? &rb_entry(parent, typeof(*pt),
node)->link : &obj->pt_list);
}
unlock:
spin_unlock_irq(&obj->lock);
return pt;
}
/*
* *WARNING*
*
* improper use of this can result in deadlocking kernel drivers from userspace.
*/
/* opening mdp_sync create a new sync obj */
static int mdp_sync_open(struct inode *inode, struct file *file)
{
struct sync_timeline *obj;
char task_comm[TASK_COMM_LEN];
get_task_comm(task_comm, current);
obj = mdp_timeline_create(task_comm);
if (!obj)
return -ENOMEM;
file->private_data = obj;
return 0;
}
static int mdp_sync_release(struct inode *inode, struct file *file)
{
struct sync_timeline *obj = file->private_data;
struct sync_pt *pt, *next;
spin_lock_irq(&obj->lock);
list_for_each_entry_safe(pt, next, &obj->pt_list, link) {
dma_fence_set_error(&pt->base, -ENOENT);
dma_fence_signal_locked(&pt->base);
}
spin_unlock_irq(&obj->lock);
//smp_wmb();/*memory barrier*/
sync_timeline_put(obj);
return 0;
}
static long mdp_sync_ioctl_create_fence(struct sync_timeline *obj,
unsigned long arg)
{
int fd = get_unused_fd_flags(O_CLOEXEC);
int err;
struct sync_pt *pt;
struct sync_file *sync_file;
struct mdp_sync_create_fence_data data;
if (fd < 0)
return fd;
if (copy_from_user(&data, (void __user *)arg, sizeof(data))) {
err = -EFAULT;
goto err;
}
pt = sync_pt_create(obj, data.value);
if (!pt) {
err = -ENOMEM;
goto err;
}
sync_file = sync_file_create(&pt->base);
dma_fence_put(&pt->base);
if (!sync_file) {
err = -ENOMEM;
goto err;
}
data.dma_fence = fd;
if (copy_to_user((void __user *)arg, &data, sizeof(data))) {
fput(sync_file->file);
err = -EFAULT;
goto err;
}
fd_install(fd, sync_file->file);
return 0;
err:
put_unused_fd(fd);
return err;
}
static long mdp_sync_ioctl_inc(struct sync_timeline *obj, unsigned long arg)
{
u32 value;
if (copy_from_user(&value, (void __user *)arg, sizeof(value)))
return -EFAULT;
while (value > INT_MAX) {
sync_timeline_signal(obj, INT_MAX);
value -= INT_MAX;
}
sync_timeline_signal(obj, value);
return 0;
}
static long mdp_sync_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
struct sync_timeline *obj = file->private_data;
switch (cmd) {
case MDP_SYNC_IOC_CREATE_FENCE:
return mdp_sync_ioctl_create_fence(obj, arg);
case MDP_SYNC_IOC_INC:
return mdp_sync_ioctl_inc(obj, arg);
default:
return -ENOTTY;
}
}
const struct file_operations mdp_sync_fops = {
.open = mdp_sync_open,
.release = mdp_sync_release,
.unlocked_ioctl = mdp_sync_ioctl,
.compat_ioctl = mdp_sync_ioctl,
};
static struct miscdevice mdp_sync_dev = {
.minor = MISC_DYNAMIC_MINOR,
.name = "mdp_sync",
.fops = &mdp_sync_fops,
};
static int __init mdp_sync_device_init(void)
{
return misc_register(&mdp_sync_dev);
}
device_initcall(mdp_sync_device_init);
+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
+138
View File
@@ -0,0 +1,138 @@
#
# 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
MTK_PLATFORM := $(subst ",,$(CONFIG_MTK_PLATFORM))
ccflags-$(CONFIG_MACH_MT6768) += -DCMDQ_MDP_ENABLE_SPR
ifneq ($(filter mt6768,$(shell echo $(MTK_PLATFORM)|tr A-Z a-z)),)
ccflags-y += -DCMDQ_MDP_ENABLE_SPR
endif
ifneq ($(filter mt6785,$(shell echo $(MTK_PLATFORM)|tr A-Z a-z)),)
#ccflags-y += -DPMQOS_VERSION2
ccflags-y += -DMDP_MMPATH
ccflags-y += -DCMDQ_MDP_ENABLE_SPR
ifeq ($(CONFIG_MTK_DEVAPC),y)
ccflags-y += -DCMDQ_DEVAPC
endif
endif
ifneq ($(filter mt6779,$(shell echo $(MTK_PLATFORM)|tr A-Z a-z)),)
ccflags-y += -DPMQOS_VERSION2
ccflags-y += -DMDP_MMPATH
ccflags-y += -DCMDQ_MDP_ENABLE_SPR
endif
ccflags-y += -I$(srctree)/drivers/misc/mediatek/smi/ \
-I$(srctree)/drivers/misc/mediatek/smi/$(MTK_PLATFORM)/ \
-I$(srctree)/drivers/misc/mediatek/mmdvfs/ \
-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 \
-I$(srctree)/drivers/misc/mediatek/cmdq/bridge
ifneq ($(filter mt8168,$(shell echo $(MTK_PLATFORM)|tr A-Z a-z)),)
ccflags-y += -DCMDQ_TABLET_ENABLE
endif
# mdp platform code
MDP_PLATFORM_DIR=$(srctree)/drivers/misc/mediatek/cmdq/v3/$(MTK_PLATFORM)
platformdir_exists=$(shell if [ -d ${MDP_PLATFORM_DIR} ]; then echo "y"; else echo "n"; fi;)
ifeq ($(platformdir_exists), y)
ccflags-y += -I$(MDP_PLATFORM_DIR)/
else
ccflags-y += -DCMDQ_COMMON_ENG_SUPPORT
endif
ccflags-y += -DCMDQ_TEST_PROC
ifeq ($(CONFIG_MTK_ENG_BUILD),y)
ccflags-y += -DCMDQ_PROFILE_LOCK
ccflags-y += -DCMDQ_DEBUG_LOOP_IRQ
endif
# secure path
ifeq ($(or $(strip $(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT)), $(strip $(CONFIG_MTK_CAM_SECURITY_SUPPORT))),y)
ifeq ($(CONFIG_TRUSTONIC_TEE_SUPPORT),y)
include $(srctree)/drivers/tee/gud/Makefile.include
endif
ifeq ($(CONFIG_MICROTRUST_TEE_SUPPORT),y)
include $(srctree)/drivers/tee/teei/Makefile.include
endif
ccflags-y += -I$(srctree)/drivers/misc/mediatek/cmdq/v3/inc/cmdq_sec_dr \
-I$(srctree)/drivers/misc/mediatek/cmdq/v3/inc/cmdq_sec_tl
ccflags-y += -DCMDQ_SECURE_PATH_SUPPORT
obj-y += cmdq_sec.o
ccflags-y += -DCMDQ_EVENT_SVP_BACKUP
endif # end of CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT or CONFIG_MTK_CAM_SECURITY_SUPPORT
ifeq ($(strip $(CONFIG_MTK_TEE_GP_SUPPORT)),y)
ccflags-y += -DCMDQ_GP_SUPPORT
endif
ifeq ($(strip $(CONFIG_MTK_CAM_SECURITY_SUPPORT)),y)
ifeq ($(strip $(CONFIG_MTK_CAM_GENIEZONE_SUPPORT)),y)
ifeq ($(strip $(CONFIG_MTK_ENABLE_GENIEZONE)),y)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/geniezone/public
ccflags-y += -DCMDQ_SECURE_MTEE_SUPPORT
ccflags-y += -DCMDQ_LATE_INIT_SUPPORT
obj-y += cmdq_sec_mtee.o
endif
else
ccflags-y += -DCMDQ_SECURE_TEE_SUPPORT
obj-y += cmdq_sec_gp.o
endif
endif
ifeq ($(strip $(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT)),y)
ccflags-y += -DCMDQ_SECURE_TEE_SUPPORT
obj-y += cmdq_sec_gp.o
endif
# platform dependent definition
ccflags-y += -DCMDQ_SPECIAL_ESD_PRIORITY
ccflags-y += -D_CMDQ_DISABLE_MARKER_
ifneq ($(strip $(CONFIG_MTK_GMO_RAM_OPTIMIZE)),y)
ccflags-y += -DCMDQ_LARGE_MAX_FIRSTERROR_BUFFER
endif
# driver module
obj-y += cmdq_record.o
obj-y += cmdq_virtual.o
obj-y += cmdq_device.o
obj-y += cmdq_driver.o
obj-y += cmdq_mdp_common.o
obj-y += cmdq_test.o
#obj-y += cmdq_prof.o
obj-y += cmdq_event_common.o
obj-y += cmdq_subsys_common.o
obj-y += cmdq_helper_ext.o
ifeq ($(strip $(CONFIG_MMPROFILE)),y)
obj-y += cmdq_mmp.o
endif
ifeq ($(platformdir_exists), y)
obj-y += $(subst ",,$(MTK_PLATFORM))/
endif
MTK_PLATFORM := $(subst ",,$(CONFIG_MTK_PLATFORM))
+11
View File
@@ -0,0 +1,11 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_CORE_H__
#define __CMDQ_CORE_H__
#include "cmdq_helper_ext.h"
#endif /* __CMDQ_CORE_H__ */
+559
View File
@@ -0,0 +1,559 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_DEF_H__
#define __CMDQ_DEF_H__
#include <linux/kernel.h>
#include <linux/soc/mediatek/mtk-cmdq.h>
#include "cmdq_subsys_common.h"
#include "cmdq_event_common.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_MAX_PROFILE_MARKER_IN_TASK (5)
#define CMDQ_INVALID_THREAD (-1)
#if IS_ENABLED(CONFIG_MTK_MT6382_DBG)
#define CMDQ_MAX_THREAD_COUNT (BIT(5) | 24)
#else
#define CMDQ_MAX_THREAD_COUNT (24)
#endif
#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 (8)
#define CMDQ_MIN_SECURE_THREAD_ID (CMDQ_MAX_HIGH_PRIORITY_THREAD_COUNT)
#if IS_ENABLED(CONFIG_MACH_MT6779) || IS_ENABLED(CONFIG_MACH_MT6785)
/* primary disp / secondary disp / mdp / isp fd */
#define CMDQ_MAX_SECURE_THREAD_COUNT (4)
#else
/* primary disp / secondary disp / mdp */
#define CMDQ_MAX_SECURE_THREAD_COUNT (3)
#endif
#ifdef CMDQ_SECURE_PATH_SUPPORT
#define CMDQ_DYNAMIC_THREAD_ID_START (CMDQ_MIN_SECURE_THREAD_ID + \
CMDQ_MAX_SECURE_THREAD_COUNT)
#else
#define CMDQ_DYNAMIC_THREAD_ID_START (CMDQ_MAX_HIGH_PRIORITY_THREAD_COUNT)
#endif
#define CMDQ_SEC_IRQ_THREAD 15
#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 (64)
#else
#define CMDQ_MAX_RECORD_COUNT (128)
#endif
#define CMDQ_INITIAL_CMD_BLOCK_SIZE (PAGE_SIZE)
/* instruction is 64-bit */
#define CMDQ_DMA_POOL_COUNT 128
#define CMDQ_MAX_LOOP_COUNT (1000000)
#define CMDQ_MAX_INST_CYCLE (27)
#define CMDQ_MAX_ERROR_SIZE (8 * 1024)
#define CMDQ_MAX_TASK_IN_SECURE_THREAD_MAX (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_FPGA_EARLY_PORTING
#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)
#ifndef CONFIG_FPGA_EARLY_PORTING
#define CMDQ_PWR_AWARE /* FPGA does not have ClkMgr */
#else
#undef CMDQ_PWR_AWARE
#endif
typedef u64 CMDQ_VARIABLE;
/*
* SPR / CPR / VAR naming rule and number
**********************************************
* <- SPR -> <- CPR ->
* <reserved><FREE use > < FREE use >
* VAR# 0 1 2 3 4 5 6 7
* CPR# 0 1 2 3
*/
#define CMDQ_SPR_FOR_LOOP_DEBUG (1)
#define CMDQ_THR_SPR_START (2)
#define CMDQ_THR_FREE_CPR_MAX (4)
#define CMDQ_THR_FREE_USR_VAR_MAX (CMDQ_THR_SPR_MAX + \
CMDQ_THR_FREE_CPR_MAX)
#define CMDQ_THR_CPR_MAX (CMDQ_THR_FREE_CPR_MAX + 0)
#define CMDQ_THR_VAR_MAX (CMDQ_THR_SPR_MAX + CMDQ_THR_CPR_MAX)
#define CMDQ_SRAM_STRAT_ADDR (0x0)
#define CMDQ_GPR_V3_OFFSET (0x20)
#define CMDQ_POLLING_TPR_MASK_BIT (10)
#define CMDQ_SRAM_ADDR(CPR_OFFSRT) \
(((CMDQ_SRAM_STRAT_ADDR + CPR_OFFSRT / 2) << 3) + 0x001)
#define CMDQ_CPR_OFFSET(SRAM_ADDR) \
(((SRAM_ADDR >> 3) - CMDQ_SRAM_STRAT_ADDR) * 2)
#define CMDQ_INVALID_CPR_OFFSET (0xFFFFFFFF)
#define CMDQ_MAX_SRAM_OWNER_NAME (32)
#define CMDQ_DELAY_TPR_MASK_BIT (11)
#define CMDQ_DELAY_TPR_MASK_VALUE (1 << 17 | 1 << 14 | 1 << 11)
#define CMDQ_DELAY_MAX_SET (3)
#define CMDQ_DELAY_SET_START_CPR (0)
#define CMDQ_DELAY_SET_DURATION_CPR (1)
#define CMDQ_DELAY_SET_RESULT_CPR (2)
#define CMDQ_DELAY_SET_MAX_CPR (3)
#define CMDQ_DELAY_THD_SIZE (64 * 64) /* delay inst in bytes */
/* #define CMDQ_DUMP_GIC (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,
CMDQ_THR_PRIO_SUPERHIGH = 5, /* High priority monitor loop */
CMDQ_THR_PRIO_MAX = 7, /* maximum possible priority */
};
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,
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_DISP_VFP_CHANGE = 34,
CMDQ_SCENARIO_RDMA2_DISP = 35,
/* for primary trigger loop enable pre-fetch usage */
CMDQ_SCENARIO_HIGHP_TRIGGER_LOOP = 36,
/* for low priority monitor loop to polling bus status */
CMDQ_SCENARIO_LOWP_TRIGGER_LOOP = 37,
CMDQ_SCENARIO_KERNEL_CONFIG_GENERAL = 38,
CMDQ_SCENARIO_TIMER_LOOP = 39,
CMDQ_SCENARIO_MOVE = 40,
CMDQ_SCENARIO_SRAM_LOOP = 41,
/* debug scenario use mdp flush */
CMDQ_SCENARIO_DEBUG_MDP = 42,
/* for ISP kernel driver */
CMDQ_SCENARIO_ISP_RSC = 43,
CMDQ_SCENARIO_ISP_FDVT = 44,
CMDQ_SCENARIO_ISP_DPE = 45,
CMDQ_SCENARIO_ISP_FDVT_OFF = 46,
/* Trigger loop scenario does not enable HWs */
CMDQ_SCENARIO_TRIGGER_LOOP_SUB = 47,
/* bridge */
CMDQ_BDG_SCENARIO_DISP_TEST,
CMDQ_BDG_SCENARIO_DISP_TEST2,
/* TODO */
CMDQ_MAX_SCENARIO_COUNT /* ALWAYS keep at the end */
};
#define CMDQ_BDG_TASK(thread) \
(((thread) & BIT(5)) ? true : false)
/* General Purpose Register */
enum cmdq_gpr_reg {
/* 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 */
};
#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*.
*/
#define cmdqU32Ptr_t unsigned long long
#define CMDQ_U32_PTR(x) ((uint32_t *)(unsigned long)x)
struct cmdqReadRegStruct {
/* number of entries in regAddresses */
uint32_t count;
/* 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 u32 type.
*/
cmdqU32Ptr_t dmaAddresses;
/* [OUT] u32 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 */
CMDQ_SAM_NMVA_2_MVA = 2, /* map normal MVA to secure world */
CMDQ_SAM_PH_2_MVA = 3, /* protected handle to sec MVA */
};
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;
};
struct cmdqMetaBuf {
uint64_t va;
uint64_t size;
};
#define CMDQ_ISP_META_CNT 8
struct cmdqSecIspMeta {
struct cmdqMetaBuf ispBufs[CMDQ_ISP_META_CNT];
uint64_t CqSecHandle;
uint32_t CqSecSize;
uint32_t CqDesOft;
uint32_t CqVirtOft;
uint64_t TpipeSecHandle;
uint32_t TpipeSecSize;
uint32_t TpipeOft;
uint64_t BpciHandle;
uint64_t LsciHandle;
uint64_t LceiHandle;
uint64_t DepiHandle;
uint64_t DmgiHandle;
};
/* client extension bits for cmdq secure driver
* must sync with iwc header sec_extension_iwc
*/
enum sec_extension {
SEC_MDP_AAL = 0,
SEC_TDSHP
};
#ifdef CONFIG_MTK_IN_HOUSE_TEE_SUPPORT
/* 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,
};
#endif
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;
/* reset HW thread in SWd */
bool resetExecCnt;
/* ISP metadata for secure camera */
struct cmdqSecIspMeta ispMeta;
/* client extension feature */
uint64_t extension;
bool mtee;
/*iommu_sec_id*/
int32_t sec_id;
#ifdef CONFIG_MTK_IN_HOUSE_TEE_SUPPORT
/* tablet use */
uint32_t secMode;
#endif
};
struct cmdq_v3_replace_struct {
/* [IN] count of element in instr_position */
uint32_t number;
/* [IN] position of instruction */
cmdqU32Ptr_t position;
};
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];
};
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] CPR position */
struct cmdq_v3_replace_struct replace_instr;
/* [IN] use SRAM buffer or not */
bool use_sram_buffer;
/* [IN] SRAM buffer owner name */
char sram_owner_name[CMDQ_MAX_SRAM_OWNER_NAME];
/* [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;
/* task property */
uint32_t prop_size;
cmdqU32Ptr_t prop_addr;
struct cmdqProfileMarkerStruct profileMarker;
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__ */
+550
View File
@@ -0,0 +1,550 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#include "cmdq_device.h"
#include "cmdq_virtual.h"
#include "cmdq_helper_ext.h"
#ifdef CMDQ_CONFIG_SMI
#include "smi_public.h"
#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 <linux/vmalloc.h>
#include <linux/slab.h>
#include <linux/clk-provider.h>
struct CmdqDeviceStruct {
struct device *pDev;
struct clk *clk_gce;
struct clk *clk_gce_timer;
struct clk *clk_mmsys_mtcmos;
long regBaseVA; /* considering 64 bit kernel, use long */
phys_addr_t regBasePA;
u32 irqId;
u32 irqSecId;
s32 dma_mask_result;
};
static struct CmdqDeviceStruct gCmdqDev;
static u32 gThreadCount;
static u32 gMMSYSDummyRegOffset;
struct device *cmdq_dev_get(void)
{
return gCmdqDev.pDev;
}
u32 cmdq_dev_get_irq_id(void)
{
return gCmdqDev.irqId;
}
u32 cmdq_dev_get_irq_secure_id(void)
{
return gCmdqDev.irqSecId;
}
long cmdq_dev_get_module_base_VA_GCE(void)
{
return gCmdqDev.regBaseVA;
}
phys_addr_t cmdq_dev_get_module_base_PA_GCE(void)
{
return gCmdqDev.regBasePA;
}
s32 cmdq_dev_get_dma_mask_result(void)
{
return gCmdqDev.dma_mask_result;
}
u32 cmdq_dev_get_thread_count(void)
{
return gThreadCount;
}
u32 cmdq_dev_get_mmsys_dummy_reg_offset(void)
{
return gMMSYSDummyRegOffset;
}
void cmdq_dev_init_module_base_VA(void)
{
cmdq_mdp_get_func()->initModuleBaseVA();
}
void cmdq_dev_deinit_module_base_VA(void)
{
cmdq_mdp_get_func()->deinitModuleBaseVA();
}
unsigned long cmdq_dev_alloc_reference_VA_by_name(const char *ref_name)
{
unsigned long VA = 0L;
struct device_node *node = NULL;
node = of_parse_phandle(gCmdqDev.pDev->of_node, ref_name, 0);
if (node) {
VA = (unsigned long)of_iomap(node, 0);
of_node_put(node);
}
CMDQ_LOG("DEV: VA ref(%s):0x%lx\n", ref_name, VA);
return VA;
}
void cmdq_dev_free_module_base_VA(const long VA)
{
iounmap((void *)VA);
}
phys_addr_t cmdq_dev_get_gce_node_PA(struct device_node *node, int index)
{
struct resource res;
phys_addr_t regBasePA = 0L;
do {
if (of_address_to_resource(node, index, &res) < 0)
break;
regBasePA = (0L | res.start);
} while (0);
return regBasePA;
}
#define IMP_ENABLE_HW_CLOCK(FN_NAME, HW_NAME) \
u32 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 *ref_name,
const char *clkName, struct clk **clk_module)
{
struct device_node *node = NULL;
node = of_parse_phandle(gCmdqDev.pDev->of_node, ref_name, 0);
*clk_module = of_clk_get_by_name(node, clkName);
if (IS_ERR(*clk_module)) {
/* error status print */
CMDQ_ERR("%s (%s): clock:%s err:%d\n", __func__, ref_name,
clkName, (int)PTR_ERR(*clk_module));
} else {
/* message print */
CMDQ_MSG("%s (%s): clock:%s\n", __func__, ref_name, clkName);
}
}
u32 cmdq_dev_enable_device_clock(bool enable,
struct clk *clk_module, const char *clkName)
{
int result = 0;
if (IS_ERR(clk_module)) {
CMDQ_LOG("[WARN]clock module does not support:%s\n", clkName);
return PTR_ERR(clk_module);
}
if (enable) {
result = clk_prepare_enable(clk_module);
if (result)
CMDQ_ERR("enable clock with module:%s result:%d\n",
clkName, result);
else
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;
}
bool cmdq_dev_device_clock_is_enable(struct clk *clk_module)
{
return true;
}
/* Common Clock Framework */
void cmdq_dev_init_module_clk(void)
{
cmdq_mdp_get_func()->initModuleCLK();
}
void cmdq_dev_enable_gce_clock(bool enable)
{
cmdq_dev_enable_device_clock(enable, gCmdqDev.clk_gce, "gce-clk");
if (!IS_ERR(gCmdqDev.clk_gce_timer))
cmdq_dev_enable_device_clock(enable, gCmdqDev.clk_gce_timer,
"gce-clk-timer");
}
bool cmdq_dev_gce_clock_is_enable(void)
{
return cmdq_dev_device_clock_is_enable(gCmdqDev.clk_gce);
}
bool cmdq_dev_mmsys_clock_is_enable(void)
{
if (IS_ERR(gCmdqDev.clk_mmsys_mtcmos)) {
CMDQ_ERR("MMSYS_MTCMOS clk not support\n");
return false;
}
return __clk_is_enabled(gCmdqDev.clk_mmsys_mtcmos);
}
phys_addr_t cmdq_dev_get_reference_PA(const char *ref_name, int index)
{
int status;
struct device_node *node = NULL;
struct resource res;
phys_addr_t start_pa = 0;
do {
node = of_parse_phandle(gCmdqDev.pDev->of_node, ref_name, 0);
if (!node)
break;
status = of_address_to_resource(node, index, &res);
if (status < 0)
break;
start_pa = res.start;
CMDQ_LOG("DEV: PA ref(%s): start:%pa\n",
ref_name, &start_pa);
} while (0);
if (node)
of_node_put(node);
return start_pa;
}
/* Get MDP base address to user space */
void cmdq_dev_init_MDP_PA(struct device_node *node)
{
u32 *pMDPBaseAddress = cmdq_core_get_dts_data()->MDPBaseAddress;
phys_addr_t module_pa_start = 0;
module_pa_start = cmdq_dev_get_reference_PA("mm_mutex", 0);
if (!module_pa_start)
CMDQ_ERR("DEV: init mm_mutex PA fail!!\n");
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]);
}
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;
u32 gceSubsys[3] = { 0, 0, 0 };
struct SubsysStruct *gceSubsysStruct = NULL;
do {
if (subsys < 0 || subsys >= (u32)CMDQ_SUBSYS_MAX_COUNT)
break;
gceSubsysStruct = cmdq_core_get_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_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);
}
}
}
void cmdq_dev_init_subsys(struct device_node *node)
{
u32 i;
struct cmdq_subsys_dts_name *subsys = cmdq_subsys_get_dts();
for (i = 0; i < cmdq_subsys_get_size(); i++)
if (subsys[i].name)
cmdq_dev_get_subsys_by_name(node, i, subsys[i].group,
subsys[i].name);
}
void cmdq_dev_get_event_value_by_name(struct device_node *node,
enum cmdq_event event, const char *dts_name)
{
s32 status;
s32 event_value = -1;
do {
if (event < 0 || event >= (u32)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 event,
const char *dts_name, const char *event_name)
{
s32 eventValue = cmdq_core_get_event_value(event);
if (eventValue >= 0 && eventValue < (u32)CMDQ_SYNC_TOKEN_MAX) {
/* print event name from device tree */
if (event < (u32)CMDQ_MAX_HW_EVENT_COUNT)
CMDQ_LOG("%s = %d\n", dts_name, eventValue);
else
CMDQ_LOG("%s = %d\n", event_name, eventValue);
}
}
void cmdq_dev_init_event_table(struct device_node *node)
{
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);
}
}
void cmdq_dev_test_dts_correctness(void)
{
struct cmdq_event_table *events = cmdq_event_get_table();
struct cmdq_subsys_dts_name *subsys = cmdq_subsys_get_dts();
u32 i;
for (i = 0; i < cmdq_event_get_table_size(); i++)
cmdq_dev_test_event_correctness_impl(events[i].event,
events[i].dts_name, events[i].event_name);
for (i = 0; i < cmdq_subsys_get_size(); i++)
if (subsys[i].name)
cmdq_dev_test_subsys_correctness_impl(i);
}
void cmdq_dev_get_dts_setting(struct cmdq_dts_setting *dts_setting)
{
s32 ret = -1;
u32 sram_size_cpr_64 = 0;
ret = of_property_read_u32(gCmdqDev.pDev->of_node, "sram_size_cpr_64",
&sram_size_cpr_64);
if (ret != 0 || !sram_size_cpr_64) {
dts_setting->cpr_size = gThreadCount * CMDQ_THR_FREE_CPR_MAX;
CMDQ_ERR("sram_size_cpr_64 not support, default:%u\n",
dts_setting->cpr_size);
} else {
/* CPRs are 32bit register, device tree count in 64bit */
dts_setting->cpr_size = sram_size_cpr_64 * 2;
CMDQ_LOG("free CPR size:%u thread:%u\n",
dts_setting->cpr_size, gThreadCount);
}
ret = of_property_read_u32(gCmdqDev.pDev->of_node,
"max_prefetch_cnt", &dts_setting->prefetch_thread_count);
if (ret == 0) {
/* read prefetch array base on count */
ret = of_property_read_u32_array(gCmdqDev.pDev->of_node,
"prefetch_size", dts_setting->prefetch_size,
dts_setting->prefetch_thread_count);
if (ret != 0) {
/* print log but do notify error hw setting */
CMDQ_ERR("read prefetch size fail\n");
}
}
ret = of_property_read_u32(gCmdqDev.pDev->of_node, "ctl_int0",
&dts_setting->ctl_int0);
if (ret != 0) {
/* debug only feature */
CMDQ_VERBOSE("ctl_int0 not support\n");
}
}
void cmdq_dev_init_resource(CMDQ_DEV_INIT_RESOURCE_CB init_cb)
{
int status, index;
u32 count = 0;
status = of_property_read_u32(gCmdqDev.pDev->of_node,
"sram_share_cnt", &count);
if (status < 0)
return;
for (index = 0; index < count; index++) {
u32 engine, event;
status = of_property_read_u32_index(
gCmdqDev.pDev->of_node, "sram_share_engine",
index, &engine);
if (status < 0)
return;
status = of_property_read_u32_index(
gCmdqDev.pDev->of_node, "sram_share_event",
index, &event);
if (status < 0)
return;
if (init_cb != NULL)
init_cb(engine, event);
}
}
void cmdq_dev_init_device_tree(struct device_node *node)
{
int status;
u32 mmsys_dummy_reg_offset_value = 0;
u32 thread_count = CMDQ_MAX_THREAD_COUNT;
struct cmdq_dts_setting *dts_setting = cmdq_core_get_dts_setting();
gThreadCount = thread_count;
gMMSYSDummyRegOffset = 0;
cmdq_core_init_dts_data();
status = of_property_read_u32(node, "thread_count", &thread_count);
if (status >= 0)
gThreadCount = thread_count;
/* 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);
/* 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)
mmsys_dummy_reg_offset_value = 0x89C;
gMMSYSDummyRegOffset = mmsys_dummy_reg_offset_value;
/* Initialize DTS Setting structure */
memset(dts_setting, 0x0, sizeof(struct cmdq_dts_setting));
/* Initialize setting for legacy chip */
dts_setting->prefetch_thread_count = 3;
dts_setting->prefetch_size = kcalloc(gThreadCount,
sizeof(*dts_setting->prefetch_size), GFP_KERNEL);
cmdq_dev_get_dts_setting(dts_setting);
}
void cmdq_dev_init(struct platform_device *pDevice)
{
struct device_node *node = pDevice->dev.of_node;
u32 dma_mask_bit = 0;
s32 ret;
/* init cmdq device dependent data */
do {
memset(&gCmdqDev, 0x0, sizeof(struct CmdqDeviceStruct));
gCmdqDev.pDev = &pDevice->dev;
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");
gCmdqDev.clk_gce_timer = devm_clk_get(&pDevice->dev,
"GCE_TIMER");
gCmdqDev.clk_mmsys_mtcmos = devm_clk_get(&pDevice->dev,
"MMSYS_MTCMOS");
CMDQ_LOG(
"[CMDQ] platform_dev: dev:%p PA:%pa VA:%lx irqId:%d irqSecId:%d\n",
gCmdqDev.pDev, &gCmdqDev.regBasePA,
gCmdqDev.regBaseVA, gCmdqDev.irqId,
gCmdqDev.irqSecId);
} while (0);
ret = of_property_read_u32(gCmdqDev.pDev->of_node, "dma_mask_bit",
&dma_mask_bit);
/* if not assign from dts, give default 32bit for legacy chip */
if (ret != 0 || !dma_mask_bit)
dma_mask_bit = 32;
gCmdqDev.dma_mask_result = dma_set_coherent_mask(
&pDevice->dev, DMA_BIT_MASK(dma_mask_bit));
CMDQ_LOG("set dma mask bit:%u result:%d\n",
dma_mask_bit, gCmdqDev.dma_mask_result);
/* map MMSYS VA */
cmdq_mdp_map_mmsys_VA();
/* 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)
{
/* unmap MMSYS VA */
cmdq_mdp_unmap_mmsys_VA();
cmdq_dev_deinit_module_base_VA();
/* deinit cmdq device dependent data */
do {
cmdq_dev_free_module_base_VA(
cmdq_dev_get_module_base_VA_GCE());
gCmdqDev.regBaseVA = 0;
} while (0);
}
@@ -0,0 +1,80 @@
/* 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) \
u32 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 *ref_name,
const char *clkName, struct clk **clk_module);
u32 cmdq_dev_enable_device_clock(bool enable, struct clk *clk_module,
const char *clkName);
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 u32 testWriteValue,
const unsigned long testReadReg, const bool verifyWriteResult);
struct device *cmdq_dev_get(void);
/* interrupt index */
u32 cmdq_dev_get_irq_id(void);
u32 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);
bool cmdq_dev_mmsys_clock_is_enable(void);
/* virtual address */
long cmdq_dev_get_module_base_VA_GCE(void);
unsigned long cmdq_dev_alloc_reference_VA_by_name(const char *ref_name);
/* Other modules information */
void cmdq_dev_free_module_base_VA(const long VA);
u32 cmdq_dev_get_mmsys_dummy_reg_offset(void);
/* physical address */
phys_addr_t cmdq_dev_get_reference_PA(const char *ref_name, int index);
phys_addr_t 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 */
s32 cmdq_dev_get_dma_mask_result(void);
u32 cmdq_dev_get_thread_count(void);
struct cmdq_dts_setting {
u32 prefetch_thread_count;
u32 *prefetch_size;
u32 ctl_int0;
u32 cpr_size;
};
/* callback when read resource from device tree */
typedef void(*CMDQ_DEV_INIT_RESOURCE_CB) (u32 engineFlag,
enum cmdq_event 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
+109
View File
@@ -0,0 +1,109 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_DRIVER_H__
#define __CMDQ_DRIVER_H__
#include <linux/kernel.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;
uint64_t engineFlag; /* [OUT] engine flag passed down originally */
/* [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 u32, 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 u32 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 *ids, u32 *addrs, u32 count, u32 *values);
#endif /* __CMDQ_DRIVER_H__ */
@@ -0,0 +1,176 @@
/* 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_WPEI = 0,
CMDQ_ENG_WPEO, /* 1 */
CMDQ_ENG_ISP_IMGI, /* 2 */
CMDQ_ENG_ISP_IMGO, /* 3 */
CMDQ_ENG_ISP_IMG2O, /* 4 */
/* IPU */
CMDQ_ENG_IPUI, /* 5 */
CMDQ_ENG_IPUO, /* 6 */
/* MDP */
CMDQ_ENG_MDP_CAMIN, /* 7 */
CMDQ_ENG_MDP_RDMA0, /* 8 */
CMDQ_ENG_MDP_RDMA1, /* 9 */
CMDQ_ENG_MDP_IPUIN, /* 10 */
CMDQ_ENG_MDP_RSZ0, /* 11 */
CMDQ_ENG_MDP_RSZ1, /* 12 */
CMDQ_ENG_MDP_RSZ2, /* 13 */
CMDQ_ENG_MDP_TDSHP0, /* 14 */
CMDQ_ENG_MDP_TDSHP1, /* 15 */
CMDQ_ENG_MDP_COLOR0, /* 16 */
CMDQ_ENG_MDP_MOUT0, /* 17 */
CMDQ_ENG_MDP_MOUT1, /* 18 */
CMDQ_ENG_MDP_PATH0_SOUT, /* 19 */
CMDQ_ENG_MDP_PATH1_SOUT, /* 20 */
CMDQ_ENG_MDP_WROT0, /* 21 */
CMDQ_ENG_MDP_WROT1, /* 22 */
CMDQ_ENG_MDP_WDMA, /* 23 */
/* JPEG & VENC */
CMDQ_ENG_JPEG_ENC, /* 24 */
CMDQ_ENG_VIDEO_ENC, /* 25 */
CMDQ_ENG_JPEG_DEC, /* 26 */
CMDQ_ENG_JPEG_REMDC, /* 27 */
/* DISP */
CMDQ_ENG_DISP_UFOE, /* 28 */
CMDQ_ENG_DISP_AAL, /* 29 */
CMDQ_ENG_DISP_COLOR0, /* 30 */
CMDQ_ENG_DISP_COLOR1, /* 31 */
CMDQ_ENG_DISP_RDMA0, /* 32 */
CMDQ_ENG_DISP_RDMA1, /* 33 */
CMDQ_ENG_DISP_RDMA2, /* 34 */
CMDQ_ENG_DISP_WDMA0, /* 35 */
CMDQ_ENG_DISP_WDMA1, /* 36 */
CMDQ_ENG_DISP_OVL0, /* 37 */
CMDQ_ENG_DISP_OVL1, /* 38 */
CMDQ_ENG_DISP_OVL2, /* 39 */
CMDQ_ENG_DISP_2L_OVL0, /* 40 */
CMDQ_ENG_DISP_2L_OVL1, /* 41 */
CMDQ_ENG_DISP_2L_OVL2, /* 42 */
CMDQ_ENG_DISP_GAMMA, /* 43 */
CMDQ_ENG_DISP_MERGE, /* 44 */
CMDQ_ENG_DISP_SPLIT0, /* 45 */
CMDQ_ENG_DISP_SPLIT1, /* 46 */
CMDQ_ENG_DISP_DSI0_VDO, /* 47 */
CMDQ_ENG_DISP_DSI1_VDO, /* 48 */
CMDQ_ENG_DISP_DSI0_CMD, /* 49 */
CMDQ_ENG_DISP_DSI1_CMD, /* 50 */
CMDQ_ENG_DISP_DSI0, /* 51 */
CMDQ_ENG_DISP_DSI1, /* 52 */
CMDQ_ENG_DISP_DPI, /* 53 */
/* DPE */
CMDQ_ENG_DPE, /* 54 */
CMDQ_ENG_RSC, /* 55 */
CMDQ_ENG_GEPF, /* 56 */
/* temp: CMDQ internal usage */
CMDQ_ENG_CMDQ, /* 57 */
CMDQ_ENG_DISP_MUTEX, /* 58 */
CMDQ_ENG_MMSYS_CONFIG, /* 59 */
CMDQ_MAX_ENGINE_COUNT /* ALWAYS keep at the end */
};
#define CMDQ_ENG_WPE_GROUP_BITS ((1LL << CMDQ_ENG_WPEI) | \
(1LL << CMDQ_ENG_WPEO))
#define CMDQ_ENG_ISP_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_IMGO) | \
(1LL << CMDQ_ENG_ISP_IMG2O))
#define CMDQ_ENG_MDP_GROUP_BITS ((1LL << CMDQ_ENG_MDP_CAMIN) | \
(1LL << CMDQ_ENG_MDP_RDMA0) | \
(1LL << CMDQ_ENG_MDP_RDMA1) | \
(1LL << CMDQ_ENG_MDP_RSZ0) | \
(1LL << CMDQ_ENG_MDP_RSZ1) | \
(1LL << CMDQ_ENG_MDP_RSZ2) | \
(1LL << CMDQ_ENG_MDP_TDSHP0) | \
(1LL << CMDQ_ENG_MDP_TDSHP1) | \
(1LL << CMDQ_ENG_MDP_COLOR0) | \
(1LL << CMDQ_ENG_MDP_WROT0) | \
(1LL << CMDQ_ENG_MDP_WROT1) | \
(1LL << CMDQ_ENG_MDP_WDMA))
#define CMDQ_ENG_DISP_GROUP_BITS \
((1LL << CMDQ_ENG_DISP_UFOE) | \
(1LL << CMDQ_ENG_DISP_AAL) | \
(1LL << CMDQ_ENG_DISP_COLOR0) | \
(1LL << CMDQ_ENG_DISP_COLOR1) | \
(1LL << CMDQ_ENG_DISP_RDMA0) | \
(1LL << CMDQ_ENG_DISP_RDMA1) | \
(1LL << CMDQ_ENG_DISP_RDMA2) | \
(1LL << CMDQ_ENG_DISP_WDMA0) | \
(1LL << CMDQ_ENG_DISP_WDMA1) | \
(1LL << CMDQ_ENG_DISP_OVL0) | \
(1LL << CMDQ_ENG_DISP_OVL1) | \
(1LL << CMDQ_ENG_DISP_OVL2) | \
(1LL << CMDQ_ENG_DISP_2L_OVL0) | \
(1LL << CMDQ_ENG_DISP_2L_OVL1) | \
(1LL << CMDQ_ENG_DISP_2L_OVL2) | \
(1LL << CMDQ_ENG_DISP_GAMMA) | \
(1LL << CMDQ_ENG_DISP_MERGE) | \
(1LL << CMDQ_ENG_DISP_SPLIT0) | \
(1LL << CMDQ_ENG_DISP_SPLIT1) | \
(1LL << CMDQ_ENG_DISP_DSI0_VDO) | \
(1LL << CMDQ_ENG_DISP_DSI1_VDO) | \
(1LL << CMDQ_ENG_DISP_DSI0_CMD) | \
(1LL << CMDQ_ENG_DISP_DSI1_CMD) | \
(1LL << CMDQ_ENG_DISP_DSI0) | \
(1LL << CMDQ_ENG_DISP_DSI1) | \
(1LL << CMDQ_ENG_DISP_DPI))
#define CMDQ_ENG_VENC_GROUP_BITS ((1LL << CMDQ_ENG_VIDEO_ENC))
#define CMDQ_ENG_JPEG_GROUP_BITS ((1LL << CMDQ_ENG_JPEG_ENC) | \
(1LL << CMDQ_ENG_JPEG_REMDC) | \
(1LL << CMDQ_ENG_JPEG_DEC))
#define CMDQ_ENG_DPE_GROUP_BITS (1LL << CMDQ_ENG_DPE)
#define CMDQ_ENG_RSC_GROUP_BITS (1LL << CMDQ_ENG_RSC)
#define CMDQ_ENG_GEPF_GROUP_BITS (1LL << CMDQ_ENG_GEPF)
#define CMDQ_ENG_EAF_GROUP_BITS (1LL << CMDQ_ENG_EAF)
#define CMDQ_ENG_ISP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_ISP_GROUP_BITS))
#define CMDQ_ENG_MDP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_MDP_GROUP_BITS))
#define CMDQ_ENG_DISP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_DISP_GROUP_BITS))
#define CMDQ_ENG_JPEG_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_JPEG_GROUP_BITS))
#define CMDQ_ENG_VENC_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_VENC_GROUP_BITS))
#define CMDQ_ENG_DPE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_DPE_GROUP_BITS))
#define CMDQ_ENG_RSC_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_RSC_GROUP_BITS))
#define CMDQ_ENG_GEPF_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_GEPF_GROUP_BITS))
#define CMDQ_ENG_WPE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_WPE_GROUP_BITS))
#define CMDQ_ENG_EAF_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_EAF_GROUP_BITS))
#define CMDQ_FOREACH_GROUP(ACTION_struct)\
ACTION_struct(CMDQ_GROUP_ISP, ISP) \
ACTION_struct(CMDQ_GROUP_MDP, MDP) \
ACTION_struct(CMDQ_GROUP_DISP, DISP) \
ACTION_struct(CMDQ_GROUP_JPEG, JPEG) \
ACTION_struct(CMDQ_GROUP_VENC, VENC) \
ACTION_struct(CMDQ_GROUP_DPE, DPE) \
ACTION_struct(CMDQ_GROUP_RSC, RSC) \
ACTION_struct(CMDQ_GROUP_GEPF, GEPF) \
ACTION_struct(CMDQ_GROUP_WPE, WPE) \
ACTION_struct(CMDQ_GROUP_EAF, EAF)
#define MDP_GENERATE_ENUM(_enum, _string) _enum,
enum CMDQ_GROUP_ENUM {
CMDQ_FOREACH_GROUP(MDP_GENERATE_ENUM)
CMDQ_MAX_GROUP_COUNT, /* ALWAYS keep at the end */
};
#endif /* __CMDQ_ENGINE_COMMON_H__ */
@@ -0,0 +1,770 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#include <linux/soc/mediatek/mtk-cmdq.h>
#include "cmdq_device.h"
#define DECLAR_EVENT(event_enum, dts_name) \
{event_enum, #event_enum, #dts_name},
static struct cmdq_event_table cmdq_events[] = {
/* MDP start frame */
DECLAR_EVENT(CMDQ_EVENT_MDP_RDMA0_SOF, mdp_rdma0_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_RDMA1_SOF, mdp_rdma1_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_RSZ0_SOF, mdp_rsz0_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_RSZ1_SOF, mdp_rsz1_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_RSZ2_SOF, mdp_rsz2_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_TDSHP_SOF, mdp_tdshp_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_TDSHP0_SOF, mdp_tdshp0_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_TDSHP1_SOF, mdp_tdshp1_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_WDMA_SOF, mdp_wdma_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT_SOF, mdp_wrot_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT0_SOF, mdp_wrot0_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT1_SOF, mdp_wrot1_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_COLOR_SOF, mdp_color_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_MVW_SOF, mdp_mvw_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_CROP_SOF, mdp_crop_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_AAL_SOF, mdp_aal_sof)
/* Display start frame */
DECLAR_EVENT(CMDQ_EVENT_DISP_OVL0_SOF, disp_ovl0_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_OVL1_SOF, disp_ovl1_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_2L_OVL0_SOF, disp_2l_ovl0_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_2L_OVL1_SOF, disp_2l_ovl1_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_RDMA0_SOF, disp_rdma0_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_RDMA1_SOF, disp_rdma1_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_RDMA2_SOF, disp_rdma2_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_WDMA0_SOF, disp_wdma0_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_WDMA1_SOF, disp_wdma1_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_COLOR_SOF, disp_color_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_COLOR0_SOF, disp_color0_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_COLOR1_SOF, disp_color1_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_CCORR_SOF, disp_ccorr_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_CCORR0_SOF, disp_ccorr0_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_CCORR1_SOF, disp_ccorr1_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_AAL_SOF, disp_aal_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_AAL0_SOF, disp_aal0_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_AAL1_SOF, disp_aal1_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_GAMMA_SOF, disp_gamma_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_GAMMA0_SOF, disp_gamma0_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_GAMMA1_SOF, disp_gamma1_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_DITHER_SOF, disp_dither_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_DITHER0_SOF, disp_dither0_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_DITHER1_SOF, disp_dither1_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_UFOE_SOF, disp_ufoe_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_PWM0_SOF, disp_pwm0_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_PWM1_SOF, disp_pwm1_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_OD_SOF, disp_od_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_DSC_SOF, disp_dsc_sof)
DECLAR_EVENT(CMDQ_EVENT_UFOD_RAMA0_L0_SOF, ufod_rdma0_l0_sof)
DECLAR_EVENT(CMDQ_EVENT_UFOD_RAMA0_L1_SOF, ufod_rdma0_l1_sof)
DECLAR_EVENT(CMDQ_EVENT_UFOD_RAMA0_L2_SOF, ufod_rdma0_l2_sof)
DECLAR_EVENT(CMDQ_EVENT_UFOD_RAMA0_L3_SOF, ufod_rdma0_l3_sof)
DECLAR_EVENT(CMDQ_EVENT_UFOD_RAMA1_L0_SOF, ufod_rdma1_l0_sof)
DECLAR_EVENT(CMDQ_EVENT_UFOD_RAMA1_L1_SOF, ufod_rdma1_l1_sof)
DECLAR_EVENT(CMDQ_EVENT_UFOD_RAMA1_L2_SOF, ufod_rdma1_l2_sof)
DECLAR_EVENT(CMDQ_EVENT_UFOD_RAMA1_L3_SOF, ufod_rdma1_l3_sof)
/* MDP frame done */
DECLAR_EVENT(CMDQ_EVENT_MDP_RDMA0_EOF, mdp_rdma0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_RDMA1_EOF, mdp_rdma1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_RSZ0_EOF, mdp_rsz0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_RSZ1_EOF, mdp_rsz1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_RSZ2_EOF, mdp_rsz2_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_TDSHP_EOF, mdp_tdshp_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_TDSHP0_EOF, mdp_tdshp0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_TDSHP1_EOF, mdp_tdshp1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WDMA_EOF, mdp_wdma_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT_WRITE_EOF, mdp_wrot_write_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT_READ_EOF, mdp_wrot_read_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT0_WRITE_EOF,
mdp_wrot0_write_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT0_READ_EOF, mdp_wrot0_read_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT1_WRITE_EOF,
mdp_wrot1_write_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT1_READ_EOF, mdp_wrot1_read_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT0_W_EOF, mdp_wrot0_write_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT0_R_EOF, mdp_wrot0_read_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT1_W_EOF, mdp_wrot1_write_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT1_R_EOF, mdp_wrot1_read_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_COLOR_EOF, mdp_color_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_CROP_EOF, mdp_crop_frame_done)
/* Display frame done */
DECLAR_EVENT(CMDQ_EVENT_DISP_OVL0_EOF, disp_ovl0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_OVL1_EOF, disp_ovl1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_2L_OVL0_EOF, disp_2l_ovl0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_2L_OVL1_EOF, disp_2l_ovl1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_RDMA0_EOF, disp_rdma0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_RDMA1_EOF, disp_rdma1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_RDMA2_EOF, disp_rdma2_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_WDMA0_EOF, disp_wdma0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_WDMA1_EOF, disp_wdma1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_COLOR_EOF, disp_color_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_COLOR0_EOF, disp_color0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_COLOR1_EOF, disp_color1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_CCORR_EOF, disp_ccorr_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_CCORR0_EOF, disp_ccorr0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_CCORR1_EOF, disp_ccorr1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_AAL_EOF, disp_aal_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_AAL0_EOF, disp_aal0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_AAL1_EOF, disp_aal1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_GAMMA_EOF, disp_gamma_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_GAMMA0_EOF, disp_gamma0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_GAMMA1_EOF, disp_gamma1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_DITHER_EOF, disp_dither_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_DITHER0_EOF, disp_dither0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_DITHER1_EOF, disp_dither1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_UFOE_EOF, disp_ufoe_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_OD_EOF, disp_od_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_OD_RDMA_EOF, disp_od_rdma_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_OD_WDMA_EOF, disp_od_wdma_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_DSC_EOF, disp_dsc_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_DSI0_EOF, disp_dsi0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_DSI1_EOF, disp_dsi1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_DPI0_EOF, disp_dpi0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_UFOD_RAMA0_L0_EOF, ufod_rdma0_l0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_UFOD_RAMA0_L1_EOF, ufod_rdma0_l1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_UFOD_RAMA0_L2_EOF, ufod_rdma0_l2_frame_done)
DECLAR_EVENT(CMDQ_EVENT_UFOD_RAMA0_L3_EOF, ufod_rdma0_l3_frame_done)
DECLAR_EVENT(CMDQ_EVENT_UFOD_RAMA1_L0_EOF, ufod_rdma1_l0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_UFOD_RAMA1_L1_EOF, ufod_rdma1_l1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_UFOD_RAMA1_L2_EOF, ufod_rdma1_l2_frame_done)
DECLAR_EVENT(CMDQ_EVENT_UFOD_RAMA1_L3_EOF, ufod_rdma1_l3_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_POSTMASK0_SOF, disp_postmask0_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_POSTMASK0_FRAME_DONE,
disp_postmask0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_POSTMASK0_FRAME_RST_DONE_PULSE,
disp_postmask0_frame_rst_done_pulse)
/* Mutex frame done */
/* DISPSYS */
DECLAR_EVENT(CMDQ_EVENT_MUTEX0_STREAM_EOF, stream_done_0)
/* DISPSYS */
DECLAR_EVENT(CMDQ_EVENT_MUTEX1_STREAM_EOF, stream_done_1)
/* DISPSYS */
DECLAR_EVENT(CMDQ_EVENT_MUTEX2_STREAM_EOF, stream_done_2)
/* DISPSYS */
DECLAR_EVENT(CMDQ_EVENT_MUTEX3_STREAM_EOF, stream_done_3)
/* DISPSYS, please refer to disp_hal.h */
DECLAR_EVENT(CMDQ_EVENT_MUTEX4_STREAM_EOF, stream_done_4)
/* DpFramework */
DECLAR_EVENT(CMDQ_EVENT_MUTEX5_STREAM_EOF, stream_done_5)
/* DpFramework */
DECLAR_EVENT(CMDQ_EVENT_MUTEX6_STREAM_EOF, stream_done_6)
/* DpFramework */
DECLAR_EVENT(CMDQ_EVENT_MUTEX7_STREAM_EOF, stream_done_7)
/* DpFramework */
DECLAR_EVENT(CMDQ_EVENT_MUTEX8_STREAM_EOF, stream_done_8)
/* DpFramework via CMDQ_IOCTL_LOCK_MUTEX */
DECLAR_EVENT(CMDQ_EVENT_MUTEX9_STREAM_EOF, stream_done_9)
DECLAR_EVENT(CMDQ_EVENT_MUTEX10_STREAM_EOF, stream_done_10)
DECLAR_EVENT(CMDQ_EVENT_MUTEX11_STREAM_EOF, stream_done_11)
DECLAR_EVENT(CMDQ_EVENT_MUTEX12_STREAM_EOF, stream_done_12)
DECLAR_EVENT(CMDQ_EVENT_MUTEX13_STREAM_EOF, stream_done_13)
DECLAR_EVENT(CMDQ_EVENT_MUTEX14_STREAM_EOF, stream_done_14)
DECLAR_EVENT(CMDQ_EVENT_MUTEX15_STREAM_EOF, stream_done_15)
/* Display underrun */
DECLAR_EVENT(CMDQ_EVENT_DISP_RDMA0_UNDERRUN, buf_underrun_event_0)
DECLAR_EVENT(CMDQ_EVENT_DISP_RDMA1_UNDERRUN, buf_underrun_event_1)
DECLAR_EVENT(CMDQ_EVENT_DISP_RDMA2_UNDERRUN, buf_underrun_event_2)
DECLAR_EVENT(CMDQ_EVENT_DISP_RDMA3_UNDERRUN, buf_underrun_event_3)
/* Display TE */
DECLAR_EVENT(CMDQ_EVENT_DSI_TE, dsi0_te_event)
DECLAR_EVENT(CMDQ_EVENT_DSI0_TE, dsi0_te_event)
DECLAR_EVENT(CMDQ_EVENT_DSI1_TE, dsi1_te_event)
DECLAR_EVENT(CMDQ_EVENT_MDP_DSI0_TE_SOF, mdp_dsi0_te_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_DSI1_TE_SOF, mdp_dsi1_te_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_DSI0_SOF, disp_dsi0_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_DSI1_SOF, disp_dsi1_sof)
DECLAR_EVENT(CMDQ_EVENT_DSI0_TO_GCE_MMCK0, dsi0_to_gce_mmck0)
DECLAR_EVENT(CMDQ_EVENT_DSI0_TO_GCE_MMCK1, dsi0_to_gce_mmck1)
DECLAR_EVENT(CMDQ_EVENT_DSI0_TO_GCE_MMCK2, dsi0_to_gce_mmck2)
DECLAR_EVENT(CMDQ_EVENT_DSI0_TO_GCE_MMCK3, dsi0_to_gce_mmck3)
DECLAR_EVENT(CMDQ_EVENT_DSI0_TO_GCE_MMCK4, dsi0_to_gce_mmck4)
DECLAR_EVENT(CMDQ_EVENT_DSI1_TO_GCE_MMCK0, dsi1_to_gce_mmck0)
DECLAR_EVENT(CMDQ_EVENT_DSI1_TO_GCE_MMCK1, dsi1_to_gce_mmck1)
DECLAR_EVENT(CMDQ_EVENT_DSI1_TO_GCE_MMCK2, dsi1_to_gce_mmck2)
DECLAR_EVENT(CMDQ_EVENT_DSI1_TO_GCE_MMCK3, dsi1_to_gce_mmck3)
DECLAR_EVENT(CMDQ_EVENT_DSI1_TO_GCE_MMCK4, dsi1_to_gce_mmck4)
DECLAR_EVENT(CMDQ_EVENT_DSI0_IRQ_EVENT, dsi0_irq_event)
DECLAR_EVENT(CMDQ_EVENT_DSI0_DONE_EVENT, dsi0_done_event)
DECLAR_EVENT(CMDQ_EVENT_DSI1_IRQ_EVENT, dsi1_irq_event)
DECLAR_EVENT(CMDQ_EVENT_DSI1_DONE_EVENT, dsi1_done_event)
/* Reset Event */
DECLAR_EVENT(CMDQ_EVENT_DISP_WDMA0_RST_DONE, disp_wdma0_rst_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_WDMA1_RST_DONE, disp_wdma1_rst_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT0_RST_DONE, mdp_wrot0_rst_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT1_RST_DONE, mdp_wrot1_rst_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WDMA_RST_DONE, mdp_wdma_rst_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_RDMA0_RST_DONE, mdp_rdma0_rst_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_RDMA1_RST_DONE, mdp_rdma1_rst_done)
/* Display Mutex */
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD0,
disp_mutex_all_module_upd0)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD1,
disp_mutex_all_module_upd1)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD2,
disp_mutex_all_module_upd2)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD3,
disp_mutex_all_module_upd3)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD4,
disp_mutex_all_module_upd4)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD5,
disp_mutex_all_module_upd5)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD6,
disp_mutex_all_module_upd6)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD7,
disp_mutex_all_module_upd7)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD8,
disp_mutex_all_module_upd8)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD9,
disp_mutex_all_module_upd9)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD10,
disp_mutex_all_module_upd10)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD11,
disp_mutex_all_module_upd11)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD12,
disp_mutex_all_module_upd12)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD13,
disp_mutex_all_module_upd13)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD14,
disp_mutex_all_module_upd14)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD15,
disp_mutex_all_module_upd15)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE0,
disp_mutex_reg_upd_for_module0)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE1,
disp_mutex_reg_upd_for_module1)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE2,
disp_mutex_reg_upd_for_module2)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE3,
disp_mutex_reg_upd_for_module3)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE4,
disp_mutex_reg_upd_for_module4)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE5,
disp_mutex_reg_upd_for_module5)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE6,
disp_mutex_reg_upd_for_module6)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE7,
disp_mutex_reg_upd_for_module7)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE8,
disp_mutex_reg_upd_for_module8)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE9,
disp_mutex_reg_upd_for_module9)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE10,
disp_mutex_reg_upd_for_module10)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE11,
disp_mutex_reg_upd_for_module11)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE12,
disp_mutex_reg_upd_for_module12)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE13,
disp_mutex_reg_upd_for_module13)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE14,
disp_mutex_reg_upd_for_module14)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE15,
disp_mutex_reg_upd_for_module15)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE16,
disp_mutex_reg_upd_for_module16)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE17,
disp_mutex_reg_upd_for_module17)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE18,
disp_mutex_reg_upd_for_module18)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE19,
disp_mutex_reg_upd_for_module19)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE20,
disp_mutex_reg_upd_for_module20)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE21,
disp_mutex_reg_upd_for_module21)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE22,
disp_mutex_reg_upd_for_module22)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE23,
disp_mutex_reg_upd_for_module23)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE24,
disp_mutex_reg_upd_for_module24)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE25,
disp_mutex_reg_upd_for_module25)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE26,
disp_mutex_reg_upd_for_module26)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE27,
disp_mutex_reg_upd_for_module27)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE28,
disp_mutex_reg_upd_for_module28)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE29,
disp_mutex_reg_upd_for_module29)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE30,
disp_mutex_reg_upd_for_module30)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE31,
disp_mutex_reg_upd_for_module31)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE32,
disp_mutex_reg_upd_for_module32)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE33,
disp_mutex_reg_upd_for_module33)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE34,
disp_mutex_reg_upd_for_module34)
/* ISP frame done */
DECLAR_EVENT(CMDQ_EVENT_ISP_PASS2_2_EOF, isp_frame_done_p2_2)
DECLAR_EVENT(CMDQ_EVENT_ISP_PASS2_1_EOF, isp_frame_done_p2_1)
DECLAR_EVENT(CMDQ_EVENT_ISP_PASS2_0_EOF, isp_frame_done_p2_0)
DECLAR_EVENT(CMDQ_EVENT_ISP_PASS1_1_EOF, isp_frame_done_p1_1)
DECLAR_EVENT(CMDQ_EVENT_ISP_PASS1_0_EOF, isp_frame_done_p1_0)
/* ISP (IMGSYS) frame done */
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD0_EOF, dip_cq_thread0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD1_EOF, dip_cq_thread1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD2_EOF, dip_cq_thread2_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD3_EOF, dip_cq_thread3_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD4_EOF, dip_cq_thread4_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD5_EOF, dip_cq_thread5_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD6_EOF, dip_cq_thread6_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD7_EOF, dip_cq_thread7_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD8_EOF, dip_cq_thread8_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD9_EOF, dip_cq_thread9_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD10_EOF,
dip_cq_thread10_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD11_EOF,
dip_cq_thread11_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD12_EOF,
dip_cq_thread12_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD13_EOF,
dip_cq_thread13_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD14_EOF,
dip_cq_thread14_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD15_EOF,
dip_cq_thread15_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD16_EOF,
dip_cq_thread16_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD17_EOF,
dip_cq_thread17_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD18_EOF,
dip_cq_thread18_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DPE_EOF, dpe_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DVE_EOF, dve_frame_done)
DECLAR_EVENT(CMDQ_EVENT_WMF_EOF, wmf_frame_done)
DECLAR_EVENT(CMDQ_EVENT_GEPF_EOF, gepf_frame_done)
DECLAR_EVENT(CMDQ_EVENT_GEPF_TEMP_EOF, gepf_temp_frame_done)
DECLAR_EVENT(CMDQ_EVENT_GEPF_BYPASS_EOF, gepf_bypass_frame_done)
DECLAR_EVENT(CMDQ_EVENT_RSC_EOF, rsc_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_DMA_ERR_EVENT, dip_dma_err_event)
/* ISP (IMGSYS) engine events */
DECLAR_EVENT(CMDQ_EVENT_ISP_SENINF_CAM1_2_3_FULL,
seninf_cam1_2_3_fifo_full)
DECLAR_EVENT(CMDQ_EVENT_ISP_SENINF_CAM0_FULL, seninf_cam0_fifo_full)
/* VENC frame done */
DECLAR_EVENT(CMDQ_EVENT_VENC_EOF, venc_done)
DECLAR_EVENT(CMDQ_EVENT_VENC_CMDQ_PAUSE_DONE, venc_cmdq_pause_done)
/* JPEG frame done */
DECLAR_EVENT(CMDQ_EVENT_JPEG_ENC_EOF, jpgenc_done)
DECLAR_EVENT(CMDQ_EVENT_JPEG_ENC_PASS2_EOF, jpgenc_pass2_done)
DECLAR_EVENT(CMDQ_EVENT_JPEG_ENC_PASS1_EOF, jpgenc_pass1_done)
DECLAR_EVENT(CMDQ_EVENT_JPEG_DEC_EOF, jpgdec_done)
/* VENC engine events */
DECLAR_EVENT(CMDQ_EVENT_VENC_MB_DONE, venc_mb_done)
DECLAR_EVENT(CMDQ_EVENT_VENC_128BYTE_CNT_DONE, venc_128byte_cnt_done)
/* ISP (CAMSYS) frame done */
DECLAR_EVENT(CMDQ_EVENT_ISP_FRAME_DONE_A, isp_frame_done_a)
DECLAR_EVENT(CMDQ_EVENT_ISP_FRAME_DONE_B, isp_frame_done_b)
DECLAR_EVENT(CMDQ_EVENT_ISP_FRAME_DONE_C, isp_frame_done_c)
DECLAR_EVENT(CMDQ_EVENT_ISP_CAMSV_0_PASS1_DONE, camsv_0_pass1_done)
DECLAR_EVENT(CMDQ_EVENT_ISP_CAMSV_0_2_PASS1_DONE, camsv_0_2_pass1_done)
DECLAR_EVENT(CMDQ_EVENT_ISP_CAMSV_1_PASS1_DONE, camsv_1_pass1_done)
DECLAR_EVENT(CMDQ_EVENT_ISP_CAMSV_2_PASS1_DONE, camsv_2_pass1_done)
DECLAR_EVENT(CMDQ_EVENT_ISP_CAMSV_3_PASS1_DONE, camsv_3_pass1_done)
DECLAR_EVENT(CMDQ_EVENT_ISP_TSF_DONE, tsf_done)
DECLAR_EVENT(CMDQ_EVENT_ISP_RELAY_SOF, isp_relay_sof)
DECLAR_EVENT(CMDQ_EVENT_IPU_RELAY_SOF, ipu_relay_sof)
/* ISP (CAMSYS) engine events */
DECLAR_EVENT(CMDQ_EVENT_SENINF_0_FIFO_FULL, seninf_0_fifo_full)
DECLAR_EVENT(CMDQ_EVENT_SENINF_1_FIFO_FULL, seninf_1_fifo_full)
DECLAR_EVENT(CMDQ_EVENT_SENINF_2_FIFO_FULL, seninf_2_fifo_full)
DECLAR_EVENT(CMDQ_EVENT_SENINF_3_FIFO_FULL, seninf_3_fifo_full)
DECLAR_EVENT(CMDQ_EVENT_SENINF_4_FIFO_FULL, seninf_4_fifo_full)
DECLAR_EVENT(CMDQ_EVENT_SENINF_5_FIFO_FULL, seninf_5_fifo_full)
DECLAR_EVENT(CMDQ_EVENT_SENINF_6_FIFO_FULL, seninf_6_fifo_full)
DECLAR_EVENT(CMDQ_EVENT_SENINF_7_FIFO_FULL, seninf_7_fifo_full)
DECLAR_EVENT(CMDQ_EVENT_TG_OVRUN_A_INT_DLY, tg_ovrun_a_int_dly)
DECLAR_EVENT(CMDQ_EVENT_TG_OVRUN_B_INT_DLY, tg_ovrun_b_int_dly)
DECLAR_EVENT(CMDQ_EVENT_TG_OVRUN_C_INT, tg_ovrun_c_int)
DECLAR_EVENT(CMDQ_EVENT_TG_GRABERR_A_INT_DLY, tg_graberr_a_int_dly)
DECLAR_EVENT(CMDQ_EVENT_TG_GRABERR_B_INT_DLY, tg_graberr_b_int_dly)
DECLAR_EVENT(CMDQ_EVENT_TG_GRABERR_C_INT, tg_graberr_c_int)
DECLAR_EVENT(CMDQ_EVENT_CQ_VR_SNAP_A_INT_DLY, cq_vr_snap_a_int_dly)
DECLAR_EVENT(CMDQ_EVENT_CQ_VR_SNAP_B_INT_DLY, cq_vr_snap_b_int_dly)
DECLAR_EVENT(CMDQ_EVENT_CQ_VR_SNAP_C_INT, cq_vr_snap_c_int)
/* 6799 New Event */
DECLAR_EVENT(CMDQ_EVENT_DISP_DSC1_SOF, disp_dsc_sof_1)
DECLAR_EVENT(CMDQ_EVENT_DISP_DSC2_SOF, disp_dsc_sof_2)
DECLAR_EVENT(CMDQ_EVENT_DISP_RSZ0_SOF, disp_rsz0_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_RSZ1_SOF, disp_rsz1_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_DSC0_EOF, disp_dsc_frame_done_0)
DECLAR_EVENT(CMDQ_EVENT_DISP_DSC1_EOF, disp_dsc_frame_done_1)
DECLAR_EVENT(CMDQ_EVENT_DISP_RSZ0_EOF, disp_rsz0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_RSZ1_EOF, disp_rsz1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_OVL0_RST_DONE,
disp_ovl0_frame_rst_done_pusle)
DECLAR_EVENT(CMDQ_EVENT_DISP_OVL1_RST_DONE,
disp_ovl1_frame_rst_done_pusle)
DECLAR_EVENT(CMDQ_EVENT_DISP_OVL0_2L_RST_DONE,
disp_ovl0_2l_frame_rst_done_pusle)
DECLAR_EVENT(CMDQ_EVENT_DISP_OVL1_2L_RST_DONE,
disp_ovl1_2l_frame_rst_done_pusle)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE35,
disp_mutex_reg_upd_for_module35)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE36,
disp_mutex_reg_upd_for_module36)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE37,
disp_mutex_reg_upd_for_module37)
DECLAR_EVENT(CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE38,
disp_mutex_reg_upd_for_module38)
DECLAR_EVENT(CMDQ_EVENT_WPE_A_EOF, wpe_a_frame_done)
DECLAR_EVENT(CMDQ_EVENT_EAF_EOF, eaf_frame_done)
DECLAR_EVENT(CMDQ_EVENT_VENC_BSDMA_FULL, venc_bsdma_full)
DECLAR_EVENT(CMDQ_EVENT_IPU0_EOF, ipu_done_0)
DECLAR_EVENT(CMDQ_EVENT_IPU1_EOF, ipu_done_1)
DECLAR_EVENT(CMDQ_EVENT_IPU2_EOF, ipu_done_2)
DECLAR_EVENT(CMDQ_EVENT_IPU3_EOF, ipu_done_3)
/* 6759 New Event */
DECLAR_EVENT(CMDQ_EVENT_DISP_SPLIT_SOF, disp_split_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_SPLIT_FRAME_DONE, disp_split_frame_done)
DECLAR_EVENT(CMDQ_EVENT_AMD_FRAME_DONE, amd_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_DPI0_SOF, disp_dpi0_sof)
DECLAR_EVENT(CMDQ_EVENT_DSI0_TE_INFRA, dsi0_te_from_infra)
/* 6739 New Event*/
DECLAR_EVENT(CMDQ_EVENT_DISP_DBI0_SOF, disp_dbi0_sof)
DECLAR_EVENT(CMDQ_EVENT_DISP_DBI0_EOF, disp_dbi0_frame_done)
/* 6775 New Event */
DECLAR_EVENT(CMDQ_EVENT_MDP_CCORR_SOF, mdp_ccorr_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_CCORR_FRAME_DONE, mdp_ccorr_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_AAL_FRAME_DONE, mdp_aal_frame_done)
DECLAR_EVENT(CMDQ_EVENT_WPE_B_FRAME_DONE, wpe_b_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MFB_DONE, mfb_done)
DECLAR_EVENT(CMDQ_EVENT_OCC_DONE, occ_done)
DECLAR_EVENT(CMDQ_EVENT_IPU_DONE_1_0, ipu_done_1_0)
DECLAR_EVENT(CMDQ_EVENT_IPU_DONE_1_1, ipu_done_1_1)
DECLAR_EVENT(CMDQ_EVENT_IPU_DONE_1_2, ipu_done_1_2)
DECLAR_EVENT(CMDQ_EVENT_IPU_DONE_1_3, ipu_done_1_3)
DECLAR_EVENT(CMDQ_EVENT_IPU_DONE_2_0, ipu_done_2_0)
DECLAR_EVENT(CMDQ_EVENT_IPU_DONE_2_1, ipu_done_2_1)
DECLAR_EVENT(CMDQ_EVENT_IPU_DONE_2_2, ipu_done_2_2)
DECLAR_EVENT(CMDQ_EVENT_IPU_DONE_2_3, ipu_done_2_3)
/* 6765 */
DECLAR_EVENT(CMDQ_EVENT_MDP_CCORR0_SOF, mdp_ccorr0_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_CCORR0_FRAME_DONE, mdp_ccorr0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG_DL_RELAY_SOF, img_dl_relay_sof)
/* 6779 New Event */
DECLAR_EVENT(CMDQ_EVENT_DMA_R1_ERROR_A_INT_DLY, dma_r1_error_a_int_dly)
DECLAR_EVENT(CMDQ_EVENT_DMA_R1_ERROR_B_INT_DLY, dma_r1_error_b_int_dly)
DECLAR_EVENT(CMDQ_EVENT_DMA_R1_ERROR_C_INT, dma_r1_error_c_int)
DECLAR_EVENT(CMDQ_EVENT_APU_GCE_CORE0_EVENT_0, apu_gce_core0_event_0)
DECLAR_EVENT(CMDQ_EVENT_APU_GCE_CORE0_EVENT_1, apu_gce_core0_event_1)
DECLAR_EVENT(CMDQ_EVENT_APU_GCE_CORE0_EVENT_2, apu_gce_core0_event_2)
DECLAR_EVENT(CMDQ_EVENT_APU_GCE_CORE0_EVENT_3, apu_gce_core0_event_3)
DECLAR_EVENT(CMDQ_EVENT_APU_GCE_CORE1_EVENT_0, apu_gce_core1_event_0)
DECLAR_EVENT(CMDQ_EVENT_APU_GCE_CORE1_EVENT_1, apu_gce_core1_event_1)
DECLAR_EVENT(CMDQ_EVENT_APU_GCE_CORE1_EVENT_2, apu_gce_core1_event_2)
DECLAR_EVENT(CMDQ_EVENT_APU_GCE_CORE1_EVENT_3, apu_gce_core1_event_3)
DECLAR_EVENT(CMDQ_EVENT_VDEC_EVENT_0, vdec_event_0)
DECLAR_EVENT(CMDQ_EVENT_VDEC_EVENT_1, vdec_event_1)
DECLAR_EVENT(CMDQ_EVENT_VDEC_EVENT_2, vdec_event_2)
DECLAR_EVENT(CMDQ_EVENT_VDEC_EVENT_3, vdec_event_3)
DECLAR_EVENT(CMDQ_EVENT_VDEC_EVENT_4, vdec_event_4)
DECLAR_EVENT(CMDQ_EVENT_VDEC_EVENT_5, vdec_event_5)
DECLAR_EVENT(CMDQ_EVENT_VDEC_EVENT_6, vdec_event_6)
DECLAR_EVENT(CMDQ_EVENT_VDEC_EVENT_7, vdec_event_7)
DECLAR_EVENT(CMDQ_EVENT_VDEC_EVENT_8, vdec_event_8)
DECLAR_EVENT(CMDQ_EVENT_VDEC_EVENT_9, vdec_event_9)
DECLAR_EVENT(CMDQ_EVENT_VDEC_EVENT_10, vdec_event_10)
DECLAR_EVENT(CMDQ_EVENT_VDEC_EVENT_11, vdec_event_11)
DECLAR_EVENT(CMDQ_EVENT_VDEC_EVENT_12, vdec_event_12)
DECLAR_EVENT(CMDQ_EVENT_VDEC_EVENT_13, vdec_event_13)
DECLAR_EVENT(CMDQ_EVENT_VDEC_EVENT_14, vdec_event_14)
DECLAR_EVENT(CMDQ_EVENT_VDEC_EVENT_15, vdec_event_15)
DECLAR_EVENT(CMDQ_EVENT_FDVT_DONE, fdvt_done)
DECLAR_EVENT(CMDQ_EVENT_FE_DONE, fe_done)
DECLAR_EVENT(CMDQ_EVENT_DVS_DONE_ASYNC_SHOT, dvs_done_async_shot)
DECLAR_EVENT(CMDQ_EVENT_DVP_DONE_ASYNC_SHOT, dvp_done_async_shot)
DECLAR_EVENT(CMDQ_EVENT_VENC_FRAME_DONE, venc_frame_done)
DECLAR_EVENT(CMDQ_EVENT_VENC_PAUSE_DONE, venc_pause_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_0,
dip_cq_thread0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_1,
dip_cq_thread1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_2,
dip_cq_thread2_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_3,
dip_cq_thread3_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_4,
dip_cq_thread4_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_5,
dip_cq_thread5_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_6,
dip_cq_thread6_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_7,
dip_cq_thread7_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_8,
dip_cq_thread8_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_9,
dip_cq_thread9_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_10,
dip_cq_thread10_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_11,
dip_cq_thread11_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_12,
dip_cq_thread12_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_13,
dip_cq_thread13_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_14,
dip_cq_thread14_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_15,
dip_cq_thread15_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_16,
dip_cq_thread16_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_17,
dip_cq_thread17_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_18,
dip_cq_thread18_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_19,
dip_cq_thread19_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_20,
dip_cq_thread20_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_21,
dip_cq_thread21_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_22,
dip_cq_thread22_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_23,
dip_cq_thread23_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_0,
dip2_cq_thread0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_1,
dip2_cq_thread1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_2,
dip2_cq_thread2_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_3,
dip2_cq_thread3_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_4,
dip2_cq_thread4_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_5,
dip2_cq_thread5_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_6,
dip2_cq_thread6_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_7,
dip2_cq_thread7_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_8,
dip2_cq_thread8_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_9,
dip2_cq_thread9_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_10,
dip2_cq_thread10_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_11,
dip2_cq_thread11_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_12,
dip2_cq_thread12_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_13,
dip2_cq_thread13_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_14,
dip2_cq_thread14_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_15,
dip2_cq_thread15_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_16,
dip2_cq_thread16_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_17,
dip2_cq_thread17_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_18,
dip2_cq_thread18_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_19,
dip2_cq_thread19_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_20,
dip2_cq_thread20_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_21,
dip2_cq_thread21_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_22,
dip2_cq_thread22_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_23,
dip2_cq_thread23_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IPE_EVENT_TX_FRAME_DONE_0,
ipe_event_tx_frame_done_0)
DECLAR_EVENT(CMDQ_EVENT_IPE_EVENT_TX_FRAME_DONE_1,
ipe_event_tx_frame_done_1)
DECLAR_EVENT(CMDQ_EVENT_IPE_EVENT_TX_FRAME_DONE_2,
ipe_event_tx_frame_done_2)
DECLAR_EVENT(CMDQ_EVENT_IPE_EVENT_TX_FRAME_DONE_3,
ipe_event_tx_frame_done_3)
DECLAR_EVENT(CMDQ_EVENT_IPE_EVENT_TX_FRAME_DONE_4,
ipe_event_tx_frame_done_4)
/* Keep this at the end of HW events */
DECLAR_EVENT(CMDQ_MAX_HW_EVENT_COUNT, hw_event_conunt)
/* SW Sync Tokens (Pre-defined) */
/* Config thread notify trigger thread */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_CONFIG_DIRTY, sw_token)
/* Trigger thread notify config thread */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_STREAM_EOF, sw_token)
/* Block Trigger thread until the ESD check finishes. */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_ESD_EOF, sw_token)
/* check CABC setup finish */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_CABC_EOF, sw_token)
/* Block Trigger thread until the path freeze finishes */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_FREEZE_EOF, sw_token)
/* Pass-2 notifies VENC frame is ready to be encoded */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_VENC_INPUT_READY, sw_token)
/* VENC notifies Pass-2 encode done so next frame may start */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_VENC_EOF, sw_token)
/* Notify normal CMDQ there are some secure task done */
DECLAR_EVENT(CMDQ_SYNC_SECURE_THR_EOF, sw_token)
/* Lock WSM resource */
DECLAR_EVENT(CMDQ_SYNC_SECURE_WSM_LOCK, sw_token)
/* SW Sync Tokens (User-defined) */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_USER_0, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_USER_1, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_POLL_MONITOR, sw_token)
/* SW Sync Tokens (Pre-defined) */
/* Config thread notify trigger thread for external display */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_EXT_CONFIG_DIRTY, sw_token)
/* Trigger thread notify config thread */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_EXT_STREAM_EOF, sw_token)
/* Check CABC setup finish */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_EXT_CABC_EOF, sw_token)
/* Secure video path notify SW token */
DECLAR_EVENT(CMDQ_SYNC_DISP_OVL0_2NONSEC_END, sw_token)
DECLAR_EVENT(CMDQ_SYNC_DISP_OVL1_2NONSEC_END, sw_token)
DECLAR_EVENT(CMDQ_SYNC_DISP_2LOVL0_2NONSEC_END, sw_token)
DECLAR_EVENT(CMDQ_SYNC_DISP_2LOVL1_2NONSEC_END, sw_token)
DECLAR_EVENT(CMDQ_SYNC_DISP_RDMA0_2NONSEC_END, sw_token)
DECLAR_EVENT(CMDQ_SYNC_DISP_RDMA1_2NONSEC_END, sw_token)
DECLAR_EVENT(CMDQ_SYNC_DISP_WDMA0_2NONSEC_END, sw_token)
DECLAR_EVENT(CMDQ_SYNC_DISP_WDMA1_2NONSEC_END, sw_token)
DECLAR_EVENT(CMDQ_SYNC_DISP_EXT_STREAM_EOF, 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.
*/
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR0, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR1, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR2, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR3, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR4, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR5, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR6, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR7, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR8, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR9, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR10, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR11, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR12, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR13, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR14, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR15, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR16, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR17, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR18, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR19, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR20, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR21, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR22, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_APPEND_THR23, sw_token)
/* GPR access tokens (for HW register backup)
* There are 15 32-bit GPR, 3 GPR form a set
* (64-bit for address, 32-bit for value)
*/
DECLAR_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_0, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_1, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_2, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_3, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_4, sw_token)
/* Resource lock event to control resource in GCE thread */
DECLAR_EVENT(CMDQ_SYNC_RESOURCE_WROT0, sw_token)
DECLAR_EVENT(CMDQ_SYNC_RESOURCE_WROT1, sw_token)
/* GCE HW TPR Event*/
DECLAR_EVENT(CMDQ_EVENT_TIMER_00, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_01, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_02, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_03, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_04, sw_token)
/* 5: 1us */
DECLAR_EVENT(CMDQ_EVENT_TIMER_05, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_06, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_07, sw_token)
/* 8: 10us */
DECLAR_EVENT(CMDQ_EVENT_TIMER_08, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_09, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_10, sw_token)
/* 11: 100us */
DECLAR_EVENT(CMDQ_EVENT_TIMER_11, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_12, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_13, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_14, sw_token)
/* 15: 1ms */
DECLAR_EVENT(CMDQ_EVENT_TIMER_15, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_16, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_17, sw_token)
/* 18: 10ms */
DECLAR_EVENT(CMDQ_EVENT_TIMER_18, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_19, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_20, sw_token)
/* 21: 100ms */
DECLAR_EVENT(CMDQ_EVENT_TIMER_21, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_22, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_23, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_24, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_25, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_26, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_27, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_28, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_29, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_30, sw_token)
DECLAR_EVENT(CMDQ_EVENT_TIMER_31, sw_token)
/* event id is 10 bit */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_MAX, max_token)
};
struct cmdq_event_table *cmdq_event_get_table(void)
{
return cmdq_events;
}
u32 cmdq_event_get_table_size(void)
{
return ARRAY_SIZE(cmdq_events);
}
@@ -0,0 +1,660 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef CMDQ_EVENT_COMMON
#define CMDQ_EVENT_COMMON
/* Define CMDQ events
*
* For hardware event must define in device tree.
* For SW event assign event ID here directly.
*
* Note: event name must sync to cmdq_events table in cmdq_event_common.c
*/
enum cmdq_event {
/* MDP start frame */
CMDQ_EVENT_MDP_RDMA0_SOF, /* 0 */
CMDQ_EVENT_MDP_RDMA1_SOF, /* 1 */
CMDQ_EVENT_MDP_RSZ0_SOF, /* 2 */
CMDQ_EVENT_MDP_RSZ1_SOF, /* 3 */
CMDQ_EVENT_MDP_RSZ2_SOF, /* 4 */
CMDQ_EVENT_MDP_TDSHP_SOF, /* 5 */
CMDQ_EVENT_MDP_TDSHP0_SOF, /* 6 */
CMDQ_EVENT_MDP_TDSHP1_SOF, /* 7 */
CMDQ_EVENT_MDP_WDMA_SOF, /* 8 */
CMDQ_EVENT_MDP_WROT_SOF, /* 9 */
CMDQ_EVENT_MDP_WROT0_SOF, /* 10 */
CMDQ_EVENT_MDP_WROT1_SOF, /* 11 */
CMDQ_EVENT_MDP_COLOR_SOF, /* 12 */
CMDQ_EVENT_MDP_MVW_SOF, /* 13 */
CMDQ_EVENT_MDP_CROP_SOF, /* 14 */
CMDQ_EVENT_MDP_AAL_SOF, /* 15 */
/* Display start frame */
CMDQ_EVENT_DISP_OVL0_SOF, /* 16 */
CMDQ_EVENT_DISP_OVL1_SOF, /* 17 */
CMDQ_EVENT_DISP_2L_OVL0_SOF, /* 18 */
CMDQ_EVENT_DISP_2L_OVL1_SOF, /* 19 */
CMDQ_EVENT_DISP_RDMA0_SOF, /* 20 */
CMDQ_EVENT_DISP_RDMA1_SOF, /* 21 */
CMDQ_EVENT_DISP_RDMA2_SOF, /* 22 */
CMDQ_EVENT_DISP_WDMA0_SOF, /* 23 */
CMDQ_EVENT_DISP_WDMA1_SOF, /* 24 */
CMDQ_EVENT_DISP_COLOR_SOF, /* 25 */
CMDQ_EVENT_DISP_COLOR0_SOF, /* 26 */
CMDQ_EVENT_DISP_COLOR1_SOF, /* 27 */
CMDQ_EVENT_DISP_CCORR_SOF, /* 28 */
CMDQ_EVENT_DISP_CCORR0_SOF, /* 29 */
CMDQ_EVENT_DISP_CCORR1_SOF, /* 30 */
CMDQ_EVENT_DISP_AAL_SOF, /* 31 */
CMDQ_EVENT_DISP_AAL0_SOF, /* 32 */
CMDQ_EVENT_DISP_AAL1_SOF, /* 33 */
CMDQ_EVENT_DISP_GAMMA_SOF, /* 34 */
CMDQ_EVENT_DISP_GAMMA0_SOF, /* 35 */
CMDQ_EVENT_DISP_GAMMA1_SOF, /* 36 */
CMDQ_EVENT_DISP_DITHER_SOF, /* 37 */
CMDQ_EVENT_DISP_DITHER0_SOF, /* 38 */
CMDQ_EVENT_DISP_DITHER1_SOF, /* 39 */
CMDQ_EVENT_DISP_UFOE_SOF, /* 40 */
CMDQ_EVENT_DISP_PWM0_SOF, /* 41 */
CMDQ_EVENT_DISP_PWM1_SOF, /* 42 */
CMDQ_EVENT_DISP_OD_SOF, /* 43 */
CMDQ_EVENT_DISP_DSC_SOF, /* 44 */
CMDQ_EVENT_UFOD_RAMA0_L0_SOF, /* 45 */
CMDQ_EVENT_UFOD_RAMA0_L1_SOF, /* 46 */
CMDQ_EVENT_UFOD_RAMA0_L2_SOF, /* 47 */
CMDQ_EVENT_UFOD_RAMA0_L3_SOF, /* 48 */
CMDQ_EVENT_UFOD_RAMA1_L0_SOF, /* 49 */
CMDQ_EVENT_UFOD_RAMA1_L1_SOF, /* 50 */
CMDQ_EVENT_UFOD_RAMA1_L2_SOF, /* 51 */
CMDQ_EVENT_UFOD_RAMA1_L3_SOF, /* 52 */
/* MDP frame done */
CMDQ_EVENT_MDP_RDMA0_EOF, /* 53 */
CMDQ_EVENT_MDP_RDMA1_EOF, /* 54 */
CMDQ_EVENT_MDP_RSZ0_EOF, /* 55 */
CMDQ_EVENT_MDP_RSZ1_EOF, /* 56 */
CMDQ_EVENT_MDP_RSZ2_EOF, /* 57 */
CMDQ_EVENT_MDP_TDSHP_EOF, /* 58 */
CMDQ_EVENT_MDP_TDSHP0_EOF, /* 59 */
CMDQ_EVENT_MDP_TDSHP1_EOF, /* 60 */
CMDQ_EVENT_MDP_WDMA_EOF, /* 61 */
CMDQ_EVENT_MDP_WROT_WRITE_EOF, /* 62 */
CMDQ_EVENT_MDP_WROT_READ_EOF, /* 63 */
CMDQ_EVENT_MDP_WROT0_WRITE_EOF, /* 64 */
CMDQ_EVENT_MDP_WROT0_READ_EOF, /* 65 */
CMDQ_EVENT_MDP_WROT1_WRITE_EOF, /* 66 */
CMDQ_EVENT_MDP_WROT1_READ_EOF, /* 67 */
CMDQ_EVENT_MDP_WROT0_W_EOF, /* 68 */
CMDQ_EVENT_MDP_WROT0_R_EOF, /* 69 */
CMDQ_EVENT_MDP_WROT1_W_EOF, /* 70 */
CMDQ_EVENT_MDP_WROT1_R_EOF, /* 71 */
CMDQ_EVENT_MDP_COLOR_EOF, /* 72 */
CMDQ_EVENT_MDP_CROP_EOF, /* 73 */
/* Display frame done */
CMDQ_EVENT_DISP_OVL0_EOF, /* 74 */
CMDQ_EVENT_DISP_OVL1_EOF, /* 75 */
CMDQ_EVENT_DISP_2L_OVL0_EOF, /* 76 */
CMDQ_EVENT_DISP_2L_OVL1_EOF, /* 77 */
CMDQ_EVENT_DISP_RDMA0_EOF, /* 78 */
CMDQ_EVENT_DISP_RDMA1_EOF, /* 79 */
CMDQ_EVENT_DISP_RDMA2_EOF, /* 80 */
CMDQ_EVENT_DISP_WDMA0_EOF, /* 81 */
CMDQ_EVENT_DISP_WDMA1_EOF, /* 82 */
CMDQ_EVENT_DISP_COLOR_EOF, /* 83 */
CMDQ_EVENT_DISP_COLOR0_EOF, /* 84 */
CMDQ_EVENT_DISP_COLOR1_EOF, /* 85 */
CMDQ_EVENT_DISP_CCORR_EOF, /* 86 */
CMDQ_EVENT_DISP_CCORR0_EOF, /* 87 */
CMDQ_EVENT_DISP_CCORR1_EOF, /* 88 */
CMDQ_EVENT_DISP_AAL_EOF, /* 89 */
CMDQ_EVENT_DISP_AAL0_EOF, /* 90 */
CMDQ_EVENT_DISP_AAL1_EOF, /* 91 */
CMDQ_EVENT_DISP_GAMMA_EOF, /* 92 */
CMDQ_EVENT_DISP_GAMMA0_EOF, /* 93 */
CMDQ_EVENT_DISP_GAMMA1_EOF, /* 94 */
CMDQ_EVENT_DISP_DITHER_EOF, /* 95 */
CMDQ_EVENT_DISP_DITHER0_EOF, /* 96 */
CMDQ_EVENT_DISP_DITHER1_EOF, /* 97 */
CMDQ_EVENT_DISP_UFOE_EOF, /* 98 */
CMDQ_EVENT_DISP_OD_EOF, /* 99 */
CMDQ_EVENT_DISP_OD_RDMA_EOF, /* 100 */
CMDQ_EVENT_DISP_OD_WDMA_EOF, /* 101 */
CMDQ_EVENT_DISP_DSC_EOF, /* 102 */
CMDQ_EVENT_DISP_DSI0_EOF, /* 103 */
CMDQ_EVENT_DISP_DSI1_EOF, /* 104 */
CMDQ_EVENT_DISP_DPI0_EOF, /* 105 */
CMDQ_EVENT_UFOD_RAMA0_L0_EOF, /* 106 */
CMDQ_EVENT_UFOD_RAMA0_L1_EOF, /* 107 */
CMDQ_EVENT_UFOD_RAMA0_L2_EOF, /* 108 */
CMDQ_EVENT_UFOD_RAMA0_L3_EOF, /* 109 */
CMDQ_EVENT_UFOD_RAMA1_L0_EOF, /* 110 */
CMDQ_EVENT_UFOD_RAMA1_L1_EOF, /* 111 */
CMDQ_EVENT_UFOD_RAMA1_L2_EOF, /* 112 */
CMDQ_EVENT_UFOD_RAMA1_L3_EOF, /* 113 */
CMDQ_EVENT_DISP_POSTMASK0_SOF, /* 114 */
CMDQ_EVENT_DISP_POSTMASK0_FRAME_DONE, /* 115 */
CMDQ_EVENT_DISP_POSTMASK0_FRAME_RST_DONE_PULSE, /* 116 */
/* Mutex frame done */
/* DISPSYS */
CMDQ_EVENT_MUTEX0_STREAM_EOF, /* 117 */
/* DISPSYS */
CMDQ_EVENT_MUTEX1_STREAM_EOF, /* 118 */
/* DISPSYS */
CMDQ_EVENT_MUTEX2_STREAM_EOF, /* 119 */
/* DISPSYS */
CMDQ_EVENT_MUTEX3_STREAM_EOF, /* 120 */
/* DISPSYS, please refer to disp_hal.h */
CMDQ_EVENT_MUTEX4_STREAM_EOF, /* 121 */
/* DpFramework */
CMDQ_EVENT_MUTEX5_STREAM_EOF, /* 122 */
/* DpFramework */
CMDQ_EVENT_MUTEX6_STREAM_EOF, /* 123 */
/* DpFramework */
CMDQ_EVENT_MUTEX7_STREAM_EOF, /* 124 */
/* DpFramework */
CMDQ_EVENT_MUTEX8_STREAM_EOF, /* 125 */
/* DpFramework via CMDQ_IOCTL_LOCK_MUTEX */
CMDQ_EVENT_MUTEX9_STREAM_EOF, /* 126 */
CMDQ_EVENT_MUTEX10_STREAM_EOF, /* 127 */
CMDQ_EVENT_MUTEX11_STREAM_EOF, /* 128 */
CMDQ_EVENT_MUTEX12_STREAM_EOF, /* 129 */
CMDQ_EVENT_MUTEX13_STREAM_EOF, /* 130 */
CMDQ_EVENT_MUTEX14_STREAM_EOF, /* 131 */
CMDQ_EVENT_MUTEX15_STREAM_EOF, /* 132 */
/* Display underrun */
CMDQ_EVENT_DISP_RDMA0_UNDERRUN, /* 133 */
CMDQ_EVENT_DISP_RDMA1_UNDERRUN, /* 134 */
CMDQ_EVENT_DISP_RDMA2_UNDERRUN, /* 135 */
CMDQ_EVENT_DISP_RDMA3_UNDERRUN, /* 136 */
/* Display TE */
CMDQ_EVENT_DSI_TE, /* 137 */
CMDQ_EVENT_DSI0_TE, /* 138 */
CMDQ_EVENT_DSI1_TE, /* 139 */
CMDQ_EVENT_MDP_DSI0_TE_SOF, /* 140 */
CMDQ_EVENT_MDP_DSI1_TE_SOF, /* 141 */
CMDQ_EVENT_DISP_DSI0_SOF, /* 142 */
CMDQ_EVENT_DISP_DSI1_SOF, /* 143 */
CMDQ_EVENT_DSI0_TO_GCE_MMCK0, /* 144 */
CMDQ_EVENT_DSI0_TO_GCE_MMCK1, /* 145 */
CMDQ_EVENT_DSI0_TO_GCE_MMCK2, /* 146 */
CMDQ_EVENT_DSI0_TO_GCE_MMCK3, /* 147 */
CMDQ_EVENT_DSI0_TO_GCE_MMCK4, /* 148 */
CMDQ_EVENT_DSI1_TO_GCE_MMCK0, /* 149 */
CMDQ_EVENT_DSI1_TO_GCE_MMCK1, /* 150 */
CMDQ_EVENT_DSI1_TO_GCE_MMCK2, /* 151 */
CMDQ_EVENT_DSI1_TO_GCE_MMCK3, /* 152 */
CMDQ_EVENT_DSI1_TO_GCE_MMCK4, /* 153 */
CMDQ_EVENT_DSI0_IRQ_EVENT, /* 154 */
CMDQ_EVENT_DSI0_DONE_EVENT, /* 155 */
CMDQ_EVENT_DSI1_IRQ_EVENT, /* 156 */
CMDQ_EVENT_DSI1_DONE_EVENT, /* 157 */
/* Reset Event */
CMDQ_EVENT_DISP_WDMA0_RST_DONE, /* 158 */
CMDQ_EVENT_DISP_WDMA1_RST_DONE, /* 159 */
CMDQ_EVENT_MDP_WROT0_RST_DONE, /* 160 */
CMDQ_EVENT_MDP_WROT1_RST_DONE, /* 161 */
CMDQ_EVENT_MDP_WDMA_RST_DONE, /* 162 */
CMDQ_EVENT_MDP_RDMA0_RST_DONE, /* 163 */
CMDQ_EVENT_MDP_RDMA1_RST_DONE, /* 164 */
/* Display Mutex */
CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD0, /* 165 */
CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD1, /* 166 */
CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD2, /* 167 */
CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD3, /* 168 */
CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD4, /* 169 */
CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD5, /* 170 */
CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD6, /* 171 */
CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD7, /* 172 */
CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD8, /* 173 */
CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD9, /* 174 */
CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD10, /* 175 */
CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD11, /* 176 */
CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD12, /* 177 */
CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD13, /* 178 */
CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD14, /* 179 */
CMDQ_EVENT_DISP_MUTEX_ALL_MODULE_UPD15, /* 180 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE0, /* 181 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE1, /* 182 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE2, /* 183 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE3, /* 184 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE4, /* 185 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE5, /* 186 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE6, /* 187 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE7, /* 188 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE8, /* 189 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE9, /* 190 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE10, /* 191 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE11, /* 192 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE12, /* 193 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE13, /* 194 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE14, /* 195 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE15, /* 196 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE16, /* 197 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE17, /* 198 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE18, /* 199 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE19, /* 200 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE20, /* 201 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE21, /* 202 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE22, /* 203 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE23, /* 204 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE24, /* 205 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE25, /* 206 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE26, /* 207 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE27, /* 208 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE28, /* 209 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE29, /* 210 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE30, /* 211 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE31, /* 212 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE32, /* 213 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE33, /* 214 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE34, /* 215 */
/* ISP frame done */
CMDQ_EVENT_ISP_PASS2_2_EOF, /* 216 */
CMDQ_EVENT_ISP_PASS2_1_EOF, /* 217 */
CMDQ_EVENT_ISP_PASS2_0_EOF, /* 218 */
CMDQ_EVENT_ISP_PASS1_1_EOF, /* 219 */
CMDQ_EVENT_ISP_PASS1_0_EOF, /* 220 */
/* ISP (IMGSYS) frame done */
CMDQ_EVENT_DIP_CQ_THREAD0_EOF, /* 221 */
CMDQ_EVENT_DIP_CQ_THREAD1_EOF, /* 222 */
CMDQ_EVENT_DIP_CQ_THREAD2_EOF, /* 223 */
CMDQ_EVENT_DIP_CQ_THREAD3_EOF, /* 224 */
CMDQ_EVENT_DIP_CQ_THREAD4_EOF, /* 225 */
CMDQ_EVENT_DIP_CQ_THREAD5_EOF, /* 226 */
CMDQ_EVENT_DIP_CQ_THREAD6_EOF, /* 227 */
CMDQ_EVENT_DIP_CQ_THREAD7_EOF, /* 228 */
CMDQ_EVENT_DIP_CQ_THREAD8_EOF, /* 229 */
CMDQ_EVENT_DIP_CQ_THREAD9_EOF, /* 230 */
CMDQ_EVENT_DIP_CQ_THREAD10_EOF, /* 231 */
CMDQ_EVENT_DIP_CQ_THREAD11_EOF, /* 232 */
CMDQ_EVENT_DIP_CQ_THREAD12_EOF, /* 233 */
CMDQ_EVENT_DIP_CQ_THREAD13_EOF, /* 234 */
CMDQ_EVENT_DIP_CQ_THREAD14_EOF, /* 235 */
CMDQ_EVENT_DIP_CQ_THREAD15_EOF, /* 236 */
CMDQ_EVENT_DIP_CQ_THREAD16_EOF, /* 237 */
CMDQ_EVENT_DIP_CQ_THREAD17_EOF, /* 238 */
CMDQ_EVENT_DIP_CQ_THREAD18_EOF, /* 239 */
CMDQ_EVENT_DPE_EOF, /* 240 */
CMDQ_EVENT_DVE_EOF, /* 241 */
CMDQ_EVENT_WMF_EOF, /* 242 */
CMDQ_EVENT_GEPF_EOF, /* 243 */
CMDQ_EVENT_GEPF_TEMP_EOF, /* 244 */
CMDQ_EVENT_GEPF_BYPASS_EOF, /* 245 */
CMDQ_EVENT_RSC_EOF, /* 246 */
CMDQ_EVENT_DIP_DMA_ERR_EVENT, /* 247 */
/* ISP (IMGSYS) engine events */
CMDQ_EVENT_ISP_SENINF_CAM1_2_3_FULL, /* 248 */
CMDQ_EVENT_ISP_SENINF_CAM0_FULL, /* 249 */
/* VENC frame done */
CMDQ_EVENT_VENC_EOF, /* 250 */
CMDQ_EVENT_VENC_CMDQ_PAUSE_DONE, /* 251 */
/* JPEG frame done */
CMDQ_EVENT_JPEG_ENC_EOF, /* 252 */
CMDQ_EVENT_JPEG_ENC_PASS2_EOF, /* 253 */
CMDQ_EVENT_JPEG_ENC_PASS1_EOF, /* 254 */
CMDQ_EVENT_JPEG_DEC_EOF, /* 255 */
/* VENC engine events */
CMDQ_EVENT_VENC_MB_DONE, /* 256 */
CMDQ_EVENT_VENC_128BYTE_CNT_DONE, /* 257 */
/* ISP (CAMSYS) frame done */
CMDQ_EVENT_ISP_FRAME_DONE_A, /* 258 */
CMDQ_EVENT_ISP_FRAME_DONE_B, /* 259 */
CMDQ_EVENT_ISP_FRAME_DONE_C, /* 260 */
CMDQ_EVENT_ISP_CAMSV_0_PASS1_DONE, /* 261 */
CMDQ_EVENT_ISP_CAMSV_0_2_PASS1_DONE, /* 262 */
CMDQ_EVENT_ISP_CAMSV_1_PASS1_DONE, /* 263 */
CMDQ_EVENT_ISP_CAMSV_2_PASS1_DONE, /* 264 */
CMDQ_EVENT_ISP_CAMSV_3_PASS1_DONE, /* 265 */
CMDQ_EVENT_ISP_TSF_DONE, /* 266 */
CMDQ_EVENT_ISP_RELAY_SOF, /* 267 */
CMDQ_EVENT_IPU_RELAY_SOF, /* 268 */
/* ISP (CAMSYS) engine events */
CMDQ_EVENT_SENINF_0_FIFO_FULL, /* 269 */
CMDQ_EVENT_SENINF_1_FIFO_FULL, /* 270 */
CMDQ_EVENT_SENINF_2_FIFO_FULL, /* 271 */
CMDQ_EVENT_SENINF_3_FIFO_FULL, /* 272 */
CMDQ_EVENT_SENINF_4_FIFO_FULL, /* 273 */
CMDQ_EVENT_SENINF_5_FIFO_FULL, /* 274 */
CMDQ_EVENT_SENINF_6_FIFO_FULL, /* 275 */
CMDQ_EVENT_SENINF_7_FIFO_FULL, /* 276 */
CMDQ_EVENT_TG_OVRUN_A_INT_DLY, /* 277 */
CMDQ_EVENT_TG_OVRUN_B_INT_DLY, /* 278 */
CMDQ_EVENT_TG_OVRUN_C_INT, /* 279 */
CMDQ_EVENT_TG_GRABERR_A_INT_DLY, /* 280 */
CMDQ_EVENT_TG_GRABERR_B_INT_DLY, /* 281 */
CMDQ_EVENT_TG_GRABERR_C_INT, /* 282 */
CMDQ_EVENT_CQ_VR_SNAP_A_INT_DLY, /* 283 */
CMDQ_EVENT_CQ_VR_SNAP_B_INT_DLY, /* 284 */
CMDQ_EVENT_CQ_VR_SNAP_C_INT, /* 285 */
/* 6799 New Event */
CMDQ_EVENT_DISP_DSC1_SOF, /* 286 */
CMDQ_EVENT_DISP_DSC2_SOF, /* 287 */
CMDQ_EVENT_DISP_RSZ0_SOF, /* 288 */
CMDQ_EVENT_DISP_RSZ1_SOF, /* 289 */
CMDQ_EVENT_DISP_DSC0_EOF, /* 290 */
CMDQ_EVENT_DISP_DSC1_EOF, /* 291 */
CMDQ_EVENT_DISP_RSZ0_EOF, /* 292 */
CMDQ_EVENT_DISP_RSZ1_EOF, /* 293 */
CMDQ_EVENT_DISP_OVL0_RST_DONE, /* 294 */
CMDQ_EVENT_DISP_OVL1_RST_DONE, /* 295 */
CMDQ_EVENT_DISP_OVL0_2L_RST_DONE, /* 296 */
CMDQ_EVENT_DISP_OVL1_2L_RST_DONE, /* 297 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE35, /* 298 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE36, /* 299 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE37, /* 300 */
CMDQ_EVENT_DISP_MUTEX_REG_UPD_FOR_MODULE38, /* 301 */
CMDQ_EVENT_WPE_A_EOF, /* 302 */
CMDQ_EVENT_EAF_EOF, /* 303 */
CMDQ_EVENT_VENC_BSDMA_FULL, /* 304 */
CMDQ_EVENT_IPU0_EOF, /* 305 */
CMDQ_EVENT_IPU1_EOF, /* 306 */
CMDQ_EVENT_IPU2_EOF, /* 307 */
CMDQ_EVENT_IPU3_EOF, /* 308 */
/* 6759 New Event */
CMDQ_EVENT_DISP_SPLIT_SOF, /* 309 */
CMDQ_EVENT_DISP_SPLIT_FRAME_DONE, /* 310 */
CMDQ_EVENT_AMD_FRAME_DONE, /* 311 */
CMDQ_EVENT_DISP_DPI0_SOF, /* 312 */
CMDQ_EVENT_DSI0_TE_INFRA, /* 313 */
/* 6739 New Event*/
CMDQ_EVENT_DISP_DBI0_SOF, /* 314 */
CMDQ_EVENT_DISP_DBI0_EOF, /* 315 */
/* 6775 New Event*/
CMDQ_EVENT_MDP_CCORR_SOF, /* 316 */
CMDQ_EVENT_MDP_CCORR_FRAME_DONE, /* 317 */
CMDQ_EVENT_MDP_AAL_FRAME_DONE, /* 318 */
CMDQ_EVENT_WPE_B_FRAME_DONE, /* 319 */
CMDQ_EVENT_MFB_DONE, /* 320 */
CMDQ_EVENT_OCC_DONE, /* 321 */
CMDQ_EVENT_IPU_DONE_1_1, /* 322 */
CMDQ_EVENT_IPU_DONE_1_2, /* 323 */
CMDQ_EVENT_IPU_DONE_1_0, /* 324 */
CMDQ_EVENT_IPU_DONE_1_3, /* 325 */
CMDQ_EVENT_IPU_DONE_2_0, /* 326 */
CMDQ_EVENT_IPU_DONE_2_1, /* 327 */
CMDQ_EVENT_IPU_DONE_2_3, /* 328 */
CMDQ_EVENT_IPU_DONE_2_2, /* 329 */
/* 6765 New Event */
CMDQ_EVENT_MDP_CCORR0_SOF, /* 330 */
CMDQ_EVENT_MDP_CCORR0_FRAME_DONE, /* 331 */
CMDQ_EVENT_IMG_DL_RELAY_SOF, /* 332 */
CMDQ_EVENT_DMA_R1_ERROR_A_INT_DLY, /* 333 */
CMDQ_EVENT_DMA_R1_ERROR_B_INT_DLY, /* 334 */
CMDQ_EVENT_DMA_R1_ERROR_C_INT, /* 335 */
CMDQ_EVENT_APU_GCE_CORE0_EVENT_0, /* 336 */
CMDQ_EVENT_APU_GCE_CORE0_EVENT_1, /* 337 */
CMDQ_EVENT_APU_GCE_CORE0_EVENT_2, /* 338 */
CMDQ_EVENT_APU_GCE_CORE0_EVENT_3, /* 339 */
CMDQ_EVENT_APU_GCE_CORE1_EVENT_0, /* 340 */
CMDQ_EVENT_APU_GCE_CORE1_EVENT_1, /* 341 */
CMDQ_EVENT_APU_GCE_CORE1_EVENT_2, /* 342 */
CMDQ_EVENT_APU_GCE_CORE1_EVENT_3, /* 343 */
CMDQ_EVENT_VDEC_EVENT_0, /* 344 */
CMDQ_EVENT_VDEC_EVENT_1, /* 345 */
CMDQ_EVENT_VDEC_EVENT_2, /* 346 */
CMDQ_EVENT_VDEC_EVENT_3, /* 347 */
CMDQ_EVENT_VDEC_EVENT_4, /* 348 */
CMDQ_EVENT_VDEC_EVENT_5, /* 349 */
CMDQ_EVENT_VDEC_EVENT_6, /* 350 */
CMDQ_EVENT_VDEC_EVENT_7, /* 351 */
CMDQ_EVENT_VDEC_EVENT_8, /* 352 */
CMDQ_EVENT_VDEC_EVENT_9, /* 353 */
CMDQ_EVENT_VDEC_EVENT_10, /* 354 */
CMDQ_EVENT_VDEC_EVENT_11, /* 355 */
CMDQ_EVENT_VDEC_EVENT_12, /* 356 */
CMDQ_EVENT_VDEC_EVENT_13, /* 357 */
CMDQ_EVENT_VDEC_EVENT_14, /* 358 */
CMDQ_EVENT_VDEC_EVENT_15, /* 359 */
CMDQ_EVENT_FDVT_DONE, /* 360 */
CMDQ_EVENT_FE_DONE, /* 361 */
CMDQ_EVENT_DVS_DONE_ASYNC_SHOT, /* 362 */
CMDQ_EVENT_DVP_DONE_ASYNC_SHOT, /* 363 */
CMDQ_EVENT_VENC_FRAME_DONE, /* 364 */
CMDQ_EVENT_VENC_PAUSE_DONE, /* 365 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_0, /* 366 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_1, /* 367 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_2, /* 368 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_3, /* 369 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_4, /* 370 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_5, /* 371 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_6, /* 372 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_7, /* 373 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_8, /* 374 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_9, /* 375 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_10, /* 376 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_11, /* 377 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_12, /* 378 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_13, /* 379 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_14, /* 380 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_15, /* 381 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_16, /* 382 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_17, /* 383 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_18, /* 384 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_19, /* 385 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_20, /* 386 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_21, /* 387 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_22, /* 388 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_23, /* 389 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_0, /* 390 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_1, /* 391 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_2, /* 392 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_3, /* 393 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_4, /* 394 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_5, /* 395 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_6, /* 396 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_7, /* 397 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_8, /* 398 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_9, /* 399 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_10, /* 400 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_11, /* 401 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_12, /* 402 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_13, /* 403 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_14, /* 404 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_15, /* 405 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_16, /* 406 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_17, /* 407 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_18, /* 408 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_19, /* 409 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_20, /* 410 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_21, /* 411 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_22, /* 412 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_23, /* 413 */
CMDQ_EVENT_IPE_EVENT_TX_FRAME_DONE_0, /* 414 */
CMDQ_EVENT_IPE_EVENT_TX_FRAME_DONE_1, /* 415 */
CMDQ_EVENT_IPE_EVENT_TX_FRAME_DONE_2, /* 416 */
CMDQ_EVENT_IPE_EVENT_TX_FRAME_DONE_3, /* 417 */
CMDQ_EVENT_IPE_EVENT_TX_FRAME_DONE_4, /* 418 */
/* Keep this at the end of HW events */
CMDQ_MAX_HW_EVENT_COUNT = 512,
/* token 512 to 639 may set secure */
/* SW Sync Tokens (Pre-defined) */
/* Config thread notify trigger thread */
CMDQ_SYNC_TOKEN_CONFIG_DIRTY = 640,
/* Trigger thread notify config thread */
CMDQ_SYNC_TOKEN_STREAM_EOF, /* 641 */
/* Block Trigger thread until the ESD check finishes. */
CMDQ_SYNC_TOKEN_ESD_EOF, /* 642 */
/* check CABC setup finish */
CMDQ_SYNC_TOKEN_CABC_EOF, /* 643 */
/* Block Trigger thread until the path freeze finishes */
CMDQ_SYNC_TOKEN_FREEZE_EOF, /* 644 */
/* Pass-2 notifies VENC frame is ready to be encoded */
CMDQ_SYNC_TOKEN_VENC_INPUT_READY, /* 645 */
/* VENC notifies Pass-2 encode done so next frame may start */
CMDQ_SYNC_TOKEN_VENC_EOF, /* 646 */
/* Notify normal CMDQ there are some secure task done */
CMDQ_SYNC_SECURE_THR_EOF, /* 647 */
/* Lock WSM resource */
CMDQ_SYNC_SECURE_WSM_LOCK, /* 648 */
/* SW Sync Tokens (User-defined) */
CMDQ_SYNC_TOKEN_USER_0, /* 649 */
CMDQ_SYNC_TOKEN_USER_1, /* 650 */
CMDQ_SYNC_TOKEN_POLL_MONITOR, /* 651 */
/* SW Sync Tokens (Pre-defined) */
/* Config thread notify trigger thread for external display */
CMDQ_SYNC_TOKEN_EXT_CONFIG_DIRTY, /* 652 */
/* Trigger thread notify config thread */
CMDQ_SYNC_TOKEN_EXT_STREAM_EOF, /* 653 */
/* Check CABC setup finish */
CMDQ_SYNC_TOKEN_EXT_CABC_EOF, /* 654 */
/* Secure video path notify SW token */
CMDQ_SYNC_DISP_OVL0_2NONSEC_END, /* 655 */
CMDQ_SYNC_DISP_OVL1_2NONSEC_END, /* 656 */
CMDQ_SYNC_DISP_2LOVL0_2NONSEC_END, /* 657 */
CMDQ_SYNC_DISP_2LOVL1_2NONSEC_END, /* 658 */
CMDQ_SYNC_DISP_RDMA0_2NONSEC_END, /* 659 */
CMDQ_SYNC_DISP_RDMA1_2NONSEC_END, /* 660 */
CMDQ_SYNC_DISP_WDMA0_2NONSEC_END, /* 661 */
CMDQ_SYNC_DISP_WDMA1_2NONSEC_END, /* 662 */
CMDQ_SYNC_DISP_EXT_STREAM_EOF, /* 663 */
/* Event for CMDQ to block executing command when append command
* Plz sync CMDQ_SYNC_TOKEN_APPEND_THR(id) in cmdq_core source file.
*/
CMDQ_SYNC_TOKEN_APPEND_THR0 = 670,
CMDQ_SYNC_TOKEN_APPEND_THR1, /* 671 */
CMDQ_SYNC_TOKEN_APPEND_THR2, /* 672 */
CMDQ_SYNC_TOKEN_APPEND_THR3, /* 673 */
CMDQ_SYNC_TOKEN_APPEND_THR4, /* 674 */
CMDQ_SYNC_TOKEN_APPEND_THR5, /* 675 */
CMDQ_SYNC_TOKEN_APPEND_THR6, /* 676 */
CMDQ_SYNC_TOKEN_APPEND_THR7, /* 677 */
CMDQ_SYNC_TOKEN_APPEND_THR8, /* 678 */
CMDQ_SYNC_TOKEN_APPEND_THR9, /* 679 */
CMDQ_SYNC_TOKEN_APPEND_THR10, /* 680 */
CMDQ_SYNC_TOKEN_APPEND_THR11, /* 681 */
CMDQ_SYNC_TOKEN_APPEND_THR12, /* 682 */
CMDQ_SYNC_TOKEN_APPEND_THR13, /* 683 */
CMDQ_SYNC_TOKEN_APPEND_THR14, /* 684 */
CMDQ_SYNC_TOKEN_APPEND_THR15, /* 685 */
CMDQ_SYNC_TOKEN_APPEND_THR16, /* 686 */
CMDQ_SYNC_TOKEN_APPEND_THR17, /* 687 */
CMDQ_SYNC_TOKEN_APPEND_THR18, /* 688 */
CMDQ_SYNC_TOKEN_APPEND_THR19, /* 689 */
CMDQ_SYNC_TOKEN_APPEND_THR20, /* 690 */
CMDQ_SYNC_TOKEN_APPEND_THR21, /* 691 */
CMDQ_SYNC_TOKEN_APPEND_THR22, /* 692 */
CMDQ_SYNC_TOKEN_APPEND_THR23, /* 693 */
/* secure world notify normal world task done */
CMDQ_SYNC_TOKEN_SEC_DONE, /* 694 */
/* token after 700 sync user space header */
/* GPR access tokens (for HW register backup)
* There are 15 32-bit GPR, 3 GPR form a set
* (64-bit for address, 32-bit for value)
*/
CMDQ_SYNC_TOKEN_GPR_SET_0 = 700,
CMDQ_SYNC_TOKEN_GPR_SET_1, /* 701 */
CMDQ_SYNC_TOKEN_GPR_SET_2, /* 702 */
CMDQ_SYNC_TOKEN_GPR_SET_3, /* 703 */
CMDQ_SYNC_TOKEN_GPR_SET_4, /* 704 */
/* Resource lock event to control resource in GCE thread */
CMDQ_SYNC_RESOURCE_WROT0 = 710,
CMDQ_SYNC_RESOURCE_WROT1 = 711,
/**
* Event for CMDQ delay implement
* Plz sync CMDQ_SYNC_TOKEN_DELAY_THR(id) in cmdq_core source file.
*/
CMDQ_SYNC_TOKEN_TIMER = 720,
CMDQ_SYNC_TOKEN_DELAY_SET0 = 721,
CMDQ_SYNC_TOKEN_DELAY_SET1 = 722,
CMDQ_SYNC_TOKEN_DELAY_SET2 = 723,
/* GCE reserved hw event */
CMDQ_OUT_EVENT = 898,
/* GCE HW TPR Event*/
CMDQ_EVENT_TIMER_00 = 962,
CMDQ_EVENT_TIMER_01 = 963,
CMDQ_EVENT_TIMER_02 = 964,
CMDQ_EVENT_TIMER_03 = 965,
CMDQ_EVENT_TIMER_04 = 966,
/* 5: 1us */
CMDQ_EVENT_TIMER_05 = 967,
CMDQ_EVENT_TIMER_06 = 968,
CMDQ_EVENT_TIMER_07 = 969,
/* 8: 10us */
CMDQ_EVENT_TIMER_08 = 970,
CMDQ_EVENT_TIMER_09 = 971,
CMDQ_EVENT_TIMER_10 = 972,
/* 11: 100us */
CMDQ_EVENT_TIMER_11 = 973,
CMDQ_EVENT_TIMER_12 = 974,
CMDQ_EVENT_TIMER_13 = 975,
CMDQ_EVENT_TIMER_14 = 976,
/* 15: 1ms */
CMDQ_EVENT_TIMER_15 = 977,
CMDQ_EVENT_TIMER_16 = 978,
CMDQ_EVENT_TIMER_17 = 979,
/* 18: 10ms */
CMDQ_EVENT_TIMER_18 = 980,
CMDQ_EVENT_TIMER_19 = 981,
CMDQ_EVENT_TIMER_20 = 982,
/* 21: 100ms */
CMDQ_EVENT_TIMER_21 = 983,
CMDQ_EVENT_TIMER_22 = 984,
CMDQ_EVENT_TIMER_23 = 985,
CMDQ_EVENT_TIMER_24 = 986,
CMDQ_EVENT_TIMER_25 = 987,
CMDQ_EVENT_TIMER_26 = 988,
CMDQ_EVENT_TIMER_27 = 989,
CMDQ_EVENT_TIMER_28 = 990,
CMDQ_EVENT_TIMER_29 = 991,
CMDQ_EVENT_TIMER_30 = 992,
CMDQ_EVENT_TIMER_31 = 993,
/* GPR timer token, 994 to 994+23 */
CMDQ_EVENT_TIMER_GPR = 994,
/* event id is 9 bit */
CMDQ_SYNC_TOKEN_MAX = 0x3FF,
CMDQ_SYNC_TOKEN_INVALID = -1,
};
#endif
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,19 @@
/* 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)
/* 32 for read, 4 for write */
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_WRI_WITH_MASK, CMDQ_CODE_WRITE, 36,
WRI_W_MASK)
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,300 @@
/* 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_helper_ext.h"
#include <linux/types.h>
#ifdef CONFIG_MTK_SMI_EXT
enum mtk_iommu_sec_id {
SEC_ID_SEC_CAM = 0,
SEC_ID_SVP,
SEC_ID_SDSP,
SEC_ID_WFD,
SEC_ID_COUNT
};
/* translate port */
typedef uint32_t (*CmdqTranslatePort) (uint32_t engineId);
/* get request */
typedef struct mm_qos_request *(*CmdqGetRequest) (
uint32_t thread_id, uint32_t port);
/* init pmqos mdp */
typedef void (*CmdqInitPmqosMdp) (s32 index, struct plist_head *owner_list);
/* init pmqos isp */
typedef void (*CmdqInitPmqosIsp) (s32 index, struct plist_head *owner_list);
#endif /* CONFIG_MTK_SMI_EXT */
enum MEM_TYPE {
MEM_SVP = 0,
MEM_SEC = MEM_SVP,
MEM_PROT = 1,
MEM_WFD = 2,
MEM_2D_FR = 3,
MEM_SDSP_SHARED = 4,
MEM_SDSP_FIRMWARE = 5,
MEM_HAPP_ELF = 6,
MEM_HAPP_EXTRA = 7,
MEM_TYPE_MAX
};
/* dump mmsys config */
typedef void (*CmdqDumpMMSYSConfig) (void);
/* VENC callback function */
typedef s32(*CmdqVEncDumpInfo) (u64 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 s32(*CmdqMdpClockOn) (u64 engineFlag);
typedef s32(*CmdqMdpDumpInfo) (u64 engineFlag, int level);
typedef s32(*CmdqMdpResetEng) (u64 engineFlag);
typedef s32(*CmdqMdpClockOff) (u64 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 u32(*CmdqMdpRdmaGetRegOffsetSrcAddr) (void);
typedef u32(*CmdqMdpWrotGetRegOffsetDstAddr) (void);
typedef u32(*CmdqMdpWdmaGetRegOffsetDstAddr) (void);
typedef void (*CmdqTestcaseClkmgrMdp) (void);
typedef const char*(*CmdqDispatchModule) (u64 engineFlag);
typedef void (*CmdqTrackTask) (const struct cmdqRecStruct *task);
typedef const char *(*CmdqPraseErrorModByEngFlag) (
const struct cmdqRecStruct *task);
typedef const char *(*CmdqPraseHandleErrorModByEngFlag) (
const struct cmdqRecStruct *handle);
typedef u64 (*CmdqMdpGetEngineGroupBits) (u32 engine_group);
typedef s32 (*CmdqMdpEnableCommonClock) (bool enable);
typedef void (*CmdqCheckHwStatus) (struct cmdqRecStruct *handle);
typedef u64(*CmdqMdpGetSecEngine) (u64 engine_flag);
typedef void (*CmdqMdpComposeReadback) (struct cmdqRecStruct *handle,
u16 engine, dma_addr_t dma, u32 param);
typedef void (*CmdqMdpReadbackEngine) (struct cmdqRecStruct *handle,
u16 engine, phys_addr_t base, dma_addr_t pa, u32 param);
struct cmdqMDPFuncStruct {
#ifdef CONFIG_MTK_SMI_EXT
CmdqTranslatePort translatePort;
CmdqGetRequest getRequest;
CmdqInitPmqosMdp initPmqosMdp;
CmdqInitPmqosIsp initPmqosIsp;
#endif /* CONFIG_MTK_SMI_EXT */
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;
CmdqPraseErrorModByEngFlag parseErrModByEngFlag;
CmdqPraseHandleErrorModByEngFlag parseHandleErrModByEngFlag;
CmdqMdpGetEngineGroupBits getEngineGroupBits;
CmdqErrorResetCB errorReset;
CmdqMdpEnableCommonClock mdpEnableCommonClock;
CmdqBeginTaskCB beginTask;
CmdqEndTaskCB endTask;
CmdqBeginTaskCB beginISPTask;
CmdqEndTaskCB endISPTask;
CmdqCheckHwStatus CheckHwStatus;
CmdqMdpGetSecEngine mdpGetSecEngine;
CmdqMdpComposeReadback mdpComposeReadback;
CmdqMdpReadbackEngine mdpReadbackAal;
CmdqMdpReadbackEngine mdpReadbackHdr;
};
struct mdp_pmqos_record {
uint32_t mdp_throughput;
struct timeval submit_tm;
struct timeval end_tm;
};
/* 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)
#define MDP_TOTAL_THREAD 16
#ifdef CMDQ_SECURE_PATH_SUPPORT
#define MDP_THREAD_START (CMDQ_MIN_SECURE_THREAD_ID + 2)
#else
#define MDP_THREAD_START CMDQ_DYNAMIC_THREAD_ID_START
#endif
/* MDP common kernel logic */
void cmdq_mdp_fix_command_scenario_for_user_space(
struct cmdqCommandStruct *command);
bool cmdq_mdp_is_request_from_user_space(
const enum CMDQ_SCENARIO_ENUM scenario);
s32 cmdq_mdp_query_usage(s32 *counters);
s32 cmdq_mdp_get_smi_usage(void);
void cmdq_mdp_reset_resource(void);
void cmdq_mdp_dump_thread_usage(void);
void cmdq_mdp_dump_engine_usage(void);
void cmdq_mdp_dump_resource(u32 event);
void cmdq_mdp_init_resource(u32 engine_id,
enum cmdq_event res_event);
void cmdq_mdp_enable_res(u64 engine_flag, bool enable);
void cmdq_mdp_lock_resource(u64 engine_flag, bool from_notify);
bool cmdq_mdp_acquire_resource(enum cmdq_event res_event,
u64 *engine_flag_out);
void cmdq_mdp_release_resource(enum cmdq_event res_event,
u64 *engine_flag_out);
void cmdq_mdp_set_resource_callback(enum cmdq_event res_event,
CmdqResourceAvailableCB res_available,
CmdqResourceReleaseCB res_release);
void cmdq_mdp_unlock_thread(struct cmdqRecStruct *handle);
void cmdq_mdp_op_readback(struct cmdqRecStruct *handle, u16 engine,
dma_addr_t addr, u32 param);
s32 cmdq_mdp_flush_async(struct cmdqCommandStruct *desc, bool user_space,
struct cmdqRecStruct **handle_out);
s32 cmdq_mdp_flush_async_impl(struct cmdqRecStruct *handle);
struct cmdqRecStruct *cmdq_mdp_get_valid_handle(unsigned long job);
s32 cmdq_mdp_wait(struct cmdqRecStruct *handle,
struct cmdqRegValueStruct *results);
s32 cmdq_mdp_flush(struct cmdqCommandStruct *desc, bool user_space);
void cmdq_mdp_suspend(void);
void cmdq_mdp_resume(void);
void cmdq_mdp_release_task_by_file_node(void *file_node);
void cmdq_mdp_init(void);
void cmdq_mdp_deinit_pmqos(void);
s32 cmdq_mdp_handle_create(struct cmdqRecStruct **handle_out);
s32 cmdq_mdp_handle_flush(struct cmdqRecStruct *handle);
s32 cmdq_mdp_handle_sec_setup(struct cmdqSecDataStruct *secData,
struct cmdqRecStruct *handle);
struct op_meta;
struct mdp_submit;
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);
/* Platform dependent function */
void cmdq_mdp_virtual_function_setting(void);
void cmdq_mdp_map_mmsys_VA(void);
long cmdq_mdp_get_module_base_VA_MMSYS_CONFIG(void);
void cmdq_mdp_unmap_mmsys_VA(void);
struct cmdqMDPFuncStruct *cmdq_mdp_get_func(void);
void cmdq_mdp_enable(u64 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 u32 resetMask,
const u32 resetValue, const bool pollInitResult);
void cmdq_mdp_loop_off(enum CMDQ_ENG_ENUM engine,
const unsigned long resetReg,
const unsigned long resetStateReg,
const u32 resetMask,
const u32 resetValue, const bool pollInitResult);
const char *cmdq_mdp_get_rsz_state(const u32 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);
const char *cmdq_mdp_parse_error_module_by_hwflag(
const struct cmdqRecStruct *task);
const char *cmdq_mdp_parse_handle_error_module_by_hwflag(
const struct cmdqRecStruct *handle);
/* Platform dependent function */
s32 cmdqMdpClockOn(u64 engineFlag);
s32 cmdqMdpDumpInfo(u64 engineFlag, int level);
s32 cmdqVEncDumpInfo(u64 engineFlag, int level);
s32 cmdqMdpResetEng(u64 engineFlag);
s32 cmdqMdpClockOff(u64 engineFlag);
u32 cmdq_mdp_rdma_get_reg_offset_src_addr(void);
u32 cmdq_mdp_wrot_get_reg_offset_dst_addr(void);
u32 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);
long cmdq_mdp_get_module_base_VA_MDP_WROT0(void);
#endif /* __CMDQ_MDP_COMMON_H__ */
@@ -0,0 +1,40 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_MDP_PMQOS_H__
#define __CMDQ_MDP_PMQOS_H__
#define PMQOS_ISP_PORT_NUM 16
#define PMQOS_MDP_PORT_NUM 4
struct mdp_pmqos {
uint32_t isp_total_datasize;
uint32_t isp_total_pixel;
uint32_t mdp_total_datasize;
uint32_t mdp_total_pixel;
uint32_t qos2_isp_bandwidth[PMQOS_ISP_PORT_NUM];
uint32_t qos2_isp_total_pixel[PMQOS_ISP_PORT_NUM];
uint32_t qos2_isp_port[PMQOS_ISP_PORT_NUM];
uint32_t qos2_isp_count;
uint32_t qos2_mdp_bandwidth[PMQOS_MDP_PORT_NUM];
uint32_t qos2_mdp_total_pixel[PMQOS_MDP_PORT_NUM];
uint32_t qos2_mdp_port[PMQOS_MDP_PORT_NUM];
uint32_t qos2_mdp_count;
uint64_t tv_sec;
uint64_t tv_usec;
uint64_t ispMetString;
uint32_t ispMetStringSize;
uint64_t mdpMetString;
uint32_t mdpMetStringSize;
uint64_t mdpMMpathString;
uint32_t mdpMMpathStringSize;
};
#endif
+72
View File
@@ -0,0 +1,72 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2015 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)
{
#if IS_ENABLED(CMDQ_MMPROFILE_SUPPORT)
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_task_done = mmprofile_register_event(
CMDQ_MMP_events.CMDQ, "wait_task_done");
CMDQ_MMP_events.task_exec = mmprofile_register_event(
CMDQ_MMP_events.CMDQ, "task_exec");
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.MDP_clock_on = mmprofile_register_event(
CMDQ_MMP_events.CMDQ, "MDP_clock_on");
CMDQ_MMP_events.MDP_clock_off = mmprofile_register_event(
CMDQ_MMP_events.CMDQ, "MDP_clock_off");
CMDQ_MMP_events.MDP_clock_smi = mmprofile_register_event(
CMDQ_MMP_events.CMDQ, "MDP_clock_smi");
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");
CMDQ_MMP_events.alloc_buffer = mmprofile_register_event(
CMDQ_MMP_events.CMDQ, "alloc_buffer");
CMDQ_MMP_events.timeout = mmprofile_register_event(
CMDQ_MMP_events.CMDQ, "timeout");
CMDQ_MMP_events.read_reg = mmprofile_register_event(
CMDQ_MMP_events.CMDQ, "read_reg");
mmprofile_enable_event_recursive(CMDQ_MMP_events.CMDQ, 1);
}
mmprofile_start(1);
#endif
}
+44
View File
@@ -0,0 +1,44 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_MMP_H__
#define __CMDQ_MMP_H__
#include "cmdq_helper_ext.h"
#if IS_ENABLED(CONFIG_MMPROFILE)
#include "mmprofile.h"
#endif
struct CMDQ_MMP_events_t {
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_task_done;
mmp_event task_exec;
mmp_event wait_thread;
mmp_event wait_task_clean;
mmp_event MDP_reset;
mmp_event MDP_clock_on;
mmp_event MDP_clock_off;
mmp_event MDP_clock_smi;
mmp_event thread_suspend;
mmp_event thread_resume;
mmp_event alloc_buffer;
mmp_event timeout;
mmp_event read_reg;
};
void cmdq_mmp_init(void);
struct CMDQ_MMP_events_t *cmdq_mmp_get_event(void);
#endif /* __CMDQ_MMP_H__ */
+166
View File
@@ -0,0 +1,166 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#include "cmdq_prof.h"
#include "cmdq_helper_ext.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;
}
u32 cmdq_prof_get_statistic_id(const u32 *pCmd)
{
const u32 arg_b = pCmd[0];
const u32 arg_a = pCmd[1];
const u32 op = arg_a >> 24;
u32 addr;
u32 maskEn = 0;
switch (op) {
case CMDQ_CODE_WRITE_S:
return CMDQ_STA_WRI;
case CMDQ_CODE_WRITE_S_W_MASK:
return CMDQ_STA_WRI_WITH_MASK;
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:
case CMDQ_CODE_READ_S:
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:
case CMDQ_CODE_LOGIC:
case CMDQ_CODE_JUMP_C_RELATIVE:
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;
}
u32 cmdq_prof_calculate_HW_cycle(
const enum CMDQ_OP_STATISTIC_ENUM statisticId, const u32 count)
{
u32 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;
}
s32 cmdq_prof_estimate_command_exe_time(const u32 *pCmd,
u32 commandSize)
{
u32 statistic[CMDQ_STA_MAX_COUNT] = { 0 };
int i;
u32 statisticId = 0;
u32 cycle = 0;
u32 totalCycle = 0;
u32 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));
CMDQ_LOG(
"***Real exec time will be longer when POLL/WAIT instr cannot pass their condition immediately.\n");
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>
s32 cmdq_prof_estimate_command_exe_time(
const u32 *pCmd, u32 commandSize);
#endif /* __CMDQ_PROF_H__ */
File diff suppressed because it is too large. Load diff
+922
View File
@@ -0,0 +1,922 @@
/* 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/soc/mediatek/mtk-cmdq.h>
#include "cmdq_def.h"
#include "cmdq_helper_ext.h"
enum CMDQ_STACK_TYPE_ENUM {
CMDQ_STACK_NULL = -1,
CMDQ_STACK_TYPE_IF = 0,
CMDQ_STACK_TYPE_ELSE = 1,
CMDQ_STACK_TYPE_WHILE = 2,
CMDQ_STACK_TYPE_BREAK = 3,
CMDQ_STACK_TYPE_CONTINUE = 4,
CMDQ_STACK_TYPE_DO_WHILE = 5,
};
#define CMDQ_DATA_BIT (62)
#define CMDQ_BIT_VALUE (0LL)
#define CMDQ_BIT_VAR (1LL)
#define CMDQ_TASK_CPR_INITIAL_VALUE (0)
#define CMDQ_REC_DEFAULT_PRIORITY (100)
#define CMDQ_REC_MAX_PRIORITY (0x7FFFFFFF)
struct cmdq_stack_node {
u32 position;
enum CMDQ_STACK_TYPE_ENUM stack_type;
struct cmdq_stack_node *next;
};
struct cmdq_user_req {
u32 reg_count;
u32 user_token;
};
#define cmdqBackupSlotHandle dma_addr_t
/* Create command queue recorder handle
* Parameter:
* pHandle: pointer to retrieve the handle
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_task_create(enum CMDQ_SCENARIO_ENUM scenario,
struct cmdqRecStruct **pHandle);
s32 cmdqRecCreate(enum CMDQ_SCENARIO_ENUM scenario,
struct cmdqRecStruct **pHandle);
s32 cmdq_task_duplicate(struct cmdqRecStruct *handle,
struct cmdqRecStruct **handle_out);
/* 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
*/
s32 cmdq_task_set_engine(struct cmdqRecStruct *handle,
u64 engineFlag);
s32 cmdqRecSetEngine(struct cmdqRecStruct *handle,
u64 engineFlag);
/* Reset command queue recorder commands
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_task_reset(struct cmdqRecStruct *handle);
s32 cmdqRecReset(struct cmdqRecStruct *handle);
void cmdq_task_set_timeout(struct cmdqRecStruct *handle, u32 timeout);
/* 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
*/
s32 cmdq_task_set_secure(struct cmdqRecStruct *handle, const bool is_secure);
s32 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)
*/
s32 cmdq_task_is_secure(struct cmdqRecStruct *handle);
s32 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
*/
s32 cmdq_task_secure_enable_dapc(struct cmdqRecStruct *handle,
const u64 engineFlag);
s32 cmdqRecSecureEnableDAPC(struct cmdqRecStruct *handle,
const u64 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
*/
s32 cmdq_task_secure_enable_port_security(struct cmdqRecStruct *handle,
const u64 engineFlag);
s32 cmdqRecSecureEnablePortSecurity(struct cmdqRecStruct *handle,
const u64 engineFlag);
/* Assign secure metadata for client driver */
s32 cmdq_task_set_secure_meta(struct cmdqRecStruct *handle,
enum cmdq_sec_rec_meta_type type, void *meta, u32 size);
/* Append mark command to the recorder
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
s32 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
*/
s32 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
*/
s32 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
*/
s32 cmdq_op_write_reg(struct cmdqRecStruct *handle, u32 addr,
CMDQ_VARIABLE argument, u32 mask);
s32 cmdqRecWrite(struct cmdqRecStruct *handle, u32 addr, u32 value, u32 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
*/
void cmdq_task_set_mtee(struct cmdqRecStruct *handle, const bool enable);
void cmdq_task_set_secure_id(struct cmdqRecStruct *handle, s32 sec_id);
s32 cmdq_op_write_reg_secure(struct cmdqRecStruct *handle, u32 addr,
enum CMDQ_SEC_ADDR_METADATA_TYPE type, u64 baseHandle,
u32 offset, u32 size, u32 port, uint32_t sec_id);
s32 cmdqRecWriteSecure(struct cmdqRecStruct *handle,
u32 addr, enum CMDQ_SEC_ADDR_METADATA_TYPE type,
u64 baseHandle, u32 offset, u32 size, u32 port);
s32 cmdqRecWriteSecureMetaData(struct cmdqRecStruct *handle,
u32 addr, enum CMDQ_SEC_ADDR_METADATA_TYPE type,
u64 baseHandle, u32 offset, u32 size, u32 port, uint32_t sec_id);
/* 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
*/
s32 cmdq_op_poll(struct cmdqRecStruct *handle, u32 addr, u32 value, u32 mask);
s32 cmdqRecPoll(struct cmdqRecStruct *handle, u32 addr, u32 value, u32 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
*/
s32 cmdq_op_wait(struct cmdqRecStruct *handle, enum cmdq_event event);
s32 cmdqRecWait(struct cmdqRecStruct *handle, enum cmdq_event 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
*/
s32 cmdq_op_wait_no_clear(struct cmdqRecStruct *handle,
enum cmdq_event event);
s32 cmdqRecWaitNoClear(struct cmdqRecStruct *handle,
enum cmdq_event 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
*/
s32 cmdq_op_clear_event(struct cmdqRecStruct *handle,
enum cmdq_event event);
s32 cmdqRecClearEventToken(struct cmdqRecStruct *handle,
enum cmdq_event 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
*/
s32 cmdq_op_set_event(struct cmdqRecStruct *handle,
enum cmdq_event event);
s32 cmdqRecSetEventToken(struct cmdqRecStruct *handle,
enum cmdq_event event);
/* Replace overwite CPR parameters of arg_a.
* Parameter:
* handle: the command queue recorder handle
* index: the index of instruction to replace
* new_arg_a: the desired cpr value to overwrite arg_a
* new_arg_b: the desired cpr value to overwrite arg_b
* new_arg_c: the desired cpr value to overwrite arg_c
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_replace_overwrite_cpr(struct cmdqRecStruct *handle, u32 index,
s32 new_arg_a, s32 new_arg_b, s32 new_arg_c);
/* 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
*/
s32 cmdq_op_read_to_data_register(struct cmdqRecStruct *handle,
u32 hw_addr, enum cmdq_gpr_reg dst_data_reg);
s32 cmdqRecReadToDataRegister(struct cmdqRecStruct *handle, u32 hw_addr,
enum cmdq_gpr_reg 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
*/
s32 cmdq_op_write_from_data_register(struct cmdqRecStruct *handle,
enum cmdq_gpr_reg src_data_reg, u32 hw_addr);
s32 cmdqRecWriteFromDataRegister(struct cmdqRecStruct *handle,
enum cmdq_gpr_reg src_data_reg, u32 hw_addr);
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 event);
s32 cmdq_op_wait_no_clear_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, enum cmdq_event event);
s32 cmdq_op_clear_event_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, enum cmdq_event event);
s32 cmdq_op_set_event_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, enum cmdq_event event);
s32 cmdq_op_acquire_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, enum cmdq_event 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);
/* Allocate 32-bit register backup slot
*/
s32 cmdq_alloc_mem(cmdqBackupSlotHandle *p_h_backup_slot, u32 slotCount);
s32 cmdqBackupAllocateSlot(cmdqBackupSlotHandle *p_h_backup_slot,
u32 slotCount);
/* Read 32-bit register backup slot by index
*/
s32 cmdq_cpu_read_mem(cmdqBackupSlotHandle h_backup_slot, u32 slot_index,
u32 *value);
s32 cmdqBackupReadSlot(cmdqBackupSlotHandle h_backup_slot, u32 slot_index,
u32 *value);
/* Use CPU to write value into 32-bit register backup slot by index directly.
*/
s32 cmdq_cpu_write_mem(cmdqBackupSlotHandle h_backup_slot,
u32 slot_index, u32 value);
s32 cmdqBackupWriteSlot(cmdqBackupSlotHandle h_backup_slot, u32 slot_index,
u32 value);
/* Free allocated backup slot. DO NOT free them before corresponding
* task finishes. Becareful on AsyncFlush use cases.
*/
s32 cmdq_free_mem(cmdqBackupSlotHandle h_backup_slot);
s32 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().
*/
s32 cmdq_op_read_reg_to_mem(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 addr);
s32 cmdqRecBackupRegisterToSlot(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 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().
*/
s32 cmdq_op_read_mem_to_reg(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 addr);
s32 cmdqRecBackupWriteRegisterFromSlot(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 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().
*/
s32 cmdq_op_write_mem(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 value);
s32 cmdqRecBackupUpdateSlot(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 value);
s32 cmdq_op_finalize_command(struct cmdqRecStruct *handle, bool loop);
void cmdq_task_prepare(struct cmdqRecStruct *handle);
void cmdq_task_unprepare(struct cmdqRecStruct *handle);
s32 cmdq_task_update_property(struct cmdqRecStruct *handle,
void *prop_addr, u32 prop_size);
/* 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.
*/
s32 cmdq_task_flush(struct cmdqRecStruct *handle);
s32 cmdqRecFlush(struct cmdqRecStruct *handle);
/* Flush the command; Also at the end of the command, backup registers
* appointed by addrArray.
*/
s32 cmdq_task_append_backup_reg(struct cmdqRecStruct *handle,
u32 reg_count, u32 *addrs);
s32 cmdq_task_flush_and_read_register(struct cmdqRecStruct *handle,
u32 reg_count, u32 *addrs, u32 *values_out);
s32 cmdqRecFlushAndReadRegister(struct cmdqRecStruct *handle,
u32 reg_count, u32 *addrs, u32 *values_out);
/* 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.
*/
s32 cmdq_task_flush_async(struct cmdqRecStruct *handle);
s32 cmdqRecFlushAsync(struct cmdqRecStruct *handle);
s32 cmdq_task_flush_async_callback(struct cmdqRecStruct *handle,
CmdqAsyncFlushCB callback, u64 user_data);
s32 cmdq_task_flush_async_destroy(struct cmdqRecStruct *handle);
s32 cmdqRecFlushAsyncCallback(struct cmdqRecStruct *handle,
CmdqAsyncFlushCB callback, u64 user_data);
/* 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.
*/
s32 cmdq_task_start_loop(struct cmdqRecStruct *handle);
s32 cmdqRecStartLoop(struct cmdqRecStruct *handle);
s32 cmdq_task_start_loop_callback(struct cmdqRecStruct *handle,
CmdqInterruptCB loopCB, unsigned long loopData);
s32 cmdqRecStartLoopWithCallback(struct cmdqRecStruct *handle,
CmdqInterruptCB loopCB, unsigned long loopData);
s32 cmdq_task_start_loop_sram(struct cmdqRecStruct *handle,
const char *SRAM_owner_name);
/* Unconditionally stops the loop thread.
* Must call after cmdq_task_start_loop().
*/
s32 cmdq_task_stop_loop(struct cmdqRecStruct *handle);
s32 cmdqRecStopLoop(struct cmdqRecStruct *handle);
/* Trigger CMDQ to copy data between DRAM and SRAM.
*
* Parameter:
* pa_src: the copy to source of DRAM PA address
* pa_dest: the copy from destination of DRAM PA address
* sram_src: the copy to destination of SRAM address
* sram_dest: the copy from source of SRAM address
* size: the copy size
*
* Return:
* 0 for success; else the error code is returned
*
* Note:
* This is an BLOCKING function. When the function is returned,
* the SRAM move is done.
*/
s32 cmdq_task_copy_to_sram(dma_addr_t pa_src, u32 sram_dest, size_t size);
s32 cmdq_task_copy_from_sram(dma_addr_t pa_dest, u32 sram_src, size_t size);
/* returns current count of instructions in given handle
*/
s32 cmdq_task_get_inst_cnt(struct cmdqRecStruct *handle);
s32 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
*/
s32 cmdq_op_profile_marker(struct cmdqRecStruct *handle, const char *tag);
s32 cmdqRecProfileMarker(struct cmdqRecStruct *handle, const char *tag);
/* Dump command buffer to kernel log
* This is for debugging purpose.
*/
s32 cmdqRecDumpCommand(struct cmdqRecStruct *handle);
/* Destroy command queue recorder handle
* Parameter:
* handle: the command queue recorder handle
*/
s32 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
*/
s32 cmdq_op_set_nop(struct cmdqRecStruct *handle, u32 index);
s32 cmdqRecSetNOP(struct cmdqRecStruct *handle, u32 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
*/
s32 cmdq_task_query_offset(struct cmdqRecStruct *handle, u32 startIndex,
const enum cmdq_code opCode, enum cmdq_event event);
s32 cmdqRecQueryOffset(struct cmdqRecStruct *handle, u32 startIndex,
const enum cmdq_code opCode, enum cmdq_event 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
*/
s32 cmdq_resource_acquire(struct cmdqRecStruct *handle,
enum cmdq_event resourceEvent);
s32 cmdqRecAcquireResource(struct cmdqRecStruct *handle,
enum cmdq_event 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
*/
s32 cmdq_resource_acquire_and_write(struct cmdqRecStruct *handle,
enum cmdq_event resourceEvent, u32 addr, u32 value, u32 mask);
s32 cmdqRecWriteForResource(struct cmdqRecStruct *handle,
enum cmdq_event resourceEvent, u32 addr, u32 value, u32 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
*/
s32 cmdq_resource_release(struct cmdqRecStruct *handle,
enum cmdq_event resourceEvent);
s32 cmdqRecReleaseResource(struct cmdqRecStruct *handle,
enum cmdq_event 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
*/
s32 cmdq_resource_release_and_write(struct cmdqRecStruct *handle,
enum cmdq_event resourceEvent, u32 addr, u32 value, u32 mask);
s32 cmdqRecWriteAndReleaseResource(struct cmdqRecStruct *handle,
enum cmdq_event resourceEvent, u32 addr, u32 value, u32 mask);
s32 cmdq_task_create_delay_thread_dram(void **pp_delay_thread_buffer,
u32 *buffer_size);
s32 cmdq_task_create_delay_thread_sram(void **pp_delay_thread_buffer,
u32 *buffer_size, u32 *cpr_offset);
/* 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_IN_HOUSE_TEE_SUPPORT
s32 cmdq_task_set_secure_mode(struct cmdqRecStruct *handle,
enum CMDQ_DISP_MODE mode);
s32 cmdqRecSetSecureMode(struct cmdqRecStruct *handle,
enum CMDQ_DISP_MODE mode);
#endif
/* Initialize the logical variable
* Parameter:
* arg: the variable you want to Initialize
*/
void cmdq_op_init_variable(CMDQ_VARIABLE *arg);
/* Initialize the logical variable
* Parameter:
* arg: the variable you want to Initialize
* cpr_offset: the cpr offset you want to use
*/
void cmdq_op_init_global_cpr_variable(CMDQ_VARIABLE *arg, u32 cpr_offset);
/* Append logic command for assign
* arg_out = arg_b
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_in: the specified GCE CPR or value
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_assign(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_in);
/* Append logic command for addition
* arg_out = arg_b + arg_c
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* arg_c: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_add(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
/* Append logic command for subtraction
* arg_out = arg_b - arg_c
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* arg_c: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_subtract(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
/* Append logic command for multiplication
* arg_out = arg_b * arg_c
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* arg_c: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_multiply(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
/* Append logic command for exclusive or operation
* arg_out = arg_b ^ arg_c
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* arg_c: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_xor(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
/* Append logic command for not operation
* arg_out = ~arg_b
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_not(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b);
/* Append logic command for or operation
* arg_out = arg_b | arg_c
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* arg_c: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_or(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
/* Append logic command for or operation
* arg_out = arg_b & arg_c
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* arg_c: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_and(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
/* Append logic command for left shift operation
* arg_out = arg_b << arg_c
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* arg_c: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_left_shift(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
/* Append logic command for left right operation
* arg_out = arg_b >> arg_c
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* arg_c: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_right_shift(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
/* Append commands for delay (micro second)
* Parameter:
* handle: the command queue recorder handle
* delay_time: delay time in us
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_delay_us(struct cmdqRecStruct *handle, u32 delay_time);
s32 cmdq_op_backup_CPR(struct cmdqRecStruct *handle, CMDQ_VARIABLE cpr,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index);
s32 cmdq_op_backup_TPR(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index);
/* Append if statement command
* if (arg_b condition arg_c)
* Parameter:
* handle: the command queue recorder handle
* arg_b: the value who use to do conditional operation
* arg_condition: conditional operator
* arg_c: the value who use to do conditional operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_if(struct cmdqRecStruct *handle, CMDQ_VARIABLE arg_b,
enum CMDQ_CONDITION_ENUM arg_condition, CMDQ_VARIABLE arg_c);
/* Append end if statement command
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_end_if(struct cmdqRecStruct *handle);
/* Append else statement command
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_else(struct cmdqRecStruct *handle);
/* Append if statement command
* else if (arg_b condition arg_c)
* Parameter:
* handle: the command queue recorder handle
* arg_b: the value who use to do conditional operation
* arg_condition: conditional operator
* arg_c: the value who use to do conditional operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_else_if(struct cmdqRecStruct *handle, CMDQ_VARIABLE arg_b,
enum CMDQ_CONDITION_ENUM arg_condition, CMDQ_VARIABLE arg_c);
/* Append while statement command
* Parameter:
* handle: the command queue recorder handle
* arg_b: the value who use to do conditional operation
* arg_condition: conditional operator
* arg_c: the value who use to do conditional operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_while(struct cmdqRecStruct *handle, CMDQ_VARIABLE arg_b,
enum CMDQ_CONDITION_ENUM arg_condition, CMDQ_VARIABLE arg_c);
/* Append continue statement command into while loop
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_continue(struct cmdqRecStruct *handle);
/* Append break statement command into while loop
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_break(struct cmdqRecStruct *handle);
/* Append end while statement command
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_end_while(struct cmdqRecStruct *handle);
/* Append do-while statement command
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_do_while(struct cmdqRecStruct *handle);
/* Append end do while statement command
* Parameter:
* handle: the command queue recorder handle
* arg_b: the value who use to do conditional operation
* arg_condition: conditional operator
* arg_c: the value who use to do conditional operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_end_do_while(struct cmdqRecStruct *handle, CMDQ_VARIABLE arg_b,
enum CMDQ_CONDITION_ENUM arg_condition, CMDQ_VARIABLE arg_c);
/* Linux like wait_event_timeout
* Parameter:
* handle: the command queue recorder handle
* arg_out, wait result (=0: timeout, >0: wait time when got event)
* wait_event: GCE event
* timeout_time: timeout time in us
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_wait_event_timeout(struct cmdqRecStruct *handle,
CMDQ_VARIABLE *arg_out, enum cmdq_event wait_event,
u32 timeout_time);
/* Append write command to the recorder
* Parameter:
* handle: the command queue recorder handle
* addr: the specified source register physical address
* arg_out: the value will be save in GCE CPR
* mask: the specified target register mask
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_read_reg(struct cmdqRecStruct *handle, u32 addr,
CMDQ_VARIABLE *arg_out, u32 mask);
/* Insert instructions to write to CMDQ variable
* from a backup memory.
*/
s32 cmdq_op_read_mem(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index,
CMDQ_VARIABLE *arg_out);
#endif /* __CMDQ_RECORD_H__ */
@@ -0,0 +1,37 @@
/* 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
s32 cmdq_append_command(struct cmdqRecStruct *handle,
enum cmdq_code code,
u32 arg_a, u32 arg_b, u32 arg_a_type, u32 arg_b_type);
s32 cmdq_op_finalize_command(struct cmdqRecStruct *handle, bool loop);
s32 cmdq_setup_sec_data_of_command_desc_by_rec_handle(
struct cmdqCommandStruct *pDesc, struct cmdqRecStruct *handle);
s32 cmdq_setup_replace_of_command_desc_by_rec_handle(
struct cmdqCommandStruct *pDesc, struct cmdqRecStruct *handle);
s32 cmdq_rec_setup_profile_marker_data(
struct cmdqCommandStruct *pDesc, struct cmdqRecStruct *handle);
s32 cmdq_task_create_delay_thread_dram(void **pp_delay_thread_buffer,
u32 *buffer_size);
s32 cmdq_task_create_delay_thread_sram(void **pp_delay_thread_buffer,
u32 *buffer_size, u32 *cpr_offset);
#ifdef __cplusplus
}
#endif
#endif /* __CMDQ_RECORD_PRIVATE_H__ */
+127
View File
@@ -0,0 +1,127 @@
/* 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_helper_ext.h"
#include "cmdq_device.h"
#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_H_SPEED_BUSY (GCE_BASE_VA + 0x048)
#define CMDQ_CURR_INST_ABORT (GCE_BASE_VA + 0x020)
#define CMDQ_SECURITY_ABORT (GCE_BASE_VA + 0x050)
#define CMDQ_SECURITY_CTL (GCE_BASE_VA + 0x054)
#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_TPR_MASK (GCE_BASE_VA + 0x0D0)
#define CMDQ_TPR_GPR_TIMER (GCE_BASE_VA + 0x0DC)
#define CMDQ_CTL_INT0 (GCE_BASE_VA + 0x0F0)
#define CMDQ_CTL_INT1 (GCE_BASE_VA + 0x0F4)
#define CMDQ_CACHE_0_EN_LO (GCE_BASE_VA + 0x10D0)
#define CMDQ_CACHE_0_EN_HI (GCE_BASE_VA + 0x10D4)
#define CMDQ_CACHE_1_EN_LO (GCE_BASE_VA + 0x10D8)
#define CMDQ_CACHE_1_EN_HI (GCE_BASE_VA + 0x10DC)
#define CMDQ_TOKEN_0_EN_LO (GCE_BASE_VA + 0x10E0)
#define CMDQ_TOKEN_0_EN_HI (GCE_BASE_VA + 0x10E4)
#define CMDQ_TOKEN_1_EN_LO (GCE_BASE_VA + 0x10E8)
#define CMDQ_TOKEN_1_EN_HI (GCE_BASE_VA + 0x10EC)
#define GCE_DBG_CTL (GCE_BASE_VA + 0x3000)
#define GCE_DBG0 (GCE_BASE_VA + 0x3004)
#define GCE_DBG1 (GCE_BASE_VA + 0x3008)
#define GCE_DBG2 (GCE_BASE_VA + 0x300C)
#define GCE_DBG3 (GCE_BASE_VA + 0x3010)
#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_SPR0(id) (GCE_BASE_VA + (0x080 * id) + 0x160)
#define CMDQ_THR_SPR1(id) (GCE_BASE_VA + (0x080 * id) + 0x164)
#define CMDQ_THR_SPR2(id) (GCE_BASE_VA + (0x080 * id) + 0x168)
#define CMDQ_THR_SPR3(id) (GCE_BASE_VA + (0x080 * id) + 0x16c)
#define CMDQ_THR_SECURITY_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x118)
#define CMDQ_THR_CURR_ADDR_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x120)
#define CMDQ_THR_END_ADDR_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x124)
#define CMDQ_THR_EXEC_CNT_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x128)
#define CMDQ_THR_SPR0_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x160)
#define CMDQ_THR_SPR1_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x164)
#define CMDQ_THR_SPR2_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x168)
#define CMDQ_THR_SPR3_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x16c)
#define CMDQ_SECURITY_CTL_PA (GCE_BASE_PA + 0x054)
#define CMDQ_SYNC_TOKEN_ID_PA (GCE_BASE_PA + 0x060)
#define CMDQ_SYNC_TOKEN_VAL_PA (GCE_BASE_PA + 0x064)
#define CMDQ_PREFETCH_GSIZE_PA (GCE_BASE_PA + 0x0C0)
#define CMDQ_TPR_MASK_PA (GCE_BASE_PA + 0x0D0)
#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_CACHE_0_EN_LO_PA (GCE_BASE_PA + 0x10D0)
#define CMDQ_CACHE_0_EN_HI_PA (GCE_BASE_PA + 0x10D4)
#define CMDQ_CACHE_1_EN_LO_PA (GCE_BASE_PA + 0x10D8)
#define CMDQ_CACHE_1_EN_HI_PA (GCE_BASE_PA + 0x10DC)
#define CMDQ_TOKEN_0_EN_LO_PA (GCE_BASE_PA + 0x10E0)
#define CMDQ_TOKEN_0_EN_HI_PA (GCE_BASE_PA + 0x10E4)
#define CMDQ_TOKEN_1_EN_LO_PA (GCE_BASE_PA + 0x10E8)
#define CMDQ_TOKEN_1_EN_HI_PA (GCE_BASE_PA + 0x10EC)
#define CMDQ_IS_END_ADDR(addr) (addr == 0)
#define CMDQ_IS_END_INSTR(p_cmd_end) \
(p_cmd_end[0] == 0 && p_cmd_end[-1] == 0)
#define CMDQ_IS_SRAM_ADDR(addr) (((addr) & 0xFFFF) == (addr))
#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
+189
View File
@@ -0,0 +1,189 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_SEC_H__
#define __CMDQ_SEC_H__
#include "cmdq_helper_ext.h"
#if defined(CMDQ_SECURE_PATH_SUPPORT)
#include "cmdq_sec_iwc_common.h"
#if defined(CMDQ_SECURE_TEE_SUPPORT)
#include "tee_client_api.h"
#endif
#if defined(CMDQ_GP_SUPPORT)
#include "cmdq_sec_gp.h"
#else
#include "cmdq_sec_trustonic.h"
#endif
#if defined(CMDQ_SECURE_MTEE_SUPPORT)
#include "cmdq_sec_mtee.h"
#endif
#endif /* CMDQ_SECURE_PATH_SUPPORT */
/*
* 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_CONTEXT_INITED = 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 */
void *iwcMessageEx; /* message buffer extra */
void *iwcMessageEx2; /* message buffer extra */
#if defined(CMDQ_SECURE_PATH_SUPPORT)
struct cmdq_sec_tee_context tee; /* trustzone parameters */
#endif
#if defined(CMDQ_SECURE_MTEE_SUPPORT)
void *mtee_iwcMessage;
void *mtee_iwcMessageEx;
void *mtee_iwcMessageEx2;
struct cmdq_sec_mtee_context mtee;
#endif
};
extern const u32 isp_iwc_buf_size[];
int32_t cmdq_sec_init_allocate_resource_thread(void *data);
s32 cmdq_sec_task_copy_to_buffer(struct cmdqRecStruct *task,
struct cmdqCommandStruct *desc);
const struct cmdq_controller *cmdq_sec_get_controller(void);
/*
* 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;
*/
typedef int32_t(*CmdqSecFillIwcCB) (
int32_t, void *, int32_t, void *, void *, void *);
/*
* Entry secure world to handle secure path jobs
* .submit task
* .cancel error task
*/
int32_t cmdq_sec_exec_task_async_unlocked(
struct cmdqRecStruct *pTask, int32_t thread);
int32_t cmdq_sec_cancel_error_task_unlocked(
struct cmdqRecStruct *pTask, int32_t thread,
struct cmdqSecCancelTaskResultStruct *pResult);
int32_t cmdq_sec_allocate_path_resource_unlocked(
bool throwAEE, const bool mtee);
s32 cmdq_sec_get_secure_thread_exec_counter(const s32 thread);
s32 cmdq_sec_revise_jump(struct cmdqRecStruct *handle);
s32 cmdq_sec_handle_error_result(struct cmdqRecStruct *task, s32 thread,
const s32 waitQ, bool throw_aee);
/* function declaretion */
struct cmdqSecContextStruct *cmdq_sec_context_handle_create(uint32_t tgid);
s32 cmdq_sec_insert_backup_cookie_instr(struct cmdqRecStruct *task, s32 thread);
void cmdq_sec_dump_secure_thread_cookie(s32 thread);
s32 cmdq_mbox_sec_chan_id(void *chan);
/*
* 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);
#if defined(CMDQ_SECURE_PATH_SUPPORT)
/*
* tee vendor interface
*/
void cmdq_sec_setup_tee_context(struct cmdq_sec_tee_context *tee);
s32 cmdq_sec_init_context(struct cmdq_sec_tee_context *tee);
s32 cmdq_sec_deinit_context(struct cmdq_sec_tee_context *tee);
s32 cmdq_sec_allocate_wsm(struct cmdq_sec_tee_context *tee, void **wsm_buffer,
u32 size, void **wsm_buf_ex, u32 size_ex,
void **wsm_buf_ex2, u32 size_ex2);
s32 cmdq_sec_free_wsm(struct cmdq_sec_tee_context *tee, void **wsm_buffer);
s32 cmdq_sec_open_session(struct cmdq_sec_tee_context *tee, void *wsm_buffer);
s32 cmdq_sec_close_session(struct cmdq_sec_tee_context *tee);
s32 cmdq_sec_execute_session(struct cmdq_sec_tee_context *tee,
u32 cmd, s32 timeout_ms, bool share_mem_ex, bool share_mem_ex2);
#endif /* CMDQ_SECURE_PATH_SUPPORT */
#if defined(CMDQ_SECURE_MTEE_SUPPORT)
void cmdq_sec_mtee_setup_context(struct cmdq_sec_mtee_context *tee);
s32 cmdq_sec_mtee_allocate_shared_memory(struct cmdq_sec_mtee_context *tee,
const dma_addr_t MVABase, const u32 size);
s32 cmdq_sec_mtee_allocate_wsm(struct cmdq_sec_mtee_context *tee,
void **wsm_buffer, u32 size, void **wsm_buf_ex, u32 size_ex,
void **wsm_buf_ex2, u32 size_ex2);
s32 cmdq_sec_mtee_free_wsm(
struct cmdq_sec_mtee_context *tee, void **wsm_buffer);
s32 cmdq_sec_mtee_open_session(
struct cmdq_sec_mtee_context *tee, void *wsm_buffer);
s32 cmdq_sec_mtee_close_session(struct cmdq_sec_mtee_context *tee);
s32 cmdq_sec_mtee_execute_session(struct cmdq_sec_mtee_context *tee,
u32 cmd, s32 timeout_ms, bool share_mem_ex, bool share_mem_ex2);
#endif
#endif /* __DDP_CMDQ_SEC_H__ */
+196
View File
@@ -0,0 +1,196 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#include "cmdq_core.h"
#include "cmdq_sec_gp.h"
#define UUID_STR "09010000000000000000000000000000"
void cmdq_sec_setup_tee_context(struct cmdq_sec_tee_context *tee)
{
/* 09010000 0000 0000 0000000000000000 */
tee->uuid = (struct TEEC_UUID) { 0x09010000, 0x0, 0x0,
{ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } };
}
s32 cmdq_sec_init_context(struct cmdq_sec_tee_context *tee)
{
s32 status;
CMDQ_MSG("[SEC] enter %s\n", __func__);
#if defined(CONFIG_MICROTRUST_TEE_SUPPORT)
while (!is_teei_ready()) {
CMDQ_MSG("[SEC] Microtrust TEE is not ready, wait...\n");
msleep(1000);
}
#elif defined(CONFIG_TRUSTONIC_TEE_SUPPORT)
while (!is_mobicore_ready()) {
CMDQ_MSG("[SEC] Trustonic TEE is not ready, wait...\n");
msleep(1000);
}
#endif
CMDQ_LOG("[SEC]TEE is ready\n");
status = TEEC_InitializeContext(NULL, &tee->gp_context);
if (status != TEEC_SUCCESS)
CMDQ_ERR("[SEC]init_context fail: status:0x%x\n", status);
else
CMDQ_MSG("[SEC]init_context: status:0x%x\n", status);
return status;
}
s32 cmdq_sec_deinit_context(struct cmdq_sec_tee_context *tee)
{
TEEC_FinalizeContext(&tee->gp_context);
return 0;
}
s32 cmdq_sec_allocate_wsm(struct cmdq_sec_tee_context *tee,
void **wsm_buffer, u32 size, void **wsm_buf_ex, u32 size_ex,
void **wsm_buf_ex2, u32 size_ex2)
{
s32 status;
if (!wsm_buffer || !wsm_buf_ex || !wsm_buf_ex2)
return -EINVAL;
CMDQ_MSG("%s tee:0x%p size:%u size ex:%u size ex2:%u\n",
__func__, tee, size, size_ex, size_ex2);
tee->shared_mem.size = size;
tee->shared_mem.flags = TEEC_MEM_INPUT | TEEC_MEM_OUTPUT;
status = TEEC_AllocateSharedMemory(&tee->gp_context,
&tee->shared_mem);
if (status != TEEC_SUCCESS) {
CMDQ_LOG("[WARN][SEC]allocate_wsm: err:0x%x size:%u\n",
status, size);
} else {
CMDQ_LOG("[SEC]allocate_wsm: status:0x%x wsm:0x%p size:%u\n",
status, tee->shared_mem.buffer, size);
*wsm_buffer = (void *)tee->shared_mem.buffer;
}
tee->shared_mem_ex.size = size_ex;
tee->shared_mem_ex.flags = TEEC_MEM_INPUT | TEEC_MEM_OUTPUT;
status = TEEC_AllocateSharedMemory(&tee->gp_context,
&tee->shared_mem_ex);
if (status != TEEC_SUCCESS) {
CMDQ_LOG("[WARN][SEC]allocate_wsm: err:0x%x size_ex:%u\n",
status, size_ex);
} else {
CMDQ_LOG("[SEC]allocate_wsm: status:0x%x wsm:0x%p size ex:%u\n",
status, tee->shared_mem_ex.buffer, size_ex);
*wsm_buf_ex = (void *)tee->shared_mem_ex.buffer;
}
tee->shared_mem_ex2.size = size_ex2;
tee->shared_mem_ex2.flags = TEEC_MEM_INPUT | TEEC_MEM_OUTPUT;
status = TEEC_AllocateSharedMemory(&tee->gp_context,
&tee->shared_mem_ex2);
if (status != TEEC_SUCCESS) {
CMDQ_LOG("[WARN][SEC]allocate_wsm: err:0x%x size_ex:%u\n",
status, size_ex2);
} else {
CMDQ_LOG("[SEC]allocate_wsm: status:0x%x wsm:0x%p size ex:%u\n",
status, tee->shared_mem_ex2.buffer, size_ex2);
*wsm_buf_ex2 = (void *)tee->shared_mem_ex2.buffer;
}
return status;
}
s32 cmdq_sec_free_wsm(struct cmdq_sec_tee_context *tee,
void **wsm_buffer)
{
if (!wsm_buffer)
return -EINVAL;
TEEC_ReleaseSharedMemory(&tee->shared_mem);
*wsm_buffer = NULL;
return 0;
}
s32 cmdq_sec_open_session(struct cmdq_sec_tee_context *tee,
void *wsm_buffer)
{
s32 status, ret_origin;
if (!wsm_buffer) {
CMDQ_ERR("[SEC]open_session: invalid param wsm buffer:0x%p\n",
wsm_buffer);
return -EINVAL;
}
status = TEEC_OpenSession(&tee->gp_context,
&tee->session, &tee->uuid,
TEEC_LOGIN_PUBLIC, NULL, NULL, &ret_origin);
if (status != TEEC_SUCCESS) {
/* print error message */
CMDQ_ERR(
"[SEC]open_session fail: status:0x%x ret origin:0x%08x\n",
status, ret_origin);
} else {
CMDQ_MSG("[SEC]open_session: status:0x%x\n", status);
}
return status;
}
s32 cmdq_sec_close_session(struct cmdq_sec_tee_context *tee)
{
TEEC_CloseSession(&tee->session);
return 0;
}
s32 cmdq_sec_execute_session(struct cmdq_sec_tee_context *tee,
u32 cmd, s32 timeout_ms, bool share_mem_ex1, bool share_mem_ex2)
{
s32 status;
struct TEEC_Operation operation;
memset(&operation, 0, sizeof(struct TEEC_Operation));
#if defined(CONFIG_TRUSTONIC_TEE_SUPPORT)
operation.param_types = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INOUT,
share_mem_ex1 ? TEEC_MEMREF_PARTIAL_INOUT : TEEC_NONE,
share_mem_ex2 ? TEEC_MEMREF_PARTIAL_INOUT : TEEC_NONE,
TEEC_NONE);
#else
operation.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_PARTIAL_INOUT,
share_mem_ex1 ? TEEC_MEMREF_PARTIAL_INOUT : TEEC_NONE,
share_mem_ex2 ? TEEC_MEMREF_PARTIAL_INOUT : TEEC_NONE,
TEEC_NONE);
#endif
operation.params[0].memref.parent = &tee->shared_mem;
operation.params[0].memref.size = tee->shared_mem.size;
operation.params[0].memref.offset = 0;
if (share_mem_ex1) {
operation.params[1].memref.parent = &tee->shared_mem_ex;
operation.params[1].memref.size = tee->shared_mem_ex.size;
operation.params[1].memref.offset = 0;
}
if (share_mem_ex2) {
operation.params[2].memref.parent = &tee->shared_mem_ex2;
operation.params[2].memref.size = tee->shared_mem_ex2.size;
operation.params[2].memref.offset = 0;
}
status = TEEC_InvokeCommand(&tee->session, cmd, &operation,
NULL);
if (status != TEEC_SUCCESS)
CMDQ_ERR(
"[SEC]execute: TEEC_InvokeCommand:%u err:%d memex:%s memex2:%s\n",
cmd, status, share_mem_ex1 ? "true" : "false",
share_mem_ex2 ? "true" : "false");
else
CMDQ_MSG(
"[SEC]execute: TEEC_InvokeCommand:%u ret:%d memex:%s memex2:%s\n",
cmd, status, share_mem_ex1 ? "true" : "false",
share_mem_ex2 ? "true" : "false");
return status;
}
@@ -0,0 +1,31 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_SEC_GP_H__
#define __CMDQ_SEC_GP_H__
#include <linux/types.h>
#include <linux/delay.h>
#include "tee_client_api.h"
#if defined(CONFIG_MICROTRUST_TEE_SUPPORT)
#include "teei_client_main.h"
#endif
#if defined(CONFIG_TRUSTONIC_TEE_SUPPORT)
#include "mobicore_driver_api.h"
#endif
/* context for tee vendor */
struct cmdq_sec_tee_context {
/* Universally Unique Identifier of secure tl/dr */
struct TEEC_UUID uuid;
struct TEEC_Context gp_context; /* basic context */
struct TEEC_Session session; /* session handle */
struct TEEC_SharedMemory shared_mem; /* shared memory */
struct TEEC_SharedMemory shared_mem_ex; /* shared memory */
struct TEEC_SharedMemory shared_mem_ex2; /* shared memory */
};
#endif /* __CMDQ_SEC_GP_H__ */
@@ -0,0 +1,223 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#include <linux/arm-smccc.h>
#include <linux/soc/mediatek/mtk-cmdq.h>
#include "cmdq_sec_mtee.h"
static bool cmdq_mtee;
void cmdq_sec_mtee_setup_context(struct cmdq_sec_mtee_context *tee)
{
const char ta_uuid[32] = "com.mediatek.geniezone.cmdq";
const char wsm_uuid[32] = "com.mediatek.geniezone.srv.mem";
struct arm_smccc_res res;
memset(tee, 0, sizeof(*tee));
strncpy(tee->ta_uuid, ta_uuid, sizeof(ta_uuid));
strncpy(tee->wsm_uuid, wsm_uuid, sizeof(wsm_uuid));
arm_smccc_smc(0xBC00000B, 1, 0, 0, 0, 0, 0, 0, &res);
if (res.a0 == 1)
cmdq_mtee = true;
cmdq_msg("%s cmdq_mtee:%d", __func__, cmdq_mtee);
}
s32 cmdq_sec_mtee_allocate_shared_memory(struct cmdq_sec_mtee_context *tee,
const dma_addr_t MVABase, const u32 size)
{
s32 status;
if (!cmdq_mtee) {
cmdq_msg("%s cmdq_mtee:%d not support", __func__, cmdq_mtee);
return 0;
}
tee->mem_param.size = size;
tee->mem_param.buffer = (void *)(unsigned long)MVABase;
status = KREE_RegisterSharedmem(tee->wsm_pHandle,
&tee->mem_handle, &tee->mem_param);
if (status != TZ_RESULT_SUCCESS)
cmdq_err("%s: session:%#x handle:%#x size:%#x buffer:%p",
__func__, tee->wsm_pHandle, tee->mem_handle,
tee->mem_param.size, tee->mem_param.buffer);
else
cmdq_log("%s: session:%#x handle:%#x size:%#x buffer:%p",
__func__, tee->wsm_pHandle, tee->mem_handle,
tee->mem_param.size, tee->mem_param.buffer);
return status;
}
s32 cmdq_sec_mtee_allocate_wsm(struct cmdq_sec_mtee_context *tee,
void **wsm_buffer, u32 size, void **wsm_buf_ex, u32 size_ex,
void **wsm_buf_ex2, u32 size_ex2)
{
s32 status;
if (!cmdq_mtee) {
cmdq_msg("%s cmdq_mtee:%d not support", __func__, cmdq_mtee);
return 0;
}
if (!wsm_buffer || !wsm_buf_ex || !wsm_buf_ex2)
return -EINVAL;
#ifndef CMDQ_LATE_INIT_SUPPORT
/* region_id = 0, mapAry = NULL for continuous */
*wsm_buffer = kzalloc(size, GFP_KERNEL);
if (!*wsm_buffer)
return -ENOMEM;
#endif
tee->wsm_param.size = size;
tee->wsm_param.buffer = (void *)(u64)virt_to_phys(*wsm_buffer);
status = KREE_RegisterSharedmem(tee->wsm_pHandle,
&tee->wsm_handle, &tee->wsm_param);
if (status != TZ_RESULT_SUCCESS) {
cmdq_err("%s: session:%#x handle:%#x size:%#x buffer:%p",
__func__, tee->wsm_pHandle, tee->wsm_handle,
tee->wsm_param.size, *wsm_buffer);
return status;
}
cmdq_log("%s: session:%#x handle:%#x size:%#x buffer:%p",
__func__, tee->wsm_pHandle, tee->wsm_handle,
tee->wsm_param.size, *wsm_buffer);
#ifndef CMDQ_LATE_INIT_SUPPORT
*wsm_buf_ex = kzalloc(size_ex, GFP_KERNEL);
if (!*wsm_buf_ex)
return -ENOMEM;
#endif
tee->wsm_ex_param.size = size_ex;
tee->wsm_ex_param.buffer = (void *)(u64)virt_to_phys(*wsm_buf_ex);
status = KREE_RegisterSharedmem(tee->wsm_pHandle,
&tee->wsm_ex_handle, &tee->wsm_ex_param);
if (status != TZ_RESULT_SUCCESS)
cmdq_err("%s: session:%#x handle:%#x size:%#x buffer:%p",
__func__, tee->wsm_pHandle, tee->wsm_ex_handle,
tee->wsm_ex_param.size, *wsm_buf_ex);
else
cmdq_log("%s: session:%#x handle:%#x size:%#x buffer:%p",
__func__, tee->wsm_pHandle, tee->wsm_ex_handle,
tee->wsm_ex_param.size, *wsm_buf_ex);
#ifndef CMDQ_LATE_INIT_SUPPORT
*wsm_buf_ex2 = kzalloc(size_ex2, GFP_KERNEL);
if (!*wsm_buf_ex2)
return -ENOMEM;
#endif
tee->wsm_ex2_param.size = size_ex2;
tee->wsm_ex2_param.buffer = (void *)(u64)virt_to_phys(*wsm_buf_ex2);
status = KREE_RegisterSharedmem(tee->wsm_pHandle,
&tee->wsm_ex2_handle, &tee->wsm_ex2_param);
if (status != TZ_RESULT_SUCCESS)
cmdq_err("%s: session:%#x handle:%#x size:%#x buffer:%p",
__func__, tee->wsm_pHandle, tee->wsm_ex2_handle,
tee->wsm_ex2_param.size, *wsm_buf_ex2);
else
cmdq_log("%s: session:%#x handle:%#x size:%#x buffer:%p",
__func__, tee->wsm_pHandle, tee->wsm_ex2_handle,
tee->wsm_ex2_param.size, *wsm_buf_ex2);
return status;
}
s32 cmdq_sec_mtee_free_wsm(struct cmdq_sec_mtee_context *tee,
void **wsm_buffer)
{
if (!cmdq_mtee) {
cmdq_msg("%s cmdq_mtee:%d not support", __func__, cmdq_mtee);
return 0;
}
if (!wsm_buffer)
return -EINVAL;
KREE_UnregisterSharedmem(tee->wsm_pHandle, tee->wsm_handle);
vfree(*wsm_buffer);
*wsm_buffer = NULL;
return 0;
}
s32 cmdq_sec_mtee_open_session(struct cmdq_sec_mtee_context *tee,
void *wsm_buffer)
{
s32 status;
if (!cmdq_mtee) {
cmdq_msg("%s cmdq_mtee:%d not support", __func__, cmdq_mtee);
return 0;
}
status = KREE_CreateSession(tee->ta_uuid, &tee->pHandle);
if (status != TZ_RESULT_SUCCESS) {
cmdq_err("%s:%s:%d", __func__, tee->ta_uuid, status);
return status;
}
cmdq_log("%s: tee:%p ta_uuid:%s session:%#x",
__func__, tee, tee->ta_uuid, tee->pHandle);
status = KREE_CreateSession(tee->wsm_uuid, &tee->wsm_pHandle);
if (status != TZ_RESULT_SUCCESS) {
cmdq_err("%s:%s:%d", __func__, tee->ta_uuid, status);
return status;
}
cmdq_log("%s: tee:%p ta_uuid:%s session:%#x",
__func__, tee, tee->wsm_uuid, tee->wsm_pHandle);
return status;
}
s32 cmdq_sec_mtee_close_session(struct cmdq_sec_mtee_context *tee)
{
if (!cmdq_mtee) {
cmdq_msg("%s cmdq_mtee:%d not support", __func__, cmdq_mtee);
return 0;
}
KREE_CloseSession(tee->wsm_pHandle);
return KREE_CloseSession(tee->pHandle);
}
s32 cmdq_sec_mtee_execute_session(struct cmdq_sec_mtee_context *tee,
u32 cmd, s32 timeout_ms, bool share_mem_ex, bool share_mem_ex2)
{
s32 status;
u32 types = TZ_ParamTypes4(TZPT_VALUE_INOUT,
share_mem_ex ? TZPT_VALUE_INOUT : TZPT_NONE,
share_mem_ex2 ? TZPT_VALUE_INOUT : TZPT_NONE,
cmd == 4 ? TZPT_VALUE_INOUT : TZPT_NONE); // TODO
union MTEEC_PARAM param[4];
if (!cmdq_mtee) {
cmdq_msg("%s cmdq_mtee:%d not support", __func__, cmdq_mtee);
return 0;
}
param[0].value.a = tee->wsm_handle;
param[0].value.b = tee->wsm_param.size;
param[1].value.a = tee->wsm_ex_handle;
param[1].value.b = tee->wsm_ex_param.size;
param[2].value.a = tee->wsm_ex2_handle;
param[2].value.b = tee->wsm_ex2_param.size;
param[3].value.a = tee->mem_handle;
param[3].value.b = (u32)(unsigned long)tee->mem_param.buffer;
cmdq_log("%s: tee:%p session:%#x cmd:%u timeout:%d",
__func__, tee, tee->pHandle, cmd, timeout_ms);
cmdq_log("%s: mem_ex:%d mem_ex2:%d types:%#x",
__func__, share_mem_ex, share_mem_ex2, types);
cmdq_log("wsm:%#x:%#x ex:%#x:%#x ex2:%#x:%#x mem:%#x:%#x",
param[0].value.a, param[0].value.b,
param[1].value.a, param[1].value.b,
param[2].value.a, param[2].value.b,
param[3].value.a, param[3].value.b);
status = KREE_TeeServiceCall(tee->pHandle, cmd, types, param);
if (status != TZ_RESULT_SUCCESS)
cmdq_err("%s:%d cmd:%u", __func__, status, cmd);
else
cmdq_msg("%s:%d cmd:%u", __func__, status, cmd);
return status;
}
@@ -0,0 +1,43 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_SEC_MTEE_H__
#define __CMDQ_SEC_MTEE_H__
#include <linux/types.h>
#include <linux/delay.h>
#include <linux/limits.h>
#include <kree/system.h>
#include <kree/mem.h>
#include <linux/vmalloc.h>
//#include "tee_client_api.h"
#if defined(CONFIG_MICROTRUST_TEE_SUPPORT)
#include "teei_client_main.h"
#endif
#if defined(CONFIG_TRUSTONIC_TEE_SUPPORT)
#include "mobicore_driver_api.h"
#endif
/* context for tee vendor */
struct cmdq_sec_mtee_context {
char ta_uuid[NAME_MAX];
KREE_SESSION_HANDLE pHandle;
char wsm_uuid[NAME_MAX];
KREE_SESSION_HANDLE wsm_pHandle;
KREE_SHAREDMEM_HANDLE wsm_handle;
KREE_SHAREDMEM_PARAM wsm_param;
KREE_SHAREDMEM_HANDLE wsm_ex_handle;
KREE_SHAREDMEM_PARAM wsm_ex_param;
KREE_SHAREDMEM_HANDLE wsm_ex2_handle;
KREE_SHAREDMEM_PARAM wsm_ex2_param;
KREE_SHAREDMEM_HANDLE mem_handle;
KREE_SHAREDMEM_PARAM mem_param;
};
#endif /* __CMDQ_SEC_MTEE_H__ */
@@ -0,0 +1,237 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#include "cmdq_core.h"
#include "cmdq_sec_trustonic.h"
void cmdq_sec_setup_tee_context(struct cmdq_sec_tee_context *tee)
{
/* 09010000 0000 0000 0000000000000000 */
tee->uuid = (struct mc_uuid_t){ { 9, 1, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0 } };
}
s32 cmdq_sec_init_context(struct cmdq_sec_tee_context *tee)
{
s32 status;
enum mc_result mcRet = MC_DRV_ERR_UNKNOWN;
s32 retry_cnt = 0, max_retry = 30;
do {
status = 0;
mcRet = mc_open_device(MC_DEVICE_ID_DEFAULT);
/* Currently, a process context limits to open mobicore device
* once, and mc_open_device dose not support reference cout
* so skip the false alarm error....
*/
if (mcRet == MC_DRV_ERR_INVALID_OPERATION) {
CMDQ_MSG(
"[SEC]init_context: already opened, continue to execution\n");
status = 0;
tee->open_mobicore_by_other = 1;
} else if (mcRet != MC_DRV_OK) {
CMDQ_ERR("[SEC]init_context: err:0x%x, retry:%d\n",
mcRet, retry_cnt);
status = -1;
msleep_interruptible(2000);
retry_cnt++;
continue;
}
break;
} while (retry_cnt < max_retry);
if (retry_cnt >= max_retry) {
/* print error message */
CMDQ_ERR(
"[SEC]init_context fail: status:%d mcRet:0x%x retry:%d\n",
status, mcRet, retry_cnt);
} else {
CMDQ_MSG("[SEC]init_context: status:%d mcRet:0x%x retry:%d\n",
status, mcRet, retry_cnt);
}
return status;
}
s32 cmdq_sec_deinit_context(struct cmdq_sec_tee_context *tee)
{
s32 status = 0;
enum mc_result mcRet = 0;
if (tee->open_mobicore_by_other == 1) {
/* do nothing */
/* let last user to close mobicore.... */
CMDQ_MSG(
"[SEC]_MOBICORE_CLOSE: opened by other, bypass device close\n");
} else {
mcRet = mc_close_device(MC_DEVICE_ID_DEFAULT);
CMDQ_MSG(
"[SEC]_MOBICORE_CLOSE: status:%d ret:0x%x openMobicoreByOther:%d\n",
status, mcRet, tee->open_mobicore_by_other);
if (mcRet != MC_DRV_OK) {
CMDQ_ERR("[SEC]_MOBICORE_CLOSE: err:0x%x\n", mcRet);
status = -1;
}
}
return status;
}
s32 cmdq_sec_allocate_wsm(struct cmdq_sec_tee_context *tee,
void **wsm_buffer, u32 size)
{
s32 status;
enum mc_result mcRet = MC_DRV_OK;
if (!wsm_buffer)
return -EINVAL;
/* because world shared mem(WSM) will ba managed by mobicore device,
* instead of linux kernel vmalloc/kmalloc, call mc_malloc_wasm to
* alloc WSM to prvent error such as "can not resolve tci physicall
* address" etc
*/
mcRet = mc_malloc_wsm(MC_DEVICE_ID_DEFAULT, 0, size,
(u8 **)wsm_buffer, 0);
if (mcRet != MC_DRV_OK) {
CMDQ_ERR("[SEC]allocate_wsm: err:0x%x\n", mcRet);
status = -EINVAL;
} else {
CMDQ_MSG("[SEC]allocate_wsm: status:%d *ppWsm:0x%p\n",
status, *wsm_buffer);
tee->wsm_size = size;
}
return status;
}
s32 cmdq_sec_free_wsm(struct cmdq_sec_tee_context *tee,
void **wsm_buffer)
{
s32 status = 0;
enum mc_result mcRet;
if (!wsm_buffer)
return -EINVAL;
mcRet = mc_free_wsm(MC_DEVICE_ID_DEFAULT,
*wsm_buffer);
if (mcRet != MC_DRV_OK) {
CMDQ_ERR("free_wsm: err:0x%x", mcRet);
status = -EINVAL;
} else {
*wsm_buffer = NULL;
CMDQ_VERBOSE("free_wsm: ret:0x%x\n", mcRet);
}
return status;
}
s32 cmdq_sec_open_session(struct cmdq_sec_tee_context *tee,
void *wsm_buffer)
{
s32 status;
s32 retry_cnt = 0, max_retry = 30;
enum mc_result mcRet = MC_DRV_OK;
if (!wsm_buffer) {
CMDQ_ERR("[SEC]open_session: invalid param wsm buffer:0x%p\n",
wsm_buffer);
return -EINVAL;
}
tee->session.device_id = MC_DEVICE_ID_DEFAULT;
do {
mcRet = mc_open_session(&tee->session,
&tee->uuid, wsm_buffer, tee->wsm_size);
if (mcRet != MC_DRV_OK) {
CMDQ_ERR("[SEC]open_session: err:0x%x retry:%d\n",
mcRet, retry_cnt);
retry_cnt++;
msleep_interruptible(2000);
status = -1;
continue;
}
/* Open Session success */
status = 0;
break;
} while (retry_cnt < max_retry);
if (retry_cnt >= max_retry) {
/* print error message */
CMDQ_ERR(
"[SEC]open_session fail: status:%d mcRet:0x%x retry:%d\n",
status, mcRet, retry_cnt);
} else {
CMDQ_MSG(
"[SEC]open_session: status:%d mcRet:0x%x retry:%d\n",
status, mcRet, retry_cnt);
}
return status;
}
s32 cmdq_sec_close_session(struct cmdq_sec_tee_context *tee)
{
s32 status = 0;
enum mc_result mcRet = mc_close_session(&tee->session);
if (mcRet != MC_DRV_OK) {
CMDQ_ERR("close_session: err:0x%x", mcRet);
status = -1;
}
return status;
}
s32 cmdq_sec_execute_session(struct cmdq_sec_tee_context *tee,
s32 timeout_ms)
{
enum mc_result mcRet;
s32 status = 0;
const s32 sec_timeout = timeout_ms > 0 ?
timeout_ms : MC_INFINITE_TIMEOUT;
CMDQ_PROF_START(current->pid, "CMDQ_SEC_EXE");
do {
/* notify to secure world */
mcRet = mc_notify(&tee->session);
if (mcRet != MC_DRV_OK) {
CMDQ_ERR("[SEC]EXEC: mc_notify err:0x%x\n", mcRet);
status = -1;
break;
}
CMDQ_MSG("[SEC]EXEC: mc_notify ret:0x%x\n", mcRet);
/* wait respond */
mcRet = mc_wait_notification(&tee->session, sec_timeout);
if (mcRet == MC_DRV_ERR_TIMEOUT) {
CMDQ_ERR(
"[SEC]EXEC: mc_wait_notification timeout, err:0x%x secureWoldTimeout_ms:%d\n",
mcRet, sec_timeout);
status = -ETIMEDOUT;
break;
}
if (mcRet != MC_DRV_OK) {
CMDQ_ERR("[SEC]EXEC: mc_wait_notification err:0x%x\n",
mcRet);
status = -1;
break;
}
CMDQ_MSG("[SEC]EXEC: mc_wait_notification err:%d\n", mcRet);
} while (0);
CMDQ_PROF_END(current->pid, "CMDQ_SEC_EXE");
return status;
}
@@ -0,0 +1,29 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef __CMDQ_SEC_TRUSTONIC_H__
#define __CMDQ_SEC_TRUSTONIC_H__
#include <linux/delay.h>
#if defined(CONFIG_TRUSTONIC_TEE_SUPPORT)
#include "mobicore_driver_api.h"
#endif
/* context for tee vendor */
struct cmdq_sec_tee_context {
#if defined(CONFIG_TRUSTONIC_TEE_SUPPORT)
/* Universally Unique Identifier of secure tl/dr */
struct mc_uuid_t uuid;
struct mc_session_handle session; /* session handle */
#endif
/* true if someone has opened mobicore device
* in this prpocess context
*/
u32 open_mobicore_by_other;
u32 wsm_size;
};
#endif /* __CMDQ_SEC_TRUSTONIC_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,79 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#include "cmdq_subsys_common.h"
#include "cmdq_helper_ext.h"
static struct cmdq_subsys_dts_name subsys[] = {
[CMDQ_SUBSYS_G3D_CONFIG_BASE] = {
.group = "MFG", .name = "g3d_config_base"},
[CMDQ_SUBSYS_MMSYS_CONFIG] = {
.group = "MMSYS", .name = "mmsys_config_base"},
[CMDQ_SUBSYS_DISP_DITHER] = {
.group = "MMSYS", .name = "disp_dither_base"},
[CMDQ_SUBSYS_NA] = {.group = "MMSYS", .name = "mm_na_base"},
[CMDQ_SUBSYS_IMGSYS] = {.group = "CAM", .name = "imgsys_base"},
[CMDQ_SUBSYS_VDEC_GCON] = {.group = "VDEC", .name = "vdec_gcon_base"},
[CMDQ_SUBSYS_VENC_GCON] = {.group = "VENC", .name = "venc_gcon_base"},
[CMDQ_SUBSYS_CONN_PERIPHERALS] = {
.group = "PERISYS", .name = "conn_peri_base"},
[CMDQ_SUBSYS_TOPCKGEN] = {
.group = "TOP_AO_3", .name = "topckgen_base"},
[CMDQ_SUBSYS_KP] = {.group = "INFRA_AO", .name = "kp_base"},
[CMDQ_SUBSYS_SCP_SRAM] = {
.group = "INFRA_AO", .name = "scp_sram_base"},
[CMDQ_SUBSYS_INFRA_NA3] = {.group = "NA", .name = "infra_na3_base"},
[CMDQ_SUBSYS_INFRA_NA4] = {.group = "NA", .name = "infra_na4_base"},
[CMDQ_SUBSYS_SCP] = {.group = "SCP", .name = "scp_base"},
[CMDQ_SUBSYS_MCUCFG] = {.group = "INFRASYS", .name = "mcucfg_base"},
[CMDQ_SUBSYS_GCPU] = {.group = "INFRASYS", .name = "gcpu_base"},
[CMDQ_SUBSYS_USB0] = {.group = "PERISYS", .name = "usb0_base"},
[CMDQ_SUBSYS_USB_SIF] = {.group = "PERISYS", .name = "usb_sif_base"},
[CMDQ_SUBSYS_AUDIO] = {.group = "PERISYS", .name = "audio_base"},
[CMDQ_SUBSYS_MSDC0] = {.group = "PERISYS", .name = "msdc0_base"},
[CMDQ_SUBSYS_MSDC1] = {.group = "PERISYS", .name = "msdc1_base"},
[CMDQ_SUBSYS_MSDC2] = {.group = "PERISYS", .name = "msdc2_base"},
[CMDQ_SUBSYS_MSDC3] = {.group = "PERISYS", .name = "msdc3_base"},
[CMDQ_SUBSYS_AP_DMA] = {.group = "INFRASYS", .name = "ap_dma_base"},
[CMDQ_SUBSYS_GCE] = {.group = "GCE", .name = "gce_base"},
[CMDQ_SUBSYS_VDEC] = {.group = "VDEC", .name = "vdec_base"},
[CMDQ_SUBSYS_VDEC1] = {.group = "VDEC", .name = "vdec1_base"},
[CMDQ_SUBSYS_VDEC2] = {.group = "VDEC", .name = "vdec2_base"},
[CMDQ_SUBSYS_VDEC3] = {.group = "VDEC", .name = "vdec3_base"},
[CMDQ_SUBSYS_CAMSYS] = {.group = "CAMSYS", .name = "camsys_base"},
[CMDQ_SUBSYS_CAMSYS1] = {.group = "CAMSYS", .name = "camsys1_base"},
[CMDQ_SUBSYS_CAMSYS2] = {.group = "CAMSYS", .name = "camsys2_base"},
[CMDQ_SUBSYS_CAMSYS3] = {.group = "CAMSYS", .name = "camsys3_base"},
[CMDQ_SUBSYS_IMGSYS1] = {.group = "IMGSYS", .name = "imgsys1_base"},
[CMDQ_SUBSYS_SMI_LAB1] = {
.group = "SMI_LAB1", .name = "smi_larb1_base"},
/* Special subsys */
[CMDQ_SUBSYS_PWM_SW] = {.group = "SPECIAL", .name = "pwm_sw_base"},
[CMDQ_SUBSYS_PWM1_SW] = {.group = "SPECIAL", .name = "pwm1_sw_base"},
[CMDQ_SUBSYS_DIP_A0_SW] = {
.group = "SPECIAL", .name = "dip_a0_sw_base"},
[CMDQ_SUBSYS_MIPITX0] = {.group = "SPECIAL", .name = "mipitx0_base"},
[CMDQ_SUBSYS_MIPITX1] = {.group = "SPECIAL", .name = "mipitx1_base"},
[CMDQ_SUBSYS_VENC] = {.group = "SPECIAL", .name = "venc_base"},
[CMDQ_SUBSYS_IMGSYS2] = {.group = "SPECIAL", .name = "imgsys2_base"},
[CMDQ_SUBSYS_IPESYS] = {.group = "SPECIAL", .name = "ipesys_base"},
[CMDQ_SUBSYS_DPE] = {.group = "SPECIAL", .name = "dpe_base"},
};
struct cmdq_subsys_dts_name *cmdq_subsys_get_dts(void)
{
return subsys;
}
u32 cmdq_subsys_get_size(void)
{
return ARRAY_SIZE(subsys);
}
@@ -0,0 +1,71 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2015 MediaTek Inc.
*/
#ifndef _CMDQ_SUBSYS_COMMON_H_
#define _CMDQ_SUBSYS_COMMON_H_
/* Define CMDQ subsys
*
* CMDQ subsys base address define in DTS.
* Mapping dts name and subsys define must sync with
* subsys table define in cmdq_subsys_common.c.
*/
enum CMDQ_SUBSYS_ENUM {
CMDQ_SUBSYS_G3D_CONFIG_BASE,
CMDQ_SUBSYS_MMSYS_CONFIG,
CMDQ_SUBSYS_DISP_DITHER,
CMDQ_SUBSYS_NA,
CMDQ_SUBSYS_IMGSYS,
CMDQ_SUBSYS_VDEC_GCON,
CMDQ_SUBSYS_VENC_GCON,
CMDQ_SUBSYS_CONN_PERIPHERALS,
CMDQ_SUBSYS_TOPCKGEN,
CMDQ_SUBSYS_KP,
CMDQ_SUBSYS_SCP_SRAM,
CMDQ_SUBSYS_INFRA_NA3,
CMDQ_SUBSYS_INFRA_NA4,
CMDQ_SUBSYS_SCP,
CMDQ_SUBSYS_MCUCFG,
CMDQ_SUBSYS_GCPU,
CMDQ_SUBSYS_USB0,
CMDQ_SUBSYS_USB_SIF,
CMDQ_SUBSYS_AUDIO,
CMDQ_SUBSYS_MSDC0,
CMDQ_SUBSYS_MSDC1,
CMDQ_SUBSYS_MSDC2,
CMDQ_SUBSYS_MSDC3,
CMDQ_SUBSYS_AP_DMA,
CMDQ_SUBSYS_GCE,
CMDQ_SUBSYS_VDEC,
CMDQ_SUBSYS_VDEC1,
CMDQ_SUBSYS_VDEC2,
CMDQ_SUBSYS_VDEC3,
CMDQ_SUBSYS_CAMSYS,
CMDQ_SUBSYS_CAMSYS1,
CMDQ_SUBSYS_CAMSYS2,
CMDQ_SUBSYS_CAMSYS3,
CMDQ_SUBSYS_IMGSYS1,
CMDQ_SUBSYS_SMI_LAB1,
/* Special subsys */
CMDQ_SUBSYS_PWM_SW,
CMDQ_SUBSYS_PWM1_SW,
CMDQ_SUBSYS_DIP_A0_SW,
CMDQ_SUBSYS_MIPITX0,
CMDQ_SUBSYS_MIPITX1,
CMDQ_SUBSYS_VENC,
CMDQ_SUBSYS_IMGSYS2,
CMDQ_SUBSYS_IPESYS,
CMDQ_SUBSYS_DPE,
/* ALWAYS keep at the end */
CMDQ_SUBSYS_MAX_COUNT
};
#endif
File diff suppressed because it is too large. Load diff
Loaded 100 of 80519 files, more files were not shown because too many files have changed in this diff. Show more