1 // SPDX-License-Identifier: GPL-2.0+
4 * Common security related functions for OMAP devices
6 * (C) Copyright 2016-2017
7 * Texas Instruments, <www.ti.com>
9 * Daniel Allred <d-allred@ti.com>
10 * Andreas Dannenberg <dannenberg@ti.com>
11 * Harinarayan Bhatta <harinarayan@ti.com>
12 * Andrew F. Davis <afd@ti.com>
22 #include <asm/arch/sys_proto.h>
23 #include <asm/cache.h>
24 #include <asm/omap_common.h>
25 #include <asm/omap_sec_common.h>
27 #include <asm/ti-common/sys_proto.h>
30 #include <tee/optee.h>
32 /* Index for signature verify ROM API */
34 #define API_HAL_KM_VERIFYCERTIFICATESIGNATURE_INDEX (0x0000000C)
36 #define API_HAL_KM_VERIFYCERTIFICATESIGNATURE_INDEX (0x0000000E)
39 /* Index for signature PPA-based TI HAL APIs */
40 #define PPA_HAL_SERVICES_START_INDEX (0x200)
41 #define PPA_SERV_HAL_TEE_LOAD_MASTER (PPA_HAL_SERVICES_START_INDEX + 23)
42 #define PPA_SERV_HAL_TEE_LOAD_SLAVE (PPA_HAL_SERVICES_START_INDEX + 24)
43 #define PPA_SERV_HAL_SETUP_SEC_RESVD_REGION (PPA_HAL_SERVICES_START_INDEX + 25)
44 #define PPA_SERV_HAL_SETUP_EMIF_FW_REGION (PPA_HAL_SERVICES_START_INDEX + 26)
45 #define PPA_SERV_HAL_LOCK_EMIF_FW (PPA_HAL_SERVICES_START_INDEX + 27)
47 /* Offset of header size if image is signed as ISW */
48 #define HEADER_SIZE_OFFSET (0x6D)
52 /* Argument for PPA_SERV_HAL_TEE_LOAD_MASTER */
53 struct ppa_tee_load_info
{
54 u32 tee_sec_mem_start
; /* Physical start address reserved for TEE */
55 u32 tee_sec_mem_size
; /* Size of the memory reserved for TEE */
56 u32 tee_cert_start
; /* Address where signed TEE binary is loaded */
57 u32 tee_cert_size
; /* Size of TEE certificate (signed binary) */
58 u32 tee_jump_addr
; /* Address to jump to start TEE execution */
59 u32 tee_arg0
; /* argument to TEE jump function, in r0 */
62 static uint32_t secure_rom_call_args
[5] __aligned(ARCH_DMA_MINALIGN
) __section(".data");
64 u32
secure_rom_call(u32 service
, u32 proc_id
, u32 flag
, ...)
72 num_args
= va_arg(ap
, u32
);
79 /* Copy args to aligned args structure */
80 for (i
= 0; i
< num_args
; i
++)
81 secure_rom_call_args
[i
+ 1] = va_arg(ap
, u32
);
83 secure_rom_call_args
[0] = num_args
;
87 /* if data cache is enabled, flush the aligned args structure */
89 (unsigned int)&secure_rom_call_args
[0],
90 (unsigned int)&secure_rom_call_args
[0] +
91 roundup(sizeof(secure_rom_call_args
), ARCH_DMA_MINALIGN
));
93 return omap_smc_sec(service
, proc_id
, flag
, secure_rom_call_args
);
96 static u32
find_sig_start(char *image
, size_t size
)
98 char *image_end
= image
+ size
;
99 char *sig_start_magic
= "CERT_";
100 int magic_str_len
= strlen(sig_start_magic
);
103 while (--image_end
> image
) {
104 if (*image_end
== '_') {
105 ch
= image_end
- magic_str_len
+ 1;
106 if (!strncmp(ch
, sig_start_magic
, magic_str_len
))
113 int secure_boot_verify_image(void **image
, size_t *size
)
116 u32 cert_addr
, sig_addr
;
119 /* Perform cache writeback on input buffer */
121 rounddown((u32
)*image
, ARCH_DMA_MINALIGN
),
122 roundup((u32
)*image
+ *size
, ARCH_DMA_MINALIGN
));
124 cert_addr
= (uint32_t)*image
;
125 sig_addr
= find_sig_start((char *)*image
, *size
);
128 printf("No signature found in image!\n");
133 *size
= sig_addr
- cert_addr
; /* Subtract out the signature size */
134 /* Subtract header if present */
135 if (strncmp((char *)sig_addr
, "CERT_ISW_", 9) == 0)
136 *size
-= ((u32
*)*image
)[HEADER_SIZE_OFFSET
];
139 /* Check if image load address is 32-bit aligned */
140 if (!IS_ALIGNED(cert_addr
, 4)) {
141 printf("Image is not 4-byte aligned!\n");
146 /* Image size also should be multiple of 4 */
147 if (!IS_ALIGNED(cert_size
, 4)) {
148 printf("Image size is not 4-byte aligned!\n");
153 /* Call ROM HAL API to verify certificate signature */
154 debug("%s: load_addr = %x, size = %x, sig_addr = %x\n", __func__
,
155 cert_addr
, cert_size
, sig_addr
);
157 result
= secure_rom_call(
158 API_HAL_KM_VERIFYCERTIFICATESIGNATURE_INDEX
, 0, 0,
159 4, cert_addr
, cert_size
, sig_addr
, 0xFFFFFFFF);
161 /* Perform cache writeback on output buffer */
163 rounddown((u32
)*image
, ARCH_DMA_MINALIGN
),
164 roundup((u32
)*image
+ *size
, ARCH_DMA_MINALIGN
));
168 printf("Authentication failed!\n");
169 printf("Return Value = %08X\n", result
);
174 * Output notification of successful authentication to re-assure the
175 * user that the secure code is being processed as expected. However
176 * suppress any such log output in case of building for SPL and booting
177 * via YMODEM. This is done to avoid disturbing the YMODEM serial
178 * protocol transactions.
180 if (!(IS_ENABLED(CONFIG_SPL_BUILD
) &&
181 IS_ENABLED(CONFIG_SPL_YMODEM_SUPPORT
) &&
182 spl_boot_device() == BOOT_DEVICE_UART
))
183 printf("Authentication passed\n");
188 u32
get_sec_mem_start(void)
190 u32 sec_mem_start
= CONFIG_TI_SECURE_EMIF_REGION_START
;
191 u32 sec_mem_size
= CONFIG_TI_SECURE_EMIF_TOTAL_REGION_SIZE
;
193 * Total reserved region is all contiguous with protected
194 * region coming first, followed by the non-secure region.
195 * If 0x0 start address is given, we simply put the reserved
196 * region at the end of the external DRAM.
198 if (sec_mem_start
== 0)
200 (CONFIG_SYS_SDRAM_BASE
+ (
201 #if defined(CONFIG_OMAP54XX)
204 get_ram_size((void *)CONFIG_SYS_SDRAM_BASE
,
205 CONFIG_MAX_RAM_BANK_SIZE
)
208 return sec_mem_start
;
211 int secure_emif_firewall_setup(uint8_t region_num
, uint32_t start_addr
,
212 uint32_t size
, uint32_t access_perm
,
213 uint32_t initiator_perm
)
218 * Call PPA HAL API to do any other general firewall
219 * configuration for regions 1-6 of the EMIF firewall.
221 debug("%s: regionNum = %x, startAddr = %x, size = %x", __func__
,
222 region_num
, start_addr
, size
);
224 result
= secure_rom_call(
225 PPA_SERV_HAL_SETUP_EMIF_FW_REGION
, 0, 0, 4,
226 (start_addr
& 0xFFFFFFF0) | (region_num
& 0x0F),
227 size
, access_perm
, initiator_perm
);
230 puts("Secure EMIF Firewall Setup failed!\n");
231 debug("Return Value = %x\n", result
);
237 #if (CONFIG_TI_SECURE_EMIF_TOTAL_REGION_SIZE < \
238 CONFIG_TI_SECURE_EMIF_PROTECTED_REGION_SIZE)
239 #error "TI Secure EMIF: Protected size cannot be larger than total size."
241 int secure_emif_reserve(void)
244 u32 sec_mem_start
= get_sec_mem_start();
245 u32 sec_prot_size
= CONFIG_TI_SECURE_EMIF_PROTECTED_REGION_SIZE
;
247 /* If there is no protected region, there is no reservation to make */
248 if (sec_prot_size
== 0)
252 * Call PPA HAL API to reserve a chunk of EMIF SDRAM
253 * for secure world use. This region should be carved out
254 * from use by any public code. EMIF firewall region 7
255 * will be used to protect this block of memory.
257 result
= secure_rom_call(
258 PPA_SERV_HAL_SETUP_SEC_RESVD_REGION
,
259 0, 0, 2, sec_mem_start
, sec_prot_size
);
262 puts("SDRAM Firewall: Secure memory reservation failed!\n");
263 debug("Return Value = %x\n", result
);
269 int secure_emif_firewall_lock(void)
274 * Call PPA HAL API to lock the EMIF firewall configurations.
275 * After this API is called, none of the PPA HAL APIs for
276 * configuring the EMIF firewalls will be usable again (that
277 * is, calls to those APIs will return failure and have no
281 result
= secure_rom_call(
282 PPA_SERV_HAL_LOCK_EMIF_FW
,
286 puts("Secure EMIF Firewall Lock failed!\n");
287 debug("Return Value = %x\n", result
);
293 static struct ppa_tee_load_info tee_info
__aligned(ARCH_DMA_MINALIGN
);
295 int secure_tee_install(u32 addr
)
297 struct optee_header
*hdr
;
300 u32 sec_mem_start
= get_sec_mem_start();
301 const u32 size
= CONFIG_TI_SECURE_EMIF_PROTECTED_REGION_SIZE
;
304 /* If there is no protected region, there is no place to put the TEE */
306 printf("Error loading TEE, no protected memory region available\n");
310 hdr
= (struct optee_header
*)map_sysmem(addr
, sizeof(struct optee_header
));
311 /* 280 bytes = size of signature */
312 tee_file_size
= hdr
->init_size
+ hdr
->paged_size
+
313 sizeof(struct optee_header
) + 280;
315 if ((hdr
->magic
!= OPTEE_MAGIC
) ||
316 (hdr
->version
!= OPTEE_VERSION
) ||
317 (tee_file_size
> size
)) {
318 printf("Error in TEE header. Check firewall and TEE sizes\n");
320 return CMD_RET_FAILURE
;
323 tee_info
.tee_sec_mem_start
= sec_mem_start
;
324 tee_info
.tee_sec_mem_size
= size
;
325 tee_info
.tee_jump_addr
= hdr
->init_load_addr_lo
;
326 tee_info
.tee_cert_start
= addr
;
327 tee_info
.tee_cert_size
= tee_file_size
;
328 tee_info
.tee_arg0
= hdr
->init_size
+ tee_info
.tee_jump_addr
;
330 loadptr
= map_sysmem(addr
, tee_file_size
);
332 debug("tee_info.tee_sec_mem_start= %08X\n", tee_info
.tee_sec_mem_start
);
333 debug("tee_info.tee_sec_mem_size = %08X\n", tee_info
.tee_sec_mem_size
);
334 debug("tee_info.tee_jump_addr = %08X\n", tee_info
.tee_jump_addr
);
335 debug("tee_info.tee_cert_start = %08X\n", tee_info
.tee_cert_start
);
336 debug("tee_info.tee_cert_size = %08X\n", tee_info
.tee_cert_size
);
337 debug("tee_info.tee_arg0 = %08X\n", tee_info
.tee_arg0
);
338 debug("tee_file_size = %d\n", tee_file_size
);
340 #if !CONFIG_IS_ENABLED(SYS_DCACHE_OFF)
342 rounddown((u32
)loadptr
, ARCH_DMA_MINALIGN
),
343 roundup((u32
)loadptr
+ tee_file_size
, ARCH_DMA_MINALIGN
));
345 flush_dcache_range((u32
)&tee_info
, (u32
)&tee_info
+
346 roundup(sizeof(tee_info
), ARCH_DMA_MINALIGN
));
348 unmap_sysmem(loadptr
);
350 ret
= secure_rom_call(PPA_SERV_HAL_TEE_LOAD_MASTER
, 0, 0, 1, &tee_info
);
352 printf("TEE_LOAD_MASTER Failed\n");
355 printf("TEE_LOAD_MASTER Done\n");
357 #if defined(CONFIG_OMAP54XX)
359 u32
*smc_cpu1_params
;
360 /* Reuse the tee_info buffer for SMC params */
361 smc_cpu1_params
= (u32
*)&tee_info
;
362 smc_cpu1_params
[0] = 0;
363 #if !CONFIG_IS_ENABLED(SYS_DCACHE_OFF)
364 flush_dcache_range((u32
)smc_cpu1_params
, (u32
)smc_cpu1_params
+
365 roundup(sizeof(u32
), ARCH_DMA_MINALIGN
));
367 ret
= omap_smc_sec_cpu1(PPA_SERV_HAL_TEE_LOAD_SLAVE
, 0, 0,
370 printf("TEE_LOAD_SLAVE Failed\n");
373 printf("TEE_LOAD_SLAVE Done\n");