openclaw/tqma6-yocto-mirror
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Complete Yocto mirror with license table for TQMa6UL (2038-compliance)

Browse Source 
- 264 license table entries with exact download URLs (224/264 resolved)
- Complete sources/ directory with all BitBake recipes
- Build configuration: tqma6ul-multi-mba6ulx, spaetzle (musl)
- Full traceability for Softwarefreigabeantrag
- GCC 13.4.0, Linux 6.6.102, U-Boot 2023.04, musl 1.2.4
- License distribution: GPL-2.0 (24), MIT (23), GPL-2.0+ (18), BSD-3 (16)
This commit is contained in:
Siggi (OpenClaw Agent)
2026-03-01 20:58:18 +00:00
commit 16accb6b24
15086 changed files with 1292356 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
sources/meta-freescale/classes/fsl-dynamic-packagearch.bbclass Normal file
View File

@@ -0,0 +1,80 @@
# Automatically set PACKAGE_ARCH for MACHINE_SOCARCH
#
# This allow to easy reuse of binary packages among similar SoCs. The
# usual use for this is to share SoC specific packages among different
# boards.
#
# MACHINE_SOCARCH_FILTER list all packages associated with
# MACHINE_SOCARCH and, when match, will set PACKAGE_ARCH as MACHINE_SOCARCH
#
# MACHINE_ARCH_FILTER list all packages associated with
# MACHINE_ARCH and, when match, will set PACKAGE_ARCH as MACHINE_ARCH
#
# For example, in meta-fsl-arm, this is used to share GPU packages for
# i.MX53 boards (as all them share the AMD GPU) and i.MX6 based boards
# (as all them share Vivante GPU).
#
# To use the class, specify, for example:
#
# MACHINE_SOCARCH_SUFFIX_soc = "-soc"
#
# and the need filters, as:
#
# MACHINE_ARCH_FILTER = "virtual/kernel"
# MACHINE_SOCARCH_FILTER_soc = "virtual/libgles1 ... virtual/libgl"
#
# Copyright 2013-2016 (C) O.S. Systems Software LTDA.
python __anonymous () {
machine_arch_filter = set((d.getVar("MACHINE_ARCH_FILTER") or "").split())
machine_socarch_filter = set((d.getVar("MACHINE_SOCARCH_FILTER") or "").split())
if machine_socarch_filter or machine_arch_filter:
provides = set((d.getVar("PROVIDES") or "").split())
depends = set((d.getVar("DEPENDS") or "").split())
PN = d.getVar("PN")
package_arch = None
if list(machine_arch_filter & (provides | depends)):
package_arch = d.getVar("MACHINE_ARCH")
elif list(machine_socarch_filter & (provides | depends)):
package_arch = d.getVar("MACHINE_SOCARCH")
if not package_arch:
raise bb.parse.SkipPackage("You must set MACHINE_SOCARCH as MACHINE_SOCARCH_FILTER is set for this SoC.")
machine_socarch_suffix = d.getVar("MACHINE_SOCARCH_SUFFIX")
if not machine_socarch_suffix:
raise bb.parse.SkipPackage("You must set MACHINE_SOCARCH_SUFFIX as MACHINE_SOCARCH_FILTER is set for this SoC.")
if package_arch:
bb.debug(1, "Use '%s' as package architecture for '%s'" % (package_arch, PN))
d.setVar("PACKAGE_ARCH", package_arch)
cur_package_archs = (d.getVar("PACKAGE_ARCHS") or "").split()
machine_socarch = (d.getVar("MACHINE_SOCARCH") or "")
if not machine_socarch in cur_package_archs:
d.appendVar("PACKAGE_EXTRA_ARCHS", " %s" % machine_socarch)
multilib_variants = (d.getVar("MULTILIB_VARIANTS") or "").split()
for variant in multilib_variants:
defaulttune = d.getVar("DEFAULTTUNE:virtclass-multilib-" + variant)
if defaulttune:
package_extra_archs_tune_archs = (d.getVar("PACKAGE_EXTRA_ARCHS:tune-" + defaulttune) or "").split()
arch_suffix = d.getVar("MACHINE_SOCARCH_SUFFIX")
for arch in package_extra_archs_tune_archs:
socarch = arch + arch_suffix
if not socarch in cur_package_archs:
d.appendVar("PACKAGE_EXTRA_ARCHS", " %s" % socarch )
if d.getVar("TUNE_ARCH") == "arm":
# For ARM we have two possible machine_socarch values, one for the arm and one for the thumb instruction set
# add the other value to extra archs also, so that a image recipe searches both for packages.
if d.getVar("ARM_INSTRUCTION_SET") == "thumb":
d.appendVar("PACKAGE_EXTRA_ARCHS", " %s" % d.getVar("ARM_EXTRA_SOCARCH"))
else:
d.appendVar("PACKAGE_EXTRA_ARCHS", " %s" % d.getVar("THUMB_EXTRA_SOCARCH"))
}
MACHINE_SOCARCH = "${TUNE_PKGARCH}${MACHINE_SOCARCH_SUFFIX}"
ARM_EXTRA_SOCARCH = "${ARMPKGARCH}${ARMPKGSFX_DSP}${ARMPKGSFX_EABI}${ARMPKGSFX_ENDIAN}${ARMPKGSFX_FPU}${MACHINE_SOCARCH_SUFFIX}"
THUMB_EXTRA_SOCARCH = "${ARMPKGARCH}${ARM_THUMB_SUFFIX}${ARMPKGSFX_DSP}${ARMPKGSFX_EABI}${ARMPKGSFX_ENDIAN}${ARMPKGSFX_FPU}${MACHINE_SOCARCH_SUFFIX}"

226
sources/meta-freescale/classes/fsl-eula-unpack.bbclass Normal file
View File

