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

@@ -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";
}