1447 lines
39 KiB
C
Executable file
1447 lines
39 KiB
C
Executable file
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) 2019 MediaTek Inc.
|
|
*/
|
|
|
|
#include <linux/arm-smccc.h>
|
|
#include <linux/clk.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of_irq.h>
|
|
#include <linux/of_address.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/sched/debug.h>
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <mt-plat/aee.h>
|
|
#include <mt-plat/devapc_public.h>
|
|
#include <mt-plat/mtk_secure_api.h>
|
|
#include "devapc-mtk-multi-ao.h"
|
|
|
|
static struct mtk_devapc_context {
|
|
struct clk *devapc_infra_clk;
|
|
uint32_t devapc_irq;
|
|
|
|
/* HW reg mapped addr */
|
|
void __iomem *devapc_pd_base[4];
|
|
void __iomem *devapc_infra_ao_base;
|
|
void __iomem *infracfg_base;
|
|
void __iomem *sramrom_base;
|
|
|
|
struct mtk_devapc_soc *soc;
|
|
struct mutex viocb_list_lock;
|
|
} mtk_devapc_ctx[1];
|
|
|
|
static LIST_HEAD(viocb_list);
|
|
static DEFINE_SPINLOCK(devapc_lock);
|
|
|
|
static void devapc_test_cb(void)
|
|
{
|
|
pr_info(PFX "%s success !\n", __func__);
|
|
}
|
|
|
|
static enum devapc_cb_status devapc_test_adv_cb(uint32_t vio_addr)
|
|
{
|
|
pr_info(PFX "%s success !\n", __func__);
|
|
pr_info(PFX "vio_addr: 0x%x\n", vio_addr);
|
|
|
|
return DEVAPC_NOT_KE;
|
|
}
|
|
|
|
static struct devapc_vio_callbacks devapc_test_handle = {
|
|
.id = DEVAPC_SUBSYS_TEST,
|
|
.debug_dump = devapc_test_cb,
|
|
.debug_dump_adv = devapc_test_adv_cb,
|
|
};
|
|
|
|
/*
|
|
* mtk_devapc_pd_get - get devapc pd_types of register address.
|
|
*
|
|
* Returns the value of reg addr
|
|
*/
|
|
static void __iomem *mtk_devapc_pd_get(int slave_type,
|
|
enum DEVAPC_PD_REG_TYPE pd_reg_type,
|
|
uint32_t index)
|
|
{
|
|
struct mtk_devapc_vio_info *vio_info = mtk_devapc_ctx->soc->vio_info;
|
|
const uint32_t *devapc_pds = mtk_devapc_ctx->soc->devapc_pds;
|
|
uint32_t slave_type_num = mtk_devapc_ctx->soc->slave_type_num;
|
|
void __iomem *reg;
|
|
|
|
if (unlikely(devapc_pds == NULL)) {
|
|
pr_err(PFX "%s:%d NULL pointer\n", __func__, __LINE__);
|
|
return NULL;
|
|
}
|
|
|
|
if ((slave_type < slave_type_num &&
|
|
index < vio_info->vio_mask_sta_num[slave_type]) &&
|
|
(pd_reg_type < PD_REG_TYPE_NUM)) {
|
|
|
|
reg = mtk_devapc_ctx->devapc_pd_base[slave_type] +
|
|
devapc_pds[pd_reg_type];
|
|
|
|
if (pd_reg_type == VIO_MASK || pd_reg_type == VIO_STA)
|
|
reg += 0x4 * index;
|
|
|
|
} else {
|
|
pr_err(PFX "%s:0x%x or %s:0x%x or %s:0x%x is out of boundary\n",
|
|
"slave_type", slave_type,
|
|
"pd_reg_type", pd_reg_type,
|
|
"index", index);
|
|
return NULL;
|
|
}
|
|
|
|
return reg;
|
|
}
|
|
|
|
/*
|
|
* sramrom_vio_handler - clean sramrom violation & print violation information
|
|
* for debugging.
|
|
*/
|
|
static void sramrom_vio_handler(void)
|
|
{
|
|
const struct mtk_sramrom_sec_vio_desc *sramrom_vios;
|
|
struct mtk_devapc_vio_info *vio_info;
|
|
struct arm_smccc_res res;
|
|
size_t sramrom_vio_sta;
|
|
int sramrom_vio;
|
|
uint32_t rw;
|
|
|
|
sramrom_vios = mtk_devapc_ctx->soc->sramrom_sec_vios;
|
|
vio_info = mtk_devapc_ctx->soc->vio_info;
|
|
|
|
arm_smccc_smc(MTK_SIP_KERNEL_CLR_SRAMROM_VIO,
|
|
0, 0, 0, 0, 0, 0, 0, &res);
|
|
|
|
sramrom_vio = res.a0;
|
|
sramrom_vio_sta = res.a1;
|
|
vio_info->vio_addr = res.a2;
|
|
|
|
if (sramrom_vio == SRAM_VIOLATION)
|
|
pr_info(PFX "%s, SRAM violation is triggered\n", __func__);
|
|
else if (sramrom_vio == ROM_VIOLATION)
|
|
pr_info(PFX "%s, ROM violation is triggered\n", __func__);
|
|
else {
|
|
pr_info(PFX "sramrom_vio:0x%x, sramrom_vio_sta:0x%zx, vio_addr:0x%x\n",
|
|
sramrom_vio,
|
|
sramrom_vio_sta,
|
|
vio_info->vio_addr);
|
|
pr_info(PFX "SRAMROM violation is not triggered\n");
|
|
return;
|
|
}
|
|
|
|
vio_info->master_id = (sramrom_vio_sta & sramrom_vios->vio_id_mask)
|
|
>> sramrom_vios->vio_id_shift;
|
|
vio_info->domain_id = (sramrom_vio_sta & sramrom_vios->vio_domain_mask)
|
|
>> sramrom_vios->vio_domain_shift;
|
|
rw = (sramrom_vio_sta & sramrom_vios->vio_rw_mask) >>
|
|
sramrom_vios->vio_rw_shift;
|
|
|
|
if (rw)
|
|
vio_info->write = 1;
|
|
else
|
|
vio_info->read = 1;
|
|
|
|
pr_info(PFX "%s: %s:0x%x, %s:0x%x, %s:%s, %s:0x%x\n",
|
|
__func__, "master_id", vio_info->master_id,
|
|
"domain_id", vio_info->domain_id,
|
|
"rw", rw ? "Write" : "Read",
|
|
"vio_addr", vio_info->vio_addr);
|
|
}
|
|
|
|
static void mask_module_irq(int slave_type, uint32_t module, bool mask)
|
|
{
|
|
struct mtk_devapc_vio_info *vio_info = mtk_devapc_ctx->soc->vio_info;
|
|
uint32_t slave_type_num = mtk_devapc_ctx->soc->slave_type_num;
|
|
uint32_t apc_register_index;
|
|
uint32_t apc_set_index;
|
|
void __iomem *reg;
|
|
|
|
apc_register_index = module / (MOD_NO_IN_1_DEVAPC * 2);
|
|
apc_set_index = module % (MOD_NO_IN_1_DEVAPC * 2);
|
|
|
|
if ((slave_type < slave_type_num) &&
|
|
(apc_register_index < vio_info->vio_mask_sta_num[slave_type])) {
|
|
|
|
reg = mtk_devapc_pd_get(slave_type, VIO_MASK,
|
|
apc_register_index);
|
|
|
|
if (mask)
|
|
writel(readl(reg) | (1 << apc_set_index), reg);
|
|
else
|
|
writel(readl(reg) & (~(1 << apc_set_index)), reg);
|
|
|
|
} else
|
|
pr_err(PFX "%s: %s, %s:0x%x, %s:0x%x, %s:%s\n",
|
|
__func__, "out of boundary",
|
|
"slave_type", slave_type,
|
|
"module_index", module,
|
|
"mask", mask ? "true" : "false");
|
|
}
|
|
|
|
static int32_t check_vio_status(int slave_type, uint32_t module)
|
|
{
|
|
struct mtk_devapc_vio_info *vio_info = mtk_devapc_ctx->soc->vio_info;
|
|
uint32_t slave_type_num = mtk_devapc_ctx->soc->slave_type_num;
|
|
uint32_t apc_register_index;
|
|
uint32_t apc_set_index;
|
|
void __iomem *reg;
|
|
|
|
apc_register_index = module / (MOD_NO_IN_1_DEVAPC * 2);
|
|
apc_set_index = module % (MOD_NO_IN_1_DEVAPC * 2);
|
|
|
|
if ((slave_type < slave_type_num) &&
|
|
(apc_register_index < vio_info->vio_mask_sta_num[slave_type])) {
|
|
|
|
reg = mtk_devapc_pd_get(slave_type, VIO_STA,
|
|
apc_register_index);
|
|
|
|
} else {
|
|
pr_err(PFX "%s: %s, %s:0x%x, %s:0x%x\n",
|
|
__func__, "out of boundary",
|
|
"slave_type", slave_type,
|
|
"module_index", module);
|
|
return -EOVERFLOW;
|
|
}
|
|
|
|
if (readl(reg) & (0x1 << apc_set_index))
|
|
return VIOLATION_TRIGGERED;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
static int32_t clear_vio_status(int slave_type, uint32_t module)
|
|
{
|
|
struct mtk_devapc_vio_info *vio_info = mtk_devapc_ctx->soc->vio_info;
|
|
uint32_t slave_type_num = mtk_devapc_ctx->soc->slave_type_num;
|
|
uint32_t apc_register_index;
|
|
uint32_t apc_set_index;
|
|
void __iomem *reg;
|
|
|
|
apc_register_index = module / (MOD_NO_IN_1_DEVAPC * 2);
|
|
apc_set_index = module % (MOD_NO_IN_1_DEVAPC * 2);
|
|
|
|
if ((slave_type < slave_type_num) &&
|
|
(apc_register_index < vio_info->vio_mask_sta_num[slave_type])) {
|
|
|
|
reg = mtk_devapc_pd_get(slave_type, VIO_STA,
|
|
apc_register_index);
|
|
writel(0x1 << apc_set_index, reg);
|
|
|
|
} else {
|
|
pr_err(PFX "%s: %s, %s:0x%x, %s:0x%x\n",
|
|
__func__, "out of boundary",
|
|
"slave_type", slave_type,
|
|
"module_index", module);
|
|
return -EOVERFLOW;
|
|
}
|
|
|
|
if (check_vio_status(slave_type, module))
|
|
return -EIO;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const char *slave_type_to_string(uint32_t slave_type)
|
|
{
|
|
uint32_t slave_type_num = mtk_devapc_ctx->soc->slave_type_num;
|
|
const char * const *slave_type_arr;
|
|
|
|
slave_type_arr = mtk_devapc_ctx->soc->slave_type_arr;
|
|
|
|
if (slave_type < slave_type_num)
|
|
return slave_type_arr[slave_type];
|
|
else
|
|
return slave_type_arr[slave_type_num];
|
|
}
|
|
|
|
static void print_vio_mask_sta(bool debug)
|
|
{
|
|
struct mtk_devapc_vio_info *vio_info = mtk_devapc_ctx->soc->vio_info;
|
|
uint32_t slave_type_num = mtk_devapc_ctx->soc->slave_type_num;
|
|
void __iomem *pd_vio_shift_sta_reg;
|
|
int slave_type, i;
|
|
|
|
for (slave_type = 0; slave_type < slave_type_num; slave_type++) {
|
|
|
|
pd_vio_shift_sta_reg = mtk_devapc_pd_get(slave_type,
|
|
VIO_SHIFT_STA, 0);
|
|
|
|
pr_info(PFX "[%s] %s: 0x%x\n",
|
|
slave_type_to_string(slave_type),
|
|
"VIO_SHIFT_STA",
|
|
readl(pd_vio_shift_sta_reg)
|
|
);
|
|
|
|
for (i = 0; i < vio_info->vio_mask_sta_num[slave_type]; i++) {
|
|
if (debug)
|
|
pr_info(PFX "%s: %s_%d: 0x%x, %s_%d: 0x%x\n",
|
|
slave_type_to_string(slave_type),
|
|
"VIO_MASK", i,
|
|
readl(mtk_devapc_pd_get(slave_type,
|
|
VIO_MASK, i)),
|
|
"VIO_STA", i,
|
|
readl(mtk_devapc_pd_get(slave_type,
|
|
VIO_STA, i))
|
|
);
|
|
else
|
|
pr_debug(PFX "%s: %s_%d: 0x%x, %s_%d: 0x%x\n",
|
|
slave_type_to_string(slave_type),
|
|
"VIO_MASK", i,
|
|
readl(mtk_devapc_pd_get(slave_type,
|
|
VIO_MASK, i)),
|
|
"VIO_STA", i,
|
|
readl(mtk_devapc_pd_get(slave_type,
|
|
VIO_STA, i))
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void devapc_vio_info_print(void)
|
|
{
|
|
struct mtk_devapc_vio_info *vio_info;
|
|
|
|
vio_info = mtk_devapc_ctx->soc->vio_info;
|
|
|
|
/* Print violation information */
|
|
if (vio_info->write)
|
|
pr_info(PFX "Write Violation\n");
|
|
else if (vio_info->read)
|
|
pr_info(PFX "Read Violation\n");
|
|
else
|
|
pr_err(PFX "R/W Violation are not raised\n");
|
|
|
|
pr_info(PFX "%s%x, %s%x, %s%x, %s%x\n",
|
|
"Vio Addr:0x", vio_info->vio_addr,
|
|
"High:0x", vio_info->vio_addr_high,
|
|
"Bus ID:0x", vio_info->master_id,
|
|
"Dom ID:0x", vio_info->domain_id);
|
|
|
|
pr_info(PFX "%s - %s%s, %s%x\n",
|
|
"Violation",
|
|
"Current Process:", current->comm,
|
|
"PID:", current->pid);
|
|
}
|
|
|
|
static bool check_type2_vio_status(int slave_type, int *vio_idx, int *index)
|
|
{
|
|
uint32_t sramrom_vio_idx, mdp_vio_idx, disp2_vio_idx, mmsys_vio_idx;
|
|
const struct mtk_device_info **device_info;
|
|
const struct mtk_device_num *ndevices;
|
|
int sramrom_slv_type, mm2nd_slv_type;
|
|
bool mdp_vio, disp2_vio, mmsys_vio;
|
|
int i;
|
|
|
|
sramrom_slv_type = mtk_devapc_ctx->soc->vio_info->sramrom_slv_type;
|
|
sramrom_vio_idx = mtk_devapc_ctx->soc->vio_info->sramrom_vio_idx;
|
|
|
|
mm2nd_slv_type = mtk_devapc_ctx->soc->vio_info->mm2nd_slv_type;
|
|
mdp_vio_idx = mtk_devapc_ctx->soc->vio_info->mdp_vio_idx;
|
|
disp2_vio_idx = mtk_devapc_ctx->soc->vio_info->disp2_vio_idx;
|
|
mmsys_vio_idx = mtk_devapc_ctx->soc->vio_info->mmsys_vio_idx;
|
|
|
|
device_info = mtk_devapc_ctx->soc->device_info;
|
|
ndevices = mtk_devapc_ctx->soc->ndevices;
|
|
|
|
/* check SRAMROM */
|
|
if (slave_type == sramrom_slv_type &&
|
|
check_vio_status(slave_type, sramrom_vio_idx)) {
|
|
|
|
pr_info(PFX "SRAMROM violation is triggered\n");
|
|
sramrom_vio_handler();
|
|
|
|
*vio_idx = sramrom_vio_idx;
|
|
for (i = 0; i < ndevices[slave_type].vio_slave_num; i++) {
|
|
if (device_info[slave_type][i].vio_index == *vio_idx)
|
|
*index = i;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/* check mm2nd */
|
|
if (slave_type == mm2nd_slv_type) {
|
|
mdp_vio = check_vio_status(slave_type, mdp_vio_idx) ==
|
|
VIOLATION_TRIGGERED;
|
|
disp2_vio = check_vio_status(slave_type, disp2_vio_idx) ==
|
|
VIOLATION_TRIGGERED;
|
|
mmsys_vio = check_vio_status(slave_type, mmsys_vio_idx) ==
|
|
VIOLATION_TRIGGERED;
|
|
|
|
if (mdp_vio || disp2_vio || mmsys_vio) {
|
|
|
|
pr_info(PFX "MM2nd violation is triggered\n");
|
|
mtk_devapc_ctx->soc->mm2nd_vio_handler(
|
|
mtk_devapc_ctx->infracfg_base,
|
|
mtk_devapc_ctx->soc->vio_info,
|
|
mdp_vio, disp2_vio, mmsys_vio);
|
|
|
|
if (mdp_vio)
|
|
*vio_idx = mdp_vio_idx;
|
|
else if (disp2_vio)
|
|
*vio_idx = disp2_vio_idx;
|
|
else if (mmsys_vio)
|
|
*vio_idx = mmsys_vio_idx;
|
|
|
|
for (i = 0; i < ndevices[slave_type].vio_slave_num;
|
|
i++) {
|
|
if (device_info[slave_type][i].vio_index ==
|
|
*vio_idx)
|
|
*index = i;
|
|
}
|
|
|
|
devapc_vio_info_print();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
pr_info(PFX "%s: no violation for %s:0x%x\n", __func__,
|
|
"slave_type", slave_type);
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* sync_vio_dbg - start to get violation information by selecting violation
|
|
* group and enable violation shift.
|
|
*
|
|
* Returns sync done or not
|
|
*/
|
|
static uint32_t sync_vio_dbg(int slave_type, uint32_t shift_bit)
|
|
{
|
|
uint32_t slave_type_num = mtk_devapc_ctx->soc->slave_type_num;
|
|
void __iomem *pd_vio_shift_sta_reg;
|
|
void __iomem *pd_vio_shift_sel_reg;
|
|
void __iomem *pd_vio_shift_con_reg;
|
|
uint32_t shift_count;
|
|
uint32_t sync_done;
|
|
|
|
if (slave_type >= slave_type_num ||
|
|
shift_bit >= (MOD_NO_IN_1_DEVAPC * 2)) {
|
|
pr_err(PFX "param check failed, %s:0x%x, %s:0x%x\n",
|
|
"slave_type", slave_type,
|
|
"shift_bit", shift_bit);
|
|
return 0;
|
|
}
|
|
|
|
pd_vio_shift_sta_reg = mtk_devapc_pd_get(slave_type, VIO_SHIFT_STA, 0);
|
|
pd_vio_shift_sel_reg = mtk_devapc_pd_get(slave_type, VIO_SHIFT_SEL, 0);
|
|
pd_vio_shift_con_reg = mtk_devapc_pd_get(slave_type, VIO_SHIFT_CON, 0);
|
|
|
|
pr_debug(PFX "%s:0x%x %s:0x%x\n",
|
|
"slave_type", slave_type,
|
|
"VIO_SHIFT_STA", readl(pd_vio_shift_sta_reg));
|
|
|
|
writel(0x1 << shift_bit, pd_vio_shift_sel_reg);
|
|
writel(0x1, pd_vio_shift_con_reg);
|
|
|
|
for (shift_count = 0; (shift_count < 100) &&
|
|
((readl(pd_vio_shift_con_reg) & 0x3) != 0x3);
|
|
++shift_count)
|
|
;
|
|
|
|
if ((readl(pd_vio_shift_con_reg) & 0x3) == 0x3)
|
|
sync_done = 1;
|
|
else {
|
|
sync_done = 0;
|
|
pr_info(PFX "sync failed, shift_bit:0x%x\n", shift_bit);
|
|
}
|
|
|
|
/* Disable shift mechanism */
|
|
writel(0x0, pd_vio_shift_con_reg);
|
|
writel(0x0, pd_vio_shift_sel_reg);
|
|
writel(0x1 << shift_bit, pd_vio_shift_sta_reg);
|
|
|
|
pr_debug(PFX "(Post) %s:0x%x, %s:0x%x, %s:0x%x\n",
|
|
"VIO_SHIFT_STA",
|
|
readl(pd_vio_shift_sta_reg),
|
|
"VIO_SHIFT_SEL",
|
|
readl(pd_vio_shift_sel_reg),
|
|
"VIO_SHIFT_CON",
|
|
readl(pd_vio_shift_con_reg));
|
|
|
|
return sync_done;
|
|
}
|
|
|
|
static const char * const perm_to_str[] = {
|
|
"NO_PROTECTION",
|
|
"SECURE_RW_ONLY",
|
|
"SECURE_RW_NS_R_ONLY",
|
|
"FORBIDDEN",
|
|
"NO_PERM_CTRL"
|
|
};
|
|
|
|
static const char *perm_to_string(uint8_t perm)
|
|
{
|
|
if (perm < 4)
|
|
return perm_to_str[perm];
|
|
else
|
|
return perm_to_str[4];
|
|
}
|
|
|
|
static void devapc_vio_reason(uint8_t perm)
|
|
{
|
|
pr_info(PFX "Permission setting: %s\n", perm_to_string(perm));
|
|
|
|
if (perm == 0 || perm > 3)
|
|
pr_info(PFX "Reason: power/clock is not enabled\n");
|
|
else if (perm == 1 || perm == 2 || perm == 3)
|
|
pr_info(PFX "Reason: might be permission denied\n");
|
|
}
|
|
|
|
/*
|
|
* get_permission - get slave's access permission of domain id.
|
|
*
|
|
* Returns the value of access permission
|
|
*/
|
|
static uint8_t get_permission(int slave_type, int module_index, int domain)
|
|
{
|
|
uint32_t slave_type_num = mtk_devapc_ctx->soc->slave_type_num;
|
|
const struct mtk_device_info **device_info;
|
|
const struct mtk_device_num *ndevices;
|
|
int sys_index, ctrl_index, vio_index;
|
|
uint32_t ret, apc_set_index;
|
|
struct arm_smccc_res res;
|
|
|
|
ndevices = mtk_devapc_ctx->soc->ndevices;
|
|
|
|
if (slave_type >= slave_type_num ||
|
|
module_index >= ndevices[slave_type].vio_slave_num) {
|
|
pr_err(PFX "%s: param check failed, %s:0x%x, %s:0x%x\n",
|
|
__func__,
|
|
"slave_type", slave_type,
|
|
"module_index", module_index);
|
|
return 0xFF;
|
|
}
|
|
|
|
device_info = mtk_devapc_ctx->soc->device_info;
|
|
|
|
sys_index = device_info[slave_type][module_index].sys_index;
|
|
ctrl_index = device_info[slave_type][module_index].ctrl_index;
|
|
vio_index = device_info[slave_type][module_index].vio_index;
|
|
|
|
if (sys_index == -1 || ctrl_index == -1) {
|
|
pr_err(PFX "%s: cannot get sys_index & ctrl_index\n",
|
|
__func__);
|
|
return 0xFF;
|
|
} else if (sys_index == -2) {
|
|
pr_info(PFX "%s: check ATF logs for type2 permssion\n",
|
|
__func__);
|
|
}
|
|
|
|
arm_smccc_smc(MTK_SIP_KERNEL_DAPC_PERM_GET, slave_type, sys_index,
|
|
domain, ctrl_index, vio_index, 0, 0, &res);
|
|
ret = res.a0;
|
|
|
|
if (ret == DEAD) {
|
|
pr_err(PFX "%s: permission get failed, ret:0x%x\n",
|
|
__func__, ret);
|
|
return 0xFF;
|
|
}
|
|
|
|
apc_set_index = ctrl_index % MOD_NO_IN_1_DEVAPC;
|
|
ret = (ret & (0x3 << (apc_set_index * 2))) >> (apc_set_index * 2);
|
|
|
|
return (ret & 0x3);
|
|
}
|
|
|
|
/*
|
|
* mtk_devapc_vio_check - check violation shift status is raised or not.
|
|
*
|
|
* Returns the value of violation shift status reg
|
|
*/
|
|
static void mtk_devapc_vio_check(int slave_type, int *shift_bit)
|
|
{
|
|
uint32_t slave_type_num = mtk_devapc_ctx->soc->slave_type_num;
|
|
struct mtk_devapc_vio_info *vio_info;
|
|
uint32_t vio_shift_sta;
|
|
int i;
|
|
|
|
if (slave_type >= slave_type_num) {
|
|
pr_err(PFX "%s: param check failed, %s:0x%x\n",
|
|
__func__, "slave_type", slave_type);
|
|
return;
|
|
}
|
|
|
|
vio_info = mtk_devapc_ctx->soc->vio_info;
|
|
vio_shift_sta = readl(mtk_devapc_pd_get(slave_type, VIO_SHIFT_STA, 0));
|
|
|
|
if (!vio_shift_sta) {
|
|
pr_info(PFX "violation is triggered before. %s:0x%x\n",
|
|
"shift_bit", *shift_bit);
|
|
|
|
} else if (vio_shift_sta & (0x1UL << *shift_bit)) {
|
|
pr_info(PFX "%s: 0x%x is matched with %s:%d\n",
|
|
"vio_shift_sta", vio_shift_sta,
|
|
"shift_bit", *shift_bit);
|
|
|
|
} else {
|
|
pr_info(PFX "%s: 0x%x is not matched with %s:%d\n",
|
|
"vio_shift_sta", vio_shift_sta,
|
|
"shift_bit", *shift_bit);
|
|
|
|
for (i = 0; i < MOD_NO_IN_1_DEVAPC * 2; i++) {
|
|
if (vio_shift_sta & (0x1 << i)) {
|
|
*shift_bit = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
vio_info->shift_sta_bit = *shift_bit;
|
|
}
|
|
|
|
static void devapc_extract_vio_dbg(int slave_type)
|
|
{
|
|
uint32_t slave_type_num = mtk_devapc_ctx->soc->slave_type_num;
|
|
void __iomem *vio_dbg0_reg, *vio_dbg1_reg, *vio_dbg2_reg;
|
|
const struct mtk_infra_vio_dbg_desc *vio_dbgs;
|
|
struct mtk_devapc_vio_info *vio_info;
|
|
uint32_t dbg0;
|
|
|
|
if (slave_type >= slave_type_num) {
|
|
pr_err(PFX "%s: param check failed, %s:0x%x\n",
|
|
__func__, "slave_type", slave_type);
|
|
return;
|
|
}
|
|
|
|
vio_dbg0_reg = mtk_devapc_pd_get(slave_type, VIO_DBG0, 0);
|
|
vio_dbg1_reg = mtk_devapc_pd_get(slave_type, VIO_DBG1, 0);
|
|
vio_dbg2_reg = mtk_devapc_pd_get(slave_type, VIO_DBG2, 0);
|
|
|
|
vio_dbgs = mtk_devapc_ctx->soc->vio_dbgs;
|
|
vio_info = mtk_devapc_ctx->soc->vio_info;
|
|
|
|
/* Extract violation information */
|
|
dbg0 = readl(vio_dbg0_reg);
|
|
vio_info->master_id = readl(vio_dbg1_reg);
|
|
vio_info->vio_addr = readl(vio_dbg2_reg);
|
|
|
|
vio_info->domain_id = (dbg0 & vio_dbgs->vio_dbg_dmnid)
|
|
>> vio_dbgs->vio_dbg_dmnid_start_bit;
|
|
vio_info->write = ((dbg0 & vio_dbgs->vio_dbg_w_vio)
|
|
>> vio_dbgs->vio_dbg_w_vio_start_bit) == 1;
|
|
vio_info->read = ((dbg0 & vio_dbgs->vio_dbg_r_vio)
|
|
>> vio_dbgs->vio_dbg_r_vio_start_bit) == 1;
|
|
vio_info->vio_addr_high = (dbg0 & vio_dbgs->vio_addr_high)
|
|
>> vio_dbgs->vio_addr_high_start_bit;
|
|
|
|
devapc_vio_info_print();
|
|
}
|
|
|
|
/*
|
|
* mtk_devapc_dump_vio_dbg - shift & dump the violation debug information.
|
|
*/
|
|
static bool mtk_devapc_dump_vio_dbg(int slave_type, int *vio_idx, int *index)
|
|
{
|
|
const struct mtk_device_info **device_info;
|
|
const struct mtk_device_num *ndevices;
|
|
void __iomem *pd_vio_shift_sta_reg;
|
|
uint32_t shift_bit;
|
|
int i;
|
|
|
|
if (unlikely(vio_idx == NULL)) {
|
|
pr_err(PFX "%s:%d NULL pointer\n", __func__, __LINE__);
|
|
return NULL;
|
|
}
|
|
|
|
device_info = mtk_devapc_ctx->soc->device_info;
|
|
ndevices = mtk_devapc_ctx->soc->ndevices;
|
|
|
|
pd_vio_shift_sta_reg = mtk_devapc_pd_get(slave_type, VIO_SHIFT_STA, 0);
|
|
|
|
for (i = 0; i < ndevices[slave_type].vio_slave_num; i++) {
|
|
if (!device_info[slave_type][i].enable_vio_irq)
|
|
continue;
|
|
|
|
*vio_idx = device_info[slave_type][i].vio_index;
|
|
if (check_vio_status(slave_type, *vio_idx) !=
|
|
VIOLATION_TRIGGERED)
|
|
continue;
|
|
|
|
shift_bit = mtk_devapc_ctx->soc->shift_group_get(
|
|
slave_type, *vio_idx);
|
|
|
|
mtk_devapc_vio_check(slave_type, &shift_bit);
|
|
|
|
if (!sync_vio_dbg(slave_type, shift_bit))
|
|
continue;
|
|
|
|
devapc_extract_vio_dbg(slave_type);
|
|
*index = i;
|
|
|
|
return true;
|
|
}
|
|
|
|
pr_info(PFX "check_devapc_vio_status: no violation for %s:0x%x\n",
|
|
"slave_type", slave_type);
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* start_devapc - initialize devapc status and start receiving interrupt
|
|
* while devapc violation is triggered.
|
|
*/
|
|
static void start_devapc(void)
|
|
{
|
|
uint32_t slave_type_num = mtk_devapc_ctx->soc->slave_type_num;
|
|
const struct mtk_device_info **device_info;
|
|
const struct mtk_device_num *ndevices;
|
|
void __iomem *pd_vio_shift_sta_reg;
|
|
void __iomem *pd_apc_con_reg;
|
|
uint32_t vio_shift_sta;
|
|
int slave_type, i, vio_idx, index;
|
|
uint32_t retry = RETRY_COUNT;
|
|
|
|
print_vio_mask_sta(false);
|
|
ndevices = mtk_devapc_ctx->soc->ndevices;
|
|
|
|
device_info = mtk_devapc_ctx->soc->device_info;
|
|
|
|
for (slave_type = 0; slave_type < slave_type_num; slave_type++) {
|
|
|
|
pd_apc_con_reg = mtk_devapc_pd_get(slave_type, APC_CON, 0);
|
|
pd_vio_shift_sta_reg = mtk_devapc_pd_get(
|
|
slave_type, VIO_SHIFT_STA, 0);
|
|
|
|
if (unlikely(pd_apc_con_reg == NULL ||
|
|
pd_vio_shift_sta_reg == NULL ||
|
|
device_info == NULL)) {
|
|
pr_err(PFX "%s:%d NULL pointer\n", __func__, __LINE__);
|
|
return;
|
|
}
|
|
|
|
/* Clear DEVAPC violation status */
|
|
writel(BIT(31), pd_apc_con_reg);
|
|
|
|
/* Clear violation shift status */
|
|
vio_shift_sta = readl(pd_vio_shift_sta_reg);
|
|
if (vio_shift_sta) {
|
|
writel(vio_shift_sta, pd_vio_shift_sta_reg);
|
|
pr_info(PFX "clear %s:0x%x %s:0x%x to 0x%x\n",
|
|
"slave_type", slave_type,
|
|
"VIO_SHIFT_STA", vio_shift_sta,
|
|
readl(pd_vio_shift_sta_reg));
|
|
}
|
|
|
|
check_type2_vio_status(slave_type, &vio_idx, &i);
|
|
|
|
/* Clear violation status */
|
|
for (i = 0; i < ndevices[slave_type].vio_slave_num; i++) {
|
|
if (!device_info[slave_type][i].enable_vio_irq)
|
|
continue;
|
|
|
|
vio_idx = device_info[slave_type][i].vio_index;
|
|
if ((check_vio_status(slave_type, vio_idx) ==
|
|
VIOLATION_TRIGGERED) &&
|
|
clear_vio_status(slave_type, vio_idx)) {
|
|
pr_warn(PFX "%s, %s:0x%x, %s:0x%x, %s:%d\n",
|
|
"clear vio status failed",
|
|
"slave_type", slave_type,
|
|
"vio_index", vio_idx,
|
|
"retry", retry);
|
|
|
|
index = i;
|
|
mtk_devapc_dump_vio_dbg(slave_type, &vio_idx,
|
|
&index);
|
|
|
|
if (--retry)
|
|
i = index - 1;
|
|
else /* reset retry and continue */
|
|
retry = RETRY_COUNT;
|
|
}
|
|
|
|
mask_module_irq(slave_type, vio_idx, false);
|
|
}
|
|
}
|
|
|
|
print_vio_mask_sta(false);
|
|
|
|
/* register subsys test cb */
|
|
register_devapc_vio_callback(&devapc_test_handle);
|
|
|
|
pr_info(PFX "%s done\n", __func__);
|
|
}
|
|
|
|
/*
|
|
* devapc_extra_handler -
|
|
* 1. trigger kernel exception/aee exception/kernel warning to increase devapc
|
|
* violation severity level
|
|
* 2. call subsys handler to get more debug information
|
|
*/
|
|
static void devapc_extra_handler(int slave_type, const char *vio_master,
|
|
uint32_t vio_index, uint32_t vio_addr)
|
|
{
|
|
const struct mtk_device_info **device_info;
|
|
struct mtk_devapc_dbg_status *dbg_stat;
|
|
struct mtk_devapc_vio_info *vio_info;
|
|
struct devapc_vio_callbacks *viocb;
|
|
char dispatch_key[48] = {0};
|
|
enum infra_subsys_id id;
|
|
uint32_t ret_cb = 0;
|
|
|
|
device_info = mtk_devapc_ctx->soc->device_info;
|
|
dbg_stat = mtk_devapc_ctx->soc->dbg_stat;
|
|
vio_info = mtk_devapc_ctx->soc->vio_info;
|
|
|
|
pr_info(PFX "%s:%d\n", "vio_trigger_times",
|
|
mtk_devapc_ctx->soc->vio_info->vio_trigger_times++);
|
|
|
|
/* Dispatch slave owner if APMCU access. Others, dispatch master */
|
|
if (!strncmp(vio_master, "APMCU", 5))
|
|
strncpy(dispatch_key, mtk_devapc_ctx->soc->subsys_get(
|
|
slave_type, vio_index, vio_addr),
|
|
sizeof(dispatch_key) - 1);
|
|
else
|
|
strncpy(dispatch_key, vio_master, sizeof(dispatch_key) - 1);
|
|
|
|
dispatch_key[sizeof(dispatch_key) - 1] = '\0';
|
|
|
|
/* Callback func for vio master */
|
|
if (!strncasecmp(vio_master, "MD", 2)) {
|
|
id = INFRA_SUBSYS_MD;
|
|
strncpy(dispatch_key, "MD", sizeof(dispatch_key) - 1);
|
|
|
|
} else if (!strncasecmp(vio_master, "CONN", 4) ||
|
|
!strncasecmp(dispatch_key, "CONN", 4)) {
|
|
id = INFRA_SUBSYS_CONN;
|
|
strncpy(dispatch_key, "CONNSYS", sizeof(dispatch_key) - 1);
|
|
|
|
} else if (!strncasecmp(vio_master, "TINYSYS", 7)) {
|
|
id = INFRA_SUBSYS_ADSP;
|
|
strncpy(dispatch_key, "TINYSYS", sizeof(dispatch_key) - 1);
|
|
|
|
} else if (!strncasecmp(vio_master, "GCE", 3) ||
|
|
!strncasecmp(dispatch_key, "GCE", 3)) {
|
|
id = INFRA_SUBSYS_GCE;
|
|
strncpy(dispatch_key, "GCE", sizeof(dispatch_key) - 1);
|
|
|
|
} else if (!strncasecmp(vio_master, "AUDIO", 5)) {
|
|
id = INFRA_SUBSYS_AUDIO;
|
|
strncpy(dispatch_key, "AUDIO", sizeof(dispatch_key) - 1);
|
|
|
|
} else if (!strncasecmp(vio_master, "APMCU", 5))
|
|
if (vio_info->domain_id == 0)
|
|
id = INFRA_SUBSYS_APMCU;
|
|
else
|
|
id = INFRA_SUBSYS_GZ;
|
|
else
|
|
id = DEVAPC_SUBSYS_RESERVED;
|
|
|
|
/* enable_ut to test callback */
|
|
if (dbg_stat->enable_ut)
|
|
id = DEVAPC_SUBSYS_TEST;
|
|
|
|
list_for_each_entry(viocb, &viocb_list, list) {
|
|
if (viocb->id == id && viocb->debug_dump)
|
|
viocb->debug_dump();
|
|
|
|
/* call MD cb_adv if it's registered */
|
|
if (viocb->id == id && id == INFRA_SUBSYS_MD &&
|
|
viocb->debug_dump_adv)
|
|
ret_cb = viocb->debug_dump_adv(vio_addr);
|
|
|
|
/* always call clkmgr cb if it's registered */
|
|
if (viocb->id == DEVAPC_SUBSYS_CLKMGR &&
|
|
viocb->debug_dump)
|
|
viocb->debug_dump();
|
|
}
|
|
|
|
/* Severity level */
|
|
if (dbg_stat->enable_KE && (ret_cb != DEVAPC_NOT_KE)) {
|
|
pr_info(PFX "Device APC Violation Issue/%s", dispatch_key);
|
|
BUG_ON(id != INFRA_SUBSYS_CONN);
|
|
|
|
} else if (dbg_stat->enable_AEE) {
|
|
|
|
/* call mtk aee_kernel_exception */
|
|
aee_kernel_exception("[DEVAPC]",
|
|
"%s%s\n",
|
|
"CRDISPATCH_KEY:Device APC Violation Issue/",
|
|
dispatch_key
|
|
);
|
|
|
|
} else if (dbg_stat->enable_WARN) {
|
|
WARN(1, "Device APC Violation Issue/%s", dispatch_key);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* devapc_violation_irq - the devapc Interrupt Service Routine (ISR) will dump
|
|
* violation information including which master violates
|
|
* access slave.
|
|
*/
|
|
static irqreturn_t devapc_violation_irq(int irq_number, void *dev_id)
|
|
{
|
|
uint32_t slave_type_num = mtk_devapc_ctx->soc->slave_type_num;
|
|
const struct mtk_device_info **device_info;
|
|
struct mtk_devapc_vio_info *vio_info;
|
|
int slave_type, vio_idx, index;
|
|
const char *vio_master;
|
|
unsigned long flags;
|
|
uint8_t perm;
|
|
bool normal;
|
|
|
|
spin_lock_irqsave(&devapc_lock, flags);
|
|
|
|
print_vio_mask_sta(false);
|
|
|
|
device_info = mtk_devapc_ctx->soc->device_info;
|
|
vio_info = mtk_devapc_ctx->soc->vio_info;
|
|
normal = false;
|
|
vio_idx = index = -1;
|
|
|
|
/* There are multiple DEVAPC_PD */
|
|
for (slave_type = 0; slave_type < slave_type_num; slave_type++) {
|
|
|
|
if (!check_type2_vio_status(slave_type, &vio_idx, &index))
|
|
if (!mtk_devapc_dump_vio_dbg(slave_type, &vio_idx,
|
|
&index))
|
|
continue;
|
|
|
|
/* Ensure that violation info are written before
|
|
* further operations
|
|
*/
|
|
smp_mb();
|
|
normal = true;
|
|
|
|
mask_module_irq(slave_type, vio_idx, true);
|
|
|
|
if (clear_vio_status(slave_type, vio_idx))
|
|
pr_warn(PFX "%s, %s:0x%x, %s:0x%x\n",
|
|
"clear vio status failed",
|
|
"slave_type", slave_type,
|
|
"vio_index", vio_idx);
|
|
|
|
perm = get_permission(slave_type, index, vio_info->domain_id);
|
|
|
|
vio_master = mtk_devapc_ctx->soc->master_get(
|
|
vio_info->master_id,
|
|
vio_info->vio_addr,
|
|
slave_type,
|
|
vio_info->shift_sta_bit,
|
|
vio_info->domain_id);
|
|
|
|
if (!vio_master) {
|
|
pr_warn(PFX "master_get failed\n");
|
|
vio_master = "UNKNOWN_MASTER";
|
|
}
|
|
|
|
pr_info(PFX "%s - %s:0x%x, %s:0x%x, %s:0x%x, %s:0x%x\n",
|
|
"Violation", "slave_type", slave_type,
|
|
"sys_index",
|
|
device_info[slave_type][index].sys_index,
|
|
"ctrl_index",
|
|
device_info[slave_type][index].ctrl_index,
|
|
"vio_index",
|
|
device_info[slave_type][index].vio_index);
|
|
|
|
pr_info(PFX "%s %s %s %s\n",
|
|
"Violation - master:", vio_master,
|
|
"access violation slave:",
|
|
device_info[slave_type][index].device);
|
|
|
|
devapc_vio_reason(perm);
|
|
|
|
devapc_extra_handler(slave_type, vio_master, vio_idx,
|
|
vio_info->vio_addr);
|
|
|
|
mask_module_irq(slave_type, vio_idx, false);
|
|
}
|
|
|
|
if (normal) {
|
|
spin_unlock_irqrestore(&devapc_lock, flags);
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
/* It's an abnormal status */
|
|
pr_info(PFX "WARNING: Abnormal Status\n");
|
|
print_vio_mask_sta(true);
|
|
BUG_ON(1);
|
|
|
|
spin_unlock_irqrestore(&devapc_lock, flags);
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
void register_devapc_vio_callback(struct devapc_vio_callbacks *viocb)
|
|
{
|
|
INIT_LIST_HEAD(&viocb->list);
|
|
list_add_tail(&viocb->list, &viocb_list);
|
|
}
|
|
EXPORT_SYMBOL(register_devapc_vio_callback);
|
|
|
|
/*
|
|
* devapc_ut - There are two UT commands to support
|
|
* 1. test permission denied violation
|
|
* 2. test sramrom decode error violation
|
|
*/
|
|
static void devapc_ut(uint32_t cmd)
|
|
{
|
|
void __iomem *devapc_ao_base;
|
|
void __iomem *sramrom_base = mtk_devapc_ctx->sramrom_base;
|
|
|
|
pr_info(PFX "%s, cmd:0x%x\n", __func__, cmd);
|
|
|
|
devapc_ao_base = mtk_devapc_ctx->devapc_infra_ao_base;
|
|
|
|
if (cmd == DEVAPC_UT_DAPC_VIO) {
|
|
if (unlikely(devapc_ao_base == NULL)) {
|
|
pr_err(PFX "%s:%d NULL pointer\n", __func__, __LINE__);
|
|
return;
|
|
}
|
|
|
|
pr_info(PFX "%s, devapc_ao_infra_base:0x%x\n", __func__,
|
|
readl(devapc_ao_base));
|
|
|
|
pr_info(PFX "test done, it should generate violation!\n");
|
|
|
|
} else if (cmd == DEVAPC_UT_SRAM_VIO) {
|
|
if (unlikely(sramrom_base == NULL)) {
|
|
pr_info(PFX "%s:%d NULL pointer\n", __func__, __LINE__);
|
|
return;
|
|
}
|
|
|
|
pr_info(PFX "%s, sramrom_base:0x%x\n", __func__,
|
|
readl(sramrom_base + RANDOM_OFFSET));
|
|
|
|
pr_info(PFX "test done, it should generate violation!\n");
|
|
|
|
} else {
|
|
pr_info(PFX "%s, cmd(0x%x) not supported\n", __func__, cmd);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* mtk_devapc_dbg_read - dump status of struct mtk_devapc_dbg_status.
|
|
* Currently, we have 5 debug status:
|
|
* 1. enable_ut: enable/disable devapc ut commands
|
|
* 2~4. enable_KE/enable_AEE/enable_WARN
|
|
* 5. enable_dapc: enable/disable dump access permission control
|
|
*
|
|
*/
|
|
ssize_t mtk_devapc_dbg_read(struct file *file, char __user *buffer,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct mtk_devapc_dbg_status *dbg_stat = mtk_devapc_ctx->soc->dbg_stat;
|
|
struct mtk_devapc_vio_info *vio_info = mtk_devapc_ctx->soc->vio_info;
|
|
char msg_buf[1024] = {0};
|
|
char *p = msg_buf;
|
|
int len;
|
|
|
|
if (unlikely(dbg_stat == NULL) || unlikely(vio_info == NULL)) {
|
|
pr_err(PFX "%s:%d NULL pointer\n", __func__, __LINE__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
devapc_log(p, msg_buf, "DEVAPC debug status:\n");
|
|
devapc_log(p, msg_buf, "\tenable_ut = %d\n", dbg_stat->enable_ut);
|
|
devapc_log(p, msg_buf, "\tenable_KE = %d\n", dbg_stat->enable_KE);
|
|
devapc_log(p, msg_buf, "\tenable_AEE = %d\n", dbg_stat->enable_AEE);
|
|
devapc_log(p, msg_buf, "\tenable_WARN = %d\n", dbg_stat->enable_WARN);
|
|
devapc_log(p, msg_buf, "\tenable_dapc = %d\n", dbg_stat->enable_dapc);
|
|
devapc_log(p, msg_buf, "\tviolation count = %d\n",
|
|
vio_info->vio_trigger_times);
|
|
devapc_log(p, msg_buf, "\n");
|
|
|
|
len = p - msg_buf;
|
|
|
|
return simple_read_from_buffer(buffer, count, ppos, msg_buf, len);
|
|
}
|
|
|
|
/*
|
|
* mtk_devapc_dbg_write - control status of struct mtk_devapc_dbg_status.
|
|
* There are 7 nodes we can control:
|
|
* 1. enable_ut
|
|
* 2~4. enable_KE/enable_AEE/enable_WARN
|
|
* 5. enable_dapc
|
|
* 6. devapc_ut
|
|
* 7. dump_apc
|
|
*/
|
|
ssize_t mtk_devapc_dbg_write(struct file *file, const char __user *buffer,
|
|
size_t count, loff_t *data)
|
|
{
|
|
uint32_t slave_type_num = mtk_devapc_ctx->soc->slave_type_num;
|
|
long param, sys_index, domain, ctrl_index;
|
|
struct mtk_devapc_dbg_status *dbg_stat;
|
|
uint32_t slave_type, apc_set_idx, ret;
|
|
char *parm_str, *cmd_str, *pinput;
|
|
struct arm_smccc_res res;
|
|
char input[32] = {0};
|
|
int err, len;
|
|
|
|
dbg_stat = mtk_devapc_ctx->soc->dbg_stat;
|
|
if (unlikely(dbg_stat == NULL)) {
|
|
pr_err(PFX "%s:%d NULL pointer\n", __func__, __LINE__);
|
|
return -EINVAL;
|
|
}
|
|
|
|
len = (count < (sizeof(input) - 1)) ? count : (sizeof(input) - 1);
|
|
if (copy_from_user(input, buffer, len)) {
|
|
pr_err(PFX "copy from user failed!\n");
|
|
return -EFAULT;
|
|
}
|
|
|
|
input[len] = '\0';
|
|
pinput = input;
|
|
|
|
cmd_str = strsep(&pinput, " ");
|
|
|
|
if (!cmd_str)
|
|
return -EINVAL;
|
|
|
|
parm_str = strsep(&pinput, " ");
|
|
|
|
if (!parm_str)
|
|
return -EINVAL;
|
|
|
|
err = kstrtol(parm_str, 10, ¶m);
|
|
|
|
if (err)
|
|
return err;
|
|
|
|
if (!strncmp(cmd_str, "enable_ut", sizeof("enable_ut"))) {
|
|
dbg_stat->enable_ut = (param != 0);
|
|
pr_info(PFX "debapc_dbg_stat->enable_ut = %s\n",
|
|
dbg_stat->enable_ut ? "enable" : "disable");
|
|
return count;
|
|
|
|
} else if (!strncmp(cmd_str, "devapc_ut", sizeof("devapc_ut"))) {
|
|
if (dbg_stat->enable_ut)
|
|
devapc_ut(param);
|
|
else
|
|
pr_info(PFX "devapc_ut is not enabled\n");
|
|
|
|
return count;
|
|
|
|
} else if (!strncmp(cmd_str, "enable_KE", sizeof("enable_KE"))) {
|
|
if (dbg_stat->enable_ut) {
|
|
dbg_stat->enable_KE = (param != 0);
|
|
pr_info(PFX "debapc_dbg_stat->enable_KE = %s\n",
|
|
dbg_stat->enable_KE ?
|
|
"enable" : "disable");
|
|
} else
|
|
pr_info(PFX "devapc_ut is not enabled\n");
|
|
|
|
return count;
|
|
|
|
} else if (!strncmp(cmd_str, "enable_AEE", sizeof("enable_AEE"))) {
|
|
if (dbg_stat->enable_ut) {
|
|
dbg_stat->enable_AEE = (param != 0);
|
|
pr_info(PFX "debapc_dbg_stat->enable_AEE = %s\n",
|
|
dbg_stat->enable_AEE ?
|
|
"enable" : "disable");
|
|
} else
|
|
pr_info(PFX "devapc_ut is not enabled\n");
|
|
|
|
return count;
|
|
|
|
} else if (!strncmp(cmd_str, "enable_WARN", sizeof("enable_WARN"))) {
|
|
if (dbg_stat->enable_ut) {
|
|
dbg_stat->enable_WARN = (param != 0);
|
|
pr_info(PFX "debapc_dbg_stat->enable_WARN = %s\n",
|
|
dbg_stat->enable_WARN ?
|
|
"enable" : "disable");
|
|
} else
|
|
pr_info(PFX "devapc_ut is not enabled\n");
|
|
|
|
return count;
|
|
|
|
} else if (!strncmp(cmd_str, "enable_dapc", sizeof("enable_dapc"))) {
|
|
dbg_stat->enable_dapc = (param != 0);
|
|
pr_info(PFX "debapc_dbg_stat->enable_dapc = %s\n",
|
|
dbg_stat->enable_dapc ? "enable" : "disable");
|
|
|
|
return count;
|
|
|
|
} else if (!strncmp(cmd_str, "dump_apc", sizeof("dump_apc"))) {
|
|
if (!dbg_stat->enable_dapc) {
|
|
pr_info(PFX "dump_apc is not enabled\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* slave_type is already parse before */
|
|
slave_type = (uint32_t)param;
|
|
|
|
if (slave_type >= slave_type_num) {
|
|
pr_err(PFX "Wrong slave type:0x%x\n", slave_type);
|
|
return -EFAULT;
|
|
}
|
|
|
|
sys_index = 0xFFFFFFFF;
|
|
ctrl_index = 0xFFFFFFFF;
|
|
domain = DOMAIN_OTHERS;
|
|
|
|
/* Parse sys_index */
|
|
parm_str = strsep(&pinput, " ");
|
|
if (parm_str)
|
|
err = kstrtol(parm_str, 10, &sys_index);
|
|
|
|
/* Parse domain id */
|
|
parm_str = strsep(&pinput, " ");
|
|
if (parm_str)
|
|
err = kstrtol(parm_str, 10, &domain);
|
|
|
|
/* Parse ctrl_index */
|
|
parm_str = strsep(&pinput, " ");
|
|
if (parm_str != NULL)
|
|
err = kstrtol(parm_str, 10, &ctrl_index);
|
|
|
|
pr_info(PFX "%s:0x%x, %s:0x%lx, %s:0x%lx, %s:0x%lx\n",
|
|
"slave_type", slave_type,
|
|
"sys_index", sys_index,
|
|
"domain_id", domain,
|
|
"ctrl_index", ctrl_index);
|
|
|
|
arm_smccc_smc(MTK_SIP_KERNEL_DAPC_PERM_GET, slave_type,
|
|
sys_index, domain, ctrl_index, 0, 0, 0, &res);
|
|
ret = res.a0;
|
|
|
|
if (ret == DEAD) {
|
|
pr_err(PFX "%s, SMC call failed, ret: 0x%x\n",
|
|
__func__, ret);
|
|
return -EINVAL;
|
|
}
|
|
|
|
apc_set_idx = ctrl_index % MOD_NO_IN_1_DEVAPC;
|
|
ret = (ret & (0x3 << (apc_set_idx * 2))) >> (apc_set_idx * 2);
|
|
|
|
pr_info(PFX "Permission is %s\n",
|
|
perm_to_string((ret & 0x3)));
|
|
return count;
|
|
} else
|
|
return -EINVAL;
|
|
|
|
return count;
|
|
}
|
|
|
|
static const struct file_operations devapc_dbg_fops = {
|
|
.owner = THIS_MODULE,
|
|
.write = mtk_devapc_dbg_write,
|
|
.read = mtk_devapc_dbg_read,
|
|
};
|
|
|
|
#ifdef CONFIG_DEVAPC_SWP_SUPPORT
|
|
static struct devapc_swp_context {
|
|
void __iomem *devapc_swp_base;
|
|
bool swp_enable;
|
|
bool swp_clr;
|
|
bool swp_rw;
|
|
uint32_t swp_phy_addr;
|
|
uint32_t swp_rg;
|
|
uint32_t swp_wr_val;
|
|
uint32_t swp_wr_mask;
|
|
} devapc_swp_ctx[1];
|
|
|
|
static ssize_t set_swp_addr_show(struct device_driver *driver, char *buf)
|
|
{
|
|
return snprintf(buf, PAGE_SIZE,
|
|
"%s:%s\n\t%s:%s\n\t%s:0x%x\n\t%s:0x%x\n\t%s:0x%x\n\t%s:0x%x\n",
|
|
"devapc_swp",
|
|
devapc_swp_ctx->swp_enable ? "enable" : "disable",
|
|
"swp_rw",
|
|
devapc_swp_ctx->swp_rw ? "write" : "read",
|
|
"swp_physical_addr", devapc_swp_ctx->swp_phy_addr,
|
|
"swp_rg", devapc_swp_ctx->swp_rg,
|
|
"swp_wr_val", devapc_swp_ctx->swp_wr_val,
|
|
"swp_wr_mask", devapc_swp_ctx->swp_wr_mask
|
|
);
|
|
}
|
|
|
|
static ssize_t set_swp_addr_store(struct device_driver *driver,
|
|
const char *buf, size_t count)
|
|
{
|
|
char *cmd_str, *param_str;
|
|
unsigned int param;
|
|
int err;
|
|
|
|
pr_info(PFX "buf: %s", buf);
|
|
|
|
cmd_str = strsep((char **)&buf, " ");
|
|
if (!cmd_str)
|
|
return -EINVAL;
|
|
|
|
param_str = strsep((char **)&buf, " ");
|
|
if (!param_str)
|
|
return -EINVAL;
|
|
|
|
err = kstrtou32(param_str, 16, ¶m);
|
|
if (err)
|
|
return err;
|
|
|
|
if (!strncmp(cmd_str, "enable_swp", sizeof("enable_swp"))) {
|
|
devapc_swp_ctx->swp_enable = (param != 0);
|
|
pr_info(PFX "devapc_swp_enable = %s\n",
|
|
devapc_swp_ctx->swp_enable ? "enable" : "disable");
|
|
|
|
writel(param, devapc_swp_ctx->devapc_swp_base);
|
|
if (!devapc_swp_ctx->swp_enable)
|
|
devapc_swp_ctx->swp_phy_addr = 0x0;
|
|
|
|
} else if (!strncmp(cmd_str, "set_swp_clr", sizeof("set_swp_clr"))) {
|
|
pr_info(PFX "set swp clear: 0x%x\n", param);
|
|
devapc_swp_ctx->swp_clr = (param != 0);
|
|
|
|
if (devapc_swp_ctx->swp_clr)
|
|
writel(0x1 << DEVAPC_SWP_CON_CLEAR,
|
|
devapc_swp_ctx->devapc_swp_base);
|
|
|
|
} else if (!strncmp(cmd_str, "set_swp_rw", sizeof("set_swp_rw"))) {
|
|
pr_info(PFX "set swp r/w: %s\n", param ? "write" : "read");
|
|
devapc_swp_ctx->swp_rw = (param != 0);
|
|
|
|
if (devapc_swp_ctx->swp_rw)
|
|
writel(0x1 << DEVAPC_SWP_CON_RW,
|
|
devapc_swp_ctx->devapc_swp_base);
|
|
|
|
} else if (!strncmp(cmd_str, "set_swp_addr", sizeof("set_swp_addr"))) {
|
|
pr_info(PFX "set swp physical addr: 0x%x\n", param);
|
|
devapc_swp_ctx->swp_phy_addr = param;
|
|
|
|
writel(devapc_swp_ctx->swp_phy_addr,
|
|
devapc_swp_ctx->devapc_swp_base + DEVAPC_SWP_SA_OFFSET);
|
|
|
|
} else if (!strncmp(cmd_str, "set_swp_rg", sizeof("set_swp_rg"))) {
|
|
pr_info(PFX "set swp range: 0x%x\n", param);
|
|
devapc_swp_ctx->swp_rg = param;
|
|
|
|
writel(devapc_swp_ctx->swp_rg,
|
|
devapc_swp_ctx->devapc_swp_base + DEVAPC_SWP_RG_OFFSET);
|
|
|
|
} else if (!strncmp(cmd_str, "set_swp_wr_val",
|
|
sizeof("set_swp_wr_val"))) {
|
|
pr_info(PFX "set swp write value: 0x%x\n", param);
|
|
devapc_swp_ctx->swp_wr_val = param;
|
|
|
|
writel(devapc_swp_ctx->swp_wr_val,
|
|
devapc_swp_ctx->devapc_swp_base +
|
|
DEVAPC_SWP_WR_VAL_OFFSET);
|
|
|
|
} else if (!strncmp(cmd_str, "set_swp_wr_mask",
|
|
sizeof("set_swp_wr_mask"))) {
|
|
pr_info(PFX "set swp write mask: 0x%x\n", param);
|
|
devapc_swp_ctx->swp_wr_mask = param;
|
|
|
|
writel(devapc_swp_ctx->swp_wr_mask,
|
|
devapc_swp_ctx->devapc_swp_base +
|
|
DEVAPC_SWP_WR_MASK_OFFSET);
|
|
|
|
} else
|
|
return -EINVAL;
|
|
|
|
return count;
|
|
}
|
|
static DRIVER_ATTR_RW(set_swp_addr);
|
|
#endif /* CONFIG_DEVAPC_SWP_SUPPORT */
|
|
|
|
int mtk_devapc_probe(struct platform_device *pdev,
|
|
struct mtk_devapc_soc *soc)
|
|
{
|
|
struct device_node *node = pdev->dev.of_node;
|
|
uint32_t slave_type_num;
|
|
int slave_type;
|
|
int ret;
|
|
|
|
pr_info(PFX "driver registered\n");
|
|
|
|
if (IS_ERR(node)) {
|
|
pr_err(PFX "cannot find device node\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
mtk_devapc_ctx->soc = soc;
|
|
slave_type_num = mtk_devapc_ctx->soc->slave_type_num;
|
|
|
|
for (slave_type = 0; slave_type < slave_type_num; slave_type++) {
|
|
mtk_devapc_ctx->devapc_pd_base[slave_type] = of_iomap(node,
|
|
slave_type);
|
|
if (unlikely(mtk_devapc_ctx->devapc_pd_base[slave_type]
|
|
== NULL)) {
|
|
pr_err(PFX "parse devapc_pd_base:0x%x failed\n",
|
|
slave_type);
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
mtk_devapc_ctx->devapc_infra_ao_base = of_iomap(node, slave_type_num);
|
|
if (unlikely(mtk_devapc_ctx->devapc_infra_ao_base == NULL)) {
|
|
pr_err(PFX "parse devapc_infra_ao_base failed\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
mtk_devapc_ctx->infracfg_base = of_iomap(node, slave_type_num + 1);
|
|
if (unlikely(mtk_devapc_ctx->infracfg_base == NULL)) {
|
|
pr_err(PFX "parse infracfg_base failed\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
mtk_devapc_ctx->devapc_irq = irq_of_parse_and_map(node, 0);
|
|
if (!mtk_devapc_ctx->devapc_irq) {
|
|
pr_err(PFX "parse and map the interrupt failed\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
for (slave_type = 0; slave_type < slave_type_num; slave_type++)
|
|
pr_debug(PFX "%s:0x%x %s:0x%px\n",
|
|
"slave_type", slave_type,
|
|
"devapc_pd_base",
|
|
mtk_devapc_ctx->devapc_pd_base[slave_type]);
|
|
|
|
pr_debug(PFX " IRQ:%d\n", mtk_devapc_ctx->devapc_irq);
|
|
|
|
/* CCF (Common Clock Framework) */
|
|
mtk_devapc_ctx->devapc_infra_clk = devm_clk_get(&pdev->dev,
|
|
"devapc-infra-clock");
|
|
|
|
if (IS_ERR(mtk_devapc_ctx->devapc_infra_clk))
|
|
pr_info(PFX "(Infra) Cannot get devapc clock from CCF (%d)\n",
|
|
PTR_ERR(mtk_devapc_ctx->devapc_infra_clk));
|
|
|
|
proc_create("devapc_dbg", 0664, NULL, &devapc_dbg_fops);
|
|
|
|
#ifdef CONFIG_DEVAPC_SWP_SUPPORT
|
|
devapc_swp_ctx->devapc_swp_base = of_iomap(node, slave_type_num + 2);
|
|
ret = driver_create_file(pdev->dev.driver,
|
|
&driver_attr_set_swp_addr);
|
|
if (ret)
|
|
pr_info(PFX "create SWP sysfs file failed, ret:%d\n", ret);
|
|
#endif
|
|
|
|
mtk_devapc_ctx->sramrom_base = of_iomap(node, slave_type_num + 3);
|
|
if (unlikely(mtk_devapc_ctx->sramrom_base == NULL))
|
|
pr_info(PFX "parse sramrom_base failed\n");
|
|
|
|
if (!IS_ERR(mtk_devapc_ctx->devapc_infra_clk)) {
|
|
if (clk_prepare_enable(mtk_devapc_ctx->devapc_infra_clk)) {
|
|
pr_err(PFX " Cannot enable devapc clock\n");
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
start_devapc();
|
|
|
|
ret = devm_request_irq(&pdev->dev, mtk_devapc_ctx->devapc_irq,
|
|
(irq_handler_t)devapc_violation_irq,
|
|
IRQF_TRIGGER_NONE, "devapc", NULL);
|
|
if (ret) {
|
|
pr_err(PFX "request devapc irq failed, ret:%d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(mtk_devapc_probe);
|
|
|
|
int mtk_devapc_remove(struct platform_device *dev)
|
|
{
|
|
if (!IS_ERR(mtk_devapc_ctx->devapc_infra_clk))
|
|
clk_disable_unprepare(mtk_devapc_ctx->devapc_infra_clk);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(mtk_devapc_remove);
|
|
|
|
MODULE_DESCRIPTION("Mediatek Device APC Driver");
|
|
MODULE_AUTHOR("Neal Liu <neal.liu@mediatek.com>");
|
|
MODULE_LICENSE("GPL");
|