kernel_samsung_a34x-permissive/drivers/misc/mediatek/iommu/m4u_secure.c

645 lines
13 KiB
C
Raw Normal View History

// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2019 MediaTek Inc.
*/
#define pr_fmt(fmt) "[M4U] " fmt
#include <linux/notifier.h>
#include <linux/fb.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/of_platform.h>
#include <linux/proc_fs.h>
#include <linux/slab.h>
#include <linux/debugfs.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/arm-smccc.h>
#include <linux/soc/mediatek/mtk_sip_svc.h>
#include <linux/pm_runtime.h>
#include "m4u_secure.h"
#if defined(CONFIG_TRUSTONIC_TEE_SUPPORT)
#include "mobicore_driver_api.h"
#endif
static struct m4u_device *m4u_dev;
static unsigned long m4u_mm_base;
static unsigned int m4u_dev_irq[SECURE_BANK_NUM];
int M4U_L2_ENABLE = 1;
static unsigned long mtk_m4u_get_pt(void);
#ifdef M4U_TEE_SERVICE_ENABLE
static DEFINE_MUTEX(gM4u_sec_init);
bool m4u_tee_en;
static struct m4u_sec_gp_context m4u_gp_ta_ctx = {
.uuid = (struct TEEC_UUID)M4U_TA_UUID,
.ctx_lock = __MUTEX_INITIALIZER(m4u_gp_ta_ctx.ctx_lock),
.ctx_type = CTX_TYPE_TA,
};
struct m4u_sec_context m4u_ta_ctx;
void m4u_sec_set_context(void)
{
m4u_ta_ctx.name = "m4u_ta";
m4u_ta_ctx.imp = &m4u_gp_ta_ctx;
}
static int m4u_exec_session(struct m4u_sec_context *ctx)
{
int ret;
struct TEEC_Operation m4u_operation;
struct m4u_sec_gp_context *gp_ctx = ctx->imp;
if (!ctx->m4u_msg) {
pr_err("%s TCI/DCI error\n", __func__);
return -1;
}
pr_info("%s, Notify 0x%x\n", __func__, ctx->m4u_msg->cmd);
memset(&m4u_operation, 0, sizeof(struct TEEC_Operation));
m4u_operation.paramTypes = TEEC_PARAM_TYPES(
TEEC_MEMREF_PARTIAL_INPUT, TEEC_NONE, TEEC_NONE, TEEC_NONE);
m4u_operation.params[0].memref.parent = &gp_ctx->shared_mem;
m4u_operation.params[0].memref.offset = 0;
m4u_operation.params[0].memref.size = gp_ctx->shared_mem.size;
ret = TEEC_InvokeCommand(&gp_ctx->session,
ctx->m4u_msg->cmd, &m4u_operation, NULL);
if (ret != TEEC_SUCCESS) {
pr_err("tz_m4u Notify failed: %d\n", ret);
goto exit;
}
pr_info("%s, get_resp %x\n", __func__, ctx->m4u_msg->cmd);
exit:
return ret;
}
static int m4u_sec_gp_init(struct m4u_sec_context *ctx)
{
int ret;
struct m4u_sec_gp_context *gp_ctx = ctx->imp;
ret = TEEC_InitializeContext(TA_UUID, &gp_ctx->ctx);
if (ret != TEEC_SUCCESS) {
pr_err("teec_initialize_context failed: %x\n", ret);
return ret;
}
pr_info("%s, ta teec_initialize_context\n", __func__);
memset(&gp_ctx->shared_mem, 0, sizeof(struct TEEC_SharedMemory));
gp_ctx->shared_mem.size = sizeof(struct m4u_msg);
gp_ctx->shared_mem.flags = TEEC_MEM_INPUT;
ret = TEEC_AllocateSharedMemory(&gp_ctx->ctx, &gp_ctx->shared_mem);
if (ret == TEEC_SUCCESS) {
ctx->m4u_msg = (struct m4u_msg *)gp_ctx->shared_mem.buffer;
pr_info("teec_allocate_shared_memory buf: 0x%p\n",
gp_ctx->shared_mem.buffer);
} else {
pr_err("teec_allocate_shared_memory failed: %d\n", ret);
goto exit_finalize;
}
if (!ctx->m4u_msg) {
pr_err("m4u msg is invalid\n");
return -1;
}
if (!gp_ctx->init) {
ret = TEEC_OpenSession(&gp_ctx->ctx, &gp_ctx->session,
&gp_ctx->uuid, TEEC_LOGIN_PUBLIC, NULL, NULL, NULL);
if (ret != TEEC_SUCCESS) {
pr_err("teec_open_session failed: %x\n", ret);
goto exit_release;
}
gp_ctx->init = 1;
}
pr_info("%s, open TCI session success\n", __func__);
return ret;
exit_release:
TEEC_ReleaseSharedMemory(&gp_ctx->shared_mem);
exit_finalize:
TEEC_FinalizeContext(&gp_ctx->ctx);
return ret;
}
static int m4u_sec_gp_deinit(struct m4u_sec_context *ctx)
{
struct m4u_sec_gp_context *gp_ctx = ctx->imp;
TEEC_ReleaseSharedMemory(&gp_ctx->shared_mem);
TEEC_CloseSession(&gp_ctx->session);
TEEC_FinalizeContext(&gp_ctx->ctx);
gp_ctx->init = 0;
return 0;
}
static int m4u_sec_ta_open(void)
{
return m4u_sec_gp_init(&m4u_ta_ctx);
}
static int m4u_sec_ta_close(void)
{
return m4u_sec_gp_deinit(&m4u_ta_ctx);
}
int m4u_sec_context_init(void)
{
return m4u_sec_ta_open();
}
int m4u_sec_context_deinit(void)
{
return m4u_sec_ta_close();
}
struct m4u_sec_context *m4u_sec_ctx_get(unsigned int cmd)
{
struct m4u_sec_context *ctx = NULL;
struct m4u_sec_gp_context *gp_ctx;
ctx = &m4u_ta_ctx;
gp_ctx = ctx->imp;
if (!gp_ctx->init) {
pr_err("%s: before init\n", __func__);
return NULL;
}
mutex_lock(&gp_ctx->ctx_lock);
return ctx;
}
int m4u_sec_ctx_put(struct m4u_sec_context *ctx)
{
struct m4u_sec_gp_context *gp_ctx = ctx->imp;
mutex_unlock(&gp_ctx->ctx_lock);
return 0;
}
int m4u_exec_cmd(struct m4u_sec_context *ctx)
{
int ret;
if (ctx->m4u_msg == NULL) {
pr_err("%s TCI/DCI error\n", __func__);
return -1;
}
ret = m4u_exec_session(ctx);
if (ret < 0)
return -1;
return 0;
}
static int __m4u_sec_init(void)
{
int ret;
struct m4u_sec_context *ctx;
unsigned long pt_pa_nonsec = mtk_m4u_get_pt();
ctx = m4u_sec_ctx_get(CMD_M4UTL_INIT);
if (!ctx)
return -EFAULT;
pm_runtime_get_sync(m4u_dev->dev);
ctx->m4u_msg->cmd = CMD_M4UTL_INIT;
ctx->m4u_msg->init_param.nonsec_pt_pa = pt_pa_nonsec;
ctx->m4u_msg->init_param.l2_en = M4U_L2_ENABLE;
ctx->m4u_msg->init_param.sec_pt_pa = 0;
pr_info("%s call CMD_M4UTL_INIT, nonsec_pt_pa: 0x%lx\n",
__func__, pt_pa_nonsec);
ret = m4u_exec_cmd(ctx);
if (ret) {
pr_err("m4u exec command fail\n");
goto out;
}
ret = ctx->m4u_msg->rsp;
out:
pm_runtime_put_sync(m4u_dev->dev);
m4u_sec_ctx_put(ctx);
return ret;
}
int m4u_sec_init(void)
{
int ret;
pr_info("%s: start\n", __func__);
if (m4u_tee_en) {
pr_info("warning: re-initiation, %d\n", m4u_tee_en);
goto m4u_sec_reinit;
}
m4u_sec_set_context();
if (!m4u_tee_en) {
ret = m4u_sec_context_init();
if (ret)
return ret;
m4u_tee_en = 1;
} else {
pr_warn("[M4U] warning: reinit sec m4u en=%d\n", m4u_tee_en);
}
m4u_sec_reinit:
ret = __m4u_sec_init();
if (ret < 0) {
m4u_tee_en = 0;
m4u_sec_context_deinit();
pr_err("%s:init fail,ret=0x%x\n", __func__, ret);
return ret;
}
/* don't deinit ta because of multiple init operation */
pr_info("%s:normal init done\n", __func__);
return 0;
}
/*#ifdef TO_BE_IMPL*/
int m4u_larb_backup_sec(unsigned int larb_idx)
{
int ret;
struct m4u_sec_context *ctx;
ctx = m4u_sec_ctx_get(CMD_M4U_LARB_BACKUP);
if (!ctx)
return -EFAULT;
ctx->m4u_msg->cmd = CMD_M4U_LARB_BACKUP;
ctx->m4u_msg->larb_param.larb_idx = larb_idx;
ret = m4u_exec_cmd(ctx);
if (ret) {
pr_err("m4u exec command fail\n");
ret = -1;
goto out;
}
ret = ctx->m4u_msg->rsp;
out:
m4u_sec_ctx_put(ctx);
return ret;
}
int m4u_larb_restore_sec(unsigned int larb_idx)
{
int ret;
struct m4u_sec_context *ctx;
ctx = m4u_sec_ctx_get(CMD_M4U_LARB_RESTORE);
if (!ctx)
return -EFAULT;
ctx->m4u_msg->cmd = CMD_M4U_LARB_RESTORE;
ctx->m4u_msg->larb_param.larb_idx = larb_idx;
ret = m4u_exec_cmd(ctx);
if (ret) {
pr_err("m4u exec command fail\n");
ret = -1;
goto out;
}
ret = ctx->m4u_msg->rsp;
out:
m4u_sec_ctx_put(ctx);
return ret;
}
static int m4u_reg_backup_sec(void)
{
int ret;
struct m4u_sec_context *ctx;
ctx = m4u_sec_ctx_get(CMD_M4U_REG_BACKUP);
if (!ctx)
return -EFAULT;
ctx->m4u_msg->cmd = CMD_M4U_REG_BACKUP;
ret = m4u_exec_cmd(ctx);
if (ret) {
pr_err("m4u exec command fail\n");
ret = -1;
goto out;
}
ret = ctx->m4u_msg->rsp;
out:
m4u_sec_ctx_put(ctx);
return ret;
}
static int m4u_reg_restore_sec(void)
{
int ret;
struct m4u_sec_context *ctx;
ctx = m4u_sec_ctx_get(CMD_M4U_REG_RESTORE);
if (!ctx)
return -EFAULT;
ctx->m4u_msg->cmd = CMD_M4U_REG_RESTORE;
ret = m4u_exec_cmd(ctx);
if (ret) {
pr_err("m4u exec command fail\n");
ret = -1;
goto out;
}
ret = ctx->m4u_msg->rsp;
out:
m4u_sec_ctx_put(ctx);
return ret;
}
static void m4u_early_suspend(void)
{
pr_info("%s +, %d\n", __func__, m4u_tee_en);
if (m4u_tee_en)
m4u_reg_backup_sec();
pr_info("%s -\n", __func__);
}
static void m4u_late_resume(void)
{
pr_info("%s +, %d\n", __func__, m4u_tee_en);
if (m4u_tee_en)
m4u_reg_restore_sec();
pr_info("%s -\n", __func__);
}
static struct notifier_block m4u_fb_notifier;
static int m4u_fb_notifier_callback(
struct notifier_block *self, unsigned long event, void *data)
{
struct fb_event *evdata = data;
int blank;
pr_info("%s %ld, %d\n", __func__, event, FB_EVENT_BLANK);
if (event != FB_EVENT_BLANK)
return 0;
blank = *(int *)evdata->data;
switch (blank) {
case FB_BLANK_UNBLANK:
case FB_BLANK_NORMAL:
m4u_late_resume();
break;
case FB_BLANK_VSYNC_SUSPEND:
case FB_BLANK_HSYNC_SUSPEND:
break;
case FB_BLANK_POWERDOWN:
m4u_early_suspend();
break;
default:
return -EINVAL;
}
return 0;
}
#endif
irqreturn_t mtk_m4u_isr_sec(int irq, void *dev_id)
{
struct arm_smccc_res res;
unsigned long tf_en = 0;
unsigned long tf_port = 0;
unsigned long m4u_id = 0;
if (irq == m4u_dev_irq[0]) {
m4u_id = 0;
pr_info("This is secure MM_IOMMU domian\n");
} else if (irq == m4u_dev_irq[1]) {
m4u_id = 1;
pr_info("This is secure VPU_IOMMU domian\n");
} else {
pr_err("%s(), Invalid secure irq number %d\n", __func__, irq);
return -1;
}
pr_info("secure bank irq in normal world!\n");
arm_smccc_smc(MTK_M4U_DEBUG_DUMP, m4u_id, 0, 0,
0, 0, 0, 0, &res);
tf_en = res.a0;
tf_port = res.a1;
pr_warn("secure bank go back form secure world! en:%zu, fault_id:0x%lx\n",
tf_en, tf_port);
return IRQ_HANDLED;
}
static unsigned long mtk_m4u_get_pt(void)
{
unsigned long reval;
reval = readl_relaxed((void *)m4u_mm_base + REG_MMU_PT_BASE_ADDR);
if (reval & F_PGD_REG_BIT32)
reval |= BIT_ULL(32);
if (reval & F_PGD_REG_BIT33)
reval |= BIT_ULL(33);
pr_info("get pt: 0x%lx\n", reval);
return reval;
}
static int m4u_open(struct inode *inode, struct file *file)
{
pr_info("%s process : %s\n", __func__, current->comm);
return 0;
}
static int m4u_release(struct inode *inode, struct file *file)
{
pr_info("%s process : %s\n", __func__, current->comm);
return 0;
}
static long m4u_ioctl(struct file *filp,
unsigned int cmd, unsigned long arg)
{
int ret = 0;
switch (cmd) {
#ifdef M4U_TEE_SERVICE_ENABLE
case MTK_M4U_T_SEC_INIT:
{
pr_info("MTK M4U ioctl : MTK_M4U_T_SEC_INIT command!! 0x%x\n",
cmd);
mutex_lock(&gM4u_sec_init);
ret = m4u_sec_init();
mutex_unlock(&gM4u_sec_init);
}
break;
#endif
default:
pr_err("MTK M4U ioctl:No such command(0x%x)!!\n", cmd);
ret = -EINVAL;
break;
}
return ret;
}
#if IS_ENABLED(CONFIG_COMPAT)
static long m4u_compat_ioctl(struct file *filp,
unsigned int cmd, unsigned long arg)
{
long ret;
if (!filp->f_op || !filp->f_op->unlocked_ioctl)
return -ENOTTY;
switch (cmd) {
#ifdef M4U_TEE_SERVICE_ENABLE
case COMPAT_MTK_M4U_T_SEC_INIT:
{
pr_info("MTK_M4U_T_SEC_INIT command!! 0x%x\n",
cmd);
mutex_lock(&gM4u_sec_init);
ret = m4u_sec_init();
mutex_unlock(&gM4u_sec_init);
}
break;
#endif
default:
pr_err("compat ioctl:No such command(0x%x)!!\n", cmd);
ret = -ENOIOCTLCMD;
break;
}
return ret;
}
#else
#define m4u_compat_ioctl NULL
#endif
static const struct file_operations m4u_fops = {
.owner = THIS_MODULE,
.open = m4u_open,
.release = m4u_release,
.unlocked_ioctl = m4u_ioctl,
.compat_ioctl = m4u_compat_ioctl,
};
static int m4u_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct device_node *node = pdev->dev.of_node;
int i, ret;
struct device_node *mm_m4unode = NULL;
struct platform_device *plarbdev;
mm_m4unode = of_parse_phandle(dev->of_node, "mediatek,mm_m4u", 0);
if (!mm_m4unode) {
pr_err("not find mm m4u dts\n");
return -EINVAL;
}
plarbdev = of_find_device_by_node(mm_m4unode);
if (!plarbdev || !plarbdev->dev.driver) {
pr_info("mm m4u not ready!\n");
return -EPROBE_DEFER;
}
m4u_dev = kzalloc(sizeof(struct m4u_device), GFP_KERNEL);
if (!m4u_dev)
return -ENOMEM;
m4u_dev->dev = dev;
m4u_dev->m4u_dev_proc_entry = proc_create("m4u", 0644, NULL,
&m4u_fops);
if (!m4u_dev->m4u_dev_proc_entry) {
pr_err("proc m4u create error\n");
kfree(m4u_dev);
return -ENODEV;
}
m4u_mm_base = (unsigned long)of_iomap(mm_m4unode, 0);
dev_info(m4u_dev->dev, "mm m4u base:0x%lx\n", m4u_mm_base);
for (i = MM_SECURE_BANK; i < SECURE_BANK_NUM; i++) {
m4u_dev_irq[i] = irq_of_parse_and_map(node, i);
dev_info(m4u_dev->dev, "secure irq:%u, id:%d\n",
m4u_dev_irq[i], i);
if (request_irq(m4u_dev_irq[i], mtk_m4u_isr_sec,
IRQF_TRIGGER_NONE, "secure_m4u", NULL)) {
pr_err("request secure m4u%d IRQ line failed\n",
i);
return -ENODEV;
}
}
#ifdef M4U_TEE_SERVICE_ENABLE
m4u_fb_notifier.notifier_call = m4u_fb_notifier_callback;
ret = fb_register_client(&m4u_fb_notifier);
if (ret)
dev_err(m4u_dev->dev, "register fb_notifier failed!\n");
else
dev_info(m4u_dev->dev, "register fb_notifier OK!\n");
#endif
dev_info(m4u_dev->dev, "%s done\n", __func__);
return 0;
}
static int m4u_remove(struct platform_device *pdev)
{
if (m4u_dev->m4u_dev_proc_entry)
proc_remove(m4u_dev->m4u_dev_proc_entry);
return 0;
}
static const struct of_device_id mtk_m4u_sec_of_ids[] = {
{ .compatible = "mediatek,secure_m4u",},
{}
};
static struct platform_driver mtk_m4u_sec_driver = {
.probe = m4u_probe,
.remove = m4u_remove,
.driver = {
.name = M4U_DEVNAME,
.of_match_table = of_match_ptr(mtk_m4u_sec_of_ids),
.owner = THIS_MODULE,
}
};
module_platform_driver(mtk_m4u_sec_driver);