| # SPDX-License-Identifier: MIT |
| # |
| # Copyright PHYTEC Messtechnik GmbH |
| # Copyright (C) 2024 Pengutronix, <yocto@pengutronix.de> |
| # |
| # Class for creating (signed) FIT images |
| # Description: |
| # |
| # You have to define the 'images' to put in the FIT image in your recipe file |
| # following this example: |
| # |
| # FITIMAGE_IMAGES ?= "kernel fdt fdto setup ramdisk bootscript" |
| # |
| # FITIMAGE_IMAGE_kernel ?= "virtual/kernel" |
| # FITIMAGE_IMAGE_kernel[type] ?= "kernel" |
| # |
| # FITIMAGE_IMAGE_fdt ?= "virtual/dtb" # or "virtual/kernel" |
| # FITIMAGE_IMAGE_fdt[type] ?= "fdt" |
| # #FITIMAGE_IMAGE_fdt[file] ?= "hw-name.dtb" |
| # |
| # FITIMAGE_IMAGE_fdto ?= "virtual/kernel" |
| # FITIMAGE_IMAGE_fdto[type] ?= "fdto" |
| # FITIMAGE_IMAGE_fdto[file] ?= <list of all dtbo files from KERNEL_DEVICETREE> |
| # |
| # Add a devicetree created on-thy-fly of a base dtb and serveral dtbo's |
| # FITIMAGE_IMAGE_fdtapply ?= "virtual/kernel" |
| # FITIMAGE_IMAGE_fdtapply[type] ?= "fdtapply" |
| # FITIMAGE_IMAGE_fdtapply[file] ?= "base.dtb overlay-1.dtbo overlay-2.dtbo" |
| # FITIMAGE_IMAGE_fdtapply[name] ?= "<name for new generated fdt>" |
| # |
| # FITIMAGE_IMAGE_ramdisk ?= "core-image-minimal" |
| # FITIMAGE_IMAGE_ramdisk[type] ?= "ramdisk" |
| # FITIMAGE_IMAGE_ramdisk[fstype] ?= "cpio.gz" |
| # |
| # FITIMAGE_IMAGE_bootscript ?= "bootscript" |
| # FITIMAGE_IMAGE_bootscript[type] ?= "bootscript" |
| # FITIMAGE_IMAGE_bootscript[file] ?= "boot.scr" |
| # |
| # Valid options for the [type] varflag are: "kernel", "fdt", "fdto", "fdtapply", "ramdisk", "bootscript". |
| # |
| # To enable signing, set |
| # |
| # FITIMAGE_SIGN = "1" |
| # |
| # and configure FITIMAGE_SIGN_KEYDIR (and FITIMAGE_SIGN_KEYNAME) according to |
| # your needs. |
| # |
| # For signing via PKCS#11 URIs provided by the meta-oe signing.bbclass, add: |
| # |
| # inherit signing |
| # |
| # FITIMAGE_SIGNING_KEY_ROLE = "fit" |
| # |
| # do_fitimage:prepend() { |
| # signing_prepare |
| # signing_use_role "${FITIMAGE_SIGNING_KEY_ROLE}" |
| # } |
| # |
| # FITIMAGE_SIGN = "1" |
| # FITIMAGE_MKIMAGE_EXTRA_ARGS = "--engine pkcs11" |
| # FITIMAGE_SIGN_KEYDIR = "${PKCS11_URI}" |
| |
| |
| LICENSE ?= "MIT" |
| |
| inherit deploy kernel-artifact-names image-artifact-names kernel-arch nopackages |
| |
| do_patch[noexec] = "1" |
| do_compile[noexec] = "1" |
| do_install[noexec] = "1" |
| deltask do_populate_sysroot |
| |
| INHIBIT_DEFAULT_DEPS = "1" |
| |
| DEPENDS = "u-boot-mkimage-native dtc-native" |
| |
| FITIMAGE_SIGN ?= "0" |
| FITIMAGE_SIGN[doc] = "Enable FIT image signing" |
| FITIMAGE_SIGN_KEYDIR ?= "" |
| FITIMAGE_SIGN_KEYDIR[doc] = "Key directory or pkcs#11 URI to use for signing configuration" |
| FITIMAGE_MKIMAGE_EXTRA_ARGS[doc] = "Extra arguemnts to pass to uboot-mkimage call" |
| FITIMAGE_HASH_ALGO ?= "sha256" |
| FITIMAGE_HASH_ALGO[doc] = "Hash algorithm to use" |
| FITIMAGE_ENCRYPT_ALGO ?= "rsa2048" |
| FITIMAGE_ENCRYPT_ALGO[doc] = "Signature algorithm to use" |
| FITIMAGE_CONFIG_PREFIX ?= "conf-" |
| FITIMAGE_CONFIG_PREFIX[doc] = "Prefix to use for FIT configuration node name" |
| |
| FITIMAGE_LOADADDRESS ??= "" |
| FITIMAGE_ENTRYPOINT ??= "" |
| FITIMAGE_DTB_LOADADDRESS ??= "" |
| FITIMAGE_DTB_OVERLAY_LOADADDRESS ??= "" |
| FITIMAGE_RD_LOADADDRESS ??= "" |
| FITIMAGE_RD_ENTRYPOINT ??= "" |
| |
| PACKAGE_ARCH = "${MACHINE_ARCH}" |
| |
| # Create dependency list from images |
| python __anonymous() { |
| for image in (d.getVar('FITIMAGE_IMAGES') or "").split(): |
| imageflags = d.getVarFlags('FITIMAGE_IMAGE_%s' % image, expand=['type', 'depends']) or {} |
| imgtype = imageflags.get('type') |
| if not imgtype: |
| bb.debug(1, "No [type] given for image '%s', defaulting to 'kernel'" % image) |
| imgtype = 'kernel' |
| recipe = d.getVar('FITIMAGE_IMAGE_%s' % image) |
| |
| if not recipe: |
| bb.error("No recipe set for image '%s'. Specify via 'FITIMAGE_IMAGE_%s = \"<recipe-name>\"'" % (recipe, image)) |
| return |
| |
| d.appendVarFlag('do_unpack', 'vardeps', ' FITIMAGE_IMAGE_%s' % image) |
| depends = imageflags.get('depends') |
| if depends: |
| d.appendVarFlag('do_unpack', 'depends', ' ' + depends) |
| continue |
| |
| if imgtype == 'ramdisk': |
| d.appendVarFlag('do_unpack', 'depends', ' ' + recipe + ':do_image_complete') |
| elif 'fdt' in imgtype: |
| d.appendVarFlag('do_unpack', 'depends', ' ' + recipe + ':do_populate_sysroot') |
| d.appendVarFlag('do_unpack', 'depends', ' ' + recipe + ':do_deploy') |
| else: |
| d.appendVarFlag('do_unpack', 'depends', ' ' + recipe + ':do_deploy') |
| |
| if 'fdt' in imgtype and d.getVar('PREFERRED_PROVIDER_virtual/dtb'): |
| d.setVar('EXTERNAL_KERNEL_DEVICETREE', '${RECIPE_SYSROOT}/boot/devicetree') |
| } |
| |
| S = "${WORKDIR}/sources" |
| UNPACKDIR = "${S}" |
| B = "${WORKDIR}/build" |
| |
| # |
| # Emit the fitImage ITS header |
| # |
| def fitimage_emit_fit_header(d, fd): |
| fd.write('/dts-v1/;\n\n/ {\n') |
| fd.write(d.expand('\tdescription = "fitImage for ${DISTRO_NAME}/${PV}/${MACHINE}";\n')) |
| fd.write('\t#address-cells = <1>;\n') |
| |
| # |
| # Emit the fitImage ITS footer |
| # |
| def fitimage_emit_fit_footer(d, fd): |
| fd.write('};\n') |
| |
| # |
| # Emit the fitImage section |
| # |
| def fitimage_emit_section_start(d, fd, section): |
| fd.write(f'\t{section} {{\n') |
| |
| # |
| # Emit the fitImage section end |
| # |
| def fitimage_emit_section_end(d, fd): |
| fd.write('\t};\n') |
| |
| def fitimage_emit_section_kernel(d, fd, imgpath, imgsource, imgcomp): |
| kernelcount = 1 |
| kernel_csum = d.getVar("FITIMAGE_HASH_ALGO") |
| arch = d.getVar("ARCH") |
| loadaddr = d.getVar("FITIMAGE_LOADADDRESS") |
| entryaddr = d.getVar("FITIMAGE_ENTRYPOINT") |
| |
| bb.note(f"Adding kernel-{kernelcount} section to ITS file") |
| |
| fd.write(f'\t\tkernel-{kernelcount} {{\n') |
| fd.write('\t\t\tdescription = "Linux kernel";\n') |
| fd.write(f'\t\t\tdata = /incbin/("{imgpath}/{imgsource}");\n') |
| fd.write('\t\t\ttype = "kernel";\n') |
| fd.write(f'\t\t\tarch = "{arch}";\n') |
| fd.write('\t\t\tos = "linux";\n') |
| fd.write(f'\t\t\tcompression = "{imgcomp}";\n') |
| if (loadaddr): |
| fd.write(f'\t\t\tload = <{loadaddr}>;\n') |
| if (entryaddr): |
| fd.write(f'\t\t\tentry = <{entryaddr}>;\n') |
| fd.write('\t\t\thash-1 {\n') |
| fd.write(f'\t\t\t\talgo = "{kernel_csum}";\n') |
| fd.write('\t\t\t};\n') |
| fd.write('\t\t};\n') |
| |
| # |
| # Emit the fitImage ITS DTB section |
| # |
| def _fitimage_emit_section_dtb(d, fd, dtb_file, dtb_path, loadaddr, desc): |
| dtb_csum = d.getVar("FITIMAGE_HASH_ALGO") |
| arch = d.getVar("ARCH") |
| |
| bb.note(f"Adding fdt-{dtb_file} section to ITS file") |
| |
| fd.write(f'\t\tfdt-{dtb_file} {{\n') |
| fd.write(f'\t\t\tdescription = "{desc}";\n') |
| fd.write(f'\t\t\tdata = /incbin/("{dtb_path}/{dtb_file}");\n') |
| fd.write('\t\t\ttype = "flat_dt";\n') |
| fd.write(f'\t\t\tarch = "{arch}";\n') |
| fd.write('\t\t\tcompression = "none";\n') |
| if loadaddr: |
| fd.write(f'\t\t\tload = <{loadaddr}>;\n') |
| fd.write('\t\t\thash-1 {\n') |
| fd.write(f'\t\t\t\talgo = "{dtb_csum}";\n') |
| fd.write('\t\t\t};\n') |
| fd.write('\t\t};\n') |
| |
| |
| def fitimage_emit_section_dtb(d, fd, dtb_file, dtb_path): |
| loadaddr = d.getVar("FITIMAGE_DTB_LOADADDRESS") |
| |
| _fitimage_emit_section_dtb(d, fd, dtb_file, dtb_path, loadaddr, "Flattened Device Tree blob") |
| |
| # |
| # Emit the fitImage ITS DTB overlay section |
| # |
| def fitimage_emit_section_dtb_overlay(d, fd, dtb_file, dtb_path): |
| loadaddr = d.getVar("FITIMAGE_DTB_OVERLAY_LOADADDRESS") |
| |
| _fitimage_emit_section_dtb(d, fd, dtb_file, dtb_path, loadaddr, "Flattened Device Tree Overlay blob") |
| |
| |
| # |
| # Emit the fitImage ITS ramdisk section |
| # |
| def fitimage_emit_section_ramdisk(d, fd, img_file, img_path): |
| ramdisk_count = "1" |
| ramdisk_csum = d.getVar("FITIMAGE_HASH_ALGO") |
| arch = d.getVar("ARCH") |
| loadaddr = d.getVar("FITIMAGE_RD_LOADADDRESS") |
| entryaddr = d.getVar("FITIMAGE_RD_ENTRYPOINT") |
| |
| bb.note(f"Adding ramdisk-{ramdisk_count} section to ITS file") |
| |
| fd.write(f'\t\tramdisk-{ramdisk_count} {{\n') |
| fd.write(f'\t\t\tdescription = "{img_file}";\n') |
| fd.write(f'\t\t\tdata = /incbin/("{img_path}/{img_file}");\n') |
| fd.write('\t\t\ttype = "ramdisk";\n') |
| fd.write(f'\t\t\tarch = "{arch}";\n') |
| fd.write('\t\t\tos = "linux";\n') |
| fd.write('\t\t\tcompression = "none";\n') |
| if (loadaddr): |
| fd.write(f'\t\t\tload = <{loadaddr}>;\n') |
| if (entryaddr): |
| fd.write(f'\t\t\tentry = <{entryaddr}>;\n') |
| fd.write('\t\t\thash-1 {\n') |
| fd.write(f'\t\t\t\talgo = "{ramdisk_csum}";\n') |
| fd.write('\t\t\t};\n') |
| fd.write('\t\t};\n') |
| |
| def fitimage_emit_section_bootscript(d, fd, imgpath, imgsource): |
| hash_algo = d.getVar("FITIMAGE_HASH_ALGO") |
| arch = d.getVar("ARCH") |
| |
| bb.note(f"Adding bootscr-{imgsource} section to ITS file") |
| |
| fd.write(f'\t\tbootscr-{imgsource} {{\n') |
| fd.write('\t\t\tdescription = "U-boot script";\n') |
| fd.write(f'\t\t\tdata = /incbin/("{imgpath}/{imgsource}");\n') |
| fd.write('\t\t\ttype = "script";\n') |
| fd.write(f'\t\t\tarch = "{arch}";\n') |
| fd.write('\t\t\tos = "linux";\n') |
| fd.write('\t\t\tcompression = "none";\n') |
| fd.write('\t\t\thash-1 {\n') |
| fd.write(f'\t\t\t\talgo = "{hash_algo}";\n') |
| fd.write('\t\t\t};\n') |
| fd.write('\t\t};\n') |
| |
| def fitimage_emit_subsection_signature(d, fd, sign_images_list): |
| hash_algo = d.getVar("FITIMAGE_HASH_ALGO") |
| encrypt_algo = d.getVar("FITIMAGE_ENCRYPT_ALGO") or "" |
| conf_sign_keyname = d.getVar("FITIMAGE_SIGN_KEYNAME") |
| signer_name = d.getVar("FITIMAGE_SIGNER") |
| signer_version = d.getVar("FITIMAGE_SIGNER_VERSION") |
| sign_images = ", ".join(f'"{s}"' for s in sign_images_list) |
| |
| fd.write('\t\t\tsignature-1 {\n') |
| fd.write(f'\t\t\t\talgo = "{hash_algo},{encrypt_algo}";\n') |
| if conf_sign_keyname: |
| fd.write(f'\t\t\t\tkey-name-hint = {conf_sign_keyname}";\n') |
| fd.write(f'\t\t\t\tsign-images = {sign_images};\n') |
| fd.write(f'\t\t\t\tsigner-name = "{signer_name}";\n') |
| fd.write(f'\t\t\t\tsigner-version = "{signer_version}";\n') |
| fd.write('\t\t\t};\n') |
| |
| # |
| # Emit the fitImage ITS configuration section |
| # |
| def fitimage_emit_section_config(d, fd, dtb, kernelcount, ramdiskcount, setupcount, bootscriptid, compatible, dtbcount): |
| sign = d.getVar("FITIMAGE_SIGN") |
| conf_default = None |
| conf_prefix = d.getVar('FITIMAGE_CONFIG_PREFIX') or "" |
| |
| bb.note(f"Adding {dtb} section to ITS file") |
| |
| conf_desc="Linux kernel" |
| if dtb: |
| conf_desc += ", FDT blob" |
| if ramdiskcount: |
| conf_desc += ", ramdisk" |
| if setupcount: |
| conf_desc += ", setup" |
| if bootscriptid: |
| conf_desc += ", u-boot script" |
| if dtbcount == 1: |
| conf_default = d.getVar('FITIMAGE_DEFAULT_CONFIG') or f'{conf_prefix}{dtb}' |
| |
| if conf_default: |
| fd.write(f'\t\tdefault = "{conf_default}";\n') |
| fd.write(f'\t\t{conf_prefix}{dtb} {{\n') |
| fd.write(f'\t\t\tdescription = "{dtbcount} {conf_desc}";\n') |
| if kernelcount: |
| fd.write('\t\t\tkernel = "kernel-1";\n') |
| fd.write(f'\t\t\tfdt = "fdt-{dtb}";\n') |
| if ramdiskcount: |
| fd.write(f'\t\t\tramdisk = "ramdisk-{ramdiskcount}";\n') |
| if bootscriptid: |
| fd.write(f'\t\t\tbootscr = "bootscr-{bootscriptid}";\n') |
| if compatible: |
| fd.write(f'\t\t\tcompatible = "{compatible}";\n') |
| |
| if sign == "1": |
| sign_images = ["kernel"] |
| if dtb: |
| sign_images.append("fdt") |
| if ramdiskcount: |
| sign_images.append("ramdisk") |
| if setupcount: |
| sign_images.append("setup") |
| if bootscriptid: |
| sign_images.append("bootscr") |
| fitimage_emit_subsection_signature(d, fd, sign_images) |
| |
| fd.write('\t\t' + '};\n') |
| |
| # |
| # Emits a device tree overlay config section |
| # |
| def fitimage_emit_section_config_fdto(d, fd, dtb, compatible): |
| sign = d.getVar("FITIMAGE_SIGN") |
| bb.note("Adding overlay config section to ITS file") |
| |
| fd.write(f'\t\t{dtb} {{\n') |
| fd.write(f'\t\t\tdescription = "Device Tree Overlay";\n') |
| fd.write(f'\t\t\tfdt = "fdt-{dtb}";') |
| if compatible: |
| fd.write(f'\t\t\tcompatible = "{compatible}";') |
| |
| if sign == "1": |
| sign_images = ["fdt"] |
| fitimage_emit_subsection_signature(d, fd, sign_images) |
| |
| fd.write('\t\t' + '};\n') |
| |
| python write_manifest() { |
| machine = d.getVar('MACHINE') |
| kernelcount=1 |
| DTBS = "" |
| DTBOS = "" |
| ramdiskcount = "" |
| setupcount = "" |
| bootscriptid = "" |
| compatible = "" |
| |
| def get_dtbs(d, dtb_suffix): |
| sysroot = d.getVar('RECIPE_SYSROOT') |
| deploydir = d.getVar('DEPLOY_DIR_IMAGE') |
| |
| dtbs = (d.getVar('KERNEL_DEVICETREE') or '').split() |
| dtbs = [os.path.basename(x) for x in dtbs if x.endswith(dtb_suffix)] |
| ext_dtbs = os.listdir(d.getVar('EXTERNAL_KERNEL_DEVICETREE')) if d.getVar('EXTERNAL_KERNEL_DEVICETREE') else [] |
| ext_dtbs = [x for x in ext_dtbs if x.endswith(dtb_suffix)] |
| |
| result = [] |
| # Prefer BSP dts if BSP and kernel provide the same dts |
| for d in sorted(set(dtbs + ext_dtbs)): |
| dtbpath = f'{sysroot}/boot/devicetree/{d}' if d in ext_dtbs else f'{deploydir}/{d}' |
| result.append(dtbpath) |
| |
| return " ".join(result) |
| |
| with open('%s/manifest.its' % d.getVar('B'), 'w') as fd: |
| images = d.getVar('FITIMAGE_IMAGES') |
| if not images: |
| bb.warn("No images specified in FITIMAGE_IMAGES. Generated FIT image will be empty") |
| |
| fitimage_emit_fit_header(d, fd) |
| fitimage_emit_section_start(d, fd, 'images') |
| |
| for image in (images or "").split(): |
| imageflags = d.getVarFlags('FITIMAGE_IMAGE_%s' % image, expand=['file', 'fstype', 'type', 'comp']) or {} |
| imgtype = imageflags.get('type', '') |
| if imgtype == 'kernel': |
| default = "%s-%s%s" % (d.getVar('KERNEL_IMAGETYPE'), machine, d.getVar('KERNEL_IMAGE_BIN_EXT')) |
| imgsource = imageflags.get('file', default) |
| imgcomp = imageflags.get('comp', 'none') |
| imgpath = d.getVar("DEPLOY_DIR_IMAGE") |
| fitimage_emit_section_kernel(d, fd, imgpath, imgsource, imgcomp) |
| elif imgtype == 'fdt': |
| default = get_dtbs(d, "dtb") |
| dtbfiles = imageflags.get('file', default) |
| if not dtbfiles: |
| bb.fatal(f"No dtb file found for image '{image}'. Set KERNEL_DEVICETREE, [file] varflag, or reference devicetree.bbclass-based recipe.") |
| for dtb in dtbfiles.split(): |
| dtb_path, dtb_file = os.path.split(dtb) |
| DTBS += f" {dtb}" |
| fitimage_emit_section_dtb(d, fd, dtb_file, dtb_path) |
| elif imgtype == 'fdto': |
| default = get_dtbs(d, "dtbo") |
| dtbofiles = imageflags.get('file', default) |
| if not dtbofiles: |
| bb.fatal(f"No dtbo file found for image '{image}'. Set KERNEL_DEVICETREE, [file] varflag, or reference devicetree.bbclass-based recipe.") |
| for dtb in dtbofiles.split(): |
| dtb_path, dtb_file = os.path.split(dtb) |
| DTBOS = DTBOS + " " + dtb |
| fitimage_emit_section_dtb_overlay(d, fd, dtb_file, dtb_path) |
| elif imgtype == 'fdtapply': |
| import subprocess |
| dtbofiles = imageflags.get('file', None) |
| if not dtbofiles: |
| bb.fatal(f"No dtbo file found for image '{image}'. Set via [file] varflag.") |
| dtboutname = imageflags.get('name', None) |
| if not dtboutname: |
| bb.fatal(f"No dtb output name found for image '{image}'. Set via [name] varflag.") |
| dtbresult = "%s/%s" % (d.getVar('B'), dtboutname) |
| dtbcommand = "" |
| for dtb in dtbofiles.split(): |
| dtb_path, dtb_file = os.path.split(dtb) |
| if not dtb_path: |
| dtb_path = d.getVar("DEPLOY_DIR_IMAGE") |
| if not dtbcommand: |
| if not dtb_file.endswith('.dtb'): |
| bb.fatal(f"fdtapply failed: Expected (non-overlay) .dtb file as first element, but got {dtb_file}") |
| dtbcommand = f"fdtoverlay -i {dtb_path}/{dtb_file} -o {dtbresult}" |
| else: |
| if not dtb_file.endswith('.dtbo'): |
| bb.fatal(f"fdtapply failed: Expected .dtbo file, but got {dtb_file}") |
| dtbcommand += f" {dtb_path}/{dtb_file}" |
| result = subprocess.run(dtbcommand, stderr=subprocess.PIPE, shell=True, text=True) |
| if result.returncode != 0: |
| bb.fatal(f"Running {dtbcommand} failed: {result.stderr}") |
| dtb_path, dtb_file = os.path.split(dtbresult) |
| DTBS += f" {dtbresult}" |
| fitimage_emit_section_dtb(d, fd, dtb_file, dtb_path) |
| elif imgtype == 'ramdisk': |
| ramdiskcount = "1" |
| default_imgfstype = d.getVar('INITRAMFS_FSTYPES' or "").split()[0] |
| img_fstype = imageflags.get('fstype', default_imgfstype) |
| img_file = "%s%s.%s" % (d.getVar('FITIMAGE_IMAGE_%s' % image), d.getVar('IMAGE_MACHINE_SUFFIX'), img_fstype) |
| img_path = d.getVar("DEPLOY_DIR_IMAGE") |
| fitimage_emit_section_ramdisk(d, fd, img_file, img_path) |
| elif imgtype == 'bootscript': |
| if bootscriptid: |
| bb.fatal("Only a single boot script is supported (already set to: %s)" % bootscriptid) |
| imgsource = imageflags.get('file', None) |
| imgpath = d.getVar("DEPLOY_DIR_IMAGE") |
| bootscriptid = imgsource |
| fitimage_emit_section_bootscript(d, fd, imgpath, imgsource) |
| fitimage_emit_section_end(d, fd) |
| # |
| # Step 5: Prepare a configurations section |
| # |
| fitimage_emit_section_start(d, fd, 'configurations') |
| dtbcount = 1 |
| for dtb in (DTBS or "").split(): |
| import subprocess |
| try: |
| cmd = "fdtget -t s {} / compatible".format(dtb) |
| compatible = subprocess.check_output(cmd, shell=True, text=True).split()[0] |
| except subprocess.CalledProcessError: |
| bb.fatal("Failed to find root-node compatible string in (%s)" % dtb) |
| |
| dtb_path, dtb_file = os.path.split(dtb) |
| fitimage_emit_section_config(d, fd, dtb_file, kernelcount, ramdiskcount, setupcount, bootscriptid, compatible, dtbcount) |
| dtbcount += 1 |
| for dtb in (DTBOS or "").split(): |
| import subprocess |
| try: |
| cmd = "fdtget -t s {} / compatible".format(dtb) |
| compatible = subprocess.check_output(cmd, shell=True, text=True).split()[0] |
| except subprocess.CalledProcessError: |
| bb.note("Failed to find root-node compatible string in (%s)" % dtb) |
| compatible = None |
| |
| dtb_path, dtb_file = os.path.split(dtb) |
| fitimage_emit_section_config_fdto(d, fd, dtb_file, compatible) |
| |
| fitimage_emit_section_end(d, fd) |
| fitimage_emit_fit_footer(d, fd) |
| } |
| |
| do_configure[postfuncs] += "write_manifest" |
| |
| do_fitimage () { |
| if [ "${FITIMAGE_SIGN}" = "1" ]; then |
| uboot-mkimage ${FITIMAGE_MKIMAGE_EXTRA_ARGS} \ |
| -k ${FITIMAGE_SIGN_KEYDIR} -r \ |
| -f "${B}/manifest.its" \ |
| "${B}/fitImage" |
| else |
| uboot-mkimage ${FITIMAGE_MKIMAGE_EXTRA_ARGS} \ |
| -f "${B}/manifest.its" \ |
| "${B}/fitImage" |
| fi |
| } |
| addtask fitimage after do_configure |
| |
| ITS_NAME ?= "${PN}-${KERNEL_ARTIFACT_NAME}" |
| ITS_LINK_NAME ?= "${PN}-${KERNEL_ARTIFACT_LINK_NAME}" |
| FITIMAGE_IMAGE_NAME ?= "fitImage-${PN}-${KERNEL_FIT_NAME}${KERNEL_FIT_BIN_EXT}" |
| FITIMAGE_IMAGE_LINK_NAME ?= "fitImage-${PN}-${KERNEL_FIT_LINK_NAME}" |
| |
| SSTATE_SKIP_CREATION:task-deploy = '1' |
| |
| do_deploy() { |
| bbnote 'Copying fit-image.its source file...' |
| install -m 0644 ${B}/manifest.its ${DEPLOYDIR}/${ITS_NAME}.its |
| |
| bbnote 'Copying all created fdt from type fdtapply' |
| for DTB_FILE in `find ${B} -maxdepth 1 -name *.dtb`; do |
| install -m 0644 ${DTB_FILE} ${DEPLOYDIR}/ |
| done |
| |
| bbnote 'Copying fitImage file...' |
| install -m 0644 ${B}/fitImage ${DEPLOYDIR}/${FITIMAGE_IMAGE_NAME} |
| |
| cd ${DEPLOYDIR} |
| ln -sf ${ITS_NAME}.its ${ITS_LINK_NAME}.its |
| ln -sf ${FITIMAGE_IMAGE_NAME} ${FITIMAGE_IMAGE_LINK_NAME} |
| } |
| addtask deploy after do_fitimage before do_build |
