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