@@ -0,0 +1,226 @@
# fsl-eula-unpack.bbclass provides the mechanism used for unpacking
# the .bin file downloaded by HTTP and handle the EULA acceptance.
#
# To use it, the 'fsl-eula' parameter needs to be added to the
# SRC_URI entry, e.g:
#
# SRC_URI = "${FSL_MIRROR}/firmware-imx-${PV};fsl-eula=true"
FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V8 = "01ba08a2b77c3a0a9d0ab5d4d83fed64"
FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V10 = "3880bb9c943b135a30fad5e8aabd3ee9"
FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V11 = "a31dce3023402a821cfcdc1bb8dbdbc0"
FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V12 = "8cf95184c220e247b9917e7244124c5a"
FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V13 = "102094e9e695888c6a9f9fda9004165d"
FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V14 = "d4f548f93b5fe0ee2bc86758c344412d"
FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V16 = "be67a88e9e6c841043b005ad7bcf8309"
FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V17 = "88595f92466edd79be7f4f9547ffa0ef"
FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V18 = "6b552f505eedab4a11ab538cf3db743a"
FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V20 = "08fd295cce89b0a9c74b9b83ed74f671"
FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V21 = "6bd2df2910a2234bf6f419b7d2f531a3"
FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V22 = "75abe2fa1d16ca79f87cde926f05f72d"
FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V24 = "ab61cab9599935bfe9f700405ef00f28"
FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V26 = "5ab1a30d0cd181e3408077727ea5a2db"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V3 = "6dfb32a488e5fd6bae52fbf6c7ebb086"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V5 = "80c0478f4339af024519b3723023fe28"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V7 = "fb0303e4ee8b0e71c094171e2272bd44"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V8 = "72c0f70181bb6e83eee6aab8de12a9f3"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V9 = "6c12031a11b81db21cdfe0be88cac4b3"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V10 = "fd4b227530cd88a82af6a5982cfb724d"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V11 = "228c72f2a91452b8a03c4cab30f30ef9"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V13 = "1b4db4b25c3a1e422c0c0ed64feb65d2"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V15 = "983e4c77621568488dd902b27e0c2143"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V16 = "e9e880185bda059c90c541d40ceca922"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V17 = "cf3f9b8d09bc3926b1004ea71f7a248a"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V18 = "231e11849a4331fcbb19d7f4aab4a659"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V19 = "a632fefd1c359980434f9389833cab3a"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V22 = "3c3fe2b904fd694f28d2f646ee16dddb"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V23 = "85d06b38f17b935ca11784d67075b846"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V24 = "417b82f17fc02b88125331ed312f6f1b"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V24.1 = "b3b0bab6ff55420d043cf1652c52d788"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V25 = "f35df765ff17e69043ea21f350e3229c"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V27 = "e565271ec9a80ce47abbddc4bffe56fa"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V29 = "28241cb895217d7946e40e7227136d02"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V30 = "03bcadc8dc0a788f66ca9e2b89f56c6f"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V31 = "dedee5689786754f61ea3a76035c8a81"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V32 = "17d2319de7baa686e8a755ba58a9ebf5"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V33 = "e4098ac4459cb81b07d3f0c22b3e8370"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V34 = "be5ff43682ed6c57dfcbeb97651c2829"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V35 = "d3c315c6eaa43e07d8c130dc3a04a011"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V36 = "b54da624b8d2ffe8a3b47757da48e60f"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V37 = "37cb2d8c2bcf8bf2fbe0366d5d928c29"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V38 = "65c483bb431ccd9a1820e6872c604771"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V39 = "5a0bf11f745e68024f37b4724a5364fe"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V40 = "add2d392714d3096ed7e0f7e2190724b"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V42 = "ea25d099982d035af85d193c88a1b479"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V44 = "d7853b7bf2936b2c25c893eac7033374"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V45 = "63a38e9f392d8813d6f1f4d0d6fbe657"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V46 = "673fa34349fa40f59e0713cb0ac22b1f"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V47 = "9135422c7a38dac21bf1f858b6ef3bac"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V48 = "db4762b09b6bda63da103963e6e081de"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V49 = "2827219e81f28aba7c6a569f7c437fa7"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V53 = "44a8052c384584ba09077e85a3d1654f"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V56 = "10c0fda810c63b052409b15a5445671a"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V57 = "ca53281cc0caa7e320d4945a896fb837"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V58 = "c0fb372b5d7f12181de23ef480f225f3"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V60 = "cf2070b16b9d4acf60a98e8cbc32a25a"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V62 = "a93b654673e1bc8398ed1f30e0813359"
FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V63 = "bc649096ad3928ec06a8713b8d787eac"
FSL_EULA_FILE_MD5SUMS = " \
${FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V8} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V10} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V11} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V12} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V13} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V14} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V16} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V17} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V18} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V20} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V21} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V22} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V24} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_BASE_LICENSE_V26} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V3} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V5} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V7} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V8} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V9} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V10} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V11} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V13} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V15} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V16} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V17} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V18} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V19} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V22} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V23} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V24} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V24.1} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V25} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V27} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V29} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V30} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V31} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V32} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V33} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V34} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V35} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V36} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V37} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V38} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V39} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V40} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V42} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V44} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V45} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V46} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V47} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V48} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V49} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V53} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V56} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V57} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V58} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V60} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V62} \
${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V63} \
"
# The checksum for the EULA in the layer
FSL_EULA_FILE_MD5SUM ?= \
"${FSL_EULA_FILE_MD5SUM_LA_OPT_NXP_SOFTWARE_LICENSE_V63}"
LIC_FILES_CHKSUM_LAYER ?= "file://${FSL_EULA_FILE};md5=${FSL_EULA_FILE_MD5SUM}"
LIC_FILES_CHKSUM_LAYER[vardepsexclude] += "FSL_EULA_FILE"
LIC_FILES_CHKSUM:append = " ${LIC_FILES_CHKSUM_LAYER}"
LIC_FILES_CHKSUM[vardepsexclude] += "FSL_EULA_FILE"
do_fetch:prepend() {
if "Proprietary" not in d.getVar("LICENSE"):
bb.fatal("The recipe LICENSE should include Proprietary but is " + d.getVar("LICENSE") + ".")
}
do_unpack[vardepsexclude] += "FSL_EULA_FILE"
python do_unpack() {
eula = d.getVar('ACCEPT_FSL_EULA')
eula_file = d.getVar('FSL_EULA_FILE')
pkg = d.getVar('PN')
if eula == None:
bb.fatal("To use '%s' you need to accept the Freescale EULA at '%s'. "
"Please read it and in case you accept it, write: "
"ACCEPT_FSL_EULA = \"1\" in your local.conf." % (pkg, eula_file))
elif eula == '0':
bb.fatal("To use '%s' you need to accept the Freescale EULA." % pkg)
else:
bb.note("Freescale EULA has been accepted for '%s'" % pkg)
try:
bb.build.exec_func('base_do_unpack', d)
except:
raise
bb.build.exec_func('fsl_bin_do_unpack', d)
}
python fsl_bin_do_unpack() {
src_uri = (d.getVar('SRC_URI') or "").split()
if len(src_uri) == 0:
return
localdata = bb.data.createCopy(d)
rootdir = localdata.getVar('WORKDIR', True)
fetcher = bb.fetch2.Fetch(src_uri, localdata)
found = 0
for url in fetcher.ud.values():
# Skip this fetcher if it's not under EULA or if the fetcher type is not supported
if not url.parm.get('fsl-eula', False) or url.type not in ['http', 'https', 'ftp', 'file']:
continue
# If download has failed, do nothing
if not os.path.exists(url.localpath):
bb.debug(1, "Exiting as '%s' cannot be found" % url.basename)
return
found += 1
bb.note("Handling file '%s' as a Freescale EULA-licensed archive." % url.basename)
cmd = "sh %s --auto-accept --force" % (url.localpath)
bb.fetch2.runfetchcmd(cmd, d, quiet=True, workdir=rootdir)
if not found:
bb.fatal("The recipe inherits 'fsl-eula-unpack.bbclass' but does not mark any URL in SRC_URI with the option 'fsl-eula=true'")
# Check for two EULAs, one from the layer and one from the package
bb.note("Checking LIC_FILES_CHKSUM for Freescale EULA consistency...")
if found > 1:
bb.warn("The package contains multiple Freescale EULA-licensed archives. The consistency logic may not be able to detect a EULA problem.")
(layer_license, licenses, md5sums, found_layer_licenses, found_package_licenses) = find_nxp_eula_licenses(d)
if not found_layer_licenses:
bb.fatal("The Freescale layer EULA '%s' is not listed in LIC_FILES_CHKSUM '%s'."
% (layer_license, licenses))
if not found_package_licenses:
bb.fatal("A valid package EULA with md5sum in %s was not found in LIC_FILES_CHKSUM '%s'."
% (md5sums.split(), licenses))
}
def find_nxp_eula_licenses(d):
layer_license = d.getVar('LIC_FILES_CHKSUM_LAYER')
licenses = d.getVar('LIC_FILES_CHKSUM') or ""
md5sums = d.getVar('FSL_EULA_FILE_MD5SUMS') or ""
found_layer_licenses = ""
found_package_licenses = ""
for license in licenses.split():
try:
(method, host, path, user, pswd, parm) = bb.fetch.decodeurl(license)
if method != "file" or not path:
raise bb.fetch.MalformedUrl()
except bb.fetch.MalformedUrl:
bb.fatal("%s: LIC_FILES_CHKSUM contains an invalid URL: %s" % (d.getVar('PF'), license))
if license == layer_license:
bb.note("Found Freescale EULA for the layer %s." % license)
found_layer_licenses += license
elif parm.get('md5') in md5sums:
bb.note("Found Freescale EULA for the package %s." % license)
found_package_licenses += license
return (layer_license, licenses, md5sums, found_layer_licenses, found_package_licenses)

