xref: /rk3399_rockchip-uboot/arch/arm/mach-rockchip/fit_nodes.sh (revision 568668158232933b5fe724d2b02fffb5aeaf519f) 
1#!/bin/bash
2#
3# Copyright (C) 2021 Rockchip Electronics Co., Ltd
4#
5# SPDX-License-Identifier:     GPL-2.0+
6#
7
8# Process args and auto set variables
9source ./${srctree}/arch/arm/mach-rockchip/fit_args.sh
10rm -f ${srctree}/*.digest ${srctree}/*.bin.gz ${srctree}/bl31_0x*.bin
11
12# Periph register base
13if grep -q '^CONFIG_ROCKCHIP_RK3576=y' .config ; then
14MAX_ADDR_VAL=$((0x10000000))
15elif grep -q '^CONFIG_ROCKCHIP_RV1126B=y' .config ; then
16MAX_ADDR_VAL=$((0x20000000))
17elif grep -q '^CONFIG_ROCKCHIP_RV1103B=y' .config ; then
18MAX_ADDR_VAL=$((0x20000000))
19else
20MAX_ADDR_VAL=$((0xf0000000))
21fi
22
23# dram base
24DRAM_BASE_VAL=`sed -n "/CONFIG_SYS_SDRAM_BASE=/s/CONFIG_SYS_SDRAM_BASE=//p" ${srctree}/include/autoconf.mk|tr -d '\r'`
25
26# compression
27if [ "${COMPRESSION}" == "gzip" ]; then
28	SUFFIX=".gz"
29	COMPRESS_CMD="gzip -kf9"
30elif [ "${COMPRESSION}" == "lzma" ]; then
31	SUFFIX=".lzma"
32	COMPRESS_CMD="${srctree}/scripts/compress.sh lzma"
33else
34	COMPRESSION="none"
35	SUFFIX=
36fi
37
38# nodes
39function gen_uboot_node()
40{
41	if [ -z ${UBOOT_LOAD_ADDR} ]; then
42		return
43	fi
44
45	UBOOT="u-boot-nodtb.bin"
46	echo "		uboot {
47			description = \"U-Boot\";
48			data = /incbin/(\"${UBOOT}${SUFFIX}\");
49			type = \"standalone\";
50			arch = \"${U_ARCH}\";
51			os = \"U-Boot\";
52			compression = \"${COMPRESSION}\";
53			load = <"${UBOOT_LOAD_ADDR}">;"
54	if [ "${COMPRESSION}" != "none" ]; then
55		openssl dgst -sha256 -binary -out ${UBOOT}.digest ${UBOOT}
56		UBOOT_SZ=`ls -l ${UBOOT} | awk '{ print $5 }'`
57		if [ ${UBOOT_SZ} -gt 0 ]; then
58			${COMPRESS_CMD} ${srctree}/${UBOOT}
59		else
60			touch ${srctree}/${UBOOT}${SUFFIX}
61		fi
62		echo "			digest {
63				value = /incbin/(\"./${UBOOT}.digest\");
64				algo = \"sha256\";
65			};"
66	fi
67	echo "			hash {
68				algo = \"sha256\";
69			};
70		};"
71
72	LOADABLE_UBOOT="\"uboot\", "
73}
74
75function gen_fdt_node()
76{
77	if [ -z ${UBOOT_LOAD_ADDR} ]; then
78		return
79	fi
80
81	echo "		fdt {
82			description = \"U-Boot dtb\";
83			data = /incbin/(\"./u-boot.dtb\");
84			type = \"flat_dt\";
85			arch = \"${U_ARCH}\";
86			compression = \"none\";
87			hash {
88				algo = \"sha256\";
89			};
90		};"
91
92	FDT_SIGN=", \"fdt\""
93	FDT="fdt = \"fdt\"${PROP_KERN_DTB};"
94};
95
96function gen_kfdt_node()
97{
98	if [ -z ${UBOOT_LOAD_ADDR} ]; then
99		return
100	fi
101
102	KERN_DTB=`sed -n "/CONFIG_EMBED_KERNEL_DTB_PATH=/s/CONFIG_EMBED_KERNEL_DTB_PATH=//p" .config | tr -d '"'`
103	if [ -z ${KERN_DTB} ]; then
104		return;
105	fi
106
107	if [ -f ${srctree}/${KERN_DTB} ]; then
108	PROP_KERN_DTB=', "kern-fdt"';
109	echo "		kern-fdt {
110			description = \"${KERN_DTB}\";
111			data = /incbin/(\"${KERN_DTB}\");
112			type = \"flat_dt\";
113			arch = \"${U_ARCH}\";
114			compression = \"none\";
115			hash {
116				algo = \"sha256\";
117			};
118		};"
119	fi
120}
121
122function gen_bl31_node()
123{
124	${srctree}/arch/arm/mach-rockchip/decode_bl31.py
125
126	NUM=1
127	for ATF in `ls -1 -S bl31_0x*.bin`
128	do
129		ATF_LOAD_ADDR=`echo ${ATF} | awk -F "_" '{ printf $2 }' | awk -F "." '{ printf $1 }'`
130		# only atf-1 support compress
131		if [ "${COMPRESSION}" != "none" -a ${NUM} -eq 1  ]; then
132			openssl dgst -sha256 -binary -out ${ATF}.digest ${ATF}
133			${COMPRESS_CMD} ${ATF}
134
135			echo "		atf-${NUM} {
136			description = \"ARM Trusted Firmware\";
137			data = /incbin/(\"./${ATF}${SUFFIX}\");
138			type = \"firmware\";
139			arch = \"${ARCH}\";
140			os = \"arm-trusted-firmware\";
141			compression = \"${COMPRESSION}\";
142			load = <"${ATF_LOAD_ADDR}">;
143			hash {
144				algo = \"sha256\";
145			};
146			digest {
147				value = /incbin/(\"./${ATF}.digest\");
148				algo = \"sha256\";
149			};
150		};"
151		else
152			echo "		atf-${NUM} {
153			description = \"ARM Trusted Firmware\";
154			data = /incbin/(\"./${ATF}\");
155			type = \"firmware\";
156			arch = \"${ARCH}\";
157			os = \"arm-trusted-firmware\";
158			compression = \"none\";
159			load = <"${ATF_LOAD_ADDR}">;
160			hash {
161				algo = \"sha256\";
162			};
163		};"
164		fi
165
166		if [ ${NUM} -eq 2 ]; then
167			LOADABLE_ATF=${LOADABLE_ATF}"\"atf-${NUM}\""
168		elif [ ${NUM} -gt 2 ]; then
169			LOADABLE_ATF=${LOADABLE_ATF}", \"atf-${NUM}\""
170		fi
171		NUM=`expr ${NUM} + 1`
172	done
173}
174
175function gen_bl32_node()
176{
177	if [ -z ${TEE_LOAD_ADDR} ]; then
178		return
179	fi
180
181	if [ "${ARCH}" == "arm" ]; then
182		# If not AArch32 mode
183		if ! grep  -q '^CONFIG_ARM64_BOOT_AARCH32=y' .config ; then
184			ENTRY="entry = <"${TEE_LOAD_ADDR}">;"
185
186			# if disable packing tee.bin
187			if ! grep -q '^CONFIG_SPL_OPTEE=y' .config ; then
188				return
189			fi
190
191		fi
192	fi
193
194	TEE="tee.bin"
195	echo "		optee {
196			description = \"OP-TEE\";
197			data = /incbin/(\"${TEE}${SUFFIX}\");
198			type = \"firmware\";
199			arch = \"${ARCH}\";
200			os = \"op-tee\";
201			compression = \"${COMPRESSION}\";
202			${ENTRY}
203			load = <"${TEE_LOAD_ADDR}">;"
204	if [ "${COMPRESSION}" != "none" ]; then
205		openssl dgst -sha256 -binary -out ${TEE}.digest ${TEE}
206		${COMPRESS_CMD} ${TEE}
207		echo "			digest {
208				value = /incbin/(\"./${TEE}.digest\");
209				algo = \"sha256\";
210			};"
211	fi
212	echo "			hash {
213				algo = \"sha256\";
214			};
215		};"
216	LOADABLE_OPTEE=", \"optee\""
217	FIRMWARE_OPTEE="firmware = \"optee\";"
218	FIRMWARE_SIGN="\"firmware\""
219}
220
221function gen_mcu_node()
222{
223	for ((i=0, n=0; i<5; i++))
224	do
225		if [ ${i} -eq 0 ]; then
226			MCU_ADDR=${MCU0_LOAD_ADDR}
227		elif [ ${i} -eq 1 ]; then
228			MCU_ADDR=${MCU1_LOAD_ADDR}
229		elif [ ${i} -eq 2 ]; then
230			MCU_ADDR=${MCU2_LOAD_ADDR}
231		elif [ ${i} -eq 3 ]; then
232			MCU_ADDR=${MCU3_LOAD_ADDR}
233		elif [ ${i} -eq 4 ]; then
234			MCU_ADDR=${MCU4_LOAD_ADDR}
235		fi
236
237		if [ -z ${MCU_ADDR} ]; then
238			continue
239		fi
240
241		MCU_ADDR_VAL=$((MCU_ADDR))
242		MCU="mcu${i}"
243		echo "		${MCU} {
244			description = \"${MCU}\";
245			type = \"standalone\";
246			arch = \"riscv\";
247			load = <"${MCU_ADDR}">;"
248
249		# When allow to be compressed?
250		# DRAM base < load addr < Periph register base
251		# Periph register base < DRAM base < load addr
252		if [ "${COMPRESSION}" != "none" -a "$((MCU_ADDR_VAL))" -gt "$((DRAM_BASE_VAL))" ] &&
253		   [ "$((DRAM_BASE_VAL))" -gt "$((MAX_ADDR_VAL))" -o "$((MCU_ADDR_VAL))" -lt "$((MAX_ADDR_VAL))" ]; then
254				openssl dgst -sha256 -binary -out ${MCU}.bin.digest ${MCU}.bin
255				${COMPRESS_CMD} ${MCU}.bin
256				echo "			data = /incbin/(\"./${MCU}.bin${SUFFIX}\");
257				compression = \"${COMPRESSION}\";
258				digest {
259					value = /incbin/(\"./${MCU}.bin.digest\");
260					algo = \"sha256\";
261				};"
262		else
263			echo "			data = /incbin/(\"./${MCU}.bin\");
264			compression = \"none\";"
265		fi
266
267		echo "			hash {
268				algo = \"sha256\";
269			};
270		};"
271
272		if [ ${n} -eq 0 ]; then
273			STANDALONE_LIST=${STANDALONE_LIST}"\"${MCU}\""
274		else
275			STANDALONE_LIST=${STANDALONE_LIST}", \"${MCU}\""
276		fi
277		n=`expr ${n} + 1`
278
279		STANDALONE_SIGN=", \"standalone\""
280		STANDALONE_MCU="standalone = ${STANDALONE_LIST};"
281	done
282
283	if [ -z ${INIT0_LOAD_ADDR} ]; then
284		return
285	fi
286
287	INIT="init0"
288	echo "		${INIT} {
289			description = \"${INIT}\";
290			type = \"standalone\";
291			arch = \"${ARCH}\";
292			load = <"${INIT0_LOAD_ADDR}">;
293			data = /incbin/(\"./${INIT}.bin\");
294			compression = \"none\";
295			hash {
296				algo = \"sha256\";
297			};
298		};"
299	STANDALONE_MCU="standalone = \"init0\"${STANDALONE_LIST};"
300}
301
302function gen_loadable_node()
303{
304	for ((i=0; i<5; i++))
305	do
306		if [ ${i} -eq 0 ]; then
307			LOAD_ADDR=${LOAD0_LOAD_ADDR}
308		elif [ ${i} -eq 1 ]; then
309			LOAD_ADDR=${LOAD1_LOAD_ADDR}
310		elif [ ${i} -eq 2 ]; then
311			LOAD_ADDR=${LOAD2_LOAD_ADDR}
312		elif [ ${i} -eq 3 ]; then
313			LOAD_ADDR=${LOAD3_LOAD_ADDR}
314		elif [ ${i} -eq 4 ]; then
315			LOAD_ADDR=${LOAD4_LOAD_ADDR}
316		fi
317
318		if [ -z ${LOAD_ADDR} ]; then
319			continue
320		fi
321
322		LOAD_ADDR_VAL=$((LOAD_ADDR))
323		LOAD="load${i}"
324		echo "		${LOAD} {
325			description = \"${LOAD}\";
326			type = \"standalone\";
327			arch = \"${ARCH}\";
328			load = <"${LOAD_ADDR}">;"
329
330		# When allow to be compressed?
331		# DRAM base < load addr < Periph register base
332		# Periph register base < DRAM base < load addr
333		if [ "${COMPRESSION}" != "none" -a "$((MCU_ADDR_VAL))" -gt "$((DRAM_BASE_VAL))" ] &&
334		   [ "$((DRAM_BASE_VAL))" -gt "$((MAX_ADDR_VAL))" -o "$((MCU_ADDR_VAL))" -lt "$((MAX_ADDR_VAL))" ]; then
335				openssl dgst -sha256 -binary -out ${LOAD}.bin.digest ${LOAD}.bin
336				${COMPRESS_CMD} ${LOAD}.bin
337				echo "			data = /incbin/(\"./${LOAD}.bin${SUFFIX}\");
338				compression = \"${COMPRESSION}\";
339				digest {
340					value = /incbin/(\"./${LOAD}.bin.digest\");
341					algo = \"sha256\";
342				};"
343		else
344			echo "			data = /incbin/(\"./${LOAD}.bin\");
345			compression = \"none\";"
346		fi
347
348		echo "			hash {
349				algo = \"sha256\";
350			};
351		};"
352
353		LOADABLE_OTHER=${LOADABLE_OTHER}", \"${LOAD}\""
354	done
355}
356
357function gen_header()
358{
359echo "
360/*
361 * Copyright (C) 2020 Rockchip Electronic Co.,Ltd
362 *
363 * Simple U-boot fit source file containing ATF/OP-TEE/U-Boot/dtb/MCU
364 */
365
366/dts-v1/;
367
368/ {
369	description = \"FIT Image with ATF/OP-TEE/U-Boot/MCU\";
370	#address-cells = <1>;
371
372	images {
373"
374}
375
376function gen_arm64_configurations()
377{
378PLATFORM=`sed -n "/CONFIG_DEFAULT_DEVICE_TREE/p" .config | awk -F "=" '{ print $2 }' | tr -d '"'`
379if grep -q '^CONFIG_FIT_ENABLE_RSASSA_PSS_SUPPORT=y' .config ; then
380	ALGO_PADDING="				padding = \"pss\";"
381fi
382if grep -q '^CONFIG_FIT_ENABLE_RSA4096_SUPPORT=y' .config ; then
383	ALGO_NAME="				algo = \"sha256,rsa4096\";"
384else
385	ALGO_NAME="				algo = \"sha256,rsa2048\";"
386fi
387if [ -z "${LOADABLE_ATF}" ]; then
388	LOADABLE_UBOOT="\"uboot\""
389fi
390
391echo "	};
392
393	configurations {
394		default = \"conf\";
395		conf {
396			description = \"${PLATFORM}\";
397			rollback-index = <0x0>;
398			firmware = \"atf-1\";
399			loadables = ${LOADABLE_UBOOT}${LOADABLE_ATF}${LOADABLE_OPTEE}${LOADABLE_OTHER};
400			${STANDALONE_MCU}
401			${FDT}
402			signature {
403				${ALGO_NAME}
404				${ALGO_PADDING}
405				key-name-hint = \"dev\";
406				sign-images = \"firmware\", \"loadables\"${FDT_SIGN}${STANDALONE_SIGN};
407			};
408		};
409	};
410};
411"
412}
413
414function gen_arm_configurations()
415{
416PLATFORM=`sed -n "/CONFIG_DEFAULT_DEVICE_TREE/p" .config | awk -F "=" '{ print $2 }' | tr -d '"'`
417if grep -q '^CONFIG_FIT_ENABLE_RSASSA_PSS_SUPPORT=y' .config ; then
418        ALGO_PADDING="                          padding = \"pss\";"
419fi
420if grep -q '^CONFIG_FIT_ENABLE_RSA4096_SUPPORT=y' .config ; then
421	ALGO_NAME="				algo = \"sha256,rsa4096\";"
422else
423	ALGO_NAME="				algo = \"sha256,rsa2048\";"
424fi
425if [ ! -z "${LOADABLE_UBOOT}" ] || [ ! -z "${LOADABLE_OTHER}" ]; then
426	LOADABLE_UBOOT="\"uboot\""
427	LOADABLES="loadables = ${LOADABLE_UBOOT}${LOADABLE_OTHER};"
428	if [ -z ${FIRMWARE_SIGN} ]; then
429		LOADABLES_SIGN="\"loadables\""
430	else
431		LOADABLES_SIGN=", \"loadables\""
432	fi
433fi
434
435echo "	};
436
437	configurations {
438		default = \"conf\";
439		conf {
440			description = \"${PLATFORM}\";
441			rollback-index = <0x0>;
442			${FIRMWARE_OPTEE}
443			${LOADABLES}
444			${STANDALONE_MCU}
445			${FDT}
446			signature {
447				${ALGO_NAME}
448				${ALGO_PADDING}
449				key-name-hint = \"dev\";
450				sign-images = ${FIRMWARE_SIGN}${LOADABLES_SIGN}${FDT_SIGN}${STANDALONE_SIGN};
451			};
452		};
453	};
454};
455"
456}
457
458