aubrey/kernel_samsung_a34x-permissive
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity
kernel_samsung_a34x-permissive/drivers/soc/mediatek/devapc/devapc-mtk-multi-ao.c

1447 lines
39 KiB
C
Raw Permalink Normal View History

Import A346BXXU1AWB9 kernel source Android 13
2024-04-28 06:49:01 -07:00
// 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, &param);
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, &param);
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");
Reference in a new issue Copy permalink