47
sources/meta-freescale/classes/fsl-kernel-localversion.bbclass Normal file
View File

@@ -0,0 +1,47 @@
# Freescale Kernel LOCALVERSION extension
#
# This allow to easy reuse of code between different kernel recipes
#
# The following options are supported:
#
# SCMVERSION Puts the Git hash in kernel local version
# LOCALVERSION Value used in LOCALVERSION (default to '+fslc')
#
# Copyright 2014, 2015 (C) O.S. Systems Software LTDA.
SCMVERSION ??= "y"
LOCALVERSION ??= "+fslc"
# LINUX_VERSION_EXTENSION is used as CONFIG_LOCALVERSION by kernel-yocto class
LINUX_VERSION_EXTENSION ?= "${LOCALVERSION}"
do_kernel_localversion[dirs] += "${S} ${B}"
do_kernel_localversion() {
# Fallback for recipes not able to use LINUX_VERSION_EXTENSION
if [ "${@bb.data.inherits_class('kernel-yocto', d)}" = "False" ]; then
echo 'CONFIG_LOCALVERSION="${LOCALVERSION}"' >> ${B}/.config
fi
if [ "${SCMVERSION}" = "y" ]; then
# Add GIT revision to the local version
if [ "${SRCREV}" = "INVALID" ]; then
hash=${SRCREV_machine}
else
hash=${SRCREV}
fi
if [ "$hash" = "AUTOINC" ]; then
branch=`git --git-dir=${S}/.git symbolic-ref --short -q HEAD`
head=`git --git-dir=${S}/.git rev-parse --verify --short origin/${branch} 2> /dev/null`
else
head=`git --git-dir=${S}/.git rev-parse --verify --short $hash 2> /dev/null`
fi
patches=`git --git-dir=${S}/.git rev-list --count $head..HEAD 2> /dev/null`
printf "%s%s%s%s" +g $head +p $patches > ${S}/.scmversion
sed -i -e "/CONFIG_LOCALVERSION_AUTO[ =]/d" ${B}/.config
echo "CONFIG_LOCALVERSION_AUTO=y" >> ${B}/.config
fi
}
addtask kernel_localversion before do_configure after do_patch do_kernel_configme

38
sources/meta-freescale/classes/fsl-u-boot-localversion.bbclass Normal file
View File

@@ -0,0 +1,38 @@
# Freescale U-Boot LOCALVERSION extension
#
# This allow to easy reuse of code between different U-Boot recipes
#
# The following options are supported:
#
# SCMVERSION Puts the Git hash in U-Boot local version
# LOCALVERSION Value used in LOCALVERSION (default to '+fslc')
#
# Copyright 2014 (C) O.S. Systems Software LTDA.
SCMVERSION ??= "y"
LOCALVERSION ??= "+fslc"
UBOOT_LOCALVERSION = "${LOCALVERSION}"
do_compile:prepend() {
if [ "${SCMVERSION}" = "y" ]; then
# Add GIT revision to the local version
if [ "${SRCREV}" = "INVALID" ]; then
hash=${SRCREV_machine}
else
hash=${SRCREV}
fi
if [ "$hash" = "AUTOINC" ]; then
branch=`git --git-dir=${S}/.git symbolic-ref --short -q HEAD`
head=`git --git-dir=${S}/.git rev-parse --verify --short origin/${branch} 2> /dev/null`
else
head=`git --git-dir=${S}/.git rev-parse --verify --short $hash 2> /dev/null`
fi
patches=`git --git-dir=${S}/.git rev-list --count $head..HEAD 2> /dev/null`
printf "%s%s%s%s%s" "${UBOOT_LOCALVERSION}" +g $head +p $patches > ${S}/.scmversion
printf "%s%s%s%s%s" "${UBOOT_LOCALVERSION}" +g $head +p $patches > ${B}/.scmversion
else
printf "%s" "${UBOOT_LOCALVERSION}" > ${S}/.scmversion
printf "%s" "${UBOOT_LOCALVERSION}" > ${B}/.scmversion
fi
}

63
sources/meta-freescale/classes/fsl-vivante-kernel-driver-handler.bbclass Normal file
View File

