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

+8
View File
@@ -0,0 +1,8 @@
config MTK_EMI_LEGACY
bool "MediaTek EMI legacy driver"
default n
help
This config enable/disable the IP-based EMI
driver, which includes bandwidth limiter
(BWL), memory protect unit (MPU), and EMI
latency monitor (ELM).
+17
View File
@@ -0,0 +1,17 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
MTK_PLATFORM := $(subst ",,$(CONFIG_MTK_PLATFORM))
obj-$(CONFIG_MTK_EMI_LEGACY) += $(MTK_PLATFORM)/
+338
View File
@@ -0,0 +1,338 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/printk.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <mt_emi.h>
#include "emi_ctrl_v1.h"
static void __iomem *CEN_EMI_BASE;
static void __iomem *CHN_EMI_BASE[MAX_CH];
#ifdef ENABLE_EMI_DEBUG_API
static void __iomem *EMI_DBG_BASE[MAX_DBG_NR];
#endif
static void __iomem *EMI_MPU_BASE;
static struct emi_info_t emi_info;
static unsigned int emi_dcm;
static int emi_probe(struct platform_device *pdev);
static int ddr_info_show(struct seq_file *m, void *v)
{
unsigned char buf[128];
ssize_t ret;
unsigned int density, rank, ddr_info;
ret = 0;
for (rank = 0, density = 0; rank < get_rk_num(); rank++)
density += get_rank_size(rank);
density *= 128;
ddr_info = ((density >> 2) & 0xF00) | get_dram_mr(5);
ret += snprintf(buf + ret, sizeof(buf) - ret,
"ddr_info: 0x%x\n", ddr_info);
ret += snprintf(buf + ret, sizeof(buf) - ret,
"DRAM density: %d MB\n", density);
ret += snprintf(buf + ret, sizeof(buf) - ret,
"vendor ID: 0x%x\n", get_dram_mr(5));
seq_write(m, buf, ret);
return 0;
}
static int ddr_info_open(struct inode *inode, struct file *file)
{
return single_open(file, ddr_info_show, NULL);
}
static const struct file_operations ddr_info_proc_fops = {
.open = ddr_info_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
static int emi_remove(struct platform_device *dev)
{
return 0;
}
#ifdef CONFIG_OF
static const struct of_device_id emi_of_ids[] = {
{.compatible = "mediatek,emi",},
{}
};
#endif
#ifdef CONFIG_PM
static int emi_suspend_noirq(struct device *dev)
{
/* pr_info("[EMI] suspend\n"); */
#if ENABLE_ELM
suspend_elm();
#endif
return 0;
}
static int emi_resume_noirq(struct device *dev)
{
/* pr_info("[EMI] resume\n"); */
#if ENABLE_ELM
resume_elm();
#endif
#ifdef DECS_ON_SSPM
resume_decs(CEN_EMI_BASE);
#endif
return 0;
}
static const struct dev_pm_ops emi_pm_ops = {
.suspend_noirq = emi_suspend_noirq,
.resume_noirq = emi_resume_noirq,
};
#define EMI_PM_OPS (&emi_pm_ops)
#else
#define EMI_PM_OPS NULL
#endif
static struct platform_driver emi_ctrl = {
.probe = emi_probe,
.remove = emi_remove,
.driver = {
.name = "emi_ctrl",
.owner = THIS_MODULE,
.pm = EMI_PM_OPS,
#ifdef CONFIG_OF
.of_match_table = emi_of_ids,
#endif
},
};
__weak void plat_debug_api_init(void)
{
}
static int emi_probe(struct platform_device *pdev)
{
struct resource *res;
struct proc_dir_entry *proc_entry;
int i;
pr_info("[EMI] module probe.\n");
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
CEN_EMI_BASE = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(CEN_EMI_BASE)) {
pr_err("[EMI] unable to map CEN_EMI_BASE\n");
return -EINVAL;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
EMI_MPU_BASE = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(EMI_MPU_BASE)) {
pr_err("[EMI] unable to map EMI_MPU_BASE\n");
return -EINVAL;
}
for (i = 0; i < MAX_CH; i++) {
res = platform_get_resource(pdev, IORESOURCE_MEM, 2 + i);
CHN_EMI_BASE[i] = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(CHN_EMI_BASE[i])) {
pr_err("[EMI] unable to map CH%d_EMI_BASE\n", i);
return -EINVAL;
}
}
#ifdef ENABLE_EMI_DEBUG_API
for (i = 0; i < MAX_DBG_NR; i++) {
res = platform_get_resource(pdev, IORESOURCE_MEM,
2 + MAX_CH + i);
EMI_DBG_BASE[i] = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(EMI_DBG_BASE[i])) {
pr_debug("[EMI] unable to map dbg\n");
return -EINVAL;
}
}
of_property_read_u32(pdev->dev.of_node,
"emi_dcm", &emi_dcm);
plat_debug_api_init();
#endif
pr_info("[EMI] get CEN_EMI_BASE @ %p\n", mt_cen_emi_base_get());
pr_info("[EMI] get EMI_MPU_BASE @ %p\n", mt_emi_mpu_base_get());
for (i = 0; i < MAX_CH; i++)
pr_info("[EMI] get CH%d_EMI_BASE @ %p\n",
i, mt_chn_emi_base_get(i));
proc_entry = proc_create("ddr_info", 0444, NULL, &ddr_info_proc_fops);
#if ENABLE_BWL
bwl_init(&emi_ctrl);
#endif
#if ENABLE_MPU
mpu_init(&emi_ctrl, pdev);
#endif
#if ENABLE_ELM
elm_init(&emi_ctrl, pdev);
#endif
#if ENABLE_MBW
mbw_init(&emi_ctrl);
#endif
return 0;
}
/*
* emi_ctrl_init: module init function.
*/
static int __init emi_ctrl_init(void)
{
int ret;
int i;
struct device_node *node;
/* register EMI ctrl interface */
ret = platform_driver_register(&emi_ctrl);
if (ret)
pr_err("[EMI/BWL] fail to register emi_ctrl driver\n");
/* get EMI info from boot tags */
node = of_find_compatible_node(NULL, NULL, "mediatek,emi");
if (node) {
ret = of_property_read_u32(node,
"emi_info,dram_type", &(emi_info.dram_type));
if (ret)
pr_err("[EMI] fail to get dram_type\n");
ret = of_property_read_u32(node,
"emi_info,ch_num", &(emi_info.ch_num));
if (ret)
pr_err("[EMI] fail to get ch_num\n");
ret = of_property_read_u32(node,
"emi_info,rk_num", &(emi_info.rk_num));
if (ret)
pr_err("[EMI] fail to get rk_num\n");
ret = of_property_read_u32_array(node, "emi_info,rank_size",
emi_info.rank_size, MAX_RK);
if (ret)
pr_err("[EMI] fail to get rank_size\n");
}
pr_info("[EMI] dram_type(%d)\n", get_dram_type());
pr_info("[EMI] mr5(0x%x)\n", get_dram_mr(5));
pr_info("[EMI] ch_num(%d)\n", get_ch_num());
pr_info("[EMI] rk_num(%d)\n", get_rk_num());
for (i = 0; i < get_rk_num(); i++)
pr_info("[EMI] rank%d_size(0x%x)", i, get_rank_size(i));
return 0;
}
/*
* emi_ctrl_exit: module exit function.
*/
static void __exit emi_ctrl_exit(void)
{
}
postcore_initcall(emi_ctrl_init);
module_exit(emi_ctrl_exit);
unsigned int get_dram_type(void)
{
return (emi_info.dram_type & 0xF);
}
unsigned int get_dram_mr(unsigned int index)
{
switch (index) {
case 5:
return ((emi_info.dram_type >> 24) & 0xFF);
default:
return 0;
}
}
unsigned int get_ch_num(void)
{
return emi_info.ch_num;
}
unsigned int get_rk_num(void)
{
return emi_info.rk_num;
}
unsigned int get_rank_size(unsigned int rank_index)
{
if ((rank_index < emi_info.rk_num) && (rank_index < MAX_RK))
return emi_info.rank_size[rank_index];
return 0;
}
void __iomem *mt_cen_emi_base_get(void)
{
return CEN_EMI_BASE;
}
EXPORT_SYMBOL(mt_cen_emi_base_get);
/* for legacy use */
void __iomem *mt_emi_base_get(void)
{
return mt_cen_emi_base_get();
}
EXPORT_SYMBOL(mt_emi_base_get);
void __iomem *mt_chn_emi_base_get(unsigned int channel_index)
{
if (channel_index < MAX_CH)
return CHN_EMI_BASE[channel_index];
return NULL;
}
EXPORT_SYMBOL(mt_chn_emi_base_get);
#ifdef ENABLE_EMI_DEBUG_API
void __iomem *mt_emi_dbg_base_get(unsigned int index)
{
if (index < MAX_DBG_NR)
return EMI_DBG_BASE[index];
return NULL;
}
EXPORT_SYMBOL(mt_emi_dbg_base_get);
#endif
void __iomem *mt_emi_mpu_base_get(void)
{
return EMI_MPU_BASE;
}
EXPORT_SYMBOL(mt_emi_mpu_base_get);
unsigned int mt_emi_dcm_config(void)
{
return emi_dcm;
}
EXPORT_SYMBOL(mt_emi_dcm_config);
+37
View File
@@ -0,0 +1,37 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __EMI_CTRL_H__
#define __EMI_CTRL_H__
struct emi_info_t {
unsigned int dram_type;
unsigned int ch_num;
unsigned int rk_num;
unsigned int rank_size[MAX_RK];
};
extern void bwl_init(struct platform_driver *emi_ctrl);
extern void mpu_init(
struct platform_driver *emi_ctrl, struct platform_device *pdev);
extern void elm_init(
struct platform_driver *emi_ctrl, struct platform_device *pdev);
extern unsigned int get_dram_type(void);
extern unsigned int get_dram_mr(unsigned int index);
extern unsigned int get_ch_num(void);
extern unsigned int get_rk_num(void);
extern unsigned int get_rank_size(unsigned int rank_index);
extern void __iomem *mt_cen_emi_base_get(void);
extern void __iomem *mt_emi_base_get(void);
extern void __iomem *mt_chn_emi_base_get(unsigned int channel_index);
extern void __iomem *mt_emi_dbg_base_get(unsigned int index);
extern void __iomem *mt_emi_mpu_base_get(void);
extern void resume_decs(void __iomem *CEN_EMI_BASE);
extern unsigned int mt_emi_dcm_config(void);
#endif /* __EMI_CTRL_H__ */
+16
View File
@@ -0,0 +1,16 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __EMI_IO_H__
#define __EMI_IO_H__
/* only for arm64 */
#ifdef CONFIG_ARM64
#define IOMEM(a) ((void __force __iomem *)((a)))
#endif
#endif /* __EMI_IO_H__ */
+30
View File
@@ -0,0 +1,30 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
ccflags-y += -I$(srctree)/drivers/misc/mediatek/emi
ccflags-y += -I$(srctree)/drivers/misc/mediatek/emi/submodule
ccflags-y += -I$(srctree)/drivers/misc/mediatek/dramc
ccflags-y += -I$(srctree)/drivers/misc/mediatek/dramc/$(MTK_PLATFORM)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/debug_latch/plat_dbg_info
ccflags-y += -I$(srctree)/include/memory/mediatek
obj-y += bwl_platform.o
obj-y += mpu_platform.o
obj-y += plat_debug_api.o
obj-y += ../emi_ctrl_v1.o
obj-y += ../submodule/bwl_v1.o
obj-y += ../submodule/mpu_v1.o
obj-y += ../submodule/elm_v2.o
obj-y += ../submodule/pasr_api_v1.o
@@ -0,0 +1,114 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/kernel.h>
#include <linux/delay.h>
#include <mt-plat/sync_write.h>
#include <emi_io.h>
#include "mt_emi.h"
#include "bwl_platform.h"
#define EMI_BWCT0_2ND (CEN_EMI_BASE + 0x6A0)
#define EMI_BWCT0_4TH (CEN_EMI_BASE + 0x780)
#define EMI_BWCT0_5TH (CEN_EMI_BASE + 0x7B0)
#define EMI_BWST0 (CEN_EMI_BASE + 0x5C4)
#define EMI_BWST_2ND (CEN_EMI_BASE + 0x6A8)
#define EMI_BWST_3RD (CEN_EMI_BASE + 0x778)
#define EMI_BWST_4TH (CEN_EMI_BASE + 0x788)
#define EMI_BWST_5TH (CEN_EMI_BASE + 0x7B8)
#define EMI_BWVL (CEN_EMI_BASE + 0x7D0)
#define EMI_BWVL_2ND (CEN_EMI_BASE + 0x7D4)
#define EMI_BWVL_3RD (CEN_EMI_BASE + 0x7D8)
#define EMI_BWVL_4TH (CEN_EMI_BASE + 0x7DC)
#define EMI_BWVL_5TH (CEN_EMI_BASE + 0x7E0)
static unsigned int decs_status;
unsigned int decode_bwl_env(
unsigned int dram_type, unsigned int ch_num, unsigned int rk_num)
{
if (ch_num == 1)
return BWL_ENV_LPDDR3_1CH;
else
return BWL_ENV_LPDDR4_2CH;
}
unsigned int acquire_bwl_ctrl(void __iomem *LAST_EMI_BASE)
{
unsigned int timeout;
decs_status = readl(IOMEM(LAST_EMI_DECS_CTRL));
mt_reg_sync_writel(0x1, LAST_EMI_DECS_CTRL);
for (timeout = 1; readl(IOMEM(LAST_EMI_DECS_CTRL)) != 2; timeout++) {
mdelay(1);
if ((timeout % 100) == 0) {
mt_reg_sync_writel(decs_status, LAST_EMI_DECS_CTRL);
pr_debug("[BWL] switch scenario timeout\n");
return -1;
}
}
return 0;
}
void release_bwl_ctrl(void __iomem *LAST_EMI_BASE)
{
mt_reg_sync_writel(decs_status, LAST_EMI_DECS_CTRL);
}
void resume_decs(void __iomem *CEN_EMI_BASE)
{
mt_reg_sync_writel(0x00030023, EMI_BWCT0_2ND);
mt_reg_sync_writel(0x00C00023, EMI_BWCT0_4TH);
mt_reg_sync_writel(0x00240023, EMI_BWCT0_5TH);
}
unsigned int get_emi_bwst(unsigned int bw_index)
{
void __iomem *CEN_EMI_BASE;
CEN_EMI_BASE = mt_cen_emi_base_get();
switch (bw_index) {
case 0:
return readl(IOMEM(EMI_BWST0));
case 1:
return readl(IOMEM(EMI_BWST_2ND));
case 2:
return readl(IOMEM(EMI_BWST_3RD));
case 3:
return readl(IOMEM(EMI_BWST_4TH));
case 4:
return readl(IOMEM(EMI_BWST_5TH));
default:
return 0;
}
}
unsigned int get_emi_bwvl(unsigned int bw_index)
{
void __iomem *CEN_EMI_BASE;
CEN_EMI_BASE = mt_cen_emi_base_get();
switch (bw_index) {
case 0:
return readl(IOMEM(EMI_BWVL));
case 1:
return readl(IOMEM(EMI_BWVL_2ND));
case 2:
return readl(IOMEM(EMI_BWVL_3RD));
case 3:
return readl(IOMEM(EMI_BWVL_4TH));
case 4:
return readl(IOMEM(EMI_BWVL_5TH));
default:
return 0;
}
}
@@ -0,0 +1,49 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __BWL_PLATFORM_H__
#define __BWL_PLATFORM_H__
enum BWL_ENV {
BWL_ENV_LPDDR3_1CH,
BWL_ENV_LPDDR4_2CH,
BWL_ENV_MAX
};
enum BWL_SCN {
BWL_SCN_VPWFD,
BWL_SCN_VR4K,
BWL_SCN_ICFP,
BWL_SCN_UI,
BWL_SCN_MAX
};
enum BWL_CEN_REG {
BWL_CEN_0x00000100,
BWL_CEN_0x00000108,
BWL_CEN_0x00000110,
BWL_CEN_0x00000118,
BWL_CEN_0x00000120,
BWL_CEN_0x00000128,
BWL_CEN_0x00000130,
BWL_CEN_0x00000138,
BWL_CEN_MAX
};
enum BWL_CHN_REG {
BWL_CHN_0x00000048,
BWL_CHN_0x00000080,
BWL_CHN_0x00000088,
BWL_CHN_0x00000140,
BWL_CHN_0x00000144,
BWL_CHN_0x00000158,
BWL_CHN_0x0000015c,
BWL_CHN_MAX
};
#define SCN_DEFAULT BWL_SCN_UI
#endif /* __BWL_PLATFORM_H__ */
@@ -0,0 +1,126 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000110, 0xa0a050d8)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000128, 0xa0a070d7)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000048, 0x00008027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000080, 0x00000f00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000140, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000144, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x0000015c, 0x82410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000110, 0xa0a050da)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000128, 0xa0a070d3)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000048, 0x00008027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000080, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000140, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000144, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x0000015c, 0x82410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000110, 0xa0a050cb)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000128, 0xa0a070d6)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000048, 0x00008027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000080, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000140, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000144, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000158, 0x00080868)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x0000015c, 0x88410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000110, 0xa0a050c6)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000128, 0xa0a070d5)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000048, 0x00008027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000080, 0x00000f00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000140, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000144, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x0000015c, 0x82410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000110, 0xa0a050d8)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000128, 0xa0a070d7)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000048, 0x00030027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000080, 0x00000f00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000140, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000144, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x0000015c, 0x82410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000110, 0xa0a050da)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000128, 0xa0a070d3)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000048, 0x00030027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000080, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000140, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000144, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x0000015c, 0x82410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000110, 0xa0a050cb)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000128, 0xa0a070d6)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000048, 0x00030027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000080, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000140, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000144, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000158, 0x00080868)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x0000015c, 0x88410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000110, 0xa0a050c6)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000128, 0xa0a070d5)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000048, 0x00030027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000080, 0x00000f00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000140, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000144, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x0000015c, 0x82410222)
@@ -0,0 +1,42 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/platform_device.h>
#include "mt_emi.h"
enum {
MASTER_APM0 = 0,
MASTER_APM1 = 1,
MASTER_MM0 = 2,
MASTER_MDMCU = 3,
MASTER_MD = 4,
MASTER_MM1 = 5,
MASTER_GPU0_PERI = 6,
MASTER_GPU1_LPDMA = 7,
MASTER_ALL = 8
};
int is_md_master(unsigned int master_id, unsigned int domain_id)
{
if ((master_id & 0x7) == MASTER_MDMCU)
return 1;
if ((master_id & 0x7) == MASTER_MD)
return 1;
return 0;
}
void set_ap_region_permission(unsigned int apc[EMI_MPU_DGROUP_NUM])
{
SET_ACCESS_PERMISSION(apc, LOCK,
FORBIDDEN, FORBIDDEN, FORBIDDEN, FORBIDDEN,
FORBIDDEN, FORBIDDEN, NO_PROTECTION, NO_PROTECTION,
FORBIDDEN, SEC_R_NSEC_RW, FORBIDDEN, NO_PROTECTION,
FORBIDDEN, FORBIDDEN, FORBIDDEN, NO_PROTECTION);
}
@@ -0,0 +1,908 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __MPU_PLATFORM_H__
#define __MPU_PLATFORM_H__
enum {
MT6761_M7_AXI_MST_THERM,
MT6761_M7_AXI_MST_PWM,
MT6761_M4_AXI_MST_HRQ_WR,
MT6761_M5_AXI_MST_DISP_WDMA0,
MT6761_M2_AXI_MST_MDP_RDMA0,
MT6761_M4_AXI_MST_DEBUG,
MT6761_M2_AXI_MST_VENC_CUR_LUMA_HW_VDEC_VLD_EXT,
MT6761_M2_AXI_MST_DISP_WDMA0,
MT6761_M5_AXI_MST_DISP_RDMA0,
MT6761_M5_AXI_MST_RP,
MT6761_M4_AXI_MST_TRACE_TOP,
MT6761_M5_AXI_MST_JPGENC_BSDMA,
MT6761_M5_AXI_MST_AFO_D,
MT6761_M5_AXI_MST_JPGENC_RDMA,
MT6761_M4_AXI_MST_PPPHA,
MT6761_M2_AXI_MST_VENC_REF_CHROMA,
MT6761_M2_AXI_MST_AAO,
MT6761_M5_AXI_MST_VENC_RD_COMV_HW_VDEC_PRED_RD_EXT,
MT6761_M3_AXI_MST_MD_MMU,
MT6761_M2_AXI_MST_VENC_SV_COMV_HW_VDEC_PRED_WR_EXT,
MT6761_M5_AXI_MST_RRZO,
MT6761_M2_AXI_MST_VENC_CUR_CHROMA_HW_VDEC_PPWRAP_EXT,
MT6761_M2_AXI_MST_VENC_BSDMA_HW_VDEC_PP_EXT,
MT6761_M7_AXI_MST_USB20,
MT6761_M5_AXI_MST_IMG2O,
MT6761_M2_AXI_MST_RB,
MT6761_M5_AXI_MST_IMGO_S,
MT6761_M4_AXI_MST_TPC,
MT6761_M4_AXI_MST_HRQ_WR1,
MT6761_M2_AXI_MST_RRZO,
MT6761_M7_AXI_MST_DEBUGTOP,
MT6761_M3_AXI_MST_USIP_0_DNOCACHE,
MT6761_M7_AXI_MST_SPM,
MT6761_M4_AXI_MST_BR_DMA,
MT6761_M0_AXI_MST_MP0,
MT6761_M5_AXI_MST_BPCI,
MT6761_M2_AXI_MST_AFO,
MT6761_M2_AXI_MST_DISP_RDMA0,
MT6761_M5_AXI_MST_MDP_WROT0,
MT6761_M5_AXI_MST_WR,
MT6761_M2_AXI_MST_BPCI,
MT6761_M5_AXI_MST_IMGI,
MT6761_M4_AXI_MST_QP,
MT6761_M2_AXI_MST_VENC_REF_LUMA_HW_VDEC_AVC_MV_EXT,
MT6761_M2_AXI_MST_AFO_D,
MT6761_M7_AXI_MST_CONNSYS_N9_MCU_RW,
MT6761_M2_AXI_MST_IMGO_S,
MT6761_M2_AXI_MST_IMGI,
MT6761_M5_AXI_MST_VENC_CUR_CHROMA_HW_VDEC_PPWRAP_EXT,
MT6761_M4_AXI_MST_DMA_WR,
MT6761_M2_AXI_MST_DISP_OVL0_2L,
MT6761_M4_AXI_MST_GDMA,
MT6761_M4_AXI_MST_VTB,
MT6761_M2_AXI_MST_IMG2O,
MT6761_M7_AXI_MST_SPI0,
MT6761_M2_AXI_MST_DISP_FAKE,
MT6761_M2_AXI_MST_VIPI,
MT6761_M5_AXI_MST_IMG3O,
MT6761_M5_AXI_MST_IMGO_S2,
MT6761_M4_AXI_MST_RXDFE_DMA,
MT6761_M7_AXI_MST_SPI2,
MT6761_M5_AXI_MST_ESFKO,
MT6761_M2_AXI_MST_JPGENC_RDMA,
MT6761_M4_AXI_MST_TBO,
MT6761_M5_AXI_MST_IMGO,
MT6761_M4_AXI_MST_MRSG0,
MT6761_M5_AXI_MST_LCEI,
MT6761_M7_AXI_MST_SPI4,
MT6761_M5_AXI_MST_VIPI,
MT6761_M7_AXI_MST_MSDC0,
MT6761_M4_AXI_MST_CNWDMA,
MT6761_M4_AXI_MST_IRDMA,
MT6761_M2_AXI_MST_IMGO,
MT6761_M2_AXI_MST_LCEI,
MT6761_M4_AXI_MST_LOG_TOP_DSP,
MT6761_M7_AXI_MST_MCUPM,
MT6761_M4_AXI_MST_TXBRP0,
MT6761_M5_AXI_MST_VENC_SV_COMV_HW_VDEC_PRED_WR_EXT,
MT6761_M3_AXI_MST_MD_MM,
MT6761_M3_AXI_MST_USIP_1_DNOCACHE,
MT6761_M5_AXI_MST_VIP2I,
MT6761_M5_AXI_MST_VENC_REF_LUMA_HW_VDEC_AVC_MV_EXT,
MT6761_M4_AXI_MST_LOG_TOP_MCU,
MT6761_M2_AXI_MST_IMG3O,
MT6761_M2_AXI_MST_RP,
MT6761_M5_AXI_MST_MDP_WDMA0,
MT6761_M4_AXI_MST_HRQ_RD,
MT6761_M7_AXI_MST_CCU,
MT6761_M2_AXI_MST_ESFKO,
MT6761_M2_AXI_MST_VENC_REC,
MT6761_M7_AXI_MST_DX_CC,
MT6761_M4_AXI_MST_CSH,
MT6761_M2_AXI_MST_JPGENC_BSDMA,
MT6761_M2_AXI_MST_MDP_WROT0,
MT6761_M7_AXI_MST_CONNSYS_WIFI_PDMA,
MT6761_M4_AXI_MST_IPSEC,
MT6761_M5_AXI_MST_DISP_OVL0,
MT6761_M4_AXI_MST_MCUSYS_DFD,
MT6761_M5_AXI_MST_BPCI_D,
MT6761_M7_AXI_MST_CONNSYS_RBIST_INTERNAL_CAPTURE,
MT6761_M5_AXI_MST_LCSO,
MT6761_M2_AXI_MST_VIP2I,
MT6761_M5_AXI_MST_RB,
MT6761_M5_AXI_MST_MDP_RDMA0,
MT6761_M2_AXI_MST_WR,
MT6761_M2_AXI_MST_LSCI_D,
MT6761_M5_AXI_MST_LSCI_D,
MT6761_M4_AXI_MST_HRQ_RD1,
MT6761_M2_AXI_MST_LCSO,
MT6761_M7_AXI_MST_CQ_DMA,
MT6761_M7_AXI_MST_CONNSYS_NA,
MT6761_M5_AXI_MST_VIP3I,
MT6761_M2_AXI_MST_VENC_RD_COMV_HW_VDEC_PRED_RD_EXT,
MT6761_M5_AXI_MST_AAO,
MT6761_M3_AXI_MST_USIP_1_I,
MT6761_M2_AXI_MST_BPCI_D,
MT6761_M5_AXI_MST_VENC_BSDMA_HW_VDEC_PP_EXT,
MT6761_M5_AXI_MST_VENC_REF_CHROMA,
MT6761_M4_AXI_MST_DMA_RD,
MT6761_M5_AXI_MST_DISP_OVL0_2L,
MT6761_M4_AXI_MST_DBGSYS,
MT6761_M7_AXI_MST_CLDMA,
MT6761_M5_AXI_MST_MM_IOMMU,
MT6761_M7_AXI_MST_DMA_EXT,
MT6761_M6_AXI_MST_MFG_M0,
MT6761_M4_AXI_MST_MMU,
MT6761_M7_AXI_MST_SPI1,
MT6761_M7_AXI_MST_SSPM,
MT6761_M5_AXI_MST_AFO,
MT6761_M4_AXI_MST_DCXO,
MT6761_M2_AXI_MST_VENC_RCPU_HW_VDEC_MC_EXT,
MT6761_M7_AXI_MST_GPU,
MT6761_M7_AXI_MST_AUDIO,
MT6761_M2_AXI_MST_VIP3I,
MT6761_M2_AXI_MST_MDP_WDMA0,
MT6761_M7_AXI_MST_SCP,
MT6761_M7_AXI_MST_SPI3,
MT6761_M5_AXI_MST_VENC_CUR_LUMA_HW_VDEC_VLD_EXT,
MT6761_M2_AXI_MST_IMGO_S2,
MT6761_M3_AXI_MST_USIP_1_DCACHE,
MT6761_M5_AXI_MST_UFDI,
MT6761_M4_AXI_MST_MRSG1,
MT6761_M7_AXI_MST_SPI5,
MT6761_M3_AXI_MST_USIP_0_DCACHE,
MT6761_M7_AXI_MST_MSDC1,
MT6761_M5_AXI_MST_LSCI,
MT6761_M2_AXI_MST_UFDI,
MT6761_M5_AXI_MST_VENC_REC,
MT6761_M5_AXI_MST_DISP_FAKE,
MT6761_M4_AXI_MST_DFE_DUMP,
MT6761_M2_AXI_MST_DISP_OVL0,
MT6761_M5_AXI_MST_VENC_RCPU_HW_VDEC_MC_EXT,
MT6761_M4_AXI_MST_TXBRP1,
MT6761_M3_AXI_MST_USIP_0_I,
MT6761_M2_AXI_MST_LSCI,
MT6761_M4_AXI_MST_TXCAL,
MT6761_M7_AXI_MST_GCE_M,
MST_INVALID,
NR_MST
};
static const struct mst_tbl_entry mst_tbl[] = {
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1FFC,
.id_val = 0x0,
.note = "Core nn system domain store exclusive",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1FFC,
.id_val = 0x4,
.note = "Core nn barrier",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1FFF,
.id_val = 0x8,
.note = "Unused",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1FFF,
.id_val = 0x49,
.note = "SCU generated barrier",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1FFE,
.id_val = 0xA,
.note = "Unused",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1FFC,
.id_val = 0xC,
.note = "Core nn non-re-orderable device write",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1FF0,
.id_val = 0x10,
.note = "Write to normal memory or re-orderable device memory",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1BFC,
.id_val = 0x0,
.note = "Core nn exclusive read or non-reorderable device read",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1FFC,
.id_val = 0x4,
.note = "Core nn barrier",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1FFF,
.id_val = 0x8,
.note = "Unused",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1FFF,
.id_val = 0x9,
.note = "SCU generated barrier or DVM complete",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1FFE,
.id_val = 0xA,
.note = "Unused",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1FFC,
.id_val = 0xC,
.note = "Unused",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1FF3,
.id_val = 0x10,
.note = "ACP read",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1FF3,
.id_val = 0x11,
.note = "Unused",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1FF2,
.id_val = 0x12,
.note = "Unused",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1FE0,
.id_val = 0x20,
.note = "Core nn read",
.name = "MT6761_M0_AXI_MST_MP0"},
{.master = MT6761_M2_AXI_MST_DISP_OVL0, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x0,
.note = "",
.name = "MT6761_M2_AXI_MST_DISP_OVL0"},
{.master = MT6761_M2_AXI_MST_DISP_OVL0_2L, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x4,
.note = "",
.name = "MT6761_M2_AXI_MST_DISP_OVL0_2L"},
{.master = MT6761_M2_AXI_MST_DISP_RDMA0, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x8,
.note = "",
.name = "MT6761_M2_AXI_MST_DISP_RDMA0"},
{.master = MT6761_M2_AXI_MST_DISP_WDMA0, .port = 2, .id_mask = 0x1FFC,
.id_val = 0xC,
.note = "",
.name = "MT6761_M2_AXI_MST_DISP_WDMA0"},
{.master = MT6761_M2_AXI_MST_MDP_RDMA0, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x10,
.note = "",
.name = "MT6761_M2_AXI_MST_MDP_RDMA0"},
{.master = MT6761_M2_AXI_MST_MDP_WDMA0, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x14,
.note = "",
.name = "MT6761_M2_AXI_MST_MDP_WDMA0"},
{.master = MT6761_M2_AXI_MST_MDP_WROT0, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x18,
.note = "",
.name = "MT6761_M2_AXI_MST_MDP_WROT0"},
{.master = MT6761_M2_AXI_MST_DISP_FAKE, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x1C,
.note = "",
.name = "MT6761_M2_AXI_MST_DISP_FAKE"},
{.master = MT6761_M2_AXI_MST_VENC_RCPU_HW_VDEC_MC_EXT, .port = 2,
.id_mask = 0x1FFC,
.id_val = 0x80,
.note = "",
.name = "MT6761_M2_AXI_MST_VENC_RCPU_HW_VDEC_MC_EXT"},
{.master = MT6761_M2_AXI_MST_VENC_REC, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x84,
.note = "",
.name = "MT6761_M2_AXI_MST_VENC_REC"},
{.master = MT6761_M2_AXI_MST_VENC_BSDMA_HW_VDEC_PP_EXT, .port = 2,
.id_mask = 0x1FFC,
.id_val = 0x88,
.note = "",
.name = "MT6761_M2_AXI_MST_VENC_BSDMA_HW_VDEC_PP_EXT"},
{.master = MT6761_M2_AXI_MST_VENC_SV_COMV_HW_VDEC_PRED_WR_EXT,
.port = 2,
.id_mask = 0x1FFC,
.id_val = 0x8C,
.note = "",
.name = "MT6761_M2_AXI_MST_VENC_SV_COMV_HW_VDEC_PRED_WR_EXT"},
{.master = MT6761_M2_AXI_MST_VENC_RD_COMV_HW_VDEC_PRED_RD_EXT,
.port = 2,
.id_mask = 0x1FFC,
.id_val = 0x90,
.note = "",
.name = "MT6761_M2_AXI_MST_VENC_RD_COMV_HW_VDEC_PRED_RD_EXT"},
{.master = MT6761_M2_AXI_MST_JPGENC_RDMA, .port = 2,
.id_mask = 0x1FFC,
.id_val = 0x94,
.note = "",
.name = "MT6761_M2_AXI_MST_JPGENC_RDMA"},
{.master = MT6761_M2_AXI_MST_JPGENC_BSDMA, .port = 2,
.id_mask = 0x1FFC,
.id_val = 0x98,
.note = "",
.name = "MT6761_M2_AXI_MST_JPGENC_BSDMA"},
{.master = MT6761_M2_AXI_MST_VENC_CUR_LUMA_HW_VDEC_VLD_EXT, .port = 2,
.id_mask = 0x1FFC,
.id_val = 0x9C,
.note = "",
.name = "MT6761_M2_AXI_MST_VENC_CUR_LUMA_HW_VDEC_VLD_EXT"},
{.master = MT6761_M2_AXI_MST_VENC_CUR_CHROMA_HW_VDEC_PPWRAP_EXT,
.port = 2,
.id_mask = 0x1FFC,
.id_val = 0xA0,
.note = "",
.name = "MT6761_M2_AXI_MST_VENC_CUR_CHROMA_HW_VDEC_PPWRAP_EXT"
},
{.master = MT6761_M2_AXI_MST_VENC_REF_LUMA_HW_VDEC_AVC_MV_EXT,
.port = 2,
.id_mask = 0x1FFC,
.id_val = 0xA4,
.note = "",
.name = "MT6761_M2_AXI_MST_VENC_REF_LUMA_HW_VDEC_AVC_MV_EXT"},
{.master = MT6761_M2_AXI_MST_VENC_REF_CHROMA, .port = 2,
.id_mask = 0x1FFC,
.id_val = 0xA8,
.note = "",
.name = "MT6761_M2_AXI_MST_VENC_REF_CHROMA"},
{.master = MT6761_M2_AXI_MST_IMGO, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x100,
.note = "",
.name = "MT6761_M2_AXI_MST_IMGO"},
{.master = MT6761_M2_AXI_MST_RRZO, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x104,
.note = "",
.name = "MT6761_M2_AXI_MST_RRZO"},
{.master = MT6761_M2_AXI_MST_AAO, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x108,
.note = "",
.name = "MT6761_M2_AXI_MST_AAO"},
{.master = MT6761_M2_AXI_MST_LCSO, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x10C,
.note = "",
.name = "MT6761_M2_AXI_MST_LCSO"},
{.master = MT6761_M2_AXI_MST_ESFKO, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x110,
.note = "",
.name = "MT6761_M2_AXI_MST_ESFKO"},
{.master = MT6761_M2_AXI_MST_IMGO_S, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x114,
.note = "",
.name = "MT6761_M2_AXI_MST_IMGO_S"},
{.master = MT6761_M2_AXI_MST_IMGO_S2, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x118,
.note = "",
.name = "MT6761_M2_AXI_MST_IMGO_S2"},
{.master = MT6761_M2_AXI_MST_LSCI, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x11C,
.note = "",
.name = "MT6761_M2_AXI_MST_LSCI"},
{.master = MT6761_M2_AXI_MST_LSCI_D, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x120,
.note = "",
.name = "MT6761_M2_AXI_MST_LSCI_D"},
{.master = MT6761_M2_AXI_MST_AFO, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x124,
.note = "",
.name = "MT6761_M2_AXI_MST_AFO"},
{.master = MT6761_M2_AXI_MST_AFO_D, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x128,
.note = "",
.name = "MT6761_M2_AXI_MST_AFO_D"},
{.master = MT6761_M2_AXI_MST_BPCI, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x12C,
.note = "",
.name = "MT6761_M2_AXI_MST_BPCI"},
{.master = MT6761_M2_AXI_MST_BPCI_D, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x130,
.note = "",
.name = "MT6761_M2_AXI_MST_BPCI_D"},
{.master = MT6761_M2_AXI_MST_UFDI, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x134,
.note = "",
.name = "MT6761_M2_AXI_MST_UFDI"},
{.master = MT6761_M2_AXI_MST_IMGI, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x138,
.note = "",
.name = "MT6761_M2_AXI_MST_IMGI"},
{.master = MT6761_M2_AXI_MST_IMG2O, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x13C,
.note = "",
.name = "MT6761_M2_AXI_MST_IMG2O"},
{.master = MT6761_M2_AXI_MST_IMG3O, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x140,
.note = "",
.name = "MT6761_M2_AXI_MST_IMG3O"},
{.master = MT6761_M2_AXI_MST_VIPI, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x144,
.note = "",
.name = "MT6761_M2_AXI_MST_VIPI"},
{.master = MT6761_M2_AXI_MST_VIP2I, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x148,
.note = "",
.name = "MT6761_M2_AXI_MST_VIP2I"},
{.master = MT6761_M2_AXI_MST_VIP3I, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x14C,
.note = "",
.name = "MT6761_M2_AXI_MST_VIP3I"},
{.master = MT6761_M2_AXI_MST_LCEI, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x150,
.note = "",
.name = "MT6761_M2_AXI_MST_LCEI"},
{.master = MT6761_M2_AXI_MST_RB, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x154,
.note = "",
.name = "MT6761_M2_AXI_MST_RB"},
{.master = MT6761_M2_AXI_MST_RP, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x158,
.note = "",
.name = "MT6761_M2_AXI_MST_RP"},
{.master = MT6761_M2_AXI_MST_WR, .port = 2, .id_mask = 0x1FFC,
.id_val = 0x15C,
.note = "",
.name = "MT6761_M2_AXI_MST_WR"},
{.master = MT6761_M3_AXI_MST_MD_MM, .port = 3, .id_mask = 0x1F83,
.id_val = 0x0,
.note = "",
.name = "MT6761_M3_AXI_MST_MD_MM"},
{.master = MT6761_M3_AXI_MST_MD_MMU, .port = 3, .id_mask = 0x1F83,
.id_val = 0x1,
.note = "",
.name = "MT6761_M3_AXI_MST_MD_MMU"},
{.master = MT6761_M3_AXI_MST_USIP_0_I, .port = 3, .id_mask = 0x1F1F,
.id_val = 0x2,
.note = "",
.name = "MT6761_M3_AXI_MST_USIP_0_I"},
{.master = MT6761_M3_AXI_MST_USIP_0_DCACHE, .port = 3,
.id_mask = 0x1F1F,
.id_val = 0x6,
.note = "",
.name = "MT6761_M3_AXI_MST_USIP_0_DCACHE"},
{.master = MT6761_M3_AXI_MST_USIP_0_DNOCACHE, .port = 3,
.id_mask = 0x1F1F,
.id_val = 0xA,
.note = "",
.name = "MT6761_M3_AXI_MST_USIP_0_DNOCACHE"},
{.master = MT6761_M3_AXI_MST_USIP_1_I, .port = 3, .id_mask = 0x1F1F,
.id_val = 0x12,
.note = "",
.name = "MT6761_M3_AXI_MST_USIP_1_I"},
{.master = MT6761_M3_AXI_MST_USIP_1_DCACHE, .port = 3,
.id_mask = 0x1F1F,
.id_val = 0x16,
.note = "",
.name = "MT6761_M3_AXI_MST_USIP_1_DCACHE"},
{.master = MT6761_M3_AXI_MST_USIP_1_DNOCACHE, .port = 3,
.id_mask = 0x1F1F,
.id_val = 0x1A,
.note = "",
.name = "MT6761_M3_AXI_MST_USIP_1_DNOCACHE"},
{.master = MT6761_M4_AXI_MST_HRQ_RD, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1000,
.note = "",
.name = "MT6761_M4_AXI_MST_HRQ_RD"},
{.master = MT6761_M4_AXI_MST_HRQ_RD1, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1008,
.note = "",
.name = "MT6761_M4_AXI_MST_HRQ_RD1"},
{.master = MT6761_M4_AXI_MST_HRQ_WR, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1002,
.note = "",
.name = "MT6761_M4_AXI_MST_HRQ_WR"},
{.master = MT6761_M4_AXI_MST_HRQ_WR1, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x100A,
.note = "",
.name = "MT6761_M4_AXI_MST_HRQ_WR1"},
{.master = MT6761_M4_AXI_MST_VTB, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x100C,
.note = "",
.name = "MT6761_M4_AXI_MST_VTB"},
{.master = MT6761_M4_AXI_MST_TBO, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1014,
.note = "",
.name = "MT6761_M4_AXI_MST_TBO"},
{.master = MT6761_M4_AXI_MST_DEBUG, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1004,
.note = "",
.name = "MT6761_M4_AXI_MST_DEBUG"},
{.master = MT6761_M4_AXI_MST_DFE_DUMP, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x800,
.note = "",
.name = "MT6761_M4_AXI_MST_DFE_DUMP"},
{.master = MT6761_M4_AXI_MST_BR_DMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x802,
.note = "",
.name = "MT6761_M4_AXI_MST_BR_DMA"},
{.master = MT6761_M4_AXI_MST_IRDMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x10,
.note = "",
.name = "MT6761_M4_AXI_MST_IRDMA"},
{.master = MT6761_M4_AXI_MST_TXBRP0, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x50,
.note = "",
.name = "MT6761_M4_AXI_MST_TXBRP0"},
{.master = MT6761_M4_AXI_MST_TXBRP1, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x150,
.note = "",
.name = "MT6761_M4_AXI_MST_TXBRP1"},
{.master = MT6761_M4_AXI_MST_TXCAL, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xD0,
.note = "",
.name = "MT6761_M4_AXI_MST_TXCAL"},
{.master = MT6761_M4_AXI_MST_TPC, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1D0,
.note = "",
.name = "MT6761_M4_AXI_MST_TPC"},
{.master = MT6761_M4_AXI_MST_RXDFE_DMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x70,
.note = "",
.name = "MT6761_M4_AXI_MST_RXDFE_DMA"},
{.master = MT6761_M4_AXI_MST_MRSG0, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xF0,
.note = "",
.name = "MT6761_M4_AXI_MST_MRSG0"},
{.master = MT6761_M4_AXI_MST_MRSG1, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x170,
.note = "",
.name = "MT6761_M4_AXI_MST_MRSG1"},
{.master = MT6761_M4_AXI_MST_CNWDMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x130,
.note = "",
.name = "MT6761_M4_AXI_MST_CNWDMA"},
{.master = MT6761_M4_AXI_MST_CSH, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xB0,
.note = "",
.name = "MT6761_M4_AXI_MST_CSH"},
{.master = MT6761_M4_AXI_MST_DCXO, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x30,
.note = "",
.name = "MT6761_M4_AXI_MST_DCXO"},
{.master = MT6761_M4_AXI_MST_DMA_RD, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1804,
.note = "",
.name = "MT6761_M4_AXI_MST_DMA_RD"},
{.master = MT6761_M4_AXI_MST_DMA_WR, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1806,
.note = "",
.name = "MT6761_M4_AXI_MST_DMA_WR"},
{.master = MT6761_M4_AXI_MST_MMU, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1800,
.note = "",
.name = "MT6761_M4_AXI_MST_MMU"},
{.master = MT6761_M4_AXI_MST_QP, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1802,
.note = "",
.name = "MT6761_M4_AXI_MST_QP"},
{.master = MT6761_M4_AXI_MST_LOG_TOP_MCU, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x24,
.note = "",
.name = "MT6761_M4_AXI_MST_LOG_TOP_MCU"},
{.master = MT6761_M4_AXI_MST_LOG_TOP_DSP, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x6,
.note = "",
.name = "MT6761_M4_AXI_MST_LOG_TOP_DSP"},
{.master = MT6761_M4_AXI_MST_TRACE_TOP, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x8,
.note = "",
.name = "MT6761_M4_AXI_MST_TRACE_TOP"},
{.master = MT6761_M4_AXI_MST_PPPHA, .port = 4, .id_mask = 0x1FDF,
.id_val = 0x2,
.note = "",
.name = "MT6761_M4_AXI_MST_PPPHA"},
{.master = MT6761_M4_AXI_MST_IPSEC, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xA,
.note = "",
.name = "MT6761_M4_AXI_MST_IPSEC"},
{.master = MT6761_M4_AXI_MST_GDMA, .port = 4, .id_mask = 0x1E3F,
.id_val = 0xE,
.note = "",
.name = "MT6761_M4_AXI_MST_GDMA"},
{.master = MT6761_M4_AXI_MST_DBGSYS, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xE,
.note = "",
.name = "MT6761_M4_AXI_MST_DBGSYS"},
{.master = MT6761_M4_AXI_MST_MCUSYS_DFD, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1,
.note = "",
.name = "MT6761_M4_AXI_MST_MCUSYS_DFD"},
{.master = MT6761_M5_AXI_MST_DISP_OVL0, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x0,
.note = "",
.name = "MT6761_M5_AXI_MST_DISP_OVL0"},
{.master = MT6761_M5_AXI_MST_DISP_OVL0_2L, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x4,
.note = "",
.name = "MT6761_M5_AXI_MST_DISP_OVL0_2L"},
{.master = MT6761_M5_AXI_MST_DISP_RDMA0, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x8,
.note = "",
.name = "MT6761_M5_AXI_MST_DISP_RDMA0"},
{.master = MT6761_M5_AXI_MST_DISP_WDMA0, .port = 5, .id_mask = 0x1FFC,
.id_val = 0xC,
.note = "",
.name = "MT6761_M5_AXI_MST_DISP_WDMA0"},
{.master = MT6761_M5_AXI_MST_MDP_RDMA0, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x10,
.note = "",
.name = "MT6761_M5_AXI_MST_MDP_RDMA0"},
{.master = MT6761_M5_AXI_MST_MDP_WDMA0, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x14,
.note = "",
.name = "MT6761_M5_AXI_MST_MDP_WDMA0"},
{.master = MT6761_M5_AXI_MST_MDP_WROT0, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x18,
.note = "",
.name = "MT6761_M5_AXI_MST_MDP_WROT0"},
{.master = MT6761_M5_AXI_MST_DISP_FAKE, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x1C,
.note = "",
.name = "MT6761_M5_AXI_MST_DISP_FAKE"},
{.master = MT6761_M5_AXI_MST_VENC_RCPU_HW_VDEC_MC_EXT, .port = 5,
.id_mask = 0x1FFC,
.id_val = 0x80,
.note = "",
.name = "MT6761_M5_AXI_MST_VENC_RCPU_HW_VDEC_MC_EXT"},
{.master = MT6761_M5_AXI_MST_VENC_REC, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x84,
.note = "",
.name = "MT6761_M5_AXI_MST_VENC_REC"},
{.master = MT6761_M5_AXI_MST_VENC_BSDMA_HW_VDEC_PP_EXT, .port = 5,
.id_mask = 0x1FFC,
.id_val = 0x88,
.note = "",
.name = "MT6761_M5_AXI_MST_VENC_BSDMA_HW_VDEC_PP_EXT"},
{.master = MT6761_M5_AXI_MST_VENC_SV_COMV_HW_VDEC_PRED_WR_EXT,
.port = 5,
.id_mask = 0x1FFC,
.id_val = 0x8C,
.note = "",
.name = "MT6761_M5_AXI_MST_VENC_SV_COMV_HW_VDEC_PRED_WR_EXT"},
{.master = MT6761_M5_AXI_MST_VENC_RD_COMV_HW_VDEC_PRED_RD_EXT,
.port = 5,
.id_mask = 0x1FFC,
.id_val = 0x90,
.note = "",
.name = "MT6761_M5_AXI_MST_VENC_RD_COMV_HW_VDEC_PRED_RD_EXT"},
{.master = MT6761_M5_AXI_MST_JPGENC_RDMA, .port = 5,
.id_mask = 0x1FFC,
.id_val = 0x94,
.note = "",
.name = "MT6761_M5_AXI_MST_JPGENC_RDMA"},
{.master = MT6761_M5_AXI_MST_JPGENC_BSDMA, .port = 5,
.id_mask = 0x1FFC,
.id_val = 0x98,
.note = "",
.name = "MT6761_M5_AXI_MST_JPGENC_BSDMA"},
{.master = MT6761_M5_AXI_MST_VENC_CUR_LUMA_HW_VDEC_VLD_EXT, .port = 5,
.id_mask = 0x1FFC,
.id_val = 0x9C,
.note = "",
.name = "MT6761_M5_AXI_MST_VENC_CUR_LUMA_HW_VDEC_VLD_EXT"},
{.master = MT6761_M5_AXI_MST_VENC_CUR_CHROMA_HW_VDEC_PPWRAP_EXT,
.port = 5,
.id_mask = 0x1FFC,
.id_val = 0xA0,
.note = "",
.name = "MT6761_M5_AXI_MST_VENC_CUR_CHROMA_HW_VDEC_PPWRAP_EXT"
},
{.master = MT6761_M5_AXI_MST_VENC_REF_LUMA_HW_VDEC_AVC_MV_EXT,
.port = 5,
.id_mask = 0x1FFC,
.id_val = 0xA4,
.note = "",
.name = "MT6761_M5_AXI_MST_VENC_REF_LUMA_HW_VDEC_AVC_MV_EXT"},
{.master = MT6761_M5_AXI_MST_VENC_REF_CHROMA, .port = 5,
.id_mask = 0x1FFC,
.id_val = 0xA8,
.note = "",
.name = "MT6761_M5_AXI_MST_VENC_REF_CHROMA"},
{.master = MT6761_M5_AXI_MST_IMGO, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x100,
.note = "",
.name = "MT6761_M5_AXI_MST_IMGO"},
{.master = MT6761_M5_AXI_MST_RRZO, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x104,
.note = "",
.name = "MT6761_M5_AXI_MST_RRZO"},
{.master = MT6761_M5_AXI_MST_AAO, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x108,
.note = "",
.name = "MT6761_M5_AXI_MST_AAO"},
{.master = MT6761_M5_AXI_MST_LCSO, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x10C,
.note = "",
.name = "MT6761_M5_AXI_MST_LCSO"},
{.master = MT6761_M5_AXI_MST_ESFKO, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x110,
.note = "",
.name = "MT6761_M5_AXI_MST_ESFKO"},
{.master = MT6761_M5_AXI_MST_IMGO_S, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x114,
.note = "",
.name = "MT6761_M5_AXI_MST_IMGO_S"},
{.master = MT6761_M5_AXI_MST_IMGO_S2, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x118,
.note = "",
.name = "MT6761_M5_AXI_MST_IMGO_S2"},
{.master = MT6761_M5_AXI_MST_LSCI, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x11C,
.note = "",
.name = "MT6761_M5_AXI_MST_LSCI"},
{.master = MT6761_M5_AXI_MST_LSCI_D, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x120,
.note = "",
.name = "MT6761_M5_AXI_MST_LSCI_D"},
{.master = MT6761_M5_AXI_MST_AFO, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x124,
.note = "",
.name = "MT6761_M5_AXI_MST_AFO"},
{.master = MT6761_M5_AXI_MST_AFO_D, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x128,
.note = "",
.name = "MT6761_M5_AXI_MST_AFO_D"},
{.master = MT6761_M5_AXI_MST_BPCI, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x12C,
.note = "",
.name = "MT6761_M5_AXI_MST_BPCI"},
{.master = MT6761_M5_AXI_MST_BPCI_D, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x130,
.note = "",
.name = "MT6761_M5_AXI_MST_BPCI_D"},
{.master = MT6761_M5_AXI_MST_UFDI, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x134,
.note = "",
.name = "MT6761_M5_AXI_MST_UFDI"},
{.master = MT6761_M5_AXI_MST_IMGI, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x138,
.note = "",
.name = "MT6761_M5_AXI_MST_IMGI"},
{.master = MT6761_M5_AXI_MST_IMG2O, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x13C,
.note = "",
.name = "MT6761_M5_AXI_MST_IMG2O"},
{.master = MT6761_M5_AXI_MST_IMG3O, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x140,
.note = "",
.name = "MT6761_M5_AXI_MST_IMG3O"},
{.master = MT6761_M5_AXI_MST_VIPI, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x144,
.note = "",
.name = "MT6761_M5_AXI_MST_VIPI"},
{.master = MT6761_M5_AXI_MST_VIP2I, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x148,
.note = "",
.name = "MT6761_M5_AXI_MST_VIP2I"},
{.master = MT6761_M5_AXI_MST_VIP3I, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x14C,
.note = "",
.name = "MT6761_M5_AXI_MST_VIP3I"},
{.master = MT6761_M5_AXI_MST_LCEI, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x150,
.note = "",
.name = "MT6761_M5_AXI_MST_LCEI"},
{.master = MT6761_M5_AXI_MST_RB, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x154,
.note = "",
.name = "MT6761_M5_AXI_MST_RB"},
{.master = MT6761_M5_AXI_MST_RP, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x158,
.note = "",
.name = "MT6761_M5_AXI_MST_RP"},
{.master = MT6761_M5_AXI_MST_WR, .port = 5, .id_mask = 0x1FFC,
.id_val = 0x15C,
.note = "",
.name = "MT6761_M5_AXI_MST_WR"},
{.master = MT6761_M5_AXI_MST_MM_IOMMU, .port = 5, .id_mask = 0x1FFF,
.id_val = 0x3FC,
.note = "",
.name = "MT6761_M5_AXI_MST_MM_IOMMU"},
{.master = MT6761_M5_AXI_MST_MM_IOMMU, .port = 5, .id_mask = 0x1FFF,
.id_val = 0x3FD,
.note = "",
.name = "MT6761_M5_AXI_MST_MM_IOMMU"},
{.master = MT6761_M6_AXI_MST_MFG_M0, .port = 6, .id_mask = 0x1FC0,
.id_val = 0x0,
.note = "",
.name = "MT6761_M6_AXI_MST_MFG_M0"},
{.master = MT6761_M7_AXI_MST_CONNSYS_WIFI_PDMA, .port = 7,
.id_mask = 0x1FEF,
.id_val = 0x0,
.note = "",
.name = "MT6761_M7_AXI_MST_CONNSYS_WIFI_PDMA"},
{.master = MT6761_M7_AXI_MST_CONNSYS_RBIST_INTERNAL_CAPTURE, .port = 7,
.id_mask = 0x1FEF,
.id_val = 0x4,
.note = "",
.name = "MT6761_M7_AXI_MST_CONNSYS_RBIST_INTERNAL_CAPTURE"},
{.master = MT6761_M7_AXI_MST_CONNSYS_N9_MCU_RW, .port = 7,
.id_mask = 0x1FEF,
.id_val = 0x8,
.note = "",
.name = "MT6761_M7_AXI_MST_CONNSYS_N9_MCU_RW"},
{.master = MT6761_M7_AXI_MST_CONNSYS_NA, .port = 7, .id_mask = 0x1FEF,
.id_val = 0xC,
.note = "",
.name = "MT6761_M7_AXI_MST_CONNSYS_NA"},
{.master = MT6761_M7_AXI_MST_DEBUGTOP, .port = 7, .id_mask = 0x1FDF,
.id_val = 0x2,
.note = "",
.name = "MT6761_M7_AXI_MST_DEBUGTOP"},
{.master = MT6761_M7_AXI_MST_MSDC0, .port = 7, .id_mask = 0x1CFF,
.id_val = 0x6,
.note = "",
.name = "MT6761_M7_AXI_MST_MSDC0"},
{.master = MT6761_M7_AXI_MST_SPI0, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x326,
.note = "",
.name = "MT6761_M7_AXI_MST_SPI0"},
{.master = MT6761_M7_AXI_MST_AUDIO, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x226,
.note = "",
.name = "MT6761_M7_AXI_MST_AUDIO"},
{.master = MT6761_M7_AXI_MST_MSDC1, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x126,
.note = "",
.name = "MT6761_M7_AXI_MST_MSDC1"},
{.master = MT6761_M7_AXI_MST_PWM, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x26,
.note = "",
.name = "MT6761_M7_AXI_MST_PWM"},
{.master = MT6761_M7_AXI_MST_USB20, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x46,
.note = "",
.name = "MT6761_M7_AXI_MST_USB20"},
{.master = MT6761_M7_AXI_MST_SPI1, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x346,
.note = "",
.name = "MT6761_M7_AXI_MST_SPI1"},
{.master = MT6761_M7_AXI_MST_SPI2, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x246,
.note = "",
.name = "MT6761_M7_AXI_MST_SPI2"},
{.master = MT6761_M7_AXI_MST_THERM, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x366,
.note = "",
.name = "MT6761_M7_AXI_MST_THERM"},
{.master = MT6761_M7_AXI_MST_CCU, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x266,
.note = "",
.name = "MT6761_M7_AXI_MST_CCU"},
{.master = MT6761_M7_AXI_MST_SPM, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x166,
.note = "",
.name = "MT6761_M7_AXI_MST_SPM"},
{.master = MT6761_M7_AXI_MST_MCUPM, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x66,
.note = "",
.name = "MT6761_M7_AXI_MST_MCUPM"},
{.master = MT6761_M7_AXI_MST_DMA_EXT, .port = 7, .id_mask = 0x1EFF,
.id_val = 0x86,
.note = "",
.name = "MT6761_M7_AXI_MST_DMA_EXT"},
{.master = MT6761_M7_AXI_MST_SPI5, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x3A6,
.note = "",
.name = "MT6761_M7_AXI_MST_SPI5"},
{.master = MT6761_M7_AXI_MST_SPI4, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x2A6,
.note = "",
.name = "MT6761_M7_AXI_MST_SPI4"},
{.master = MT6761_M7_AXI_MST_SPI3, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x1A6,
.note = "",
.name = "MT6761_M7_AXI_MST_SPI3"},
{.master = MT6761_M7_AXI_MST_DX_CC, .port = 7, .id_mask = 0x1E1F,
.id_val = 0xE,
.note = "",
.name = "MT6761_M7_AXI_MST_DX_CC"},
{.master = MT6761_M7_AXI_MST_CQ_DMA, .port = 7, .id_mask = 0x1F1F,
.id_val = 0x12,
.note = "",
.name = "MT6761_M7_AXI_MST_CQ_DMA"},
{.master = MT6761_M7_AXI_MST_CLDMA, .port = 7, .id_mask = 0x1F9F,
.id_val = 0x16,
.note = "",
.name = "MT6761_M7_AXI_MST_CLDMA"},
{.master = MT6761_M7_AXI_MST_GCE_M, .port = 7, .id_mask = 0x1F9F,
.id_val = 0x1A,
.note = "",
.name = "MT6761_M7_AXI_MST_GCE_M"},
{.master = MT6761_M7_AXI_MST_SCP, .port = 7, .id_mask = 0x1F3F,
.id_val = 0x1E,
.note = "",
.name = "MT6761_M7_AXI_MST_SCP"},
{.master = MT6761_M7_AXI_MST_SSPM, .port = 7, .id_mask = 0x1F3F,
.id_val = 0x3E,
.note = "",
.name = "MT6761_M7_AXI_MST_SSPM"},
{.master = MT6761_M7_AXI_MST_GPU, .port = 7, .id_mask = 0x1F81,
.id_val = 0x1,
.note = "",
.name = "MT6761_M7_AXI_MST_GPU"},
};
#endif /* __MPU_PLATFORM_H__ */
+59
View File
@@ -0,0 +1,59 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __MT_EMI_H__
#define __MT_EMI_H__
/* submodule control */
#define ENABLE_BWL 1
#define ENABLE_MPU 1
#define ENABLE_ELM 1
#define ENABLE_MBW 0
#define DECS_ON_SSPM
/* #define ENABLE_BWL_CONFIG */
/* #define ENABLE_MPU_SLVERR */
#define DBG_INFO_READY 1
/* IRQ from device tree */
#define MPU_IRQ_INDEX 0
#define ELM_IRQ_INDEX 1 /* CGM IRQ as ELM IRQ */
/* macro for MPU */
#define ENABLE_AP_REGION 1
#define AP_REGION_ID 31
#define EMI_MPUD0_ST (CEN_EMI_BASE + 0x160)
#define EMI_MPUD_ST(domain) (EMI_MPUD0_ST + (4*domain))
#define EMI_MPUD0_ST2 (CEN_EMI_BASE + 0x200)
#define EMI_MPUD_ST2(domain) (EMI_MPUD0_ST2 + (4*domain))
#define EMI_MPUS (CEN_EMI_BASE + 0x01F0)
#define EMI_MPUT (CEN_EMI_BASE + 0x01F8)
#define EMI_MPUT_2ND (CEN_EMI_BASE + 0x01FC)
#define EMI_MPU_SA0 (0x100)
#define EMI_MPU_EA0 (0x200)
#define EMI_MPU_SA(region) (EMI_MPU_SA0 + (region*4))
#define EMI_MPU_EA(region) (EMI_MPU_EA0 + (region*4))
#define EMI_MPU_APC0 (0x300)
#define EMI_MPU_APC(region, dgroup) \
(EMI_MPU_APC0 + (region*4) + ((dgroup)*0x100))
#define EMI_MPU_CTRL_D0 (0x800)
#define EMI_MPU_CTRL_D(domain) (EMI_MPU_CTRL_D0 + (domain*4))
/* macro for ELM */
#define MBW_BUF_LEN 0x800000
#define LAST_EMI_DECS_CTRL (LAST_EMI_BASE + 0x04)
#define LAST_EMI_MBW_BUF_L (LAST_EMI_BASE + 0x10)
#define LAST_EMI_MBW_BUF_H (LAST_EMI_BASE + 0x14)
#include <mt_emi_api.h>
#include <bwl_v1.h>
#include <elm_v1.h>
#endif /* __MT_EMI_H__ */
@@ -0,0 +1,37 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __MT_EMI_API_H__
#define __MT_EMI_API_H__
/* macro for MPU */
#define EMI_MPU_DOMAIN_NUM 16
#define EMI_MPU_REGION_NUM 32
#define EMI_MPU_ALIGN_BITS 16
/* general macro */
#define MAX_CH 2
#define MAX_RK 2
#define DRAM_OFFSET 0x40000000
unsigned int get_dram_type(void);
unsigned int get_dram_mr(unsigned int index);
unsigned int get_ch_num(void);
unsigned int get_rk_num(void);
unsigned int get_rank_size(unsigned int rank_index);
unsigned int get_emi_bwst(unsigned int bw_index);
unsigned int get_emi_bwvl(unsigned int bw_index);
extern void __iomem *mt_cen_emi_base_get(void);
extern void __iomem *mt_emi_base_get(void);
extern void __iomem *mt_chn_emi_base_get(unsigned int channel_index);
extern void __iomem *mt_emi_mpu_base_get(void);
extern void dump_last_bm(char *buf, unsigned int leng);
#include <mpu_v1.h>
#include <pasr_api_v1.h>
#endif /* __MT_EMI_API_H__ */
@@ -0,0 +1,23 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/platform_device.h>
#include <linux/of_address.h>
#include <mt-plat/sync_write.h>
#ifdef CONFIG_MTK_AEE_FEATURE
#include <mt-plat/aee.h>
#endif
#include <emi_io.h>
#include "mt_emi.h"
void plat_debug_api_init(void)
{
}
void dump_emi_outstanding(void)
{
}
@@ -0,0 +1,12 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __PLAT_DEBUG_API_H__
#define __PLAT_DEBUG_API_H__
extern void dump_emi_outstanding(void);
#endif /* end of __PLAT_DEBUG_API_H__ */
+30
View File
@@ -0,0 +1,30 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
ccflags-y += -I$(srctree)/drivers/misc/mediatek/emi
ccflags-y += -I$(srctree)/drivers/misc/mediatek/emi/submodule
ccflags-y += -I$(srctree)/drivers/misc/mediatek/dramc
ccflags-y += -I$(srctree)/drivers/misc/mediatek/dramc/$(MTK_PLATFORM)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/debug_latch/plat_dbg_info
ccflags-y += -I$(srctree)/include/memory/mediatek
obj-y += bwl_platform.o
obj-y += mpu_platform.o
obj-y += plat_debug_api.o
obj-y += ../emi_ctrl_v1.o
obj-y += ../submodule/bwl_v1.o
obj-y += ../submodule/mpu_v1.o
obj-y += ../submodule/elm_v2.o
obj-y += ../submodule/pasr_api_v1.o
@@ -0,0 +1,114 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/kernel.h>
#include <linux/delay.h>
#include <mt-plat/sync_write.h>
#include <emi_io.h>
#include "mt_emi.h"
#include "bwl_platform.h"
#define EMI_BWCT0_2ND (CEN_EMI_BASE + 0x6A0)
#define EMI_BWCT0_4TH (CEN_EMI_BASE + 0x780)
#define EMI_BWCT0_5TH (CEN_EMI_BASE + 0x7B0)
#define EMI_BWST0 (CEN_EMI_BASE + 0x5C4)
#define EMI_BWST_2ND (CEN_EMI_BASE + 0x6A8)
#define EMI_BWST_3RD (CEN_EMI_BASE + 0x778)
#define EMI_BWST_4TH (CEN_EMI_BASE + 0x788)
#define EMI_BWST_5TH (CEN_EMI_BASE + 0x7B8)
#define EMI_BWVL (CEN_EMI_BASE + 0x7D0)
#define EMI_BWVL_2ND (CEN_EMI_BASE + 0x7D4)
#define EMI_BWVL_3RD (CEN_EMI_BASE + 0x7D8)
#define EMI_BWVL_4TH (CEN_EMI_BASE + 0x7DC)
#define EMI_BWVL_5TH (CEN_EMI_BASE + 0x7E0)
static unsigned int decs_status;
unsigned int decode_bwl_env(
unsigned int dram_type, unsigned int ch_num, unsigned int rk_num)
{
if (ch_num == 1)
return BWL_ENV_LPDDR3_1CH;
else
return BWL_ENV_LPDDR4_2CH;
}
unsigned int acquire_bwl_ctrl(void __iomem *LAST_EMI_BASE)
{
unsigned int timeout;
decs_status = readl(IOMEM(LAST_EMI_DECS_CTRL));
mt_reg_sync_writel(0x1, LAST_EMI_DECS_CTRL);
for (timeout = 1; readl(IOMEM(LAST_EMI_DECS_CTRL)) != 2; timeout++) {
mdelay(1);
if ((timeout % 100) == 0) {
mt_reg_sync_writel(decs_status, LAST_EMI_DECS_CTRL);
pr_debug("[BWL] switch scenario timeout\n");
return -1;
}
}
return 0;
}
void release_bwl_ctrl(void __iomem *LAST_EMI_BASE)
{
mt_reg_sync_writel(decs_status, LAST_EMI_DECS_CTRL);
}
void resume_decs(void __iomem *CEN_EMI_BASE)
{
mt_reg_sync_writel(0x00030023, EMI_BWCT0_2ND);
mt_reg_sync_writel(0x00C00023, EMI_BWCT0_4TH);
mt_reg_sync_writel(0x00240023, EMI_BWCT0_5TH);
}
unsigned int get_emi_bwst(unsigned int bw_index)
{
void __iomem *CEN_EMI_BASE;
CEN_EMI_BASE = mt_cen_emi_base_get();
switch (bw_index) {
case 0:
return readl(IOMEM(EMI_BWST0));
case 1:
return readl(IOMEM(EMI_BWST_2ND));
case 2:
return readl(IOMEM(EMI_BWST_3RD));
case 3:
return readl(IOMEM(EMI_BWST_4TH));
case 4:
return readl(IOMEM(EMI_BWST_5TH));
default:
return 0;
}
}
unsigned int get_emi_bwvl(unsigned int bw_index)
{
void __iomem *CEN_EMI_BASE;
CEN_EMI_BASE = mt_cen_emi_base_get();
switch (bw_index) {
case 0:
return readl(IOMEM(EMI_BWVL));
case 1:
return readl(IOMEM(EMI_BWVL_2ND));
case 2:
return readl(IOMEM(EMI_BWVL_3RD));
case 3:
return readl(IOMEM(EMI_BWVL_4TH));
case 4:
return readl(IOMEM(EMI_BWVL_5TH));
default:
return 0;
}
}
@@ -0,0 +1,49 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __BWL_PLATFORM_H__
#define __BWL_PLATFORM_H__
enum BWL_ENV {
BWL_ENV_LPDDR3_1CH,
BWL_ENV_LPDDR4_2CH,
BWL_ENV_MAX
};
enum BWL_SCN {
BWL_SCN_VPWFD,
BWL_SCN_VR4K,
BWL_SCN_ICFP,
BWL_SCN_UI,
BWL_SCN_MAX
};
enum BWL_CEN_REG {
BWL_CEN_0x00000100,
BWL_CEN_0x00000108,
BWL_CEN_0x00000110,
BWL_CEN_0x00000118,
BWL_CEN_0x00000120,
BWL_CEN_0x00000128,
BWL_CEN_0x00000130,
BWL_CEN_0x00000138,
BWL_CEN_MAX
};
enum BWL_CHN_REG {
BWL_CHN_0x00000048,
BWL_CHN_0x00000080,
BWL_CHN_0x00000088,
BWL_CHN_0x00000140,
BWL_CHN_0x00000144,
BWL_CHN_0x00000158,
BWL_CHN_0x0000015c,
BWL_CHN_MAX
};
#define SCN_DEFAULT BWL_SCN_UI
#endif /* __BWL_PLATFORM_H__ */
@@ -0,0 +1,126 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000110, 0xa0a050d8)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000128, 0xa0a070d7)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000048, 0x00008027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000080, 0x00000f00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000140, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000144, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x0000015c, 0x82410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000110, 0xa0a050da)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000128, 0xa0a070d3)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000048, 0x00008027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000080, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000140, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000144, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x0000015c, 0x82410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000110, 0xa0a050cb)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000128, 0xa0a070d6)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000048, 0x00008027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000080, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000140, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000144, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000158, 0x00080868)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x0000015c, 0x88410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000110, 0xa0a050c6)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000128, 0xa0a070d5)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000048, 0x00008027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000080, 0x00000f00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000140, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000144, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x0000015c, 0x82410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000110, 0xa0a050d8)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000128, 0xa0a070d7)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000048, 0x00030027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000080, 0x00000f00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000140, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000144, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x0000015c, 0x82410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000110, 0xa0a050da)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000128, 0xa0a070d3)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000048, 0x00030027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000080, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000140, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000144, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x0000015c, 0x82410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000110, 0xa0a050cb)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000128, 0xa0a070d6)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000048, 0x00030027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000080, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000140, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000144, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000158, 0x00080868)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x0000015c, 0x88410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000110, 0xa0a050c6)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000128, 0xa0a070d5)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000048, 0x00030027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000080, 0x00000f00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000140, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000144, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x0000015c, 0x82410222)
@@ -0,0 +1,42 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/platform_device.h>
#include "mt_emi.h"
enum {
MASTER_APM0 = 0,
MASTER_APM1 = 1,
MASTER_MM0 = 2,
MASTER_MDMCU = 3,
MASTER_MD = 4,
MASTER_MM1 = 5,
MASTER_GPU0_PERI = 6,
MASTER_GPU1_LPDMA = 7,
MASTER_ALL = 8
};
int is_md_master(unsigned int master_id, unsigned int domain_id)
{
if ((master_id & 0x7) == MASTER_MDMCU)
return 1;
if ((master_id & 0x7) == MASTER_MD)
return 1;
return 0;
}
void set_ap_region_permission(unsigned int apc[EMI_MPU_DGROUP_NUM])
{
SET_ACCESS_PERMISSION(apc, LOCK,
FORBIDDEN, FORBIDDEN, FORBIDDEN, FORBIDDEN,
FORBIDDEN, FORBIDDEN, NO_PROTECTION, NO_PROTECTION,
FORBIDDEN, SEC_R_NSEC_RW, FORBIDDEN, NO_PROTECTION,
FORBIDDEN, FORBIDDEN, FORBIDDEN, NO_PROTECTION);
}
File diff suppressed because it is too large. Load diff
+59
View File
@@ -0,0 +1,59 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __MT_EMI_H__
#define __MT_EMI_H__
/* submodule control */
#define ENABLE_BWL 1
#define ENABLE_MPU 1
#define ENABLE_ELM 1
#define ENABLE_MBW 0
#define DECS_ON_SSPM
/* #define ENABLE_BWL_CONFIG */
/* #define ENABLE_MPU_SLVERR */
#define DBG_INFO_READY 1
/* IRQ from device tree */
#define MPU_IRQ_INDEX 0
#define ELM_IRQ_INDEX 1 /* CGM IRQ as ELM IRQ */
/* macro for MPU */
#define ENABLE_AP_REGION 1
#define AP_REGION_ID 31
#define EMI_MPUD0_ST (CEN_EMI_BASE + 0x160)
#define EMI_MPUD_ST(domain) (EMI_MPUD0_ST + (4*domain))
#define EMI_MPUD0_ST2 (CEN_EMI_BASE + 0x200)
#define EMI_MPUD_ST2(domain) (EMI_MPUD0_ST2 + (4*domain))
#define EMI_MPUS (CEN_EMI_BASE + 0x01F0)
#define EMI_MPUT (CEN_EMI_BASE + 0x01F8)
#define EMI_MPUT_2ND (CEN_EMI_BASE + 0x01FC)
#define EMI_MPU_SA0 (0x100)
#define EMI_MPU_EA0 (0x200)
#define EMI_MPU_SA(region) (EMI_MPU_SA0 + (region*4))
#define EMI_MPU_EA(region) (EMI_MPU_EA0 + (region*4))
#define EMI_MPU_APC0 (0x300)
#define EMI_MPU_APC(region, dgroup) \
(EMI_MPU_APC0 + (region*4) + ((dgroup)*0x100))
#define EMI_MPU_CTRL_D0 (0x800)
#define EMI_MPU_CTRL_D(domain) (EMI_MPU_CTRL_D0 + (domain*4))
/* macro for ELM */
#define MBW_BUF_LEN 0x800000
#define LAST_EMI_DECS_CTRL (LAST_EMI_BASE + 0x04)
#define LAST_EMI_MBW_BUF_L (LAST_EMI_BASE + 0x10)
#define LAST_EMI_MBW_BUF_H (LAST_EMI_BASE + 0x14)
#include <mt_emi_api.h>
#include <bwl_v1.h>
#include <elm_v1.h>
#endif /* __MT_EMI_H__ */
@@ -0,0 +1,37 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __MT_EMI_API_H__
#define __MT_EMI_API_H__
/* macro for MPU */
#define EMI_MPU_DOMAIN_NUM 16
#define EMI_MPU_REGION_NUM 32
#define EMI_MPU_ALIGN_BITS 16
/* general macro */
#define MAX_CH 2
#define MAX_RK 2
#define DRAM_OFFSET 0x40000000
unsigned int get_dram_type(void);
unsigned int get_dram_mr(unsigned int index);
unsigned int get_ch_num(void);
unsigned int get_rk_num(void);
unsigned int get_rank_size(unsigned int rank_index);
unsigned int get_emi_bwst(unsigned int bw_index);
unsigned int get_emi_bwvl(unsigned int bw_index);
extern void __iomem *mt_cen_emi_base_get(void);
extern void __iomem *mt_emi_base_get(void);
extern void __iomem *mt_chn_emi_base_get(unsigned int channel_index);
extern void __iomem *mt_emi_mpu_base_get(void);
extern void dump_last_bm(char *buf, unsigned int leng);
#include <mpu_v1.h>
#include <pasr_api_v1.h>
#endif /* __MT_EMI_API_H__ */
@@ -0,0 +1,23 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/platform_device.h>
#include <linux/of_address.h>
#include <mt-plat/sync_write.h>
#ifdef CONFIG_MTK_AEE_FEATURE
#include <mt-plat/aee.h>
#endif
#include <emi_io.h>
#include "mt_emi.h"
void plat_debug_api_init(void)
{
}
void dump_emi_outstanding(void)
{
}
@@ -0,0 +1,12 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __PLAT_DEBUG_API_H__
#define __PLAT_DEBUG_API_H__
extern void dump_emi_outstanding(void);
#endif /* end of __PLAT_DEBUG_API_H__ */
+30
View File
@@ -0,0 +1,30 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
ccflags-y += -I$(srctree)/drivers/misc/mediatek/emi
ccflags-y += -I$(srctree)/drivers/misc/mediatek/emi/submodule
ccflags-y += -I$(srctree)/drivers/misc/mediatek/dramc
ccflags-y += -I$(srctree)/drivers/misc/mediatek/dramc/$(MTK_PLATFORM)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/debug_latch/plat_dbg_info
ccflags-y += -I$(srctree)/include/memory/mediatek
obj-y += bwl_platform.o
obj-y += mpu_platform.o
obj-y += plat_debug_api.o
obj-y += ../emi_ctrl_v1.o
obj-y += ../submodule/bwl_v1.o
obj-y += ../submodule/mpu_v1.o
obj-y += ../submodule/elm_v2.o
obj-y += ../submodule/pasr_api_v1.o
@@ -0,0 +1,113 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/delay.h>
#include <mt-plat/mtk_io.h>
#include <mt-plat/sync_write.h>
#include "mt_emi.h"
#include "bwl_platform.h"
#define EMI_BWCT0_2ND (CEN_EMI_BASE + 0x6A0)
#define EMI_BWCT0_4TH (CEN_EMI_BASE + 0x780)
#define EMI_BWCT0_5TH (CEN_EMI_BASE + 0x7B0)
#define EMI_BWST0 (CEN_EMI_BASE + 0x5C4)
#define EMI_BWST_2ND (CEN_EMI_BASE + 0x6A8)
#define EMI_BWST_3RD (CEN_EMI_BASE + 0x778)
#define EMI_BWST_4TH (CEN_EMI_BASE + 0x788)
#define EMI_BWST_5TH (CEN_EMI_BASE + 0x7B8)
#define EMI_BWVL (CEN_EMI_BASE + 0x7D0)
#define EMI_BWVL_2ND (CEN_EMI_BASE + 0x7D4)
#define EMI_BWVL_3RD (CEN_EMI_BASE + 0x7D8)
#define EMI_BWVL_4TH (CEN_EMI_BASE + 0x7DC)
#define EMI_BWVL_5TH (CEN_EMI_BASE + 0x7E0)
static unsigned int decs_status;
unsigned int decode_bwl_env(
unsigned int dram_type, unsigned int ch_num, unsigned int rk_num)
{
if (ch_num == 1)
return BWL_ENV_LPDDR3_1CH;
else
return BWL_ENV_LPDDR4_2CH;
}
unsigned int acquire_bwl_ctrl(void __iomem *LAST_EMI_BASE)
{
unsigned int timeout;
decs_status = readl(IOMEM(LAST_EMI_DECS_CTRL));
mt_reg_sync_writel(0x1, LAST_EMI_DECS_CTRL);
for (timeout = 1; readl(IOMEM(LAST_EMI_DECS_CTRL)) != 2; timeout++) {
mdelay(1);
if ((timeout % 100) == 0) {
mt_reg_sync_writel(decs_status, LAST_EMI_DECS_CTRL);
pr_debug("[BWL] switch scenario timeout\n");
return -1;
}
}
return 0;
}
void release_bwl_ctrl(void __iomem *LAST_EMI_BASE)
{
mt_reg_sync_writel(decs_status, LAST_EMI_DECS_CTRL);
}
void resume_decs(void __iomem *CEN_EMI_BASE)
{
mt_reg_sync_writel(0x00030023, EMI_BWCT0_2ND);
mt_reg_sync_writel(0x00C00023, EMI_BWCT0_4TH);
mt_reg_sync_writel(0x00240023, EMI_BWCT0_5TH);
}
unsigned int get_emi_bwst(unsigned int bw_index)
{
void __iomem *CEN_EMI_BASE;
CEN_EMI_BASE = mt_cen_emi_base_get();
switch (bw_index) {
case 0:
return readl(IOMEM(EMI_BWST0));
case 1:
return readl(IOMEM(EMI_BWST_2ND));
case 2:
return readl(IOMEM(EMI_BWST_3RD));
case 3:
return readl(IOMEM(EMI_BWST_4TH));
case 4:
return readl(IOMEM(EMI_BWST_5TH));
default:
return 0;
}
}
unsigned int get_emi_bwvl(unsigned int bw_index)
{
void __iomem *CEN_EMI_BASE;
CEN_EMI_BASE = mt_cen_emi_base_get();
switch (bw_index) {
case 0:
return readl(IOMEM(EMI_BWVL));
case 1:
return readl(IOMEM(EMI_BWVL_2ND));
case 2:
return readl(IOMEM(EMI_BWVL_3RD));
case 3:
return readl(IOMEM(EMI_BWVL_4TH));
case 4:
return readl(IOMEM(EMI_BWVL_5TH));
default:
return 0;
}
}
@@ -0,0 +1,43 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __BWL_PLATFORM_H__
#define __BWL_PLATFORM_H__
enum BWL_ENV {
BWL_ENV_LPDDR4_2CH,
BWL_ENV_LPDDR3_1CH,
BWL_ENV_MAX
};
enum BWL_SCN {
BWL_SCN_ICFP,
BWL_SCN_VPWFD,
BWL_SCN_VR4K,
BWL_SCN_UI,
BWL_SCN_MAX
};
enum BWL_CEN_REG {
BWL_CEN_0x00000100,
BWL_CEN_0x00000108,
BWL_CEN_0x00000110,
BWL_CEN_0x00000118,
BWL_CEN_0x00000120,
BWL_CEN_0x00000124,
BWL_CEN_0x00000128,
BWL_CEN_0x00000130,
BWL_CEN_0x00000138,
BWL_CEN_MAX
};
enum BWL_CHN_REG {
BWL_CHN_0x0000015c,
BWL_CHN_MAX
};
#define SCN_DEFAULT BWL_SCN_UI
#endif /* __BWL_PLATFORM_H__ */
@@ -0,0 +1,85 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000100, 0x10107244)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000108, 0x10107044)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000110, 0x040a50df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000118, 0x0000f0d0)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000120, 0x08086048)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000124, 0x00000034)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000128, 0x0a0a50df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000130, 0x20207044)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000138, 0x20207044)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x0000015c, 0x88410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000100, 0x10107244)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000108, 0x10107044)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000110, 0x040a50df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000118, 0x0000f0d0)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000120, 0x08086048)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000124, 0x00000034)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000128, 0x0a0a50df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000130, 0x20207044)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000138, 0x20207044)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x0000015c, 0x88410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000100, 0x10107244)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000108, 0x10107044)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000110, 0x040a50df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000118, 0x0000f0d0)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000120, 0x08086048)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000124, 0x00000034)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000128, 0x0a0a50df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000130, 0x20207044)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000138, 0x20207044)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x0000015c, 0x88410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000100, 0x08047250)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000108, 0x10107050)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000110, 0x0a0a50df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000118, 0x0000f0d0)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000120, 0x08086050)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000124, 0x00000034)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000128, 0x0a0a50df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000130, 0x20207048)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000138, 0x20207048)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x0000015c, 0x82410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000100, 0x10107244)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000108, 0x10107044)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000110, 0x040a50df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000118, 0x0000f0d0)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000120, 0x08086048)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000124, 0x00000034)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000128, 0x0a0a50df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000130, 0x20207044)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000138, 0x20207044)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x0000015c, 0x88410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000100, 0x10107244)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000108, 0x10107044)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000110, 0x040a50df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000118, 0x0000f0d0)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000120, 0x08086048)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000124, 0x00000034)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000128, 0x0a0a50df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000130, 0x20207044)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000138, 0x20207044)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x0000015c, 0x88410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000100, 0x10107244)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000108, 0x10107044)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000110, 0x040a50df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000118, 0x0000f0d0)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000120, 0x08086048)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000124, 0x00000034)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000128, 0x0a0a50df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000130, 0x20207044)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000138, 0x20207044)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x0000015c, 0x88410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000100, 0x08047250)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000108, 0x10107050)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000110, 0x0a0a50df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000118, 0x0000f0d0)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000120, 0x08086050)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000124, 0x00000034)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000128, 0x0a0a50df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000130, 0x20207048)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000138, 0x20207048)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x0000015c, 0x82410222)
@@ -0,0 +1,83 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/platform_device.h>
#include <mt-plat/sync_write.h>
#include <mt-plat/mtk_io.h>
#include "mt_emi.h"
static void __iomem *CEN_EMI_BASE;
enum {
MASTER_APM0 = 0,
MASTER_APM1 = 1,
MASTER_MM0 = 2,
MASTER_MDMCU = 3,
MASTER_MD = 4,
MASTER_MM1 = 5,
MASTER_GPU0_PERI = 6,
MASTER_GPU1_LPDMA = 7,
MASTER_ALL = 8
};
int is_md_master(unsigned int master_id, unsigned int domain_id)
{
if ((master_id & 0x7) == MASTER_MDMCU)
return 1;
if ((master_id & 0x7) == MASTER_MD)
return 1;
return 0;
}
void set_ap_region_permission(unsigned int apc[EMI_MPU_DGROUP_NUM])
{
SET_ACCESS_PERMISSION(apc, LOCK,
FORBIDDEN, FORBIDDEN, FORBIDDEN, FORBIDDEN,
SEC_R_NSEC_R, FORBIDDEN, NO_PROTECTION, NO_PROTECTION,
FORBIDDEN, SEC_R_NSEC_RW, FORBIDDEN, NO_PROTECTION,
FORBIDDEN, FORBIDDEN, FORBIDDEN, NO_PROTECTION);
}
void bypass_init(unsigned int *init_flag)
{
CEN_EMI_BASE = mt_cen_emi_base_get();
*init_flag = 1;
}
int bypass_violation(unsigned int mpus, unsigned int *init_flag)
{
unsigned int mput, mput_2nd;
unsigned long long vio_addr;
unsigned int master_id, domain_id;
unsigned int port_id;
unsigned int wr_vio, wr_oo_vio;
unsigned int hp_wr_vio;
mput = readl(IOMEM(EMI_MPUT));
mput_2nd = readl(IOMEM(EMI_MPUT_2ND));
vio_addr = ((((unsigned long long)(mput_2nd & 0xF)) << 32) + mput +
DRAM_OFFSET);
hp_wr_vio = (mput_2nd >> 21) & 0x3;
master_id = mpus & 0xFFFF;
domain_id = (mpus >> 21) & 0xF;
wr_vio = (mpus >> 29) & 0x3;
wr_oo_vio = (mpus >> 27) & 0x3;
port_id = master_id & 0x7;
#if defined(CONFIG_MTK_ENABLE_GENIEZONE) \
|| defined(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT)
if ((wr_vio == 2) && (wr_oo_vio == 0) &&
((port_id == 0) || (port_id == 1)))
return 1;
#endif
return 0;
}
File diff suppressed because it is too large. Load diff
+66
View File
@@ -0,0 +1,66 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_EMI_H__
#define __MT_EMI_H__
/* submodule control */
#define ENABLE_BWL 1
#define ENABLE_MPU 1
#define ENABLE_ELM 1
#define ENABLE_MBW 0
#define DECS_ON_SSPM
#define MPU_BYPASS
#define ISU_VER_CTRL
/* #define ENABLE_MPU_SLVERR */
#define DBG_INFO_READY 1
#define ENABLE_EMI_DEBUG_API
/* IRQ from device tree */
#define MPU_IRQ_INDEX 0
#define ELM_IRQ_INDEX 1 /* fcBianco uses CGM IRQ as ELM IRQ */
/* macro for MPU */
#if defined(CONFIG_MACH_MT6768)
#define ENABLE_AP_REGION 1
#else
#define ENABLE_AP_REGION 0
#endif
#define AP_REGION_ID 31
#define EMI_MPUD0_ST (CEN_EMI_BASE + 0x160)
#define EMI_MPUD_ST(domain) (EMI_MPUD0_ST + (4*domain))
#define EMI_MPUD0_ST2 (CEN_EMI_BASE + 0x200)
#define EMI_MPUD_ST2(domain) (EMI_MPUD0_ST2 + (4*domain))
#define EMI_MPUS (CEN_EMI_BASE + 0x01F0)
#define EMI_MPUT (CEN_EMI_BASE + 0x01F8)
#define EMI_MPUT_2ND (CEN_EMI_BASE + 0x01FC)
#define EMI_MPU_SA0 (0x100)
#define EMI_MPU_EA0 (0x200)
#define EMI_MPU_SA(region) (EMI_MPU_SA0 + (region*4))
#define EMI_MPU_EA(region) (EMI_MPU_EA0 + (region*4))
#define EMI_MPU_APC0 (0x300)
#define EMI_MPU_APC(region, dgroup) \
(EMI_MPU_APC0 + (region*4) + ((dgroup)*0x100))
#define EMI_MPU_CTRL_D0 (0x800)
#define EMI_MPU_CTRL_D(domain) (EMI_MPU_CTRL_D0 + (domain*4))
/* macro for ELM */
#define MBW_BUF_LEN 0x800000
#define LAST_EMI_DECS_CTRL (LAST_EMI_BASE + 0x04)
#define LAST_EMI_MBW_BUF_L (LAST_EMI_BASE + 0x10)
#define LAST_EMI_MBW_BUF_H (LAST_EMI_BASE + 0x14)
#define LAST_EMI_ISU_VER (LAST_EMI_BASE + 0x18)
#include <mt_emi_api.h>
#include <bwl_v1.h>
#include <elm_v1.h>
#endif /* __MT_EMI_H__ */
@@ -0,0 +1,38 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_EMI_API_H__
#define __MT_EMI_API_H__
/* macro for MPU */
#define EMI_MPU_DOMAIN_NUM 16
#define EMI_MPU_REGION_NUM 32
#define EMI_MPU_ALIGN_BITS 16
/* general macro */
#define MAX_CH 2
#define MAX_DBG_NR 1
#define MAX_RK 2
#define DRAM_OFFSET 0x40000000
unsigned int get_dram_type(void);
unsigned int get_ch_num(void);
unsigned int get_rk_num(void);
unsigned int get_dram_mr(unsigned int index);
unsigned int get_rank_size(unsigned int rank_index);
unsigned int get_emi_bwst(unsigned int bw_index);
unsigned int get_emi_bwvl(unsigned int bw_index);
extern void __iomem *mt_cen_emi_base_get(void);
extern void __iomem *mt_emi_base_get(void);
extern void __iomem *mt_chn_emi_base_get(unsigned int channel_index);
extern void __iomem *mt_emi_mpu_base_get(void);
extern void dump_last_bm(char *buf, unsigned int leng);
#include <mpu_v1.h>
#include <pasr_api_v1.h>
#endif /* __MT_EMI_API_H__ */
@@ -0,0 +1,132 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/platform_device.h>
#include <linux/of_address.h>
#include <linux/delay.h>
#include <mt-plat/sync_write.h>
#include <mt-plat/mtk_io.h>
#ifdef CONFIG_MTK_AEE_FEATURE
#include <mt-plat/aee.h>
#include <mt-plat/mboot_params.h>
#endif
#include "mt_emi_api.h"
#include <../emi_ctrl_v1.h>
#include "mt_emi.h"
#include "plat_debug_api.h"
static void __iomem *cen_emi_base;
static void __iomem *base0;
static void __iomem *base1;
static void __iomem *base2;
void plat_debug_api_init(void)
{
cen_emi_base = mt_cen_emi_base_get();
base0 = mt_emi_dbg_base_get(0);
base1 = mt_chn_emi_base_get(0);
base2 = mt_chn_emi_base_get(1);
pr_debug("[EMI] >> cen: %p\n", cen_emi_base);
pr_debug("[EMI] >> base0: %p\n", base0);
pr_debug("[EMI] >> base1: %p\n", base1);
pr_debug("[EMI] >> base2: %p\n", base2);
}
static void infra_dbg0(unsigned int v0, unsigned int v1,
unsigned int v2, unsigned int v3,
const char *str)
{
writel(v0, base0+0x100);
writel(v1, base0+0x104);
writel(v2, base0+0x108);
writel(v3, base0+0x10c);
pr_debug("[EMI] %s: 0x%x\n", str, readl(cen_emi_base+0x7fc));
}
static void infra_dbg1(unsigned int v0, unsigned int v1,
const char *str)
{
writel(v0, base1+0xa88);
writel(v1, base1+0xa8c);
pr_debug("[EMI] %s: 0x%x\n", str, readl(base1+0xa84));
}
static void infra_dbg2(unsigned int v0, unsigned int v1,
const char *str)
{
writel(v0, base2+0xa88);
writel(v1, base2+0xa8c);
pr_debug("[EMI] %s: 0x%x\n", str, readl(base2+0xa84));
}
static void one_shot(void)
{
pr_debug("\n----------------\n");
writel(readl(cen_emi_base+0xe8)|(0x1<<8), cen_emi_base+0xe8);
infra_dbg0(0x20, 0x40, 0x60, 0x80, "CEN_EMI_DEBUG_0");
infra_dbg0(0xa0, 0xc0, 0xe0, 0x100, "CEN_EMI_DEBUG_1");
infra_dbg0(0x120, 0x140, 0x160, 0x180, "CEN_EMI_DEBUG_2");
infra_dbg0(0x1a0, 0x1c0, 0x1e0, 0x200, "CEN_EMI_DEBUG_3");
infra_dbg0(0x220, 0x240, 0x260, 0x280, "CEN_EMI_DEBUG_4");
infra_dbg0(0x2a0, 0x2c0, 0x2e0, 0x300, "CEN_EMI_DEBUG_5");
infra_dbg0(0x320, 0x340, 0x360, 0x380, "CEN_EMI_DEBUG_6");
infra_dbg0(0x3a0, 0x3c0, 0x3e0, 0x400, "CEN_EMI_DEBUG_7");
infra_dbg0(0x420, 0x4e0, 0x500, 0x520, "CEN_EMI_DEBUG_8");
infra_dbg0(0x540, 0x560, 0x580, 0x5a0, "CEN_EMI_DEBUG_9");
infra_dbg0(0x6c0, 0x6e0, 0x700, 0x720, "CEN_EMI_DEBUG_A");
infra_dbg0(0x740, 0x7a0, 0x7c0, 0x7e0, "CEN_EMI_DEBUG_B");
pr_debug("[EMI] %s: 0x%x\n", "EMI_IOCL", readl(cen_emi_base+0xd0));
pr_debug("[EMI] %s: 0x%x\n", "EMI_IOCL_2ND", readl(cen_emi_base+0xd4));
pr_debug("[EMI] %s: 0x%x\n", "EMI_IOCM", readl(cen_emi_base+0xd8));
pr_debug("[EMI] %s: 0x%x\n", "EMI_IOCM_2ND", readl(cen_emi_base+0xdc));
writel(readl(base1+0xa80)|0x1, base1+0xa80);
infra_dbg1(0x10000, 0x30002, "CHN0_EMI_DBG_0");
infra_dbg1(0x50004, 0x70006, "CHN0_EMI_DBG_1");
infra_dbg1(0x90008, 0xb000a, "CHN0_EMI_DBG_2");
infra_dbg1(0xd000c, 0xf000e, "CHN0_EMI_DBG_3");
infra_dbg1(0x110010, 0x130012, "CHN0_EMI_DBG_4");
infra_dbg1(0x150014, 0x170016, "CHN0_EMI_DBG_5");
infra_dbg1(0x190018, 0x1b001a, "CHN0_EMI_DBG_6");
infra_dbg1(0x1d001c, 0x1f001e, "CHN0_EMI_DBG_7");
infra_dbg1(0x210020, 0x230022, "CHN0_EMI_DBG_8");
infra_dbg1(0x250024, 0x270026, "CHN0_EMI_DBG_9");
infra_dbg1(0x290028, 0x310030, "CHN0_EMI_DBG_A");
infra_dbg1(0x370036, 0x390038, "CHN0_EMI_DBG_B");
writel(readl(base2+0xa80)|0x1, base2+0xa80);
infra_dbg2(0x10000, 0x30002, "CHN1_EMI_DBG_0");
infra_dbg2(0x50004, 0x70006, "CHN1_EMI_DBG_1");
infra_dbg2(0x90008, 0xb000a, "CHN1_EMI_DBG_2");
infra_dbg2(0xd000c, 0xf000e, "CHN1_EMI_DBG_3");
infra_dbg2(0x110010, 0x130012, "CHN1_EMI_DBG_4");
infra_dbg2(0x150014, 0x170016, "CHN1_EMI_DBG_5");
infra_dbg2(0x190018, 0x1b001a, "CHN1_EMI_DBG_6");
infra_dbg2(0x1d001c, 0x1f001e, "CHN1_EMI_DBG_7");
infra_dbg2(0x210020, 0x230022, "CHN1_EMI_DBG_8");
infra_dbg2(0x250024, 0x270026, "CHN1_EMI_DBG_9");
infra_dbg2(0x290028, 0x310030, "CHN1_EMI_DBG_A");
infra_dbg2(0x370036, 0x390038, "CHN1_EMI_DBG_B");
}
void dump_emi_outstanding(void)
{
if (is_infra_timeout()) {
lastbus_timeout_dump();
one_shot();
mdelay(1);
one_shot();
mdelay(1);
one_shot();
} else {
pr_debug("[BUS] no infra timeout now\n");
pr_debug("[BUS] should check those before bus\n");
}
}
@@ -0,0 +1,13 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __PLAT_DEBUG_API_H__
#define __PLAT_DEBUG_API_H__
extern void dump_emi_outstanding(void);
extern int lastbus_timeout_dump(void);
extern int is_infra_timeout(void);
#endif /* end of __PLAT_DEBUG_API_H__ */
+29
View File
@@ -0,0 +1,29 @@
# SPDX-License-Identifier: GPL-2.0
#
# Copyright (c) 2019 MediaTek Inc.
#
UBSAN_SANITIZE := n
ccflags-y += -I$(srctree)/drivers/misc/mediatek/emi
ccflags-y += -I$(srctree)/drivers/misc/mediatek/emi/submodule
ccflags-y += -I$(srctree)/drivers/misc/mediatek/dramc
ccflags-y += -I$(srctree)/drivers/misc/mediatek/dramc/$(MTK_PLATFORM)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/debug_latch/plat_dbg_info
ccflags-y += -I$(srctree)/include/memory/mediatek
ifeq ($(CONFIG_MTK_DEVMPU),y)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/devmpu
ccflags-y += -I$(srctree)/drivers/misc/mediatek/devmpu/$(MTK_PLATFORM)
endif
obj-y += bwl_platform.o
obj-y += mpu_platform.o
obj-y += plat_debug_api.o
obj-y += ../emi_ctrl_v1.o
obj-y += ../submodule/bwl_v1.o
obj-y += ../submodule/mpu_v1.o
obj-y += ../submodule/elm_v2.o
obj-y += ../submodule/pasr_api_v1.o
@@ -0,0 +1,131 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/kernel.h>
#include <linux/delay.h>
#include <mt-plat/mtk_io.h>
#include <mt-plat/sync_write.h>
#include "mt_emi.h"
#include "bwl_platform.h"
#define EMI_BWCT0_2ND (CEN_EMI_BASE + 0x6A0)
#define EMI_BWCT0_4TH (CEN_EMI_BASE + 0x780)
#define EMI_BWCT0_5TH (CEN_EMI_BASE + 0x7B0)
#define EMI_BWCT0_7TH (CEN_EMI_BASE + 0x880)
#define EMI_EXT_BW_CON0_1ST (CEN_EMI_BASE + 0xE40)
#define EMI_BWST0 (CEN_EMI_BASE + 0x5C4)
#define EMI_BWST_2ND (CEN_EMI_BASE + 0x6A8)
#define EMI_BWST_3RD (CEN_EMI_BASE + 0x778)
#define EMI_BWST_4TH (CEN_EMI_BASE + 0x788)
#define EMI_BWST_5TH (CEN_EMI_BASE + 0x7B8)
#define EMI_BWVL (CEN_EMI_BASE + 0x7D0)
#define EMI_BWVL_2ND (CEN_EMI_BASE + 0x7D4)
#define EMI_BWVL_3RD (CEN_EMI_BASE + 0x7D8)
#define EMI_BWVL_4TH (CEN_EMI_BASE + 0x7DC)
#define EMI_BWVL_5TH (CEN_EMI_BASE + 0x7E0)
static unsigned int decs_status;
int is_emi_latency_regulator_on(void)
{
return 1;
}
unsigned int decode_bwl_env(
unsigned int dram_type, unsigned int ch_num, unsigned int rk_num)
{
return BWL_ENV_LPDDR4_2CH;
}
unsigned int acquire_bwl_ctrl(void __iomem *LAST_EMI_BASE)
{
unsigned int timeout;
decs_status = readl(IOMEM(LAST_EMI_DECS_CTRL));
writel(0x1, LAST_EMI_DECS_CTRL);
for (timeout = 1; readl(IOMEM(LAST_EMI_DECS_CTRL)) != 2; timeout++) {
mdelay(1);
if ((timeout % 100) == 0) {
writel(decs_status, LAST_EMI_DECS_CTRL);
pr_debug("[BWL] switch scenario timeout\n");
return -1;
}
}
return 0;
}
void release_bwl_ctrl(void __iomem *LAST_EMI_BASE)
{
writel(decs_status, LAST_EMI_DECS_CTRL);
}
void resume_decs(void __iomem *CEN_EMI_BASE)
{
writel(0x00030023, EMI_BWCT0_2ND);
writel(0x00C00023, EMI_BWCT0_4TH);
writel(0x00240023, EMI_BWCT0_5TH);
writel(0x003FC023, EMI_EXT_BW_CON0_1ST);
}
unsigned int get_emi_bwst(unsigned int bw_index)
{
void __iomem *CEN_EMI_BASE;
CEN_EMI_BASE = mt_cen_emi_base_get();
switch (bw_index) {
case 0:
return readl(IOMEM(EMI_BWST0));
case 1:
return readl(IOMEM(EMI_BWST_2ND));
case 2:
return readl(IOMEM(EMI_BWST_3RD));
case 3:
return readl(IOMEM(EMI_BWST_4TH));
case 4:
return readl(IOMEM(EMI_BWST_5TH));
default:
return 0;
}
}
unsigned int get_emi_bwvl(unsigned int bw_index)
{
void __iomem *CEN_EMI_BASE;
CEN_EMI_BASE = mt_cen_emi_base_get();
switch (bw_index) {
case 0:
return readl(IOMEM(EMI_BWVL));
case 1:
return readl(IOMEM(EMI_BWVL_2ND));
case 2:
return readl(IOMEM(EMI_BWVL_3RD));
case 3:
return readl(IOMEM(EMI_BWVL_4TH));
case 4:
return readl(IOMEM(EMI_BWVL_5TH));
default:
return 0;
}
}
void bw_monitor_init(void)
{
void __iomem *CEN_EMI_BASE;
CEN_EMI_BASE = mt_cen_emi_base_get();
/* init BW monitor for sspm use */
writel(0x00030023, EMI_BWCT0_2ND);
writel(0x00C00023, EMI_BWCT0_4TH);
writel(0x00240023, EMI_BWCT0_5TH);
writel(0x003FC023, EMI_EXT_BW_CON0_1ST);
}
@@ -0,0 +1,41 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __BWL_PLATFORM_H__
#define __BWL_PLATFORM_H__
enum BWL_ENV {
BWL_ENV_LPDDR4_2CH,
BWL_ENV_MAX
};
enum BWL_SCN {
BWL_SCN_ICFP,
BWL_SCN_UI,
BWL_SCN_MAX,
};
enum BWL_CEN_REG {
BWL_CEN_0x00000100,
BWL_CEN_0x00000108,
BWL_CEN_0x00000110,
BWL_CEN_0x00000118,
BWL_CEN_0x00000120,
BWL_CEN_0x00000124,
BWL_CEN_0x00000128,
BWL_CEN_0x00000130,
BWL_CEN_0x00000138,
BWL_CEN_MAX,
};
enum BWL_CHN_REG {
BWL_CHN_0x0000015c,
BWL_CHN_MAX,
};
#define SCN_DEFAULT BWL_SCN_UI
#endif /* __BWL_PLATFORM_H__ */
@@ -0,0 +1,26 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000100, 0x20107244)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000108, 0x10107044)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000110, 0x343450df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000118, 0x0000f0d0)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000120, 0x10106048)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000124, 0x00000034)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000128, 0x343450df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000130, 0x83837044)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000138, 0x83837044)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x0000015c, 0x884102a2)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000100, 0x20107250)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000108, 0x10107050)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000110, 0x343450df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000118, 0x0000f0d0)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000120, 0x10106050)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000124, 0x00000034)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000128, 0x343450df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000130, 0x83837048)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000138, 0x83837048)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x0000015c, 0x824102a2)
@@ -0,0 +1,50 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/platform_device.h>
#include "mt_emi.h"
enum {
MASTER_APM0 = 0,
MASTER_APM1 = 1,
MASTER_MM0 = 2,
MASTER_MDMCU = 3,
MASTER_MD = 4,
MASTER_MM1 = 5,
MASTER_GPU0_PERI = 6,
MASTER_GPU1_LPDMA = 7,
MASTER_ALL = 8
};
#define MDMCU_DOMAIN 1
#define MDHW_DOMAIN 7
int is_md_master(unsigned int master_id,
unsigned int domain_id)
{
if ((domain_id != MDMCU_DOMAIN) &&
(domain_id != MDHW_DOMAIN))
return 0;
if ((master_id & 0x7) == MASTER_MDMCU)
return 1;
if ((master_id & 0x7) == MASTER_MD)
return 1;
return 0;
}
void set_ap_region_permission(unsigned int apc[EMI_MPU_DGROUP_NUM])
{
SET_ACCESS_PERMISSION(apc, LOCK,
FORBIDDEN, FORBIDDEN, SEC_RW, SEC_RW,
NO_PROTECTION, FORBIDDEN, NO_PROTECTION, NO_PROTECTION,
FORBIDDEN, SEC_R_NSEC_RW, FORBIDDEN, NO_PROTECTION,
FORBIDDEN, FORBIDDEN, FORBIDDEN, NO_PROTECTION);
}
@@ -0,0 +1,697 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __MPU_PLATFORM_H__
#define __MPU_PLATFORM_H__
enum {
MT6779_M4_AXI_MST_QP_DLCH,
MT6779_M7_AXI_MST_SPI5,
MT6779_M4_AXI_MST_TRACE_TOP,
MT6779_M2_AXI_MST_MM_IOMMU,
MT6779_M4_AXI_MST_DFD,
MT6779_M7_AXI_MST_SPI7,
MT6779_M2_AXI_MST_CCU,
MT6779_M2_AXI_MST_SMI_LARB0,
MT6779_M7_AXI_MST_APU_IOMMU_PORT1,
MT6779_M7_AXI_MST_IPU,
MT6779_M3_AXI_MST_MMU,
MT6779_M7_AXI_MST_NA,
MT6779_M2_AXI_MST_SMI_LARB2,
MT6779_M4_AXI_MST_MRSG0,
MT6779_M4_AXI_MST_IRDMA,
MT6779_M7_AXI_MST_MSDC0,
MT6779_M4_AXI_MST_HRQ_RD,
MT6779_M4_AXI_MST_DBGSYS_DSP,
MT6779_M4_AXI_MST_CNWDMA,
MT6779_M5_AXI_MST_SMI_LARB1,
MT6779_M0_AXI_MST_MP1,
MT6779_M7_AXI_MST_DEVICE_MPU,
MT6779_M4_AXI_MST_QP,
MT6779_M2_AXI_MST_SMI_LARB8,
MT6779_M5_AXI_MST_SMI_LARB3,
MT6779_M7_AXI_MST_DX_CC,
MT6779_M4_AXI_MST_GDMA,
MT6779_M3_AXI_MST_MM,
MT6779_M5_AXI_MST_SMI_LARB5,
MT6779_M7_AXI_MST_UFS,
MT6779_M7_AXI_MST_SPI0,
MT6779_M4_AXI_MST_IPSEC,
MT6779_M4_AXI_MST_MMU,
MT6779_M4_AXI_MST_XDMA,
MT6779_M7_AXI_MST_CQ_DMA,
MT6779_M1_AXI_MST_MP1,
MT6779_M5_AXI_MST_SMI_LARB7,
MT6779_M7_AXI_MST_SPI2,
MT6779_M5_AXI_MST_SMI_LARB10,
MT6779_M5_AXI_MST_SMI_LARB9,
MT6779_M4_AXI_MST_DMA_RD,
MT6779_M7_AXI_MST_SPI4,
MT6779_M7_AXI_MST_DMA_EXT,
MT6779_M2_AXI_MST_SMI_LARB10,
MT6779_M4_AXI_MST_HRQ_RD1,
MT6779_M6_AXI_MST_APU_M0,
MT6779_M4_AXI_MST_TXBSRP,
MT6779_M3_AXI_MST_USIP_1_DPERI,
MT6779_M3_AXI_MST_USIP_0_DPERI,
MT6779_M7_AXI_MST_SPI6,
MT6779_M3_AXI_MST_USIP_1_I,
MT6779_M6_AXI_MST_APU_IOMMU,
MT6779_M5_AXI_MST_MM_IOMMU,
MT6779_M5_AXI_MST_CCU,
MT6779_M7_AXI_MST_PWM,
MT6779_M2_AXI_MST_SMI_LARB1,
MT6779_M7_AXI_MST_SPM,
MT6779_M7_AXI_MST_AUDIO,
MT6779_M3_AXI_MST_USIP_0_I,
MT6779_M2_AXI_MST_SMI_LARB3,
MT6779_M4_AXI_MST_IPF,
MT6779_M7_AXI_MST_APU_M1,
MT6779_M4_AXI_MST_MRSG1,
MT6779_M7_AXI_MST_MFG_M1,
MT6779_M4_AXI_MST_TPC,
MT6779_M2_AXI_MST_SMI_LARB5,
MT6779_M4_AXI_MST_HRQ_WR,
MT6779_M5_AXI_MST_SMI_LARB0,
MT6779_M7_AXI_MST_MSDC1,
MT6779_M4_AXI_MST_CLDMA,
MT6779_M4_AXI_MST_LOG_TOP_MCU,
MT6779_M4_AXI_MST_VTB,
MT6779_M0_AXI_MST_MP0,
MT6779_M7_AXI_MST_SSUSB,
MT6779_M4_AXI_MST_HIFI3,
MT6779_M2_AXI_MST_SMI_LARB7,
MT6779_M7_AXI_MST_GCE_M,
MT6779_M5_AXI_MST_SMI_LARB2,
MT6779_M7_AXI_MST_THERM,
MT6779_M4_AXI_MST_LOG_TOP_DSP,
MT6779_M4_AXI_MST_SCP,
MT6779_M3_AXI_MST_USIP_0_DLONG,
MT6779_M2_AXI_MST_SMI_LARB9,
MT6779_M4_AXI_MST_DMA_RD_DLCH,
MT6779_M6_AXI_MST_MFG,
MT6779_M4_AXI_MST_PPPHA,
MT6779_M4_AXI_MST_CSH0,
MT6779_M4_AXI_MST_BR_DMA,
MT6779_M1_AXI_MST_MP0,
MT6779_M7_AXI_MST_SPI1,
MT6779_M4_AXI_MST_DCXO,
MT6779_M3_AXI_MST_USIP_1_DLONG,
MT6779_M4_AXI_MST_SSPM,
MT6779_M4_AXI_MST_HRQ_WR1,
MT6779_M5_AXI_MST_SMI_LARB8,
MT6779_M7_AXI_MST_DEBUGTOP,
MT6779_M4_AXI_MST_TBO,
MT6779_M7_AXI_MST_SPI3,
MT6779_M4_AXI_MST_DMA_WR,
MT6779_M4_AXI_MST_CONNSYS,
MT6779_M7_AXI_MST_CCU,
MST_INVALID,
NR_MST
};
static const struct mst_tbl_entry mst_tbl[] = {
{.master = MT6779_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1EF8,
.id_val = 0x0,
.note = "",
.name = "MT6779_M0_AXI_MST_MP0"},
{.master = MT6779_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1EF8,
.id_val = 0x20,
.note = "",
.name = "MT6779_M0_AXI_MST_MP0"},
{.master = MT6779_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1E80,
.id_val = 0x80,
.note = "",
.name = "MT6779_M0_AXI_MST_MP0"},
{.master = MT6779_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1DF8,
.id_val = 0x0,
.note = "",
.name = "MT6779_M0_AXI_MST_MP0"},
{.master = MT6779_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1DF8,
.id_val = 0x20,
.note = "",
.name = "MT6779_M0_AXI_MST_MP0"},
{.master = MT6779_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1DFF,
.id_val = 0x40,
.note = "",
.name = "MT6779_M0_AXI_MST_MP0"},
{.master = MT6779_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1DFF,
.id_val = 0x41,
.note = "",
.name = "MT6779_M0_AXI_MST_MP0"},
{.master = MT6779_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1D80,
.id_val = 0x80,
.note = "",
.name = "MT6779_M0_AXI_MST_MP0"},
{.master = MT6779_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1D00,
.id_val = 0x100,
.note = "",
.name = "MT6779_M0_AXI_MST_MP0"},
{.master = MT6779_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1EF8,
.id_val = 0x0,
.note = "",
.name = "MT6779_M1_AXI_MST_MP1"},
{.master = MT6779_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1EF8,
.id_val = 0x20,
.note = "",
.name = "MT6779_M1_AXI_MST_MP1"},
{.master = MT6779_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1E80,
.id_val = 0x80,
.note = "",
.name = "MT6779_M1_AXI_MST_MP1"},
{.master = MT6779_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1DF8,
.id_val = 0x0,
.note = "",
.name = "MT6779_M1_AXI_MST_MP1"},
{.master = MT6779_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1DF8,
.id_val = 0x20,
.note = "",
.name = "MT6779_M1_AXI_MST_MP1"},
{.master = MT6779_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1DFF,
.id_val = 0x40,
.note = "",
.name = "MT6779_M1_AXI_MST_MP1"},
{.master = MT6779_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1DFF,
.id_val = 0x41,
.note = "",
.name = "MT6779_M1_AXI_MST_MP1"},
{.master = MT6779_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1D80,
.id_val = 0x80,
.note = "",
.name = "MT6779_M1_AXI_MST_MP1"},
{.master = MT6779_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1D00,
.id_val = 0x100,
.note = "",
.name = "MT6779_M1_AXI_MST_MP1"},
{.master = MT6779_M2_AXI_MST_MM_IOMMU, .port = 2, .id_mask = 0x1FFF,
.id_val = 0xFFC,
.note = "",
.name = "MT6779_M2_AXI_MST_MM_IOMMU"},
{.master = MT6779_M2_AXI_MST_MM_IOMMU, .port = 2, .id_mask = 0x1FFF,
.id_val = 0xFFD,
.note = "",
.name = "MT6779_M2_AXI_MST_MM_IOMMU"},
{.master = MT6779_M2_AXI_MST_SMI_LARB0, .port = 2, .id_mask = 0x1F80,
.id_val = 0x0,
.note = "",
.name = "MT6779_M2_AXI_MST_SMI_LARB0"},
{.master = MT6779_M2_AXI_MST_SMI_LARB1, .port = 2, .id_mask = 0x1F80,
.id_val = 0x200,
.note = "",
.name = "MT6779_M2_AXI_MST_SMI_LARB1"},
{.master = MT6779_M2_AXI_MST_SMI_LARB2, .port = 2, .id_mask = 0x1F80,
.id_val = 0x400,
.note = "",
.name = "MT6779_M2_AXI_MST_SMI_LARB2"},
{.master = MT6779_M2_AXI_MST_SMI_LARB3, .port = 2, .id_mask = 0x1F80,
.id_val = 0x600,
.note = "",
.name = "MT6779_M2_AXI_MST_SMI_LARB3"},
{.master = MT6779_M2_AXI_MST_SMI_LARB5, .port = 2, .id_mask = 0x1F80,
.id_val = 0x800,
.note = "",
.name = "MT6779_M2_AXI_MST_SMI_LARB5"},
{.master = MT6779_M2_AXI_MST_SMI_LARB7, .port = 2, .id_mask = 0x1F80,
.id_val = 0xA00,
.note = "",
.name = "MT6779_M2_AXI_MST_SMI_LARB7"},
{.master = MT6779_M2_AXI_MST_SMI_LARB8, .port = 2, .id_mask = 0x1F80,
.id_val = 0xA80,
.note = "",
.name = "MT6779_M2_AXI_MST_SMI_LARB8"},
{.master = MT6779_M2_AXI_MST_SMI_LARB9, .port = 2, .id_mask = 0x1F80,
.id_val = 0xE00,
.note = "",
.name = "MT6779_M2_AXI_MST_SMI_LARB9"},
{.master = MT6779_M2_AXI_MST_SMI_LARB10, .port = 2, .id_mask = 0x1F80,
.id_val = 0xC80,
.note = "",
.name = "MT6779_M2_AXI_MST_SMI_LARB10"},
{.master = MT6779_M2_AXI_MST_CCU, .port = 2, .id_mask = 0x1F80,
.id_val = 0xC00,
.note = "",
.name = "MT6779_M2_AXI_MST_CCU"},
{.master = MT6779_M5_AXI_MST_MM_IOMMU, .port = 5, .id_mask = 0x1FFF,
.id_val = 0xFFC,
.note = "",
.name = "MT6779_M5_AXI_MST_MM_IOMMU"},
{.master = MT6779_M5_AXI_MST_MM_IOMMU, .port = 5, .id_mask = 0x1FFF,
.id_val = 0xFFD,
.note = "",
.name = "MT6779_M5_AXI_MST_MM_IOMMU"},
{.master = MT6779_M5_AXI_MST_SMI_LARB0, .port = 5, .id_mask = 0x1F80,
.id_val = 0x0,
.note = "",
.name = "MT6779_M5_AXI_MST_SMI_LARB0"},
{.master = MT6779_M5_AXI_MST_SMI_LARB1, .port = 5, .id_mask = 0x1F80,
.id_val = 0x200,
.note = "",
.name = "MT6779_M5_AXI_MST_SMI_LARB1"},
{.master = MT6779_M5_AXI_MST_SMI_LARB2, .port = 5, .id_mask = 0x1F80,
.id_val = 0x400,
.note = "",
.name = "MT6779_M5_AXI_MST_SMI_LARB2"},
{.master = MT6779_M5_AXI_MST_SMI_LARB3, .port = 5, .id_mask = 0x1F80,
.id_val = 0x600,
.note = "",
.name = "MT6779_M5_AXI_MST_SMI_LARB3"},
{.master = MT6779_M5_AXI_MST_SMI_LARB5, .port = 5, .id_mask = 0x1F80,
.id_val = 0x800,
.note = "",
.name = "MT6779_M5_AXI_MST_SMI_LARB5"},
{.master = MT6779_M5_AXI_MST_SMI_LARB7, .port = 5, .id_mask = 0x1F80,
.id_val = 0xA00,
.note = "",
.name = "MT6779_M5_AXI_MST_SMI_LARB7"},
{.master = MT6779_M5_AXI_MST_SMI_LARB8, .port = 5, .id_mask = 0x1F80,
.id_val = 0xA80,
.note = "",
.name = "MT6779_M5_AXI_MST_SMI_LARB8"},
{.master = MT6779_M5_AXI_MST_SMI_LARB9, .port = 5, .id_mask = 0x1F80,
.id_val = 0xE00,
.note = "",
.name = "MT6779_M5_AXI_MST_SMI_LARB9"},
{.master = MT6779_M5_AXI_MST_SMI_LARB10, .port = 5, .id_mask = 0x1F80,
.id_val = 0xC80,
.note = "",
.name = "MT6779_M5_AXI_MST_SMI_LARB10"},
{.master = MT6779_M5_AXI_MST_CCU, .port = 5, .id_mask = 0x1F80,
.id_val = 0xC00,
.note = "",
.name = "MT6779_M5_AXI_MST_CCU"},
{.master = MT6779_M6_AXI_MST_APU_IOMMU, .port = 6, .id_mask = 0x1FFF,
.id_val = 0x7FC,
.note = "",
.name = "MT6779_M6_AXI_MST_APU_IOMMU"},
{.master = MT6779_M6_AXI_MST_APU_IOMMU, .port = 6, .id_mask = 0x1FFF,
.id_val = 0x7FD,
.note = "",
.name = "MT6779_M6_AXI_MST_APU_IOMMU"},
{.master = MT6779_M6_AXI_MST_APU_M0, .port = 6, .id_mask = 0x1C00,
.id_val = 0x400,
.note = "",
.name = "MT6779_M6_AXI_MST_APU_M0"},
{.master = MT6779_M6_AXI_MST_MFG, .port = 6, .id_mask = 0x1FC0,
.id_val = 0x0,
.note = "",
.name = "MT6779_M6_AXI_MST_MFG"},
{.master = MT6779_M7_AXI_MST_SSUSB, .port = 7, .id_mask = 0x1FCF,
.id_val = 0x0,
.note = "",
.name = "MT6779_M7_AXI_MST_SSUSB"},
{.master = MT6779_M7_AXI_MST_PWM, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x8,
.note = "",
.name = "MT6779_M7_AXI_MST_PWM"},
{.master = MT6779_M7_AXI_MST_MSDC1, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x18,
.note = "",
.name = "MT6779_M7_AXI_MST_MSDC1"},
{.master = MT6779_M7_AXI_MST_SPI6, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x28,
.note = "",
.name = "MT6779_M7_AXI_MST_SPI6"},
{.master = MT6779_M7_AXI_MST_SPI0, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x38,
.note = "",
.name = "MT6779_M7_AXI_MST_SPI0"},
{.master = MT6779_M7_AXI_MST_DEBUGTOP, .port = 7, .id_mask = 0x1FBF,
.id_val = 0x4,
.note = "",
.name = "MT6779_M7_AXI_MST_DEBUGTOP"},
{.master = MT6779_M7_AXI_MST_AUDIO, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x20C,
.note = "",
.name = "MT6779_M7_AXI_MST_AUDIO"},
{.master = MT6779_M7_AXI_MST_IPU, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x40C,
.note = "",
.name = "MT6779_M7_AXI_MST_IPU"},
{.master = MT6779_M7_AXI_MST_SPI1, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x60C,
.note = "",
.name = "MT6779_M7_AXI_MST_SPI1"},
{.master = MT6779_M7_AXI_MST_SPI7, .port = 7, .id_mask = 0x1FFF,
.id_val = 0xC,
.note = "",
.name = "MT6779_M7_AXI_MST_SPI7"},
{.master = MT6779_M7_AXI_MST_CCU, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x4C,
.note = "",
.name = "MT6779_M7_AXI_MST_CCU"},
{.master = MT6779_M7_AXI_MST_SPM, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x24C,
.note = "",
.name = "MT6779_M7_AXI_MST_SPM"},
{.master = MT6779_M7_AXI_MST_NA, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x44C,
.note = "",
.name = "MT6779_M7_AXI_MST_NA"},
{.master = MT6779_M7_AXI_MST_THERM, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x64C,
.note = "",
.name = "MT6779_M7_AXI_MST_THERM"},
{.master = MT6779_M7_AXI_MST_UFS, .port = 7, .id_mask = 0x19FF,
.id_val = 0x8C,
.note = "",
.name = "MT6779_M7_AXI_MST_UFS"},
{.master = MT6779_M7_AXI_MST_DMA_EXT, .port = 7, .id_mask = 0x1DFF,
.id_val = 0xCC,
.note = "",
.name = "MT6779_M7_AXI_MST_DMA_EXT"},
{.master = MT6779_M7_AXI_MST_SPI2, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x14C,
.note = "",
.name = "MT6779_M7_AXI_MST_SPI2"},
{.master = MT6779_M7_AXI_MST_SPI3, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x34C,
.note = "",
.name = "MT6779_M7_AXI_MST_SPI3"},
{.master = MT6779_M7_AXI_MST_SPI4, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x54C,
.note = "",
.name = "MT6779_M7_AXI_MST_SPI4"},
{.master = MT6779_M7_AXI_MST_SPI5, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x74C,
.note = "",
.name = "MT6779_M7_AXI_MST_SPI5"},
{.master = MT6779_M7_AXI_MST_MSDC0, .port = 7, .id_mask = 0x11FF,
.id_val = 0x18C,
.note = "",
.name = "MT6779_M7_AXI_MST_MSDC0"},
{.master = MT6779_M7_AXI_MST_DX_CC, .port = 7, .id_mask = 0x1C3F,
.id_val = 0x14,
.note = "",
.name = "MT6779_M7_AXI_MST_DX_CC"},
{.master = MT6779_M7_AXI_MST_CQ_DMA, .port = 7, .id_mask = 0x1E3F,
.id_val = 0x1C,
.note = "",
.name = "MT6779_M7_AXI_MST_CQ_DMA"},
{.master = MT6779_M7_AXI_MST_GCE_M, .port = 7, .id_mask = 0x1F3F,
.id_val = 0x24,
.note = "",
.name = "MT6779_M7_AXI_MST_GCE_M"},
{.master = MT6779_M7_AXI_MST_APU_IOMMU_PORT1, .port = 7,
.id_mask = 0x1FFF,
.id_val = 0x1FF1,
.note = "",
.name = "MT6779_M7_AXI_MST_APU_IOMMU_PORT1"},
{.master = MT6779_M7_AXI_MST_APU_IOMMU_PORT1, .port = 7,
.id_mask = 0x1FFF,
.id_val = 0x1FF5,
.note = "",
.name = "MT6779_M7_AXI_MST_APU_IOMMU_PORT1"},
{.master = MT6779_M7_AXI_MST_APU_M1, .port = 7, .id_mask = 0x1003,
.id_val = 0x1001,
.note = "",
.name = "MT6779_M7_AXI_MST_APU_M1"},
{.master = MT6779_M7_AXI_MST_MFG_M1, .port = 7, .id_mask = 0x1F03,
.id_val = 0x1,
.note = "",
.name = "MT6779_M7_AXI_MST_MFG_M1"},
{.master = MT6779_M7_AXI_MST_DEVICE_MPU, .port = 7, .id_mask = 0x1803,
.id_val = 0x2,
.note = "",
.name = "MT6779_M7_AXI_MST_DEVICE_MPU"},
{.master = MT6779_M3_AXI_MST_MM, .port = 3, .id_mask = 0x1F83,
.id_val = 0x0,
.note = "",
.name = "MT6779_M3_AXI_MST_MM"},
{.master = MT6779_M3_AXI_MST_MMU, .port = 3, .id_mask = 0x1F83,
.id_val = 0x1,
.note = "",
.name = "MT6779_M3_AXI_MST_MMU"},
{.master = MT6779_M3_AXI_MST_USIP_0_I, .port = 3, .id_mask = 0x1F1F,
.id_val = 0x2,
.note = "",
.name = "MT6779_M3_AXI_MST_USIP_0_I"},
{.master = MT6779_M3_AXI_MST_USIP_0_DLONG, .port = 3, .id_mask = 0x1F1F,
.id_val = 0x12,
.note = "",
.name = "MT6779_M3_AXI_MST_USIP_0_DLONG"},
{.master = MT6779_M3_AXI_MST_USIP_0_DPERI, .port = 3, .id_mask = 0x1E0F,
.id_val = 0x6,
.note = "",
.name = "MT6779_M3_AXI_MST_USIP_0_DPERI"},
{.master = MT6779_M3_AXI_MST_USIP_1_I, .port = 3, .id_mask = 0x1F1F,
.id_val = 0xA,
.note = "",
.name = "MT6779_M3_AXI_MST_USIP_1_I"},
{.master = MT6779_M3_AXI_MST_USIP_1_DLONG, .port = 3, .id_mask = 0x1F1F,
.id_val = 0x1A,
.note = "",
.name = "MT6779_M3_AXI_MST_USIP_1_DLONG"},
{.master = MT6779_M3_AXI_MST_USIP_1_DPERI, .port = 3, .id_mask = 0x1E0F,
.id_val = 0xE,
.note = "",
.name = "MT6779_M3_AXI_MST_USIP_1_DPERI"},
{.master = MT6779_M4_AXI_MST_HRQ_RD, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1001,
.note = "",
.name = "MT6779_M4_AXI_MST_HRQ_RD"},
{.master = MT6779_M4_AXI_MST_HRQ_RD1, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1009,
.note = "",
.name = "MT6779_M4_AXI_MST_HRQ_RD1"},
{.master = MT6779_M4_AXI_MST_HRQ_WR, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1003,
.note = "",
.name = "MT6779_M4_AXI_MST_HRQ_WR"},
{.master = MT6779_M4_AXI_MST_HRQ_WR1, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x100B,
.note = "",
.name = "MT6779_M4_AXI_MST_HRQ_WR1"},
{.master = MT6779_M4_AXI_MST_VTB, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1005,
.note = "",
.name = "MT6779_M4_AXI_MST_VTB"},
{.master = MT6779_M4_AXI_MST_TBO, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x100D,
.note = "",
.name = "MT6779_M4_AXI_MST_TBO"},
{.master = MT6779_M4_AXI_MST_BR_DMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x807,
.note = "",
.name = "MT6779_M4_AXI_MST_BR_DMA"},
{.master = MT6779_M4_AXI_MST_IRDMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xF,
.note = "",
.name = "MT6779_M4_AXI_MST_IRDMA"},
{.master = MT6779_M4_AXI_MST_TPC, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x6F,
.note = "",
.name = "MT6779_M4_AXI_MST_TPC"},
{.master = MT6779_M4_AXI_MST_TPC, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xEF,
.note = "",
.name = "MT6779_M4_AXI_MST_TPC"},
{.master = MT6779_M4_AXI_MST_TXBSRP, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x2F,
.note = "",
.name = "MT6779_M4_AXI_MST_TXBSRP"},
{.master = MT6779_M4_AXI_MST_XDMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x3F,
.note = "",
.name = "MT6779_M4_AXI_MST_XDMA"},
{.master = MT6779_M4_AXI_MST_XDMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x13F,
.note = "",
.name = "MT6779_M4_AXI_MST_XDMA"},
{.master = MT6779_M4_AXI_MST_MRSG0, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x7F,
.note = "",
.name = "MT6779_M4_AXI_MST_MRSG0"},
{.master = MT6779_M4_AXI_MST_MRSG1, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xBF,
.note = "",
.name = "MT6779_M4_AXI_MST_MRSG1"},
{.master = MT6779_M4_AXI_MST_CNWDMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x9F,
.note = "",
.name = "MT6779_M4_AXI_MST_CNWDMA"},
{.master = MT6779_M4_AXI_MST_CNWDMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x19F,
.note = "",
.name = "MT6779_M4_AXI_MST_CNWDMA"},
{.master = MT6779_M4_AXI_MST_CSH0, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x5F,
.note = "",
.name = "MT6779_M4_AXI_MST_CSH0"},
{.master = MT6779_M4_AXI_MST_DCXO, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1F,
.note = "",
.name = "MT6779_M4_AXI_MST_DCXO"},
{.master = MT6779_M4_AXI_MST_DMA_RD, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1805,
.note = "",
.name = "MT6779_M4_AXI_MST_DMA_RD"},
{.master = MT6779_M4_AXI_MST_DMA_WR, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1801,
.note = "",
.name = "MT6779_M4_AXI_MST_DMA_WR"},
{.master = MT6779_M4_AXI_MST_DMA_WR, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1809,
.note = "",
.name = "MT6779_M4_AXI_MST_DMA_WR"},
{.master = MT6779_M4_AXI_MST_MMU, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1809,
.note = "",
.name = "MT6779_M4_AXI_MST_MMU"},
{.master = MT6779_M4_AXI_MST_QP, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1801,
.note = "",
.name = "MT6779_M4_AXI_MST_QP"},
{.master = MT6779_M4_AXI_MST_QP_DLCH, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1803,
.note = "",
.name = "MT6779_M4_AXI_MST_QP_DLCH"},
{.master = MT6779_M4_AXI_MST_DMA_RD_DLCH, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1807,
.note = "",
.name = "MT6779_M4_AXI_MST_DMA_RD_DLCH"},
{.master = MT6779_M4_AXI_MST_IPF, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x180D,
.note = "",
.name = "MT6779_M4_AXI_MST_IPF"},
{.master = MT6779_M4_AXI_MST_LOG_TOP_MCU, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x15,
.note = "",
.name = "MT6779_M4_AXI_MST_LOG_TOP_MCU"},
{.master = MT6779_M4_AXI_MST_LOG_TOP_MCU, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x15,
.note = "",
.name = "MT6779_M4_AXI_MST_LOG_TOP_MCU"},
{.master = MT6779_M4_AXI_MST_LOG_TOP_DSP, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x7,
.note = "",
.name = "MT6779_M4_AXI_MST_LOG_TOP_DSP"},
{.master = MT6779_M4_AXI_MST_LOG_TOP_DSP, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x7,
.note = "",
.name = "MT6779_M4_AXI_MST_LOG_TOP_DSP"},
{.master = MT6779_M4_AXI_MST_TRACE_TOP, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x9,
.note = "",
.name = "MT6779_M4_AXI_MST_TRACE_TOP"},
{.master = MT6779_M4_AXI_MST_PPPHA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x3,
.note = "",
.name = "MT6779_M4_AXI_MST_PPPHA"},
{.master = MT6779_M4_AXI_MST_IPSEC, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xB,
.note = "",
.name = "MT6779_M4_AXI_MST_IPSEC"},
{.master = MT6779_M4_AXI_MST_DBGSYS_DSP, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1D,
.note = "",
.name = "MT6779_M4_AXI_MST_DBGSYS_DSP"},
{.master = MT6779_M4_AXI_MST_GDMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xD,
.note = "",
.name = "MT6779_M4_AXI_MST_GDMA"},
{.master = MT6779_M4_AXI_MST_GDMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xED,
.note = "",
.name = "MT6779_M4_AXI_MST_GDMA"},
{.master = MT6779_M4_AXI_MST_HIFI3, .port = 4, .id_mask = 0x1F07,
.id_val = 0x0,
.note = "",
.name = "MT6779_M4_AXI_MST_HIFI3"},
{.master = MT6779_M4_AXI_MST_CLDMA, .port = 4, .id_mask = 0x1F87,
.id_val = 0x2,
.note = "",
.name = "MT6779_M4_AXI_MST_CLDMA"},
{.master = MT6779_M4_AXI_MST_CONNSYS, .port = 4, .id_mask = 0x1FC7,
.id_val = 0x4,
.note = "",
.name = "MT6779_M4_AXI_MST_CONNSYS"},
{.master = MT6779_M4_AXI_MST_SSPM, .port = 4, .id_mask = 0x1FCF,
.id_val = 0xE,
.note = "",
.name = "MT6779_M4_AXI_MST_SSPM"},
{.master = MT6779_M4_AXI_MST_SCP, .port = 4, .id_mask = 0x1FCF,
.id_val = 0x6,
.note = "",
.name = "MT6779_M4_AXI_MST_SCP"},
{.master = MT6779_M4_AXI_MST_DFD, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1000,
.note = "",
.name = "MT6779_M4_AXI_MST_DFD"},
{.master = MT6779_M0_AXI_MST_MP1, .port = 0, .id_mask = 0x1EF8,
.id_val = 0x0,
.note = "",
.name = "MT6779_M0_AXI_MST_MP1"},
{.master = MT6779_M0_AXI_MST_MP1, .port = 0, .id_mask = 0x1EF8,
.id_val = 0x20,
.note = "",
.name = "MT6779_M0_AXI_MST_MP1"},
{.master = MT6779_M0_AXI_MST_MP1, .port = 0, .id_mask = 0x1E80,
.id_val = 0x80,
.note = "",
.name = "MT6779_M0_AXI_MST_MP1"},
{.master = MT6779_M0_AXI_MST_MP1, .port = 0, .id_mask = 0x1DF8,
.id_val = 0x0,
.note = "",
.name = "MT6779_M0_AXI_MST_MP1"},
{.master = MT6779_M0_AXI_MST_MP1, .port = 0, .id_mask = 0x1DF8,
.id_val = 0x20,
.note = "",
.name = "MT6779_M0_AXI_MST_MP1"},
{.master = MT6779_M0_AXI_MST_MP1, .port = 0, .id_mask = 0x1DFF,
.id_val = 0x40,
.note = "",
.name = "MT6779_M0_AXI_MST_MP1"},
{.master = MT6779_M0_AXI_MST_MP1, .port = 0, .id_mask = 0x1DFF,
.id_val = 0x41,
.note = "",
.name = "MT6779_M0_AXI_MST_MP1"},
{.master = MT6779_M0_AXI_MST_MP1, .port = 0, .id_mask = 0x1D80,
.id_val = 0x80,
.note = "",
.name = "MT6779_M0_AXI_MST_MP1"},
{.master = MT6779_M0_AXI_MST_MP1, .port = 0, .id_mask = 0x1D00,
.id_val = 0x100,
.note = "",
.name = "MT6779_M0_AXI_MST_MP1"},
{.master = MT6779_M1_AXI_MST_MP0, .port = 1, .id_mask = 0x1EF8,
.id_val = 0x0,
.note = "",
.name = "MT6779_M1_AXI_MST_MP0"},
{.master = MT6779_M1_AXI_MST_MP0, .port = 1, .id_mask = 0x1EF8,
.id_val = 0x20,
.note = "",
.name = "MT6779_M1_AXI_MST_MP0"},
{.master = MT6779_M1_AXI_MST_MP0, .port = 1, .id_mask = 0x1E80,
.id_val = 0x80,
.note = "",
.name = "MT6779_M1_AXI_MST_MP0"},
{.master = MT6779_M1_AXI_MST_MP0, .port = 1, .id_mask = 0x1DF8,
.id_val = 0x0,
.note = "",
.name = "MT6779_M1_AXI_MST_MP0"},
{.master = MT6779_M1_AXI_MST_MP0, .port = 1, .id_mask = 0x1DF8,
.id_val = 0x20,
.note = "",
.name = "MT6779_M1_AXI_MST_MP0"},
{.master = MT6779_M1_AXI_MST_MP0, .port = 1, .id_mask = 0x1DFF,
.id_val = 0x40,
.note = "",
.name = "MT6779_M1_AXI_MST_MP0"},
{.master = MT6779_M1_AXI_MST_MP0, .port = 1, .id_mask = 0x1DFF,
.id_val = 0x41,
.note = "",
.name = "MT6779_M1_AXI_MST_MP0"},
{.master = MT6779_M1_AXI_MST_MP0, .port = 1, .id_mask = 0x1D80,
.id_val = 0x80,
.note = "",
.name = "MT6779_M1_AXI_MST_MP0"},
{.master = MT6779_M1_AXI_MST_MP0, .port = 1, .id_mask = 0x1D00,
.id_val = 0x100,
.note = "",
.name = "MT6779_M1_AXI_MST_MP0"},
};
#endif /* __MPU_PLATFORM_H__ */
+62
View File
@@ -0,0 +1,62 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __MT_EMI_H__
#define __MT_EMI_H__
/* submodule control */
#define ENABLE_BWL 1
#define ENABLE_MPU 1
#define ENABLE_ELM 1
#define ENABLE_MBW 0
#define DECS_ON_SSPM
/* #define ENABLE_BWL_CONFIG */
/* #define ENABLE_MPU_SLVERR */
#define ENABLE_LATENCY_REGULATOR
#define ENABLE_EMI_DEBUG_API
#define ENABLE_BW_MON_PLAT_INIT
#define DBG_INFO_READY 1
/* IRQ from device tree */
#define MPU_IRQ_INDEX 0
#define ELM_IRQ_INDEX 1
/* macro for MPU */
#define ENABLE_AP_REGION 1
#define AP_REGION_ID 31
#define EMI_MPUD0_ST (CEN_EMI_BASE + 0x160)
#define EMI_MPUD_ST(domain) (EMI_MPUD0_ST + (4*domain))
#define EMI_MPUD0_ST2 (CEN_EMI_BASE + 0x200)
#define EMI_MPUD_ST2(domain) (EMI_MPUD0_ST2 + (4*domain))
#define EMI_MPUS (CEN_EMI_BASE + 0x01F0)
#define EMI_MPUT (CEN_EMI_BASE + 0x01F8)
#define EMI_MPUT_2ND (CEN_EMI_BASE + 0x01FC)
#define EMI_MPU_SA0 (0x100)
#define EMI_MPU_EA0 (0x200)
#define EMI_MPU_SA(region) (EMI_MPU_SA0 + (region*4))
#define EMI_MPU_EA(region) (EMI_MPU_EA0 + (region*4))
#define EMI_MPU_APC0 (0x300)
#define EMI_MPU_APC(region, dgroup) \
(EMI_MPU_APC0 + (region*4) + ((dgroup)*0x100))
#define EMI_MPU_CTRL_D0 (0x800)
#define EMI_MPU_CTRL_D(domain) (EMI_MPU_CTRL_D0 + (domain*4))
/* macro for ELM */
#define MBW_BUF_LEN 0x800000
#define LAST_EMI_DECS_CTRL (LAST_EMI_BASE + 0x04)
#define LAST_EMI_MBW_BUF_L (LAST_EMI_BASE + 0x10)
#define LAST_EMI_MBW_BUF_H (LAST_EMI_BASE + 0x14)
#include <mt_emi_api.h>
#include <bwl_v1.h>
#include <elm_v1.h>
#endif /* __MT_EMI_H__ */
@@ -0,0 +1,39 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __MT_EMI_API_H__
#define __MT_EMI_API_H__
/* macro for MPU */
#define EMI_MPU_DOMAIN_NUM 16
#define EMI_MPU_REGION_NUM 32
#define EMI_MPU_ALIGN_BITS 16
/* general macro */
#define MAX_CH 2
#define MAX_DBG_NR 1
#define MAX_RK 2
#define DRAM_OFFSET 0x40000000
unsigned int get_dram_type(void);
unsigned int get_dram_mr(unsigned int index);
unsigned int get_ch_num(void);
unsigned int get_rk_num(void);
unsigned int get_rank_size(unsigned int rank_index);
unsigned int get_emi_bwst(unsigned int bw_index);
unsigned int get_emi_bwvl(unsigned int bw_index);
void __iomem *mt_cen_emi_base_get(void);
void __iomem *mt_emi_base_get(void);
void __iomem *mt_chn_emi_base_get(unsigned int channel_index);
void __iomem *mt_emi_mpu_base_get(void);
void dump_last_bm(char *buf, unsigned int leng);
void bw_monitor_init(void);
#include <mpu_v1.h>
#include <pasr_api_v1.h>
#endif /* __MT_EMI_API_H__ */
@@ -0,0 +1,23 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/platform_device.h>
#include <linux/of_address.h>
#include <mt-plat/sync_write.h>
#ifdef CONFIG_MTK_AEE_FEATURE
#include <mt-plat/aee.h>
#endif
#include <emi_io.h>
#include "mt_emi.h"
void plat_debug_api_init(void)
{
}
void dump_emi_outstanding(void)
{
}
@@ -0,0 +1,14 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __PLAT_DEBUG_API_H__
#define __PLAT_DEBUG_API_H__
extern void dump_emi_outstanding(void);
extern int lastbus_timeout_dump(void);
extern int is_infra_timeout(void);
#endif /* end of __PLAT_DEBUG_API_H__ */
+37
View File
@@ -0,0 +1,37 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
UBSAN_SANITIZE := n
ccflags-y += -I$(srctree)/drivers/misc/mediatek/emi
ccflags-y += -I$(srctree)/drivers/misc/mediatek/emi/submodule
ccflags-y += -I$(srctree)/drivers/misc/mediatek/dramc
ccflags-y += -I$(srctree)/drivers/misc/mediatek/dramc/$(MTK_PLATFORM)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/debug_latch/plat_dbg_info
ccflags-y += -I$(srctree)/include/memory/mediatek
ifeq ($(CONFIG_MTK_DEVMPU),y)
ccflags-y += -I$(srctree)/drivers/soc/mediatek/devmpu
ccflags-y += -I$(srctree)/drivers/soc/mediatek/devmpu/$(MTK_PLATFORM)
endif
obj-y += bwl_platform.o
obj-y += mpu_platform.o
obj-y += plat_debug_api.o
obj-y += ../emi_ctrl_v1.o
obj-y += ../submodule/bwl_v1.o
obj-y += ../submodule/mpu_v1.o
obj-y += ../submodule/elm_v2.o
#obj-y += ../submodule/pasr_api_v1.o
@@ -0,0 +1,132 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/delay.h>
#include <mt-plat/mtk_io.h>
#include <mt-plat/sync_write.h>
#include "mt_emi.h"
#include "bwl_platform.h"
#define EMI_BWCT0_2ND (CEN_EMI_BASE + 0x6A0)
#define EMI_BWCT0_4TH (CEN_EMI_BASE + 0x780)
#define EMI_BWCT0_5TH (CEN_EMI_BASE + 0x7B0)
#define EMI_BWCT0_7TH (CEN_EMI_BASE + 0x880)
#define EMI_EXT_BW_CON0_1ST (CEN_EMI_BASE + 0xE40)
#define EMI_BWST0 (CEN_EMI_BASE + 0x5C4)
#define EMI_BWST_2ND (CEN_EMI_BASE + 0x6A8)
#define EMI_BWST_3RD (CEN_EMI_BASE + 0x778)
#define EMI_BWST_4TH (CEN_EMI_BASE + 0x788)
#define EMI_BWST_5TH (CEN_EMI_BASE + 0x7B8)
#define EMI_BWVL (CEN_EMI_BASE + 0x7D0)
#define EMI_BWVL_2ND (CEN_EMI_BASE + 0x7D4)
#define EMI_BWVL_3RD (CEN_EMI_BASE + 0x7D8)
#define EMI_BWVL_4TH (CEN_EMI_BASE + 0x7DC)
#define EMI_BWVL_5TH (CEN_EMI_BASE + 0x7E0)
static unsigned int decs_status;
int is_emi_latency_regulator_on(void)
{
return 1;
}
unsigned int decode_bwl_env(
unsigned int dram_type, unsigned int ch_num, unsigned int rk_num)
{
return BWL_ENV_LPDDR4_2CH;
}
unsigned int acquire_bwl_ctrl(void __iomem *LAST_EMI_BASE)
{
unsigned int timeout;
decs_status = readl(IOMEM(LAST_EMI_DECS_CTRL));
writel(0x1, LAST_EMI_DECS_CTRL);
for (timeout = 1; readl(IOMEM(LAST_EMI_DECS_CTRL)) != 2; timeout++) {
mdelay(1);
if ((timeout % 100) == 0) {
writel(decs_status, LAST_EMI_DECS_CTRL);
pr_debug("[BWL] switch scenario timeout\n");
return -1;
}
}
return 0;
}
void release_bwl_ctrl(void __iomem *LAST_EMI_BASE)
{
writel(decs_status, LAST_EMI_DECS_CTRL);
}
void resume_decs(void __iomem *CEN_EMI_BASE)
{
writel(0x00030023, EMI_BWCT0_2ND);
writel(0x00C00023, EMI_BWCT0_4TH);
writel(0x00240023, EMI_BWCT0_5TH);
writel(0x00180023, EMI_BWCT0_7TH);
writel(0x003FC023, EMI_EXT_BW_CON0_1ST);
}
unsigned int get_emi_bwst(unsigned int bw_index)
{
void __iomem *CEN_EMI_BASE;
CEN_EMI_BASE = mt_cen_emi_base_get();
switch (bw_index) {
case 0:
return readl(IOMEM(EMI_BWST0));
case 1:
return readl(IOMEM(EMI_BWST_2ND));
case 2:
return readl(IOMEM(EMI_BWST_3RD));
case 3:
return readl(IOMEM(EMI_BWST_4TH));
case 4:
return readl(IOMEM(EMI_BWST_5TH));
default:
return 0;
}
}
unsigned int get_emi_bwvl(unsigned int bw_index)
{
void __iomem *CEN_EMI_BASE;
CEN_EMI_BASE = mt_cen_emi_base_get();
switch (bw_index) {
case 0:
return readl(IOMEM(EMI_BWVL));
case 1:
return readl(IOMEM(EMI_BWVL_2ND));
case 2:
return readl(IOMEM(EMI_BWVL_3RD));
case 3:
return readl(IOMEM(EMI_BWVL_4TH));
case 4:
return readl(IOMEM(EMI_BWVL_5TH));
default:
return 0;
}
}
void bw_monitor_init(void)
{
void __iomem *CEN_EMI_BASE;
CEN_EMI_BASE = mt_cen_emi_base_get();
/* init BW monitor for sspm use */
writel(0x00030023, EMI_BWCT0_2ND);
writel(0x00C00023, EMI_BWCT0_4TH);
writel(0x00240023, EMI_BWCT0_5TH);
writel(0x00180023, EMI_BWCT0_7TH);
writel(0x003FC023, EMI_EXT_BW_CON0_1ST);
}
@@ -0,0 +1,40 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __BWL_PLATFORM_H__
#define __BWL_PLATFORM_H__
enum BWL_ENV {
BWL_ENV_LPDDR4_2CH,
BWL_ENV_MAX
};
enum BWL_SCN {
BWL_SCN_ICFP,
BWL_SCN_UI,
BWL_SCN_MAX,
};
enum BWL_CEN_REG {
BWL_CEN_0x00000100,
BWL_CEN_0x00000108,
BWL_CEN_0x00000110,
BWL_CEN_0x00000118,
BWL_CEN_0x00000120,
BWL_CEN_0x00000124,
BWL_CEN_0x00000128,
BWL_CEN_0x00000130,
BWL_CEN_0x00000138,
BWL_CEN_MAX,
};
enum BWL_CHN_REG {
BWL_CHN_0x0000015c,
BWL_CHN_MAX,
};
#define SCN_DEFAULT BWL_SCN_UI
#endif /* __BWL_PLATFORM_H__ */
@@ -0,0 +1,25 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000100, 0x20107244)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000108, 0x10107044)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000110, 0x343450df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000118, 0x0000f0d0)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000120, 0x10106048)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000124, 0x00000034)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000128, 0x343450df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000130, 0x83837044)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000138, 0x83837044)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x0000015c, 0x884102a2)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000100, 0x20107250)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000108, 0x10107050)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000110, 0x343450df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000118, 0x0000f0d0)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000120, 0x10106050)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000124, 0x00000034)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000128, 0x343450df)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000130, 0x83837048)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000138, 0x83837048)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x0000015c, 0x824102a2)
@@ -0,0 +1,137 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/platform_device.h>
#include <linux/arm-smccc.h>
#include <mt-plat/sync_write.h>
#include <mt-plat/mtk_io.h>
#include <mt-plat/mtk_secure_api.h>
#include <devmpu.h>
#include "mt_emi.h"
static void __iomem *CEN_EMI_BASE;
enum {
MASTER_APM0 = 0,
MASTER_APM1 = 1,
MASTER_MM0 = 2,
MASTER_MDMCU = 3,
MASTER_MD = 4,
MASTER_MM1 = 5,
MASTER_GPU0_PERI = 6,
MASTER_GPU1_LPDMA = 7,
MASTER_ALL = 8
};
#define MDMCU_DOMAIN 1
#define MDHW_DOMAIN 7
int is_md_master(unsigned int master_id,
unsigned int domain_id)
{
if ((domain_id != MDMCU_DOMAIN) &&
(domain_id != MDHW_DOMAIN))
return 0;
if ((master_id & 0x7) == MASTER_MDMCU)
return 1;
if ((master_id & 0x7) == MASTER_MD)
return 1;
return 0;
}
void set_ap_region_permission(unsigned int apc[EMI_MPU_DGROUP_NUM])
{
SET_ACCESS_PERMISSION(apc, LOCK,
FORBIDDEN, FORBIDDEN, SEC_RW, NO_PROTECTION,
NO_PROTECTION, FORBIDDEN, NO_PROTECTION, NO_PROTECTION,
FORBIDDEN, SEC_R_NSEC_RW, NO_PROTECTION, NO_PROTECTION,
FORBIDDEN, FORBIDDEN, FORBIDDEN, NO_PROTECTION);
}
void bypass_init(unsigned int *init_flag)
{
CEN_EMI_BASE = mt_cen_emi_base_get();
*init_flag = 1;
}
static void clear_devmpu_violation(void)
{
unsigned int mpus, mput, mput_2nd;
unsigned int i;
struct arm_smccc_res smc_res;
/* clear violation status */
for (i = 0; i < EMI_MPU_DOMAIN_NUM; i++) {
/* clear region abort violation */
mt_reg_sync_writel(0xFFFFFFFF, EMI_MPUD_ST(i));
/* clear out-of-range violation */
mt_reg_sync_writel(0x3, EMI_MPUD_ST2(i));
}
/* clear debug info */
mt_reg_sync_writel(0x80000000, EMI_MPUS);
mpus = readl(IOMEM(EMI_MPUS));
mput = readl(IOMEM(EMI_MPUT));
if (mpus) {
pr_info("[DEVMPU] fail to clear violation\n");
pr_info("[DEVMPU] EMI_MPUS: %x, EMI_MPUT: %x\n", mpus, mput);
}
/* clear hyp violation status */
arm_smccc_smc(MTK_SIP_KERNEL_DEVMPU_VIO_CLR,
0, 0, 0, 0, 0, 0, 0, &smc_res);
mput_2nd = readl(IOMEM(EMI_MPUT_2ND));
if ((smc_res.a0) || ((mput_2nd >> 21) & 0x3)) {
pr_info("[MPU] fail to clear hypervisor violation\n");
pr_info("[MPU] EMI_MPT_2ND: %x\n", mput_2nd);
}
}
int bypass_violation(unsigned int mpus, unsigned int *init_flag)
{
unsigned int mput, mput_2nd;
unsigned long long vio_addr;
unsigned int master_id, domain_id;
unsigned int port_id;
unsigned int wr_vio, wr_oo_vio;
unsigned int hp_wr_vio;
mput = readl(IOMEM(EMI_MPUT));
mput_2nd = readl(IOMEM(EMI_MPUT_2ND));
vio_addr = ((((unsigned long long)(mput_2nd & 0xF)) << 32) + mput +
DRAM_OFFSET);
hp_wr_vio = (mput_2nd >> 21) & 0x3;
master_id = mpus & 0xFFFF;
domain_id = (mpus >> 21) & 0xF;
wr_vio = (mpus >> 29) & 0x3;
wr_oo_vio = (mpus >> 27) & 0x3;
port_id = master_id & 0x7;
/* if is hyperviosr MPU violation, deliver to DevMPU */
if (hp_wr_vio) {
devmpu_print_violation(vio_addr, master_id, domain_id,
hp_wr_vio, true);
clear_devmpu_violation();
return 1;
}
#if defined(CONFIG_MTK_ENABLE_GENIEZONE) \
|| defined(CONFIG_MTK_SEC_VIDEO_PATH_SUPPORT)
if ((wr_vio == 2) && (wr_oo_vio == 0) &&
((port_id == 0) || (port_id == 1)))
return 1;
#endif
return 0;
}
@@ -0,0 +1,591 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MPU_PLATFORM_H__
#define __MPU_PLATFORM_H__
enum {
MT6785_M4_AXI_MST_QP_DLCH,
MT6785_M4_AXI_MST_BR_DMA,
MT6785_M2_AXI_MST_CCU,
MT6785_M2_AXI_MST_SMI_LARB0,
MT6785_M4_AXI_MST_DCXO,
MT6785_M4_AXI_MST_MRSG0,
MT6785_M7_AXI_MST_IPU,
MT6785_M7_AXI_MST_CCU,
MT6785_M4_AXI_MST_IRDMA,
MT6785_M7_AXI_MST_MSDC0,
MT6785_M2_AXI_MST_SMI_LARB2,
MT6785_M4_AXI_MST_TRACE_TOP,
MT6785_M4_AXI_MST_CSH0,
MT6785_M4_AXI_MST_DMA_WR,
MT6785_M7_AXI_MST_APU,
MT6785_M7_AXI_MST_SPI1,
MT6785_M4_AXI_MST_SSPM,
MT6785_M2_AXI_MST_SMI_LARB6,
MT6785_M7_AXI_MST_SPI3,
MT6785_M3_AXI_MST_MMU,
MT6785_M7_AXI_MST_SPI5,
MT6785_M4_AXI_MST_IPSEC,
MT6785_M4_AXI_MST_CNWDMA,
MT6785_M7_AXI_MST_SPI7,
MT6785_M5_AXI_MST_SMI_LARB1,
MT6785_M7_AXI_MST_UFS,
MT6785_M7_AXI_MST_DX_CC,
MT6785_M4_AXI_MST_MMU,
MT6785_M7_AXI_MST_APU_IOMMU_P1,
MT6785_M1_AXI_MST_MP1,
MT6785_M3_AXI_MST_USIP_0_DPERI,
MT6785_M5_AXI_MST_SMI_LARB3,
MT6785_M4_AXI_MST_HRQ_RD,
MT6785_M4_AXI_MST_LOG_TOP_MCU,
MT6785_M3_AXI_MST_USIP_1_I,
MT6785_M5_AXI_MST_SMI_LARB5,
MT6785_M5_AXI_MST_MM_IOMMU,
MT6785_M4_AXI_MST_DBGSYS_DSP,
MT6785_M3_AXI_MST_USIP_1_DPERI,
MT6785_M4_AXI_MST_GDMA,
MT6785_M4_AXI_MST_LOG_TOP_DSP,
MT6785_M7_AXI_MST_DEVICE_MPU,
MT6785_M7_AXI_MST_DMA_EXT,
MT6785_M4_AXI_MST_HRQ_RD1,
MT6785_M3_AXI_MST_USIP_0_I,
MT6785_M4_AXI_MST_DMA_RD_DLCH,
MT6785_M4_AXI_MST_TXBSRP,
MT6785_M6_AXI_MST_APU_IOMMU,
MT6785_M7_AXI_MST_CQ_DMA,
MT6785_M2_AXI_MST_SMI_LARB1,
MT6785_M7_AXI_MST_PWM,
MT6785_M4_AXI_MST_,
MT6785_M4_AXI_MST_MRSG1,
MT6785_M2_AXI_MST_SMI_LARB3,
MT6785_M7_AXI_MST_MSDC1,
MT6785_M7_AXI_MST_SPI0,
MT6785_M7_AXI_MST_NA,
MT6785_M4_AXI_MST_IPF,
MT6785_M4_AXI_MST_DMA_RD,
MT6785_M4_AXI_MST_XDMA,
MT6785_M7_AXI_MST_AUDIO,
MT6785_M2_AXI_MST_SMI_LARB5,
MT6785_M4_AXI_MST_TPC,
MT6785_M7_AXI_MST_THERM,
MT6785_M7_AXI_MST_SPI2,
MT6785_M5_AXI_MST_CCU,
MT6785_M4_AXI_MST_VTB,
MT6785_M7_AXI_MST_SPM,
MT6785_M0_AXI_MST_MP0,
MT6785_M3_AXI_MST_MM,
MT6785_M7_AXI_MST_MFG_M1,
MT6785_M7_AXI_MST_SPI4,
MT6785_M4_AXI_MST_CLDMA,
MT6785_M4_AXI_MST_PPPHA,
MT6785_M3_AXI_MST_USIP_1_DLONG,
MT6785_M7_AXI_MST_SSUSB,
MT6785_M4_AXI_MST_SCP,
MT6785_M4_AXI_MST_HIFI3,
MT6785_M4_AXI_MST_QP,
MT6785_M3_AXI_MST_USIP_0_DLONG,
MT6785_M7_AXI_MST_GCE_M,
MT6785_M7_AXI_MST_SPI6,
MT6785_M5_AXI_MST_SMI_LARB0,
MT6785_M6_AXI_MST_MFG,
MT6785_M7_AXI_MST_DEBUGTOP,
MT6785_M5_AXI_MST_SMI_LARB2,
MT6785_M4_AXI_MST_MCUSYS_DFD,
MT6785_M4_AXI_MST_HRQ_WR,
MT6785_M6_AXI_MST_APU,
MT6785_M4_AXI_MST_TBO,
MT6785_M2_AXI_MST_MM_IOMMU,
MT6785_M5_AXI_MST_SMI_LARB6,
MT6785_M4_AXI_MST_HRQ_WR1,
MT6785_M4_AXI_MST_CONNSYS,
MST_INVALID,
NR_MST
};
static const struct mst_tbl_entry mst_tbl[] = {
{.master = MT6785_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1EF8,
.id_val = 0x0,
.note = "",
.name = "MT6785_M0_AXI_MST_MP0"},
{.master = MT6785_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1EF8,
.id_val = 0x20,
.note = "",
.name = "MT6785_M0_AXI_MST_MP0"},
{.master = MT6785_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1E80,
.id_val = 0x80,
.note = "",
.name = "MT6785_M0_AXI_MST_MP0"},
{.master = MT6785_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1DF8,
.id_val = 0x0,
.note = "",
.name = "MT6785_M0_AXI_MST_MP0"},
{.master = MT6785_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1DF8,
.id_val = 0x20,
.note = "",
.name = "MT6785_M0_AXI_MST_MP0"},
{.master = MT6785_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1DFF,
.id_val = 0x40,
.note = "",
.name = "MT6785_M0_AXI_MST_MP0"},
{.master = MT6785_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1DFF,
.id_val = 0x41,
.note = "",
.name = "MT6785_M0_AXI_MST_MP0"},
{.master = MT6785_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1D80,
.id_val = 0x80,
.note = "",
.name = "MT6785_M0_AXI_MST_MP0"},
{.master = MT6785_M0_AXI_MST_MP0, .port = 0, .id_mask = 0x1D00,
.id_val = 0x100,
.note = "",
.name = "MT6785_M0_AXI_MST_MP0"},
{.master = MT6785_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1EF8,
.id_val = 0x0,
.note = "",
.name = "MT6785_M1_AXI_MST_MP1"},
{.master = MT6785_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1EF8,
.id_val = 0x20,
.note = "",
.name = "MT6785_M1_AXI_MST_MP1"},
{.master = MT6785_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1E80,
.id_val = 0x80,
.note = "",
.name = "MT6785_M1_AXI_MST_MP1"},
{.master = MT6785_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1DF8,
.id_val = 0x0,
.note = "",
.name = "MT6785_M1_AXI_MST_MP1"},
{.master = MT6785_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1DF8,
.id_val = 0x20,
.note = "",
.name = "MT6785_M1_AXI_MST_MP1"},
{.master = MT6785_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1DFF,
.id_val = 0x40,
.note = "",
.name = "MT6785_M1_AXI_MST_MP1"},
{.master = MT6785_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1DFF,
.id_val = 0x41,
.note = "",
.name = "MT6785_M1_AXI_MST_MP1"},
{.master = MT6785_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1D80,
.id_val = 0x80,
.note = "",
.name = "MT6785_M1_AXI_MST_MP1"},
{.master = MT6785_M1_AXI_MST_MP1, .port = 1, .id_mask = 0x1D00,
.id_val = 0x100,
.note = "",
.name = "MT6785_M1_AXI_MST_MP1"},
{.master = MT6785_M2_AXI_MST_MM_IOMMU, .port = 2, .id_mask = 0x1FFF,
.id_val = 0xFFC,
.note = "",
.name = "MT6785_M2_AXI_MST_MM_IOMMU"},
{.master = MT6785_M2_AXI_MST_MM_IOMMU, .port = 2, .id_mask = 0x1FFF,
.id_val = 0xFFD,
.note = "",
.name = "MT6785_M2_AXI_MST_MM_IOMMU"},
{.master = MT6785_M2_AXI_MST_SMI_LARB0, .port = 2, .id_mask = 0x1F80,
.id_val = 0x0,
.note = "",
.name = "MT6785_M2_AXI_MST_SMI_LARB0"},
{.master = MT6785_M2_AXI_MST_SMI_LARB1, .port = 2, .id_mask = 0x1F80,
.id_val = 0x200,
.note = "",
.name = "MT6785_M2_AXI_MST_SMI_LARB1"},
{.master = MT6785_M2_AXI_MST_SMI_LARB2, .port = 2, .id_mask = 0x1F80,
.id_val = 0x400,
.note = "",
.name = "MT6785_M2_AXI_MST_SMI_LARB2"},
{.master = MT6785_M2_AXI_MST_SMI_LARB3, .port = 2, .id_mask = 0x1F80,
.id_val = 0x600,
.note = "",
.name = "MT6785_M2_AXI_MST_SMI_LARB3"},
{.master = MT6785_M2_AXI_MST_SMI_LARB5, .port = 2, .id_mask = 0x1F80,
.id_val = 0x800,
.note = "",
.name = "MT6785_M2_AXI_MST_SMI_LARB5"},
{.master = MT6785_M2_AXI_MST_SMI_LARB6, .port = 2, .id_mask = 0x1F80,
.id_val = 0xE00,
.note = "",
.name = "MT6785_M2_AXI_MST_SMI_LARB6"},
{.master = MT6785_M2_AXI_MST_CCU, .port = 2, .id_mask = 0x1F80,
.id_val = 0xC00,
.note = "",
.name = "MT6785_M2_AXI_MST_CCU"},
{.master = MT6785_M5_AXI_MST_MM_IOMMU, .port = 5, .id_mask = 0x1FFF,
.id_val = 0xFFC,
.note = "",
.name = "MT6785_M5_AXI_MST_MM_IOMMU"},
{.master = MT6785_M5_AXI_MST_MM_IOMMU, .port = 5, .id_mask = 0x1FFF,
.id_val = 0xFFD,
.note = "",
.name = "MT6785_M5_AXI_MST_MM_IOMMU"},
{.master = MT6785_M5_AXI_MST_SMI_LARB0, .port = 5, .id_mask = 0x1F80,
.id_val = 0x0,
.note = "",
.name = "MT6785_M5_AXI_MST_SMI_LARB0"},
{.master = MT6785_M5_AXI_MST_SMI_LARB1, .port = 5, .id_mask = 0x1F80,
.id_val = 0x200,
.note = "",
.name = "MT6785_M5_AXI_MST_SMI_LARB1"},
{.master = MT6785_M5_AXI_MST_SMI_LARB2, .port = 5, .id_mask = 0x1F80,
.id_val = 0x400,
.note = "",
.name = "MT6785_M5_AXI_MST_SMI_LARB2"},
{.master = MT6785_M5_AXI_MST_SMI_LARB3, .port = 5, .id_mask = 0x1F80,
.id_val = 0x600,
.note = "",
.name = "MT6785_M5_AXI_MST_SMI_LARB3"},
{.master = MT6785_M5_AXI_MST_SMI_LARB5, .port = 5, .id_mask = 0x1F80,
.id_val = 0x800,
.note = "",
.name = "MT6785_M5_AXI_MST_SMI_LARB5"},
{.master = MT6785_M5_AXI_MST_SMI_LARB6, .port = 5, .id_mask = 0x1F80,
.id_val = 0xE00,
.note = "",
.name = "MT6785_M5_AXI_MST_SMI_LARB6"},
{.master = MT6785_M5_AXI_MST_CCU, .port = 5, .id_mask = 0x1F80,
.id_val = 0xC00,
.note = "",
.name = "MT6785_M5_AXI_MST_CCU"},
{.master = MT6785_M6_AXI_MST_APU_IOMMU, .port = 6, .id_mask = 0x1FFF,
.id_val = 0x7FC,
.note = "",
.name = "MT6785_M6_AXI_MST_APU_IOMMU"},
{.master = MT6785_M6_AXI_MST_APU_IOMMU, .port = 6, .id_mask = 0x1FFF,
.id_val = 0x7FD,
.note = "",
.name = "MT6785_M6_AXI_MST_APU_IOMMU"},
{.master = MT6785_M6_AXI_MST_APU, .port = 6, .id_mask = 0x1C00,
.id_val = 0x400,
.note = "",
.name = "MT6785_M6_AXI_MST_APU"},
{.master = MT6785_M6_AXI_MST_MFG, .port = 6, .id_mask = 0x1FC0,
.id_val = 0x0,
.note = "",
.name = "MT6785_M6_AXI_MST_MFG"},
{.master = MT6785_M7_AXI_MST_SSUSB, .port = 7, .id_mask = 0x1FCF,
.id_val = 0x0,
.note = "",
.name = "MT6785_M7_AXI_MST_SSUSB"},
{.master = MT6785_M7_AXI_MST_PWM, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x8,
.note = "",
.name = "MT6785_M7_AXI_MST_PWM"},
{.master = MT6785_M7_AXI_MST_MSDC1, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x18,
.note = "",
.name = "MT6785_M7_AXI_MST_MSDC1"},
{.master = MT6785_M7_AXI_MST_SPI6, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x28,
.note = "",
.name = "MT6785_M7_AXI_MST_SPI6"},
{.master = MT6785_M7_AXI_MST_SPI0, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x38,
.note = "",
.name = "MT6785_M7_AXI_MST_SPI0"},
{.master = MT6785_M7_AXI_MST_DEBUGTOP, .port = 7, .id_mask = 0x1FBF,
.id_val = 0x4,
.note = "",
.name = "MT6785_M7_AXI_MST_DEBUGTOP"},
{.master = MT6785_M7_AXI_MST_AUDIO, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x20C,
.note = "",
.name = "MT6785_M7_AXI_MST_AUDIO"},
{.master = MT6785_M7_AXI_MST_IPU, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x40C,
.note = "",
.name = "MT6785_M7_AXI_MST_IPU"},
{.master = MT6785_M7_AXI_MST_SPI1, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x60C,
.note = "",
.name = "MT6785_M7_AXI_MST_SPI1"},
{.master = MT6785_M7_AXI_MST_SPI7, .port = 7, .id_mask = 0x1FFF,
.id_val = 0xC,
.note = "",
.name = "MT6785_M7_AXI_MST_SPI7"},
{.master = MT6785_M7_AXI_MST_CCU, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x4C,
.note = "",
.name = "MT6785_M7_AXI_MST_CCU"},
{.master = MT6785_M7_AXI_MST_SPM, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x24C,
.note = "",
.name = "MT6785_M7_AXI_MST_SPM"},
{.master = MT6785_M7_AXI_MST_NA, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x44C,
.note = "",
.name = "MT6785_M7_AXI_MST_NA"},
{.master = MT6785_M7_AXI_MST_THERM, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x64C,
.note = "",
.name = "MT6785_M7_AXI_MST_THERM"},
{.master = MT6785_M7_AXI_MST_UFS, .port = 7, .id_mask = 0x19FF,
.id_val = 0x8C,
.note = "",
.name = "MT6785_M7_AXI_MST_UFS"},
{.master = MT6785_M7_AXI_MST_DMA_EXT, .port = 7, .id_mask = 0x1DFF,
.id_val = 0xCC,
.note = "",
.name = "MT6785_M7_AXI_MST_DMA_EXT"},
{.master = MT6785_M7_AXI_MST_SPI2, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x14C,
.note = "",
.name = "MT6785_M7_AXI_MST_SPI2"},
{.master = MT6785_M7_AXI_MST_SPI3, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x34C,
.note = "",
.name = "MT6785_M7_AXI_MST_SPI3"},
{.master = MT6785_M7_AXI_MST_SPI4, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x54C,
.note = "",
.name = "MT6785_M7_AXI_MST_SPI4"},
{.master = MT6785_M7_AXI_MST_SPI5, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x74C,
.note = "",
.name = "MT6785_M7_AXI_MST_SPI5"},
{.master = MT6785_M7_AXI_MST_MSDC0, .port = 7, .id_mask = 0x11FF,
.id_val = 0x18C,
.note = "",
.name = "MT6785_M7_AXI_MST_MSDC0"},
{.master = MT6785_M7_AXI_MST_DX_CC, .port = 7, .id_mask = 0x1C3F,
.id_val = 0x14,
.note = "",
.name = "MT6785_M7_AXI_MST_DX_CC"},
{.master = MT6785_M7_AXI_MST_CQ_DMA, .port = 7, .id_mask = 0x1E3F,
.id_val = 0x1C,
.note = "",
.name = "MT6785_M7_AXI_MST_CQ_DMA"},
{.master = MT6785_M7_AXI_MST_GCE_M, .port = 7, .id_mask = 0x1F3F,
.id_val = 0x24,
.note = "",
.name = "MT6785_M7_AXI_MST_GCE_M"},
{.master = MT6785_M7_AXI_MST_APU_IOMMU_P1, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x1FF1,
.note = "",
.name = "MT6785_M7_AXI_MST_APU_IOMMU_P1"},
{.master = MT6785_M7_AXI_MST_APU_IOMMU_P1, .port = 7, .id_mask = 0x1FFF,
.id_val = 0x1FF5,
.note = "",
.name = "MT6785_M7_AXI_MST_APU_IOMMU_P1"},
{.master = MT6785_M7_AXI_MST_APU, .port = 7, .id_mask = 0x1003,
.id_val = 0x1001,
.note = "",
.name = "MT6785_M7_AXI_MST_APU"},
{.master = MT6785_M7_AXI_MST_MFG_M1, .port = 7, .id_mask = 0x1F03,
.id_val = 0x1,
.note = "",
.name = "MT6785_M7_AXI_MST_MFG_M1"},
{.master = MT6785_M7_AXI_MST_DEVICE_MPU, .port = 7, .id_mask = 0x1803,
.id_val = 0x2,
.note = "",
.name = "MT6785_M7_AXI_MST_DEVICE_MPU"},
{.master = MT6785_M3_AXI_MST_MM, .port = 3, .id_mask = 0x1F83,
.id_val = 0x0,
.note = "",
.name = "MT6785_M3_AXI_MST_MM"},
{.master = MT6785_M3_AXI_MST_MMU, .port = 3, .id_mask = 0x1F83,
.id_val = 0x1,
.note = "",
.name = "MT6785_M3_AXI_MST_MMU"},
{.master = MT6785_M3_AXI_MST_USIP_0_I, .port = 3, .id_mask = 0x1F1F,
.id_val = 0x2,
.note = "",
.name = "MT6785_M3_AXI_MST_USIP_0_I"},
{.master = MT6785_M3_AXI_MST_USIP_0_DLONG, .port = 3, .id_mask = 0x1F1F,
.id_val = 0x12,
.note = "",
.name = "MT6785_M3_AXI_MST_USIP_0_DLONG"},
{.master = MT6785_M3_AXI_MST_USIP_0_DPERI, .port = 3, .id_mask = 0x1E0F,
.id_val = 0x6,
.note = "",
.name = "MT6785_M3_AXI_MST_USIP_0_DPERI"},
{.master = MT6785_M3_AXI_MST_USIP_1_I, .port = 3, .id_mask = 0x1F1F,
.id_val = 0xA,
.note = "",
.name = "MT6785_M3_AXI_MST_USIP_1_I"},
{.master = MT6785_M3_AXI_MST_USIP_1_DLONG, .port = 3, .id_mask = 0x1F1F,
.id_val = 0x1A,
.note = "",
.name = "MT6785_M3_AXI_MST_USIP_1_DLONG"},
{.master = MT6785_M3_AXI_MST_USIP_1_DPERI, .port = 3, .id_mask = 0x1E0F,
.id_val = 0xE,
.note = "",
.name = "MT6785_M3_AXI_MST_USIP_1_DPERI"},
{.master = MT6785_M4_AXI_MST_HRQ_RD, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1001,
.note = "",
.name = "MT6785_M4_AXI_MST_HRQ_RD"},
{.master = MT6785_M4_AXI_MST_HRQ_RD1, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1009,
.note = "",
.name = "MT6785_M4_AXI_MST_HRQ_RD1"},
{.master = MT6785_M4_AXI_MST_HRQ_WR, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1003,
.note = "",
.name = "MT6785_M4_AXI_MST_HRQ_WR"},
{.master = MT6785_M4_AXI_MST_HRQ_WR1, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x100B,
.note = "",
.name = "MT6785_M4_AXI_MST_HRQ_WR1"},
{.master = MT6785_M4_AXI_MST_VTB, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1005,
.note = "",
.name = "MT6785_M4_AXI_MST_VTB"},
{.master = MT6785_M4_AXI_MST_TBO, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x100D,
.note = "",
.name = "MT6785_M4_AXI_MST_TBO"},
{.master = MT6785_M4_AXI_MST_BR_DMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x807,
.note = "",
.name = "MT6785_M4_AXI_MST_BR_DMA"},
{.master = MT6785_M4_AXI_MST_IRDMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xF,
.note = "",
.name = "MT6785_M4_AXI_MST_IRDMA"},
{.master = MT6785_M4_AXI_MST_TPC, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x6F,
.note = "",
.name = "MT6785_M4_AXI_MST_TPC"},
{.master = MT6785_M4_AXI_MST_, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xEF,
.note = "",
.name = "MT6785_M4_AXI_MST_"},
{.master = MT6785_M4_AXI_MST_TXBSRP, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x2F,
.note = "",
.name = "MT6785_M4_AXI_MST_TXBSRP"},
{.master = MT6785_M4_AXI_MST_XDMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x3F,
.note = "",
.name = "MT6785_M4_AXI_MST_XDMA"},
{.master = MT6785_M4_AXI_MST_, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x13F,
.note = "",
.name = "MT6785_M4_AXI_MST_"},
{.master = MT6785_M4_AXI_MST_MRSG0, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x7F,
.note = "",
.name = "MT6785_M4_AXI_MST_MRSG0"},
{.master = MT6785_M4_AXI_MST_MRSG1, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xBF,
.note = "",
.name = "MT6785_M4_AXI_MST_MRSG1"},
{.master = MT6785_M4_AXI_MST_CNWDMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x9F,
.note = "",
.name = "MT6785_M4_AXI_MST_CNWDMA"},
{.master = MT6785_M4_AXI_MST_, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x19F,
.note = "",
.name = "MT6785_M4_AXI_MST_"},
{.master = MT6785_M4_AXI_MST_CSH0, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x5F,
.note = "",
.name = "MT6785_M4_AXI_MST_CSH0"},
{.master = MT6785_M4_AXI_MST_DCXO, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1F,
.note = "",
.name = "MT6785_M4_AXI_MST_DCXO"},
{.master = MT6785_M4_AXI_MST_DMA_RD, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1805,
.note = "",
.name = "MT6785_M4_AXI_MST_DMA_RD"},
{.master = MT6785_M4_AXI_MST_DMA_WR, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1801,
.note = "",
.name = "MT6785_M4_AXI_MST_DMA_WR"},
{.master = MT6785_M4_AXI_MST_, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1809,
.note = "",
.name = "MT6785_M4_AXI_MST_"},
{.master = MT6785_M4_AXI_MST_MMU, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1809,
.note = "",
.name = "MT6785_M4_AXI_MST_MMU"},
{.master = MT6785_M4_AXI_MST_QP, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1801,
.note = "",
.name = "MT6785_M4_AXI_MST_QP"},
{.master = MT6785_M4_AXI_MST_QP_DLCH, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1803,
.note = "",
.name = "MT6785_M4_AXI_MST_QP_DLCH"},
{.master = MT6785_M4_AXI_MST_DMA_RD_DLCH, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1807,
.note = "",
.name = "MT6785_M4_AXI_MST_DMA_RD_DLCH"},
{.master = MT6785_M4_AXI_MST_IPF, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x180D,
.note = "",
.name = "MT6785_M4_AXI_MST_IPF"},
{.master = MT6785_M4_AXI_MST_LOG_TOP_MCU, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x15,
.note = "",
.name = "MT6785_M4_AXI_MST_LOG_TOP_MCU"},
{.master = MT6785_M4_AXI_MST_, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x15,
.note = "",
.name = "MT6785_M4_AXI_MST_"},
{.master = MT6785_M4_AXI_MST_LOG_TOP_DSP, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x7,
.note = "",
.name = "MT6785_M4_AXI_MST_LOG_TOP_DSP"},
{.master = MT6785_M4_AXI_MST_, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x7,
.note = "",
.name = "MT6785_M4_AXI_MST_"},
{.master = MT6785_M4_AXI_MST_TRACE_TOP, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x9,
.note = "",
.name = "MT6785_M4_AXI_MST_TRACE_TOP"},
{.master = MT6785_M4_AXI_MST_PPPHA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x3,
.note = "",
.name = "MT6785_M4_AXI_MST_PPPHA"},
{.master = MT6785_M4_AXI_MST_IPSEC, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xB,
.note = "",
.name = "MT6785_M4_AXI_MST_IPSEC"},
{.master = MT6785_M4_AXI_MST_DBGSYS_DSP, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1D,
.note = "",
.name = "MT6785_M4_AXI_MST_DBGSYS_DSP"},
{.master = MT6785_M4_AXI_MST_GDMA, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xD,
.note = "",
.name = "MT6785_M4_AXI_MST_GDMA"},
{.master = MT6785_M4_AXI_MST_, .port = 4, .id_mask = 0x1FFF,
.id_val = 0xED,
.note = "",
.name = "MT6785_M4_AXI_MST_"},
{.master = MT6785_M4_AXI_MST_HIFI3, .port = 4, .id_mask = 0x1F07,
.id_val = 0x0,
.note = "",
.name = "MT6785_M4_AXI_MST_HIFI3"},
{.master = MT6785_M4_AXI_MST_CLDMA, .port = 4, .id_mask = 0x1F87,
.id_val = 0x2,
.note = "",
.name = "MT6785_M4_AXI_MST_CLDMA"},
{.master = MT6785_M4_AXI_MST_CONNSYS, .port = 4, .id_mask = 0x1FC7,
.id_val = 0x4,
.note = "",
.name = "MT6785_M4_AXI_MST_CONNSYS"},
{.master = MT6785_M4_AXI_MST_SSPM, .port = 4, .id_mask = 0x1FCF,
.id_val = 0xE,
.note = "",
.name = "MT6785_M4_AXI_MST_SSPM"},
{.master = MT6785_M4_AXI_MST_SCP, .port = 4, .id_mask = 0x1FCF,
.id_val = 0x6,
.note = "",
.name = "MT6785_M4_AXI_MST_SCP"},
{.master = MT6785_M4_AXI_MST_MCUSYS_DFD, .port = 4, .id_mask = 0x1FFF,
.id_val = 0x1000,
.note = "",
.name = "MT6785_M4_AXI_MST_MCUSYS_DFD"},
};
#endif /* __MPU_PLATFORM_H__ */
+62
View File
@@ -0,0 +1,62 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_EMI_H__
#define __MT_EMI_H__
/* submodule control */
#define ENABLE_BWL 1
#define ENABLE_MPU 1
#define ENABLE_ELM 1
#define ENABLE_MBW 0
#define DECS_ON_SSPM
#define MPU_BYPASS
/* #define ENABLE_BWL_CONFIG */
/* #define ENABLE_MPU_SLVERR */
/* #define ENABLE_LATENCY_REGULATOR */
#define ENABLE_EMI_DEBUG_API
#define ENABLE_BW_MON_PLAT_INIT
/* IRQ from device tree */
#define MPU_IRQ_INDEX 0
#define ELM_IRQ_INDEX 1
/* macro for MPU */
#define ENABLE_AP_REGION 1
#define AP_REGION_ID 31
#define DBG_INFO_READY 1
#define EMI_MPUD0_ST (CEN_EMI_BASE + 0x160)
#define EMI_MPUD_ST(domain) (EMI_MPUD0_ST + (4*domain))
#define EMI_MPUD0_ST2 (CEN_EMI_BASE + 0x200)
#define EMI_MPUD_ST2(domain) (EMI_MPUD0_ST2 + (4*domain))
#define EMI_MPUS (CEN_EMI_BASE + 0x01F0)
#define EMI_MPUT (CEN_EMI_BASE + 0x01F8)
#define EMI_MPUT_2ND (CEN_EMI_BASE + 0x01FC)
#define EMI_MPU_SA0 (0x100)
#define EMI_MPU_EA0 (0x200)
#define EMI_MPU_SA(region) (EMI_MPU_SA0 + (region*4))
#define EMI_MPU_EA(region) (EMI_MPU_EA0 + (region*4))
#define EMI_MPU_APC0 (0x300)
#define EMI_MPU_APC(region, dgroup) \
(EMI_MPU_APC0 + (region*4) + ((dgroup)*0x100))
#define EMI_MPU_CTRL_D0 (0x800)
#define EMI_MPU_CTRL_D(domain) (EMI_MPU_CTRL_D0 + (domain*4))
/* macro for ELM */
#define MBW_BUF_LEN 0x800000
#define LAST_EMI_DECS_CTRL (LAST_EMI_BASE + 0x04)
#define LAST_EMI_MBW_BUF_L (LAST_EMI_BASE + 0x10)
#define LAST_EMI_MBW_BUF_H (LAST_EMI_BASE + 0x14)
#include <mt_emi_api.h>
#include <bwl_v1.h>
#include <elm_v1.h>
#endif /* __MT_EMI_H__ */
@@ -0,0 +1,38 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_EMI_API_H__
#define __MT_EMI_API_H__
/* macro for MPU */
#define EMI_MPU_DOMAIN_NUM 16
#define EMI_MPU_REGION_NUM 32
#define EMI_MPU_ALIGN_BITS 16
/* general macro */
#define MAX_CH 2
#define MAX_DBG_NR 1
#define MAX_RK 2
#define DRAM_OFFSET 0x40000000
unsigned int get_dram_type(void);
unsigned int get_dram_mr(unsigned int index);
unsigned int get_ch_num(void);
unsigned int get_rk_num(void);
unsigned int get_rank_size(unsigned int rank_index);
unsigned int get_emi_bwst(unsigned int bw_index);
unsigned int get_emi_bwvl(unsigned int bw_index);
void __iomem *mt_cen_emi_base_get(void);
void __iomem *mt_emi_base_get(void);
void __iomem *mt_chn_emi_base_get(unsigned int channel_index);
void __iomem *mt_emi_mpu_base_get(void);
void dump_last_bm(char *buf, unsigned int leng);
void bw_monitor_init(void);
#include <mpu_v1.h>
#include <pasr_api_v1.h>
#endif /* __MT_EMI_API_H__ */
@@ -0,0 +1,132 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/platform_device.h>
#include <linux/of_address.h>
#include <linux/delay.h>
#include <mt-plat/sync_write.h>
#include <mt-plat/mtk_io.h>
#ifdef CONFIG_MTK_AEE_FEATURE
#include <mt-plat/aee.h>
//#include <mt-plat/mtk_ram_console.h>
#endif
#include "mt_emi_api.h"
#include <../emi_ctrl_v1.h>
#include "mt_emi.h"
#include "plat_debug_api.h"
static void __iomem *cen_emi_base;
static void __iomem *base0;
static void __iomem *base1;
static void __iomem *base2;
void plat_debug_api_init(void)
{
cen_emi_base = mt_cen_emi_base_get();
base0 = mt_emi_dbg_base_get(0);
base1 = mt_chn_emi_base_get(0);
base2 = mt_chn_emi_base_get(1);
pr_debug("[EMI] >> cen: %p\n", cen_emi_base);
pr_debug("[EMI] >> base0: %p\n", base0);
pr_debug("[EMI] >> base1: %p\n", base1);
pr_debug("[EMI] >> base2: %p\n", base2);
}
static void infra_dbg0(unsigned int v0, unsigned int v1,
unsigned int v2, unsigned int v3,
const char *str)
{
writel(v0, base0+0x100);
writel(v1, base0+0x104);
writel(v2, base0+0x108);
writel(v3, base0+0x10c);
pr_debug("[EMI] %s: 0x%x\n", str, readl(cen_emi_base+0x7fc));
}
static void infra_dbg1(unsigned int v0, unsigned int v1,
const char *str)
{
writel(v0, base1+0xa88);
writel(v1, base1+0xa8c);
pr_debug("[EMI] %s: 0x%x\n", str, readl(base1+0xa84));
}
static void infra_dbg2(unsigned int v0, unsigned int v1,
const char *str)
{
writel(v0, base2+0xa88);
writel(v1, base2+0xa8c);
pr_debug("[EMI] %s: 0x%x\n", str, readl(base2+0xa84));
}
static void one_shot(void)
{
pr_debug("\n----------------\n");
writel(readl(cen_emi_base+0xe8)|(0x1<<8), cen_emi_base+0xe8);
infra_dbg0(0x20, 0x40, 0x60, 0x80, "CEN_EMI_DEBUG_0");
infra_dbg0(0xa0, 0xc0, 0xe0, 0x100, "CEN_EMI_DEBUG_1");
infra_dbg0(0x120, 0x140, 0x160, 0x180, "CEN_EMI_DEBUG_2");
infra_dbg0(0x1a0, 0x1c0, 0x1e0, 0x200, "CEN_EMI_DEBUG_3");
infra_dbg0(0x220, 0x240, 0x260, 0x280, "CEN_EMI_DEBUG_4");
infra_dbg0(0x2a0, 0x2c0, 0x2e0, 0x300, "CEN_EMI_DEBUG_5");
infra_dbg0(0x320, 0x340, 0x360, 0x380, "CEN_EMI_DEBUG_6");
infra_dbg0(0x3a0, 0x3c0, 0x3e0, 0x400, "CEN_EMI_DEBUG_7");
infra_dbg0(0x420, 0x4e0, 0x500, 0x520, "CEN_EMI_DEBUG_8");
infra_dbg0(0x540, 0x560, 0x580, 0x5a0, "CEN_EMI_DEBUG_9");
infra_dbg0(0x6c0, 0x6e0, 0x700, 0x720, "CEN_EMI_DEBUG_A");
infra_dbg0(0x740, 0x7a0, 0x7c0, 0x7e0, "CEN_EMI_DEBUG_B");
pr_debug("[EMI] %s: 0x%x\n", "EMI_IOCL", readl(cen_emi_base+0xd0));
pr_debug("[EMI] %s: 0x%x\n", "EMI_IOCL_2ND", readl(cen_emi_base+0xd4));
pr_debug("[EMI] %s: 0x%x\n", "EMI_IOCM", readl(cen_emi_base+0xd8));
pr_debug("[EMI] %s: 0x%x\n", "EMI_IOCM_2ND", readl(cen_emi_base+0xdc));
writel(readl(base1+0xa80)|0x1, base1+0xa80);
infra_dbg1(0x10000, 0x30002, "CHN0_EMI_DBG_0");
infra_dbg1(0x50004, 0x70006, "CHN0_EMI_DBG_1");
infra_dbg1(0x90008, 0xb000a, "CHN0_EMI_DBG_2");
infra_dbg1(0xd000c, 0xf000e, "CHN0_EMI_DBG_3");
infra_dbg1(0x110010, 0x130012, "CHN0_EMI_DBG_4");
infra_dbg1(0x150014, 0x170016, "CHN0_EMI_DBG_5");
infra_dbg1(0x190018, 0x1b001a, "CHN0_EMI_DBG_6");
infra_dbg1(0x1d001c, 0x1f001e, "CHN0_EMI_DBG_7");
infra_dbg1(0x210020, 0x230022, "CHN0_EMI_DBG_8");
infra_dbg1(0x250024, 0x270026, "CHN0_EMI_DBG_9");
infra_dbg1(0x290028, 0x310030, "CHN0_EMI_DBG_A");
infra_dbg1(0x370036, 0x390038, "CHN0_EMI_DBG_B");
writel(readl(base2+0xa80)|0x1, base2+0xa80);
infra_dbg2(0x10000, 0x30002, "CHN1_EMI_DBG_0");
infra_dbg2(0x50004, 0x70006, "CHN1_EMI_DBG_1");
infra_dbg2(0x90008, 0xb000a, "CHN1_EMI_DBG_2");
infra_dbg2(0xd000c, 0xf000e, "CHN1_EMI_DBG_3");
infra_dbg2(0x110010, 0x130012, "CHN1_EMI_DBG_4");
infra_dbg2(0x150014, 0x170016, "CHN1_EMI_DBG_5");
infra_dbg2(0x190018, 0x1b001a, "CHN1_EMI_DBG_6");
infra_dbg2(0x1d001c, 0x1f001e, "CHN1_EMI_DBG_7");
infra_dbg2(0x210020, 0x230022, "CHN1_EMI_DBG_8");
infra_dbg2(0x250024, 0x270026, "CHN1_EMI_DBG_9");
infra_dbg2(0x290028, 0x310030, "CHN1_EMI_DBG_A");
infra_dbg2(0x370036, 0x390038, "CHN1_EMI_DBG_B");
}
void dump_emi_outstanding(void)
{
if (is_infra_timeout()) {
lastbus_timeout_dump();
one_shot();
mdelay(1);
one_shot();
mdelay(1);
one_shot();
} else {
pr_debug("[BUS] no infra timeout now\n");
pr_debug("[BUS] should check those before bus\n");
}
}
@@ -0,0 +1,13 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __PLAT_DEBUG_API_H__
#define __PLAT_DEBUG_API_H__
extern void dump_emi_outstanding(void);
extern int lastbus_timeout_dump(void);
extern int is_infra_timeout(void);
#endif /* end of __PLAT_DEBUG_API_H__ */
+28
View File
@@ -0,0 +1,28 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
ccflags-y += -I$(srctree)/drivers/misc/mediatek/emi
ccflags-y += -I$(srctree)/drivers/misc/mediatek/emi/submodule
ccflags-y += -I$(srctree)/drivers/misc/mediatek/dramc
ccflags-y += -I$(srctree)/drivers/misc/mediatek/dramc/$(MTK_PLATFORM)
obj-y += bwl_platform.o
obj-y += mpu_platform.o
obj-y += plat_debug_api.o
obj-y += ../emi_ctrl_v1.o
obj-y += ../submodule/bwl_v1.o
obj-y += ../submodule/mpu_v1.o
obj-y += ../submodule/elm_v2.o
obj-y += ../submodule/pasr_api_v1.o
@@ -0,0 +1,113 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/delay.h>
#include <mt-plat/mtk_io.h>
#include <mt-plat/sync_write.h>
#include "mt_emi.h"
#include "bwl_platform.h"
#define EMI_BWCT0_2ND (CEN_EMI_BASE + 0x6A0)
#define EMI_BWCT0_4TH (CEN_EMI_BASE + 0x780)
#define EMI_BWCT0_5TH (CEN_EMI_BASE + 0x7B0)
#define EMI_BWST0 (CEN_EMI_BASE + 0x5C4)
#define EMI_BWST_2ND (CEN_EMI_BASE + 0x6A8)
#define EMI_BWST_3RD (CEN_EMI_BASE + 0x778)
#define EMI_BWST_4TH (CEN_EMI_BASE + 0x788)
#define EMI_BWST_5TH (CEN_EMI_BASE + 0x7B8)
#define EMI_BWVL (CEN_EMI_BASE + 0x7D0)
#define EMI_BWVL_2ND (CEN_EMI_BASE + 0x7D4)
#define EMI_BWVL_3RD (CEN_EMI_BASE + 0x7D8)
#define EMI_BWVL_4TH (CEN_EMI_BASE + 0x7DC)
#define EMI_BWVL_5TH (CEN_EMI_BASE + 0x7E0)
static unsigned int decs_status;
unsigned int decode_bwl_env(
unsigned int dram_type, unsigned int ch_num, unsigned int rk_num)
{
if (ch_num == 1)
return BWL_ENV_LPDDR3_1CH;
else
return BWL_ENV_LPDDR4_2CH;
}
unsigned int acquire_bwl_ctrl(void __iomem *LAST_EMI_BASE)
{
unsigned int timeout;
decs_status = readl(IOMEM(LAST_EMI_DECS_CTRL));
mt_reg_sync_writel(0x1, LAST_EMI_DECS_CTRL);
for (timeout = 1; readl(IOMEM(LAST_EMI_DECS_CTRL)) != 2; timeout++) {
mdelay(1);
if ((timeout % 100) == 0) {
mt_reg_sync_writel(decs_status, LAST_EMI_DECS_CTRL);
pr_debug("[BWL] switch scenario timeout\n");
return -1;
}
}
return 0;
}
void release_bwl_ctrl(void __iomem *LAST_EMI_BASE)
{
mt_reg_sync_writel(decs_status, LAST_EMI_DECS_CTRL);
}
void resume_decs(void __iomem *CEN_EMI_BASE)
{
mt_reg_sync_writel(0x00030023, EMI_BWCT0_2ND);
mt_reg_sync_writel(0x00C00023, EMI_BWCT0_4TH);
mt_reg_sync_writel(0x00240023, EMI_BWCT0_5TH);
}
unsigned int get_emi_bwst(unsigned int bw_index)
{
void __iomem *CEN_EMI_BASE;
CEN_EMI_BASE = mt_cen_emi_base_get();
switch (bw_index) {
case 0:
return readl(IOMEM(EMI_BWST0));
case 1:
return readl(IOMEM(EMI_BWST_2ND));
case 2:
return readl(IOMEM(EMI_BWST_3RD));
case 3:
return readl(IOMEM(EMI_BWST_4TH));
case 4:
return readl(IOMEM(EMI_BWST_5TH));
default:
return 0;
}
}
unsigned int get_emi_bwvl(unsigned int bw_index)
{
void __iomem *CEN_EMI_BASE;
CEN_EMI_BASE = mt_cen_emi_base_get();
switch (bw_index) {
case 0:
return readl(IOMEM(EMI_BWVL));
case 1:
return readl(IOMEM(EMI_BWVL_2ND));
case 2:
return readl(IOMEM(EMI_BWVL_3RD));
case 3:
return readl(IOMEM(EMI_BWVL_4TH));
case 4:
return readl(IOMEM(EMI_BWVL_5TH));
default:
return 0;
}
}
@@ -0,0 +1,48 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __BWL_PLATFORM_H__
#define __BWL_PLATFORM_H__
enum BWL_ENV {
BWL_ENV_LPDDR4_2CH,
BWL_ENV_LPDDR3_1CH,
BWL_ENV_MAX
};
enum BWL_SCN {
BWL_SCN_VPWFD,
BWL_SCN_VR4K,
BWL_SCN_ICFP,
BWL_SCN_UI,
BWL_SCN_MAX
};
enum BWL_CEN_REG {
BWL_CEN_0x00000100,
BWL_CEN_0x00000108,
BWL_CEN_0x00000110,
BWL_CEN_0x00000118,
BWL_CEN_0x00000120,
BWL_CEN_0x00000128,
BWL_CEN_0x00000130,
BWL_CEN_0x00000138,
BWL_CEN_MAX
};
enum BWL_CHN_REG {
BWL_CHN_0x00000048,
BWL_CHN_0x00000080,
BWL_CHN_0x00000088,
BWL_CHN_0x00000140,
BWL_CHN_0x00000144,
BWL_CHN_0x00000158,
BWL_CHN_0x0000015c,
BWL_CHN_MAX
};
#define SCN_DEFAULT BWL_SCN_UI
#endif /* __BWL_PLATFORM_H__ */
@@ -0,0 +1,125 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000110, 0xa0a050d8)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000118, 0x000070c3)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000120, 0x40406048)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000128, 0xa0a070d7)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000048, 0x00030027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000080, 0x00000f00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000140, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000144, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VPWFD, 0x0000015c, 0x82410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000110, 0xa0a050da)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000118, 0x000070c4)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000120, 0x40406049)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000128, 0xa0a070d3)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000048, 0x00030027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000080, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000140, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000144, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_VR4K, 0x0000015c, 0x82410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000110, 0xa0a050cb)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000128, 0xa0a070d6)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000048, 0x00030027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000080, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000140, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000144, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x00000158, 0x00080868)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_ICFP, 0x0000015c, 0x88410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000110, 0xa0a050c6)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000120, 0x40406045)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000128, 0xa0a070d5)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000048, 0x00030027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000080, 0x00000f00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000140, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000144, 0x20406188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR4_2CH, BWL_SCN_UI, 0x0000015c, 0x82410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000110, 0xa0a050d8)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000118, 0x000070c3)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000120, 0x40406048)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000128, 0xa0a070d7)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000048, 0x00008027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000080, 0x00000f00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000140, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000144, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VPWFD, 0x0000015c, 0x82410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000110, 0xa0a050da)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000118, 0x000070c4)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000120, 0x40406049)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000128, 0xa0a070d3)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000048, 0x00008027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000080, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000140, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000144, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_VR4K, 0x0000015c, 0x82410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000110, 0xa0a050cb)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000120, 0x40406046)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000128, 0xa0a070d6)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000048, 0x00008027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000080, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000140, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000144, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x00000158, 0x00080868)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_ICFP, 0x0000015c, 0x88410222)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000100, 0x4020524f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000108, 0x4020504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000110, 0xa0a050c6)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000118, 0x000070cc)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000120, 0x40406045)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000128, 0xa0a070d5)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000130, 0xa0a0504f)
SET_BWL_CEN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000138, 0xa0a0504f)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000048, 0x00008027)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000080, 0x00000f00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000088, 0x00000b00)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000140, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000144, 0x20407188)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x00000158, 0x00080888)
SET_BWL_CHN_REG(BWL_ENV_LPDDR3_1CH, BWL_SCN_UI, 0x0000015c, 0x82410222)
@@ -0,0 +1,41 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/platform_device.h>
#include "mt_emi.h"
enum {
MASTER_APM0 = 0,
MASTER_APM1 = 1,
MASTER_MM0 = 2,
MASTER_MDMCU = 3,
MASTER_MD = 4,
MASTER_MM1 = 5,
MASTER_GPU0_PERI = 6,
MASTER_GPU1_LPDMA = 7,
MASTER_ALL = 8
};
int is_md_master(unsigned int master_id, unsigned int domain_id)
{
if ((master_id & 0x7) == MASTER_MDMCU)
return 1;
if ((master_id & 0x7) == MASTER_MD)
return 1;
return 0;
}
void set_ap_region_permission(unsigned int apc[EMI_MPU_DGROUP_NUM])
{
SET_ACCESS_PERMISSION(apc, LOCK,
FORBIDDEN, FORBIDDEN, FORBIDDEN, FORBIDDEN,
SEC_R_NSEC_R, FORBIDDEN, NO_PROTECTION, NO_PROTECTION,
FORBIDDEN, SEC_R_NSEC_RW, FORBIDDEN, NO_PROTECTION,
FORBIDDEN, FORBIDDEN, FORBIDDEN, NO_PROTECTION);
}
File diff suppressed because it is too large. Load diff
+57
View File
@@ -0,0 +1,57 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_EMI_H__
#define __MT_EMI_H__
/* submodule control */
#define ENABLE_BWL 1
#define ENABLE_MPU 1
#define ENABLE_ELM 1
#define ENABLE_MBW 0
#define DECS_ON_SSPM
/* #define ENABLE_MPU_SLVERR */
#define DBG_INFO_READY 0
/* IRQ from device tree */
#define MPU_IRQ_INDEX 0
#define ELM_IRQ_INDEX 1 /* fcBianco uses CGM IRQ as ELM IRQ */
/* macro for MPU */
#define ENABLE_AP_REGION 1
#define AP_REGION_ID 31
#define EMI_MPUD0_ST (CEN_EMI_BASE + 0x160)
#define EMI_MPUD_ST(domain) (EMI_MPUD0_ST + (4*domain))
#define EMI_MPUD0_ST2 (CEN_EMI_BASE + 0x200)
#define EMI_MPUD_ST2(domain) (EMI_MPUD0_ST2 + (4*domain))
#define EMI_MPUS (CEN_EMI_BASE + 0x01F0)
#define EMI_MPUT (CEN_EMI_BASE + 0x01F8)
#define EMI_MPUT_2ND (CEN_EMI_BASE + 0x01FC)
#define EMI_MPU_SA0 (0x100)
#define EMI_MPU_EA0 (0x200)
#define EMI_MPU_SA(region) (EMI_MPU_SA0 + (region*4))
#define EMI_MPU_EA(region) (EMI_MPU_EA0 + (region*4))
#define EMI_MPU_APC0 (0x300)
#define EMI_MPU_APC(region, dgroup) \
(EMI_MPU_APC0 + (region*4) + ((dgroup)*0x100))
#define EMI_MPU_CTRL_D0 (0x800)
#define EMI_MPU_CTRL_D(domain) (EMI_MPU_CTRL_D0 + (domain*4))
/* macro for ELM */
#define MBW_BUF_LEN 0x800000
#define LAST_EMI_DECS_CTRL (LAST_EMI_BASE + 0x04)
#define LAST_EMI_MBW_BUF_L (LAST_EMI_BASE + 0x10)
#define LAST_EMI_MBW_BUF_H (LAST_EMI_BASE + 0x14)
#include <mt_emi_api.h>
#include <bwl_v1.h>
#include <elm_v1.h>
#endif /* __MT_EMI_H__ */
@@ -0,0 +1,35 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_EMI_API_H__
#define __MT_EMI_API_H__
/* macro for MPU */
#define EMI_MPU_DOMAIN_NUM 16
#define EMI_MPU_REGION_NUM 32
#define EMI_MPU_ALIGN_BITS 16
/* general macro */
#define MAX_CH 2
#define MAX_RK 2
#define DRAM_OFFSET 0x40000000
unsigned int get_dram_type(void);
unsigned int get_ch_num(void);
unsigned int get_rk_num(void);
unsigned int get_rank_size(unsigned int rank_index);
unsigned int get_emi_bwst(unsigned int bw_index);
unsigned int get_emi_bwvl(unsigned int bw_index);
extern void __iomem *mt_cen_emi_base_get(void);
extern void __iomem *mt_emi_base_get(void);
extern void __iomem *mt_chn_emi_base_get(unsigned int channel_index);
extern void __iomem *mt_emi_mpu_base_get(void);
extern void dump_last_bm(char *buf, unsigned int leng);
#include <mpu_v1.h>
#include <pasr_api_v1.h>
#endif /* __MT_EMI_API_H__ */
@@ -0,0 +1,23 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/platform_device.h>
#include <linux/of_address.h>
#include <mt-plat/sync_write.h>
#include <mt-plat/mtk_io.h>
#ifdef CONFIG_MTK_AEE_FEATURE
#include <mt-plat/aee.h>
#include <mt-plat/mtk_ram_console.h>
#endif
#include "mt_emi.h"
void plat_debug_api_init(void)
{
}
void dump_emi_outstanding(void)
{
}
@@ -0,0 +1,11 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __PLAT_DEBUG_API_H__
#define __PLAT_DEBUG_API_H__
extern void dump_emi_outstanding(void);
#endif /* end of __PLAT_DEBUG_API_H__ */
@@ -0,0 +1,348 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/kernel.h>
#include <linux/interrupt.h>
#include <linux/semaphore.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <mt-plat/sync_write.h>
#include <emi_io.h>
#include <mt_emi.h>
#include <bwl_platform.h>
#include "bwl_v1.h"
#if DBG_INFO_READY
#include <plat_dbg_info.h>
#endif
#ifdef DECS_ON_SSPM
#include <dramc.h>
#endif
DEFINE_SEMAPHORE(bwl_sem);
static void __iomem *CEN_EMI_BASE;
static void __iomem *CHN_EMI_BASE[MAX_CH];
#ifdef DECS_ON_SSPM
static void __iomem *LAST_EMI_BASE;
static unsigned int init_status;
#endif
/* reg table and pointer*/
static struct scn_reg_t (*env_cen_reg)[BWL_CEN_MAX];
static struct scn_reg_t cen_reg[BWL_ENV_MAX][BWL_SCN_MAX][BWL_CEN_MAX] = {
#define SET_BWL_CEN_REG(ENV, SCN, OFFSET, VAL) \
[ENV][SCN][BWL_CEN_##OFFSET].offset = OFFSET, \
[ENV][SCN][BWL_CEN_##OFFSET].value = VAL,
#define SET_BWL_CHN_REG(ENV, SCN, OFFSET, VAL)
#include <bwl_scenario.h>
#undef SET_BWL_CEN_REG
#undef SET_BWL_CHN_REG
};
static struct scn_reg_t (*env_chn_reg)[BWL_CHN_MAX];
static struct scn_reg_t chn_reg[BWL_ENV_MAX][BWL_SCN_MAX][BWL_CHN_MAX] = {
#define SET_BWL_CEN_REG(ENV, SCN, OFFSET, VAL)
#define SET_BWL_CHN_REG(ENV, SCN, OFFSET, VAL) \
[ENV][SCN][BWL_CHN_##OFFSET].offset = OFFSET, \
[ENV][SCN][BWL_CHN_##OFFSET].value = VAL,
#include <bwl_scenario.h>
#undef SET_BWL_CEN_REG
#undef SET_BWL_CHN_REG
};
/* BWL control table */
static unsigned int ctrl_table[BWL_SCN_MAX];
static unsigned int cur_scn = 0xFFFFFFFF;
static struct scn_name_t scn_name[BWL_SCN_MAX] = {
#define SET_BWL_CEN_REG(ENV, SCN, OFFSET, VAL) \
[SCN].name = #SCN,
#define SET_BWL_CHN_REG(ENV, SCN, OFFSET, VAL)
#include <bwl_scenario.h>
#undef SET_BWL_CEN_REG
#undef SET_BWL_CHN_REG
};
void set_emi_reg(unsigned int scn)
{
int i, j;
unsigned int value, offset;
for (i = 0; i < BWL_CEN_MAX; i++) {
value = env_cen_reg[scn][i].value;
offset = env_cen_reg[scn][i].offset;
mt_reg_sync_writel(value, IOMEM(CEN_EMI_BASE + offset));
}
for (i = 0; i < BWL_CHN_MAX; i++) {
value = env_chn_reg[scn][i].value;
offset = env_chn_reg[scn][i].offset;
for (j = 0; j < MAX_CH; j++) {
mt_reg_sync_writel(value,
IOMEM(CHN_EMI_BASE[j] + offset));
}
}
}
/* op: 0 for disable, 1 for enable */
int bwl_ctrl(unsigned int scn, unsigned int op)
{
int i;
int highest;
if (scn >= BWL_SCN_MAX)
return -1;
if (op > 1)
return -1;
if (in_interrupt())
return -1;
down(&bwl_sem);
#ifdef DECS_ON_SSPM
if (init_status) {
if (acquire_bwl_ctrl(LAST_EMI_BASE)) {
up(&bwl_sem);
return -1;
}
}
#endif
if (op == 1)
ctrl_table[scn]++;
else if (op == 0) {
if (ctrl_table[scn] != 0)
ctrl_table[scn]--;
}
/* find the scenario with the highest priority */
highest = -1;
for (i = 0; i < BWL_SCN_MAX; i++) {
if (ctrl_table[i] != 0) {
highest = i;
break;
}
}
if (highest == -1)
highest = SCN_DEFAULT;
/* set new EMI bandwidth limiter value */
if (highest != cur_scn) {
set_emi_reg(highest);
cur_scn = highest;
}
#ifdef DECS_ON_SSPM
if (init_status)
release_bwl_ctrl(LAST_EMI_BASE);
init_status = 1;
#endif
up(&bwl_sem);
return 0;
}
#ifdef ENABLE_BWL_CONFIG
#define BWL_MAX_CMD_LEN 128
#define BWL_MAX_TOKEN 4
static ssize_t bwl_config_show(struct device_driver *driver, char *buf)
{
ssize_t ret;
unsigned int decs_ctrl;
ret = 0;
decs_ctrl = readl(IOMEM(LAST_EMI_DECS_CTRL));
if (ret < PAGE_SIZE) {
ret += snprintf(buf + ret, PAGE_SIZE - ret,
"decs_status: 0x%x\n", decs_ctrl);
}
return ret;
}
static ssize_t bwl_config_store
(struct device_driver *driver, const char *buf, size_t count)
{
char *command;
char *ptr;
char *token[BWL_MAX_TOKEN];
unsigned long scn_index;
unsigned long reg_index;
unsigned long reg_value;
int i, ret;
if ((strlen(buf) + 1) > BWL_MAX_CMD_LEN) {
pr_info("[BWL] store command overflow\n");
return count;
}
command = kmalloc((size_t) BWL_MAX_CMD_LEN, GFP_KERNEL);
if (!command)
return count;
strncpy(command, buf, (size_t) BWL_MAX_CMD_LEN);
for (i = 0; i < BWL_MAX_TOKEN; i++) {
ptr = strsep(&command, " ");
if (ptr == NULL)
break;
token[i] = ptr;
}
if (!strncmp(buf, "DECS_CTRL", strlen("DECS_CTRL"))) {
if (i < 2)
goto bwl_store_end;
ret = kstrtoul(token[1], 16, &reg_value);
mt_reg_sync_writel(reg_value, LAST_EMI_DECS_CTRL);
} else if (!strncmp(buf, "SET_CEN", strlen("SET_CEN"))) {
if (i < 4)
goto bwl_store_end;
ret = kstrtoul(token[1], 10, &scn_index);
ret = kstrtoul(token[2], 10, &reg_index);
ret = kstrtoul(token[3], 16, &reg_value);
if (scn_index >= BWL_SCN_MAX)
goto bwl_store_end;
if (reg_index >= BWL_CEN_MAX)
goto bwl_store_end;
env_cen_reg[scn_index][reg_index].value = reg_value;
} else if (!strncmp(buf, "SET_CHN", strlen("SET_CHN"))) {
if (i < 4)
goto bwl_store_end;
ret = kstrtoul(token[1], 10, &scn_index);
ret = kstrtoul(token[2], 10, &reg_index);
ret = kstrtoul(token[3], 16, &reg_value);
if (scn_index >= BWL_SCN_MAX)
goto bwl_store_end;
if (reg_index >= BWL_CHN_MAX)
goto bwl_store_end;
env_chn_reg[scn_index][reg_index].value = reg_value;
}
bwl_store_end:
kfree(command);
return count;
}
static DRIVER_ATTR_RW(bwl_config);
#endif
static ssize_t concurrency_scenario_show
(struct device_driver *driver, char *buf)
{
ssize_t ret = 0;
unsigned int offset;
int i, j;
if (cur_scn >= BWL_SCN_MAX)
return sprintf(buf, "none\n");
ret += snprintf(buf, 64, "current scenario: %s\n",
scn_name[cur_scn].name);
ret += snprintf(buf + ret, 32, "%s\n", scn_name[cur_scn].name);
for (i = 0; i < BWL_CEN_MAX; i++) {
if (ret >= PAGE_SIZE)
return strlen(buf);
offset = env_cen_reg[cur_scn][i].offset;
ret += snprintf(buf + ret, PAGE_SIZE - ret, "CEN 0x%x: 0x%x\n",
offset, readl(IOMEM(CEN_EMI_BASE + offset)));
}
for (i = 0; i < BWL_CHN_MAX; i++) {
offset = env_chn_reg[cur_scn][i].offset;
for (j = 0; j < MAX_CH; j++) {
if (ret >= PAGE_SIZE)
return strlen(buf);
ret += snprintf(buf + ret, PAGE_SIZE - ret,
"CH%d 0x%x:0x%x\n", j, offset,
readl(IOMEM(CHN_EMI_BASE[j] + offset)));
}
}
for (i = 0; i < BWL_SCN_MAX; i++) {
if (ret >= PAGE_SIZE)
return strlen(buf);
ret += snprintf(buf + ret, PAGE_SIZE - ret, "%s = 0x%x\n",
scn_name[i].name, ctrl_table[i]);
}
return strlen(buf);
}
static ssize_t concurrency_scenario_store
(struct device_driver *driver, const char *buf, size_t count)
{
int i;
char *name;
for (i = 0; i < BWL_SCN_MAX; i++) {
name = scn_name[i].name;
if (strncmp(buf, name, strlen(name)))
continue;
if (!strncmp(buf + strlen(name) + 1,
"ON", strlen("ON"))) {
bwl_ctrl(i, 1);
/* pr_info("[BWL] %s ON\n", name); */
break;
} else if (!strncmp(buf + strlen(name) + 1,
"OFF", strlen("OFF"))) {
bwl_ctrl(i, 0);
/* pr_info("[BWL] %s OFF\n", name); */
break;
}
}
return count;
}
static DRIVER_ATTR_RW(concurrency_scenario);
void bwl_init(struct platform_driver *emi_ctrl)
{
int i;
int ret;
unsigned int env;
CEN_EMI_BASE = mt_cen_emi_base_get();
for (i = 0; i < MAX_CH; i++)
CHN_EMI_BASE[i] = mt_chn_emi_base_get(i);
#if (defined(DECS_ON_SSPM) && DBG_INFO_READY)
LAST_EMI_BASE = get_dbg_info_base(0xE31C);
#endif
env = decode_bwl_env(get_dram_type(), get_ch_num(), get_rk_num());
env_cen_reg = cen_reg[env];
env_chn_reg = chn_reg[env];
bwl_ctrl(SCN_DEFAULT, 1);
ret = driver_create_file(&emi_ctrl->driver,
&driver_attr_concurrency_scenario);
if (ret)
pr_err("[BWL] fail to create concurrency_scenario\n");
#ifdef ENABLE_BWL_CONFIG
ret = driver_create_file(&emi_ctrl->driver, &driver_attr_bwl_config);
if (ret)
pr_err("[BWL] fail to bwl_config\n");
#endif
}
@@ -0,0 +1,24 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __BWL_H__
#define __BWL_H__
struct scn_name_t {
char *name;
};
struct scn_reg_t {
unsigned int offset;
unsigned int value;
};
extern unsigned int decode_bwl_env(
unsigned int dram_type, unsigned int ch_num, unsigned int rk_num);
extern unsigned int acquire_bwl_ctrl(void __iomem *LAST_EMI_BASE);
extern void release_bwl_ctrl(void __iomem *LAST_EMI_BASE);
#endif /* __BWL_H__ */
@@ -0,0 +1,151 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/printk.h>
#include <mt_emi.h>
#include "elm_v1.h"
static bool elm_enabled;
static DEFINE_SPINLOCK(elm_lock);
bool is_elm_enabled(void)
{
return elm_enabled;
}
EXPORT_SYMBOL(is_elm_enabled);
void enable_elm(void)
{
unsigned long flags;
int emi_dcm_status;
spin_lock_irqsave(&elm_lock, flags);
emi_dcm_status = disable_emi_dcm();
turn_on_elm();
elm_enabled = true;
restore_emi_dcm(emi_dcm_status);
spin_unlock_irqrestore(&elm_lock, flags);
}
EXPORT_SYMBOL(enable_elm);
void disable_elm(void)
{
unsigned long flags;
int emi_dcm_status;
spin_lock_irqsave(&elm_lock, flags);
emi_dcm_status = disable_emi_dcm();
turn_off_elm();
elm_enabled = false;
restore_emi_dcm(emi_dcm_status);
spin_unlock_irqrestore(&elm_lock, flags);
}
EXPORT_SYMBOL(disable_elm);
static irqreturn_t elm_isr(int irq, void *dev_id)
{
unsigned long flags;
int emi_dcm_status;
pr_info("[ELM] latency violation\n");
spin_lock_irqsave(&elm_lock, flags);
save_debug_reg();
emi_dcm_status = disable_emi_dcm();
reset_elm();
restore_emi_dcm(emi_dcm_status);
spin_unlock_irqrestore(&elm_lock, flags);
return IRQ_HANDLED;
}
/* the interface of CCCI for MD EE */
void dump_last_bm(char *buf, unsigned int leng)
{
unsigned long flags;
spin_lock_irqsave(&elm_lock, flags);
dump_elm(buf, leng);
spin_unlock_irqrestore(&elm_lock, flags);
}
static ssize_t elm_ctrl_show(struct device_driver *driver, char *buf)
{
return sprintf(buf, "ELM enabled: %d\n", is_elm_enabled());
}
static ssize_t elm_ctrl_store(struct device_driver *driver,
const char *buf, size_t count)
{
if (!strncmp(buf, "ON", strlen("ON")))
enable_elm();
else if (!strncmp(buf, "OFF", strlen("OFF")))
disable_elm();
return count;
}
DRIVER_ATTR(elm_ctrl, 0644, elm_ctrl_show, elm_ctrl_store);
void elm_init(struct platform_driver *emi_ctrl, struct platform_device *pdev)
{
struct device_node *node = pdev->dev.of_node;
unsigned int elm_irq;
int ret;
pr_info("[ELM] initialize EMI ELM\n");
mt_elm_init(mt_cen_emi_base_get());
if (node) {
elm_irq = irq_of_parse_and_map(node, ELM_IRQ_INDEX);
pr_info("[ELM] get ELM IRQ: %d\n", elm_irq);
ret = request_irq(elm_irq, (irq_handler_t)elm_isr,
IRQF_TRIGGER_NONE, "elm", emi_ctrl);
if (ret != 0) {
pr_info("[ELM] fail to request IRQ (%d)\n", ret);
return;
}
enable_elm();
}
ret = driver_create_file(&emi_ctrl->driver, &driver_attr_elm_ctrl);
if (ret)
pr_info("[ELM] fail to create elm_ctrl\n");
}
void suspend_elm(void)
{
int emi_dcm_status;
if (is_elm_enabled()) {
emi_dcm_status = disable_emi_dcm();
turn_off_elm();
restore_emi_dcm(emi_dcm_status);
}
}
void resume_elm(void)
{
if (is_elm_enabled())
enable_elm();
}
@@ -0,0 +1,22 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __ELM_H__
#define __ELM_H__
extern void mt_elm_init(void __iomem *elm_base);
extern unsigned int disable_emi_dcm(void);
extern void restore_emi_dcm(unsigned int emi_dcm_status);
extern void turn_on_elm(void);
extern void turn_off_elm(void);
extern void reset_elm(void);
extern void dump_elm(char *buf, unsigned int leng);
extern void save_debug_reg(void);
extern void suspend_elm(void);
extern void resume_elm(void);
extern void dump_last_bm(char *buf, unsigned int leng);
#endif /* __ELM_H__ */
@@ -0,0 +1,114 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/printk.h>
#include <linux/uaccess.h>
#include <linux/fs.h>
#include <linux/debugfs.h>
#include <mt-plat/sync_write.h>
#include <emi_io.h>
#include <mt_emi.h>
#if DBG_INFO_READY
#include <plat_dbg_info.h>
#endif
static struct dentry *emi_mbw_dir;
static struct dentry *dump_buf;
static void __iomem *mbw_dram_buf;
static bool elm_enabled;
static ssize_t dump_buf_read
(struct file *file, char __user *data, size_t len, loff_t *ppos)
{
ssize_t bytes = len < (MBW_BUF_LEN - *ppos) ?
len : (MBW_BUF_LEN - *ppos);
if (!mbw_dram_buf)
return 0;
if (bytes) {
if (copy_to_user(data, (char *)mbw_dram_buf + *ppos, bytes))
return -EFAULT;
}
*ppos += bytes;
return bytes;
}
static int dump_buf_open(struct inode *inode, struct file *file)
{
return nonseekable_open(inode, file);
}
static const struct file_operations dump_buf_fops = {
.owner = THIS_MODULE,
.read = dump_buf_read,
.open = dump_buf_open
};
void elm_init(struct platform_driver *emi_ctrl, struct platform_device *pdev)
{
void __iomem *LAST_EMI_BASE;
unsigned int mbw_buf_h, mbw_buf_l;
phys_addr_t mbw_buf_start;
pr_info("[ELM] initialize EMI ELMv2\n");
#if DBG_INFO_READY
LAST_EMI_BASE = get_dbg_info_base(0xE31C);
#else
LAST_EMI_BASE = NULL;
#endif
if (!LAST_EMI_BASE) {
pr_err("[ELM] get LAST_EMI_BASE fail\n");
return;
}
elm_enabled = false;
if (readl(IOMEM(LAST_EMI_DECS_CTRL)) == 0xDECDDECD) {
mbw_buf_l = readl(IOMEM(LAST_EMI_MBW_BUF_L));
mbw_buf_h = readl(IOMEM(LAST_EMI_MBW_BUF_H));
#ifdef CONFIG_PHYS_ADDR_T_64BIT
mbw_buf_start = ((phys_addr_t)mbw_buf_h << 32) + mbw_buf_l;
#else
mbw_buf_start = (phys_addr_t)mbw_buf_l;
#endif
mbw_dram_buf = ioremap_wc(mbw_buf_start, MBW_BUF_LEN);
elm_enabled = true;
pr_info("[ELM] enable mbw_buf dump\n");
}
emi_mbw_dir = debugfs_create_dir("emi_mbw", NULL);
if (!emi_mbw_dir) {
pr_err("[ELM] create dir fail\n");
return;
}
dump_buf = debugfs_create_file("dump_buf", 0444,
emi_mbw_dir, NULL, &dump_buf_fops);
if (!dump_buf) {
pr_err("[ELM] create dump_buf fail\n");
return;
}
}
void suspend_elm(void)
{
}
void resume_elm(void)
{
}
@@ -0,0 +1,595 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/printk.h>
#include <linux/memblock.h>
#include <linux/arm-smccc.h>
#include <linux/soc/mediatek/mtk_sip_svc.h>
#include <mt-plat/sync_write.h>
#include <mt-plat/mtk_ccci_common.h>
#ifdef CONFIG_MTK_AEE_FEATURE
#include <mt-plat/aee.h>
#endif
#include <emi.h>
#include <emi_io.h>
#include <mt_emi.h>
#include "mpu_v1.h"
#include <mpu_platform.h>
_Static_assert(EMI_MPU_DOMAIN_NUM <= 2048, "EMI_MPU_DOMAIN_NUM is over 2048");
_Static_assert(EMI_MPU_REGION_NUM <= 256, "EMI_MPU_REGION_NUM is over 256");
#if EMI_MPU_TEST
char mpu_test_buf[0x20000] __aligned(PAGE_SIZE);
#endif
static void __iomem *CEN_EMI_BASE;
static void (*check_violation_cb)(void);
static const char *UNKNOWN_MASTER = "unknown";
#ifndef USER_BUILD_KERNEL
static unsigned int show_region;
#endif
#ifdef MPU_BYPASS
static unsigned int init_flag;
#endif
static unsigned int match_id(
unsigned int axi_id, unsigned int tbl_idx, unsigned int port_id)
{
if ((axi_id & mst_tbl[tbl_idx].id_mask) == mst_tbl[tbl_idx].id_val) {
if (port_id == mst_tbl[tbl_idx].port)
return 1;
}
return 0;
}
static const char *id2name(unsigned int axi_id, unsigned int port_id)
{
int i;
for (i = 0; i < ARRAY_SIZE(mst_tbl); i++) {
if (match_id(axi_id, i, port_id))
return mst_tbl[i].name;
}
return (char *)UNKNOWN_MASTER;
}
static unsigned int emi_mpu_read_protection(
unsigned int reg_type, unsigned int region, unsigned int dgroup)
{
struct arm_smccc_res smc_res;
arm_smccc_smc(MTK_SIP_EMIMPU_CONTROL, MTK_EMIMPU_READ,
reg_type, region, dgroup, 0, 0, 0, &smc_res);
return (unsigned int)smc_res.a0;
}
static void clear_violation(void)
{
unsigned int mpus, mput, i;
/* clear violation status */
for (i = 0; i < EMI_MPU_DOMAIN_NUM; i++) {
/* clear region abort violation */
mt_reg_sync_writel(0xFFFFFFFF, EMI_MPUD_ST(i));
/* clear out-of-range violation */
mt_reg_sync_writel(0x3, EMI_MPUD_ST2(i));
}
/* clear debug info */
mt_reg_sync_writel(0x80000000, EMI_MPUS);
mpus = readl(IOMEM(EMI_MPUS));
mput = readl(IOMEM(EMI_MPUT));
if (mpus) {
pr_info("[MPU] fail to clear violation\n");
pr_info("[MPU] EMI_MPUS: %x, EMI_MPUT: %x\n", mpus, mput);
}
}
static void check_violation(void)
{
unsigned int mpus, mput, mput_2nd;
unsigned int master_id, domain_id;
unsigned int port_id, axi_id;
unsigned int region;
unsigned int wr_vio, wr_oo_vio;
unsigned long long vio_addr;
const char *master_name;
mpus = readl(IOMEM(EMI_MPUS));
mput = readl(IOMEM(EMI_MPUT));
mput_2nd = readl(IOMEM(EMI_MPUT_2ND));
vio_addr = ((((unsigned long long)(mput_2nd & 0xF)) << 32) + mput +
DRAM_OFFSET);
/* decode EMI_MPUS */
master_id = mpus & 0xFFFF;
domain_id = (mpus >> 21) & 0xF;
region = (mpus >> 16) & 0x1F;
wr_vio = (mpus >> 29) & 0x3;
wr_oo_vio = (mpus >> 27) & 0x3;
port_id = master_id & 0x7;
axi_id = (master_id >> 3) & 0x1FFF;
master_name = id2name(axi_id, port_id);
pr_info("[MPU] EMI MPU violation\n");
pr_info("[MPU] MPUS: %x, MPUT: %x, MPUT_2ND: %x.\n",
mpus, mput, mput_2nd);
pr_info("[MPU] current process is \"%s \" (pid: %i)\n",
current->comm, current->pid);
pr_info("[MPU] corrupted address is 0x%llx, in region %d\n",
vio_addr, region);
pr_info("[MPU] master ID: 0x%x, AXI ID: 0x%x, port ID: 0x%x\n",
master_id, axi_id, port_id);
pr_info("[MPU] violation master is %s, from domain 0x%x\n",
master_name, domain_id);
if (wr_vio == 1)
pr_info("[MPU] write violation\n");
else if (wr_vio == 2)
pr_info("[MPU] read violation\n");
else
pr_info("[MPU] strange write/read violation (%d)\n", wr_vio);
if (wr_oo_vio == 1)
pr_info("[MPU] write out-of-range violation\n");
else if (wr_oo_vio == 2)
pr_info("[MPU] read out-of-range violation\n");
#ifdef MPU_BYPASS
if (bypass_violation(mpus, &init_flag)) {
pr_info("[MPU] bypass flow\n");
clear_violation();
clear_md_violation();
return;
}
#endif
#ifdef CONFIG_MTK_AEE_FEATURE
if (wr_vio != 0) {
if (is_md_master(master_id, domain_id)) {
char str[CCCI_STR_MAX_LEN] = "0";
if (snprintf(str, CCCI_STR_MAX_LEN,
"EMI_MPUS = 0x%x, ADDR = 0x%llx",
mpus, vio_addr) < 0) {
pr_info("[MPU] CCCI string fail\n");
}
#if CCCI_API_READY
exec_ccci_kern_func_by_md_id(0, ID_MD_MPU_ASSERT,
str, strlen(str));
#endif
pr_info("[MPU] violation trigger MD, ");
pr_info("str=%s strlen(str)=%d\n",
str, (int)strlen(str));
}
aee_kernel_exception("EMI MPU",
"%s%s = 0x%x,%s = 0x%x,%s = 0x%x,%s = 0x%llx\n%s%s\n",
"EMI MPU violation.\n",
"EMI_MPUS", mpus,
"EMI_MPUT", mput,
"EMI_MPUT_2ND", mput_2nd,
"vio_addr", vio_addr,
"CRDISPATCH_KEY:EMI MPU Violation Issue/",
master_name);
}
#endif
clear_violation();
}
static irqreturn_t violation_irq(int irq, void *dev_id)
{
check_violation_cb();
return IRQ_HANDLED;
}
int emi_mpu_set_protection(struct emi_region_info_t *region_info)
{
unsigned int start, end;
struct arm_smccc_res smc_res;
int i;
if (region_info->region >= EMI_MPU_REGION_NUM) {
pr_info("[MPU] can not support region %u\n",
region_info->region);
return -1;
}
start = (unsigned int)(region_info->start >> EMI_MPU_ALIGN_BITS) |
(region_info->region << 24);
for (i = EMI_MPU_DGROUP_NUM - 1; i >= 0; i--) {
end = (unsigned int)(region_info->end >> EMI_MPU_ALIGN_BITS) |
(i << 24);
arm_smccc_smc(MTK_SIP_EMIMPU_CONTROL, MTK_EMIMPU_SET,
start, end, region_info->apc[i], 0, 0, 0, &smc_res);
}
return 0;
}
EXPORT_SYMBOL(emi_mpu_set_protection);
int emi_mpu_set_single_permission(unsigned int region,
unsigned int domain,
unsigned int permission)
{
struct arm_smccc_res smc_res;
unsigned int old_apc, new_apc;
unsigned long long start, end;
int i;
if (region >= EMI_MPU_REGION_NUM) {
pr_debug("[EMI] wrong region %d when calling %s\n",
region, __func__);
return -1;
}
if (domain >= EMI_MPU_DOMAIN_NUM) {
pr_debug("[EMI] wrong domain %d when calling %s\n",
domain, __func__);
return -1;
}
for (i = 0; i < EMI_MPU_DGROUP_NUM; i++) {
unsigned int index = domain % 8;
if ((domain / 8) == i) {
old_apc = emi_mpu_read_protection(
MTK_EMIMPU_READ_APC, region, i);
old_apc &= ~(0x7 << (3 * index));
new_apc = old_apc | (permission << (3 * index));
start = (unsigned long long)emi_mpu_read_protection(
MTK_EMIMPU_READ_SA, region, 0) & 0xffffff;
end = (unsigned long long)emi_mpu_read_protection(
MTK_EMIMPU_READ_EA, region, 0) & 0xffffff;
start = (start << EMI_MPU_ALIGN_BITS) + DRAM_OFFSET;
start = start >> EMI_MPU_ALIGN_BITS;
end = (end << EMI_MPU_ALIGN_BITS) + DRAM_OFFSET;
end = end >> EMI_MPU_ALIGN_BITS;
arm_smccc_smc(MTK_SIP_EMIMPU_CONTROL, MTK_EMIMPU_SET,
(region << 24) | start, (i << 24) | end,
new_apc, 0, 0, 0, &smc_res);
} else {
pr_debug("[EMI] don't need to set apc\n");
continue;
}
}
return 0;
}
EXPORT_SYMBOL(emi_mpu_set_single_permission);
int emi_mpu_clear_protection(struct emi_region_info_t *region_info)
{
struct arm_smccc_res smc_res;
if (region_info->region > EMI_MPU_REGION_NUM) {
pr_info("[MPU] can not support region %u\n",
region_info->region);
return -1;
}
arm_smccc_smc(MTK_SIP_EMIMPU_CONTROL, MTK_EMIMPU_CLEAR,
region_info->region, 0, 0, 0, 0, 0, &smc_res);
return 0;
}
#ifndef USER_BUILD_KERNEL
static ssize_t mpu_config_show(struct device_driver *driver, char *buf)
{
ssize_t ret = 0;
unsigned int i;
unsigned int region;
unsigned int apc;
unsigned long long start, end;
static const char *permission[8] = {
"No",
"S_RW",
"S_RW_NS_R",
"S_RW_NS_W",
"S_R_NS_R",
"FORBIDDEN",
"S_R_NS_RW",
"NONE"
};
#if EMI_MPU_TEST
i = (*((unsigned int *)(mpu_test_buf + 0x10000)));
pr_info("[MPU] trigger violation with read 0x%x\n", i);
#endif
for (region = show_region; region < EMI_MPU_REGION_NUM; region++) {
start = (unsigned long long)emi_mpu_read_protection(
MTK_EMIMPU_READ_SA, region, 0);
start = (start << EMI_MPU_ALIGN_BITS) + DRAM_OFFSET;
end = (unsigned long long)emi_mpu_read_protection(
MTK_EMIMPU_READ_EA, region, 0);
end = (end << EMI_MPU_ALIGN_BITS) + DRAM_OFFSET;
ret += snprintf(buf + ret, PAGE_SIZE - ret,
"R%u-> 0x%llx to 0x%llx\n",
region, start, end + 0xFFFF);
if (ret >= PAGE_SIZE)
return strlen(buf);
for (i = 0; i < EMI_MPU_DGROUP_NUM; i++) {
apc = emi_mpu_read_protection(
MTK_EMIMPU_READ_APC, region, i);
ret += snprintf(buf + ret, PAGE_SIZE - ret,
"%s, %s, %s, %s\n%s, %s, %s, %s\n\n",
permission[(apc >> 0) & 0x7],
permission[(apc >> 3) & 0x7],
permission[(apc >> 6) & 0x7],
permission[(apc >> 9) & 0x7],
permission[(apc >> 12) & 0x7],
permission[(apc >> 15) & 0x7],
permission[(apc >> 18) & 0x7],
permission[(apc >> 21) & 0x7]);
if (ret >= PAGE_SIZE)
return strlen(buf);
}
}
return strlen(buf);
}
static ssize_t mpu_config_store
(struct device_driver *driver, const char *buf, size_t count)
{
char *command;
char *backup_command;
char *ptr;
char *token[EMI_MPU_MAX_TOKEN];
static struct emi_region_info_t region_info;
unsigned long long start, end;
unsigned long region;
unsigned long dgroup;
unsigned long apc;
int i, ret;
if ((strlen(buf) + 1) > EMI_MPU_MAX_CMD_LEN) {
pr_info("[MPU] store command overflow\n");
return count;
}
pr_info("[MPU] store: %s\n", buf);
command = kmalloc((size_t) EMI_MPU_MAX_CMD_LEN, GFP_KERNEL);
backup_command = command;
if (!command)
return count;
strncpy(command, buf, (size_t) EMI_MPU_MAX_CMD_LEN);
for (i = 0; i < EMI_MPU_MAX_TOKEN; i++) {
ptr = strsep(&command, " ");
if (ptr == NULL)
break;
token[i] = ptr;
}
if (!strncmp(buf, "SHOW", strlen("SHOW"))) {
if (i < 2)
goto mpu_store_end;
pr_info("[MPU] %s %s\n", token[0], token[1]);
ret = kstrtoul(token[1], 10, &region);
if (ret != 0) {
pr_info("[MPU] fail to parse region\n");
goto mpu_store_end;
}
if (region < EMI_MPU_REGION_NUM) {
show_region = (unsigned int) region;
pr_info("[MPU] set show_region to %u\n", show_region);
}
} else if (!strncmp(buf, "SET", strlen("SET"))) {
if (i < 3)
goto mpu_store_end;
pr_info("[MPU] %s %s %s\n", token[0], token[1], token[2]);
ret = kstrtoul(token[1], 10, &dgroup);
if (ret != 0) {
pr_info("[MPU] fail to parse dgroup\n");
goto mpu_store_end;
}
ret = kstrtoul(token[2], 16, &apc);
if (ret != 0) {
pr_info("[MPU] fail to parse apc\n");
goto mpu_store_end;
}
if (dgroup < EMI_MPU_DGROUP_NUM) {
region_info.apc[dgroup] = (unsigned int) apc;
pr_info("[MPU] apc[%lu]: 0x%x\n",
dgroup, region_info.apc[dgroup]);
}
} else if (!strncmp(buf, "ON", strlen("ON"))) {
if (i < 4)
goto mpu_store_end;
pr_info("[MPU] %s %s %s %s\n",
token[0], token[1], token[2], token[3]);
ret = kstrtoull(token[1], 16, &start);
if (ret != 0) {
pr_info("[MPU] fail to parse start\n");
goto mpu_store_end;
}
ret = kstrtoull(token[2], 16, &end);
if (ret != 0) {
pr_info("[MPU] fail to parse end\n");
goto mpu_store_end;
}
ret = kstrtoul(token[3], 10, &region);
if (ret != 0) {
pr_info("[MPU] fail to parse region\n");
goto mpu_store_end;
}
if (region < EMI_MPU_REGION_NUM) {
region_info.start = start;
region_info.end = end;
region_info.region = (unsigned int)region;
emi_mpu_set_protection(&region_info);
}
} else if (!strncmp(buf, "OFF", strlen("OFF"))) {
if (i < 2)
goto mpu_store_end;
pr_info("[MPU] %s %s\n", token[0], token[1]);
ret = kstrtoul(token[1], 10, &region);
if (ret != 0) {
pr_info("[MPU] fail to parse region\n");
goto mpu_store_end;
}
if (region < EMI_MPU_REGION_NUM) {
region_info.region = (unsigned int)region;
emi_mpu_clear_protection(&region_info);
}
} else
pr_info("[MPU] unknown store command\n");
mpu_store_end:
kfree(backup_command);
return count;
}
static DRIVER_ATTR_RW(mpu_config);
#endif
#if ENABLE_AP_REGION
static void protect_ap_region(void)
{
struct emi_region_info_t region_info;
region_info.start = (unsigned long long)memblock_start_of_DRAM();
region_info.end = (unsigned long long)memblock_end_of_DRAM() - 1;
region_info.region = AP_REGION_ID;
set_ap_region_permission(region_info.apc);
emi_mpu_set_protection(&region_info);
}
#endif
#ifdef ENABLE_MPU_SLVERR
static void enable_slverr(void)
{
struct arm_smccc_res smc_res;
unsigned int domain;
for (domain = 0; domain < EMI_MPU_DOMAIN_NUM; domain++) {
arm_smccc_smc(MTK_SIP_EMIMPU_CONTROL, MTK_EMIMPU_SLVERR,
i, 0, 0, 0, 0, 0, &smc_res);
}
}
#endif
void mpu_init(struct platform_driver *emi_ctrl, struct platform_device *pdev)
{
struct device_node *node = pdev->dev.of_node;
unsigned int mpu_irq;
int ret;
#if EMI_MPU_TEST
unsigned int *ptr_test_buf;
ptr_test_buf = (unsigned int *)__pa(mpu_test_buf);
pr_info("[MPU] mpu_test_buf: %p\n", ptr_test_buf);
*((unsigned int *)(mpu_test_buf + 0x10000)) = 0xDEADDEAD;
#endif
pr_info("[MPU] initialize EMI MPU\n");
CEN_EMI_BASE = mt_cen_emi_base_get();
#ifdef MPU_BYPASS
bypass_init(&init_flag);
#endif
if (!check_violation_cb)
check_violation_cb = check_violation;
if (readl(IOMEM(EMI_MPUS))) {
pr_info("[MPU] detect violation in driver init\n");
check_violation_cb();
} else
clear_violation();
if (node) {
mpu_irq = irq_of_parse_and_map(node, MPU_IRQ_INDEX);
pr_info("[MPU] get MPU IRQ: %d\n", mpu_irq);
ret = request_irq(mpu_irq, (irq_handler_t)violation_irq,
IRQF_TRIGGER_NONE, "mpu", emi_ctrl);
if (ret != 0) {
pr_info("[MPU] fail to request IRQ (%d)\n", ret);
return;
}
}
#if ENABLE_AP_REGION
protect_ap_region();
#endif
#ifdef ENABLE_MPU_SLVERR
enable_slverr();
#endif
#if !defined(USER_BUILD_KERNEL)
ret = driver_create_file(&emi_ctrl->driver, &driver_attr_mpu_config);
if (ret)
pr_info("[MPU] fail to create mpu_config\n");
#endif
}
int emi_mpu_check_register(void (*cb_func)(void))
{
if (!cb_func) {
pr_info("%s%d: cb_func is NULL\n", __func__, __LINE__);
return -EINVAL;
}
check_violation_cb = cb_func;
return 0;
}
EXPORT_SYMBOL(emi_mpu_check_register);
void clear_md_violation(void)
{
mt_reg_sync_writel(0x80000000, EMI_MPUT_2ND);
}
EXPORT_SYMBOL(clear_md_violation);
@@ -0,0 +1,91 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __MPU_H__
#define __MPU_H__
#include <linux/types.h>
/* USER_BUILD_KERNEL is only defined when DEBUG_FS is enabled! */
#ifndef CONFIG_DEBUG_FS
#define USER_BUILD_KERNEL
#endif
#define CCCI_API_READY 0
#define EMI_MPU_TEST 0
#define EMI_MPU_MAX_CMD_LEN 128
#define EMI_MPU_MAX_TOKEN 4
#define CCCI_STR_MAX_LEN 60
#define NO_PROTECTION 0
#define SEC_RW 1
#define SEC_RW_NSEC_R 2
#define SEC_RW_NSEC_W 3
#define SEC_R_NSEC_R 4
#define FORBIDDEN 5
#define SEC_R_NSEC_RW 6
#define UNLOCK 0
#define LOCK 1
#define EMI_MPU_DGROUP_NUM (EMI_MPU_DOMAIN_NUM / 8)
#if (EMI_MPU_DGROUP_NUM == 1)
#define SET_ACCESS_PERMISSION(apc_ary, lock, d7, d6, d5, d4, d3, d2, d1, d0) \
do {\
apc_ary[0] = 0;\
apc_ary[0] = \
(((unsigned int) d7) << 21) | (((unsigned int) d6) << 18) | \
(((unsigned int) d5) << 15) | (((unsigned int) d4) << 12) | \
(((unsigned int) d3) << 9) | (((unsigned int) d2) << 6) | \
(((unsigned int) d1) << 3) | ((unsigned int) d0) | \
((unsigned int) lock << 31); \
} while (0)
#elif (EMI_MPU_DGROUP_NUM == 2)
#define SET_ACCESS_PERMISSION(apc_ary, lock, \
d15, d14, d13, d12, d11, d10, d9, d8, d7, d6, d5, d4, d3, d2, d1, d0) \
do { \
apc_ary[1] = \
(((unsigned int) d15) << 21) | (((unsigned int) d14) << 18) | \
(((unsigned int) d13) << 15) | (((unsigned int) d12) << 12) | \
(((unsigned int) d11) << 9) | (((unsigned int) d10) << 6) | \
(((unsigned int) d9) << 3) | ((unsigned int) d8); \
apc_ary[0] = \
(((unsigned int) d7) << 21) | (((unsigned int) d6) << 18) | \
(((unsigned int) d5) << 15) | (((unsigned int) d4) << 12) | \
(((unsigned int) d3) << 9) | (((unsigned int) d2) << 6) | \
(((unsigned int) d1) << 3) | ((unsigned int) d0) | \
((unsigned int) lock << 31); \
} while (0)
#endif
struct emi_region_info_t {
unsigned long long start;
unsigned long long end;
unsigned int region;
unsigned int apc[EMI_MPU_DGROUP_NUM];
};
struct mst_tbl_entry {
u32 master;
u32 port;
u32 id_mask;
u32 id_val;
const char *note;
const char *name;
};
extern void bypass_init(unsigned int *init_flag);
extern int bypass_violation(unsigned int mpus, unsigned int *init_flag);
extern int is_md_master(unsigned int master_id, unsigned int domain_id);
extern void set_ap_region_permission(unsigned int apc[EMI_MPU_DGROUP_NUM]);
extern int emi_mpu_set_protection(struct emi_region_info_t *region_info);
extern int emi_mpu_set_single_permission(unsigned int region,
unsigned int domain,
unsigned int permission);
extern void clear_md_violation(void);
#endif /* __MPU_H__ */
@@ -0,0 +1,59 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#include <linux/platform_device.h>
#include <mt_emi.h>
#include "pasr_api_v1.h"
/* acquire DRAM Setting for PASR/DPD */
static unsigned int get_segment_nr(unsigned int rk_index)
{
unsigned int rank_size;
unsigned int num_of_1;
unsigned int i;
rank_size = get_rank_size(rk_index) / get_ch_num();
num_of_1 = 0;
for (i = 0; i < 32; i++) {
if (rank_size & 0x1)
num_of_1++;
rank_size = rank_size >> 1;
}
if (num_of_1 > 1)
return 6;
else
return 8;
}
void acquire_dram_setting(struct basic_dram_setting *pasrdpd)
{
unsigned int ch, rk;
pasrdpd->channel_nr = get_ch_num();
for (ch = 0; ch < MAX_CH; ch++) {
for (rk = 0; rk < MAX_RK; rk++) {
if ((ch >= pasrdpd->channel_nr) ||
(rk >= get_rk_num())) {
pasrdpd->channel[ch].rank[rk].valid_rank =
false;
pasrdpd->channel[ch].rank[rk].rank_size = 0;
pasrdpd->channel[ch].rank[rk].segment_nr = 0;
continue;
}
pasrdpd->channel[ch].rank[rk].valid_rank = true;
pasrdpd->channel[ch].rank[rk].rank_size =
get_rank_size(rk) / (pasrdpd->channel_nr);
pasrdpd->channel[ch].rank[rk].segment_nr =
get_segment_nr(rk);
}
}
}
@@ -0,0 +1,29 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: Sagy Shih <sagy.shih@mediatek.com>
*/
#ifndef __PASR_API_H__
#define __PASR_API_H__
#include <linux/types.h>
#define MAX_RANKS MAX_RK
struct basic_dram_setting {
unsigned int channel_nr;
/* per-channel information */
struct {
/* per-rank information */
struct {
bool valid_rank;
unsigned int rank_size; /* unit: 1 Gb*/
unsigned int segment_nr;
} rank[MAX_RK];
} channel[MAX_CH];
};
void acquire_dram_setting(struct basic_dram_setting *pasrdpd);
#endif /* __PASR_API_H__ */