mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-16 07:24:39 +08:00
48840e16c2
On High-Security(HS) OMAP2+ class devices a couple actions must be performed from the ARM TrustZone during boot. These traditionally can be performed by calling into the secure ROM code resident in this secure world using legacy SMC calls. Optionally OP-TEE can replace this secure world functionality by replacing the ROM after boot. ARM recommends a standard calling convention is used for this interaction (SMC Calling Convention). We check for the presence of OP-TEE and use this type of call to perform the needed actions, falling back to the legacy OMAP ROM call if OP-TEE is not available. Signed-off-by: Andrew F. Davis <afd@ti.com> Reviewed-by: Lokesh Vutla <lokeshvutla@ti.com> Signed-off-by: Tony Lindgren <tony@atomide.com>
216 lines
5.0 KiB
C
216 lines
5.0 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* OMAP Secure API infrastructure.
|
|
*
|
|
* Copyright (C) 2011 Texas Instruments, Inc.
|
|
* Santosh Shilimkar <santosh.shilimkar@ti.com>
|
|
* Copyright (C) 2012 Ivaylo Dimitrov <freemangordon@abv.bg>
|
|
* Copyright (C) 2013 Pali Rohár <pali.rohar@gmail.com>
|
|
*/
|
|
|
|
#include <linux/arm-smccc.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/init.h>
|
|
#include <linux/io.h>
|
|
#include <linux/memblock.h>
|
|
#include <linux/of.h>
|
|
|
|
#include <asm/cacheflush.h>
|
|
#include <asm/memblock.h>
|
|
|
|
#include "common.h"
|
|
#include "omap-secure.h"
|
|
|
|
static phys_addr_t omap_secure_memblock_base;
|
|
|
|
bool optee_available;
|
|
|
|
#define OMAP_SIP_SMC_STD_CALL_VAL(func_num) \
|
|
ARM_SMCCC_CALL_VAL(ARM_SMCCC_STD_CALL, ARM_SMCCC_SMC_32, \
|
|
ARM_SMCCC_OWNER_SIP, (func_num))
|
|
|
|
static void __init omap_optee_init_check(void)
|
|
{
|
|
struct device_node *np;
|
|
|
|
/*
|
|
* We only check that the OP-TEE node is present and available. The
|
|
* OP-TEE kernel driver is not needed for the type of interaction made
|
|
* with OP-TEE here so the driver's status is not checked.
|
|
*/
|
|
np = of_find_node_by_path("/firmware/optee");
|
|
if (np && of_device_is_available(np))
|
|
optee_available = true;
|
|
of_node_put(np);
|
|
}
|
|
|
|
/**
|
|
* omap_sec_dispatcher: Routine to dispatch low power secure
|
|
* service routines
|
|
* @idx: The HAL API index
|
|
* @flag: The flag indicating criticality of operation
|
|
* @nargs: Number of valid arguments out of four.
|
|
* @arg1, arg2, arg3 args4: Parameters passed to secure API
|
|
*
|
|
* Return the non-zero error value on failure.
|
|
*/
|
|
u32 omap_secure_dispatcher(u32 idx, u32 flag, u32 nargs, u32 arg1, u32 arg2,
|
|
u32 arg3, u32 arg4)
|
|
{
|
|
u32 ret;
|
|
u32 param[5];
|
|
|
|
param[0] = nargs;
|
|
param[1] = arg1;
|
|
param[2] = arg2;
|
|
param[3] = arg3;
|
|
param[4] = arg4;
|
|
|
|
/*
|
|
* Secure API needs physical address
|
|
* pointer for the parameters
|
|
*/
|
|
flush_cache_all();
|
|
outer_clean_range(__pa(param), __pa(param + 5));
|
|
ret = omap_smc2(idx, flag, __pa(param));
|
|
|
|
return ret;
|
|
}
|
|
|
|
void omap_smccc_smc(u32 fn, u32 arg)
|
|
{
|
|
struct arm_smccc_res res;
|
|
|
|
arm_smccc_smc(OMAP_SIP_SMC_STD_CALL_VAL(fn), arg,
|
|
0, 0, 0, 0, 0, 0, &res);
|
|
WARN(res.a0, "Secure function call 0x%08x failed\n", fn);
|
|
}
|
|
|
|
void omap_smc1(u32 fn, u32 arg)
|
|
{
|
|
/*
|
|
* If this platform has OP-TEE installed we use ARM SMC calls
|
|
* otherwise fall back to the OMAP ROM style calls.
|
|
*/
|
|
if (optee_available)
|
|
omap_smccc_smc(fn, arg);
|
|
else
|
|
_omap_smc1(fn, arg);
|
|
}
|
|
|
|
/* Allocate the memory to save secure ram */
|
|
int __init omap_secure_ram_reserve_memblock(void)
|
|
{
|
|
u32 size = OMAP_SECURE_RAM_STORAGE;
|
|
|
|
size = ALIGN(size, SECTION_SIZE);
|
|
omap_secure_memblock_base = arm_memblock_steal(size, SECTION_SIZE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
phys_addr_t omap_secure_ram_mempool_base(void)
|
|
{
|
|
return omap_secure_memblock_base;
|
|
}
|
|
|
|
#if defined(CONFIG_ARCH_OMAP3) && defined(CONFIG_PM)
|
|
u32 omap3_save_secure_ram(void __iomem *addr, int size)
|
|
{
|
|
u32 ret;
|
|
u32 param[5];
|
|
|
|
if (size != OMAP3_SAVE_SECURE_RAM_SZ)
|
|
return OMAP3_SAVE_SECURE_RAM_SZ;
|
|
|
|
param[0] = 4; /* Number of arguments */
|
|
param[1] = __pa(addr); /* Physical address for saving */
|
|
param[2] = 0;
|
|
param[3] = 1;
|
|
param[4] = 1;
|
|
|
|
ret = save_secure_ram_context(__pa(param));
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* rx51_secure_dispatcher: Routine to dispatch secure PPA API calls
|
|
* @idx: The PPA API index
|
|
* @process: Process ID
|
|
* @flag: The flag indicating criticality of operation
|
|
* @nargs: Number of valid arguments out of four.
|
|
* @arg1, arg2, arg3 args4: Parameters passed to secure API
|
|
*
|
|
* Return the non-zero error value on failure.
|
|
*
|
|
* NOTE: rx51_secure_dispatcher differs from omap_secure_dispatcher because
|
|
* it calling omap_smc3() instead omap_smc2() and param[0] is nargs+1
|
|
*/
|
|
u32 rx51_secure_dispatcher(u32 idx, u32 process, u32 flag, u32 nargs,
|
|
u32 arg1, u32 arg2, u32 arg3, u32 arg4)
|
|
{
|
|
u32 ret;
|
|
u32 param[5];
|
|
|
|
param[0] = nargs+1; /* RX-51 needs number of arguments + 1 */
|
|
param[1] = arg1;
|
|
param[2] = arg2;
|
|
param[3] = arg3;
|
|
param[4] = arg4;
|
|
|
|
/*
|
|
* Secure API needs physical address
|
|
* pointer for the parameters
|
|
*/
|
|
local_irq_disable();
|
|
local_fiq_disable();
|
|
flush_cache_all();
|
|
outer_clean_range(__pa(param), __pa(param + 5));
|
|
ret = omap_smc3(idx, process, flag, __pa(param));
|
|
flush_cache_all();
|
|
local_fiq_enable();
|
|
local_irq_enable();
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* rx51_secure_update_aux_cr: Routine to modify the contents of Auxiliary Control Register
|
|
* @set_bits: bits to set in ACR
|
|
* @clr_bits: bits to clear in ACR
|
|
*
|
|
* Return the non-zero error value on failure.
|
|
*/
|
|
u32 rx51_secure_update_aux_cr(u32 set_bits, u32 clear_bits)
|
|
{
|
|
u32 acr;
|
|
|
|
/* Read ACR */
|
|
asm volatile ("mrc p15, 0, %0, c1, c0, 1" : "=r" (acr));
|
|
acr &= ~clear_bits;
|
|
acr |= set_bits;
|
|
|
|
return rx51_secure_dispatcher(RX51_PPA_WRITE_ACR,
|
|
0,
|
|
FLAG_START_CRITICAL,
|
|
1, acr, 0, 0, 0);
|
|
}
|
|
|
|
/**
|
|
* rx51_secure_rng_call: Routine for HW random generator
|
|
*/
|
|
u32 rx51_secure_rng_call(u32 ptr, u32 count, u32 flag)
|
|
{
|
|
return rx51_secure_dispatcher(RX51_PPA_HWRNG,
|
|
0,
|
|
NO_FLAG,
|
|
3, ptr, count, flag, 0);
|
|
}
|
|
|
|
void __init omap_secure_init(void)
|
|
{
|
|
omap_optee_init_check();
|
|
}
|