@@ -0,0 +1,63 @@
# Freescale Kernel Vivante Kernel Driver handler
#
# Enable the kernel to provide or not the Vivante kernel driver and
# dynamically set the proper providers per machine.
#
# The following options are supported:
#
# MACHINE_HAS_VIVANTE_KERNEL_DRIVER_SUPPORT
#
# Machine does or does not have support for the Vivante kernel
# driver, options are:
#
# 0 - machine does not have Vivante GPU driver support
# 1 - machine has Vivante GPU driver support
#
# MACHINE_USES_VIVANTE_KERNEL_DRIVER_MODULE
#
# Machine uses the Vivante kernel driver as module, options are:
#
# 0 - enable the builtin kernel driver module
# 1 - enable the external kernel module
#
# Copyright 2015, 2016 (C) O.S. Systems Software LTDA.
# Released under the MIT license (see COPYING.MIT for the terms)
# Handle Vivante kernel driver setting:
# 0 - machine does not have Vivante GPU driver support
# 1 - machine has Vivante GPU driver support
MACHINE_HAS_VIVANTE_KERNEL_DRIVER_SUPPORT ??= "0"
# Use Vivante kernel driver module:
# 0 - enable the builtin kernel driver module
# 1 - enable the external kernel module
MACHINE_USES_VIVANTE_KERNEL_DRIVER_MODULE ??= "${@d.getVar('MACHINE_HAS_VIVANTE_KERNEL_DRIVER_SUPPORT', False) or '0'}"
python fsl_vivante_kernel_driver_handler () {
has_vivante_kernel_driver_support = e.data.getVar('MACHINE_HAS_VIVANTE_KERNEL_DRIVER_SUPPORT', True) or "0"
use_vivante_kernel_driver_module = e.data.getVar('MACHINE_USES_VIVANTE_KERNEL_DRIVER_MODULE', True) or "0"
if has_vivante_kernel_driver_support != "1":
return
if use_vivante_kernel_driver_module != "1":
e.data.appendVar('RPROVIDES:${KERNEL_PACKAGE_NAME}-base', ' ${MLPREFIX}kernel-module-imx-gpu-viv')
e.data.appendVar('RREPLACES:${KERNEL_PACKAGE_NAME}-base', ' ${MLPREFIX}kernel-module-imx-gpu-viv')
e.data.appendVar('RCONFLICTS:${KERNEL_PACKAGE_NAME}-base', ' ${MLPREFIX}kernel-module-imx-gpu-viv')
}
addhandler fsl_vivante_kernel_driver_handler
fsl_vivante_kernel_driver_handler[eventmask] = "bb.event.RecipePreFinalise"
do_configure:append () {
if [ "${MACHINE_HAS_VIVANTE_KERNEL_DRIVER_SUPPORT}" = "1" ]; then
config="${B}/.config"
sed -i "/CONFIG_MXC_GPU_VIV[ =]/d" $config
if [ "${MACHINE_USES_VIVANTE_KERNEL_DRIVER_MODULE}" = "1" ]; then
echo "# CONFIG_MXC_GPU_VIV is not set" >> $config
else
echo "CONFIG_MXC_GPU_VIV=y" >> $config
fi
fi
}

139
sources/meta-freescale/classes/image_populate_mfgtool.bbclass Normal file
View File

