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

+136
View File
@@ -0,0 +1,136 @@
#
# Copyright (C) 2019 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# driver code for MDP
ifeq ($(CONFIG_MACH_MT6833),y)
MTK_PLATFORM := "mt6833"
else ifeq ($(CONFIG_MACH_MT6781),y)
MTK_PLATFORM := "mt6781"
else
MTK_PLATFORM := $(CONFIG_MTK_PLATFORM)
endif
ccflags-$(CONFIG_MACH_MT6885) += -DCMDQ_MDP_ENABLE_SPR
ccflags-$(CONFIG_MACH_MT6885) += -DMDP_MMPATH
ccflags-$(CONFIG_MACH_MT6893) += -DCMDQ_MDP_ENABLE_SPR
ccflags-$(CONFIG_MACH_MT6893) += -DMDP_MMPATH
ccflags-$(CONFIG_MACH_MT6873) += -DCMDQ_MDP_ENABLE_SPR
ccflags-$(CONFIG_MACH_MT6873) += -DMDP_MMPATH
ccflags-$(CONFIG_MACH_MT6853) += -DCMDQ_MDP_ENABLE_SPR
ccflags-$(CONFIG_MACH_MT6853) += -DMDP_MMPATH
ccflags-$(CONFIG_MACH_MT6833) += -DCMDQ_MDP_ENABLE_SPR
ccflags-$(CONFIG_MACH_MT6833) += -DMDP_MMPATH
ccflags-$(CONFIG_MACH_MT6877) += -DCMDQ_MDP_ENABLE_SPR
ccflags-$(CONFIG_MACH_MT6877) += -DMDP_MMPATH
ccflags-$(CONFIG_MACH_MT6781) += -DCMDQ_MDP_ENABLE_SPR
ccflags-$(CONFIG_MACH_MT6781) += -DMDP_MMPATH
ccflags-y += -I$(srctree)/drivers/misc/mediatek/smi/ \
-I$(srctree)/drivers/misc/mediatek/smi/$(MTK_PLATFORM)/ \
-I$(srctree)/drivers/misc/mediatek/mmdvfs/ \
-I$(srctree)/drivers/misc/mediatek/mmp/ \
-I$(srctree)/drivers/misc/mediatek/mach/$(MTK_PLATFORM)/include \
-I$(srctree)/drivers/iommu/ \
-I$(srctree)/drivers/misc/mediatek/trusted_mem/public
ccflags-$(CONFIG_MTK_CMDQ_MBOX_EXT) += -I$(srctree)/drivers/misc/mediatek/cmdq/mailbox/
ifneq (,$(filter $(CONFIG_MTK_PLATFORM), "mt6761" "mt6765" "mt6771" "mt6779" "mt6781" "mt6785" "mt6877" "mt6893" "mt6833" "mt6739" "mt6768" "mt6853" "mt6885" "mt6873"))
ccflags-y += -I$(srctree)/drivers/staging/android/mtk_ion \
-I$(srctree)/drivers/staging/android/mtk_ion/mtk
else
ccflags-y += -I$(srctree)/drivers/staging/android/ion \
-I$(srctree)/drivers/staging/android/ion/mtk
endif
ifeq ($(CONFIG_MTK_CMDQ_V3),y)
ifneq (,$(filter $(CONFIG_MTK_PLATFORM), "mt6739" "mt6768" "mt6771" "mt8168" "mt6785" "mt6761" "mt6765" "mt6779"))
ccflags-y += -I$(srctree)/drivers/misc/mediatek/cmdq/v3/ \
-I$(srctree)/drivers/misc/mediatek/cmdq/v3/$(MTK_PLATFORM)
endif
else ifneq (,$(filter $(CONFIG_MTK_PLATFORM), "mt8167" "mt6761" "mt6765" "mt6779"))
ccflags-y += -I$(srctree)/drivers/misc/mediatek/cmdq/v2/ \
-I$(srctree)/drivers/misc/mediatek/cmdq/v2/$(MTK_PLATFORM)
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
# mdp platform code
MDP_PLATFORM_DIR=$(srctree)/drivers/misc/mediatek/mdp/$(MTK_PLATFORM)
platformdir_exists=$(shell if [ -d ${MDP_PLATFORM_DIR} ]; then echo "y"; else echo "n"; fi;)
ifeq ($(platformdir_exists), y)
ccflags-y += -I$(MDP_PLATFORM_DIR)/
else
ccflags-y += -DMDP_COMMON_ENG_SUPPORT
endif
ifeq ($(CONFIG_MTK_ENG_BUILD),y)
ccflags-y += -DCMDQ_TEST_PROC
ccflags-y += -DCMDQ_PROFILE_LOCK
ccflags-y += -DCMDQ_DEBUG_LOOP_IRQ
ccflags-y += -DMDP_COMMAND_SIMULATE
endif
# secure path
# use CONFIG_MTK_CMDQ_MBOX_EXT support
# secure path
ifeq ($(or $(strip $(CONFIG_TRUSTONIC_TEE_SUPPORT)), $(strip $(CONFIG_MICROTRUST_TEE_SUPPORT)), \
$(strip $(CONFIG_MTK_ENABLE_GENIEZONE))),y)
ifeq ($(or $(strip $(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT)), $(strip $(CONFIG_MTK_CAM_SECURITY_SUPPORT))),y)
ccflags-y += -DCMDQ_SECURE_PATH_SUPPORT
endif # end of CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT or CONFIG_MTK_CAM_SECURITY_SUPPORT
endif # end of CONFIG_TRUSTONIC_TEE_SUPPORT or CONFIG_MICROTRUST_TEE_SUPPORT
ifeq ($(or $(strip $(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT)), $(strip $(CONFIG_MTK_CAM_SECURITY_SUPPORT))),y)
ifeq ($(strip $(CONFIG_MTK_ENABLE_GENIEZONE)),y)
ifeq ($(strip $(CONFIG_MTK_CAM_GENIEZONE_SUPPORT)),y)
ccflags-y += -DCMDQ_SECURE_MTEE_SUPPORT
endif
endif
endif
# platform dependent definition
ifneq ($(strip $(CONFIG_MTK_GMO_RAM_OPTIMIZE)),y)
ccflags-y += -DCMDQ_LARGE_MAX_FIRSTERROR_BUFFER
endif
# driver module
obj-$(CONFIG_MTK_CMDQ_MBOX_EXT) += cmdq_record.o
obj-$(CONFIG_MTK_CMDQ_MBOX_EXT) += cmdq_virtual.o
obj-$(CONFIG_MTK_CMDQ_MBOX_EXT) += cmdq_device.o
obj-$(CONFIG_MTK_CMDQ_MBOX_EXT) += mdp_driver.o
obj-$(CONFIG_MTK_CMDQ_MBOX_EXT) += mdp_common.o
#obj-y += cmdq_prof.o
#obj-y += cmdq_test.o
obj-$(CONFIG_MTK_CMDQ_MBOX_EXT) += mdp_event_common.o
obj-$(CONFIG_MTK_CMDQ_MBOX_EXT) += cmdq_subsys_common.o
obj-$(CONFIG_MTK_CMDQ_MBOX_EXT) += cmdq_helper_ext.o
obj-y += mdp_ioctl_ex.o
obj-y += mdp_m4u.o
ifeq ($(strip $(CONFIG_MMPROFILE)),y)
obj-$(CONFIG_MTK_CMDQ_MBOX_EXT) += cmdq_mmp.o
endif
ifeq ($(platformdir_exists), y)
obj-$(CONFIG_MTK_CMDQ_MBOX_EXT) += $(subst ",,$(MTK_PLATFORM))/
endif
# mdp_sw_sync
obj-$(CONFIG_MTK_CMDQ_MBOX_EXT) += sync/
+604
View File
@@ -0,0 +1,604 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "mdp_cmdq_device.h"
#include "cmdq_virtual.h"
#include "mdp_cmdq_helper_ext.h"
#ifdef CMDQ_CONFIG_SMI
#include "smi_public.h"
#endif
/* device tree */
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/of_address.h>
#include <linux/of_platform.h>
#include <linux/io.h>
#include <linux/dma-mapping.h>
#include <mt-plat/mtk_lpae.h>
#include <linux/vmalloc.h>
#include <linux/slab.h>
#include <linux/clk-provider.h>
struct CmdqDeviceStruct {
struct device *pDev;
struct clk *clk_gce;
struct clk *clk_gce_timer;
struct clk *clk_mmsys_mtcmos;
long regBaseVA; /* considering 64 bit kernel, use long */
phys_addr_t regBasePA;
u32 irqId;
u32 irqSecId;
s32 dma_mask_result;
#if IS_ENABLED(CONFIG_MACH_MT6885) || IS_ENABLED(CONFIG_MACH_MT6893)
struct device *pdev2;
unsigned long va2;
phys_addr_t pa2;
u32 irqId2;
#endif
};
static struct CmdqDeviceStruct gCmdqDev;
static u32 gThreadCount;
static u32 gMMSYSDummyRegOffset;
struct device *cmdq_dev_get(void)
{
return gCmdqDev.pDev;
}
u32 cmdq_dev_get_irq_id(void)
{
return gCmdqDev.irqId;
}
u32 cmdq_dev_get_irq_secure_id(void)
{
return gCmdqDev.irqSecId;
}
long cmdq_dev_get_module_base_VA_GCE(void)
{
return gCmdqDev.regBaseVA;
}
phys_addr_t cmdq_dev_get_module_base_PA_GCE(void)
{
return gCmdqDev.regBasePA;
}
#if IS_ENABLED(CONFIG_MACH_MT6885) || IS_ENABLED(CONFIG_MACH_MT6893)
unsigned long cmdq_dev_get_va2(void)
{
return gCmdqDev.va2;
}
phys_addr_t cmdq_dev_get_pa2(void)
{
return gCmdqDev.pa2;
}
#endif
s32 cmdq_dev_get_dma_mask_result(void)
{
return gCmdqDev.dma_mask_result;
}
u32 cmdq_dev_get_thread_count(void)
{
return gThreadCount;
}
u32 cmdq_dev_get_mmsys_dummy_reg_offset(void)
{
return gMMSYSDummyRegOffset;
}
void cmdq_dev_init_module_base_VA(void)
{
cmdq_mdp_get_func()->initModuleBaseVA();
}
void cmdq_dev_deinit_module_base_VA(void)
{
cmdq_mdp_get_func()->deinitModuleBaseVA();
}
unsigned long cmdq_dev_alloc_reference_VA_by_name(const char *ref_name)
{
unsigned long VA = 0L;
struct device_node *node = NULL;
node = of_parse_phandle(gCmdqDev.pDev->of_node, ref_name, 0);
if (node) {
VA = (unsigned long)of_iomap(node, 0);
of_node_put(node);
}
CMDQ_LOG("DEV: VA ref(%s):0x%lx\n", ref_name, VA);
return VA;
}
unsigned long cmdq_dev_alloc_reference_by_name(const char *ref_name,
uint32_t *pa)
{
unsigned long VA = 0L;
struct device_node *node = NULL;
struct resource res;
node = of_parse_phandle(gCmdqDev.pDev->of_node, ref_name, 0);
if (node) {
if (!of_address_to_resource(node, 0, &res))
*pa = (uint32_t)res.start;
VA = (unsigned long)of_iomap(node, 0);
of_node_put(node);
}
CMDQ_LOG("DEV: VA ref(%s):0x%lx pa:%#x\n", ref_name, VA, *pa);
return VA;
}
void cmdq_dev_free_module_base_VA(const long VA)
{
iounmap((void *)VA);
}
phys_addr_t cmdq_dev_get_gce_node_PA(struct device_node *node, int index)
{
struct resource res;
phys_addr_t regBasePA = 0L;
do {
if (of_address_to_resource(node, index, &res) < 0)
break;
regBasePA = (0L | res.start);
} while (0);
return regBasePA;
}
#define IMP_ENABLE_HW_CLOCK(FN_NAME, HW_NAME) \
u32 cmdq_dev_enable_clock_##FN_NAME(bool enable) \
{ \
return cmdq_dev_enable_device_clock(enable, \
gCmdqModuleClock.clk_##HW_NAME, #HW_NAME "-clk"); \
}
void cmdq_dev_get_module_clock_by_dev(struct device *dev,
const char *clkName, struct clk **clk_module)
{
*clk_module = devm_clk_get(dev, clkName);
if (IS_ERR(*clk_module)) {
/* error status print */
CMDQ_ERR("DEV: cannot get module clock:%s\n", clkName);
} else {
/* message print */
CMDQ_MSG("DEV: get module clock:%s\n", clkName);
}
}
void cmdq_dev_get_module_clock_by_name(const char *ref_name,
const char *clkName, struct clk **clk_module)
{
struct device_node *node = NULL;
node = of_parse_phandle(gCmdqDev.pDev->of_node, ref_name, 0);
*clk_module = of_clk_get_by_name(node, clkName);
if (IS_ERR(*clk_module)) {
/* error status print */
CMDQ_ERR("DEV: byName: cannot get module clock:%s\n", clkName);
} else {
/* message print */
CMDQ_MSG("DEV: byName: get module clock:%s\n", clkName);
}
}
u32 cmdq_dev_enable_device_clock(bool enable,
struct clk *clk_module, const char *clkName)
{
int result = 0;
if (IS_ERR(clk_module)) {
CMDQ_LOG("[WARN]clock module does not support:%s\n", clkName);
return PTR_ERR(clk_module);
}
if (enable) {
result = clk_prepare_enable(clk_module);
if (result)
CMDQ_ERR("enable clock with module:%s result:%d\n",
clkName, result);
else
CMDQ_MSG("enable clock with module:%s result:%d\n",
clkName, result);
} else {
clk_disable_unprepare(clk_module);
CMDQ_MSG("disable clock with module:%s\n", clkName);
}
return result;
}
bool cmdq_dev_device_clock_is_enable(struct clk *clk_module)
{
return true;
}
/* Common Clock Framework */
void cmdq_dev_init_module_clk(void)
{
cmdq_mdp_get_func()->initModuleCLK();
}
void cmdq_dev_enable_gce_clock(bool enable)
{
cmdq_dev_enable_device_clock(enable, gCmdqDev.clk_gce, "gce-clk");
if (!IS_ERR(gCmdqDev.clk_gce_timer))
cmdq_dev_enable_device_clock(enable, gCmdqDev.clk_gce_timer,
"gce-clk-timer");
}
bool cmdq_dev_gce_clock_is_enable(void)
{
return cmdq_dev_device_clock_is_enable(gCmdqDev.clk_gce);
}
bool cmdq_dev_mmsys_clock_is_enable(void)
{
if (IS_ERR(gCmdqDev.clk_mmsys_mtcmos)) {
CMDQ_ERR("MMSYS_MTCMOS clk not support\n");
return false;
}
return __clk_is_enabled(gCmdqDev.clk_mmsys_mtcmos);
}
phys_addr_t cmdq_dev_get_reference_PA(const char *ref_name, int index)
{
int status;
struct device_node *node = NULL;
struct resource res;
phys_addr_t start_pa = 0;
do {
node = of_parse_phandle(gCmdqDev.pDev->of_node, ref_name, 0);
if (!node)
break;
status = of_address_to_resource(node, index, &res);
if (status < 0)
break;
start_pa = res.start;
CMDQ_LOG("DEV: PA ref(%s): start:%pa\n",
ref_name, &start_pa);
} while (0);
if (node)
of_node_put(node);
return start_pa;
}
/* Get MDP base address to user space */
void cmdq_dev_init_MDP_PA(struct device_node *node)
{
u32 *pMDPBaseAddress = cmdq_core_get_dts_data()->MDPBaseAddress;
phys_addr_t module_pa_start = 0;
module_pa_start = cmdq_dev_get_reference_PA("mm_mutex", 0);
if (!module_pa_start)
CMDQ_ERR("DEV: init mm_mutex PA fail!!\n");
else
pMDPBaseAddress[CMDQ_MDP_PA_BASE_MM_MUTEX] = module_pa_start;
CMDQ_MSG("MM_MUTEX PA: start:0x%x\n",
pMDPBaseAddress[CMDQ_MDP_PA_BASE_MM_MUTEX]);
}
void cmdq_dev_get_subsys_by_name(struct device_node *node,
enum CMDQ_SUBSYS_ENUM subsys,
const char *grp_name, const char *dts_name)
{
int status;
u32 gceSubsys[3] = { 0, 0, 0 };
struct SubsysStruct *gceSubsysStruct = NULL;
do {
if (subsys < 0 || subsys >= (u32)CMDQ_SUBSYS_MAX_COUNT)
break;
gceSubsysStruct = cmdq_core_get_dts_data()->subsys;
status = of_property_read_u32_array(node, dts_name,
gceSubsys, ARRAY_SIZE(gceSubsys));
if (status < 0) {
gceSubsysStruct[subsys].subsysID = -1;
break;
}
gceSubsysStruct[subsys].msb = gceSubsys[0] & gceSubsys[2];
gceSubsysStruct[subsys].subsysID = gceSubsys[1];
gceSubsysStruct[subsys].mask = gceSubsys[2];
strncpy(gceSubsysStruct[subsys].grpName, grp_name,
CMDQ_SUBSYS_GRPNAME_MAX-1);
} while (0);
}
void cmdq_dev_test_subsys_correctness_impl(enum CMDQ_SUBSYS_ENUM subsys)
{
struct SubsysStruct *gceSubsysStruct = NULL;
if (subsys >= 0 && subsys < CMDQ_SUBSYS_MAX_COUNT) {
gceSubsysStruct = cmdq_core_get_dts_data()->subsys;
if (gceSubsysStruct[subsys].subsysID != -1) {
/* print subsys information from device tree */
CMDQ_LOG("(%s) msb:0x%08x, %d, 0x%08x\n",
gceSubsysStruct[subsys].grpName,
gceSubsysStruct[subsys].msb,
gceSubsysStruct[subsys].subsysID,
gceSubsysStruct[subsys].mask);
}
}
}
void cmdq_dev_init_subsys(struct device_node *node)
{
u32 i;
struct cmdq_subsys_dts_name *subsys = cmdq_subsys_get_dts();
for (i = 0; i < cmdq_subsys_get_size(); i++)
if (subsys[i].name)
cmdq_dev_get_subsys_by_name(node, i, subsys[i].group,
subsys[i].name);
}
void cmdq_dev_get_event_value_by_name(struct device_node *node,
enum cmdq_event event, const char *dts_name)
{
s32 status;
s32 event_value = -1;
do {
if (event < 0 || event >= (u32)CMDQ_MAX_HW_EVENT_COUNT)
break;
status = of_property_read_u32(node, dts_name, &event_value);
if (status < 0)
break;
cmdq_core_set_event_table(event, event_value);
} while (0);
}
void cmdq_dev_test_event_correctness_impl(enum cmdq_event event,
const char *dts_name, const char *event_name)
{
s32 eventValue = cmdq_core_get_event_value(event);
if (eventValue >= 0 && eventValue < (u32)CMDQ_SYNC_TOKEN_MAX) {
/* print event name from device tree */
if (event < (u32)CMDQ_MAX_HW_EVENT_COUNT)
CMDQ_LOG("%s = %d\n", dts_name, eventValue);
else
CMDQ_LOG("%s = %d\n", event_name, eventValue);
}
}
void cmdq_dev_init_event_table(struct device_node *node)
{
struct cmdq_event_table *events = cmdq_event_get_table();
u32 table_size = cmdq_event_get_table_size();
u32 i = 0;
for (i = 0; i < table_size; i++) {
if (events[i].event == (u32)CMDQ_MAX_HW_EVENT_COUNT)
break;
cmdq_dev_get_event_value_by_name(node, events[i].event,
events[i].dts_name);
}
#if IS_ENABLED(CONFIG_MACH_MT6885) || IS_ENABLED(CONFIG_MACH_MT6893)
cmdq_core_set_event_table(CMDQ_EVENT_DISP_RDMA0_SOF, 2);
cmdq_core_set_event_table(CMDQ_EVENT_DISP_WDMA0_EOF, 60);
cmdq_core_set_event_table(CMDQ_EVENT_DISP_RDMA0_EOF, 68);
#endif
}
void cmdq_dev_test_dts_correctness(void)
{
struct cmdq_event_table *events = cmdq_event_get_table();
struct cmdq_subsys_dts_name *subsys = cmdq_subsys_get_dts();
u32 i;
for (i = 0; i < cmdq_event_get_table_size(); i++)
cmdq_dev_test_event_correctness_impl(events[i].event,
events[i].dts_name, events[i].event_name);
for (i = 0; i < cmdq_subsys_get_size(); i++)
if (subsys[i].name)
cmdq_dev_test_subsys_correctness_impl(i);
}
void cmdq_dev_init_resource(CMDQ_DEV_INIT_RESOURCE_CB init_cb)
{
int status, index;
u32 count = 0;
status = of_property_read_u32(gCmdqDev.pDev->of_node,
"sram_share_cnt", &count);
if (status < 0)
return;
for (index = 0; index < count; index++) {
u32 engine, event;
status = of_property_read_u32_index(
gCmdqDev.pDev->of_node, "sram_share_engine",
index, &engine);
if (status < 0)
return;
status = of_property_read_u32_index(
gCmdqDev.pDev->of_node, "sram_share_event",
index, &event);
if (status < 0)
return;
if (init_cb != NULL)
init_cb(engine, event);
}
}
void cmdq_dev_init_device_tree(struct device_node *node)
{
int status;
u32 mmsys_dummy_reg_offset_value = 0;
u32 thread_count = 16;
gThreadCount = 16;
gMMSYSDummyRegOffset = 0;
cmdq_core_init_dts_data();
status = of_property_read_u32(node, "thread_count", &thread_count);
if (status >= 0)
gThreadCount = thread_count;
/* init GCE subsys */
cmdq_dev_init_subsys(node);
/* init event table */
cmdq_dev_init_event_table(node);
/* init MDP PA address */
cmdq_dev_init_MDP_PA(node);
/* read dummy register offset from device tree,
* usually DUMMY_3 because DUMMY_0/1 is CLKMGR SW.
*/
status = of_property_read_u32(node, "mmsys_dummy_reg_offset",
&mmsys_dummy_reg_offset_value);
if (status < 0)
mmsys_dummy_reg_offset_value = 0x89C;
gMMSYSDummyRegOffset = mmsys_dummy_reg_offset_value;
}
void cmdq_dev_init(struct platform_device *pDevice)
{
struct device_node *node = pDevice->dev.of_node;
u32 dma_mask_bit = 0;
s32 ret;
#if IS_ENABLED(CONFIG_MACH_MT6885) || IS_ENABLED(CONFIG_MACH_MT6893)
struct device_node *node2;
struct platform_device *pdevice2;
struct resource res;
#endif
/* init cmdq device dependent data */
do {
memset(&gCmdqDev, 0x0, sizeof(struct CmdqDeviceStruct));
gCmdqDev.pDev = &pDevice->dev;
#if !IS_ENABLED(CONFIG_MACH_MT6885) && !IS_ENABLED(CONFIG_MACH_MT6893)
gCmdqDev.regBaseVA = (unsigned long)of_iomap(node, 0);
gCmdqDev.regBasePA = cmdq_dev_get_gce_node_PA(node, 0);
gCmdqDev.irqId = irq_of_parse_and_map(node, 0);
gCmdqDev.irqSecId = irq_of_parse_and_map(node, 1);
gCmdqDev.clk_gce = devm_clk_get(&pDevice->dev, "GCE");
gCmdqDev.clk_gce_timer = devm_clk_get(&pDevice->dev,
"GCE_TIMER");
gCmdqDev.clk_mmsys_mtcmos = devm_clk_get(&pDevice->dev,
"MMSYS_MTCMOS");
CMDQ_LOG(
"[CMDQ] platform_dev: dev:%p PA:%pa VA:%lx irqId:%d irqSecId:%d\n",
gCmdqDev.pDev, &gCmdqDev.regBasePA,
gCmdqDev.regBaseVA, gCmdqDev.irqId,
gCmdqDev.irqSecId);
#else
node2 = of_parse_phandle(node, "mediatek,mailbox-gce-m", 0);
if (!node2)
break;
pdevice2 = of_find_device_by_node(node2);
of_node_put(node2);
if (!pdevice2)
break;
gCmdqDev.regBaseVA = (unsigned long)of_iomap(
pdevice2->dev.of_node, 0);
gCmdqDev.regBasePA = cmdq_dev_get_gce_node_PA(
pdevice2->dev.of_node, 0);
gCmdqDev.irqId = irq_of_parse_and_map(pdevice2->dev.of_node, 0);
gCmdqDev.irqSecId = irq_of_parse_and_map(
pdevice2->dev.of_node, 1);
gCmdqDev.irqId2 = irq_of_parse_and_map(
pdevice2->dev.of_node, 2);
gCmdqDev.clk_gce = devm_clk_get(gCmdqDev.pDev, "GCE");
gCmdqDev.clk_gce_timer = devm_clk_get(gCmdqDev.pDev,
"GCE_TIMER");
gCmdqDev.clk_mmsys_mtcmos = devm_clk_get(gCmdqDev.pDev,
"MMSYS_MTCMOS");
CMDQ_LOG(
"[CMDQ] platform_dev: dev:%p PA:%pa VA:%lx irqId:%d irqSecId:%d\n",
gCmdqDev.pDev, &gCmdqDev.regBasePA,
gCmdqDev.regBaseVA, gCmdqDev.irqId,
gCmdqDev.irqSecId);
node2 = of_parse_phandle(node, "mediatek,mailbox-gce", 0);
if (!node2)
break;
pdevice2 = of_find_device_by_node(node2);
of_node_put(node2);
if (!pdevice2)
break;
gCmdqDev.pdev2 = &pdevice2->dev;
gCmdqDev.va2 = (unsigned long)of_iomap(
pdevice2->dev.of_node, 0);
if (!gCmdqDev.va2)
break;
if (of_address_to_resource(pdevice2->dev.of_node, 0,
&res))
break;
gCmdqDev.pa2 = res.start;
CMDQ_LOG(
"[CMDQ] 2nd dev:%p PA:%pa VA:%lx irqId:%d\n",
gCmdqDev.pdev2, &gCmdqDev.pa2,
gCmdqDev.va2, gCmdqDev.irqId2);
#endif
} while (0);
ret = of_property_read_u32(gCmdqDev.pDev->of_node, "dma_mask_bit",
&dma_mask_bit);
/* if not assign from dts, give default 32bit for legacy chip */
if (ret != 0 || !dma_mask_bit)
dma_mask_bit = 32;
gCmdqDev.dma_mask_result = dma_set_coherent_mask(
&pDevice->dev, DMA_BIT_MASK(dma_mask_bit));
CMDQ_LOG("set dma mask bit:%u result:%d\n",
dma_mask_bit, gCmdqDev.dma_mask_result);
/* map MMSYS VA */
cmdq_mdp_map_mmsys_VA();
/* init module VA */
cmdq_dev_init_module_base_VA();
/* init module clock */
cmdq_dev_init_module_clk();
/* init module PA for instruction count */
cmdq_get_func()->initModulePAStat();
/* init load HW information from device tree */
cmdq_dev_init_device_tree(node);
}
void cmdq_dev_deinit(void)
{
/* unmap MMSYS VA */
cmdq_mdp_unmap_mmsys_VA();
cmdq_dev_deinit_module_base_VA();
/* deinit cmdq device dependent data */
do {
cmdq_dev_free_module_base_VA(
cmdq_dev_get_module_base_VA_GCE());
gCmdqDev.regBaseVA = 0;
} while (0);
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,19 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
/* id HW_OP MASK_EN cycle name */
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_WRI, CMDQ_CODE_WRITE, 4, WRI)
/* 32 for read, 4 for write */
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_WRI_WITH_MASK, CMDQ_CODE_WRITE, 36,
WRI_W_MASK)
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_POLL, CMDQ_CODE_POLL, 32, POLL)
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_MOVE, CMDQ_CODE_MOVE, 1, MOVE)
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_READ, CMDQ_CODE_READ, 32, READ)
/* need wait event */
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_WFE, CMDQ_CODE_WFE, 3, WAIT)
/* no need wait event and update event */
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_SYNC, CMDQ_CODE_WFE, 3, SYNC)
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_JUMP, CMDQ_CODE_JUMP, 1, JUMP)
DECLARE_CMDQ_INSTR_CYCLE(CMDQ_STA_EOC, CMDQ_CODE_EOC, 1, MARKER)
+59
View File
@@ -0,0 +1,59 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "cmdq_mmp.h"
static struct MDP_MMP_events_t mdp_mmp_events;
struct MDP_MMP_events_t *mdp_mmp_get_event(void)
{
return &mdp_mmp_events;
}
void mdp_mmp_init(void)
{
#if IS_ENABLED(CONFIG_MMPROFILE)
mmprofile_enable(1);
if (mdp_mmp_events.CMDQ == 0) {
mdp_mmp_events.CMDQ = mmprofile_register_event(
MMP_ROOT_EVENT, "MDP");
mdp_mmp_events.thread_en = mmprofile_register_event(
mdp_mmp_events.CMDQ, "thread_en");
mdp_mmp_events.CMDQ_IRQ = mmprofile_register_event(
mdp_mmp_events.CMDQ, "CMDQ_IRQ");
mdp_mmp_events.warning = mmprofile_register_event(
mdp_mmp_events.CMDQ, "warning");
mdp_mmp_events.autoRelease_add = mmprofile_register_event(
mdp_mmp_events.CMDQ, "autoRelease_add");
mdp_mmp_events.autoRelease_done = mmprofile_register_event(
mdp_mmp_events.CMDQ, "autoRelease_done");
mdp_mmp_events.consume_add = mmprofile_register_event(
mdp_mmp_events.CMDQ, "consume_add");
mdp_mmp_events.consume_done = mmprofile_register_event(
mdp_mmp_events.CMDQ, "consume_done");
mdp_mmp_events.alloc_task = mmprofile_register_event(
mdp_mmp_events.CMDQ, "alloc_task");
mdp_mmp_events.wait_task = mmprofile_register_event(
mdp_mmp_events.CMDQ, "wait_task");
mdp_mmp_events.wait_task_done = mmprofile_register_event(
mdp_mmp_events.CMDQ, "wait_task_done");
mdp_mmp_events.MDP_reset = mmprofile_register_event(
mdp_mmp_events.CMDQ, "MDP_reset");
mdp_mmp_events.MDP_clock_on = mmprofile_register_event(
mdp_mmp_events.CMDQ, "MDP_clock_on");
mdp_mmp_events.MDP_clock_off = mmprofile_register_event(
mdp_mmp_events.CMDQ, "MDP_clock_off");
mdp_mmp_events.MDP_clock_smi = mmprofile_register_event(
mdp_mmp_events.CMDQ, "MDP_clock_smi");
mdp_mmp_events.timeout = mmprofile_register_event(
mdp_mmp_events.CMDQ, "timeout");
mdp_mmp_events.read_reg = mmprofile_register_event(
mdp_mmp_events.CMDQ, "read_reg");
mmprofile_enable_event_recursive(mdp_mmp_events.CMDQ, 1);
}
mmprofile_start(1);
#endif
}
+44
View File
@@ -0,0 +1,44 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CMDQ_MMP_H__
#define __CMDQ_MMP_H__
#include "mdp_cmdq_helper_ext.h"
#if IS_ENABLED(CONFIG_MMPROFILE)
#include "mmprofile.h"
#endif
struct MDP_MMP_events_t {
mmp_event CMDQ;
mmp_event CMDQ_IRQ;
mmp_event thread_en;
mmp_event warning;
mmp_event loopBeat;
mmp_event autoRelease_add;
mmp_event autoRelease_done;
mmp_event consume_add;
mmp_event consume_done;
mmp_event alloc_task;
mmp_event wait_task;
mmp_event wait_task_done;
mmp_event task_exec;
mmp_event wait_thread;
mmp_event wait_task_clean;
mmp_event MDP_reset;
mmp_event MDP_clock_on;
mmp_event MDP_clock_off;
mmp_event MDP_clock_smi;
mmp_event thread_suspend;
mmp_event thread_resume;
mmp_event alloc_buffer;
mmp_event timeout;
mmp_event read_reg;
};
void mdp_mmp_init(void);
struct MDP_MMP_events_t *mdp_mmp_get_event(void);
#endif /* __CMDQ_MMP_H__ */
+166
View File
@@ -0,0 +1,166 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "cmdq_prof.h"
#include "mdp_cmdq_helper_ext.h"
/* expect no EMI latency, GCE spends 80 ns per 4 cycle*/
#define CMDQ_HW_EXEC_NS(hw_cycle) (hw_cycle * (80 / 4))
enum CMDQ_OP_STATISTIC_ENUM {
CMDQ_STA_READ = 0,
CMDQ_STA_MOVE,
CMDQ_STA_WRI,
CMDQ_STA_WRI_WITH_MASK,
CMDQ_STA_POLL,
CMDQ_STA_JUMP,
CMDQ_STA_WFE, /* wait for event */
CMDQ_STA_SYNC, /* sync op and no wait for event */
CMDQ_STA_EOC,
CMDQ_STA_MAX_COUNT, /* always keep at the end */
};
const char *cmdq_prof_get_statistic_id_name(
const enum CMDQ_OP_STATISTIC_ENUM statisticId)
{
const char *IDName = "UNKNOWN";
#undef DECLARE_CMDQ_INSTR_CYCLE
#define DECLARE_CMDQ_INSTR_CYCLE(id, hw_op, cycle, name) { \
if (id == statisticId) { \
IDName = #name; \
break; \
} }
do {
#include "cmdq_instr_cycle.h"
} while (0);
#undef DECLARE_CMDQ_INSTR_CYCLE
return IDName;
}
u32 cmdq_prof_get_statistic_id(const u32 *pCmd)
{
const u32 arg_b = pCmd[0];
const u32 arg_a = pCmd[1];
const u32 op = arg_a >> 24;
u32 addr;
u32 maskEn = 0;
switch (op) {
case CMDQ_CODE_WRITE_S:
return CMDQ_STA_WRI;
case CMDQ_CODE_WRITE_S_W_MASK:
return CMDQ_STA_WRI_WITH_MASK;
case CMDQ_CODE_WRITE:
/* check address */
if (arg_a & (1 << 23)) {
/* address is GPR */
return CMDQ_STA_WRI;
}
addr = cmdq_core_subsys_to_reg_addr(arg_a);
maskEn = (addr & 0x1);
if (maskEn)
return CMDQ_STA_WRI_WITH_MASK;
else
return CMDQ_STA_WRI;
case CMDQ_CODE_WFE:
/* check waiting flag */
if ((arg_b >> 15) & 0x1)
return CMDQ_STA_WFE;
else
return CMDQ_STA_SYNC;
case CMDQ_CODE_READ:
case CMDQ_CODE_READ_S:
return CMDQ_STA_READ;
case CMDQ_CODE_MOVE:
return CMDQ_STA_MOVE;
case CMDQ_CODE_POLL:
return CMDQ_STA_POLL;
case CMDQ_CODE_JUMP:
return CMDQ_STA_JUMP;
case CMDQ_CODE_EOC:
case CMDQ_CODE_LOGIC:
case CMDQ_CODE_JUMP_C_RELATIVE:
return CMDQ_STA_EOC;
default:
CMDQ_ERR("unknown op, arg_a: 0x%08x\n", arg_a);
return 0;
}
CMDQ_ERR("unknown op, arg_a: 0x%08x\n", arg_a);
return 0;
}
u32 cmdq_prof_calculate_HW_cycle(
const enum CMDQ_OP_STATISTIC_ENUM statisticId, const u32 count)
{
u32 hwCycle = -1;
#undef DECLARE_CMDQ_INSTR_CYCLE
#define DECLARE_CMDQ_INSTR_CYCLE(id, hw_op, cycle, name) { \
if (id == statisticId) { \
hwCycle = (count * cycle); \
break; } }
do {
#include "cmdq_instr_cycle.h"
} while (0);
#undef DECLARE_CMDQ_INSTR_CYCLE
if (-1 == hwCycle) {
/* Error message dump */
CMDQ_ERR("unknown statisticId: %d\n", statisticId);
}
return hwCycle;
}
s32 cmdq_prof_estimate_command_exe_time(const u32 *pCmd,
u32 commandSize)
{
u32 statistic[CMDQ_STA_MAX_COUNT] = { 0 };
int i;
u32 statisticId = 0;
u32 cycle = 0;
u32 totalCycle = 0;
u32 totalNS = 0;
if (pCmd == NULL)
return -EFAULT;
/* gather statistic */
for (i = 0; i < commandSize; i += CMDQ_INST_SIZE, pCmd += 2) {
statisticId = cmdq_prof_get_statistic_id(pCmd);
statistic[statisticId] += 1;
}
CMDQ_LOG("NAME, COUNT, least HW exec cycle\n");
/* calculate execution time */
for (i = 0; i < CMDQ_STA_MAX_COUNT; i++) {
cycle = cmdq_prof_calculate_HW_cycle(i, statistic[i]);
totalCycle += cycle;
CMDQ_LOG("%d:%11s, %d, %3d\n",
i, cmdq_prof_get_statistic_id_name(i), statistic[i],
cycle);
}
totalNS = CMDQ_HW_EXEC_NS(totalCycle);
CMDQ_LOG("=====================================\n");
CMDQ_LOG("estimated least HW exec time(ns): %6d\n", totalNS);
CMDQ_LOG("***each HW cycle spends time(ns): %6d\n",
CMDQ_HW_EXEC_NS(1));
CMDQ_LOG(
"***Real exec time will be longer when POLL/WAIT instr cannot pass their condition immediately.\n");
return totalNS;
}
+14
View File
@@ -0,0 +1,14 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CMDQ_PROF_H__
#define __CMDQ_PROF_H__
#include <linux/types.h>
s32 cmdq_prof_estimate_command_exe_time(
const u32 *pCmd, u32 commandSize);
#endif /* __CMDQ_PROF_H__ */
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,37 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CMDQ_RECORD_PRIVATE_H__
#define __CMDQ_RECORD_PRIVATE_H__
#include "mdp_cmdq_record.h"
#ifdef __cplusplus
extern "C" {
#endif
s32 cmdq_append_command(struct cmdqRecStruct *handle,
enum cmdq_code code,
u32 arg_a, u32 arg_b, u32 arg_a_type, u32 arg_b_type);
s32 cmdq_op_finalize_command(struct cmdqRecStruct *handle, bool loop);
s32 cmdq_setup_sec_data_of_command_desc_by_rec_handle(
struct cmdqCommandStruct *pDesc, struct cmdqRecStruct *handle);
s32 cmdq_setup_replace_of_command_desc_by_rec_handle(
struct cmdqCommandStruct *pDesc, struct cmdqRecStruct *handle);
s32 cmdq_rec_setup_profile_marker_data(
struct cmdqCommandStruct *pDesc, struct cmdqRecStruct *handle);
s32 cmdq_task_create_delay_thread_dram(void **pp_delay_thread_buffer,
u32 *buffer_size);
s32 cmdq_task_create_delay_thread_sram(void **pp_delay_thread_buffer,
u32 *buffer_size, u32 *cpr_offset);
#ifdef __cplusplus
}
#endif
#endif /* __CMDQ_RECORD_PRIVATE_H__ */
+127
View File
@@ -0,0 +1,127 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CMDQ_REG_H__
#define __CMDQ_REG_H__
#include <mt-plat/sync_write.h>
#include <linux/io.h>
#include "mdp_cmdq_helper_ext.h"
#include "mdp_cmdq_device.h"
#define GCE_BASE_PA cmdq_dev_get_module_base_PA_GCE()
#define GCE_BASE_VA cmdq_dev_get_module_base_VA_GCE()
#define CMDQ_CORE_WARM_RESET (GCE_BASE_VA + 0x000)
#define CMDQ_CURR_IRQ_STATUS (GCE_BASE_VA + 0x010)
#define CMDQ_SECURE_IRQ_STATUS (GCE_BASE_VA + 0x014)
#define CMDQ_CURR_LOADED_THR (GCE_BASE_VA + 0x018)
#define CMDQ_THR_SLOT_CYCLES (GCE_BASE_VA + 0x030)
#define CMDQ_THR_EXEC_CYCLES (GCE_BASE_VA + 0x034)
#define CMDQ_THR_TIMEOUT_TIMER (GCE_BASE_VA + 0x038)
#define CMDQ_BUS_CONTROL_TYPE (GCE_BASE_VA + 0x040)
#define CMDQ_H_SPEED_BUSY (GCE_BASE_VA + 0x048)
#define CMDQ_CURR_INST_ABORT (GCE_BASE_VA + 0x020)
#define CMDQ_SECURITY_ABORT (GCE_BASE_VA + 0x050)
#define CMDQ_SECURITY_CTL (GCE_BASE_VA + 0x054)
#define CMDQ_SECURITY_STA(id) (GCE_BASE_VA + (0x030 * id) + 0x024)
#define CMDQ_SECURITY_SET(id) (GCE_BASE_VA + (0x030 * id) + 0x028)
#define CMDQ_SECURITY_CLR(id) (GCE_BASE_VA + (0x030 * id) + 0x02C)
#define CMDQ_SYNC_TOKEN_ID (GCE_BASE_VA + 0x060)
#define CMDQ_SYNC_TOKEN_VAL (GCE_BASE_VA + 0x064)
#define CMDQ_SYNC_TOKEN_UPD (GCE_BASE_VA + 0x068)
#define CMDQ_PREFETCH_GSIZE (GCE_BASE_VA + 0x0C0)
#define CMDQ_TPR_MASK (GCE_BASE_VA + 0x0D0)
#define CMDQ_TPR_GPR_TIMER (GCE_BASE_VA + 0x0DC)
#define CMDQ_CTL_INT0 (GCE_BASE_VA + 0x0F0)
#define CMDQ_CTL_INT1 (GCE_BASE_VA + 0x0F4)
#define CMDQ_CACHE_0_EN_LO (GCE_BASE_VA + 0x10D0)
#define CMDQ_CACHE_0_EN_HI (GCE_BASE_VA + 0x10D4)
#define CMDQ_CACHE_1_EN_LO (GCE_BASE_VA + 0x10D8)
#define CMDQ_CACHE_1_EN_HI (GCE_BASE_VA + 0x10DC)
#define CMDQ_TOKEN_0_EN_LO (GCE_BASE_VA + 0x10E0)
#define CMDQ_TOKEN_0_EN_HI (GCE_BASE_VA + 0x10E4)
#define CMDQ_TOKEN_1_EN_LO (GCE_BASE_VA + 0x10E8)
#define CMDQ_TOKEN_1_EN_HI (GCE_BASE_VA + 0x10EC)
#define GCE_DBG_CTL (GCE_BASE_VA + 0x3000)
#define GCE_DBG0 (GCE_BASE_VA + 0x3004)
#define GCE_DBG1 (GCE_BASE_VA + 0x3008)
#define GCE_DBG2 (GCE_BASE_VA + 0x300C)
#define GCE_DBG3 (GCE_BASE_VA + 0x3010)
#define CMDQ_GPR_R32(id) (GCE_BASE_VA + (0x004 * id) + 0x80)
#define CMDQ_GPR_R32_PA(id) (GCE_BASE_PA + (0x004 * id) + 0x80)
#define CMDQ_THR_WARM_RESET(id) (GCE_BASE_VA + (0x080 * id) + 0x100)
#define CMDQ_THR_ENABLE_TASK(id) (GCE_BASE_VA + (0x080 * id) + 0x104)
#define CMDQ_THR_SUSPEND_TASK(id) (GCE_BASE_VA + (0x080 * id) + 0x108)
#define CMDQ_THR_CURR_STATUS(id) (GCE_BASE_VA + (0x080 * id) + 0x10C)
#define CMDQ_THR_IRQ_STATUS(id) (GCE_BASE_VA + (0x080 * id) + 0x110)
#define CMDQ_THR_IRQ_ENABLE(id) (GCE_BASE_VA + (0x080 * id) + 0x114)
#define CMDQ_THR_SECURITY(id) (GCE_BASE_VA + (0x080 * id) + 0x118)
#define CMDQ_THR_CURR_ADDR(id) (GCE_BASE_VA + (0x080 * id) + 0x120)
#define CMDQ_THR_END_ADDR(id) (GCE_BASE_VA + (0x080 * id) + 0x124)
#define CMDQ_THR_EXEC_CNT(id) (GCE_BASE_VA + (0x080 * id) + 0x128)
#define CMDQ_THR_WAIT_TOKEN(id) (GCE_BASE_VA + (0x080 * id) + 0x130)
#define CMDQ_THR_CFG(id) (GCE_BASE_VA + (0x080 * id) + 0x140)
#define CMDQ_THR_PREFETCH(id) (GCE_BASE_VA + (0x080 * id) + 0x144)
#define CMDQ_THR_INST_CYCLES(id) (GCE_BASE_VA + (0x080 * id) + 0x150)
#define CMDQ_THR_INST_THRESX(id) (GCE_BASE_VA + (0x080 * id) + 0x154)
#define CMDQ_THR_SPR0(id) (GCE_BASE_VA + (0x080 * id) + 0x160)
#define CMDQ_THR_SPR1(id) (GCE_BASE_VA + (0x080 * id) + 0x164)
#define CMDQ_THR_SPR2(id) (GCE_BASE_VA + (0x080 * id) + 0x168)
#define CMDQ_THR_SPR3(id) (GCE_BASE_VA + (0x080 * id) + 0x16c)
#define CMDQ_THR_SECURITY_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x118)
#define CMDQ_THR_CURR_ADDR_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x120)
#define CMDQ_THR_END_ADDR_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x124)
#define CMDQ_THR_EXEC_CNT_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x128)
#define CMDQ_THR_SPR0_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x160)
#define CMDQ_THR_SPR1_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x164)
#define CMDQ_THR_SPR2_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x168)
#define CMDQ_THR_SPR3_PA(id) (GCE_BASE_PA + (0x080 * id) + 0x16c)
#define CMDQ_SECURITY_CTL_PA (GCE_BASE_PA + 0x054)
#define CMDQ_SYNC_TOKEN_ID_PA (GCE_BASE_PA + 0x060)
#define CMDQ_SYNC_TOKEN_VAL_PA (GCE_BASE_PA + 0x064)
#define CMDQ_PREFETCH_GSIZE_PA (GCE_BASE_PA + 0x0C0)
#define CMDQ_TPR_MASK_PA (GCE_BASE_PA + 0x0D0)
#define CMDQ_GCE_END_ADDR_PA (GCE_BASE_PA + 0xC00)
#define CMDQ_THR_FIX_END_ADDR(id) (CMDQ_GCE_END_ADDR_PA | (id << 4))
#define CMDQ_CACHE_0_EN_LO_PA (GCE_BASE_PA + 0x10D0)
#define CMDQ_CACHE_0_EN_HI_PA (GCE_BASE_PA + 0x10D4)
#define CMDQ_CACHE_1_EN_LO_PA (GCE_BASE_PA + 0x10D8)
#define CMDQ_CACHE_1_EN_HI_PA (GCE_BASE_PA + 0x10DC)
#define CMDQ_TOKEN_0_EN_LO_PA (GCE_BASE_PA + 0x10E0)
#define CMDQ_TOKEN_0_EN_HI_PA (GCE_BASE_PA + 0x10E4)
#define CMDQ_TOKEN_1_EN_LO_PA (GCE_BASE_PA + 0x10E8)
#define CMDQ_TOKEN_1_EN_HI_PA (GCE_BASE_PA + 0x10EC)
#define CMDQ_IS_END_ADDR(addr) (addr == 0)
#define CMDQ_IS_END_INSTR(p_cmd_end) \
(p_cmd_end[0] == 0 && p_cmd_end[-1] == 0)
#define CMDQ_IS_SRAM_ADDR(addr) (((addr) & 0xFFFF) == (addr))
#define CMDQ_REG_GET32(addr) (readl((void *)addr) & 0xFFFFFFFF)
#define CMDQ_REG_GET16(addr) (readl((void *)addr) & 0x0000FFFF)
#define CMDQ_REG_GET64_GPR_PX(id) cmdq_core_get_gpr64(id)
#define CMDQ_REG_SET64_GPR_PX(id, value) cmdq_core_set_gpr64(id, value)
#define CMDQ_GET_GPR_PX2RX_LOW(id) ((id & 0xf) * 2)
#define CMDQ_GET_GPR_PX2RX_HIGH(id) ((id & 0xf) * 2 + 1)
#define CMDQ_REG_SET32(addr, val) mt_reg_sync_writel(val, (addr))
#endif /* __CMDQ_REG_H__ */
+159
View File
@@ -0,0 +1,159 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CMDQ_SEC_H__
#define __CMDQ_SEC_H__
#include "mdp_cmdq_helper_ext.h"
#if defined(CMDQ_SECURE_PATH_SUPPORT)
#include "tee_client_api.h"
#include "cmdq_sec_iwc_common.h"
#if defined(CMDQ_GP_SUPPORT)
#include "cmdq_sec_gp.h"
#else
#include "cmdq_sec_trustonic.h"
#endif
#endif /* CMDQ_SECURE_PATH_SUPPORT */
/*
* error code for CMDQ
*/
#define CMDQ_ERR_NULL_SEC_CTX_HANDLE (6000)
#define CMDQ_ERR_SEC_CTX_SETUP (6001)
#define CMDQ_ERR_SEC_CTX_TEARDOWN (6002)
/*
* inter-world communication state
*/
enum CMDQ_IWC_STATE_ENUM {
IWC_INIT = 0,
IWC_CONTEXT_INITED = 1,
IWC_WSM_ALLOCATED = 2,
IWC_SES_OPENED = 3,
IWC_SES_MSG_PACKAGED = 4,
IWC_SES_TRANSACTED = 5,
IWC_SES_ON_TRANSACTED = 6,
IWC_END_OF_ENUM = 7,
};
/* CMDQ secure context struct
* note it is not global data, each process has its own CMDQ sec context
*/
struct cmdqSecContextStruct {
struct list_head listEntry;
/* basic info */
uint32_t tgid; /* tgid of process context */
uint32_t referCount; /* reference count for open cmdq device node */
/* iwc state */
enum CMDQ_IWC_STATE_ENUM state;
/* iwc information */
void *iwcMessage; /* message buffer */
void *iwcMessageEx; /* message buffer extra */
#if defined(CMDQ_SECURE_PATH_SUPPORT)
struct cmdq_sec_tee_context tee; /* trustzone parameters */
#endif
};
extern const u32 isp_iwc_buf_size[];
int32_t cmdq_sec_init_allocate_resource_thread(void *data);
s32 cmdq_sec_task_copy_to_buffer(struct cmdqRecStruct *task,
struct cmdqCommandStruct *desc);
const struct cmdq_controller *cmdq_sec_get_controller(void);
/*
* Create and destroy non-cachable shared memory,
* used to share data for CMDQ driver between NWd and SWd
*
* Be careful that we should not disvlose any information about secure buffer
* address of
*/
int32_t cmdq_sec_create_shared_memory(
struct cmdqSecSharedMemoryStruct **pHandle, const uint32_t size);
int32_t cmdq_sec_destroy_shared_memory(
struct cmdqSecSharedMemoryStruct *handle);
/*
* Callback to fill message buffer for secure task
*
* Params:
* init32_t command id
* void* pornter of TaskStruct
* int32_t CMDQ HW thread id
* void* the inter-world communication buffer
* Return:
* >=0 for success;
*/
typedef int32_t(*CmdqSecFillIwcCB) (int32_t, void *, int32_t, void *, void *);
/*
* Entry secure world to handle secure path jobs
* .submit task
* .cancel error task
*/
int32_t cmdq_sec_exec_task_async_unlocked(
struct cmdqRecStruct *pTask, int32_t thread);
int32_t cmdq_sec_cancel_error_task_unlocked(
struct cmdqRecStruct *pTask, int32_t thread,
struct cmdqSecCancelTaskResultStruct *pResult);
int32_t cmdq_sec_allocate_path_resource_unlocked(bool throwAEE);
s32 cmdq_sec_get_secure_thread_exec_counter(const s32 thread);
s32 cmdq_sec_revise_jump(struct cmdqRecStruct *handle);
s32 cmdq_sec_handle_error_result(struct cmdqRecStruct *task, s32 thread,
const s32 waitQ, bool throw_aee);
/* function declaretion */
struct cmdqSecContextStruct *cmdq_sec_context_handle_create(uint32_t tgid);
s32 cmdq_sec_insert_backup_cookie_instr(struct cmdqRecStruct *task, s32 thread);
void cmdq_sec_dump_secure_thread_cookie(s32 thread);
s32 cmdq_mbox_sec_chan_id(void *chan);
/*
* secure path control
*/
void cmdq_sec_lock_secure_path(void);
void cmdq_sec_unlock_secure_path(void);
void cmdqSecInitialize(void);
void cmdqSecDeInitialize(void);
void cmdqSecEnableProfile(const bool enable);
#if defined(CMDQ_SECURE_PATH_SUPPORT)
/*
* tee vendor interface
*/
void cmdq_sec_setup_tee_context(struct cmdq_sec_tee_context *tee);
s32 cmdq_sec_init_context(struct cmdq_sec_tee_context *tee);
s32 cmdq_sec_deinit_context(struct cmdq_sec_tee_context *tee);
s32 cmdq_sec_allocate_wsm(struct cmdq_sec_tee_context *tee, void **wsm_buffer,
u32 size, void **wsm_buf_ex, u8 idx, u32 size_ex);
s32 cmdq_sec_free_wsm(struct cmdq_sec_tee_context *tee, void **wsm_buffer,
u8 idx);
s32 cmdq_sec_open_session(struct cmdq_sec_tee_context *tee, void *wsm_buffer);
s32 cmdq_sec_close_session(struct cmdq_sec_tee_context *tee);
s32 cmdq_sec_execute_session(struct cmdq_sec_tee_context *tee,
u32 cmd, s32 timeout_ms, bool share_mem_ex);
#endif /* CMDQ_SECURE_PATH_SUPPORT */
#endif /* __DDP_CMDQ_SEC_H__ */
+19
View File
@@ -0,0 +1,19 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CMDQ_STRUCT_H__
#define __CMDQ_STRUCT_H__
#include <linux/list.h>
#include <linux/spinlock.h>
struct cmdqFileNodeStruct {
pid_t userPID;
pid_t userTGID;
struct list_head taskList;
spinlock_t nodeLock;
};
#endif /* __CMDQ_STRUCT_H__ */
@@ -0,0 +1,79 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "cmdq_subsys_common.h"
#include "mdp_cmdq_helper_ext.h"
static struct cmdq_subsys_dts_name subsys[] = {
[CMDQ_SUBSYS_G3D_CONFIG_BASE] = {
.group = "MFG", .name = "g3d_config_base"},
[CMDQ_SUBSYS_MMSYS_CONFIG] = {
.group = "MMSYS", .name = "mmsys_config_base"},
[CMDQ_SUBSYS_DISP_DITHER] = {
.group = "MMSYS", .name = "disp_dither_base"},
[CMDQ_SUBSYS_NA] = {.group = "MMSYS", .name = "mm_na_base"},
[CMDQ_SUBSYS_IMGSYS] = {.group = "CAM", .name = "imgsys_base"},
[CMDQ_SUBSYS_VDEC_GCON] = {.group = "VDEC", .name = "vdec_gcon_base"},
[CMDQ_SUBSYS_VENC_GCON] = {.group = "VENC", .name = "venc_gcon_base"},
[CMDQ_SUBSYS_CONN_PERIPHERALS] = {
.group = "PERISYS", .name = "conn_peri_base"},
[CMDQ_SUBSYS_TOPCKGEN] = {
.group = "TOP_AO_3", .name = "topckgen_base"},
[CMDQ_SUBSYS_KP] = {.group = "INFRA_AO", .name = "kp_base"},
[CMDQ_SUBSYS_SCP_SRAM] = {
.group = "INFRA_AO", .name = "scp_sram_base"},
[CMDQ_SUBSYS_INFRA_NA3] = {.group = "NA", .name = "infra_na3_base"},
[CMDQ_SUBSYS_INFRA_NA4] = {.group = "NA", .name = "infra_na4_base"},
[CMDQ_SUBSYS_SCP] = {.group = "SCP", .name = "scp_base"},
[CMDQ_SUBSYS_MCUCFG] = {.group = "INFRASYS", .name = "mcucfg_base"},
[CMDQ_SUBSYS_GCPU] = {.group = "INFRASYS", .name = "gcpu_base"},
[CMDQ_SUBSYS_USB0] = {.group = "PERISYS", .name = "usb0_base"},
[CMDQ_SUBSYS_USB_SIF] = {.group = "PERISYS", .name = "usb_sif_base"},
[CMDQ_SUBSYS_AUDIO] = {.group = "PERISYS", .name = "audio_base"},
[CMDQ_SUBSYS_MSDC0] = {.group = "PERISYS", .name = "msdc0_base"},
[CMDQ_SUBSYS_MSDC1] = {.group = "PERISYS", .name = "msdc1_base"},
[CMDQ_SUBSYS_MSDC2] = {.group = "PERISYS", .name = "msdc2_base"},
[CMDQ_SUBSYS_MSDC3] = {.group = "PERISYS", .name = "msdc3_base"},
[CMDQ_SUBSYS_AP_DMA] = {.group = "INFRASYS", .name = "ap_dma_base"},
[CMDQ_SUBSYS_GCE] = {.group = "GCE", .name = "gce_base"},
[CMDQ_SUBSYS_VDEC] = {.group = "VDEC", .name = "vdec_base"},
[CMDQ_SUBSYS_VDEC1] = {.group = "VDEC", .name = "vdec1_base"},
[CMDQ_SUBSYS_VDEC2] = {.group = "VDEC", .name = "vdec2_base"},
[CMDQ_SUBSYS_VDEC3] = {.group = "VDEC", .name = "vdec3_base"},
[CMDQ_SUBSYS_CAMSYS] = {.group = "CAMSYS", .name = "camsys_base"},
[CMDQ_SUBSYS_CAMSYS1] = {.group = "CAMSYS", .name = "camsys1_base"},
[CMDQ_SUBSYS_CAMSYS2] = {.group = "CAMSYS", .name = "camsys2_base"},
[CMDQ_SUBSYS_CAMSYS3] = {.group = "CAMSYS", .name = "camsys3_base"},
[CMDQ_SUBSYS_IMGSYS1] = {.group = "IMGSYS", .name = "imgsys1_base"},
[CMDQ_SUBSYS_SMI_LAB1] = {
.group = "SMI_LAB1", .name = "smi_larb1_base"},
/* Special subsys */
[CMDQ_SUBSYS_PWM_SW] = {.group = "SPECIAL", .name = "pwm_sw_base"},
[CMDQ_SUBSYS_PWM1_SW] = {.group = "SPECIAL", .name = "pwm1_sw_base"},
[CMDQ_SUBSYS_DIP_A0_SW] = {
.group = "SPECIAL", .name = "dip_a0_sw_base"},
[CMDQ_SUBSYS_MIPITX0] = {.group = "SPECIAL", .name = "mipitx0_base"},
[CMDQ_SUBSYS_MIPITX1] = {.group = "SPECIAL", .name = "mipitx1_base"},
[CMDQ_SUBSYS_VENC] = {.group = "SPECIAL", .name = "venc_base"},
[CMDQ_SUBSYS_IMGSYS2] = {.group = "SPECIAL", .name = "imgsys2_base"},
[CMDQ_SUBSYS_IPESYS] = {.group = "SPECIAL", .name = "ipesys_base"},
[CMDQ_SUBSYS_DPE] = {.group = "SPECIAL", .name = "dpe_base"},
};
struct cmdq_subsys_dts_name *cmdq_subsys_get_dts(void)
{
return subsys;
}
u32 cmdq_subsys_get_size(void)
{
return ARRAY_SIZE(subsys);
}
@@ -0,0 +1,71 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _CMDQ_SUBSYS_COMMON_H_
#define _CMDQ_SUBSYS_COMMON_H_
/* Define CMDQ subsys
*
* CMDQ subsys base address define in DTS.
* Mapping dts name and subsys define must sync with
* subsys table define in cmdq_subsys_common.c.
*/
enum CMDQ_SUBSYS_ENUM {
CMDQ_SUBSYS_G3D_CONFIG_BASE,
CMDQ_SUBSYS_MMSYS_CONFIG,
CMDQ_SUBSYS_DISP_DITHER,
CMDQ_SUBSYS_NA,
CMDQ_SUBSYS_IMGSYS,
CMDQ_SUBSYS_VDEC_GCON,
CMDQ_SUBSYS_VENC_GCON,
CMDQ_SUBSYS_CONN_PERIPHERALS,
CMDQ_SUBSYS_TOPCKGEN,
CMDQ_SUBSYS_KP,
CMDQ_SUBSYS_SCP_SRAM,
CMDQ_SUBSYS_INFRA_NA3,
CMDQ_SUBSYS_INFRA_NA4,
CMDQ_SUBSYS_SCP,
CMDQ_SUBSYS_MCUCFG,
CMDQ_SUBSYS_GCPU,
CMDQ_SUBSYS_USB0,
CMDQ_SUBSYS_USB_SIF,
CMDQ_SUBSYS_AUDIO,
CMDQ_SUBSYS_MSDC0,
CMDQ_SUBSYS_MSDC1,
CMDQ_SUBSYS_MSDC2,
CMDQ_SUBSYS_MSDC3,
CMDQ_SUBSYS_AP_DMA,
CMDQ_SUBSYS_GCE,
CMDQ_SUBSYS_VDEC,
CMDQ_SUBSYS_VDEC1,
CMDQ_SUBSYS_VDEC2,
CMDQ_SUBSYS_VDEC3,
CMDQ_SUBSYS_CAMSYS,
CMDQ_SUBSYS_CAMSYS1,
CMDQ_SUBSYS_CAMSYS2,
CMDQ_SUBSYS_CAMSYS3,
CMDQ_SUBSYS_IMGSYS1,
CMDQ_SUBSYS_SMI_LAB1,
/* Special subsys */
CMDQ_SUBSYS_PWM_SW,
CMDQ_SUBSYS_PWM1_SW,
CMDQ_SUBSYS_DIP_A0_SW,
CMDQ_SUBSYS_MIPITX0,
CMDQ_SUBSYS_MIPITX1,
CMDQ_SUBSYS_VENC,
CMDQ_SUBSYS_IMGSYS2,
CMDQ_SUBSYS_IPESYS,
CMDQ_SUBSYS_DPE,
/* ALWAYS keep at the end */
CMDQ_SUBSYS_MAX_COUNT
};
#endif
File diff suppressed because it is too large. Load diff
+690
View File
@@ -0,0 +1,690 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "mdp_cmdq_helper_ext.h"
#include "cmdq_reg.h"
#include "mdp_cmdq_device.h"
#include "cmdq_virtual.h"
#include <linux/seq_file.h>
#ifdef CMDQ_CG_M4U_LARB0
#include "m4u.h"
#endif
#ifdef CONFIG_MTK_SMI_EXT
#include "smi_public.h"
#endif
static struct cmdqCoreFuncStruct gFunctionPointer;
u64 cmdq_virtual_flag_from_scenario_default(enum CMDQ_SCENARIO_ENUM scn)
{
u64 flag = 0;
switch (scn) {
case CMDQ_SCENARIO_TRIGGER_LOOP:
/* Trigger loop does not related to any HW by itself. */
flag = 0LL;
break;
case CMDQ_SCENARIO_USER_SPACE:
/* user space case, engine flag is passed seprately */
flag = 0LL;
break;
case CMDQ_SCENARIO_DEBUG:
case CMDQ_SCENARIO_DEBUG_PREFETCH:
flag = 0LL;
break;
case CMDQ_SCENARIO_USER_DISP_COLOR:
/* color path */
flag = 0LL;
break;
default:
if (scn < 0 || scn >= CMDQ_MAX_SCENARIO_COUNT) {
/* Error status print */
CMDQ_ERR("Unknown scenario type %d\n", scn);
}
flag = 0LL;
break;
}
return flag;
}
const char *cmdq_virtual_parse_module_from_reg_addr_legacy(u32 reg_addr)
{
const u32 addr_base_and_page = (reg_addr & 0xFFFFF000);
/* for well-known base, we check them with 12-bit mask
* defined in mt_reg_base.h
* TODO: comfirm with SS if IO_VIRT_TO_PHYS workable when enable device
* tree?
*/
switch (addr_base_and_page) {
case 0x14000000:
return "MMSYS";
case 0x14001000:
return "MDP_RDMA0";
case 0x14002000:
return "MDP_RDMA1";
case 0x14003000:
return "MDP_RSZ0";
case 0x14004000:
return "MDP_RSZ1";
case 0x14005000:
return "MDP_RSZ2";
case 0x14006000:
return "MDP_WDMA";
case 0x14007000:
return "MDP_WROT0";
case 0x14008000:
return "MDP_WROT1";
case 0x14009000:
return "MDP_TDSHP0";
case 0x1400A000:
return "MDP_TDSHP1";
case 0x1400B000:
return "MDP_CROP";
case 0x1400C000:
return "DISP_OVL0";
case 0x1400D000:
return "DISP_OVL1";
case 0x14013000:
return "COLOR0";
case 0x14014000:
return "COLOR1";
case 0x14015000:
return "AAL";
case 0x14016000:
return "GAMA";
case 0x14020000:
return "MMSYS_MUTEX";
case 0x18000000:
return "VENC_GCON";
case 0x18002000:
return "VENC";
case 0x18003000:
return "JPGENC";
case 0x18004000:
return "JPGDEC";
}
/* for other register address we rely on GCE subsys to group them
* with 16-bit mask.
*/
return cmdq_core_parse_subsys_from_reg_addr(reg_addr);
}
/*
* GCE capability
*/
u32 cmdq_virtual_get_subsys_LSB_in_arg_a(void)
{
return 16;
}
/* HW thread related */
bool cmdq_virtual_is_a_secure_thread(const s32 thread)
{
#ifdef CMDQ_SECURE_PATH_SUPPORT
if ((thread >= CMDQ_MIN_SECURE_THREAD_ID) &&
(thread < CMDQ_MIN_SECURE_THREAD_ID +
CMDQ_MAX_SECURE_THREAD_COUNT)) {
return true;
}
#endif
return false;
}
/**
* Scenario related
*
*/
bool cmdq_virtual_is_disp_scenario(const enum CMDQ_SCENARIO_ENUM scenario)
{
bool dispScenario = false;
switch (scenario) {
case CMDQ_SCENARIO_TRIGGER_LOOP:
case CMDQ_SCENARIO_USER_DISP_COLOR:
dispScenario = true;
break;
default:
break;
}
/* freely dispatch */
return dispScenario;
}
bool cmdq_virtual_is_dynamic_scenario(
const enum CMDQ_SCENARIO_ENUM scenario)
{
bool dynamic_thread;
switch (scenario) {
case CMDQ_SCENARIO_USER_SPACE:
case CMDQ_SCENARIO_USER_MDP:
case CMDQ_SCENARIO_DEBUG_MDP:
dynamic_thread = true;
break;
default:
dynamic_thread = false;
break;
}
return dynamic_thread;
}
int cmdq_virtual_disp_thread(enum CMDQ_SCENARIO_ENUM scenario)
{
switch (scenario) {
/* HACK: force debug into 0/1 thread */
case CMDQ_SCENARIO_DEBUG_PREFETCH:
/* primary config: thread 0 */
return 0;
case CMDQ_SCENARIO_USER_DISP_COLOR:
return 4;
case CMDQ_SCENARIO_TRIGGER_LOOP:
return 7;
default:
/* freely dispatch */
return CMDQ_INVALID_THREAD;
}
/* freely dispatch */
return CMDQ_INVALID_THREAD;
}
int cmdq_virtual_get_thread_index(enum CMDQ_SCENARIO_ENUM scenario,
const bool secure)
{
if (!secure)
return cmdq_get_func()->dispThread(scenario);
/* dispatch secure thread according to scenario */
switch (scenario) {
case CMDQ_SCENARIO_DEBUG_PREFETCH:
/* CMDQ_MIN_SECURE_THREAD_ID */
return CMDQ_THREAD_SEC_PRIMARY_DISP;
case CMDQ_SCENARIO_USER_MDP:
case CMDQ_SCENARIO_USER_SPACE:
case CMDQ_SCENARIO_DEBUG:
case CMDQ_SCENARIO_DEBUG_MDP:
/* because there is one input engine for MDP, reserve one
* secure thread is enough
*/
return CMDQ_THREAD_SEC_MDP;
case CMDQ_SCENARIO_ISP_FDVT:
case CMDQ_SCENARIO_ISP_FDVT_OFF:
return CMDQ_THREAD_SEC_ISP;
default:
CMDQ_ERR("no dedicated secure thread for senario:%d\n",
scenario);
return CMDQ_INVALID_THREAD;
}
}
enum CMDQ_HW_THREAD_PRIORITY_ENUM cmdq_virtual_priority_from_scenario(
enum CMDQ_SCENARIO_ENUM scenario)
{
switch (scenario) {
case CMDQ_SCENARIO_USER_DISP_COLOR:
/* currently, a prefetch thread is always in high priority. */
return CMDQ_THR_PRIO_DISPLAY_CONFIG;
/* HACK: force debug into 0/1 thread */
case CMDQ_SCENARIO_DEBUG_PREFETCH:
return CMDQ_THR_PRIO_DISPLAY_CONFIG;
default:
/* other cases need exta logic, see below. */
break;
}
if (cmdq_get_func()->is_disp_loop(scenario))
return CMDQ_THR_PRIO_DISPLAY_TRIGGER;
else
return CMDQ_THR_PRIO_NORMAL;
}
bool cmdq_virtual_is_disp_loop(enum CMDQ_SCENARIO_ENUM scenario)
{
bool is_disp_loop = false;
if (scenario == CMDQ_SCENARIO_TRIGGER_LOOP)
is_disp_loop = true;
return is_disp_loop;
}
/**
* Module dependent
*
*/
void cmdq_virtual_get_reg_id_from_hwflag(u64 hwflag,
enum cmdq_gpr_reg *valueRegId,
enum cmdq_gpr_reg *destRegId,
enum cmdq_event *regAccessToken)
{
*regAccessToken = CMDQ_SYNC_TOKEN_INVALID;
if (hwflag & (1LL << CMDQ_ENG_MDP_TDSHP0)) {
*valueRegId = CMDQ_DATA_REG_2D_SHARPNESS_0;
*destRegId = CMDQ_DATA_REG_2D_SHARPNESS_0_DST;
*regAccessToken = CMDQ_SYNC_TOKEN_GPR_SET_1;
} else if (hwflag & (1LL << CMDQ_ENG_MDP_TDSHP1)) {
*valueRegId = CMDQ_DATA_REG_2D_SHARPNESS_1;
*destRegId = CMDQ_DATA_REG_2D_SHARPNESS_1_DST;
*regAccessToken = CMDQ_SYNC_TOKEN_GPR_SET_2;
} else {
/* assume others are debug cases */
*valueRegId = CMDQ_DATA_REG_DEBUG;
*destRegId = CMDQ_DATA_REG_DEBUG_DST;
*regAccessToken = CMDQ_SYNC_TOKEN_GPR_SET_4;
}
}
const char *cmdq_virtual_module_from_event_id(const s32 event,
struct CmdqCBkStruct *groupCallback, u64 engineFlag)
{
const char *module = "CMDQ";
enum CMDQ_GROUP_ENUM group = CMDQ_MAX_GROUP_COUNT;
switch (event) {
case CMDQ_EVENT_MDP_RDMA0_SOF ... CMDQ_EVENT_MDP_WROT3_SOF:
case CMDQ_EVENT_MDP_RDMA0_EOF ... CMDQ_EVENT_MDP_WROT3_WRITE_EOF:
case CMDQ_EVENT_IMG_DL_RELAY_SOF ... CMDQ_EVENT_IMG_DL_RELAY3_SOF:
module = "MDP";
group = CMDQ_GROUP_MDP;
break;
case CMDQ_EVENT_ISP_PASS2_2_EOF ... CMDQ_EVENT_ISP_PASS2_0_EOF:
case CMDQ_EVENT_DIP_CQ_THREAD0_EOF ... CMDQ_EVENT_DIP_CQ_THREAD18_EOF:
case CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_0
... CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_23:
module = "DIP";
group = CMDQ_GROUP_ISP;
break;
case CMDQ_EVENT_WPE_A_EOF:
case CMDQ_EVENT_WPE_B_FRAME_DONE:
module = "WPE";
group = CMDQ_GROUP_WPE;
break;
default:
module = "CMDQ";
group = CMDQ_MAX_GROUP_COUNT;
break;
}
if (group < CMDQ_MAX_GROUP_COUNT && groupCallback[group].dispatchMod)
module = groupCallback[group].dispatchMod(engineFlag);
return module;
}
const char *cmdq_virtual_parse_module_from_reg_addr(u32 reg_addr)
{
const u32 addr_base_and_page = (reg_addr & 0xFFFFF000);
#ifdef CMDQ_USE_LEGACY
return cmdq_virtual_parse_module_from_reg_addr_legacy(reg_addr);
#else
/* for well-known base, we check them with 12-bit mask
* defined in mt_reg_base.h
* TODO: comfirm with SS if IO_VIRT_TO_PHYS workable when enable
* device tree?
*/
switch (addr_base_and_page) {
case 0x14001000: /* MDP_RDMA0 */
case 0x14002000: /* MDP_RDMA1 */
case 0x14003000: /* MDP_RSZ0 */
case 0x14004000: /* MDP_RSZ1 */
case 0x14005000: /* MDP_RSZ2 */
case 0x14006000: /* MDP_WDMA */
case 0x14007000: /* MDP_WROT0 */
case 0x14008000: /* MDP_WROT1 */
case 0x14009000: /* MDP_TDSHP */
return "MDP";
case 0x14014000: /* DISP_COLOR0 */
case 0x14015000: /* DISP_COLOR1 */
return "COLOR";
case 0x14016000: /* DISP_COLOR0 */
case 0x14017000: /* DISP_COLOR1 */
return "CCORR";
case 0x1400B000: /* DISP_OVL0 */
case 0x1400D000: /* DISP_OVL0_2L */
return "OVL0";
case 0x1400C000: /* DISP_OVL1 */
case 0x1400E000: /* DISP_OVL1_2L */
return "OVL1";
case 0x14018000: /* DISP_AAL0 */
case 0x14019000: /* DISP_AAL1 */
case 0x1401a000: /* DISP_GAMMA0 */
case 0x1401b000: /* DISP_GAMMA1 */
return "AAL";
case 0x17020000: /* VENC */
return "VENC";
case 0x17030000: /* JPGENC */
return "JPGENC";
case 0x17040000: /* JPGDEC */
return "JPGDEC";
}
/* for other register address we rely on GCE subsys to group them
* with 16-bit mask.
*/
return cmdq_core_parse_subsys_from_reg_addr(reg_addr);
#endif
}
s32 cmdq_virtual_can_module_entry_suspend(struct EngineStruct *engineList)
{
s32 status = 0;
int i;
enum CMDQ_ENG_ENUM e = 0;
u32 mdpEngines[] = {
CMDQ_ENG_ISP_IMGI,
CMDQ_ENG_MDP_RDMA0,
CMDQ_ENG_MDP_RDMA1,
CMDQ_ENG_MDP_RSZ0,
CMDQ_ENG_MDP_RSZ1,
CMDQ_ENG_MDP_RSZ2,
CMDQ_ENG_MDP_TDSHP0,
CMDQ_ENG_MDP_TDSHP1,
CMDQ_ENG_MDP_COLOR0,
CMDQ_ENG_MDP_WROT0,
CMDQ_ENG_MDP_WROT1,
CMDQ_ENG_MDP_WDMA,
};
for (i = 0; i < ARRAY_SIZE(mdpEngines); i++) {
e = mdpEngines[i];
if (engineList[e].userCount != 0) {
CMDQ_ERR(
"suspend but engine %d has userCount %d, owner=%d\n",
e, engineList[e].userCount,
engineList[e].currOwner);
status = -EBUSY;
}
}
return status;
}
ssize_t cmdq_virtual_print_status_clock(char *buf)
{
s32 length = 0;
char *pBuffer = buf;
#ifdef CMDQ_PWR_AWARE
/* MT_CG_DISP0_MUTEX_32K is removed in this platform */
pBuffer += sprintf(pBuffer, "MT_CG_INFRA_GCE: %d\n",
cmdq_dev_gce_clock_is_enable());
pBuffer += sprintf(pBuffer, "\n");
#endif
length = pBuffer - buf;
return length;
}
void cmdq_virtual_print_status_seq_clock(struct seq_file *m)
{
#ifdef CMDQ_PWR_AWARE
/* MT_CG_DISP0_MUTEX_32K is removed in this platform */
seq_printf(m, "MT_CG_INFRA_GCE: %d", cmdq_dev_gce_clock_is_enable());
seq_puts(m, "\n");
#endif
}
void cmdq_virtual_enable_common_clock_locked(bool enable)
{
#ifdef CMDQ_PWR_AWARE
if (enable) {
CMDQ_VERBOSE("[CLOCK] Enable SMI & LARB0 Clock\n");
/* Use SMI clock API */
#ifdef CONFIG_MTK_SMI_EXT
smi_bus_prepare_enable(SMI_LARB0, "CMDQ");
#endif
} else {
CMDQ_VERBOSE("[CLOCK] Disable SMI & LARB0 Clock\n");
/* disable, reverse the sequence */
#ifdef CONFIG_MTK_SMI_EXT
smi_bus_disable_unprepare(SMI_LARB0, "CMDQ");
#endif
}
#endif /* CMDQ_PWR_AWARE */
}
void cmdq_virtual_enable_gce_clock_locked(bool enable)
{
#ifdef CMDQ_PWR_AWARE
if (enable) {
CMDQ_VERBOSE("[CLOCK] Enable CMDQ(GCE) Clock\n");
cmdq_dev_enable_gce_clock(enable);
} else {
CMDQ_VERBOSE("[CLOCK] Disable CMDQ(GCE) Clock\n");
cmdq_dev_enable_gce_clock(enable);
}
#endif
}
const char *cmdq_virtual_parse_handle_error_module_by_hwflag_impl(
const struct cmdqRecStruct *pHandle)
{
const char *module = NULL;
if (cmdq_get_func()->isDispScenario(pHandle->scenario))
module = "DISP";
else
module = cmdq_mdp_parse_handle_error_module_by_hwflag(pHandle);
/* other case, we need to analysis instruction for more detail */
return module;
}
const char *cmdq_virtual_parse_error_module_by_hwflag_impl(
const struct cmdqRecStruct *task)
{
const char *module = NULL;
/* TODO: fill in correct dispatch module */
if (cmdq_get_func()->isDispScenario(task->scenario))
module = "DISP";
else
module = cmdq_mdp_parse_handle_error_module_by_hwflag(task);
/* other case, we need to analysis instruction for more detail */
return module;
}
/**
* Debug
*
*/
int cmdq_virtual_dump_smi(const int showSmiDump)
{
int isSMIHang = 0;
#if defined(CONFIG_MTK_SMI_EXT) && !defined(CONFIG_FPGA_EARLY_PORTING) && \
!defined(CONFIG_MTK_SMI_VARIANT)
isSMIHang = smi_debug_bus_hang_detect(showSmiDump, "CMDQ");
CMDQ_ERR("SMI Hang? = %d\n", isSMIHang);
#else
CMDQ_LOG("[WARNING]not enable SMI dump now\n");
#endif
return isSMIHang;
}
void cmdq_virtual_dump_gpr(void)
{
int i = 0;
long offset = 0;
u32 value = 0;
CMDQ_LOG("========= GPR dump =========\n");
for (i = 0; i < 16; i++) {
offset = CMDQ_GPR_R32(i);
value = CMDQ_REG_GET32(offset);
CMDQ_LOG("[GPR %2d]+0x%lx = 0x%08x\n", i, offset, value);
}
CMDQ_LOG("========= GPR dump =========\n");
}
/**
* Event backup
*
*/
struct cmdq_backup_event_struct {
enum cmdq_event EventID;
u32 BackupValue;
};
static struct cmdq_backup_event_struct g_cmdq_backup_event[] = {
#ifdef CMDQ_EVENT_NEED_BACKUP
{CMDQ_SYNC_TOKEN_VENC_EOF, 0,},
{CMDQ_SYNC_TOKEN_VENC_INPUT_READY, 0,},
#endif /* CMDQ_EVENT_NEED_BACKUP */
};
void cmdq_virtual_event_backup(void)
{
int i;
int array_size = (sizeof(g_cmdq_backup_event) /
sizeof(struct cmdq_backup_event_struct));
for (i = 0; i < array_size; i++) {
if (g_cmdq_backup_event[i].EventID < 0 ||
g_cmdq_backup_event[i].EventID >= CMDQ_SYNC_TOKEN_MAX)
continue;
g_cmdq_backup_event[i].BackupValue = cmdqCoreGetEvent(
g_cmdq_backup_event[i].EventID);
CMDQ_MSG("[backup event] event: %s, value: %d\n",
cmdq_core_get_event_name_enum(
g_cmdq_backup_event[i].EventID),
g_cmdq_backup_event[i].BackupValue);
}
}
void cmdq_virtual_event_restore(void)
{
int i;
int array_size = (sizeof(g_cmdq_backup_event) /
sizeof(struct cmdq_backup_event_struct));
for (i = 0; i < array_size; i++) {
if (g_cmdq_backup_event[i].EventID < 0 ||
g_cmdq_backup_event[i].EventID >= CMDQ_SYNC_TOKEN_MAX)
continue;
CMDQ_MSG("[restore event] event: %s, value: %d\n",
cmdq_core_get_event_name_enum(
g_cmdq_backup_event[i].EventID),
g_cmdq_backup_event[i].BackupValue);
if (g_cmdq_backup_event[i].BackupValue == 1)
cmdqCoreSetEvent(g_cmdq_backup_event[i].EventID);
else if (g_cmdq_backup_event[i].BackupValue == 0)
cmdqCoreClearEvent(g_cmdq_backup_event[i].EventID);
}
}
/**
* Test
*
*/
void cmdq_virtual_test_setup(void)
{
/* unconditionally set CMDQ_SYNC_TOKEN_CONFIG_ALLOW and mutex
* STREAM_DONE so that DISPSYS scenarios may pass check.
*/
}
void cmdq_virtual_test_cleanup(void)
{
/* do nothing */
}
void cmdq_virtual_init_module_PA_stat(void)
{
}
void cmdq_virtual_function_setting(void)
{
struct cmdqCoreFuncStruct *pFunc;
pFunc = &(gFunctionPointer);
/*
* GCE capability
*/
pFunc->getSubsysLSBArgA = cmdq_virtual_get_subsys_LSB_in_arg_a;
/* HW thread related */
pFunc->isSecureThread = cmdq_virtual_is_a_secure_thread;
/**
* Scenario related
*
*/
pFunc->isDispScenario = cmdq_virtual_is_disp_scenario;
pFunc->isDynamic = cmdq_virtual_is_dynamic_scenario;
pFunc->dispThread = cmdq_virtual_disp_thread;
pFunc->getThreadID = cmdq_virtual_get_thread_index;
pFunc->priority = cmdq_virtual_priority_from_scenario;
pFunc->is_disp_loop = cmdq_virtual_is_disp_loop;
/**
* Module dependent
*
*/
pFunc->getRegID = cmdq_virtual_get_reg_id_from_hwflag;
pFunc->moduleFromEvent = cmdq_virtual_module_from_event_id;
pFunc->parseModule = cmdq_virtual_parse_module_from_reg_addr;
pFunc->moduleEntrySuspend = cmdq_virtual_can_module_entry_suspend;
pFunc->printStatusClock = cmdq_virtual_print_status_clock;
pFunc->printStatusSeqClock = cmdq_virtual_print_status_seq_clock;
pFunc->enableGCEClockLocked = cmdq_virtual_enable_gce_clock_locked;
pFunc->parseErrorModule =
cmdq_virtual_parse_error_module_by_hwflag_impl;
pFunc->parseHandleErrorModule =
cmdq_virtual_parse_handle_error_module_by_hwflag_impl;
/**
* Debug
*
*/
pFunc->dumpSMI = cmdq_virtual_dump_smi;
pFunc->dumpGPR = cmdq_virtual_dump_gpr;
/**
* Event backup
*
*/
pFunc->eventBackup = cmdq_virtual_event_backup;
pFunc->eventRestore = cmdq_virtual_event_restore;
/**
* Test
*
*/
pFunc->testSetup = cmdq_virtual_test_setup;
pFunc->testCleanup = cmdq_virtual_test_cleanup;
pFunc->initModulePAStat = cmdq_virtual_init_module_PA_stat;
}
struct cmdqCoreFuncStruct *cmdq_get_func(void)
{
return &gFunctionPointer;
}
+137
View File
@@ -0,0 +1,137 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CMDQ_VIRTUAL_H__
#define __CMDQ_VIRTUAL_H__
#include "mdp_def.h"
#include "mdp_cmdq_helper_ext.h"
/* get subsys LSB in arg_a */
typedef u32(*CmdqGetSubsysLSBArgA) (void);
/* is a secure thread */
typedef bool(*CmdqIsSecureThread) (const s32 thread);
/* is display scenario */
typedef bool(*CmdqIsDispScenario) (const enum CMDQ_SCENARIO_ENUM scenario);
/* is exclusive thread scenario */
typedef bool(*CmdqIsDynamic) (const enum CMDQ_SCENARIO_ENUM scenario);
/* should enable prefetch */
typedef bool(*CmdqShouldEnablePrefetch) (
const enum CMDQ_SCENARIO_ENUM scenario);
/* display thread index from scenario */
typedef int (*CmdqDispThread) (enum CMDQ_SCENARIO_ENUM scenario);
/* get thread index from scenario and secure */
typedef int (*CmdqGetThreadID) (enum CMDQ_SCENARIO_ENUM scenario,
const bool secure);
/* priority from scenario */
typedef enum CMDQ_HW_THREAD_PRIORITY_ENUM(*CmdqPriority) (
enum CMDQ_SCENARIO_ENUM scenario);
/* force loop IRQ from scenario */
typedef bool(*cmdq_force_loop_irq) (enum CMDQ_SCENARIO_ENUM scenario);
/* is disp loop */
typedef bool(*cmdq_is_disp_loop) (enum CMDQ_SCENARIO_ENUM scenario);
/* get register index from hwflag */
typedef void(*CmdqGetRegID) (u64 hwflag,
enum cmdq_gpr_reg *valueRegId,
enum cmdq_gpr_reg *destRegId,
enum cmdq_event *regAccessToken);
/* module from event index */
typedef const char *(*CmdqModuleFromEvent) (const s32 event,
struct CmdqCBkStruct *groupCallback, u64 engineFlag);
/* parse module from register addr */
typedef const char *(*CmdqParseModule) (u32 reg_addr);
/* can module entry suspend */
typedef s32(*CmdqModuleEntrySuspend) (struct EngineStruct *engineList);
/* print status clock */
typedef ssize_t(*CmdqPrintStatusClock) (char *buf);
/* print seq status clock */
typedef void (*CmdqPrintStatusSeqClock) (struct seq_file *m);
/* enable GCE clock locked */
typedef void (*CmdqEnableGCEClockLocked) (bool enable);
/* parse error module by hwflag */
typedef const char *(*CmdqParseErrorModule) (const struct cmdqRecStruct *pTask);
/* parse error module by hwflag */
typedef const char *(*CmdqParseHandleErrorModule) (
const struct cmdqRecStruct *pHandle);
/* dump SMI */
typedef int (*CmdqDumpSMI) (const int showSmiDump);
/* dump GPR */
typedef void (*CmdqDumpGPR) (void);
/* flag from scenario */
typedef u64(*CmdqFlagFromScenario) (enum CMDQ_SCENARIO_ENUM scenario);
/* evet backup */
typedef void (*CmdqEventBackup) (void);
/* evet restore */
typedef void (*CmdqEventRestore) (void);
/* test setup */
typedef void (*CmdqTestSetup) (void);
/* test cleanup */
typedef void (*CmdqTestCleanup) (void);
/* test for instruction statistic */
typedef void (*CmdqInitModulePAStat) (void);
struct cmdqCoreFuncStruct {
CmdqGetSubsysLSBArgA getSubsysLSBArgA;
CmdqIsSecureThread isSecureThread;
CmdqIsDispScenario isDispScenario;
CmdqIsDynamic isDynamic;
CmdqDispThread dispThread;
CmdqGetThreadID getThreadID;
CmdqPriority priority;
cmdq_is_disp_loop is_disp_loop;
CmdqGetRegID getRegID;
CmdqModuleFromEvent moduleFromEvent;
CmdqParseModule parseModule;
CmdqModuleEntrySuspend moduleEntrySuspend;
CmdqPrintStatusClock printStatusClock;
CmdqPrintStatusSeqClock printStatusSeqClock;
CmdqEnableGCEClockLocked enableGCEClockLocked;
CmdqParseErrorModule parseErrorModule;
CmdqParseHandleErrorModule parseHandleErrorModule;
CmdqDumpSMI dumpSMI;
CmdqDumpGPR dumpGPR;
CmdqEventBackup eventBackup;
CmdqEventRestore eventRestore;
CmdqTestSetup testSetup;
CmdqTestCleanup testCleanup;
CmdqInitModulePAStat initModulePAStat;
};
#ifdef __cplusplus
extern "C" {
#endif
void cmdq_virtual_function_setting(void);
struct cmdqCoreFuncStruct *cmdq_get_func(void);
#ifdef __cplusplus
}
#endif
#endif /* __CMDQ_VIRTUAL_H__ */
@@ -0,0 +1,78 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CMDQ_DEVICE_H__
#define __CMDQ_DEVICE_H__
#include <linux/platform_device.h>
#include <linux/device.h>
#include "mdp_def.h"
#include "mdp_common.h"
#include <linux/clk.h>
#define DECLARE_ENABLE_HW_CLOCK(HW_NAME) \
u32 cmdq_dev_enable_clock_##HW_NAME(bool enable)
DECLARE_ENABLE_HW_CLOCK(SMI_COMMON);
DECLARE_ENABLE_HW_CLOCK(SMI_LARB0);
#ifdef CMDQ_USE_LEGACY
DECLARE_ENABLE_HW_CLOCK(MUTEX_32K);
#endif
#undef DECLARE_ENABLE_HW_CLOCK
void cmdq_dev_get_module_clock_by_name(const char *ref_name,
const char *clkName, struct clk **clk_module);
u32 cmdq_dev_enable_device_clock(bool enable, struct clk *clk_module,
const char *clkName);
bool cmdq_dev_device_clock_is_enable(struct clk *clk_module);
/* For test case used */
void testcase_clkmgr_impl(enum CMDQ_ENG_ENUM engine,
char *name, const unsigned long testWriteReg,
const u32 testWriteValue,
const unsigned long testReadReg, const bool verifyWriteResult);
struct device *cmdq_dev_get(void);
/* interrupt index */
u32 cmdq_dev_get_irq_id(void);
u32 cmdq_dev_get_irq_secure_id(void);
/* GCE clock */
void cmdq_dev_enable_gce_clock(bool enable);
bool cmdq_dev_gce_clock_is_enable(void);
bool cmdq_dev_mmsys_clock_is_enable(void);
/* virtual address */
long cmdq_dev_get_module_base_VA_GCE(void);
unsigned long cmdq_dev_alloc_reference_VA_by_name(const char *ref_name);
unsigned long cmdq_dev_alloc_reference_by_name(const char *ref_name,
uint32_t *pa);
/* Other modules information */
void cmdq_dev_free_module_base_VA(const long VA);
u32 cmdq_dev_get_mmsys_dummy_reg_offset(void);
/* physical address */
phys_addr_t cmdq_dev_get_reference_PA(const char *ref_name, int index);
phys_addr_t cmdq_dev_get_module_base_PA_GCE(void);
#if IS_ENABLED(CONFIG_MACH_MT6885)
unsigned long cmdq_dev_get_va2(void);
phys_addr_t cmdq_dev_get_pa2(void);
#endif
/* GCE event */
void cmdq_dev_init_event_table(struct device_node *node);
void cmdq_dev_test_dts_correctness(void);
/* device initialization / deinitialization */
void cmdq_dev_init(struct platform_device *pDevice);
void cmdq_dev_deinit(void);
/* dma_set_mask result, to show in status */
s32 cmdq_dev_get_dma_mask_result(void);
u32 cmdq_dev_get_thread_count(void);
/* callback when read resource from device tree */
typedef void(*CMDQ_DEV_INIT_RESOURCE_CB) (u32 engineFlag,
enum cmdq_event resourceEvent);
void cmdq_dev_init_resource(CMDQ_DEV_INIT_RESOURCE_CB init_cb);
#endif /* __CMDQ_DEVICE_H__ */
File diff suppressed because it is too large. Load diff
+849
View File
@@ -0,0 +1,849 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __CMDQ_RECORD_H__
#define __CMDQ_RECORD_H__
#include <linux/types.h>
#include <linux/soc/mediatek/mtk-cmdq.h>
#include "mdp_def.h"
#include "mdp_cmdq_helper_ext.h"
enum CMDQ_STACK_TYPE_ENUM {
CMDQ_STACK_NULL = -1,
CMDQ_STACK_TYPE_IF = 0,
CMDQ_STACK_TYPE_ELSE = 1,
CMDQ_STACK_TYPE_WHILE = 2,
CMDQ_STACK_TYPE_BREAK = 3,
CMDQ_STACK_TYPE_CONTINUE = 4,
CMDQ_STACK_TYPE_DO_WHILE = 5,
};
#define CMDQ_DATA_BIT (62)
#define CMDQ_BIT_VALUE (0LL)
#define CMDQ_BIT_VAR (1LL)
#define CMDQ_TASK_CPR_INITIAL_VALUE (0)
#define CMDQ_REC_DEFAULT_PRIORITY (100)
#define CMDQ_REC_MAX_PRIORITY (0x7FFFFFFF)
struct cmdq_stack_node {
u32 position;
enum CMDQ_STACK_TYPE_ENUM stack_type;
struct cmdq_stack_node *next;
};
struct cmdq_user_req {
#if 0
u32 *buffer;
u32 buffer_size;
#endif
u32 reg_count;
u32 user_token;
};
#define cmdqBackupSlotHandle dma_addr_t
/* Create command queue recorder handle
* Parameter:
* pHandle: pointer to retrieve the handle
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_task_create(enum CMDQ_SCENARIO_ENUM scenario,
struct cmdqRecStruct **pHandle);
s32 cmdqRecCreate(enum CMDQ_SCENARIO_ENUM scenario,
struct cmdqRecStruct **pHandle);
s32 cmdq_task_duplicate(struct cmdqRecStruct *handle,
struct cmdqRecStruct **handle_out);
/* Set engine flag for command queue picking HW thread
* Parameter:
* pHandle: pointer to retrieve the handle
* engineFlag: Flag use to identify which HW module can be accessed
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_task_set_engine(struct cmdqRecStruct *handle,
u64 engineFlag);
s32 cmdqRecSetEngine(struct cmdqRecStruct *handle,
u64 engineFlag);
/* Reset command queue recorder commands
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_task_reset(struct cmdqRecStruct *handle);
s32 cmdqRecReset(struct cmdqRecStruct *handle);
void cmdq_task_set_timeout(struct cmdqRecStruct *handle, u32 timeout);
/* Configure as secure task
* Parameter:
* handle: the command queue recorder handle
* is_secure: true, execute the command in secure world
* Return:
* 0 for success; else the error code is returned
*
* Note:
* a. Secure CMDQ support when t-base enabled only
* b. By default struct cmdqRecStruct records a normal command,
* please call cmdq_task_set_secure to set command as SECURE
* after cmdq_task_reset
*/
s32 cmdq_task_set_secure(struct cmdqRecStruct *handle, const bool is_secure);
s32 cmdqRecSetSecure(struct cmdqRecStruct *handle, const bool is_secure);
/* query handle is secure task or not
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for false (not secure) and 1 for true (is secure)
*/
s32 cmdq_task_is_secure(struct cmdqRecStruct *handle);
s32 cmdqRecIsSecure(struct cmdqRecStruct *handle);
/* Add DPAC protection flag
* Parameter:
* Note:
* a. Secure CMDQ support when t-base enabled only
* b. after reset handle, user have to specify protection flag again
*/
s32 cmdq_task_secure_enable_dapc(struct cmdqRecStruct *handle,
const u64 engineFlag);
s32 cmdqRecSecureEnableDAPC(struct cmdqRecStruct *handle,
const u64 engineFlag);
/* Add flag for M4U security ports
* Parameter:
* Note:
* a. Secure CMDQ support when t-base enabled only
* b. after reset handle, user have to specify protection flag again
*/
s32 cmdq_task_secure_enable_port_security(struct cmdqRecStruct *handle,
const u64 engineFlag);
s32 cmdqRecSecureEnablePortSecurity(struct cmdqRecStruct *handle,
const u64 engineFlag);
/* Assign secure metadata for client driver */
s32 cmdq_task_set_secure_meta(struct cmdqRecStruct *handle,
enum cmdq_sec_rec_meta_type type, void *meta, u32 size);
/* Append write command to the recorder
* Parameter:
* handle: the command queue recorder handle
* addr: the specified target register physical address
* argument / value: the specified target register value
* mask: the specified target register mask
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_write_reg(struct cmdqRecStruct *handle, u32 addr,
CMDQ_VARIABLE argument, u32 mask);
s32 cmdqRecWrite(struct cmdqRecStruct *handle, u32 addr, u32 value, u32 mask);
/* Append write command to the update secure buffer address in secure path
* Parameter:
* handle: the command queue recorder handle
* addr: the specified register physical address about module src/dst
* buffer address
* type: base handle type
* base handle: secure handle of a secure mememory
* offset: offset related to base handle
* (secure buffer = addr(base_handle) + offset)
* size: secure buffer size
* mask: 0xFFFF_FFFF
* Return:
* 0 for success; else the error code is returned
* Note:
* support only when secure OS enabled
*/
s32 cmdq_op_write_reg_secure(struct cmdqRecStruct *handle, u32 addr,
enum CMDQ_SEC_ADDR_METADATA_TYPE type, u64 baseHandle,
u32 offset, u32 size, u32 port);
s32 cmdqRecWriteSecure(struct cmdqRecStruct *handle,
u32 addr, enum CMDQ_SEC_ADDR_METADATA_TYPE type,
u64 baseHandle, u32 offset, u32 size, u32 port);
/* Append poll command to the recorder
* Parameter:
* handle: the command queue recorder handle
* addr: the specified register physical address
* value: the required register value
* mask: the required register mask
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_poll(struct cmdqRecStruct *handle, u32 addr, u32 value, u32 mask);
s32 cmdqRecPoll(struct cmdqRecStruct *handle, u32 addr, u32 value, u32 mask);
/* Append wait command to the recorder
* Parameter:
* handle: the command queue recorder handle
* event: the desired event type to "wait and CLEAR"
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_wait(struct cmdqRecStruct *handle, enum cmdq_event event);
s32 cmdqRecWait(struct cmdqRecStruct *handle, enum cmdq_event event);
/* like cmdq_op_wait, but won't clear the event after
* leaving wait state.
*
* Parameter:
* handle: the command queue recorder handle
* event: the desired event type wait for
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_wait_no_clear(struct cmdqRecStruct *handle,
enum cmdq_event event);
s32 cmdqRecWaitNoClear(struct cmdqRecStruct *handle,
enum cmdq_event event);
/* Unconditionally set to given event to 0.
* Parameter:
* handle: the command queue recorder handle
* event: the desired event type to set
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_clear_event(struct cmdqRecStruct *handle,
enum cmdq_event event);
s32 cmdqRecClearEventToken(struct cmdqRecStruct *handle,
enum cmdq_event event);
/* Unconditionally set to given event to 1.
* Parameter:
* handle: the command queue recorder handle
* event: the desired event type to set
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_set_event(struct cmdqRecStruct *handle,
enum cmdq_event event);
s32 cmdqRecSetEventToken(struct cmdqRecStruct *handle,
enum cmdq_event event);
/* Replace overwite CPR parameters of arg_a.
* Parameter:
* handle: the command queue recorder handle
* index: the index of instruction to replace
* new_arg_a: the desired cpr value to overwrite arg_a
* new_arg_b: the desired cpr value to overwrite arg_b
* new_arg_c: the desired cpr value to overwrite arg_c
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_replace_overwrite_cpr(struct cmdqRecStruct *handle, u32 index,
s32 new_arg_a, s32 new_arg_b, s32 new_arg_c);
/* Read a register value to a CMDQ general purpose register(GPR)
* Parameter:
* handle: the command queue recorder handle
* hw_addr: register address to read from
* dst_data_reg: CMDQ GPR to write to
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_read_to_data_register(struct cmdqRecStruct *handle,
u32 hw_addr, enum cmdq_gpr_reg dst_data_reg);
s32 cmdqRecReadToDataRegister(struct cmdqRecStruct *handle, u32 hw_addr,
enum cmdq_gpr_reg dst_data_reg);
/* Write a register value from a CMDQ general purpose register(GPR)
* Parameter:
* handle: the command queue recorder handle
* src_data_reg: CMDQ GPR to read from
* hw_addr: register address to write to
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_write_from_data_register(struct cmdqRecStruct *handle,
enum cmdq_gpr_reg src_data_reg, u32 hw_addr);
s32 cmdqRecWriteFromDataRegister(struct cmdqRecStruct *handle,
enum cmdq_gpr_reg src_data_reg, u32 hw_addr);
struct cmdq_command_buffer {
void *va_base;
u32 avail_buf_size;
};
s32 cmdq_op_poll_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, u32 addr,
CMDQ_VARIABLE value, u32 mask);
s32 cmdq_op_read_reg_to_mem_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 addr);
s32 cmdq_op_write_reg_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, u32 addr,
CMDQ_VARIABLE value, u32 mask);
s32 cmdq_op_wait_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, enum cmdq_event event);
s32 cmdq_op_wait_no_clear_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, enum cmdq_event event);
s32 cmdq_op_clear_event_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, enum cmdq_event event);
s32 cmdq_op_set_event_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, enum cmdq_event event);
s32 cmdq_op_acquire_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, enum cmdq_event event);
s32 cmdq_op_write_from_reg_ex(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf, u32 write_reg, u32 from_reg);
s32 cmdq_handle_flush_cmd_buf(struct cmdqRecStruct *handle,
struct cmdq_command_buffer *cmd_buf);
s32 cmdq_alloc_write_addr(u32 count, dma_addr_t *paStart, u32 clt, void *fp);
s32 cmdq_free_write_addr(dma_addr_t paStart, u32 clt);
s32 cmdq_free_write_addr_by_node(u32 clt, void *fp);
/* Allocate 32-bit register backup slot
*/
s32 cmdq_alloc_mem(cmdqBackupSlotHandle *p_h_backup_slot, u32 slotCount);
s32 cmdqBackupAllocateSlot(cmdqBackupSlotHandle *p_h_backup_slot,
u32 slotCount);
/* Read 32-bit register backup slot by index
*/
s32 cmdq_cpu_read_mem(cmdqBackupSlotHandle h_backup_slot, u32 slot_index,
u32 *value);
s32 cmdqBackupReadSlot(cmdqBackupSlotHandle h_backup_slot, u32 slot_index,
u32 *value);
/* Use CPU to write value into 32-bit register backup slot by index directly.
*/
s32 cmdq_cpu_write_mem(cmdqBackupSlotHandle h_backup_slot,
u32 slot_index, u32 value);
s32 cmdqBackupWriteSlot(cmdqBackupSlotHandle h_backup_slot, u32 slot_index,
u32 value);
/* Free allocated backup slot. DO NOT free them before corresponding
* task finishes. Becareful on AsyncFlush use cases.
*/
s32 cmdq_free_mem(cmdqBackupSlotHandle h_backup_slot);
s32 cmdqBackupFreeSlot(cmdqBackupSlotHandle h_backup_slot);
/* Insert instructions to backup given 32-bit HW register
* to a backup slot.
* You can use cmdq_cpu_read_mem() to retrieve the result
* AFTER cmdq_task_flush() returns, or INSIDE the callback of
* cmdq_task_flush_async_callback().
*/
s32 cmdq_op_read_reg_to_mem(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 addr);
s32 cmdqRecBackupRegisterToSlot(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 addr);
/* Insert instructions to write 32-bit HW register
* from a backup slot.
* You can use cmdq_cpu_read_mem() to retrieve the result
* AFTER cmdq_task_flush() returns, or INSIDE the callback of
* cmdq_task_flush_async_callback().
*/
s32 cmdq_op_read_mem_to_reg(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 addr);
s32 cmdqRecBackupWriteRegisterFromSlot(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 addr);
/* Insert instructions to update slot with given 32-bit value
* You can use cmdq_cpu_read_mem() to retrieve the result
* AFTER cmdq_task_flush() returns, or INSIDE the callback of
* cmdq_task_flush_async_callback().
*/
s32 cmdq_op_write_mem(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 value);
s32 cmdqRecBackupUpdateSlot(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 value);
s32 cmdq_op_finalize_command(struct cmdqRecStruct *handle, bool loop);
void cmdq_task_prepare(struct cmdqRecStruct *handle);
void cmdq_task_unprepare(struct cmdqRecStruct *handle);
s32 cmdq_task_update_property(struct cmdqRecStruct *handle,
void *prop_addr, u32 prop_size);
/* Trigger CMDQ to execute the recorded commands
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
* Note:
* This is a synchronous function. When the function
* returned, the recorded commands have been done.
*/
s32 cmdq_task_flush(struct cmdqRecStruct *handle);
s32 cmdqRecFlush(struct cmdqRecStruct *handle);
/* Flush the command; Also at the end of the command, backup registers
* appointed by addrArray.
*/
s32 cmdq_task_append_backup_reg(struct cmdqRecStruct *handle,
u32 reg_count, u32 *addrs);
s32 cmdq_task_flush_and_read_register(struct cmdqRecStruct *handle,
u32 reg_count, u32 *addrs, u32 *values_out);
s32 cmdqRecFlushAndReadRegister(struct cmdqRecStruct *handle,
u32 reg_count, u32 *addrs, u32 *values_out);
/* Trigger CMDQ to asynchronously execute the recorded commands
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for successfully start execution; else the error code is returned
* Note:
* This is an ASYNC function. When the function
* returned, it may or may not be finished. There is no way to retrieve
* the result.
*/
s32 cmdq_task_flush_async(struct cmdqRecStruct *handle);
s32 cmdqRecFlushAsync(struct cmdqRecStruct *handle);
s32 cmdq_task_flush_async_callback(struct cmdqRecStruct *handle,
CmdqAsyncFlushCB callback, u64 user_data);
s32 cmdq_task_flush_async_destroy(struct cmdqRecStruct *handle);
s32 cmdqRecFlushAsyncCallback(struct cmdqRecStruct *handle,
CmdqAsyncFlushCB callback, u64 user_data);
/* Trigger CMDQ to execute the recorded commands in loop.
* each loop completion generates callback in interrupt context.
*
* Parameter:
* handle: the command queue recorder handle
* irqCallback: this CmdqInterruptCB callback is called after each loop
* completion.
* data: user data, this will pass back to irqCallback
* hLoop: output, a handle used to stop this loop.
*
* Return:
* 0 for success; else the error code is returned
*
* Note:
* This is an asynchronous function. When the function
* returned, the thread has started. Return -1 in irqCallback to stop it.
*/
s32 cmdq_task_start_loop(struct cmdqRecStruct *handle);
/* Unconditionally stops the loop thread.
* Must call after cmdq_task_start_loop().
*/
s32 cmdq_task_stop_loop(struct cmdqRecStruct *handle);
/* returns current count of instructions in given handle
*/
s32 cmdq_task_get_inst_cnt(struct cmdqRecStruct *handle);
s32 cmdqRecGetInstructionCount(struct cmdqRecStruct *handle);
/* Record timestamp while CMDQ HW executes here
* This is for prfiling purpose.
*
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_profile_marker(struct cmdqRecStruct *handle, const char *tag);
s32 cmdqRecProfileMarker(struct cmdqRecStruct *handle, const char *tag);
/* Dump command buffer to kernel log
* This is for debugging purpose.
*/
s32 cmdqRecDumpCommand(struct cmdqRecStruct *handle);
/* Destroy command queue recorder handle
* Parameter:
* handle: the command queue recorder handle
*/
void cmdq_ref_init(struct cmdqRecStruct *handle);
void cmdq_task_use(struct cmdqRecStruct *handle);
void cmdq_task_destroy(struct cmdqRecStruct *handle);
void cmdq_task_destroy_handle(struct kref *kref);
void cmdqRecDestroy(struct cmdqRecStruct *handle);
/* Change instruction of index to NOP instruction
* Current NOP is [JUMP + 8]
*
* Parameter:
* handle: the command queue recorder handle
* index: the index of replaced instruction (start from 0)
* Return:
* > 0 (index) for success; else the error code is returned
*/
s32 cmdq_op_set_nop(struct cmdqRecStruct *handle, u32 index);
s32 cmdqRecSetNOP(struct cmdqRecStruct *handle, u32 index);
/* Query offset of instruction by instruction name
*
* Parameter:
* handle: the command queue recorder handle
* startIndex: Query offset from "startIndex" of instruction (start from 0)
* opCode: instruction name you can use the following 6 instruction names:
* CMDQ_CODE_WFE: create via cmdq_op_wait()
* CMDQ_CODE_SET_TOKEN: create via cmdq_op_set_event()
* CMDQ_CODE_WAIT_NO_CLEAR: create via cmdq_op_wait_no_clear()
* CMDQ_CODE_CLEAR_TOKEN: create via cmdq_op_clear_event()
* event: the desired event type to set, clear, or wait
* Return:
* > 0 (index) for offset of instruction; else the error code is returned
*/
s32 cmdq_task_query_offset(struct cmdqRecStruct *handle, u32 startIndex,
const enum cmdq_code opCode, enum cmdq_event event);
s32 cmdqRecQueryOffset(struct cmdqRecStruct *handle, u32 startIndex,
const enum cmdq_code opCode, enum cmdq_event event);
/* acquire resource by resourceEvent
* Parameter:
* handle: the command queue recorder handle
* resourceEvent: the event of resource to control in GCE thread
* Return:
* 0 for success; else the error code is returned
* Note:
* mutex protected, be careful
*/
s32 cmdq_resource_acquire(struct cmdqRecStruct *handle,
enum cmdq_event resourceEvent);
s32 cmdqRecAcquireResource(struct cmdqRecStruct *handle,
enum cmdq_event resourceEvent);
/* acquire resource by resourceEvent and ALSO ADD write instruction to use
* resource
* Parameter:
* handle: the command queue recorder handle
* resourceEvent: the event of resource to control in GCE thread
* addr, value, mask: same as cmdq_op_write_reg
* Return:
* 0 for success; else the error code is returned
* Note:
* mutex protected, be careful
* Order: CPU clear resourceEvent at first, then add write instruction
*/
s32 cmdq_resource_acquire_and_write(struct cmdqRecStruct *handle,
enum cmdq_event resourceEvent, u32 addr, u32 value, u32 mask);
s32 cmdqRecWriteForResource(struct cmdqRecStruct *handle,
enum cmdq_event resourceEvent, u32 addr, u32 value, u32 mask);
/* Release resource by ADD INSTRUCTION to set event
* Parameter:
* handle: the command queue recorder handle
* resourceEvent: the event of resource to control in GCE thread
* Return:
* 0 for success; else the error code is returned
* Note:
* mutex protected, be careful
* Remember to flush handle after this API to release resource via GCE
*/
s32 cmdq_resource_release(struct cmdqRecStruct *handle,
enum cmdq_event resourceEvent);
s32 cmdqRecReleaseResource(struct cmdqRecStruct *handle,
enum cmdq_event resourceEvent);
/* Release resource by ADD INSTRUCTION to set event
* Parameter:
* handle: the command queue recorder handle
* resourceEvent: the event of resource to control in GCE thread
* addr, value, mask: same as cmdq_op_write_reg
* Return:
* 0 for success; else the error code is returned
* Note:
* mutex protected, be careful
* Order: Add add write instruction at first, then set resourceEvent
* instruction
* Remember to flush handle after this API to release resource via GCE
*/
s32 cmdq_resource_release_and_write(struct cmdqRecStruct *handle,
enum cmdq_event resourceEvent, u32 addr, u32 value, u32 mask);
s32 cmdqRecWriteAndReleaseResource(struct cmdqRecStruct *handle,
enum cmdq_event resourceEvent, u32 addr, u32 value, u32 mask);
s32 cmdq_task_create_delay_thread_dram(void **pp_delay_thread_buffer,
u32 *buffer_size);
s32 cmdq_task_create_delay_thread_sram(void **pp_delay_thread_buffer,
u32 *buffer_size, u32 *cpr_offset);
/* Initialize the logical variable
* Parameter:
* arg: the variable you want to Initialize
*/
void cmdq_op_init_variable(CMDQ_VARIABLE *arg);
/* Initialize the logical variable
* Parameter:
* arg: the variable you want to Initialize
* cpr_offset: the cpr offset you want to use
*/
void cmdq_op_init_global_cpr_variable(CMDQ_VARIABLE *arg, u32 cpr_offset);
/* Append logic command for assign
* arg_out = arg_b
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_in: the specified GCE CPR or value
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_assign(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_in);
/* Append logic command for addition
* arg_out = arg_b + arg_c
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* arg_c: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_add(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
/* Append logic command for subtraction
* arg_out = arg_b - arg_c
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* arg_c: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_subtract(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
/* Append logic command for multiplication
* arg_out = arg_b * arg_c
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* arg_c: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_multiply(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
/* Append logic command for exclusive or operation
* arg_out = arg_b ^ arg_c
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* arg_c: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_xor(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
/* Append logic command for not operation
* arg_out = ~arg_b
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_not(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b);
/* Append logic command for or operation
* arg_out = arg_b | arg_c
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* arg_c: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_or(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
/* Append logic command for or operation
* arg_out = arg_b & arg_c
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* arg_c: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_and(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
/* Append logic command for left shift operation
* arg_out = arg_b << arg_c
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* arg_c: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_left_shift(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
/* Append logic command for left right operation
* arg_out = arg_b >> arg_c
* Parameter:
* handle: the command queue recorder handle
* arg_out: the output value save in GCE CPR
* arg_b: the value who use to do logical operation
* arg_c: the value who use to do logical operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_right_shift(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
/* Append commands for delay (micro second)
* Parameter:
* handle: the command queue recorder handle
* delay_time: delay time in us
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_delay_us(struct cmdqRecStruct *handle, u32 delay_time);
s32 cmdq_op_backup_CPR(struct cmdqRecStruct *handle, CMDQ_VARIABLE cpr,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index);
s32 cmdq_op_backup_TPR(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index);
/* Append if statement command
* if (arg_b condition arg_c)
* Parameter:
* handle: the command queue recorder handle
* arg_b: the value who use to do conditional operation
* arg_condition: conditional operator
* arg_c: the value who use to do conditional operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_if(struct cmdqRecStruct *handle, CMDQ_VARIABLE arg_b,
enum CMDQ_CONDITION_ENUM arg_condition, CMDQ_VARIABLE arg_c);
/* Append end if statement command
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_end_if(struct cmdqRecStruct *handle);
/* Append else statement command
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_else(struct cmdqRecStruct *handle);
/* Append if statement command
* else if (arg_b condition arg_c)
* Parameter:
* handle: the command queue recorder handle
* arg_b: the value who use to do conditional operation
* arg_condition: conditional operator
* arg_c: the value who use to do conditional operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_else_if(struct cmdqRecStruct *handle, CMDQ_VARIABLE arg_b,
enum CMDQ_CONDITION_ENUM arg_condition, CMDQ_VARIABLE arg_c);
/* Append while statement command
* Parameter:
* handle: the command queue recorder handle
* arg_b: the value who use to do conditional operation
* arg_condition: conditional operator
* arg_c: the value who use to do conditional operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_while(struct cmdqRecStruct *handle, CMDQ_VARIABLE arg_b,
enum CMDQ_CONDITION_ENUM arg_condition, CMDQ_VARIABLE arg_c);
/* Append continue statement command into while loop
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_continue(struct cmdqRecStruct *handle);
/* Append break statement command into while loop
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_break(struct cmdqRecStruct *handle);
/* Append end while statement command
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_end_while(struct cmdqRecStruct *handle);
/* Append do-while statement command
* Parameter:
* handle: the command queue recorder handle
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_do_while(struct cmdqRecStruct *handle);
/* Append end do while statement command
* Parameter:
* handle: the command queue recorder handle
* arg_b: the value who use to do conditional operation
* arg_condition: conditional operator
* arg_c: the value who use to do conditional operation
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_end_do_while(struct cmdqRecStruct *handle, CMDQ_VARIABLE arg_b,
enum CMDQ_CONDITION_ENUM arg_condition, CMDQ_VARIABLE arg_c);
/* Linux like wait_event_timeout
* Parameter:
* handle: the command queue recorder handle
* arg_out, wait result (=0: timeout, >0: wait time when got event)
* wait_event: GCE event
* timeout_time: timeout time in us
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_wait_event_timeout(struct cmdqRecStruct *handle,
CMDQ_VARIABLE *arg_out, enum cmdq_event wait_event,
u32 timeout_time);
/* Append write command to the recorder
* Parameter:
* handle: the command queue recorder handle
* addr: the specified source register physical address
* arg_out: the value will be save in GCE CPR
* mask: the specified target register mask
* Return:
* 0 for success; else the error code is returned
*/
s32 cmdq_op_read_reg(struct cmdqRecStruct *handle, u32 addr,
CMDQ_VARIABLE *arg_out, u32 mask);
/* Insert instructions to write to CMDQ variable
* from a backup memory.
*/
s32 cmdq_op_read_mem(struct cmdqRecStruct *handle,
cmdqBackupSlotHandle h_backup_slot, u32 slot_index,
CMDQ_VARIABLE *arg_out);
#endif /* __CMDQ_RECORD_H__ */
File diff suppressed because it is too large. Load diff
+285
View File
@@ -0,0 +1,285 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_COMMON_H__
#define __MDP_COMMON_H__
#include "mdp_def.h"
#include "mdp_def_ex.h"
#include "mdp_cmdq_helper_ext.h"
#include <linux/types.h>
#ifdef CONFIG_MTK_SMI_EXT
/* translate port */
typedef uint32_t (*CmdqTranslatePort) (uint32_t engineId);
/* get request */
typedef struct mm_qos_request *(*CmdqGetRequest) (
uint32_t thread_id, uint32_t port);
/* init pmqos mdp */
typedef void (*CmdqInitPmqosMdp) (s32 index, struct plist_head *owner_list);
/* init pmqos isp */
typedef void (*CmdqInitPmqosIsp) (s32 index, struct plist_head *owner_list);
#endif /* CONFIG_MTK_SMI_EXT */
#ifdef CMDQ_SECURE_PATH_SUPPORT
extern const u32 isp_iwc_buf_size[];
#endif
/* dump mmsys config */
typedef void (*CmdqDumpMMSYSConfig) (void);
/* query MDP clock is on */
typedef bool(*CmdqMdpClockIsOn) (enum CMDQ_ENG_ENUM engine);
/* enable MDP clock */
typedef void (*CmdqEnableMdpClock) (bool enable, enum CMDQ_ENG_ENUM engine);
/* Common Clock Framework */
typedef void (*CmdqMdpInitModuleClk) (void);
/* MDP callback function */
typedef s32(*CmdqMdpClockOn) (u64 engineFlag);
typedef s32(*CmdqMdpDumpInfo) (u64 engineFlag, int level);
typedef s32(*CmdqMdpResetEng) (u64 engineFlag);
typedef s32(*CmdqMdpClockOff) (u64 engineFlag);
/* MDP Initialization setting */
typedef void(*CmdqMdpInitialSet) (void);
/* Initialization & de-initialization MDP base VA */
typedef void (*CmdqMdpInitModuleBaseVA) (void);
typedef void (*CmdqMdpDeinitModuleBaseVA) (void);
/* MDP engine dump */
typedef void (*CmdqMdpDumpRSZ) (const unsigned long base, const char *label);
typedef void (*CmdqMdpDumpTDSHP) (const unsigned long base, const char *label);
/* test MDP clock function */
typedef u32(*CmdqMdpRdmaGetRegOffsetSrcAddr) (void);
typedef u32(*CmdqMdpWrotGetRegOffsetDstAddr) (void);
typedef u32(*CmdqMdpWdmaGetRegOffsetDstAddr) (void);
typedef void (*CmdqTestcaseClkmgrMdp) (void);
typedef const char*(*CmdqDispatchModule) (u64 engineFlag);
typedef void (*CmdqTrackTask) (const struct cmdqRecStruct *task);
typedef const char *(*CmdqPraseErrorModByEngFlag) (
const struct cmdqRecStruct *task);
typedef const char *(*CmdqPraseHandleErrorModByEngFlag) (
const struct cmdqRecStruct *handle);
typedef u64 (*CmdqMdpGetEngineGroupBits) (u32 engine_group);
typedef s32 (*CmdqMdpEnableCommonClock) (bool enable);
typedef void (*CmdqCheckHwStatus) (struct cmdqRecStruct *handle);
typedef u64(*CmdqMdpGetSecEngine) (u64 engine_flag);
typedef void (*CmdqMdpResolveToken) (u64 engine_flag,
const struct cmdqRecStruct *task);
typedef void (*CmdqMdpComposeReadback) (struct cmdqRecStruct *handle,
u16 engine, dma_addr_t dma, u32 param);
typedef void (*CmdqMdpReadbackEngine) (struct cmdqRecStruct *handle,
u16 engine, phys_addr_t base, dma_addr_t pa, u32 param);
struct cmdqMDPFuncStruct {
#ifdef CONFIG_MTK_SMI_EXT
CmdqTranslatePort translatePort;
CmdqGetRequest getRequest;
CmdqInitPmqosMdp initPmqosMdp;
CmdqInitPmqosIsp initPmqosIsp;
#endif /* CONFIG_MTK_SMI_EXT */
CmdqDumpMMSYSConfig dumpMMSYSConfig;
CmdqMdpInitModuleBaseVA initModuleBaseVA;
CmdqMdpDeinitModuleBaseVA deinitModuleBaseVA;
CmdqMdpClockIsOn mdpClockIsOn;
CmdqEnableMdpClock enableMdpClock;
CmdqMdpInitModuleClk initModuleCLK;
CmdqMdpDumpRSZ mdpDumpRsz;
CmdqMdpDumpTDSHP mdpDumpTdshp;
CmdqMdpClockOn mdpClockOn;
CmdqMdpDumpInfo mdpDumpInfo;
CmdqMdpResetEng mdpResetEng;
CmdqMdpClockOff mdpClockOff;
CmdqMdpInitialSet mdpInitialSet;
CmdqMdpRdmaGetRegOffsetSrcAddr rdmaGetRegOffsetSrcAddr;
CmdqMdpWrotGetRegOffsetDstAddr wrotGetRegOffsetDstAddr;
CmdqMdpWdmaGetRegOffsetDstAddr wdmaGetRegOffsetDstAddr;
CmdqTestcaseClkmgrMdp testcaseClkmgrMdp;
CmdqDispatchModule dispatchModule;
CmdqTrackTask trackTask;
CmdqPraseErrorModByEngFlag parseErrModByEngFlag;
CmdqPraseHandleErrorModByEngFlag parseHandleErrModByEngFlag;
CmdqMdpGetEngineGroupBits getEngineGroupBits;
CmdqErrorResetCB errorReset;
CmdqMdpEnableCommonClock mdpEnableCommonClock;
CmdqBeginTaskCB beginTask;
CmdqEndTaskCB endTask;
CmdqBeginTaskCB beginISPTask;
CmdqEndTaskCB endISPTask;
CmdqCheckHwStatus CheckHwStatus;
CmdqMdpGetSecEngine mdpGetSecEngine;
CmdqMdpResolveToken resolve_token;
CmdqMdpComposeReadback mdpComposeReadback;
CmdqMdpReadbackEngine mdpReadbackAal;
CmdqMdpReadbackEngine mdpReadbackHdr;
};
struct mdp_pmqos_record {
uint32_t mdp_throughput;
struct timeval submit_tm;
struct timeval end_tm;
};
/* track MDP task */
#define DEBUG_STR_LEN 1024 /* debug str length */
#define MDP_MAX_TASK_NUM 5 /* num of tasks to be keep */
#define MDP_MAX_PLANE_NUM 3 /* max color format plane num */
/* each plane has 2 info address and size */
#define MDP_PORT_BUF_INFO_NUM (MDP_MAX_PLANE_NUM * 2)
#define MDP_BUF_INFO_STR_LEN 8 /* each buf info length */
/* dispatch key format is MDP_(ThreadName) */
#define MDP_DISPATCH_KEY_STR_LEN (TASK_COMM_LEN + 5)
#define MDP_TOTAL_THREAD 16
#ifdef CMDQ_SECURE_PATH_SUPPORT
#define MDP_THREAD_START (CMDQ_MIN_SECURE_THREAD_ID + 2)
#define MDP_MAX_METADATA_COUNT_SIZE ( \
(0xFFFFFFFF) / (sizeof(struct cmdqSecAddrMetadataStruct)))
#else
#define MDP_THREAD_START CMDQ_DYNAMIC_THREAD_ID_START
#endif
/* MDP common kernel logic */
void cmdq_mdp_fix_command_scenario_for_user_space(
struct cmdqCommandStruct *command);
bool cmdq_mdp_is_request_from_user_space(
const enum CMDQ_SCENARIO_ENUM scenario);
s32 cmdq_mdp_query_usage(s32 *counters);
s32 cmdq_mdp_get_smi_usage(void);
void cmdq_mdp_reset_resource(void);
void cmdq_mdp_dump_thread_usage(void);
void cmdq_mdp_dump_engine_usage(void);
void cmdq_mdp_dump_resource(u32 event);
void cmdq_mdp_init_resource(u32 engine_id,
enum cmdq_event res_event);
void cmdq_mdp_enable_res(u64 engine_flag, bool enable);
void cmdq_mdp_lock_resource(u64 engine_flag, bool from_notify);
bool cmdq_mdp_acquire_resource(enum cmdq_event res_event,
u64 *engine_flag_out);
void cmdq_mdp_release_resource(enum cmdq_event res_event,
u64 *engine_flag_out);
void cmdq_mdp_set_resource_callback(enum cmdq_event res_event,
CmdqResourceAvailableCB res_available,
CmdqResourceReleaseCB res_release);
void cmdq_mdp_unlock_thread(struct cmdqRecStruct *handle);
void cmdq_mdp_op_readback(struct cmdqRecStruct *handle, u16 engine,
dma_addr_t dma, u32 param);
s32 cmdq_mdp_flush_async(struct cmdqCommandStruct *desc, bool user_space,
struct cmdqRecStruct **handle_out);
s32 cmdq_mdp_flush_async_impl(struct cmdqRecStruct *handle);
struct cmdqRecStruct *cmdq_mdp_get_valid_handle(unsigned long job);
s32 cmdq_mdp_wait(struct cmdqRecStruct *handle,
struct cmdqRegValueStruct *results);
s32 cmdq_mdp_flush(struct cmdqCommandStruct *desc, bool user_space);
void cmdq_mdp_suspend(void);
void cmdq_mdp_resume(void);
void cmdq_mdp_release_task_by_file_node(void *file_node);
void cmdq_mdp_init(struct platform_device *pdev);
void cmdq_mdp_deinit_pmqos(void);
s32 cmdq_mdp_handle_create(struct cmdqRecStruct **handle_out);
s32 cmdq_mdp_handle_flush(struct cmdqRecStruct *handle);
s32 cmdq_mdp_handle_sec_setup(struct cmdqSecDataStruct *secData,
struct cmdqRecStruct *handle);
void cmdq_mdp_init_secure_id(void *meta_array, u32 count);
s32 cmdq_mdp_update_sec_addr_index(struct cmdqRecStruct *handle,
u32 sec_handle, u32 index, u32 instr_index);
u32 cmdq_mdp_handle_get_instr_count(struct cmdqRecStruct *handle);
void cmdq_mdp_meta_replace_sec_addr(struct op_meta *metas,
struct mdp_submit *user_job,
struct cmdqRecStruct *handle);
/* Platform dependent function */
void cmdq_mdp_virtual_function_setting(void);
void cmdq_mdp_map_mmsys_VA(void);
long cmdq_mdp_get_module_base_VA_MMSYS_CONFIG(void);
void cmdq_mdp_unmap_mmsys_VA(void);
struct cmdqMDPFuncStruct *cmdq_mdp_get_func(void);
void cmdq_mdp_enable(u64 engineFlag, enum CMDQ_ENG_ENUM engine);
int cmdq_mdp_loop_reset(enum CMDQ_ENG_ENUM engine,
const unsigned long resetReg,
const unsigned long resetStateReg,
const u32 resetMask,
const u32 resetValue, const bool pollInitResult);
void cmdq_mdp_loop_off(enum CMDQ_ENG_ENUM engine,
const unsigned long resetReg,
const unsigned long resetStateReg,
const u32 resetMask,
const u32 resetValue, const bool pollInitResult);
const char *cmdq_mdp_get_rsz_state(const u32 state);
void cmdq_mdp_dump_venc(const unsigned long base, const char *label);
void cmdq_mdp_dump_rdma(const unsigned long base, const char *label);
void cmdq_mdp_dump_rot(const unsigned long base, const char *label);
void cmdq_mdp_dump_color(const unsigned long base, const char *label);
void cmdq_mdp_dump_wdma(const unsigned long base, const char *label);
void cmdq_mdp_check_TF_address(unsigned int mva, char *module);
const char *cmdq_mdp_parse_error_module_by_hwflag(
const struct cmdqRecStruct *task);
const char *cmdq_mdp_parse_handle_error_module_by_hwflag(
const struct cmdqRecStruct *handle);
/* Platform dependent function */
s32 cmdqMdpClockOn(u64 engineFlag);
s32 cmdqMdpDumpInfo(u64 engineFlag, int level);
s32 cmdqMdpResetEng(u64 engineFlag);
s32 cmdqMdpClockOff(u64 engineFlag);
u32 cmdq_mdp_rdma_get_reg_offset_src_addr(void);
u32 cmdq_mdp_wrot_get_reg_offset_dst_addr(void);
u32 cmdq_mdp_wdma_get_reg_offset_dst_addr(void);
void testcase_clkmgr_mdp(void);
u32 cmdq_mdp_get_hw_reg(enum MDP_ENG_BASE base, u16 offset);
u32 cmdq_mdp_get_hw_port(enum MDP_ENG_BASE base);
/* Platform virtual function setting */
void cmdq_mdp_platform_function_setting(void);
long cmdq_mdp_get_module_base_VA_MDP_WROT0(void);
#endif /* __MDP_COMMON_H__ */
+474
View File
@@ -0,0 +1,474 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_DEF_H__
#define __MDP_DEF_H__
#include <linux/kernel.h>
#include <linux/soc/mediatek/mtk-cmdq.h>
#include "cmdq_subsys_common.h"
#include "mdp_event_common.h"
#define MDP_DRIVER_DEVICE_NAME "mtk_mdp"
/* #define MDP_COMMON_ENG_SUPPORT */
#ifdef MDP_COMMON_ENG_SUPPORT
#include "mdp_engine_common.h"
#else
#include "mdp_engine.h"
#endif
#define CMDQ_SPECIAL_SUBSYS_ADDR (99)
#define CMDQ_GPR_SUPPORT
#define CMDQ_MAX_PROFILE_MARKER_IN_TASK (5)
#define CMDQ_INVALID_THREAD (-1)
#define CMDQ_MAX_THREAD_COUNT (24)
#define CMDQ_MAX_TASK_IN_THREAD (16)
#define CMDQ_MAX_READ_SLOT_COUNT (4)
#define CMDQ_INIT_FREE_TASK_COUNT (8)
/* Thread that are high-priority (display threads) */
#define CMDQ_MAX_HIGH_PRIORITY_THREAD_COUNT (8)
#define CMDQ_MIN_SECURE_THREAD_ID (CMDQ_MAX_HIGH_PRIORITY_THREAD_COUNT)
#if IS_ENABLED(CONFIG_MACH_MT6779) || IS_ENABLED(CONFIG_MACH_MT6785)
/* primary disp / secondary disp / mdp / isp fd */
#define CMDQ_MAX_SECURE_THREAD_COUNT (4)
#else
/* primary disp / secondary disp / mdp */
#define CMDQ_MAX_SECURE_THREAD_COUNT (3)
#endif
#ifdef CMDQ_SECURE_PATH_SUPPORT
#define CMDQ_DYNAMIC_THREAD_ID_START (CMDQ_MIN_SECURE_THREAD_ID + \
CMDQ_MAX_SECURE_THREAD_COUNT)
#else
#define CMDQ_DYNAMIC_THREAD_ID_START (CMDQ_MAX_HIGH_PRIORITY_THREAD_COUNT)
#endif
#define CMDQ_SEC_IRQ_THREAD 15
#define CMDQ_MAX_ERROR_COUNT (2)
#define CMDQ_MAX_RETRY_COUNT (1)
/* ram optimization related configuration */
#ifdef CONFIG_MTK_GMO_RAM_OPTIMIZE
#define CMDQ_MAX_RECORD_COUNT (64)
#else
#define CMDQ_MAX_RECORD_COUNT (128)
#endif
#define CMDQ_INITIAL_CMD_BLOCK_SIZE (PAGE_SIZE)
/* instruction is 64-bit */
#define CMDQ_DMA_POOL_COUNT 128
#define CMDQ_MAX_LOOP_COUNT (1000000)
#define CMDQ_MAX_INST_CYCLE (27)
#define CMDQ_MAX_ERROR_SIZE (8 * 1024)
#define CMDQ_MAX_TASK_IN_SECURE_THREAD (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
#define CMDQ_ARG_A_SUBSYS_MASK (0x001F0000)
#ifdef CONFIG_FPGA_EARLY_PORTING
#define CMDQ_DEFAULT_TIMEOUT_MS (10000)
#else
#define CMDQ_DEFAULT_TIMEOUT_MS (1000)
#endif
#define CMDQ_ACQUIRE_THREAD_TIMEOUT_MS (2000)
#define CMDQ_PREDUMP_TIMEOUT_MS (200)
#ifndef CONFIG_FPGA_EARLY_PORTING
#define CMDQ_PWR_AWARE /* FPGA does not have ClkMgr */
#else
#undef CMDQ_PWR_AWARE
#endif
typedef u64 CMDQ_VARIABLE;
/*
* SPR / CPR / VAR naming rule and number
**********************************************
* <- SPR -> <- CPR ->
* <reserved><FREE use > < FREE use >
* VAR# 0 1 2 3 4 5 6 7
* CPR# 0 1 2 3
*/
#define CMDQ_SPR_FOR_LOOP_DEBUG (1)
#define CMDQ_THR_SPR_START (2)
#define CMDQ_THR_FREE_CPR_MAX (4)
#define CMDQ_THR_FREE_USR_VAR_MAX (CMDQ_THR_SPR_MAX + \
CMDQ_THR_FREE_CPR_MAX)
#define CMDQ_SRAM_STRAT_ADDR (0x0)
#define CMDQ_GPR_V3_OFFSET (0x20)
#define CMDQ_POLLING_TPR_MASK_BIT (10)
#define CMDQ_SRAM_ADDR(CPR_OFFSRT) \
(((CMDQ_SRAM_STRAT_ADDR + CPR_OFFSRT / 2) << 3) + 0x001)
#define CMDQ_CPR_OFFSET(SRAM_ADDR) \
(((SRAM_ADDR >> 3) - CMDQ_SRAM_STRAT_ADDR) * 2)
#define CMDQ_INVALID_CPR_OFFSET (0xFFFFFFFF)
/* #define CMDQ_DUMP_GIC (0) */
#define CMDQ_DUMP_FIRSTERROR
/* #define CMDQ_INSTRUCTION_COUNT */
enum CMDQ_HW_THREAD_PRIORITY_ENUM {
CMDQ_THR_PRIO_SUPERLOW = 0, /* low priority monitor loop */
CMDQ_THR_PRIO_NORMAL = 1, /* nomral priority */
/* trigger loop (enables display mutex) */
CMDQ_THR_PRIO_DISPLAY_TRIGGER = 2,
/* display ESD check (every 2 secs) */
CMDQ_THR_PRIO_DISPLAY_ESD = 3,
/* display config (every frame) */
CMDQ_THR_PRIO_DISPLAY_CONFIG = 4,
CMDQ_THR_PRIO_SUPERHIGH = 5, /* High priority monitor loop */
CMDQ_THR_PRIO_MAX = 7, /* maximum possible priority */
};
enum CMDQ_SCENARIO_ENUM {
CMDQ_SCENARIO_PRIMARY_DISP = 1,
CMDQ_SCENARIO_SUB_DISP = 4,
/* Trigger loop scenario does not enable HWs */
CMDQ_SCENARIO_TRIGGER_LOOP = 11,
/* client from user space, so the cmd buffer is in user space. */
CMDQ_SCENARIO_USER_MDP = 12,
CMDQ_SCENARIO_DEBUG = 13,
CMDQ_SCENARIO_DEBUG_PREFETCH = 14,
/* color path request from user sapce */
CMDQ_SCENARIO_USER_DISP_COLOR = 21,
/* [phased out]client from user space,
* so the cmd buffer is in user space.
*/
CMDQ_SCENARIO_USER_SPACE = 22,
CMDQ_SCENARIO_TIMER_LOOP = 39,
/* debug scenario use mdp flush */
CMDQ_SCENARIO_DEBUG_MDP = 42,
/* for ISP kernel driver */
CMDQ_SCENARIO_ISP_RSC = 43,
CMDQ_SCENARIO_ISP_FDVT = 44,
CMDQ_SCENARIO_ISP_DPE = 45,
CMDQ_SCENARIO_ISP_FDVT_OFF = 46,
CMDQ_MAX_SCENARIO_COUNT /* ALWAYS keep at the end */
};
/* General Purpose Register */
enum cmdq_gpr_reg {
/* Value Reg, we use 32-bit
* Address Reg, we use 64-bit
* Note that R0-R15 and P0-P7 actullay share same memory
* and R1 cannot be used.
*/
CMDQ_DATA_REG_JPEG = 0x00, /* R0 */
CMDQ_DATA_REG_JPEG_DST = 0x11, /* P1 */
CMDQ_DATA_REG_PQ_COLOR = 0x04, /* R4 */
CMDQ_DATA_REG_PQ_COLOR_DST = 0x13, /* P3 */
CMDQ_DATA_REG_2D_SHARPNESS_0 = 0x05, /* R5 */
CMDQ_DATA_REG_2D_SHARPNESS_0_DST = 0x14, /* P4 */
CMDQ_DATA_REG_2D_SHARPNESS_1 = 0x0a, /* R10 */
CMDQ_DATA_REG_2D_SHARPNESS_1_DST = 0x16, /* P6 */
CMDQ_DATA_REG_DEBUG = 0x0b, /* R11 */
CMDQ_DATA_REG_DEBUG_DST = 0x17, /* P7 */
/* sentinel value for invalid register ID */
CMDQ_DATA_REG_INVALID = -1,
};
enum CMDQ_MDP_PA_BASE_ENUM {
CMDQ_MDP_PA_BASE_MM_MUTEX,
CMDQ_MAX_MDP_PA_BASE_COUNT, /* ALWAYS keep at the end */
};
enum DP_CMD_EXT {
DP_CMDEXT_AAL_DRE,
DP_CMDEXT_AAL_MULTIPIPE,
DP_CMDEXT_HDR,
DP_CMDEXT_VERIFY,
};
#define CMDQ_SUBSYS_GRPNAME_MAX (30)
/* GCE subsys information */
struct SubsysStruct {
uint32_t msb;
int32_t subsysID;
uint32_t mask;
char grpName[CMDQ_SUBSYS_GRPNAME_MAX];
};
struct cmdqDTSDataStruct {
/* [Out] GCE event table */
int32_t eventTable[CMDQ_SYNC_TOKEN_MAX];
/* [Out] GCE subsys ID table */
struct SubsysStruct subsys[CMDQ_SUBSYS_MAX_COUNT];
/* [Out] MDP Base address */
uint32_t MDPBaseAddress[CMDQ_MAX_MDP_PA_BASE_COUNT];
};
/* Custom "wide" pointer type for 64-bit job handle (pointer to VA)
* typedef unsigned long long cmdqJobHandle_t;
*/
#define cmdqJobHandle_t unsigned long long
/* Custom "wide" pointer type for 64-bit compatibility.
* Always cast from uint32_t*.
*/
#define cmdqU32Ptr_t unsigned long long
#define CMDQ_U32_PTR(x) ((uint32_t *)(unsigned long)x)
struct cmdqReadRegStruct {
/* number of entries in regAddresses */
uint32_t count;
/* an array of 32-bit register addresses (uint32_t) */
cmdqU32Ptr_t regAddresses;
};
struct cmdqRegValueStruct {
/* number of entries in result */
uint32_t count;
/* array of 32-bit register values (uint32_t). */
/* in the same order as cmdqReadRegStruct */
cmdqU32Ptr_t regValues;
};
#define CMDQ_MAX_READBACK_ENG 8
struct cmdqReadbackEngine {
uint32_t engine;
uint32_t start;
uint32_t count;
uint32_t param;
};
struct cmdqReadAddressStruct {
uint32_t count; /* [IN] number of entries in result. */
/* [IN] array of physical addresses to read.
* these value must allocated by
* CMDQ_IOCTL_ALLOC_WRITE_ADDRESS ioctl
*
* indeed param dmaAddresses should be UNSIGNED LONG type
* for 64 bit kernel.
* Considering our plartform supports
* max 4GB RAM(upper-32bit don't care for SW)
* and consistent common code interface, remain u32 type.
*/
cmdqU32Ptr_t dmaAddresses;
/* [OUT] u32 values that dmaAddresses point into */
cmdqU32Ptr_t values;
};
/*
* Secure address metadata:
* According to handle type,
* translate handle and replace (_d)th instruciton to
* 1. sec_addr = hadnle_sec_base_addr(baseHandle) + offset(_b)
* 2. sec_mva = mva( hadnle_sec_base_addr(baseHandle) + offset(_b) )
* 3. secure world normal mva = map(baseHandle)
* . pass normal mva to parameter baseHandle
* . use case: OVL reads from secure and normal buffers
* at the same time)
*/
enum CMDQ_SEC_ADDR_METADATA_TYPE {
CMDQ_SAM_H_2_PA = 0, /* sec handle to sec PA */
CMDQ_SAM_H_2_MVA = 1, /* sec handle to sec MVA */
CMDQ_SAM_NMVA_2_MVA = 2, /* map normal MVA to secure world */
CMDQ_SAM_PH_2_MVA = 3, /* protected handle to sec MVA */
};
struct cmdqSecAddrMetadataStruct {
/* [IN]_d, index of instruction.
* Update its arg_b value to real PA/MVA in secure world
*/
uint32_t instrIndex;
/*
* Note: Buffer and offset
*
* -------------
* | | |
* -------------
* ^ ^ ^ ^
* A B C D
*
* A: baseHandle
* B: baseHandle + blockOffset
* C: baseHandle + blockOffset + offset
* A~B or B~D: size
*/
uint32_t type; /* [IN] addr handle type */
uint64_t baseHandle; /* [IN]_h, secure address handle */
/* [IN]_b, block offset from handle(PA) to current block(plane) */
uint32_t blockOffset;
uint32_t offset; /* [IN]_b, buffser offset to secure handle */
uint32_t size; /* buffer size */
uint32_t port; /* hw port id (i.e. M4U port id) */
uint32_t sec_id; /* sec_id 0/1/3: secure camera/SVP/WFD */
uint32_t useSecIdinMeta;
int32_t ionFd;
};
struct cmdqMetaBuf {
uint64_t va;
uint64_t size;
};
#define CMDQ_ISP_META_CNT 8
struct cmdqSecIspMeta {
struct cmdqMetaBuf ispBufs[CMDQ_ISP_META_CNT];
uint64_t CqSecHandle;
uint32_t CqSecSize;
uint32_t CqDesOft;
uint32_t CqVirtOft;
uint64_t TpipeSecHandle;
uint32_t TpipeSecSize;
uint32_t TpipeOft;
uint64_t BpciHandle;
uint64_t LsciHandle;
uint64_t LceiHandle;
uint64_t DepiHandle;
uint64_t DmgiHandle;
};
/* client extension bits for cmdq secure driver
* must sync with iwc header sec_extension_iwc
*/
enum sec_extension {
SEC_MDP_AAL = 0,
SEC_TDSHP
};
struct cmdqSecDataStruct {
bool is_secure; /* [IN]true for secure command */
/* address metadata, used to translate secure buffer PA
* related instruction in secure world
*/
uint32_t addrMetadataCount; /* [IN] count of element in addrList */
/* [IN] array of cmdqSecAddrMetadataStruct */
cmdqU32Ptr_t addrMetadatas;
uint32_t addrMetadataMaxCount; /*[Reserved] */
uint64_t enginesNeedDAPC;
uint64_t enginesNeedPortSecurity;
/* [Reserved] This is for CMDQ driver usage itself. Not for client.
* task index in thread's tasklist. -1 for not in tasklist.
*/
int32_t waitCookie;
/* reset HW thread in SWd */
bool resetExecCnt;
/* ISP metadata for secure camera */
struct cmdqSecIspMeta ispMeta;
/* client extension feature */
uint64_t extension;
};
struct cmdq_v3_replace_struct {
/* [IN] count of element in instr_position */
uint32_t number;
/* [IN] position of instruction */
cmdqU32Ptr_t position;
};
struct cmdqProfileMarkerStruct {
uint32_t count;
/* i.e. cmdqBackupSlotHandle, physical start address of backup slot */
long long hSlot;
cmdqU32Ptr_t tag[CMDQ_MAX_PROFILE_MARKER_IN_TASK];
};
struct cmdqCommandStruct {
/* [IN] deprecated. will remove in the future. */
uint32_t scenario;
/* [IN] task schedule priority. this is NOT HW thread priority. */
uint32_t priority;
/* [IN] bit flag of engines used. */
uint64_t engineFlag;
/* [IN] pointer to instruction buffer. Use 64-bit for compatibility. */
/* This must point to an 64-bit aligned uint32_t array */
cmdqU32Ptr_t pVABase;
/* [IN] size of instruction buffer, in bytes. */
uint32_t blockSize;
/* [IN] request to read register values at the end of command */
struct cmdqReadRegStruct regRequest;
/* [OUT] register values of regRequest */
struct cmdqRegValueStruct regValue;
/* [IN/OUT] physical addresses to read value */
struct cmdqReadAddressStruct readAddress;
/* [IN] secure execution data */
struct cmdqSecDataStruct secData;
/* [IN] CPR position */
struct cmdq_v3_replace_struct replace_instr;
/* [IN] set to non-zero to enable register debug dump. */
uint32_t debugRegDump;
/* [Reserved] This is for CMDQ driver usage itself.
* Not for client. Do not access this field from User Space
*/
cmdqU32Ptr_t privateData;
/* task property */
uint32_t prop_size;
cmdqU32Ptr_t prop_addr;
struct cmdqProfileMarkerStruct profileMarker;
cmdqU32Ptr_t userDebugStr;
uint32_t userDebugStrLen;
};
enum CMDQ_CAP_BITS {
/* bit 0: TRUE if WFE instruction support is ready.
* FALSE if we need to POLL instead.
*/
CMDQ_CAP_WFE = 0,
};
/* reply struct for cmdq_sec_cancel_error_task */
struct cmdqSecCancelTaskResultStruct {
/* [OUT] */
bool throwAEE;
bool hasReset;
int32_t irqFlag;
uint32_t errInstr[2];
uint32_t regValue;
uint32_t pc;
};
#endif /* __MDP_DEF_H__ */
+175
View File
@@ -0,0 +1,175 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_DEF_EX_H__
#define __MDP_DEF_EX_H__
#include <linux/kernel.h>
#define MDP_LIMIT_DRIVER_DEVICE_NAME "mtk_mdp_limit"
enum CMDQ_META_OP {
CMDQ_MOP_WRITE = 0,
CMDQ_MOP_READ,
CMDQ_MOP_POLL,
CMDQ_MOP_WAIT,
CMDQ_MOP_WAIT_NO_CLEAR,
CMDQ_MOP_CLEAR,
CMDQ_MOP_SET,
CMDQ_MOP_ACQUIRE,
CMDQ_MOP_WRITE_FD,
CMDQ_MOP_WRITE_FROM_REG,
CMDQ_MOP_WRITE_SEC,
CMDQ_MOP_READBACK,
CMDQ_MOP_WRITE_RDMA,
CMDQ_MOP_WRITE_FD_RDMA,
CMDQ_MOP_NOP,
};
#define CMDQ_EVENT_WAIT 0x80008001
#define CMDQ_EVENT_WAIT_NO_CLEAR 0x00008001
#define CMDQ_EVENT_CLEAR 0x80000000
#define CMDQ_EVENT_SET 0x80010000
#define CMDQ_EVENT_ACQUIRE 0x80018000
struct op_meta {
/* read/write/poll/wait/set */
uint8_t op;
/* id of hw */
uint16_t engine;
union {
/* register offset */
uint16_t offset;
/* event id */
uint16_t event;
/* for rdma cpr */
struct {
uint8_t pipe_idx;
uint8_t cpr_idx;
};
};
union {
/* value to write */
uint32_t value;
/* for read */
uint32_t readback_id;
/* write FD */
uint32_t fd;
/* write sec */
uint32_t sec_handle;
/* write from register */
struct {
uint16_t from_offset;
uint16_t from_engine;
};
};
union {
/* for write with mask */
uint32_t mask;
/* Offset for fd */
uint32_t fd_offset;
/* index in cmdqSecDataStruct.addrMetadatas */
uint32_t sec_index;
};
};
struct hw_meta {
/* register offset */
uint16_t offset;
/* id of hw */
uint16_t engine;
};
struct mdp_submit {
/* [IN] mdp operations */
cmdqU32Ptr_t metas;
uint32_t meta_count;
/* [IN] task schedule priority. this is NOT HW thread priority. */
uint32_t priority;
/* [IN] bit flag of engines used. */
uint64_t engine_flag;
/* [IN] task property for pmqos */
uint32_t prop_size;
uint64_t prop_addr;
/* [IN] readback extension, each bit for 1 readback feature */
uint64_t readback_ext;
/* [IN] ids to represent readback register */
uint32_t read_count_v1;
cmdqU32Ptr_t hw_metas_read_v1;
/* [OUT] mdp job id in kernel */
uint64_t job_id;
/* [IN] secure execution data */
struct cmdqSecDataStruct secData;
};
struct mdp_read_v1 {
uint32_t count;
/* [OUT] values output buffer */
cmdqU32Ptr_t ret_values;
};
struct mdp_read_readback {
uint32_t count;
/* [IN] ids to represent readback ids */
cmdqU32Ptr_t ids;
/* [OUT] register values output buffer */
cmdqU32Ptr_t ret_values;
};
struct mdp_wait {
/* [IN] mdp job id in kernel */
uint64_t job_id;
/* [IN/OUT] mdp readback by input readback ids */
struct mdp_read_v1 read_v1_result;
/* [IN/OUT] mdp readback by input readback ids */
struct mdp_read_readback read_result;
};
struct mdp_readback {
/* [IN] count of the writable buffer
* (unit is # of u32, NOT in byte)
*/
uint32_t count;
/* [OUT] When Alloc, this is the resulting PA.
* It is guaranteed to be continuous.
* [IN] When Free, please pass returned address down to ioctl.
*
* indeed param startPA should be UNSIGNED LONG type for 64 bit kernel
* Considering our plartform supports max 4GB RAM
* (upper-32bit don't care for SW)
* and consistent common code interface, remain u32 type.
*/
uint32_t start_id;
};
struct mdp_simulate {
cmdqU32Ptr_t metas;
uint32_t meta_count;
cmdqU32Ptr_t commands;
uint32_t command_size;
cmdqU32Ptr_t result_size;
};
#define CMDQ_IOCTL_MAGIC_NUMBER 'x'
#define CMDQ_IOCTL_ASYNC_EXEC _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 20, \
struct mdp_submit)
#define CMDQ_IOCTL_ASYNC_WAIT _IOR(CMDQ_IOCTL_MAGIC_NUMBER, 21, \
struct mdp_wait)
#define CMDQ_IOCTL_ALLOC_READBACK_SLOTS _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 22, \
struct mdp_readback)
#define CMDQ_IOCTL_FREE_READBACK_SLOTS _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 23, \
struct mdp_readback)
#define CMDQ_IOCTL_READ_READBACK_SLOTS _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 24, \
struct mdp_read_readback)
#define CMDQ_IOCTL_SIMULATE _IOR(CMDQ_IOCTL_MAGIC_NUMBER, 25, \
struct mdp_simulate)
#endif /* __MDP_DEF_EX_H__ */
File diff suppressed because it is too large. Load diff
+110
View File
@@ -0,0 +1,110 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_DRIVER_H__
#define __MDP_DRIVER_H__
#include <linux/kernel.h>
#include "mdp_def.h"
#include "mdp_def_ex.h"
struct cmdqUsageInfoStruct {
/* [OUT] current engine ref count */
uint32_t count[CMDQ_MAX_ENGINE_COUNT];
};
struct cmdqJobStruct {
struct cmdqCommandStruct command; /* [IN] the job to perform */
cmdqJobHandle_t hJob; /* [OUT] handle to resulting job */
};
struct cmdqJobResultStruct {
/* [IN] Job handle from CMDQ_IOCTL_ASYNC_JOB_EXEC */
cmdqJobHandle_t hJob;
uint64_t engineFlag; /* [OUT] engine flag passed down originally */
/* [IN/OUT] read register values, if any.
* as input, the "count" field must represent
* buffer space pointed by "regValues".
* Upon return, CMDQ driver fills "count" with
* actual requested register count.
* However, if the input "count" is too small,
* -ENOMEM is returned, and "count" is filled
* with requested register count.
*/
struct cmdqRegValueStruct regValue;
/* [IN/OUT] physical address to read */
struct cmdqReadAddressStruct readAddress;
};
struct cmdqWriteAddressStruct {
/* [IN] count of the writable buffer
* (unit is # of u32, NOT in byte)
*/
uint32_t count;
/* [OUT] When Alloc, this is the resulting PA.
* It is guaranteed to be continuous.
* [IN] When Free, please pass returned address down to ioctl.
*
* indeed param startPA should be UNSIGNED LONG type for 64 bit kernel
* Considering our plartform supports max 4GB RAM
* (upper-32bit don't care for SW)
* and consistent common code interface, remain u32 type.
*/
uint32_t startPA;
};
#define CMDQ_IOCTL_MAGIC_NUMBER 'x'
#define CMDQ_IOCTL_LOCK_MUTEX _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 1, int)
#define CMDQ_IOCTL_UNLOCK_MUTEX _IOR(CMDQ_IOCTL_MAGIC_NUMBER, 2, int)
#define CMDQ_IOCTL_EXEC_COMMAND _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 3, \
struct cmdqCommandStruct)
#define CMDQ_IOCTL_QUERY_USAGE _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 4, \
struct cmdqUsageInfoStruct)
/* */
/* Async operations */
/* */
#define CMDQ_IOCTL_ASYNC_JOB_EXEC _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 5, \
struct cmdqJobStruct)
#define CMDQ_IOCTL_ASYNC_JOB_WAIT_AND_CLOSE _IOR(CMDQ_IOCTL_MAGIC_NUMBER, 6, \
struct cmdqJobResultStruct)
#define CMDQ_IOCTL_ALLOC_WRITE_ADDRESS _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 7, \
struct cmdqWriteAddressStruct)
#define CMDQ_IOCTL_FREE_WRITE_ADDRESS _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 8, \
struct cmdqWriteAddressStruct)
#define CMDQ_IOCTL_READ_ADDRESS_VALUE _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 9, \
struct cmdqReadAddressStruct)
/* */
/* Chip capability query. output parameter is a bit field. */
/* Bit definition is CMDQ_CAP_BITS. */
/* */
#define CMDQ_IOCTL_QUERY_CAP_BITS _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 10, int)
/* */
/* HW info. from DTS */
/* */
#define CMDQ_IOCTL_QUERY_DTS _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 11, \
struct cmdqDTSDataStruct)
/* */
/* Notify MDP will use specified engine before really use. */
/* input int is same as EngineFlag. */
/* */
#define CMDQ_IOCTL_NOTIFY_ENGINE _IOW(CMDQ_IOCTL_MAGIC_NUMBER, 12, uint64_t)
s32 cmdq_driver_ioctl_query_usage(struct file *pf, unsigned long param);
s32 cmdq_driver_ioctl_query_cap_bits(unsigned long param);
s32 cmdq_driver_ioctl_query_dts(unsigned long param);
s32 cmdq_driver_ioctl_notify_engine(unsigned long param);
void cmdq_driver_dump_readback(u32 *ids, u32 *addrs, u32 count, u32 *values);
#endif /* __MDP_DRIVER_H__ */
@@ -0,0 +1,152 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_ENGINE_COMMON_H__
#define __MDP_ENGINE_COMMON_H__
enum CMDQ_ENG_ENUM {
/* ISP */
CMDQ_ENG_WPEI = 0,
CMDQ_ENG_WPEO, /* 1 */
CMDQ_ENG_ISP_IMGI, /* 2 */
CMDQ_ENG_ISP_IMGO, /* 3 */
CMDQ_ENG_ISP_IMG2O, /* 4 */
/* IPU */
CMDQ_ENG_IPUI, /* 5 */
CMDQ_ENG_IPUO, /* 6 */
/* MDP */
CMDQ_ENG_MDP_CAMIN, /* 7 */
CMDQ_ENG_MDP_RDMA0, /* 8 */
CMDQ_ENG_MDP_RDMA1, /* 9 */
CMDQ_ENG_MDP_IPUIN, /* 10 */
CMDQ_ENG_MDP_RSZ0, /* 11 */
CMDQ_ENG_MDP_RSZ1, /* 12 */
CMDQ_ENG_MDP_RSZ2, /* 13 */
CMDQ_ENG_MDP_TDSHP0, /* 14 */
CMDQ_ENG_MDP_TDSHP1, /* 15 */
CMDQ_ENG_MDP_COLOR0, /* 16 */
CMDQ_ENG_MDP_MOUT0, /* 17 */
CMDQ_ENG_MDP_MOUT1, /* 18 */
CMDQ_ENG_MDP_PATH0_SOUT, /* 19 */
CMDQ_ENG_MDP_PATH1_SOUT, /* 20 */
CMDQ_ENG_MDP_WROT0, /* 21 */
CMDQ_ENG_MDP_WROT1, /* 22 */
CMDQ_ENG_MDP_WDMA, /* 23 */
/* JPEG & VENC */
CMDQ_ENG_JPEG_ENC, /* 24 */
CMDQ_ENG_VIDEO_ENC, /* 25 */
CMDQ_ENG_JPEG_DEC, /* 26 */
CMDQ_ENG_JPEG_REMDC, /* 27 */
/* DPE */
CMDQ_ENG_DPE, /* 28 */
CMDQ_ENG_RSC, /* 29 */
CMDQ_ENG_GEPF, /* 30 */
CMDQ_ENG_ISP_IMGI2, /* 31 */
CMDQ_ENG_ISP_IMG2O2, /* 32 */
/* temp: CMDQ internal usage */
CMDQ_ENG_CMDQ = 61,
CMDQ_ENG_MMSYS_CONFIG = 62,
CMDQ_ENG_INORDER = 63,
CMDQ_MAX_ENGINE_COUNT /* ALWAYS keep at the end */
};
#define CMDQ_ENG_WPE_GROUP_BITS ((1LL << CMDQ_ENG_WPEI) | \
(1LL << CMDQ_ENG_WPEO))
#define CMDQ_ENG_ISP_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_IMGO) | \
(1LL << CMDQ_ENG_ISP_IMG2O))
#define CMDQ_ENG_MDP_GROUP_BITS ((1LL << CMDQ_ENG_MDP_CAMIN) | \
(1LL << CMDQ_ENG_MDP_RDMA0) | \
(1LL << CMDQ_ENG_MDP_RDMA1) | \
(1LL << CMDQ_ENG_MDP_RSZ0) | \
(1LL << CMDQ_ENG_MDP_RSZ1) | \
(1LL << CMDQ_ENG_MDP_RSZ2) | \
(1LL << CMDQ_ENG_MDP_TDSHP0) | \
(1LL << CMDQ_ENG_MDP_TDSHP1) | \
(1LL << CMDQ_ENG_MDP_COLOR0) | \
(1LL << CMDQ_ENG_MDP_WROT0) | \
(1LL << CMDQ_ENG_MDP_WROT1) | \
(1LL << CMDQ_ENG_MDP_WDMA))
#define CMDQ_ENG_DISP_GROUP_BITS \
((1LL << CMDQ_ENG_DISP_UFOE) | \
(1LL << CMDQ_ENG_DISP_AAL) | \
(1LL << CMDQ_ENG_DISP_COLOR0) | \
(1LL << CMDQ_ENG_DISP_COLOR1) | \
(1LL << CMDQ_ENG_DISP_RDMA0) | \
(1LL << CMDQ_ENG_DISP_RDMA1) | \
(1LL << CMDQ_ENG_DISP_RDMA2) | \
(1LL << CMDQ_ENG_DISP_WDMA0) | \
(1LL << CMDQ_ENG_DISP_WDMA1) | \
(1LL << CMDQ_ENG_DISP_OVL0) | \
(1LL << CMDQ_ENG_DISP_OVL1) | \
(1LL << CMDQ_ENG_DISP_OVL2) | \
(1LL << CMDQ_ENG_DISP_2L_OVL0) | \
(1LL << CMDQ_ENG_DISP_2L_OVL1) | \
(1LL << CMDQ_ENG_DISP_2L_OVL2) | \
(1LL << CMDQ_ENG_DISP_GAMMA) | \
(1LL << CMDQ_ENG_DISP_MERGE) | \
(1LL << CMDQ_ENG_DISP_SPLIT0) | \
(1LL << CMDQ_ENG_DISP_SPLIT1) | \
(1LL << CMDQ_ENG_DISP_DSI0_VDO) | \
(1LL << CMDQ_ENG_DISP_DSI1_VDO) | \
(1LL << CMDQ_ENG_DISP_DSI0_CMD) | \
(1LL << CMDQ_ENG_DISP_DSI1_CMD) | \
(1LL << CMDQ_ENG_DISP_DSI0) | \
(1LL << CMDQ_ENG_DISP_DSI1) | \
(1LL << CMDQ_ENG_DISP_DPI))
#define CMDQ_ENG_VENC_GROUP_BITS ((1LL << CMDQ_ENG_VIDEO_ENC))
#define CMDQ_ENG_JPEG_GROUP_BITS ((1LL << CMDQ_ENG_JPEG_ENC) | \
(1LL << CMDQ_ENG_JPEG_REMDC) | \
(1LL << CMDQ_ENG_JPEG_DEC))
#define CMDQ_ENG_DPE_GROUP_BITS (1LL << CMDQ_ENG_DPE)
#define CMDQ_ENG_RSC_GROUP_BITS (1LL << CMDQ_ENG_RSC)
#define CMDQ_ENG_GEPF_GROUP_BITS (1LL << CMDQ_ENG_GEPF)
#define CMDQ_ENG_EAF_GROUP_BITS (1LL << CMDQ_ENG_EAF)
#define CMDQ_ENG_ISP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_ISP_GROUP_BITS))
#define CMDQ_ENG_MDP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_MDP_GROUP_BITS))
#define CMDQ_ENG_DISP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_DISP_GROUP_BITS))
#define CMDQ_ENG_JPEG_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_JPEG_GROUP_BITS))
#define CMDQ_ENG_VENC_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_VENC_GROUP_BITS))
#define CMDQ_ENG_DPE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_DPE_GROUP_BITS))
#define CMDQ_ENG_RSC_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_RSC_GROUP_BITS))
#define CMDQ_ENG_GEPF_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_GEPF_GROUP_BITS))
#define CMDQ_ENG_WPE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_WPE_GROUP_BITS))
#define CMDQ_ENG_EAF_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_EAF_GROUP_BITS))
#define CMDQ_FOREACH_GROUP(ACTION_struct)\
ACTION_struct(CMDQ_GROUP_ISP, ISP) \
ACTION_struct(CMDQ_GROUP_MDP, MDP) \
ACTION_struct(CMDQ_GROUP_DISP, DISP) \
ACTION_struct(CMDQ_GROUP_JPEG, JPEG) \
ACTION_struct(CMDQ_GROUP_VENC, VENC) \
ACTION_struct(CMDQ_GROUP_DPE, DPE) \
ACTION_struct(CMDQ_GROUP_RSC, RSC) \
ACTION_struct(CMDQ_GROUP_GEPF, GEPF) \
ACTION_struct(CMDQ_GROUP_WPE, WPE) \
ACTION_struct(CMDQ_GROUP_EAF, EAF)
#define MDP_GENERATE_ENUM(_enum, _string) _enum,
enum CMDQ_GROUP_ENUM {
CMDQ_FOREACH_GROUP(MDP_GENERATE_ENUM)
CMDQ_MAX_GROUP_COUNT, /* ALWAYS keep at the end */
};
#endif /* __MDP_ENGINE_COMMON_H__ */
@@ -0,0 +1,255 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/soc/mediatek/mtk-cmdq.h>
#include "mdp_cmdq_device.h"
#define DECLAR_EVENT(event_enum, dts_name) \
{event_enum, #event_enum, #dts_name},
static struct cmdq_event_table cmdq_events[] = {
/* MDP start frame */
DECLAR_EVENT(CMDQ_EVENT_MDP_RDMA0_SOF, mdp_rdma0_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_RDMA1_SOF, mdp_rdma1_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_RDMA2_SOF, mdp_rdma2_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_RDMA3_SOF, mdp_rdma3_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_RSZ0_SOF, mdp_rsz0_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_RSZ1_SOF, mdp_rsz1_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_RSZ2_SOF, mdp_rsz2_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_RSZ3_SOF, mdp_rsz3_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_TDSHP_SOF, mdp_tdshp_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_TDSHP1_SOF, mdp_tdshp1_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_TDSHP2_SOF, mdp_tdshp2_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_TDSHP3_SOF, mdp_tdshp3_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_WDMA_SOF, mdp_wdma_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT_SOF, mdp_wrot_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT0_SOF, mdp_wrot0_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT1_SOF, mdp_wrot1_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT2_SOF, mdp_wrot2_sof)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT3_SOF, mdp_wrot3_sof)
/* Display start frame */
DECLAR_EVENT(CMDQ_EVENT_DISP_RDMA0_SOF, disp_rdma0_sof)
/* MDP frame done */
DECLAR_EVENT(CMDQ_EVENT_MDP_RDMA0_EOF, mdp_rdma0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_RDMA1_EOF, mdp_rdma1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_RDMA2_EOF, mdp_rdma2_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_RDMA3_EOF, mdp_rdma3_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_RSZ0_EOF, mdp_rsz0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_RSZ1_EOF, mdp_rsz1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_RSZ2_EOF, mdp_rsz2_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_RSZ3_EOF, mdp_rsz3_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_TDSHP_EOF, mdp_tdshp_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_TDSHP1_EOF, mdp_tdshp1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_TDSHP2_EOF, mdp_tdshp2_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_TDSHP3_EOF, mdp_tdshp3_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WDMA_EOF, mdp_wdma_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT_WRITE_EOF, mdp_wrot_write_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT0_WRITE_EOF,
mdp_wrot0_write_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT1_WRITE_EOF,
mdp_wrot1_write_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT2_WRITE_EOF,
mdp_wrot2_write_frame_done)
DECLAR_EVENT(CMDQ_EVENT_MDP_WROT3_WRITE_EOF,
mdp_wrot3_write_frame_done)
/* Display frame done */
DECLAR_EVENT(CMDQ_EVENT_DISP_OVL0_EOF, disp_ovl0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_RDMA0_EOF, disp_rdma0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DISP_WDMA0_EOF, disp_wdma0_frame_done)
/* ISP frame done */
DECLAR_EVENT(CMDQ_EVENT_ISP_PASS2_2_EOF, isp_frame_done_p2_2)
DECLAR_EVENT(CMDQ_EVENT_ISP_PASS2_1_EOF, isp_frame_done_p2_1)
DECLAR_EVENT(CMDQ_EVENT_ISP_PASS2_0_EOF, isp_frame_done_p2_0)
/* ISP (IMGSYS) frame done */
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD0_EOF, dip_cq_thread0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD1_EOF, dip_cq_thread1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD2_EOF, dip_cq_thread2_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD3_EOF, dip_cq_thread3_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD4_EOF, dip_cq_thread4_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD5_EOF, dip_cq_thread5_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD6_EOF, dip_cq_thread6_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD7_EOF, dip_cq_thread7_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD8_EOF, dip_cq_thread8_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD9_EOF, dip_cq_thread9_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD10_EOF,
dip_cq_thread10_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD11_EOF,
dip_cq_thread11_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD12_EOF,
dip_cq_thread12_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD13_EOF,
dip_cq_thread13_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD14_EOF,
dip_cq_thread14_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD15_EOF,
dip_cq_thread15_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD16_EOF,
dip_cq_thread16_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD17_EOF,
dip_cq_thread17_frame_done)
DECLAR_EVENT(CMDQ_EVENT_DIP_CQ_THREAD18_EOF,
dip_cq_thread18_frame_done)
/* JPEG frame done */
DECLAR_EVENT(CMDQ_EVENT_JPEG_ENC_EOF, jpgenc_done)
DECLAR_EVENT(CMDQ_EVENT_JPEG_DEC_EOF, jpgdec_done)
/* WPE frame done */
DECLAR_EVENT(CMDQ_EVENT_WPE_A_EOF, wpe_a_frame_done)
DECLAR_EVENT(CMDQ_EVENT_WPE_B_FRAME_DONE, wpe_b_frame_done)
/* Direct-link start frame */
DECLAR_EVENT(CMDQ_EVENT_IMG_DL_RELAY_SOF, img_dl_relay_sof)
DECLAR_EVENT(CMDQ_EVENT_IMG_DL_RELAY1_SOF, img_dl_relay1_sof)
DECLAR_EVENT(CMDQ_EVENT_IMG_DL_RELAY2_SOF, img_dl_relay2_sof)
DECLAR_EVENT(CMDQ_EVENT_IMG_DL_RELAY3_SOF, img_dl_relay3_sof)
/* Dual DIP frame done */
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_0,
dip_cq_thread0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_1,
dip_cq_thread1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_2,
dip_cq_thread2_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_3,
dip_cq_thread3_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_4,
dip_cq_thread4_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_5,
dip_cq_thread5_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_6,
dip_cq_thread6_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_7,
dip_cq_thread7_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_8,
dip_cq_thread8_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_9,
dip_cq_thread9_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_10,
dip_cq_thread10_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_11,
dip_cq_thread11_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_12,
dip_cq_thread12_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_13,
dip_cq_thread13_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_14,
dip_cq_thread14_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_15,
dip_cq_thread15_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_16,
dip_cq_thread16_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_17,
dip_cq_thread17_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_18,
dip_cq_thread18_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_19,
dip_cq_thread19_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_20,
dip_cq_thread20_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_21,
dip_cq_thread21_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_22,
dip_cq_thread22_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_23,
dip_cq_thread23_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_0,
dip2_cq_thread0_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_1,
dip2_cq_thread1_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_2,
dip2_cq_thread2_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_3,
dip2_cq_thread3_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_4,
dip2_cq_thread4_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_5,
dip2_cq_thread5_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_6,
dip2_cq_thread6_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_7,
dip2_cq_thread7_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_8,
dip2_cq_thread8_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_9,
dip2_cq_thread9_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_10,
dip2_cq_thread10_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_11,
dip2_cq_thread11_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_12,
dip2_cq_thread12_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_13,
dip2_cq_thread13_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_14,
dip2_cq_thread14_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_15,
dip2_cq_thread15_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_16,
dip2_cq_thread16_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_17,
dip2_cq_thread17_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_18,
dip2_cq_thread18_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_19,
dip2_cq_thread19_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_20,
dip2_cq_thread20_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_21,
dip2_cq_thread21_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_22,
dip2_cq_thread22_frame_done)
DECLAR_EVENT(CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_23,
dip2_cq_thread23_frame_done)
/* Keep this at the end of HW events */
DECLAR_EVENT(CMDQ_MAX_HW_EVENT_COUNT, hw_event_conunt)
/* SW Sync Tokens (Pre-defined) */
/* Pass-2 notifies VENC frame is ready to be encoded */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_VENC_INPUT_READY, sw_token)
/* VENC notifies Pass-2 encode done so next frame may start */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_VENC_EOF, sw_token)
/* SW Sync Tokens (User-defined) */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_USER_0, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_USER_1, sw_token)
/* isp */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_MSS, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_MSF, sw_token)
/* GPR access tokens (for HW register backup)
* There are 15 32-bit GPR, 3 GPR form a set
* (64-bit for address, 32-bit for value)
*/
DECLAR_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_0, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_1, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_2, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_3, sw_token)
DECLAR_EVENT(CMDQ_SYNC_TOKEN_GPR_SET_4, sw_token)
/* Resource lock event to control resource in GCE thread */
DECLAR_EVENT(CMDQ_SYNC_RESOURCE_WROT0, sw_token)
DECLAR_EVENT(CMDQ_SYNC_RESOURCE_WROT1, sw_token)
/* event id is 10 bit */
DECLAR_EVENT(CMDQ_SYNC_TOKEN_MAX, max_token)
};
struct cmdq_event_table *cmdq_event_get_table(void)
{
return cmdq_events;
}
u32 cmdq_event_get_table_size(void)
{
return ARRAY_SIZE(cmdq_events);
}
@@ -0,0 +1,195 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef CMDQ_EVENT_COMMON
#define CMDQ_EVENT_COMMON
/* Define CMDQ events
*
* For hardware event must define in device tree.
* For SW event assign event ID here directly.
*
* Note: event name must sync to cmdq_events table in mdp_event_common.c
*/
enum cmdq_event {
/* MDP start frame */
CMDQ_EVENT_MDP_RDMA0_SOF, /* 0 */
CMDQ_EVENT_MDP_RDMA1_SOF, /* 1 */
CMDQ_EVENT_MDP_RDMA2_SOF, /* 2 */
CMDQ_EVENT_MDP_RDMA3_SOF, /* 3 */
CMDQ_EVENT_MDP_RSZ0_SOF, /* 4 */
CMDQ_EVENT_MDP_RSZ1_SOF, /* 5 */
CMDQ_EVENT_MDP_RSZ2_SOF, /* 6 */
CMDQ_EVENT_MDP_RSZ3_SOF, /* 7 */
CMDQ_EVENT_MDP_TDSHP_SOF, /* 8 */
CMDQ_EVENT_MDP_TDSHP1_SOF, /* 9 */
CMDQ_EVENT_MDP_TDSHP2_SOF, /* 10 */
CMDQ_EVENT_MDP_TDSHP3_SOF, /* 11 */
CMDQ_EVENT_MDP_WDMA_SOF, /* 12 */
CMDQ_EVENT_MDP_WROT_SOF, /* 13 */
CMDQ_EVENT_MDP_WROT0_SOF, /* 14 */
CMDQ_EVENT_MDP_WROT1_SOF, /* 15 */
CMDQ_EVENT_MDP_WROT2_SOF, /* 16 */
CMDQ_EVENT_MDP_WROT3_SOF, /* 17 */
/* Display start frame */
CMDQ_EVENT_DISP_RDMA0_SOF, /* 18 */
/* MDP frame done */
CMDQ_EVENT_MDP_RDMA0_EOF, /* 19 */
CMDQ_EVENT_MDP_RDMA1_EOF, /* 20 */
CMDQ_EVENT_MDP_RDMA2_EOF, /* 21 */
CMDQ_EVENT_MDP_RDMA3_EOF, /* 22 */
CMDQ_EVENT_MDP_RSZ0_EOF, /* 23 */
CMDQ_EVENT_MDP_RSZ1_EOF, /* 24 */
CMDQ_EVENT_MDP_RSZ2_EOF, /* 25 */
CMDQ_EVENT_MDP_RSZ3_EOF, /* 26 */
CMDQ_EVENT_MDP_TDSHP_EOF, /* 27 */
CMDQ_EVENT_MDP_TDSHP1_EOF, /* 28 */
CMDQ_EVENT_MDP_TDSHP2_EOF, /* 29 */
CMDQ_EVENT_MDP_TDSHP3_EOF, /* 30 */
CMDQ_EVENT_MDP_WDMA_EOF, /* 31 */
CMDQ_EVENT_MDP_WROT_WRITE_EOF, /* 32 */
CMDQ_EVENT_MDP_WROT0_WRITE_EOF, /* 33 */
CMDQ_EVENT_MDP_WROT1_WRITE_EOF, /* 34 */
CMDQ_EVENT_MDP_WROT2_WRITE_EOF, /* 35 */
CMDQ_EVENT_MDP_WROT3_WRITE_EOF, /* 36 */
/* Display frame done */
CMDQ_EVENT_DISP_OVL0_EOF, /* 37 */
CMDQ_EVENT_DISP_RDMA0_EOF, /* 38 */
CMDQ_EVENT_DISP_WDMA0_EOF, /* 39 */
/* ISP frame done */
CMDQ_EVENT_ISP_PASS2_2_EOF, /* 40 */
CMDQ_EVENT_ISP_PASS2_1_EOF, /* 41 */
CMDQ_EVENT_ISP_PASS2_0_EOF, /* 42 */
/* ISP (IMGSYS) frame done */
CMDQ_EVENT_DIP_CQ_THREAD0_EOF, /* 43 */
CMDQ_EVENT_DIP_CQ_THREAD1_EOF, /* 44 */
CMDQ_EVENT_DIP_CQ_THREAD2_EOF, /* 45 */
CMDQ_EVENT_DIP_CQ_THREAD3_EOF, /* 46 */
CMDQ_EVENT_DIP_CQ_THREAD4_EOF, /* 47 */
CMDQ_EVENT_DIP_CQ_THREAD5_EOF, /* 48 */
CMDQ_EVENT_DIP_CQ_THREAD6_EOF, /* 49 */
CMDQ_EVENT_DIP_CQ_THREAD7_EOF, /* 50 */
CMDQ_EVENT_DIP_CQ_THREAD8_EOF, /* 51 */
CMDQ_EVENT_DIP_CQ_THREAD9_EOF, /* 52 */
CMDQ_EVENT_DIP_CQ_THREAD10_EOF, /* 53 */
CMDQ_EVENT_DIP_CQ_THREAD11_EOF, /* 54 */
CMDQ_EVENT_DIP_CQ_THREAD12_EOF, /* 55 */
CMDQ_EVENT_DIP_CQ_THREAD13_EOF, /* 56 */
CMDQ_EVENT_DIP_CQ_THREAD14_EOF, /* 57 */
CMDQ_EVENT_DIP_CQ_THREAD15_EOF, /* 58 */
CMDQ_EVENT_DIP_CQ_THREAD16_EOF, /* 59 */
CMDQ_EVENT_DIP_CQ_THREAD17_EOF, /* 60 */
CMDQ_EVENT_DIP_CQ_THREAD18_EOF, /* 61 */
/* JPEG frame done */
CMDQ_EVENT_JPEG_ENC_EOF, /* 62 */
CMDQ_EVENT_JPEG_DEC_EOF, /* 63 */
/* WPE frame done */
CMDQ_EVENT_WPE_A_EOF, /* 64 */
CMDQ_EVENT_WPE_B_FRAME_DONE, /* 65 */
/* Direct-link start frame */
CMDQ_EVENT_IMG_DL_RELAY_SOF, /* 66 */
CMDQ_EVENT_IMG_DL_RELAY1_SOF, /* 67 */
CMDQ_EVENT_IMG_DL_RELAY2_SOF, /* 68 */
CMDQ_EVENT_IMG_DL_RELAY3_SOF, /* 69 */
/* Dual DIP frame done */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_0, /* 70 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_1, /* 71 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_2, /* 72 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_3, /* 73 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_4, /* 74 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_5, /* 75 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_6, /* 76 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_7, /* 77 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_8, /* 78 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_9, /* 79 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_10, /* 80 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_11, /* 81 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_12, /* 82 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_13, /* 83 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_14, /* 84 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_15, /* 85 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_16, /* 86 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_17, /* 87 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_18, /* 88 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_19, /* 89 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_20, /* 90 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_21, /* 91 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_22, /* 92 */
CMDQ_EVENT_IMG1_EVENT_TX_FRAME_DONE_23, /* 93 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_0, /* 94 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_1, /* 95 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_2, /* 96 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_3, /* 97 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_4, /* 98 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_5, /* 99 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_6, /* 100 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_7, /* 101 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_8, /* 102 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_9, /* 103 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_10, /* 104 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_11, /* 105 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_12, /* 106 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_13, /* 107 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_14, /* 108 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_15, /* 109 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_16, /* 110 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_17, /* 111 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_18, /* 112 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_19, /* 113 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_20, /* 114 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_21, /* 115 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_22, /* 116 */
CMDQ_EVENT_IMG2_EVENT_TX_FRAME_DONE_23, /* 117 */
/* Keep this at the end of HW events */
CMDQ_MAX_HW_EVENT_COUNT = 512,
/* token 512 to 639 may set secure */
/* SW Sync Tokens (Pre-defined) */
/* Pass-2 notifies VENC frame is ready to be encoded */
CMDQ_SYNC_TOKEN_VENC_INPUT_READY = 645, /* 645 */
/* VENC notifies Pass-2 encode done so next frame may start */
CMDQ_SYNC_TOKEN_VENC_EOF, /* 646 */
/* SW Sync Tokens (User-defined) */
CMDQ_SYNC_TOKEN_USER_0 = 649, /* 649 */
CMDQ_SYNC_TOKEN_USER_1, /* 650 */
/* isp */
CMDQ_SYNC_TOKEN_MSS = 665, /* 665 */
CMDQ_SYNC_TOKEN_MSF, /* 666 */
/* token after 700 sync user space header */
/* GPR access tokens (for HW register backup)
* There are 15 32-bit GPR, 3 GPR form a set
* (64-bit for address, 32-bit for value)
*/
CMDQ_SYNC_TOKEN_GPR_SET_0 = 700,
CMDQ_SYNC_TOKEN_GPR_SET_1, /* 701 */
CMDQ_SYNC_TOKEN_GPR_SET_2, /* 702 */
CMDQ_SYNC_TOKEN_GPR_SET_3, /* 703 */
CMDQ_SYNC_TOKEN_GPR_SET_4, /* 704 */
/* Resource lock event to control resource in GCE thread */
CMDQ_SYNC_RESOURCE_WROT0 = 710,
CMDQ_SYNC_RESOURCE_WROT1 = 711,
/* event id is 10 bit */
CMDQ_SYNC_TOKEN_MAX = 0x3FF,
CMDQ_SYNC_TOKEN_INVALID = -1,
};
#endif
File diff suppressed because it is too large. Load diff
+46
View File
@@ -0,0 +1,46 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_IOCTL_EX_H__
#define __MDP_IOCTL_EX_H__
#include <linux/kernel.h>
#include <linux/platform_device.h>
int mdp_limit_late_init(void);
int mdp_limit_dev_create(struct platform_device *device);
void mdp_limit_dev_destroy(void);
s32 mdp_ioctl_async_exec(struct file *pf, unsigned long param);
s32 mdp_ioctl_async_wait(unsigned long param);
s32 mdp_ioctl_alloc_readback_slots(void *fp, unsigned long param);
s32 mdp_ioctl_free_readback_slots(void *fp, unsigned long param);
s32 mdp_ioctl_read_readback_slots(unsigned long param);
s32 mdp_ioctl_simulate(unsigned long param);
void mdp_ioctl_free_job_by_node(void *node);
void mdp_ioctl_free_readback_slots_by_node(void *fp);
#if (IS_ENABLED(CONFIG_TRUSTONIC_TEE_SUPPORT) || \
IS_ENABLED(CONFIG_MICROTRUST_TEE_SUPPORT)) && \
IS_ENABLED(CONFIG_MTK_TEE_GP_SUPPORT)
#if (IS_ENABLED(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT) && \
!IS_ENABLED(CONFIG_MTK_SVP_ON_MTEE_SUPPORT)) || \
IS_ENABLED(CONFIG_MTK_CAM_SECURITY_SUPPORT) || \
IS_ENABLED(CONFIG_MTK_GZ_SUPPORT_SDSP)
#define MDP_M4U_TEE_SUPPORT
int m4u_sec_init(void);
#endif
#endif
#if IS_ENABLED(CONFIG_MTK_CAM_GENIEZONE_SUPPORT)
#define MDP_M4U_MTEE_SEC_CAM_SUPPORT
int m4u_gz_sec_init(int mtk_iommu_sec_id);
#endif
#if IS_ENABLED(CONFIG_MTK_SVP_ON_MTEE_SUPPORT)
#define MDP_M4U_MTEE_SVP_SUPPORT
int m4u_gz_sec_init(int mtk_iommu_sec_id);
#endif
#endif /* __MDP_IOCTL_EX_H__ */
+164
View File
@@ -0,0 +1,164 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "mdp_m4u.h"
#ifdef CONFIG_MTK_CMDQ_MBOX_EXT
#include "mdp_cmdq_helper_ext.h"
#else
#include "cmdq_record.h"
#ifndef MDP_META_IN_LEGACY_V2
#include "cmdq_helper_ext.h"
#else
#include "cmdq_core.h"
#endif
#endif
#include <ion_drv.h>
#ifdef CONFIG_MTK_IOMMU_V2
#include "mach/mt_iommu.h"
#include "mach/pseudo_m4u.h"
#include <soc/mediatek/smi.h>
#include "mtk_iommu_ext.h"
#endif
static struct ion_client *g_mdp_ion_client;
int mdp_ion_get_mva(struct ion_handle *handle,
unsigned long *mva, unsigned long fixed_mva, int port)
{
#if defined(CONFIG_MTK_IOMMU_V2)
struct ion_mm_data mm_data;
size_t mva_size;
memset((void *)&mm_data, 0, sizeof(struct ion_mm_data));
mm_data.mm_cmd = ION_MM_GET_IOVA;
mm_data.get_phys_param.module_id = port;
mm_data.get_phys_param.kernel_handle = handle;
if (fixed_mva > 0) {
mm_data.get_phys_param.phy_addr =
(port << 24) | ION_FLAG_GET_FIXED_PHYS;
mm_data.get_phys_param.len = ION_FLAG_GET_FIXED_PHYS;
mm_data.get_phys_param.reserve_iova_start = fixed_mva;
mm_data.get_phys_param.reserve_iova_end = fixed_mva;
}
if (ion_kernel_ioctl(g_mdp_ion_client, ION_CMD_MULTIMEDIA,
(unsigned long)&mm_data) < 0) {
CMDQ_ERR("%s: get mva failed.%p -%p\n",
__func__, g_mdp_ion_client, handle);
ion_free(g_mdp_ion_client, handle);
return -1;
}
*mva = mm_data.get_phys_param.phy_addr;
mva_size = mm_data.get_phys_param.len;
if (*mva == 0)
CMDQ_ERR("alloc mmu addr hnd=0x%p,mva=0x%08lx\n",
handle, *mva);
#endif
return 0;
}
struct ion_handle *mdp_ion_import_handle(int fd)
{
struct ion_handle *handle = NULL;
#if defined(CONFIG_MTK_IOMMU_V2)
/* If no need Ion support, do nothing! */
if (fd <= 0) {
CMDQ_ERR("NO NEED ion support, fd %d\n", fd);
return handle;
}
if (!g_mdp_ion_client) {
CMDQ_ERR("invalid ion client!\n");
return handle;
}
handle = ion_import_dma_buf_fd(g_mdp_ion_client, fd);
if (IS_ERR(handle)) {
CMDQ_ERR("import ion handle failed!\n");
return NULL;
}
CMDQ_MSG("import ion handle fd=%d,hnd=0x%p\n", fd, handle);
#endif
return handle;
}
#ifdef CONFIG_MTK_IN_HOUSE_TEE_SUPPORT
void mdp_ion_import_sec_handle(int fd, ion_phys_addr_t *sec_handle)
{
size_t size;
struct ion_handle *handle = NULL;
/* If no need Ion support, do nothing! */
if (fd <= 0)
CMDQ_ERR("NO NEED ion support, fd %d\n", fd);
if (!g_mdp_ion_client)
CMDQ_ERR("invalid ion client!\n");
handle = ion_import_dma_buf_fd(g_mdp_ion_client, fd);
ion_phys(g_mdp_ion_client, handle, sec_handle, &size);
if (size <= 0)
CMDQ_ERR("import ion handle fd=%d,hnd=0x%p\n", fd, sec_handle);
CMDQ_MSG("import ion handle fd=%d,0x%x,hnd=0x%p\n", fd, handle, *sec_handle);
ion_free(g_mdp_ion_client, handle);
}
#endif
void mdp_ion_free_handle(struct ion_handle *handle)
{
if (!g_mdp_ion_client) {
CMDQ_ERR("invalid ion client!\n");
return;
}
if (!handle)
return;
ion_free(g_mdp_ion_client, handle);
CMDQ_MSG("free ion handle 0x%p\n", handle);
}
void mdp_ion_cache_flush(struct ion_handle *handle)
{
#if defined(CONFIG_MTK_IOMMU_V2)
struct ion_sys_data sys_data;
void *buffer_va = NULL;
if (!g_mdp_ion_client || !handle)
return;
sys_data.sys_cmd = ION_SYS_CACHE_SYNC;
sys_data.cache_sync_param.kernel_handle = handle;
sys_data.cache_sync_param.sync_type = ION_CACHE_INVALID_BY_RANGE;
buffer_va = ion_map_kernel(g_mdp_ion_client, handle);
sys_data.cache_sync_param.va = buffer_va;
sys_data.cache_sync_param.size = handle->buffer->size;
if (ion_kernel_ioctl(g_mdp_ion_client, ION_CMD_SYSTEM,
(unsigned long)&sys_data))
pr_info("ion cache flush failed!\n");
ion_unmap_kernel(g_mdp_ion_client, handle);
#endif
}
void mdp_ion_create(const char *name)
{
if (g_ion_device)
g_mdp_ion_client = ion_client_create(g_ion_device, name);
else
CMDQ_ERR("invalid g_ion_device\n");
if (!g_mdp_ion_client)
CMDQ_ERR("create ion client failed!\n");
}
void mdp_ion_destroy(void)
{
if (g_mdp_ion_client && g_ion_device)
ion_client_destroy(g_mdp_ion_client);
}
+27
View File
@@ -0,0 +1,27 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_M4U_H__
#define __MDP_M4U_H__
#ifdef CONFIG_MTK_IOMMU_V2
#include "mach/mt_iommu.h"
#include <soc/mediatek/smi.h>
#endif
#include <ion_priv.h>
void mdp_ion_create(const char *name);
void mdp_ion_destroy(void);
int mdp_ion_get_mva(struct ion_handle *handle,
unsigned long *mva, unsigned long fixed_mva, int port);
struct ion_handle *mdp_ion_import_handle(int fd);
void mdp_ion_free_handle(struct ion_handle *handle);
void mdp_ion_cache_flush(struct ion_handle *handle);
#ifdef CONFIG_MTK_IN_HOUSE_TEE_SUPPORT
void mdp_ion_import_sec_handle(int fd, ion_phys_addr_t *sec_handle);
#endif
#endif
+49
View File
@@ -0,0 +1,49 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_PMQOS_H__
#define __MDP_PMQOS_H__
#define PMQOS_ISP_PORT_NUM 16
#define PMQOS_MDP_PORT_NUM 4
enum DP_FORMAT_FLAG_ENUM {
DP_BW_COMP_NONE = 0,
DP_BW_COMP_DEFAULT,
DP_BW_COMP_END
};
struct mdp_pmqos {
uint32_t isp_total_datasize;
uint32_t isp_total_pixel;
uint32_t mdp_total_datasize;
uint32_t mdp_total_pixel;
uint32_t qos2_isp_bandwidth[PMQOS_ISP_PORT_NUM];
uint32_t qos2_isp_total_pixel[PMQOS_ISP_PORT_NUM];
uint32_t qos2_isp_port[PMQOS_ISP_PORT_NUM];
uint32_t qos2_isp_count;
uint32_t qos2_mdp_bandwidth[PMQOS_MDP_PORT_NUM];
uint32_t qos2_mdp_total_pixel[PMQOS_MDP_PORT_NUM];
uint32_t qos2_mdp_port[PMQOS_MDP_PORT_NUM];
uint32_t qos2_mdp_count;
uint64_t tv_sec;
uint64_t tv_usec;
uint64_t ispMetString;
uint32_t ispMetStringSize;
uint64_t mdpMetString;
uint32_t mdpMetStringSize;
uint64_t mdpMMpathString;
uint32_t mdpMMpathStringSize;
uint32_t qos2_isp_port_format_flag[PMQOS_ISP_PORT_NUM];
uint32_t qos2_mdp_port_format_flag[PMQOS_MDP_PORT_NUM];
};
#endif
+44
View File
@@ -0,0 +1,44 @@
#
# Copyright (C) 2019 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# drivers/mdp
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mdp \
-I$(srctree)/drivers/misc/mediatek/mmdvfs/ \
-I$(srctree)/drivers/misc/mediatek/smi/ \
-I$(srctree)/drivers/misc/mediatek/smi/$(MTK_PLATFORM)/ \
-I$(srctree)/drivers/misc/mediatek/m4u/$(MTK_PLATFORM) \
-I$(srctree)/drivers/iommu
ccflags-$(CONFIG_MTK_CMDQ_MBOX_EXT) += -I$(srctree)/drivers/misc/mediatek/cmdq/mailbox/
ifeq ($(strip $(CONFIG_MTK_PQ_COLOR_MODE)),"MDP")
ccflags-y += -DCMDQ_MDP_COLOR
endif
# Enable MET
ccflags-y += -DMET_USER_EVENT_SUPPORT
# Enable AEE
ccflags-y += -DCMDQ_AEE_READY
# secure path
ifeq ($(or $(strip $(CONFIG_TRUSTONIC_TEE_SUPPORT)), $(strip $(CONFIG_MICROTRUST_TEE_SUPPORT)), \
$(strip $(CONFIG_MTK_ENABLE_GENIEZONE))),y)
ifeq ($(or $(strip $(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT)), $(strip $(CONFIG_MTK_CAM_SECURITY_SUPPORT))),y)
ccflags-y += -DCMDQ_SECURE_PATH_SUPPORT
endif # end of CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT or CONFIG_MTK_CAM_SECURITY_SUPPORT
endif # end of CONFIG_TRUSTONIC_TEE_SUPPORT or CONFIG_MICROTRUST_TEE_SUPPORT
obj-y += mdp.o
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,53 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_BASE_H__
#define __MDP_BASE_H__
#define MDP_HW_CHECK
#include "mach/mt_iommu.h"
static u32 mdp_engine_port[ENGBASE_COUNT] = {
0, //ENGBASE_MMSYS_CONFIG,
M4U_PORT_L2_MDP_RDMA0, //ENGBASE_MDP_RDMA0,
0, //ENGBASE_MDP_AAL0,
0, //ENGBASE_MDP_HDR0,
0, //ENGBASE_MDP_RSZ0,
0, //ENGBASE_MDP_RSZ1,
M4U_PORT_L2_MDP_WROT0, //ENGBASE_MDP_WROT0,
M4U_PORT_L2_MDP_WROT1, //ENGBASE_MDP_WROT1,
0, //ENGBASE_MDP_TDSHP0,
0, //ENGBASE_MMSYS_MUTEX,
0, //ENGINE_IMGSYS
0, //ENGINE_IMGSYS2_CONFIG
0, //ENGBASE_ISP_DIP_A0
0, //ENGBASE_ISP_DIP_A1
0, //ENGBASE_ISP_DIP_A7
0, //ENGBASE_ISP_MSS_B
0, //ENGBASE_ISP_MFB_B
};
static u32 mdp_base[ENGBASE_COUNT] = {
[ENGBASE_MMSYS_CONFIG] = 0x1b000000,
[ENGBASE_MDP_RDMA0] = 0x1b003000,
[ENGBASE_MDP_AAL0] = 0x1b005000,
[ENGBASE_MDP_HDR0] = 0x1b007000,
[ENGBASE_MDP_RSZ0] = 0x1b008000,
[ENGBASE_MDP_RSZ1] = 0x1b009000,
[ENGBASE_MDP_WROT0] = 0x1b00a000,
[ENGBASE_MDP_WROT1] = 0x1b00b000,
[ENGBASE_MDP_TDSHP0] = 0x1b00c000,
[ENGBASE_MMSYS_MUTEX] = 0x1b001000,
[ENGBASE_IMGSYS] = 0x15020000,
[ENGBASE_IMGSYS2_CONFIG] = 0x15820000,
[ENGBASE_ISP_DIP_A0] = 0x15021000,
[ENGBASE_ISP_DIP_A1] = 0x15022000,
[ENGBASE_ISP_DIP_A7] = 0x15028000,
[ENGBASE_ISP_MSS_B] = 0x15812000,
[ENGBASE_ISP_MFB_B] = 0x15810000,
};
#endif
@@ -0,0 +1,154 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_ENGINE_H__
#define __MDP_ENGINE_H__
enum CMDQ_ENG_ENUM {
/* ISP */
CMDQ_ENG_WPEI = 0,
CMDQ_ENG_WPEO, /* 1 */
CMDQ_ENG_WPEI2, /* 2 */
CMDQ_ENG_WPEO2, /* 3 */
CMDQ_ENG_ISP_IMGI, /* 4 */
CMDQ_ENG_ISP_IMG2O, /* 5 */
/* MDP */
CMDQ_ENG_MDP_CAMIN, /* 6 */
CMDQ_ENG_MDP_CAMIN2, /* 7 */
CMDQ_ENG_MDP_RDMA0, /* 8 */
CMDQ_ENG_MDP_HDR0, /* 9 */
CMDQ_ENG_MDP_AAL0, /* 10 */
CMDQ_ENG_MDP_RSZ0, /* 11 */
CMDQ_ENG_MDP_RSZ1, /* 12 */
CMDQ_ENG_MDP_TDSHP0, /* 13 */
CMDQ_ENG_MDP_WROT0, /* 14 */
CMDQ_ENG_MDP_WROT1, /* 15 */
/* DPE */
CMDQ_ENG_DPE, /* 16 */
CMDQ_ENG_RSC, /* 17 */
CMDQ_ENG_GEPF, /* 18 */
CMDQ_ENG_EAF, /* 19 */
CMDQ_ENG_OWE, /* 20 */
CMDQ_ENG_MFB, /* 21 */
CMDQ_ENG_FDVT, /* 22 */
/* ISP sec */
CMDQ_ENG_ISP_VIPI, /* 23 */
CMDQ_ENG_ISP_LCEI, /* 24 */
CMDQ_ENG_ISP_IMG3O, /* 25 */
CMDQ_ENG_ISP_SMXIO, /* 26 */
CMDQ_ENG_ISP_DMGI_DEPI, /* 27 */
CMDQ_ENG_ISP_IMGCI, /* 28 */
CMDQ_ENG_ISP_UFBCI, /* 29 */
CMDQ_ENG_ISP_UFBCO, /* 30 */
CMDQ_ENG_INORDER, /*31 */
/* Dummy Engine */
CMDQ_ENG_ISP_TIMGO = 63,
CMDQ_ENG_ISP_IMGI2 = 63,
CMDQ_ENG_ISP_IMG2O2 = 63,
CMDQ_ENG_MDP_RSZ2 = 63,
CMDQ_ENG_MDP_WDMA = 63,
CMDQ_ENG_MDP_HDR1 = 63,
CMDQ_ENG_MDP_COLOR1 = 63,
CMDQ_ENG_MDP_RDMA1 = 63,
CMDQ_ENG_MDP_COLOR0 = 63,
CMDQ_ENG_MDP_AAL1 = 63,
CMDQ_ENG_MDP_TDSHP1 = 63,
CMDQ_MAX_ENGINE_COUNT /* ALWAYS keep at the end */
};
#define CMDQ_ENG_WPE_GROUP_BITS ((1LL << CMDQ_ENG_WPEI) | \
(1LL << CMDQ_ENG_WPEO) | \
(1LL << CMDQ_ENG_WPEI2) | \
(1LL << CMDQ_ENG_WPEO2))
#define CMDQ_ENG_ISP_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_IMG2O))
#define CMDQ_ENG_ISP_MTEE_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_VIPI) | \
(1LL << CMDQ_ENG_ISP_LCEI))
#define CMDQ_ENG_SVP_MTEE_GROUP_BITS (1LL << CMDQ_ENG_MDP_RDMA0)
#define CMDQ_ENG_MDP_GROUP_BITS ((1LL << CMDQ_ENG_MDP_CAMIN) | \
(1LL << CMDQ_ENG_MDP_CAMIN2) | \
(1LL << CMDQ_ENG_MDP_RDMA0) | \
(1LL << CMDQ_ENG_MDP_RDMA1) | \
(1LL << CMDQ_ENG_MDP_RSZ0) | \
(1LL << CMDQ_ENG_MDP_RSZ1) | \
(1LL << CMDQ_ENG_MDP_TDSHP0) | \
(1LL << CMDQ_ENG_MDP_TDSHP1) | \
(1LL << CMDQ_ENG_MDP_COLOR0) | \
(1LL << CMDQ_ENG_MDP_WROT0) | \
(1LL << CMDQ_ENG_MDP_WROT1) | \
(1LL << CMDQ_ENG_MDP_AAL0) | \
(1LL << CMDQ_ENG_MDP_AAL1) | \
(1LL << CMDQ_ENG_MDP_HDR0))
#define CMDQ_ENG_DPE_GROUP_BITS (1LL << CMDQ_ENG_DPE)
#define CMDQ_ENG_RSC_GROUP_BITS (1LL << CMDQ_ENG_RSC)
#define CMDQ_ENG_GEPF_GROUP_BITS (1LL << CMDQ_ENG_GEPF)
#define CMDQ_ENG_EAF_GROUP_BITS (1LL << CMDQ_ENG_EAF)
#define CMDQ_ENG_OWE_GROUP_BITS (1LL << CMDQ_ENG_OWE)
#define CMDQ_ENG_MFB_GROUP_BITS (1LL << CMDQ_ENG_MFB)
#define CMDQ_ENG_FDVT_GROUP_BITS (1LL << CMDQ_ENG_FDVT)
#define CMDQ_ENG_ISP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_ISP_GROUP_BITS))
#define CMDQ_ENG_MDP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_MDP_GROUP_BITS))
#define CMDQ_ENG_DPE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_DPE_GROUP_BITS))
#define CMDQ_ENG_RSC_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_RSC_GROUP_BITS))
#define CMDQ_ENG_GEPF_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_GEPF_GROUP_BITS))
#define CMDQ_ENG_WPE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_WPE_GROUP_BITS))
#define CMDQ_ENG_EAF_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_EAF_GROUP_BITS))
#define CMDQ_ENG_OWE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_OWE_GROUP_BITS))
#define CMDQ_ENG_MFB_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_MFB_GROUP_BITS))
#define CMDQ_ENG_FDVT_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_FDVT_GROUP_BITS))
#define CMDQ_FOREACH_GROUP(ACTION_struct)\
ACTION_struct(CMDQ_GROUP_ISP, ISP) \
ACTION_struct(CMDQ_GROUP_MDP, MDP) \
ACTION_struct(CMDQ_GROUP_DPE, DPE) \
ACTION_struct(CMDQ_GROUP_RSC, RSC) \
ACTION_struct(CMDQ_GROUP_GEPF, GEPF) \
ACTION_struct(CMDQ_GROUP_WPE, WPE) \
ACTION_struct(CMDQ_GROUP_EAF, EAF) \
ACTION_struct(CMDQ_GROUP_OWE, OWE) \
ACTION_struct(CMDQ_GROUP_MFB, MFB) \
ACTION_struct(CMDQ_GROUP_FDVT, FDVT)
#define MDP_GENERATE_ENUM(_enum, _string) _enum,
enum CMDQ_GROUP_ENUM {
CMDQ_FOREACH_GROUP(MDP_GENERATE_ENUM)
CMDQ_MAX_GROUP_COUNT, /* ALWAYS keep at the end */
};
enum MDP_ENG_BASE {
ENGBASE_MMSYS_CONFIG,
ENGBASE_MDP_RDMA0,
ENGBASE_MDP_AAL0,
ENGBASE_MDP_HDR0,
ENGBASE_MDP_RSZ0,
ENGBASE_MDP_RSZ1,
ENGBASE_MDP_WROT0,
ENGBASE_MDP_WROT1,
ENGBASE_MDP_TDSHP0,
ENGBASE_MMSYS_MUTEX,
ENGBASE_IMGSYS,
ENGBASE_IMGSYS2_CONFIG,
ENGBASE_ISP_DIP_A0,
ENGBASE_ISP_DIP_A1,
ENGBASE_ISP_DIP_A7,
ENGBASE_ISP_MSS_B,
ENGBASE_ISP_MFB_B,
ENGBASE_COUNT
};
#endif /* __MDP_ENGINE_H__ */
+44
View File
@@ -0,0 +1,44 @@
#
# Copyright (C) 2019 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# drivers/mdp
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mdp \
-I$(srctree)/drivers/misc/mediatek/mmdvfs/ \
-I$(srctree)/drivers/misc/mediatek/smi/ \
-I$(srctree)/drivers/misc/mediatek/smi/$(MTK_PLATFORM)/ \
-I$(srctree)/drivers/misc/mediatek/m4u/$(MTK_PLATFORM) \
-I$(srctree)/drivers/iommu
ccflags-$(CONFIG_MTK_CMDQ_MBOX_EXT) += -I$(srctree)/drivers/misc/mediatek/cmdq/mailbox/
ifeq ($(strip $(CONFIG_MTK_PQ_COLOR_MODE)),"MDP")
ccflags-y += -DCMDQ_MDP_COLOR
endif
# Enable MET
ccflags-y += -DMET_USER_EVENT_SUPPORT
# Enable AEE
ccflags-y += -DCMDQ_AEE_READY
# secure path
ifeq ($(or $(strip $(CONFIG_TRUSTONIC_TEE_SUPPORT)), $(strip $(CONFIG_MICROTRUST_TEE_SUPPORT)), \
$(strip $(CONFIG_MTK_ENABLE_GENIEZONE))),y)
ifeq ($(or $(strip $(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT)), $(strip $(CONFIG_MTK_CAM_SECURITY_SUPPORT))),y)
ccflags-y += -DCMDQ_SECURE_PATH_SUPPORT
endif # end of CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT or CONFIG_MTK_CAM_SECURITY_SUPPORT
endif # end of CONFIG_TRUSTONIC_TEE_SUPPORT or CONFIG_MICROTRUST_TEE_SUPPORT
obj-y += mdp.o
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,53 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_BASE_H__
#define __MDP_BASE_H__
#define MDP_HW_CHECK
#include "mach/mt_iommu.h"
static u32 mdp_engine_port[ENGBASE_COUNT] = {
0, //ENGBASE_MMSYS_CONFIG,
M4U_PORT_L2_MDP_RDMA0, //ENGBASE_MDP_RDMA0,
0, //ENGBASE_MDP_AAL0,
0, //ENGBASE_MDP_HDR0,
0, //ENGBASE_MDP_RSZ0,
0, //ENGBASE_MDP_RSZ1,
M4U_PORT_L2_MDP_WROT0, //ENGBASE_MDP_WROT0,
M4U_PORT_L2_MDP_WROT1, //ENGBASE_MDP_WROT1,
0, //ENGBASE_MDP_TDSHP0,
0, //ENGBASE_MMSYS_MUTEX,
0, //ENGINE_IMGSYS
0, //ENGINE_IMGSYS2_CONFIG
0, //ENGBASE_ISP_DIP_A0
0, //ENGBASE_ISP_DIP_A1
0, //ENGBASE_ISP_DIP_A7
0, //ENGBASE_ISP_MSS_B
0, //ENGBASE_ISP_MFB_B
};
static u32 mdp_base[ENGBASE_COUNT] = {
[ENGBASE_MMSYS_CONFIG] = 0x1f000000,
[ENGBASE_MDP_RDMA0] = 0x1f003000,
[ENGBASE_MDP_AAL0] = 0x1f005000,
[ENGBASE_MDP_HDR0] = 0x1f007000,
[ENGBASE_MDP_RSZ0] = 0x1f008000,
[ENGBASE_MDP_RSZ1] = 0x1f009000,
[ENGBASE_MDP_WROT0] = 0x1f00a000,
[ENGBASE_MDP_WROT1] = 0x1f00b000,
[ENGBASE_MDP_TDSHP0] = 0x1f00c000,
[ENGBASE_MMSYS_MUTEX] = 0x1f001000,
[ENGBASE_IMGSYS] = 0x15020000,
[ENGBASE_IMGSYS2_CONFIG] = 0x15820000,
[ENGBASE_ISP_DIP_A0] = 0x15021000,
[ENGBASE_ISP_DIP_A1] = 0x15022000,
[ENGBASE_ISP_DIP_A7] = 0x15028000,
[ENGBASE_ISP_MSS_B] = 0x15812000,
[ENGBASE_ISP_MFB_B] = 0x15810000,
};
#endif
@@ -0,0 +1,154 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_ENGINE_H__
#define __MDP_ENGINE_H__
enum CMDQ_ENG_ENUM {
/* ISP */
CMDQ_ENG_WPEI = 0,
CMDQ_ENG_WPEO, /* 1 */
CMDQ_ENG_WPEI2, /* 2 */
CMDQ_ENG_WPEO2, /* 3 */
CMDQ_ENG_ISP_IMGI, /* 4 */
CMDQ_ENG_ISP_IMG2O, /* 5 */
/* MDP */
CMDQ_ENG_MDP_CAMIN, /* 6 */
CMDQ_ENG_MDP_CAMIN2, /* 7 */
CMDQ_ENG_MDP_RDMA0, /* 8 */
CMDQ_ENG_MDP_HDR0, /* 9 */
CMDQ_ENG_MDP_AAL0, /* 10 */
CMDQ_ENG_MDP_RSZ0, /* 11 */
CMDQ_ENG_MDP_RSZ1, /* 12 */
CMDQ_ENG_MDP_TDSHP0, /* 13 */
CMDQ_ENG_MDP_WROT0, /* 14 */
CMDQ_ENG_MDP_WROT1, /* 15 */
/* DPE */
CMDQ_ENG_DPE, /* 16 */
CMDQ_ENG_RSC, /* 17 */
CMDQ_ENG_GEPF, /* 18 */
CMDQ_ENG_EAF, /* 19 */
CMDQ_ENG_OWE, /* 20 */
CMDQ_ENG_MFB, /* 21 */
CMDQ_ENG_FDVT, /* 22 */
/* ISP sec */
CMDQ_ENG_ISP_VIPI, /* 23 */
CMDQ_ENG_ISP_LCEI, /* 24 */
CMDQ_ENG_ISP_IMG3O, /* 25 */
CMDQ_ENG_ISP_SMXIO, /* 26 */
CMDQ_ENG_ISP_DMGI_DEPI, /* 27 */
CMDQ_ENG_ISP_IMGCI, /* 28 */
CMDQ_ENG_ISP_UFBCI, /* 29 */
CMDQ_ENG_ISP_UFBCO, /* 30 */
CMDQ_ENG_INORDER, /*31 */
/* Dummy Engine */
CMDQ_ENG_ISP_TIMGO = 63,
CMDQ_ENG_ISP_IMGI2 = 63,
CMDQ_ENG_ISP_IMG2O2 = 63,
CMDQ_ENG_MDP_RSZ2 = 63,
CMDQ_ENG_MDP_WDMA = 63,
CMDQ_ENG_MDP_HDR1 = 63,
CMDQ_ENG_MDP_COLOR1 = 63,
CMDQ_ENG_MDP_RDMA1 = 63,
CMDQ_ENG_MDP_COLOR0 = 63,
CMDQ_ENG_MDP_AAL1 = 63,
CMDQ_ENG_MDP_TDSHP1 = 63,
CMDQ_MAX_ENGINE_COUNT /* ALWAYS keep at the end */
};
#define CMDQ_ENG_WPE_GROUP_BITS ((1LL << CMDQ_ENG_WPEI) | \
(1LL << CMDQ_ENG_WPEO) | \
(1LL << CMDQ_ENG_WPEI2) | \
(1LL << CMDQ_ENG_WPEO2))
#define CMDQ_ENG_ISP_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_IMG2O))
#define CMDQ_ENG_ISP_MTEE_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_VIPI) | \
(1LL << CMDQ_ENG_ISP_LCEI))
#define CMDQ_ENG_SVP_MTEE_GROUP_BITS (1LL << CMDQ_ENG_MDP_RDMA0)
#define CMDQ_ENG_MDP_GROUP_BITS ((1LL << CMDQ_ENG_MDP_CAMIN) | \
(1LL << CMDQ_ENG_MDP_CAMIN2) | \
(1LL << CMDQ_ENG_MDP_RDMA0) | \
(1LL << CMDQ_ENG_MDP_RDMA1) | \
(1LL << CMDQ_ENG_MDP_RSZ0) | \
(1LL << CMDQ_ENG_MDP_RSZ1) | \
(1LL << CMDQ_ENG_MDP_TDSHP0) | \
(1LL << CMDQ_ENG_MDP_TDSHP1) | \
(1LL << CMDQ_ENG_MDP_COLOR0) | \
(1LL << CMDQ_ENG_MDP_WROT0) | \
(1LL << CMDQ_ENG_MDP_WROT1) | \
(1LL << CMDQ_ENG_MDP_AAL0) | \
(1LL << CMDQ_ENG_MDP_AAL1) | \
(1LL << CMDQ_ENG_MDP_HDR0))
#define CMDQ_ENG_DPE_GROUP_BITS (1LL << CMDQ_ENG_DPE)
#define CMDQ_ENG_RSC_GROUP_BITS (1LL << CMDQ_ENG_RSC)
#define CMDQ_ENG_GEPF_GROUP_BITS (1LL << CMDQ_ENG_GEPF)
#define CMDQ_ENG_EAF_GROUP_BITS (1LL << CMDQ_ENG_EAF)
#define CMDQ_ENG_OWE_GROUP_BITS (1LL << CMDQ_ENG_OWE)
#define CMDQ_ENG_MFB_GROUP_BITS (1LL << CMDQ_ENG_MFB)
#define CMDQ_ENG_FDVT_GROUP_BITS (1LL << CMDQ_ENG_FDVT)
#define CMDQ_ENG_ISP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_ISP_GROUP_BITS))
#define CMDQ_ENG_MDP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_MDP_GROUP_BITS))
#define CMDQ_ENG_DPE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_DPE_GROUP_BITS))
#define CMDQ_ENG_RSC_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_RSC_GROUP_BITS))
#define CMDQ_ENG_GEPF_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_GEPF_GROUP_BITS))
#define CMDQ_ENG_WPE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_WPE_GROUP_BITS))
#define CMDQ_ENG_EAF_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_EAF_GROUP_BITS))
#define CMDQ_ENG_OWE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_OWE_GROUP_BITS))
#define CMDQ_ENG_MFB_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_MFB_GROUP_BITS))
#define CMDQ_ENG_FDVT_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_FDVT_GROUP_BITS))
#define CMDQ_FOREACH_GROUP(ACTION_struct)\
ACTION_struct(CMDQ_GROUP_ISP, ISP) \
ACTION_struct(CMDQ_GROUP_MDP, MDP) \
ACTION_struct(CMDQ_GROUP_DPE, DPE) \
ACTION_struct(CMDQ_GROUP_RSC, RSC) \
ACTION_struct(CMDQ_GROUP_GEPF, GEPF) \
ACTION_struct(CMDQ_GROUP_WPE, WPE) \
ACTION_struct(CMDQ_GROUP_EAF, EAF) \
ACTION_struct(CMDQ_GROUP_OWE, OWE) \
ACTION_struct(CMDQ_GROUP_MFB, MFB) \
ACTION_struct(CMDQ_GROUP_FDVT, FDVT)
#define MDP_GENERATE_ENUM(_enum, _string) _enum,
enum CMDQ_GROUP_ENUM {
CMDQ_FOREACH_GROUP(MDP_GENERATE_ENUM)
CMDQ_MAX_GROUP_COUNT, /* ALWAYS keep at the end */
};
enum MDP_ENG_BASE {
ENGBASE_MMSYS_CONFIG,
ENGBASE_MDP_RDMA0,
ENGBASE_MDP_AAL0,
ENGBASE_MDP_HDR0,
ENGBASE_MDP_RSZ0,
ENGBASE_MDP_RSZ1,
ENGBASE_MDP_WROT0,
ENGBASE_MDP_WROT1,
ENGBASE_MDP_TDSHP0,
ENGBASE_MMSYS_MUTEX,
ENGBASE_IMGSYS,
ENGBASE_IMGSYS2_CONFIG,
ENGBASE_ISP_DIP_A0,
ENGBASE_ISP_DIP_A1,
ENGBASE_ISP_DIP_A7,
ENGBASE_ISP_MSS_B,
ENGBASE_ISP_MFB_B,
ENGBASE_COUNT
};
#endif /* __MDP_ENGINE_H__ */
+44
View File
@@ -0,0 +1,44 @@
#
# Copyright (C) 2019 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# drivers/mdp
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mdp \
-I$(srctree)/drivers/misc/mediatek/mmdvfs/ \
-I$(srctree)/drivers/misc/mediatek/smi/ \
-I$(srctree)/drivers/misc/mediatek/smi/$(MTK_PLATFORM)/ \
-I$(srctree)/drivers/misc/mediatek/m4u/$(MTK_PLATFORM) \
-I$(srctree)/drivers/iommu
ccflags-$(CONFIG_MTK_CMDQ_MBOX_EXT) += -I$(srctree)/drivers/misc/mediatek/cmdq/mailbox/
ifeq ($(strip $(CONFIG_MTK_PQ_COLOR_MODE)),"MDP")
ccflags-y += -DCMDQ_MDP_COLOR
endif
# Enable MET
ccflags-y += -DMET_USER_EVENT_SUPPORT
# Enable AEE
ccflags-y += -DCMDQ_AEE_READY
# secure path
ifeq ($(or $(strip $(CONFIG_TRUSTONIC_TEE_SUPPORT)), $(strip $(CONFIG_MICROTRUST_TEE_SUPPORT)), \
$(strip $(CONFIG_MTK_ENABLE_GENIEZONE))),y)
ifeq ($(or $(strip $(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT)), $(strip $(CONFIG_MTK_CAM_SECURITY_SUPPORT))),y)
ccflags-y += -DCMDQ_SECURE_PATH_SUPPORT
endif # end of CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT or CONFIG_MTK_CAM_SECURITY_SUPPORT
endif # end of CONFIG_TRUSTONIC_TEE_SUPPORT or CONFIG_MICROTRUST_TEE_SUPPORT
obj-y += mdp.o
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,65 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_BASE_H__
#define __MDP_BASE_H__
#define MDP_HW_CHECK
#include "mach/mt_iommu.h"
static u32 mdp_engine_port[ENGBASE_COUNT] = {
0, //ENGBASE_MMSYS_CONFIG,
M4U_PORT_L2_MDP_RDMA0, //ENGBASE_MDP_RDMA0,
M4U_PORT_L2_MDP_RDMA1, //ENGBASE_MDP_RDMA1,
0, //ENGBASE_MDP_AAL0,
0, //ENGBASE_MDP_AAL1,
0, //ENGBASE_MDP_HDR0,
0, //ENGBASE_MDP_RSZ0,
0, //ENGBASE_MDP_RSZ1,
M4U_PORT_L2_MDP_WROT0, //ENGBASE_MDP_WROT0,
M4U_PORT_L2_MDP_WROT1, //ENGBASE_MDP_WROT1,
0, //ENGBASE_MDP_TDSHP0,
0, //ENGBASE_MDP_TDSHP1,
0, //ENGBASE_MDP_COLOR0,
0, //ENGBASE_MMSYS_MUTEX,
0, //ENGINE_IMGSYS
0, //ENGBASE_ISP_DIP_A0
0, //ENGBASE_ISP_DIP_A1
0, //ENGBASE_ISP_DIP_A7
0, //ENGBASE_ISP_MSFDL
0, //ENGBASE_ISP_MSS_B
0, //ENGBASE_ISP_MFB_B
0, //ENGBASE_ISP_WPE_A
0, //ENGBASE_ISP_WPE_B
};
static u32 mdp_base[ENGBASE_COUNT] = {
[ENGBASE_MMSYS_CONFIG] = 0x1f000000,
[ENGBASE_MDP_RDMA0] = 0x1f003000,
[ENGBASE_MDP_RDMA1] = 0x1f004000,
[ENGBASE_MDP_AAL0] = 0x1f005000,
[ENGBASE_MDP_AAL1] = 0x1f006000,
[ENGBASE_MDP_HDR0] = 0x1f007000,
[ENGBASE_MDP_RSZ0] = 0x1f008000,
[ENGBASE_MDP_RSZ1] = 0x1f009000,
[ENGBASE_MDP_WROT0] = 0x1f00a000,
[ENGBASE_MDP_WROT1] = 0x1f00b000,
[ENGBASE_MDP_TDSHP0] = 0x1f00c000,
[ENGBASE_MDP_TDSHP1] = 0x1f00d000,
[ENGBASE_MDP_COLOR0] = 0x1f00e000,
[ENGBASE_MMSYS_MUTEX] = 0x1f001000,
[ENGBASE_IMGSYS] = 0x15020000,
[ENGBASE_ISP_DIP_A0] = 0x15021000,
[ENGBASE_ISP_DIP_A1] = 0x15022000,
[ENGBASE_ISP_DIP_A7] = 0x15028000,
[ENGBASE_ISP_MSFDL] = 0x15810000,
[ENGBASE_ISP_MSS_B] = 0x15812000,
[ENGBASE_ISP_MFB_B] = 0x15820000,
[ENGBASE_ISP_WPE_A] = 0x15011000,
[ENGBASE_ISP_WPE_B] = 0x15811000,
};
#endif
@@ -0,0 +1,165 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_ENGINE_H__
#define __MDP_ENGINE_H__
enum CMDQ_ENG_ENUM {
/* ISP */
CMDQ_ENG_WPEI = 0,
CMDQ_ENG_WPEO, /* 1 */
CMDQ_ENG_WPEI2, /* 2 */
CMDQ_ENG_WPEO2, /* 3 */
CMDQ_ENG_ISP_IMGI, /* 4 */
CMDQ_ENG_ISP_IMG2O, /* 5 */
/* MDP */
CMDQ_ENG_MDP_CAMIN, /* 6 */
CMDQ_ENG_MDP_CAMIN2, /* 7 */
CMDQ_ENG_MDP_RDMA0, /* 8 */
CMDQ_ENG_MDP_RDMA1, /* 9 */
CMDQ_ENG_MDP_HDR0, /* 10 */
CMDQ_ENG_MDP_COLOR0, /* 11 */
CMDQ_ENG_MDP_AAL0, /* 12 */
CMDQ_ENG_MDP_AAL1, /* 13 */
CMDQ_ENG_MDP_RSZ0, /* 14 */
CMDQ_ENG_MDP_RSZ1, /* 15 */
CMDQ_ENG_MDP_TDSHP0, /* 16 */
CMDQ_ENG_MDP_TDSHP1, /* 17 */
CMDQ_ENG_MDP_WROT0, /* 18 */
CMDQ_ENG_MDP_WROT1, /* 19 */
/* DPE */
CMDQ_ENG_DPE, /* 20 */
CMDQ_ENG_RSC, /* 21 */
CMDQ_ENG_GEPF, /* 22 */
CMDQ_ENG_EAF, /* 23 */
CMDQ_ENG_OWE, /* 24 */
CMDQ_ENG_MFB, /* 25 */
CMDQ_ENG_FDVT, /* 26 */
/* ISP sec */
CMDQ_ENG_ISP_VIPI, /* 27 */
CMDQ_ENG_ISP_LCEI, /* 28 */
CMDQ_ENG_ISP_IMG3O, /* 29 */
CMDQ_ENG_ISP_SMXIO, /* 30 */
CMDQ_ENG_ISP_DMGI_DEPI, /* 31 */
CMDQ_ENG_ISP_IMGCI, /* 32 */
CMDQ_ENG_ISP_UFBCI, /* 33 */
CMDQ_ENG_ISP_UFBCO, /* 34 */
CMDQ_ENG_INORDER, /*35 */
/* Dummy Engine */
CMDQ_ENG_ISP_TIMGO = 63,
CMDQ_ENG_ISP_IMGI2 = 63,
CMDQ_ENG_ISP_IMG2O2 = 63,
CMDQ_ENG_MDP_RSZ2 = 63,
CMDQ_ENG_MDP_WDMA = 63,
CMDQ_ENG_MDP_HDR1 = 63,
CMDQ_ENG_MDP_COLOR1 = 63,
CMDQ_MAX_ENGINE_COUNT /* ALWAYS keep at the end */
};
#define CMDQ_ENG_WPE_GROUP_BITS ((1LL << CMDQ_ENG_WPEI) | \
(1LL << CMDQ_ENG_WPEO) | \
(1LL << CMDQ_ENG_WPEI2) | \
(1LL << CMDQ_ENG_WPEO2))
#define CMDQ_ENG_ISP_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_IMG2O))
#define CMDQ_ENG_ISP_MTEE_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_VIPI) | \
(1LL << CMDQ_ENG_ISP_LCEI))
#define CMDQ_ENG_SVP_MTEE_GROUP_BITS ((1LL << CMDQ_ENG_MDP_RDMA0) | \
(1LL << CMDQ_ENG_MDP_RDMA1))
#define CMDQ_ENG_MTEE_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_VIPI) | \
(1LL << CMDQ_ENG_ISP_LCEI))
#define CMDQ_ENG_MDP_GROUP_BITS ((1LL << CMDQ_ENG_MDP_CAMIN) | \
(1LL << CMDQ_ENG_MDP_CAMIN2) | \
(1LL << CMDQ_ENG_MDP_RDMA0) | \
(1LL << CMDQ_ENG_MDP_RDMA1) | \
(1LL << CMDQ_ENG_MDP_RSZ0) | \
(1LL << CMDQ_ENG_MDP_RSZ1) | \
(1LL << CMDQ_ENG_MDP_TDSHP0) | \
(1LL << CMDQ_ENG_MDP_TDSHP1) | \
(1LL << CMDQ_ENG_MDP_COLOR0) | \
(1LL << CMDQ_ENG_MDP_WROT0) | \
(1LL << CMDQ_ENG_MDP_WROT1) | \
(1LL << CMDQ_ENG_MDP_AAL0) | \
(1LL << CMDQ_ENG_MDP_AAL1) | \
(1LL << CMDQ_ENG_MDP_HDR0))
#define CMDQ_ENG_DPE_GROUP_BITS (1LL << CMDQ_ENG_DPE)
#define CMDQ_ENG_RSC_GROUP_BITS (1LL << CMDQ_ENG_RSC)
#define CMDQ_ENG_GEPF_GROUP_BITS (1LL << CMDQ_ENG_GEPF)
#define CMDQ_ENG_EAF_GROUP_BITS (1LL << CMDQ_ENG_EAF)
#define CMDQ_ENG_OWE_GROUP_BITS (1LL << CMDQ_ENG_OWE)
#define CMDQ_ENG_MFB_GROUP_BITS (1LL << CMDQ_ENG_MFB)
#define CMDQ_ENG_FDVT_GROUP_BITS (1LL << CMDQ_ENG_FDVT)
#define CMDQ_ENG_ISP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_ISP_GROUP_BITS))
#define CMDQ_ENG_MDP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_MDP_GROUP_BITS))
#define CMDQ_ENG_DPE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_DPE_GROUP_BITS))
#define CMDQ_ENG_RSC_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_RSC_GROUP_BITS))
#define CMDQ_ENG_GEPF_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_GEPF_GROUP_BITS))
#define CMDQ_ENG_WPE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_WPE_GROUP_BITS))
#define CMDQ_ENG_EAF_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_EAF_GROUP_BITS))
#define CMDQ_ENG_OWE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_OWE_GROUP_BITS))
#define CMDQ_ENG_MFB_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_MFB_GROUP_BITS))
#define CMDQ_ENG_FDVT_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_FDVT_GROUP_BITS))
#define CMDQ_FOREACH_GROUP(ACTION_struct)\
ACTION_struct(CMDQ_GROUP_ISP, ISP) \
ACTION_struct(CMDQ_GROUP_MDP, MDP) \
ACTION_struct(CMDQ_GROUP_DPE, DPE) \
ACTION_struct(CMDQ_GROUP_RSC, RSC) \
ACTION_struct(CMDQ_GROUP_GEPF, GEPF) \
ACTION_struct(CMDQ_GROUP_WPE, WPE) \
ACTION_struct(CMDQ_GROUP_EAF, EAF) \
ACTION_struct(CMDQ_GROUP_OWE, OWE) \
ACTION_struct(CMDQ_GROUP_MFB, MFB) \
ACTION_struct(CMDQ_GROUP_FDVT, FDVT)
#define MDP_GENERATE_ENUM(_enum, _string) _enum,
enum CMDQ_GROUP_ENUM {
CMDQ_FOREACH_GROUP(MDP_GENERATE_ENUM)
CMDQ_MAX_GROUP_COUNT, /* ALWAYS keep at the end */
};
enum MDP_ENG_BASE {
ENGBASE_MMSYS_CONFIG,
ENGBASE_MDP_RDMA0,
ENGBASE_MDP_RDMA1,
ENGBASE_MDP_AAL0,
ENGBASE_MDP_AAL1,
ENGBASE_MDP_HDR0,
ENGBASE_MDP_RSZ0,
ENGBASE_MDP_RSZ1,
ENGBASE_MDP_WROT0,
ENGBASE_MDP_WROT1,
ENGBASE_MDP_TDSHP0,
ENGBASE_MDP_TDSHP1,
ENGBASE_MDP_COLOR0,
ENGBASE_MMSYS_MUTEX,
ENGBASE_IMGSYS,
ENGBASE_ISP_DIP_A0,
ENGBASE_ISP_DIP_A1,
ENGBASE_ISP_DIP_A7,
ENGBASE_ISP_MSFDL,
ENGBASE_ISP_MSS_B,
ENGBASE_ISP_MFB_B,
ENGBASE_ISP_WPE_A,
ENGBASE_ISP_WPE_B,
ENGBASE_COUNT
};
#endif /* __MDP_ENGINE_H__ */
+44
View File
@@ -0,0 +1,44 @@
#
# Copyright (C) 2019 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# drivers/mdp
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mdp \
-I$(srctree)/drivers/misc/mediatek/mmdvfs/ \
-I$(srctree)/drivers/misc/mediatek/smi/ \
-I$(srctree)/drivers/misc/mediatek/smi/$(MTK_PLATFORM)/ \
-I$(srctree)/drivers/misc/mediatek/m4u/$(MTK_PLATFORM) \
-I$(srctree)/drivers/iommu
ccflags-$(CONFIG_MTK_CMDQ_MBOX_EXT) += -I$(srctree)/drivers/misc/mediatek/cmdq/mailbox/
ifeq ($(strip $(CONFIG_MTK_PQ_COLOR_MODE)),"MDP")
ccflags-y += -DCMDQ_MDP_COLOR
endif
# Enable MET
ccflags-y += -DMET_USER_EVENT_SUPPORT
# Enable AEE
ccflags-y += -DCMDQ_AEE_READY
# secure path
ifeq ($(or $(strip $(CONFIG_TRUSTONIC_TEE_SUPPORT)), $(strip $(CONFIG_MICROTRUST_TEE_SUPPORT)), \
$(strip $(CONFIG_MTK_ENABLE_GENIEZONE))),y)
ifeq ($(or $(strip $(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT)), $(strip $(CONFIG_MTK_CAM_SECURITY_SUPPORT))),y)
ccflags-y += -DCMDQ_SECURE_PATH_SUPPORT
endif # end of CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT or CONFIG_MTK_CAM_SECURITY_SUPPORT
endif # end of CONFIG_TRUSTONIC_TEE_SUPPORT or CONFIG_MICROTRUST_TEE_SUPPORT
obj-y += mdp.o
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,69 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_BASE_H__
#define __MDP_BASE_H__
#define MDP_HW_CHECK
#include "mach/mt_iommu.h"
static u32 mdp_engine_port[ENGBASE_COUNT] = {
0, //ENGBASE_MMSYS_CONFIG,
M4U_PORT_L2_MDP_RDMA0, //ENGBASE_MDP_RDMA0,
M4U_PORT_L2_MDP_RDMA1, //ENGBASE_MDP_RDMA1,
0, //ENGBASE_MDP_AAL0,
0, //ENGBASE_MDP_AAL1,
0, //ENGBASE_MDP_HDR0,
0, //ENGBASE_MDP_HDR1,
0, //ENGBASE_MDP_RSZ0,
0, //ENGBASE_MDP_RSZ1,
M4U_PORT_L2_MDP_WROT0, //ENGBASE_MDP_WROT0,
M4U_PORT_L2_MDP_WROT1, //ENGBASE_MDP_WROT1,
0, //ENGBASE_MDP_TDSHP0,
0, //ENGBASE_MDP_TDSHP1,
0, //ENGBASE_MDP_COLOR0,
0, //ENGBASE_MDP_COLOR1,
0, //ENGBASE_MMSYS_MUTEX,
0, //ENGBASE_IMGSYS,
0, //ENGBASE_ISP_DIP_A0,
0, //ENGBASE_ISP_DIP_A1,
0, //ENGBASE_ISP_DIP_A7,
0, //ENGBASE_ISP_MSFDL,
0, //ENGBASE_ISP_MSS_B,
0, //ENGBASE_ISP_MFB_B,
0, //ENGBASE_ISP_WPE_A,
0, //ENGBASE_ISP_WPE_B,
};
static u32 mdp_base[ENGBASE_COUNT] = {
[ENGBASE_MMSYS_CONFIG] = 0x1f000000,
[ENGBASE_MDP_RDMA0] = 0x1f003000,
[ENGBASE_MDP_RDMA1] = 0x1f004000,
[ENGBASE_MDP_AAL0] = 0x1f005000,
[ENGBASE_MDP_AAL1] = 0x1f006000,
[ENGBASE_MDP_HDR0] = 0x1f007000,
[ENGBASE_MDP_HDR1] = 0x1f008000,
[ENGBASE_MDP_RSZ0] = 0x1f009000,
[ENGBASE_MDP_RSZ1] = 0x1f00a000,
[ENGBASE_MDP_WROT0] = 0x1f00b000,
[ENGBASE_MDP_WROT1] = 0x1f00c000,
[ENGBASE_MDP_TDSHP0] = 0x1f00d000,
[ENGBASE_MDP_TDSHP1] = 0x1f00e000,
[ENGBASE_MDP_COLOR0] = 0x1f00f000,
[ENGBASE_MDP_COLOR1] = 0x1f010000,
[ENGBASE_MMSYS_MUTEX] = 0x1f001000,
[ENGBASE_IMGSYS] = 0x15020000,
[ENGBASE_ISP_DIP_A0] = 0x15021000,
[ENGBASE_ISP_DIP_A1] = 0x15022000,
[ENGBASE_ISP_DIP_A7] = 0x15028000,
[ENGBASE_ISP_MSFDL] = 0x15810000,
[ENGBASE_ISP_MSS_B] = 0x15812000,
[ENGBASE_ISP_MFB_B] = 0x15820000,
[ENGBASE_ISP_WPE_A] = 0x15011000,
[ENGBASE_ISP_WPE_B] = 0x15811000,
};
#endif
@@ -0,0 +1,169 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_ENGINE_H__
#define __MDP_ENGINE_H__
enum CMDQ_ENG_ENUM {
/* ISP */
CMDQ_ENG_WPEI = 0,
CMDQ_ENG_WPEO, /* 1 */
CMDQ_ENG_WPEI2, /* 2 */
CMDQ_ENG_WPEO2, /* 3 */
CMDQ_ENG_ISP_IMGI, /* 4 */
CMDQ_ENG_ISP_IMG2O, /* 5 */
/* MDP */
CMDQ_ENG_MDP_CAMIN, /* 6 */
CMDQ_ENG_MDP_CAMIN2, /* 7 */
CMDQ_ENG_MDP_RDMA0, /* 8 */
CMDQ_ENG_MDP_RDMA1, /* 9 */
CMDQ_ENG_MDP_HDR0, /* 10 */
CMDQ_ENG_MDP_HDR1, /* 11 */
CMDQ_ENG_MDP_COLOR0, /* 12 */
CMDQ_ENG_MDP_COLOR1, /* 13 */
CMDQ_ENG_MDP_AAL0, /* 14 */
CMDQ_ENG_MDP_AAL1, /* 15 */
CMDQ_ENG_MDP_RSZ0, /* 16 */
CMDQ_ENG_MDP_RSZ1, /* 17 */
CMDQ_ENG_MDP_TDSHP0, /* 18 */
CMDQ_ENG_MDP_TDSHP1, /* 19 */
CMDQ_ENG_MDP_WROT0, /* 20 */
CMDQ_ENG_MDP_WROT1, /* 21 */
/* DPE */
CMDQ_ENG_DPE, /* 22 */
CMDQ_ENG_RSC, /* 23 */
CMDQ_ENG_GEPF, /* 24 */
CMDQ_ENG_EAF, /* 25 */
CMDQ_ENG_OWE, /* 26 */
CMDQ_ENG_MFB, /* 27 */
CMDQ_ENG_FDVT, /* 28 */
/* ISP sec */
CMDQ_ENG_ISP_VIPI, /* 29 */
CMDQ_ENG_ISP_LCEI, /* 30 */
CMDQ_ENG_ISP_IMG3O, /* 31 */
CMDQ_ENG_ISP_SMXIO, /* 32 */
CMDQ_ENG_ISP_DMGI_DEPI, /* 33 */
CMDQ_ENG_ISP_IMGCI, /* 34 */
CMDQ_ENG_ISP_UFBCI, /* 35 */
CMDQ_ENG_ISP_UFBCO, /* 36 */
CMDQ_ENG_INORDER, /*37 */
/* Dummy Engine */
CMDQ_ENG_ISP_TIMGO = 63,
CMDQ_ENG_ISP_IMGI2 = 63,
CMDQ_ENG_ISP_IMG2O2 = 63,
CMDQ_ENG_MDP_RSZ2 = 63,
CMDQ_ENG_MDP_WDMA = 63,
CMDQ_MAX_ENGINE_COUNT /* ALWAYS keep at the end */
};
#define CMDQ_ENG_WPE_GROUP_BITS ((1LL << CMDQ_ENG_WPEI) | \
(1LL << CMDQ_ENG_WPEO) | \
(1LL << CMDQ_ENG_WPEI2) | \
(1LL << CMDQ_ENG_WPEO2))
#define CMDQ_ENG_ISP_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_IMG2O))
#define CMDQ_ENG_ISP_MTEE_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_VIPI) | \
(1LL << CMDQ_ENG_ISP_LCEI))
#define CMDQ_ENG_SVP_MTEE_GROUP_BITS ((1LL << CMDQ_ENG_MDP_RDMA0) | \
(1LL << CMDQ_ENG_MDP_RDMA1))
#define CMDQ_ENG_MTEE_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_VIPI) | \
(1LL << CMDQ_ENG_ISP_LCEI))
#define CMDQ_ENG_MDP_GROUP_BITS ((1LL << CMDQ_ENG_MDP_CAMIN) | \
(1LL << CMDQ_ENG_MDP_CAMIN2) | \
(1LL << CMDQ_ENG_MDP_RDMA0) | \
(1LL << CMDQ_ENG_MDP_RDMA1) | \
(1LL << CMDQ_ENG_MDP_RSZ0) | \
(1LL << CMDQ_ENG_MDP_RSZ1) | \
(1LL << CMDQ_ENG_MDP_TDSHP0) | \
(1LL << CMDQ_ENG_MDP_TDSHP1) | \
(1LL << CMDQ_ENG_MDP_COLOR0) | \
(1LL << CMDQ_ENG_MDP_COLOR1) | \
(1LL << CMDQ_ENG_MDP_WROT0) | \
(1LL << CMDQ_ENG_MDP_WROT1) | \
(1LL << CMDQ_ENG_MDP_AAL0) | \
(1LL << CMDQ_ENG_MDP_AAL1) | \
(1LL << CMDQ_ENG_MDP_HDR0) | \
(1LL << CMDQ_ENG_MDP_HDR1))
#define CMDQ_ENG_DPE_GROUP_BITS (1LL << CMDQ_ENG_DPE)
#define CMDQ_ENG_RSC_GROUP_BITS (1LL << CMDQ_ENG_RSC)
#define CMDQ_ENG_GEPF_GROUP_BITS (1LL << CMDQ_ENG_GEPF)
#define CMDQ_ENG_EAF_GROUP_BITS (1LL << CMDQ_ENG_EAF)
#define CMDQ_ENG_OWE_GROUP_BITS (1LL << CMDQ_ENG_OWE)
#define CMDQ_ENG_MFB_GROUP_BITS (1LL << CMDQ_ENG_MFB)
#define CMDQ_ENG_FDVT_GROUP_BITS (1LL << CMDQ_ENG_FDVT)
#define CMDQ_ENG_ISP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_ISP_GROUP_BITS))
#define CMDQ_ENG_MDP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_MDP_GROUP_BITS))
#define CMDQ_ENG_DPE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_DPE_GROUP_BITS))
#define CMDQ_ENG_RSC_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_RSC_GROUP_BITS))
#define CMDQ_ENG_GEPF_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_GEPF_GROUP_BITS))
#define CMDQ_ENG_WPE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_WPE_GROUP_BITS))
#define CMDQ_ENG_EAF_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_EAF_GROUP_BITS))
#define CMDQ_ENG_OWE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_OWE_GROUP_BITS))
#define CMDQ_ENG_MFB_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_MFB_GROUP_BITS))
#define CMDQ_ENG_FDVT_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_FDVT_GROUP_BITS))
#define CMDQ_FOREACH_GROUP(ACTION_struct)\
ACTION_struct(CMDQ_GROUP_ISP, ISP) \
ACTION_struct(CMDQ_GROUP_MDP, MDP) \
ACTION_struct(CMDQ_GROUP_DPE, DPE) \
ACTION_struct(CMDQ_GROUP_RSC, RSC) \
ACTION_struct(CMDQ_GROUP_GEPF, GEPF) \
ACTION_struct(CMDQ_GROUP_WPE, WPE) \
ACTION_struct(CMDQ_GROUP_EAF, EAF) \
ACTION_struct(CMDQ_GROUP_OWE, OWE) \
ACTION_struct(CMDQ_GROUP_MFB, MFB) \
ACTION_struct(CMDQ_GROUP_FDVT, FDVT)
#define MDP_GENERATE_ENUM(_enum, _string) _enum,
enum CMDQ_GROUP_ENUM {
CMDQ_FOREACH_GROUP(MDP_GENERATE_ENUM)
CMDQ_MAX_GROUP_COUNT, /* ALWAYS keep at the end */
};
enum MDP_ENG_BASE {
ENGBASE_MMSYS_CONFIG,
ENGBASE_MDP_RDMA0,
ENGBASE_MDP_RDMA1,
ENGBASE_MDP_AAL0,
ENGBASE_MDP_AAL1,
ENGBASE_MDP_HDR0,
ENGBASE_MDP_HDR1,
ENGBASE_MDP_RSZ0,
ENGBASE_MDP_RSZ1,
ENGBASE_MDP_WROT0,
ENGBASE_MDP_WROT1,
ENGBASE_MDP_TDSHP0,
ENGBASE_MDP_TDSHP1,
ENGBASE_MDP_COLOR0,
ENGBASE_MDP_COLOR1,
ENGBASE_MMSYS_MUTEX,
ENGBASE_IMGSYS,
ENGBASE_ISP_DIP_A0,
ENGBASE_ISP_DIP_A1,
ENGBASE_ISP_DIP_A7,
ENGBASE_ISP_MSFDL,
ENGBASE_ISP_MSS_B,
ENGBASE_ISP_MFB_B,
ENGBASE_ISP_WPE_A,
ENGBASE_ISP_WPE_B,
ENGBASE_COUNT
};
#endif /* __MDP_ENGINE_H__ */
+44
View File
@@ -0,0 +1,44 @@
#
# Copyright (C) 2019 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# drivers/mdp
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mdp \
-I$(srctree)/drivers/misc/mediatek/mmdvfs/ \
-I$(srctree)/drivers/misc/mediatek/smi/ \
-I$(srctree)/drivers/misc/mediatek/smi/$(MTK_PLATFORM)/ \
-I$(srctree)/drivers/misc/mediatek/m4u/$(MTK_PLATFORM) \
-I$(srctree)/drivers/iommu
ccflags-$(CONFIG_MTK_CMDQ_MBOX_EXT) += -I$(srctree)/drivers/misc/mediatek/cmdq/mailbox/
ifeq ($(strip $(CONFIG_MTK_PQ_COLOR_MODE)),"MDP")
ccflags-y += -DCMDQ_MDP_COLOR
endif
# Enable MET
ccflags-y += -DMET_USER_EVENT_SUPPORT
# Enable AEE
ccflags-y += -DCMDQ_AEE_READY
# secure path
ifeq ($(or $(strip $(CONFIG_TRUSTONIC_TEE_SUPPORT)), $(strip $(CONFIG_MICROTRUST_TEE_SUPPORT)), \
$(strip $(CONFIG_MTK_ENABLE_GENIEZONE))),y)
ifeq ($(or $(strip $(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT)), $(strip $(CONFIG_MTK_CAM_SECURITY_SUPPORT))),y)
ccflags-y += -DCMDQ_SECURE_PATH_SUPPORT
endif # end of CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT or CONFIG_MTK_CAM_SECURITY_SUPPORT
endif # end of CONFIG_TRUSTONIC_TEE_SUPPORT or CONFIG_MICROTRUST_TEE_SUPPORT
obj-y += mdp.o
File diff suppressed because it is too large. Load diff
+107
View File
@@ -0,0 +1,107 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_BASE_H__
#define __MDP_BASE_H__
#define MDP_HW_CHECK
#include "mach/mt_iommu.h"
static u32 mdp_engine_port[ENGBASE_COUNT] = {
0, // ENGBASE_MMSYS_CONFIG,
M4U_PORT_L2_MDP_RDMA0, // ENGBASE_MDP_RDMA0,
M4U_PORT_L3_MDP_RDMA1, // ENGBASE_MDP_RDMA1,
M4U_PORT_L2_MDP_RDMA2, // ENGBASE_MDP_RDMA2,
M4U_PORT_L3_MDP_RDMA3, // ENGBASE_MDP_RDMA3,
0, // ENGBASE_MDP_FG0,
0, // ENGBASE_MDP_FG1,
0, // ENGBASE_MDP_AAL0,
0, // ENGBASE_MDP_AAL1,
0, // ENGBASE_MDP_AAL2,
0, // ENGBASE_MDP_AAL3,
0, // ENGBASE_MDP_HDR0,
0, // ENGBASE_MDP_HDR1,
0, // ENGBASE_MDP_RSZ0,
0, // ENGBASE_MDP_RSZ1,
0, // ENGBASE_MDP_RSZ2,
0, // ENGBASE_MDP_RSZ3,
M4U_PORT_L2_MDP_WROT0, // ENGBASE_MDP_WROT0,
M4U_PORT_L3_MDP_WROT1, // ENGBASE_MDP_WROT1,
M4U_PORT_L2_MDP_WROT2, // ENGBASE_MDP_WROT2,
M4U_PORT_L3_MDP_WROT3, // ENGBASE_MDP_WROT3,
0, // ENGBASE_MDP_TDSHP0,
0, // ENGBASE_MDP_TDSHP1,
0, // ENGBASE_MDP_TDSHP2,
0, // ENGBASE_MDP_TDSHP3,
0, // ENGBASE_MDP_TCC0,
0, // ENGBASE_MDP_TCC1,
0, // ENGBASE_MDP_TCC2,
0, // ENGBASE_MDP_TCC3,
0, // ENGBASE_MDP_COLOR0,
0, // ENGBASE_MDP_COLOR1,
0, // ENGBASE_MMSYS_MUTEX,
0, // ENGBASE_ISP_MSFDL,
0, // ENGBASE_ISP_MSS,
0, // ENGBASE_ISP_MFB,
0, // ENGBASE_ISP_DIP_A0,
0, // ENGBASE_ISP_DIP_A1,
0, // ENGBASE_ISP_DIP_A7,
0, // ENGBASE_IMGSYS2_CONFIG,
0, // ENGBASE_ISP_DIP_B0,
0, // ENGBASE_ISP_DIP_B1,
0, // ENGBASE_ISP_DIP_B7,
0, // ENGBASE_ISP_WPE_A,
0, // ENGBASE_ISP_WPE_B,
};
static u32 mdp_base[ENGBASE_COUNT] = {
[ENGBASE_MMSYS_CONFIG] = 0x1f000000,
[ENGBASE_MDP_RDMA0] = 0x1f006000,
[ENGBASE_MDP_RDMA1] = 0x1f007000,
[ENGBASE_MDP_RDMA2] = 0x1f008000,
[ENGBASE_MDP_RDMA3] = 0x1f009000,
[ENGBASE_MDP_FG0] = 0x1f00a000,
[ENGBASE_MDP_FG1] = 0x1f00b000,
[ENGBASE_MDP_AAL0] = 0x1f00c000,
[ENGBASE_MDP_AAL1] = 0x1f00d000,
[ENGBASE_MDP_AAL2] = 0x1f00e000,
[ENGBASE_MDP_AAL3] = 0x1f00f000,
[ENGBASE_MDP_HDR0] = 0x1f010000,
[ENGBASE_MDP_HDR1] = 0x1f011000,
[ENGBASE_MDP_RSZ0] = 0x1f012000,
[ENGBASE_MDP_RSZ1] = 0x1f013000,
[ENGBASE_MDP_RSZ2] = 0x1f014000,
[ENGBASE_MDP_RSZ3] = 0x1f015000,
[ENGBASE_MDP_WROT0] = 0x1f016000,
[ENGBASE_MDP_WROT1] = 0x1f017000,
[ENGBASE_MDP_WROT2] = 0x1f018000,
[ENGBASE_MDP_WROT3] = 0x1f019000,
[ENGBASE_MDP_TDSHP0] = 0x1f01a000,
[ENGBASE_MDP_TDSHP1] = 0x1f01b000,
[ENGBASE_MDP_TDSHP2] = 0x1f01c000,
[ENGBASE_MDP_TDSHP3] = 0x1f01d000,
[ENGBASE_MDP_TCC0] = 0x1f01e000,
[ENGBASE_MDP_TCC1] = 0x1f01f000,
[ENGBASE_MDP_TCC2] = 0x1f020000,
[ENGBASE_MDP_TCC3] = 0x1f021000,
[ENGBASE_MDP_COLOR0] = 0x1f02c000,
[ENGBASE_MDP_COLOR1] = 0x1f02d000,
[ENGBASE_MMSYS_MUTEX] = 0x1f001000,
[ENGBASE_ISP_MSFDL] = 0x15010000,
[ENGBASE_ISP_MSS] = 0x15012000,
[ENGBASE_ISP_MFB] = 0x15020000,
[ENGBASE_ISP_DIP_A0] = 0x15021000,
[ENGBASE_ISP_DIP_A1] = 0x15022000,
[ENGBASE_ISP_DIP_A7] = 0x15028000,
[ENGBASE_IMGSYS2_CONFIG] = 0x15820000,
[ENGBASE_ISP_DIP_B0] = 0x15821000,
[ENGBASE_ISP_DIP_B1] = 0x15822000,
[ENGBASE_ISP_DIP_B7] = 0x15828000,
[ENGBASE_ISP_WPE_A] = 0x15011000,
[ENGBASE_ISP_WPE_B] = 0x15811000,
};
#endif
@@ -0,0 +1,232 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_ENGINE_H__
#define __MDP_ENGINE_H__
enum CMDQ_ENG_ENUM {
/* ISP */
CMDQ_ENG_WPEI = 0,
CMDQ_ENG_WPEO, /* 1 */
CMDQ_ENG_WPEI2, /* 2 */
CMDQ_ENG_WPEO2, /* 3 */
CMDQ_ENG_ISP_IMGI, /* 4 */
CMDQ_ENG_ISP_IMGI2, /* 5 */
CMDQ_ENG_ISP_IMG2O, /* 6 */
CMDQ_ENG_ISP_IMG2O2, /* 7 */
/* MDP */
CMDQ_ENG_MDP_CAMIN, /* 8 */
CMDQ_ENG_MDP_CAMIN2, /* 9 */
CMDQ_ENG_MDP_CAMIN3, /* 10 */
CMDQ_ENG_MDP_CAMIN4, /* 11 */
CMDQ_ENG_MDP_RDMA0, /* 12 */
CMDQ_ENG_MDP_RDMA1, /* 13 */
CMDQ_ENG_MDP_RDMA2, /* 14 */
CMDQ_ENG_MDP_RDMA3, /* 15 */
CMDQ_ENG_MDP_FG0, /* 16 */
CMDQ_ENG_MDP_FG1, /* 17 */
CMDQ_ENG_MDP_PQ0_SOUT, /* 18 */
CMDQ_ENG_MDP_PQ1_SOUT, /* 19 */
CMDQ_ENG_MDP_HDR0, /* 20 */
CMDQ_ENG_MDP_HDR1, /* 21 */
CMDQ_ENG_MDP_COLOR0, /* 22 */
CMDQ_ENG_MDP_COLOR1, /* 23 */
CMDQ_ENG_MDP_AAL0, /* 24 */
CMDQ_ENG_MDP_AAL1, /* 25 */
CMDQ_ENG_MDP_AAL2, /* 26 */
CMDQ_ENG_MDP_AAL3, /* 27 */
CMDQ_ENG_MDP_RSZ0, /* 28 */
CMDQ_ENG_MDP_RSZ1, /* 29 */
CMDQ_ENG_MDP_RSZ2, /* 30 */
CMDQ_ENG_MDP_RSZ3, /* 31 */
CMDQ_ENG_MDP_TDSHP0, /* 32 */
CMDQ_ENG_MDP_TDSHP1, /* 33 */
CMDQ_ENG_MDP_TDSHP2, /* 34 */
CMDQ_ENG_MDP_TDSHP3, /* 35 */
CMDQ_ENG_MDP_TCC0, /* 36 */
CMDQ_ENG_MDP_TCC1, /* 37 */
CMDQ_ENG_MDP_TCC2, /* 38 */
CMDQ_ENG_MDP_TCC3, /* 39 */
CMDQ_ENG_MDP_WROT0, /* 40 */
CMDQ_ENG_MDP_WROT1, /* 41 */
CMDQ_ENG_MDP_WROT2, /* 42 */
CMDQ_ENG_MDP_WROT3, /* 43 */
/* DPE */
CMDQ_ENG_DPE, /* 44 */
CMDQ_ENG_RSC, /* 45 */
CMDQ_ENG_GEPF, /* 46 */
CMDQ_ENG_EAF, /* 47 */
CMDQ_ENG_OWE, /* 48 */
CMDQ_ENG_MFB, /* 49 */
CMDQ_ENG_FDVT, /* 50 */
/* ISP sec */
CMDQ_ENG_ISP_VIPI, /* 51 */
CMDQ_ENG_ISP_LCEI, /* 52 */
CMDQ_ENG_ISP_IMG3O, /* 53 */
CMDQ_ENG_ISP_SMXIO, /* 54 */
CMDQ_ENG_ISP_DMGI_DEPI, /* 55 */
CMDQ_ENG_ISP_IMGCI, /* 56 */
CMDQ_ENG_ISP_UFBCI, /* 57 */
CMDQ_ENG_ISP_UFBCO, /* 58 */
CMDQ_ENG_ISP_MSS, /* 59 */
CMDQ_ENG_ISP_MSF, /* 60 */
CMDQ_ENG_INORDER, /* 61 */
/* Dummy Engine */
CMDQ_ENG_ISP_TIMGO = 63,
CMDQ_ENG_MDP_WDMA = 63,
CMDQ_MAX_ENGINE_COUNT /* ALWAYS keep at the end */
};
#define CMDQ_ENG_WPE_GROUP_BITS ((1LL << CMDQ_ENG_WPEI) | \
(1LL << CMDQ_ENG_WPEO) | \
(1LL << CMDQ_ENG_WPEI2) | \
(1LL << CMDQ_ENG_WPEO2))
#define CMDQ_ENG_ISP_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_IMGI2) | \
(1LL << CMDQ_ENG_ISP_IMG2O) | \
(1LL << CMDQ_ENG_ISP_IMG2O2))
#define CMDQ_ENG_ISP_MTEE_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_VIPI) | \
(1LL << CMDQ_ENG_ISP_LCEI))
#define CMDQ_ENG_SVP_MTEE_GROUP_BITS ((1LL << CMDQ_ENG_MDP_RDMA0) | \
(1LL << CMDQ_ENG_MDP_RDMA1) | \
(1LL << CMDQ_ENG_MDP_RDMA2) | \
(1LL << CMDQ_ENG_MDP_RDMA3))
#define CMDQ_ENG_MTEE_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_VIPI) | \
(1LL << CMDQ_ENG_ISP_LCEI))
#define CMDQ_ENG_MDP_GROUP_BITS ((1LL << CMDQ_ENG_MDP_CAMIN) | \
(1LL << CMDQ_ENG_MDP_CAMIN2) | \
(1LL << CMDQ_ENG_MDP_CAMIN3) | \
(1LL << CMDQ_ENG_MDP_CAMIN4) | \
(1LL << CMDQ_ENG_MDP_RDMA0) | \
(1LL << CMDQ_ENG_MDP_RDMA1) | \
(1LL << CMDQ_ENG_MDP_RDMA2) | \
(1LL << CMDQ_ENG_MDP_RDMA3) | \
(1LL << CMDQ_ENG_MDP_RSZ0) | \
(1LL << CMDQ_ENG_MDP_RSZ1) | \
(1LL << CMDQ_ENG_MDP_RSZ2) | \
(1LL << CMDQ_ENG_MDP_RSZ3) | \
(1LL << CMDQ_ENG_MDP_TDSHP0) | \
(1LL << CMDQ_ENG_MDP_TDSHP1) | \
(1LL << CMDQ_ENG_MDP_TDSHP2) | \
(1LL << CMDQ_ENG_MDP_TDSHP3) | \
(1LL << CMDQ_ENG_MDP_COLOR0) | \
(1LL << CMDQ_ENG_MDP_COLOR1) | \
(1LL << CMDQ_ENG_MDP_WROT0) | \
(1LL << CMDQ_ENG_MDP_WROT1) | \
(1LL << CMDQ_ENG_MDP_WROT2) | \
(1LL << CMDQ_ENG_MDP_WROT3) | \
(1LL << CMDQ_ENG_MDP_AAL0) | \
(1LL << CMDQ_ENG_MDP_AAL1) | \
(1LL << CMDQ_ENG_MDP_AAL2) | \
(1LL << CMDQ_ENG_MDP_AAL3) | \
(1LL << CMDQ_ENG_MDP_TCC0) | \
(1LL << CMDQ_ENG_MDP_TCC1) | \
(1LL << CMDQ_ENG_MDP_TCC2) | \
(1LL << CMDQ_ENG_MDP_TCC3) | \
(1LL << CMDQ_ENG_MDP_FG0) | \
(1LL << CMDQ_ENG_MDP_FG1) | \
(1LL << CMDQ_ENG_MDP_HDR0) | \
(1LL << CMDQ_ENG_MDP_HDR1))
#define CMDQ_ENG_DPE_GROUP_BITS (1LL << CMDQ_ENG_DPE)
#define CMDQ_ENG_RSC_GROUP_BITS (1LL << CMDQ_ENG_RSC)
#define CMDQ_ENG_GEPF_GROUP_BITS (1LL << CMDQ_ENG_GEPF)
#define CMDQ_ENG_EAF_GROUP_BITS (1LL << CMDQ_ENG_EAF)
#define CMDQ_ENG_OWE_GROUP_BITS (1LL << CMDQ_ENG_OWE)
#define CMDQ_ENG_MFB_GROUP_BITS (1LL << CMDQ_ENG_MFB)
#define CMDQ_ENG_FDVT_GROUP_BITS (1LL << CMDQ_ENG_FDVT)
#define CMDQ_ENG_ISP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_ISP_GROUP_BITS))
#define CMDQ_ENG_MDP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_MDP_GROUP_BITS))
#define CMDQ_ENG_DPE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_DPE_GROUP_BITS))
#define CMDQ_ENG_RSC_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_RSC_GROUP_BITS))
#define CMDQ_ENG_GEPF_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_GEPF_GROUP_BITS))
#define CMDQ_ENG_WPE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_WPE_GROUP_BITS))
#define CMDQ_ENG_EAF_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_EAF_GROUP_BITS))
#define CMDQ_ENG_OWE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_OWE_GROUP_BITS))
#define CMDQ_ENG_MFB_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_MFB_GROUP_BITS))
#define CMDQ_ENG_FDVT_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_FDVT_GROUP_BITS))
#define CMDQ_FOREACH_GROUP(ACTION_struct)\
ACTION_struct(CMDQ_GROUP_ISP, ISP) \
ACTION_struct(CMDQ_GROUP_MDP, MDP) \
ACTION_struct(CMDQ_GROUP_DPE, DPE) \
ACTION_struct(CMDQ_GROUP_RSC, RSC) \
ACTION_struct(CMDQ_GROUP_GEPF, GEPF) \
ACTION_struct(CMDQ_GROUP_WPE, WPE) \
ACTION_struct(CMDQ_GROUP_EAF, EAF) \
ACTION_struct(CMDQ_GROUP_OWE, OWE) \
ACTION_struct(CMDQ_GROUP_MFB, MFB) \
ACTION_struct(CMDQ_GROUP_FDVT, FDVT)
#define MDP_GENERATE_ENUM(_enum, _string) _enum,
enum CMDQ_GROUP_ENUM {
CMDQ_FOREACH_GROUP(MDP_GENERATE_ENUM)
CMDQ_MAX_GROUP_COUNT, /* ALWAYS keep at the end */
};
enum MDP_ENG_BASE {
ENGBASE_MMSYS_CONFIG = 0,
ENGBASE_MDP_RDMA0,
ENGBASE_MDP_RDMA1,
ENGBASE_MDP_RDMA2,
ENGBASE_MDP_RDMA3,
ENGBASE_MDP_FG0,
ENGBASE_MDP_FG1,
ENGBASE_MDP_AAL0,
ENGBASE_MDP_AAL1,
ENGBASE_MDP_AAL2,
ENGBASE_MDP_AAL3,
ENGBASE_MDP_HDR0,
ENGBASE_MDP_HDR1,
ENGBASE_MDP_RSZ0,
ENGBASE_MDP_RSZ1,
ENGBASE_MDP_RSZ2,
ENGBASE_MDP_RSZ3,
ENGBASE_MDP_WROT0,
ENGBASE_MDP_WROT1,
ENGBASE_MDP_WROT2,
ENGBASE_MDP_WROT3,
ENGBASE_MDP_TDSHP0,
ENGBASE_MDP_TDSHP1,
ENGBASE_MDP_TDSHP2,
ENGBASE_MDP_TDSHP3,
ENGBASE_MDP_TCC0,
ENGBASE_MDP_TCC1,
ENGBASE_MDP_TCC2,
ENGBASE_MDP_TCC3,
ENGBASE_MDP_COLOR0,
ENGBASE_MDP_COLOR1,
ENGBASE_MMSYS_MUTEX,
ENGBASE_ISP_MSFDL,
ENGBASE_ISP_MSS,
ENGBASE_ISP_MFB,
ENGBASE_ISP_DIP_A0,
ENGBASE_ISP_DIP_A1,
ENGBASE_ISP_DIP_A7,
ENGBASE_IMGSYS2_CONFIG,
ENGBASE_ISP_DIP_B0,
ENGBASE_ISP_DIP_B1,
ENGBASE_ISP_DIP_B7,
ENGBASE_ISP_WPE_A,
ENGBASE_ISP_WPE_B,
ENGBASE_COUNT
};
#endif /* __MDP_ENGINE_H__ */
+44
View File
@@ -0,0 +1,44 @@
#
# Copyright (C) 2019 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# drivers/mdp
ccflags-y += -I$(srctree)/drivers/misc/mediatek/mdp \
-I$(srctree)/drivers/misc/mediatek/mmdvfs/ \
-I$(srctree)/drivers/misc/mediatek/smi/ \
-I$(srctree)/drivers/misc/mediatek/smi/$(MTK_PLATFORM)/ \
-I$(srctree)/drivers/misc/mediatek/m4u/$(MTK_PLATFORM) \
-I$(srctree)/drivers/iommu
ccflags-$(CONFIG_MTK_CMDQ_MBOX_EXT) += -I$(srctree)/drivers/misc/mediatek/cmdq/mailbox/
ifeq ($(strip $(CONFIG_MTK_PQ_COLOR_MODE)),"MDP")
ccflags-y += -DCMDQ_MDP_COLOR
endif
# Enable MET
ccflags-y += -DMET_USER_EVENT_SUPPORT
# Enable AEE
ccflags-y += -DCMDQ_AEE_READY
# secure path
ifeq ($(or $(strip $(CONFIG_TRUSTONIC_TEE_SUPPORT)), $(strip $(CONFIG_MICROTRUST_TEE_SUPPORT)), \
$(strip $(CONFIG_MTK_ENABLE_GENIEZONE))),y)
ifeq ($(or $(strip $(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT)), $(strip $(CONFIG_MTK_CAM_SECURITY_SUPPORT))),y)
ccflags-y += -DCMDQ_SECURE_PATH_SUPPORT
endif # end of CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT or CONFIG_MTK_CAM_SECURITY_SUPPORT
endif # end of CONFIG_TRUSTONIC_TEE_SUPPORT or CONFIG_MICROTRUST_TEE_SUPPORT
obj-y += mdp.o
File diff suppressed because it is too large. Load diff
+107
View File
@@ -0,0 +1,107 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_BASE_H__
#define __MDP_BASE_H__
#define MDP_HW_CHECK
#include "mach/mt_iommu.h"
static u32 mdp_engine_port[ENGBASE_COUNT] = {
0, // ENGBASE_MMSYS_CONFIG,
M4U_PORT_L2_MDP_RDMA0, // ENGBASE_MDP_RDMA0,
M4U_PORT_L3_MDP_RDMA1, // ENGBASE_MDP_RDMA1,
M4U_PORT_L2_MDP_RDMA2, // ENGBASE_MDP_RDMA2,
M4U_PORT_L3_MDP_RDMA3, // ENGBASE_MDP_RDMA3,
0, // ENGBASE_MDP_FG0,
0, // ENGBASE_MDP_FG1,
0, // ENGBASE_MDP_AAL0,
0, // ENGBASE_MDP_AAL1,
0, // ENGBASE_MDP_AAL2,
0, // ENGBASE_MDP_AAL3,
0, // ENGBASE_MDP_HDR0,
0, // ENGBASE_MDP_HDR1,
0, // ENGBASE_MDP_RSZ0,
0, // ENGBASE_MDP_RSZ1,
0, // ENGBASE_MDP_RSZ2,
0, // ENGBASE_MDP_RSZ3,
M4U_PORT_L2_MDP_WROT0, // ENGBASE_MDP_WROT0,
M4U_PORT_L3_MDP_WROT1, // ENGBASE_MDP_WROT1,
M4U_PORT_L2_MDP_WROT2, // ENGBASE_MDP_WROT2,
M4U_PORT_L3_MDP_WROT3, // ENGBASE_MDP_WROT3,
0, // ENGBASE_MDP_TDSHP0,
0, // ENGBASE_MDP_TDSHP1,
0, // ENGBASE_MDP_TDSHP2,
0, // ENGBASE_MDP_TDSHP3,
0, // ENGBASE_MDP_TCC0,
0, // ENGBASE_MDP_TCC1,
0, // ENGBASE_MDP_TCC2,
0, // ENGBASE_MDP_TCC3,
0, // ENGBASE_MDP_COLOR0,
0, // ENGBASE_MDP_COLOR1,
0, // ENGBASE_MMSYS_MUTEX,
0, // ENGBASE_ISP_MSFDL,
0, // ENGBASE_ISP_MSS,
0, // ENGBASE_ISP_MFB,
0, // ENGBASE_ISP_DIP_A0,
0, // ENGBASE_ISP_DIP_A1,
0, // ENGBASE_ISP_DIP_A7,
0, // ENGBASE_IMGSYS2_CONFIG,
0, // ENGBASE_ISP_DIP_B0,
0, // ENGBASE_ISP_DIP_B1,
0, // ENGBASE_ISP_DIP_B7,
0, // ENGBASE_ISP_WPE_A,
0, // ENGBASE_ISP_WPE_B,
};
static u32 mdp_base[ENGBASE_COUNT] = {
[ENGBASE_MMSYS_CONFIG] = 0x1f000000,
[ENGBASE_MDP_RDMA0] = 0x1f006000,
[ENGBASE_MDP_RDMA1] = 0x1f007000,
[ENGBASE_MDP_RDMA2] = 0x1f008000,
[ENGBASE_MDP_RDMA3] = 0x1f009000,
[ENGBASE_MDP_FG0] = 0x1f00a000,
[ENGBASE_MDP_FG1] = 0x1f00b000,
[ENGBASE_MDP_AAL0] = 0x1f00c000,
[ENGBASE_MDP_AAL1] = 0x1f00d000,
[ENGBASE_MDP_AAL2] = 0x1f00e000,
[ENGBASE_MDP_AAL3] = 0x1f00f000,
[ENGBASE_MDP_HDR0] = 0x1f010000,
[ENGBASE_MDP_HDR1] = 0x1f011000,
[ENGBASE_MDP_RSZ0] = 0x1f012000,
[ENGBASE_MDP_RSZ1] = 0x1f013000,
[ENGBASE_MDP_RSZ2] = 0x1f014000,
[ENGBASE_MDP_RSZ3] = 0x1f015000,
[ENGBASE_MDP_WROT0] = 0x1f016000,
[ENGBASE_MDP_WROT1] = 0x1f017000,
[ENGBASE_MDP_WROT2] = 0x1f018000,
[ENGBASE_MDP_WROT3] = 0x1f019000,
[ENGBASE_MDP_TDSHP0] = 0x1f01a000,
[ENGBASE_MDP_TDSHP1] = 0x1f01b000,
[ENGBASE_MDP_TDSHP2] = 0x1f01c000,
[ENGBASE_MDP_TDSHP3] = 0x1f01d000,
[ENGBASE_MDP_TCC0] = 0x1f01e000,
[ENGBASE_MDP_TCC1] = 0x1f01f000,
[ENGBASE_MDP_TCC2] = 0x1f020000,
[ENGBASE_MDP_TCC3] = 0x1f021000,
[ENGBASE_MDP_COLOR0] = 0x1f02c000,
[ENGBASE_MDP_COLOR1] = 0x1f02d000,
[ENGBASE_MMSYS_MUTEX] = 0x1f001000,
[ENGBASE_ISP_MSFDL] = 0x15010000,
[ENGBASE_ISP_MSS] = 0x15012000,
[ENGBASE_ISP_MFB] = 0x15020000,
[ENGBASE_ISP_DIP_A0] = 0x15021000,
[ENGBASE_ISP_DIP_A1] = 0x15022000,
[ENGBASE_ISP_DIP_A7] = 0x15028000,
[ENGBASE_IMGSYS2_CONFIG] = 0x15820000,
[ENGBASE_ISP_DIP_B0] = 0x15821000,
[ENGBASE_ISP_DIP_B1] = 0x15822000,
[ENGBASE_ISP_DIP_B7] = 0x15828000,
[ENGBASE_ISP_WPE_A] = 0x15011000,
[ENGBASE_ISP_WPE_B] = 0x15811000,
};
#endif
@@ -0,0 +1,232 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MDP_ENGINE_H__
#define __MDP_ENGINE_H__
enum CMDQ_ENG_ENUM {
/* ISP */
CMDQ_ENG_WPEI = 0,
CMDQ_ENG_WPEO, /* 1 */
CMDQ_ENG_WPEI2, /* 2 */
CMDQ_ENG_WPEO2, /* 3 */
CMDQ_ENG_ISP_IMGI, /* 4 */
CMDQ_ENG_ISP_IMGI2, /* 5 */
CMDQ_ENG_ISP_IMG2O, /* 6 */
CMDQ_ENG_ISP_IMG2O2, /* 7 */
/* MDP */
CMDQ_ENG_MDP_CAMIN, /* 8 */
CMDQ_ENG_MDP_CAMIN2, /* 9 */
CMDQ_ENG_MDP_CAMIN3, /* 10 */
CMDQ_ENG_MDP_CAMIN4, /* 11 */
CMDQ_ENG_MDP_RDMA0, /* 12 */
CMDQ_ENG_MDP_RDMA1, /* 13 */
CMDQ_ENG_MDP_RDMA2, /* 14 */
CMDQ_ENG_MDP_RDMA3, /* 15 */
CMDQ_ENG_MDP_FG0, /* 16 */
CMDQ_ENG_MDP_FG1, /* 17 */
CMDQ_ENG_MDP_PQ0_SOUT, /* 18 */
CMDQ_ENG_MDP_PQ1_SOUT, /* 19 */
CMDQ_ENG_MDP_HDR0, /* 20 */
CMDQ_ENG_MDP_HDR1, /* 21 */
CMDQ_ENG_MDP_COLOR0, /* 22 */
CMDQ_ENG_MDP_COLOR1, /* 23 */
CMDQ_ENG_MDP_AAL0, /* 24 */
CMDQ_ENG_MDP_AAL1, /* 25 */
CMDQ_ENG_MDP_AAL2, /* 26 */
CMDQ_ENG_MDP_AAL3, /* 27 */
CMDQ_ENG_MDP_RSZ0, /* 28 */
CMDQ_ENG_MDP_RSZ1, /* 29 */
CMDQ_ENG_MDP_RSZ2, /* 30 */
CMDQ_ENG_MDP_RSZ3, /* 31 */
CMDQ_ENG_MDP_TDSHP0, /* 32 */
CMDQ_ENG_MDP_TDSHP1, /* 33 */
CMDQ_ENG_MDP_TDSHP2, /* 34 */
CMDQ_ENG_MDP_TDSHP3, /* 35 */
CMDQ_ENG_MDP_TCC0, /* 36 */
CMDQ_ENG_MDP_TCC1, /* 37 */
CMDQ_ENG_MDP_TCC2, /* 38 */
CMDQ_ENG_MDP_TCC3, /* 39 */
CMDQ_ENG_MDP_WROT0, /* 40 */
CMDQ_ENG_MDP_WROT1, /* 41 */
CMDQ_ENG_MDP_WROT2, /* 42 */
CMDQ_ENG_MDP_WROT3, /* 43 */
/* DPE */
CMDQ_ENG_DPE, /* 44 */
CMDQ_ENG_RSC, /* 45 */
CMDQ_ENG_GEPF, /* 46 */
CMDQ_ENG_EAF, /* 47 */
CMDQ_ENG_OWE, /* 48 */
CMDQ_ENG_MFB, /* 49 */
CMDQ_ENG_FDVT, /* 50 */
/* ISP sec */
CMDQ_ENG_ISP_VIPI, /* 51 */
CMDQ_ENG_ISP_LCEI, /* 52 */
CMDQ_ENG_ISP_IMG3O, /* 53 */
CMDQ_ENG_ISP_SMXIO, /* 54 */
CMDQ_ENG_ISP_DMGI_DEPI, /* 55 */
CMDQ_ENG_ISP_IMGCI, /* 56 */
CMDQ_ENG_ISP_UFBCI, /* 57 */
CMDQ_ENG_ISP_UFBCO, /* 58 */
CMDQ_ENG_ISP_MSS, /* 59 */
CMDQ_ENG_ISP_MSF, /* 60 */
CMDQ_ENG_INORDER, /* 61 */
/* Dummy Engine */
CMDQ_ENG_ISP_TIMGO = 63,
CMDQ_ENG_MDP_WDMA = 63,
CMDQ_MAX_ENGINE_COUNT /* ALWAYS keep at the end */
};
#define CMDQ_ENG_WPE_GROUP_BITS ((1LL << CMDQ_ENG_WPEI) | \
(1LL << CMDQ_ENG_WPEO) | \
(1LL << CMDQ_ENG_WPEI2) | \
(1LL << CMDQ_ENG_WPEO2))
#define CMDQ_ENG_ISP_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_IMGI2) | \
(1LL << CMDQ_ENG_ISP_IMG2O) | \
(1LL << CMDQ_ENG_ISP_IMG2O2))
#define CMDQ_ENG_ISP_MTEE_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_VIPI) | \
(1LL << CMDQ_ENG_ISP_LCEI))
#define CMDQ_ENG_SVP_MTEE_GROUP_BITS ((1LL << CMDQ_ENG_MDP_RDMA0) | \
(1LL << CMDQ_ENG_MDP_RDMA1) | \
(1LL << CMDQ_ENG_MDP_RDMA2) | \
(1LL << CMDQ_ENG_MDP_RDMA3))
#define CMDQ_ENG_MTEE_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \
(1LL << CMDQ_ENG_ISP_VIPI) | \
(1LL << CMDQ_ENG_ISP_LCEI))
#define CMDQ_ENG_MDP_GROUP_BITS ((1LL << CMDQ_ENG_MDP_CAMIN) | \
(1LL << CMDQ_ENG_MDP_CAMIN2) | \
(1LL << CMDQ_ENG_MDP_CAMIN3) | \
(1LL << CMDQ_ENG_MDP_CAMIN4) | \
(1LL << CMDQ_ENG_MDP_RDMA0) | \
(1LL << CMDQ_ENG_MDP_RDMA1) | \
(1LL << CMDQ_ENG_MDP_RDMA2) | \
(1LL << CMDQ_ENG_MDP_RDMA3) | \
(1LL << CMDQ_ENG_MDP_RSZ0) | \
(1LL << CMDQ_ENG_MDP_RSZ1) | \
(1LL << CMDQ_ENG_MDP_RSZ2) | \
(1LL << CMDQ_ENG_MDP_RSZ3) | \
(1LL << CMDQ_ENG_MDP_TDSHP0) | \
(1LL << CMDQ_ENG_MDP_TDSHP1) | \
(1LL << CMDQ_ENG_MDP_TDSHP2) | \
(1LL << CMDQ_ENG_MDP_TDSHP3) | \
(1LL << CMDQ_ENG_MDP_COLOR0) | \
(1LL << CMDQ_ENG_MDP_COLOR1) | \
(1LL << CMDQ_ENG_MDP_WROT0) | \
(1LL << CMDQ_ENG_MDP_WROT1) | \
(1LL << CMDQ_ENG_MDP_WROT2) | \
(1LL << CMDQ_ENG_MDP_WROT3) | \
(1LL << CMDQ_ENG_MDP_AAL0) | \
(1LL << CMDQ_ENG_MDP_AAL1) | \
(1LL << CMDQ_ENG_MDP_AAL2) | \
(1LL << CMDQ_ENG_MDP_AAL3) | \
(1LL << CMDQ_ENG_MDP_TCC0) | \
(1LL << CMDQ_ENG_MDP_TCC1) | \
(1LL << CMDQ_ENG_MDP_TCC2) | \
(1LL << CMDQ_ENG_MDP_TCC3) | \
(1LL << CMDQ_ENG_MDP_FG0) | \
(1LL << CMDQ_ENG_MDP_FG1) | \
(1LL << CMDQ_ENG_MDP_HDR0) | \
(1LL << CMDQ_ENG_MDP_HDR1))
#define CMDQ_ENG_DPE_GROUP_BITS (1LL << CMDQ_ENG_DPE)
#define CMDQ_ENG_RSC_GROUP_BITS (1LL << CMDQ_ENG_RSC)
#define CMDQ_ENG_GEPF_GROUP_BITS (1LL << CMDQ_ENG_GEPF)
#define CMDQ_ENG_EAF_GROUP_BITS (1LL << CMDQ_ENG_EAF)
#define CMDQ_ENG_OWE_GROUP_BITS (1LL << CMDQ_ENG_OWE)
#define CMDQ_ENG_MFB_GROUP_BITS (1LL << CMDQ_ENG_MFB)
#define CMDQ_ENG_FDVT_GROUP_BITS (1LL << CMDQ_ENG_FDVT)
#define CMDQ_ENG_ISP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_ISP_GROUP_BITS))
#define CMDQ_ENG_MDP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_MDP_GROUP_BITS))
#define CMDQ_ENG_DPE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_DPE_GROUP_BITS))
#define CMDQ_ENG_RSC_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_RSC_GROUP_BITS))
#define CMDQ_ENG_GEPF_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_GEPF_GROUP_BITS))
#define CMDQ_ENG_WPE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_WPE_GROUP_BITS))
#define CMDQ_ENG_EAF_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_EAF_GROUP_BITS))
#define CMDQ_ENG_OWE_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_OWE_GROUP_BITS))
#define CMDQ_ENG_MFB_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_MFB_GROUP_BITS))
#define CMDQ_ENG_FDVT_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_FDVT_GROUP_BITS))
#define CMDQ_FOREACH_GROUP(ACTION_struct)\
ACTION_struct(CMDQ_GROUP_ISP, ISP) \
ACTION_struct(CMDQ_GROUP_MDP, MDP) \
ACTION_struct(CMDQ_GROUP_DPE, DPE) \
ACTION_struct(CMDQ_GROUP_RSC, RSC) \
ACTION_struct(CMDQ_GROUP_GEPF, GEPF) \
ACTION_struct(CMDQ_GROUP_WPE, WPE) \
ACTION_struct(CMDQ_GROUP_EAF, EAF) \
ACTION_struct(CMDQ_GROUP_OWE, OWE) \
ACTION_struct(CMDQ_GROUP_MFB, MFB) \
ACTION_struct(CMDQ_GROUP_FDVT, FDVT)
#define MDP_GENERATE_ENUM(_enum, _string) _enum,
enum CMDQ_GROUP_ENUM {
CMDQ_FOREACH_GROUP(MDP_GENERATE_ENUM)
CMDQ_MAX_GROUP_COUNT, /* ALWAYS keep at the end */
};
enum MDP_ENG_BASE {
ENGBASE_MMSYS_CONFIG = 0,
ENGBASE_MDP_RDMA0,
ENGBASE_MDP_RDMA1,
ENGBASE_MDP_RDMA2,
ENGBASE_MDP_RDMA3,
ENGBASE_MDP_FG0,
ENGBASE_MDP_FG1,
ENGBASE_MDP_AAL0,
ENGBASE_MDP_AAL1,
ENGBASE_MDP_AAL2,
ENGBASE_MDP_AAL3,
ENGBASE_MDP_HDR0,
ENGBASE_MDP_HDR1,
ENGBASE_MDP_RSZ0,
ENGBASE_MDP_RSZ1,
ENGBASE_MDP_RSZ2,
ENGBASE_MDP_RSZ3,
ENGBASE_MDP_WROT0,
ENGBASE_MDP_WROT1,
ENGBASE_MDP_WROT2,
ENGBASE_MDP_WROT3,
ENGBASE_MDP_TDSHP0,
ENGBASE_MDP_TDSHP1,
ENGBASE_MDP_TDSHP2,
ENGBASE_MDP_TDSHP3,
ENGBASE_MDP_TCC0,
ENGBASE_MDP_TCC1,
ENGBASE_MDP_TCC2,
ENGBASE_MDP_TCC3,
ENGBASE_MDP_COLOR0,
ENGBASE_MDP_COLOR1,
ENGBASE_MMSYS_MUTEX,
ENGBASE_ISP_MSFDL,
ENGBASE_ISP_MSS,
ENGBASE_ISP_MFB,
ENGBASE_ISP_DIP_A0,
ENGBASE_ISP_DIP_A1,
ENGBASE_ISP_DIP_A7,
ENGBASE_IMGSYS2_CONFIG,
ENGBASE_ISP_DIP_B0,
ENGBASE_ISP_DIP_B1,
ENGBASE_ISP_DIP_B7,
ENGBASE_ISP_WPE_A,
ENGBASE_ISP_WPE_B,
ENGBASE_COUNT
};
#endif /* __MDP_ENGINE_H__ */
+17
View File
@@ -0,0 +1,17 @@
#
# Copyright (C) 2018 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# common driver code for MDP
# driver module
obj-y += mdp_fence.o
+467
View File
@@ -0,0 +1,467 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include <linux/sync_file.h>
#include <linux/debugfs.h>
#include <linux/miscdevice.h>
//#include "sync_debug.h"
#define CREATE_TRACE_POINTS
//#include "sync_trace.h"
/*
* MDP SYNC validation framework
*
* A sync object driver that uses a 32bit counter to coordinate
* synchronization. Useful when there is no hardware primitive backing
* the synchronization.
*
* To start the framework just open:
*
* dev/mdp_sync
*
* That will create a sync timeline, all fences created under this timeline
* file descriptor will belong to the this timeline.
*
* The 'mdp_sync' file can be opened many times as to create different
* timelines.
*
* Fences can be created with MDP_SYNC_IOC_CREATE_FENCE ioctl with struct
* mdp_sync_ioctl_create_fence as parameter.
*
* To increment the timeline counter, MDP_SYNC_IOC_INC ioctl should be used
* with the increment as u32. This will update the last signaled value
* from the timeline and signal any fence that has a seqno smaller or equal
* to it.
*
* struct mdp_sync_ioctl_create_fence
* @value: the seqno to initialise the fence with
* @name: the name of the new sync point
* @fence: return the fd of the new sync_file with the created fence
*/
struct mdp_sync_create_fence_data {
__u32 value;
char name[32];
__s32 dma_fence; /* fd of new fence */
};
#define MDP_SYNC_IOC_MAGIC 'W'
#define MDP_SYNC_IOC_CREATE_FENCE _IOWR(MDP_SYNC_IOC_MAGIC, 0,\
struct mdp_sync_create_fence_data)
#define MDP_SYNC_IOC_INC _IOW(MDP_SYNC_IOC_MAGIC, 1, __u32)
/**
* struct sync_timeline - sync object
* @kref: reference count on fence.
* @name: name of the sync_timeline. Useful for debugging
* @lock: lock protecting @pt_list and @value
* @pt_tree: rbtree of active (unsignaled/errored) sync_pts
* @pt_list: list of active (unsignaled/errored) sync_pts
* @sync_timeline_list: membership in global sync_timeline_list
*/
struct sync_timeline {
struct kref kref;
char name[32];
/* protected by lock */
u64 context;
int value;
struct rb_root pt_tree;
struct list_head pt_list;
spinlock_t lock;
struct list_head sync_timeline_list;
};
static inline struct sync_timeline *fence_parent(struct dma_fence *dma_fence)
{
return container_of(dma_fence->lock, struct sync_timeline, lock);
}
/**
* struct sync_pt - sync_pt object
* @base: base dma_fence object
* @link: link on the sync timeline's list
* @node: node in the sync timeline's tree
*/
struct sync_pt {
struct dma_fence base;
struct list_head link;
struct rb_node node;
};
static const struct dma_fence_ops timeline_dma_fence_ops;
static inline struct sync_pt *fence_to_sync_pt(struct dma_fence *dma_fence)
{
if (dma_fence->ops != &timeline_dma_fence_ops)
return NULL;
return container_of(dma_fence, struct sync_pt, base);
}
/**
* mdp_timeline_create() - creates a sync object
* @name: sync_timeline name
*
* Creates a new sync_timeline. Returns the sync_timeline object or NULL in
* case of error.
*/
struct sync_timeline *mdp_timeline_create(const char *name)
{
struct sync_timeline *obj;
obj = kzalloc(sizeof(*obj), GFP_KERNEL);
if (!obj)
return NULL;
kref_init(&obj->kref);
obj->context = dma_fence_context_alloc(1);
strlcpy(obj->name, name, sizeof(obj->name));
obj->pt_tree = RB_ROOT;
INIT_LIST_HEAD(&obj->pt_list);
spin_lock_init(&obj->lock);
//sync_timeline_debug_add(obj);
return obj;
}
static void sync_timeline_free(struct kref *kref)
{
struct sync_timeline *obj =
container_of(kref, struct sync_timeline, kref);
//sync_timeline_debug_remove(obj);
kfree(obj);
}
static void sync_timeline_get(struct sync_timeline *obj)
{
kref_get(&obj->kref);
}
static void sync_timeline_put(struct sync_timeline *obj)
{
kref_put(&obj->kref, sync_timeline_free);
}
static const char *timeline_fence_get_driver_name(struct dma_fence *dma_fence)
{
return "mdp_sync";
}
static const char *timeline_fence_get_timeline_name(struct dma_fence *dma_fence)
{
struct sync_timeline *parent = fence_parent(dma_fence);
return parent->name;
}
static void timeline_fence_release(struct dma_fence *dma_fence)
{
struct sync_pt *pt = fence_to_sync_pt(dma_fence);
struct sync_timeline *parent = fence_parent(dma_fence);
unsigned long flags;
spin_lock_irqsave(dma_fence->lock, flags);
if (pt && !list_empty(&pt->link)) {
list_del(&pt->link);
rb_erase(&pt->node, &parent->pt_tree);
}
spin_unlock_irqrestore(dma_fence->lock, flags);
sync_timeline_put(parent);
dma_fence_free(dma_fence);
}
static bool timeline_fence_signaled(struct dma_fence *dma_fence)
{
struct sync_timeline *parent = fence_parent(dma_fence);
return !__dma_fence_is_later(dma_fence->seqno, parent->value);
}
static bool timeline_fence_enable_signaling(struct dma_fence *dma_fence)
{
return true;
}
static void timeline_fence_value_str(struct dma_fence *dma_fence,
char *str, int size)
{
snprintf(str, size, "%d", dma_fence->seqno);
}
static void timeline_fence_timeline_value_str(struct dma_fence *dma_fence,
char *str, int size)
{
struct sync_timeline *parent = fence_parent(dma_fence);
snprintf(str, size, "%d", parent->value);
}
static const struct dma_fence_ops timeline_dma_fence_ops = {
.get_driver_name = timeline_fence_get_driver_name,
.get_timeline_name = timeline_fence_get_timeline_name,
.enable_signaling = timeline_fence_enable_signaling,
.signaled = timeline_fence_signaled,
.wait = dma_fence_default_wait,
.release = timeline_fence_release,
.fence_value_str = timeline_fence_value_str,
.timeline_value_str = timeline_fence_timeline_value_str,
};
/**
* sync_timeline_signal() - signal a status change on a sync_timeline
* @obj: sync_timeline to signal
* @inc: num to increment on timeline->value
*
* A sync implementation should call this any time one of it's fences
* has signaled or has an error condition.
*/
static void sync_timeline_signal(struct sync_timeline *obj, unsigned int inc)
{
struct sync_pt *pt, *next;
//trace_sync_timeline(obj);
spin_lock_irq(&obj->lock);
obj->value += inc;
list_for_each_entry_safe(pt, next, &obj->pt_list, link) {
if (!timeline_fence_signaled(&pt->base))
break;
list_del_init(&pt->link);
rb_erase(&pt->node, &obj->pt_tree);
/*
* A signal callback may release the last reference to this
* dma_fence, causing it to be freed. That operation has to be
* last to avoid a use after free inside this loop, and must
* be after we remove the dma_fence from the timeline in order to
* prevent deadlocking on timeline->lock inside
* timeline_fence_release().
*/
dma_fence_signal_locked(&pt->base);
}
spin_unlock_irq(&obj->lock);
}
/**
* sync_pt_create() - creates a sync pt
* @parent: dma_fence's parent sync_timeline
* @inc: value of the dma_fence
*
* Creates a new sync_pt as a child of @parent. @size bytes will be
* allocated allowing for implementation specific data to be kept after
* the generic sync_timeline struct. Returns the sync_pt object or
* NULL in case of error.
*/
static struct sync_pt *sync_pt_create(struct sync_timeline *obj,
unsigned int value)
{
struct sync_pt *pt;
pt = kzalloc(sizeof(*pt), GFP_KERNEL);
if (!pt)
return NULL;
sync_timeline_get(obj);
dma_fence_init(&pt->base, &timeline_dma_fence_ops, &obj->lock,
obj->context, value);
INIT_LIST_HEAD(&pt->link);
spin_lock_irq(&obj->lock);
if (!dma_fence_is_signaled_locked(&pt->base)) {
struct rb_node **p = &obj->pt_tree.rb_node;
struct rb_node *parent = NULL;
while (*p) {
struct sync_pt *other;
int cmp;
parent = *p;
other = rb_entry(parent, typeof(*pt), node);
cmp = value - other->base.seqno;
if (cmp > 0) {
p = &parent->rb_right;
} else if (cmp < 0) {
p = &parent->rb_left;
} else {
if (dma_fence_get_rcu(&other->base)) {
sync_timeline_put(obj);
kfree(pt);
pt = other;
goto unlock;
}
p = &parent->rb_left;
}
}
rb_link_node(&pt->node, parent, p);
rb_insert_color(&pt->node, &obj->pt_tree);
parent = rb_next(&pt->node);
list_add_tail(&pt->link,
parent ? &rb_entry(parent, typeof(*pt),
node)->link : &obj->pt_list);
}
unlock:
spin_unlock_irq(&obj->lock);
return pt;
}
/*
* *WARNING*
*
* improper use of this can result in deadlocking kernel drivers from userspace.
*/
/* opening mdp_sync create a new sync obj */
static int mdp_sync_open(struct inode *inode, struct file *file)
{
struct sync_timeline *obj;
char task_comm[TASK_COMM_LEN];
get_task_comm(task_comm, current);
obj = mdp_timeline_create(task_comm);
if (!obj)
return -ENOMEM;
file->private_data = obj;
return 0;
}
static int mdp_sync_release(struct inode *inode, struct file *file)
{
struct sync_timeline *obj = file->private_data;
struct sync_pt *pt, *next;
spin_lock_irq(&obj->lock);
list_for_each_entry_safe(pt, next, &obj->pt_list, link) {
dma_fence_set_error(&pt->base, -ENOENT);
dma_fence_signal_locked(&pt->base);
}
spin_unlock_irq(&obj->lock);
//smp_wmb();/*memory barrier*/
sync_timeline_put(obj);
return 0;
}
static long mdp_sync_ioctl_create_fence(struct sync_timeline *obj,
unsigned long arg)
{
int fd = get_unused_fd_flags(O_CLOEXEC);
int err;
struct sync_pt *pt;
struct sync_file *sync_file;
struct mdp_sync_create_fence_data data;
if (fd < 0)
return fd;
if (copy_from_user(&data, (void __user *)arg, sizeof(data))) {
err = -EFAULT;
goto err;
}
pt = sync_pt_create(obj, data.value);
if (!pt) {
err = -ENOMEM;
goto err;
}
sync_file = sync_file_create(&pt->base);
dma_fence_put(&pt->base);
if (!sync_file) {
err = -ENOMEM;
goto err;
}
data.dma_fence = fd;
if (copy_to_user((void __user *)arg, &data, sizeof(data))) {
fput(sync_file->file);
err = -EFAULT;
goto err;
}
fd_install(fd, sync_file->file);
return 0;
err:
put_unused_fd(fd);
return err;
}
static long mdp_sync_ioctl_inc(struct sync_timeline *obj, unsigned long arg)
{
u32 value;
if (copy_from_user(&value, (void __user *)arg, sizeof(value)))
return -EFAULT;
while (value > INT_MAX) {
sync_timeline_signal(obj, INT_MAX);
value -= INT_MAX;
}
sync_timeline_signal(obj, value);
return 0;
}
static long mdp_sync_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
struct sync_timeline *obj = file->private_data;
switch (cmd) {
case MDP_SYNC_IOC_CREATE_FENCE:
return mdp_sync_ioctl_create_fence(obj, arg);
case MDP_SYNC_IOC_INC:
return mdp_sync_ioctl_inc(obj, arg);
default:
return -ENOTTY;
}
}
const struct file_operations mdp_sync_fops = {
.open = mdp_sync_open,
.release = mdp_sync_release,
.unlocked_ioctl = mdp_sync_ioctl,
.compat_ioctl = mdp_sync_ioctl,
};
static struct miscdevice mdp_sync_dev = {
.minor = MISC_DYNAMIC_MINOR,
.name = "mdp_sync",
.fops = &mdp_sync_fops,
};
static int __init mdp_sync_device_init(void)
{
return misc_register(&mdp_sync_dev);
}
device_initcall(mdp_sync_device_init);