@@ -0,0 +1,139 @@
# Allow generation of mfgtool bundle
#
# The class provides the infrastructure for MFGTOOL generation and is tied to images. To generate
# the bundle, the task populate_mfgtool must be called. For example:
#
# ,----[ Running populate_mfgtool for core-image-minimal image ]
# | $: bitbake core-image-minimal -c populate_mfgtool
# `----
#
# The class behavior is controlled through the MFGTOOLCONFIG (analogous to PACKAGECONFIG)
# variable. The MFGTOOLCONFIG variable itself specifies a space-separated list of the script to
# enable. Following the script, you can determine the behavior of each script by providing up to two
# order-dependent arguments, which are separated by commas. You can omit any argument you like but
# must retain the separating commas. The order is important and specifies the following:
#
# 1. Extra dependencies that should be added to the do_populate_mfgtool task, if the script is
# enabled.
# 2. Extra binaries that should be added to the bundle, if the script is enabled.
#
# For example:
#
# ,----[ Defining foo.uuu.in and bar.uuu script ]
# | MFGTOOLCONFIG = "foo.uuu.in bar.uuu"
# | MFGTOOLCONFIG[foo.uuu.in] = "dep-foo1:do_deploy dep-foo2:do_deploy,file-foo1"
# | MFGTOOLCONFIG[bar.uuu] = "dep-bar1:do_deploy,file-bar1 file-bar2"
# `----
#
# The dep-foo1:do_deploy, dep-foo2:do_deploy, and dep-bar1:do_deploy are added to
# do_populate_mfgtool dependencies. In addition, file-foo1, file-bar1, and file-bar2 are copied to
# the bundle, only if the script is enabled.
#
# During the mfgtool bundle generation, the uuu.in files are processed and some variables
# replaced. The variables are:
#
# - MACHINE
# - UBOOT_BINARY
# - SPL_BINARY
# - IMAGE_BASENAME
#
# Copyright 2022-2023 (C) O.S. Systems Software LTDA.
#
# SPDX-License-Identifier: MIT
MFGTOOL_FILESPATH ??= " \
${@base_set_filespath(["%s/mfgtool" % p for p in "${BBPATH}".split(":")] \
+ ["${FILE_DIRNAME}/${BP}/mfgtool", \
"${FILE_DIRNAME}/${BPN}/mfgtool", \
"${FILE_DIRNAME}/files/mfgtool"] \
, d)} \
"
MFGTOOLDIR = "${WORKDIR}/mfgtool-${PN}"
do_populate_mfgtool[dirs] += "${MFGTOOLDIR}"
do_populate_mfgtool[cleandirs] = "${MFGTOOLDIR}"
addtask populate_mfgtool after do_image_complete do_unpack before do_deploy
do_populate_mfgtool[nostamp] = "1"
do_populate_mfgtool[dirs] += "${DEPLOY_DIR_IMAGE} ${WORKDIR}"
do_populate_mfgtool[recrdeptask] += "do_deploy"
do_populate_mfgtool[depends] += "uuu-bin:do_populate_sysroot"
python () {
depends = []
deploy_files = ""
scripts = (d.getVar('MFGTOOLCONFIG') or "").split()
scripts_and_flags = d.getVarFlags('MFGTOOLCONFIG') or {}
for flag, flagval in sorted(scripts_and_flags.items()):
items = flagval.split(",")
num = len(items)
if num > 2:
bb.error("%s: MFGTOOLCONFIG[%s] Only \"depends,deploy files\" can be specified!" % (d.getVar("PN"), flag))
if flag in scripts:
if num >= 2 and items[1]:
deploy_files += ' ' + items[1]
if num >= 1 and items[0]:
depends.append(items[0])
d.appendVarFlag('do_populate_mfgtool', 'depends', ' ' + ' '.join(depends))
d.setVar('_SCRIPT_DEPLOY_FILES', ' '.join(sorted(list(set(deploy_files.split())))))
}
python do_populate_mfgtool() {
# For MFGTOOLCONFIG items we use BitBake's fetcher module allowing a consistent behavior.
scripts = (d.getVar('MFGTOOLCONFIG') or "").split()
src_uri = ["file://%s" % f for f in scripts]
if not src_uri:
bb.fatal("MFGTOOLCONFIG is empty so populate_mfgtool cannot be run.")
return
bb.debug(1, "following scripts are used: %s" % ', '.join(scripts))
localdata = bb.data.createCopy(d)
filespath = (d.getVar('MFGTOOL_FILESPATH') or "")
localdata.setVar('FILESPATH', filespath)
try:
fetcher = bb.fetch2.Fetch(src_uri, localdata)
fetcher.unpack(localdata.getVar('WORKDIR'))
except bb.fetch2.BBFetchException as e:
bb.fatal("BitBake Fetcher Error: " + repr(e))
# Generate MFGTOOL bundle.
bb.build.exec_func('generate_mfgtool_bundle', d)
}
generate_mfgtool_bundle() {
bbnote "Processing uuu files ..."
for src in $(ls -1 ${WORKDIR}/*.uuu.in); do
dest=$(echo $src | sed 's,.in$,,g')
bbnote " - $src -> $dest"
sed -e 's/@@MACHINE@@/${MACHINE}/g' \
-e "s,@@UBOOT_BINARY@@,${UBOOT_BINARY},g" \
-e "s,@@SPL_BINARY@@,${SPL_BINARY},g" \
-e "s,@@IMAGE_BASENAME@@,${IMAGE_BASENAME},g" \
$src > $dest
done
bbnote "Deploying uuu files ..."
for src in $(ls -1 ${WORKDIR}/*.uuu); do
dest=$(basename $src)
bbnote " - $src -> ${MFGTOOLDIR}/${PN}-${MACHINE}/$dest"
install -D -m 0644 $src ${MFGTOOLDIR}/${PN}-${MACHINE}/$dest
done
bbnote "Copying uuu binaries..."
cp -v -s ${STAGING_LIBDIR}/uuu/* ${MFGTOOLDIR}/${PN}-${MACHINE}/
bbnote "Copying MFGTOOL extra deploy files..."
for f in ${_SCRIPT_DEPLOY_FILES}; do
mkdir -p ${MFGTOOLDIR}/${PN}-${MACHINE}/binaries
cp -v -s ${DEPLOY_DIR_IMAGE}/$f ${MFGTOOLDIR}/${PN}-${MACHINE}/binaries/
done
tar -czf ${DEPLOY_DIR_IMAGE}/mfgtool-bundle-${PN}-${MACHINE}.tar.gz \
--dereference -C ${MFGTOOLDIR} ${PN}-${MACHINE}
ln -fs mfgtool-bundle-${PN}-${MACHINE}.tar.gz \
${DEPLOY_DIR_IMAGE}/mfgtool-bundle-${PN}.tar.gz
}

44
sources/meta-freescale/classes/image_types_fsl.bbclass Normal file
View File

@@ -0,0 +1,44 @@
inherit image_types
# Handle u-boot suffixes
UBOOT_SUFFIX ?= "bin"
#
# Handles i.MX mxs bootstream generation
#
MXSBOOT_NAND_ARGS ?= ""
# U-Boot mxsboot generation for uSD
do_image_uboot_mxsboot_sdcard[depends] += "u-boot-mxsboot-native:do_populate_sysroot \
u-boot:do_deploy"
IMAGE_CMD:uboot-mxsboot-sdcard() {
mxsboot sd ${DEPLOY_DIR_IMAGE}/u-boot-${MACHINE}.${UBOOT_SUFFIX} \
${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.uboot-mxsboot-sdcard
ln -sf ${IMAGE_NAME}.uboot-mxsboot-sdcard \
${DEPLOY_DIR_IMAGE}/${IMAGE_LINK_NAME}.uboot-mxsboot-sdcard
}
# U-Boot mxsboot generation for NAND
do_image_uboot_mxsboot_nand[depends] += "u-boot-mxsboot-native:do_populate_sysroot \
u-boot:do_deploy"
IMAGE_CMD:uboot-mxsboot-nand() {
mxsboot ${MXSBOOT_NAND_ARGS} nand \
${DEPLOY_DIR_IMAGE}/u-boot-${MACHINE}.${UBOOT_SUFFIX} \
${DEPLOY_DIR_IMAGE}/${IMAGE_NAME}.uboot-mxsboot-nand
ln -sf ${IMAGE_NAME}.uboot-mxsboot-nand \
${DEPLOY_DIR_IMAGE}/${IMAGE_LINK_NAME}.uboot-mxsboot-nand
}
# In case we are building for i.MX23 or i.MX28 we need to have the
# image stream built before the wic generation
do_image_wic[depends] += " \
${@bb.utils.contains('IMAGE_FSTYPES', 'uboot-mxsboot-sdcard', \
'${IMAGE_BASENAME}:do_image_uboot_mxsboot_sdcard', '', d)} \
"
# We need to apply a fixup inside of the partition table
IMAGE_CMD:wic:append:mxs-generic-bsp() {
# Change partition type for mxs processor family
bbnote "Setting partition type to 0x53 as required for mxs' SoC family."
echo -n S | dd of=$out.wic bs=1 count=1 seek=450 conv=notrunc
}

109
sources/meta-freescale/classes/imx-boot-container.bbclass Normal file
View File

@@ -0,0 +1,109 @@
#
# This class provides a support to build the boot container for
# i.MX8M derivatives
#
# imx8m machines require a separate build target to be executed
# due to the fact that final boot image is constructed using flash.bin
# taget. It produces a boot binary image, which is constructed from
# various binary components (u-boot with separate dtb, atf, DDR
# firmware and optional op-tee) into a single image using FIT format.
# This flash.bin file is then parsed and loaded either via
# SPL directly (imx8mm), or using bootrom code (imx8mn and imx8mp).
#
# In order to use flash.bin binary boot image, it is required that
# the U-Boot build is to be invoked for an additional build target.
# This class extendes the U-Boot build targets with the "flash.bin",
# which effectively serves as a boot container. It replaces the boot
# container `imx-boot` provided by NXP.
#
# Class inheritance is performed in u-boot-fslc recipe, and is controlled
# by variable UBOOT_PROVIDES_BOOT_CONTAINER, which is defined in the
# base machine include file (imx-base.inc).
#
# NOTE: A backwards-compatible symlink is added for 'flash.bin', named
# 'imx-boot', during the deployment task.
# Define ATF binary file to be deployed to the U-Boot build folder
ATF_MACHINE_NAME = "bl31-${ATF_PLATFORM}.bin"
ATF_MACHINE_NAME:append = "${@bb.utils.contains('MACHINE_FEATURES', 'optee', '-optee', '', d)}"
IMX_BOOT_CONTAINER_FIRMWARE_SOC ?= ""
IMX_BOOT_CONTAINER_FIRMWARE_SOC:mx8mq-generic-bsp = " \
signed_dp_imx8m.bin \
signed_hdmi_imx8m.bin \
"
IMX_BOOT_CONTAINER_FIRMWARE ?= " \
${IMX_BOOT_CONTAINER_FIRMWARE_SOC} \
${DDR_FIRMWARE_NAME} \
"
# This package aggregates output deployed by other packages, so set the
# appropriate dependencies for populate binaries task
do_resolve_and_populate_binaries[depends] += " \
${@' '.join('%s:do_deploy' % r for r in '${IMX_EXTRA_FIRMWARE}'.split() )} \
${IMX_DEFAULT_ATF_PROVIDER}:do_deploy \
${@bb.utils.contains('MACHINE_FEATURES', 'optee', 'optee-os:do_deploy', '', d)} \
"
# Define an additional task that collects binary output from dependent packages
# and deploys them into the U-Boot build folder
do_resolve_and_populate_binaries() {
if [ -n "${UBOOT_CONFIG}" ]; then
for config in ${UBOOT_MACHINE}; do
i=$(expr $i + 1);
for type in ${UBOOT_CONFIG}; do
j=$(expr $j + 1);
if [ $j -eq $i ]; then
for firmware in ${IMX_BOOT_CONTAINER_FIRMWARE}; do
bbnote "Copy firmware: ${firmware} from ${DEPLOY_DIR_IMAGE} -> ${B}/${config}/"
cp ${DEPLOY_DIR_IMAGE}/${firmware} ${B}/${config}/
done
if [ -n "${ATF_MACHINE_NAME}" ]; then
cp ${DEPLOY_DIR_IMAGE}/${ATF_MACHINE_NAME} ${B}/${config}/bl31.bin
else
bberror "ATF binary is undefined, result binary would be unusable!"
fi
fi
done
unset j
done
unset i
fi
}
addtask do_resolve_and_populate_binaries before do_compile after do_configure
# Append the u-boot do_deploy task to deploy also the result flash.bin
# boot container as a replacement for the one provided by NXP BSP.
#
# Deploy task renames the target file from flash.bin to imx-boot to match
# the name WKS file requires.
#
# This effectively would allow the usage of the same WKS file for those
# derivatives that are using the boot container from U-Boot and those
# that are not yet have support for it enabled.
do_deploy:append() {
# Deploy the resulted flash.bin for WIC to pick it up
if [ -n "${UBOOT_CONFIG}" ]; then
for config in ${UBOOT_MACHINE}; do
i=$(expr $i + 1);
for type in ${UBOOT_CONFIG}; do
j=$(expr $j + 1);
if [ $j -eq $i ]
then
install -m 0644 ${B}/${config}/flash.bin ${DEPLOYDIR}/flash.bin-${MACHINE}-${type}
# When there's more than one word in UBOOT_CONFIG,
# the first UBOOT_CONFIG listed will be the imx-boot binary
if [ ! -f "${DEPLOYDIR}/imx-boot" ]; then
ln -sf flash.bin-${MACHINE}-${type} flash.bin
ln -sf flash.bin-${MACHINE}-${type} imx-boot
ln -sf flash.bin.tagged imx-boot.tagged
else
bbwarn "Use custom wks.in for $UBOOT_CONFIG = $type"
fi
fi
done
unset j
done
unset i
fi
}

60
sources/meta-freescale/classes/kernel-imximage.bbclass Normal file
View File

@@ -0,0 +1,60 @@
# -*- python -*-
# Linux kernel with DCD headers
#
# This new image type adds support to generate a Linux kernel with DCD
# headers. Essentially it adds support to directly boot a Linux kernel
# without a bootloader.
#
# As the Linux kernel will be boot directly, it required that the Device
# Tree is appended to the kernel image. To have the Linux kernel
# generated with the DCD headers, following steps must be followed:
#
# - Linux kernel recipe must inherit kernel-imximage class;
# - Device Tree appended Linux kernel must be used
# (KERNEL_DEVICETREE_BUNDLE = "1");
# - DCD header configuration must be provided (dcd.cfg or
# dcd-<devicetree>.cfg);
#
# Copyright 2017 (C) O.S. Systems Software LTDA.
DEPENDS:append = ' u-boot-mkimage-native'
IMXIMAGE_ENTRYPOINT ?= "${UBOOT_ENTRYPOINT}"
imx_mkimage() {
uboot-mkimage -n $1 -T imximage -e ${IMXIMAGE_ENTRYPOINT} -d $2 $2.imx
}
gen_imximage() {
if [ -z "${IMXIMAGE_ENTRYPOINT}" ]; then
bbfatal "IMXIMAGE_ENTRYPOINT must have a valid value"
fi
for DTB in ${KERNEL_DEVICETREE}; do
DTB=`normalize_dtb "${DTB}"`
DTB_EXT=${DTB##*.}
DTB_BASE_NAME=`basename ${DTB} ."${DTB_EXT}"`
base_name="zImage-"${KERNEL_IMAGE_BASE_NAME}
symlink_name="zImage-"${KERNEL_IMAGE_SYMLINK_NAME}
DTB_NAME=`echo ${base_name} | sed "s/${MACHINE}/${DTB_BASE_NAME}/g"`
DTB_SYMLINK_NAME=`echo ${symlink_name} | sed "s/${MACHINE}/${DTB_BASE_NAME}/g"`
for DCD in dcd-${DTB}.cfg dcd.cfg; do
if [ -e "${WORKDIR}/${DCD}" ]; then
if [ -e ${DEPLOYDIR}/${DTB_NAME}.${DTB_EXT}.bin ]; then
imx_mkimage ${WORKDIR}/${DCD} ${DEPLOYDIR}/${DTB_NAME}.${DTB_EXT}.bin
ln -sf ${DTB_NAME}.${DTB_EXT}.bin.imx ${DEPLOYDIR}/$type-${DTB_BASE_NAME}.${DTB_EXT}.bin.imx
fi
if [ -e ${DEPLOYDIR}/zImage-${INITRAMFS_BASE_NAME}-${DTB_BASE_NAME}.${DTB_EXT}.bin ]; then
imx_mkimage ${WORKDIR}/${DCD} ${DEPLOYDIR}/zImage-${INITRAMFS_BASE_NAME}-${DTB_BASE_NAME}.${DTB_EXT}.bin
ln -sf zImage-${INITRAMFS_BASE_NAME}-${DTB_BASE_NAME}.${DTB_EXT}.bin.imx \
${DEPLOYDIR}/zImage-initramfs-${DTB_BASE_NAME}.${DTB_EXT}-${MACHINE}.bin.imx
fi
fi
done
done
}
do_deploy:append() {
gen_imximage
}

76
sources/meta-freescale/classes/machine-overrides-extender.bbclass Normal file
View File

@@ -0,0 +1,76 @@
# -*- python -*-
# Automatically set extend the MACHINEOVERRIDES
#
# This allow to grouping of different settings for similar platforms.
#
# To indicate that a SoC contains following set of overrides, you can use:
#
# MACHINEOVERRIDES_EXTENDER:soc = "group1:group2"
#
# However to indicate that an override replaces a set of other
# overrides, you can use:
#
# MACHINEOVERRIDES_EXTENDER_FILTER_OUT:override = "group1 group2"
#
# Copyright 2016-2018, 2022 (C) O.S. Systems Software LTDA.
def machine_overrides_extender(d):
machine_overrides = (d.getVar('PRISTINE_MACHINEOVERRIDES') or '').split(':')
# Gather the list of overrides to filter out
machine_overrides_filter_out = (d.getVar('MACHINEOVERRIDES_EXTENDER_FILTER_OUT') or '').split()
for override in machine_overrides:
machine_overrides_filter_out += (d.getVar('MACHINEOVERRIDES_EXTENDER_FILTER_OUT:%s' % override) or '').split()
# Extend the overrides
for override in machine_overrides:
extender = d.getVar('MACHINEOVERRIDES_EXTENDER:%s' % override)
if extender:
extender = extender.split(':')
# Drop any extension if in filter_out
extender = [e for e in extender if e not in machine_overrides_filter_out]
extender.reverse()
if not set(extender).issubset(set(machine_overrides)):
index = machine_overrides.index(override)
for e in extender:
machine_overrides.insert(index, e)
# Drop any overrides of filter_out after extending
machine_overrides = [o for o in machine_overrides if o not in machine_overrides_filter_out]
return ':'.join(machine_overrides)
python machine_overrides_extender_handler() {
# Ideally we'd use a separate variable name for this however
# historically NXP BSPs used this. We save it to a known good name
# so we can reprocess OVERRIDES if/as/when needed.
d.renameVar("MACHINEOVERRIDES", "PRISTINE_MACHINEOVERRIDES")
# Now we add our own function intercept in instead
d.setVar("MACHINEOVERRIDES", "${@machine_overrides_extender(d)}")
}
machine_overrides_extender_handler[eventmask] = "bb.event.ConfigParsed"
addhandler machine_overrides_extender_handler
python machineoverrides_filtered_out_qa_handler() {
filtered_out = (d.getVar('MACHINEOVERRIDES_EXTENDER_FILTER_OUT') or "").split()
qa_error = d.getVar('MACHINEOVERRIDES_FILTERED_OUT_QA_ERROR')
for var in d.overridedata:
# We need to allow the overrides being used in the extender
# so avoid processing it.
if 'MACHINEOVERRIDES_EXTENDER' in var:
continue
for (r, o) in d.overridedata[var]:
common = list(set(o.split(":")).intersection(filtered_out))
if len(common) > 0:
raise bb.parse.SkipRecipe(qa_error % common)
}
machineoverrides_filtered_out_qa_handler[eventmask] = "bb.event.RecipeParsed"
addhandler machineoverrides_filtered_out_qa_handler

43
sources/meta-freescale/classes/mfgtool-initramfs-image.bbclass Normal file
View File

@@ -0,0 +1,43 @@
# Generates a Manufacturing Tool Initramfs image
#
# This generates the initramfs used for the installation process. The
# image provides the utilities which are used, in the target, during
# the process and receive the commands from the MfgTool application.
#
# Copyright 2014-2017 (C) O.S. Systems Software LTDA.
DEPENDS += "linux-mfgtool"
FEATURE_PACKAGES_mtd = "packagegroup-fsl-mfgtool-mtd"
FEATURE_PACKAGES_extfs = "packagegroup-fsl-mfgtool-extfs"
FEATURE_PACKAGES_f2fs = "packagegroup-fsl-mfgtool-f2fs"
ZSTD_COMPRESSION_LEVEL ?= "-10"
SOC_DEFAULT_IMAGE_FSTYPES = "cpio.zst.u-boot"
SOC_DEFAULT_IMAGE_FSTYPES:mxs-generic-bsp = "cpio.gz.u-boot"
IMAGE_ROOTFS_SIZE ?= "8192"
IMAGE_NAME_SUFFIX = ""
# Filesystems enabled by default
DEFAULT_FS_SUPPORT = " \
mtd \
extfs \
"
IMAGE_FEATURES = " \
${DEFAULT_FS_SUPPORT} \
\
read-only-rootfs \
"
# Avoid installation of syslog
BAD_RECOMMENDATIONS += "busybox-syslog"
# Avoid static /dev
USE_DEVFS = "1"
inherit core-image
CORE_IMAGE_BASE_INSTALL = " \
${CORE_IMAGE_EXTRA_INSTALL} \
"

18
sources/meta-freescale/classes/qoriq_build_64bit_kernel.bbclass Normal file
View File

@@ -0,0 +1,18 @@
inherit features_check
REQUIRED_DISTRO_FEATURES:e6500 += "multiarch"
python () {
promote_kernel = d.getVar('BUILD_64BIT_KERNEL', False)
if promote_kernel == "1":
sys_multilib = 'powerpc64' + d.getVar('TARGET_VENDOR', False) + 'mllib64-' + d.getVar('HOST_OS', False)
tc_options = d.getVar('TOOLCHAIN_OPTIONS', False) + '/../lib64-' + d.getVar("MACHINE", False)
d.setVar('DEPENDS:append', ' lib64-gcc-cross-powerpc64 lib64-libgcc')
d.setVar('PATH:append', ':' + d.getVar('STAGING_BINDIR_NATIVE', False) + '/' + sys_multilib)
d.setVar('KERNEL_CC', d.getVar('CCACHE', False) + sys_multilib + '-' + 'gcc' + d.getVar('HOST_CC_KERNEL_ARCH', False) + tc_options)
d.setVar('KERNEL_LD', d.getVar('CCACHE', False) + sys_multilib + '-' + 'ld.bfd' + d.getVar('HOST_LD_KERNEL_ARCH', False) + tc_options)
d.setVar('KERNEL_AR', d.getVar('CCACHE', False) + sys_multilib + '-' + 'ar' + d.getVar('HOST_AR_KERNEL_ARCH', False))
error_qa = d.getVar('ERROR_QA')
if 'arch' in error_qa:
d.setVar('ERROR_QA', error_qa.replace(' arch', ''))
}

37
sources/meta-freescale/classes/use-imx-headers.bbclass Normal file
View File

@@ -0,0 +1,37 @@
# Easy use of linux-imx-headers by packages
#
# This allow to easy reuse of binary packages among similar SoCs. The
# usual use for this is to share SoC specific packages among different
# boards independently of the kernel version it is using, as far it is
# ABI compatible with the official version it will just work.
#
# All recipes using this class ought to depend on linux-imx-headers
# and by default to use MACHINE_SOCARCH.
#
# Please use the STAGING_INCDIR_IMX variable to refer to the installed
# headers.
#
# Copyright 2018 (C) O.S. Systems Software LTDA.
DEPENDS:append:imx-nxp-bsp = " linux-imx-headers"
# Set runtime dependency of -dev for package inheriting this class to
# linux-imx-headers-dev package. This is required in order to propagate
# headers into the SDK
RDEPENDS:${PN}-dev += "linux-imx-headers-dev"
PACKAGE_ARCH:imx-nxp-bsp ?= "${MACHINE_SOCARCH}"
STAGING_INCDIR_IMX = "${STAGING_INCDIR}/imx"
# Recipes that inherit this class are contracted to use NXP BSP only.
# This is done by overriding the COMPATIBLE_HOST, as this would effectively
# cause recipes to be skipped in case if 'use-nxp-bsp' override is not
# defined for them. This effectively marks recipes that should only be
# built using NXP BSP, and gives an indication to mainline BSP creators
# that recipe is not compatible with mainline.
#
# Typical example here would be imx-vpu-hantro recipe, which requires NXP
# BSP and is not compatible with mainline.
COMPATIBLE_HOST = '(null)'
COMPATIBLE_HOST:use-nxp-bsp = '.*'

38
sources/meta-freescale/classes/use-imx-security-controller-firmware.bbclass Normal file
View File

@@ -0,0 +1,38 @@
#
# Class to provide a possibility to re-use names of Security Controller (SECO)
# Firmware files, which are required by certain derivatives on i.MX8 family.
#
# SECO Firmware names are used by imx-boot and imx-seco recipes, therefore
# their respective definitions are moved into a separate class, which is
# inherited by both recipes.
#
# Currently, only 'mx8m' family does not require SECO FW to be provided in the
# target image, therefore as a first step - the machine override is verified
# if it matches, and then derivative is taken.
#
# NOTE: SECO_FIRMWARE_NAME defaults to empty string, and is verified against
# the family first. If a derivative in the family does not have a firmware name
# set in this class - recipe parsing is stopped.
# This behavior ensures that derivatives which requires SECO Firmware to be
# present in the image file have it properly defined.
SECO_FIRMWARE_NAME ?= ""
SECO_FIRMWARE_NAME:mx8qm-generic-bsp ?= "mx8qm${IMX_SOC_REV_LOWER}-ahab-container.img"
SECO_FIRMWARE_NAME:mx8qxp-generic-bsp ?= "mx8qx${IMX_SOC_REV_LOWER}-ahab-container.img"
SECO_FIRMWARE_NAME:mx8dx-generic-bsp ?= "mx8qx${IMX_SOC_REV_LOWER}-ahab-container.img"
SECO_FIRMWARE_NAME:mx8dxl-generic-bsp ?= "mx8dxl${IMX_SOC_REV_LOWER}-ahab-container.img"
SECO_FIRMWARE_NAME:mx8ulp-generic-bsp ?= "mx8ulp${IMX_SOC_REV_LOWER}-ahab-container.img"
SECO_FIRMWARE_NAME:mx91-generic-bsp ?= "mx91${IMX_SOC_REV_LOWER}-ahab-container.img"
SECO_FIRMWARE_NAME:mx93-generic-bsp ?= "mx93${IMX_SOC_REV_LOWER}-ahab-container.img"
SECO_FIRMWARE_NAME:mx95-generic-bsp ?= "mx95${IMX_SOC_REV_LOWER}-ahab-container.img"
python () {
if "mx8m-generic-bsp" in d.getVar('MACHINEOVERRIDES').split(":"):
return # We need to allow the recipes to be parsed for this case
seco_firmware = d.getVar('SECO_FIRMWARE_NAME')
if not seco_firmware:
raise bb.parse.SkipRecipe("This SoC requires 'SECO_FIRMWARE_NAME', define it in 'use-imx-security-controller-firmware' bbclass")
}
PACKAGE_ARCH = "${MACHINE_SOCARCH}"

20
sources/meta-freescale/classes/uuu_bootloader_tag.bbclass Normal file
View File

@@ -0,0 +1,20 @@
# Create a tagged boot partition file for the SD card image file. The tag
# contains the size of the boot partition image so UUU can easily find
# the end of it in the SD card image file.
#
# IMPORTANT: The tagged boot partition file should never be used directly with
# UUU, as it can cause UUU to hang.
UUU_BOOTLOADER = "${UBOOT_BINARY}"
UUU_BOOTLOADER:mx8-generic-bsp = "${@d.getVar('UBOOT_PROVIDES_BOOT_CONTAINER') == '0' and 'imx-boot' or 'flash.bin'}"
UUU_BOOTLOADER:mx9-generic-bsp = "${@d.getVar('UBOOT_PROVIDES_BOOT_CONTAINER') == '0' and 'imx-boot' or 'flash.bin'}"
do_deploy:append() {
if [ "${UUU_BOOTLOADER}" != "" ]; then
cp ${DEPLOYDIR}/${UUU_BOOTLOADER} \
${DEPLOYDIR}/${UUU_BOOTLOADER}.tagged
stat -L -cUUUBURNXXOEUZX7+A-XY5601QQWWZ%sEND \
${DEPLOYDIR}/${UUU_BOOTLOADER}.tagged \
>> ${DEPLOYDIR}/${UUU_BOOTLOADER}.tagged
fi
}