public/meta-st-stm32mp
1
0 Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

CLASSES/MACHINES: update for v2.0.0

Browse Source 
Several updates integrated:
- removal of no more supported basic boot scheme
- removal of no more supported boot device (nor-nand and nor-emmc)
- rework of providers and machine features
- introduction of new board versions (a, c, d, f)
- update of extlinuxconf-stm32mp class to manage multiple board versions
- configure 'extlinux.conf' file to manage PARTUUID to select rootfs
partition
- new partition images management (easy to add or remove partition through
new PARTITIONS_CONFIG var
- specific configuration on machine side for all storage device supported

Change-Id: I7e4d3d16535a5654c7fd80f9b56296a61050def3
This commit is contained in:
Romuald JEANNE committed 2020-06-23 17:23:52 +02:00
1 parent 2fbe4ce39c
commit af5ae28215
33 files changed
+1297 -1245
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

classes/flashlayout-stm32mp.bbclass
+277 -59
View File
@@ -93,37 +93,52 @@
# FLASHLAYOUT_PARTITION_xxx
# -----------------------------------------------------------------------------
# Configure flashlayout file generation
ENABLE_FLASHLAYOUT_CONFIG ??= "1"
FLASHLAYOUT_SUBDIR = "flashlayout_${PN}"
FLASHLAYOUT_DESTDIR = "${IMGDEPLOYDIR}/${FLASHLAYOUT_SUBDIR}"
# Configure direct use of flashlayout file without automatic file generation
ENABLE_FLASHLAYOUT_DEFAULT ??= "0"
# Configure path for provided flashlayout file
FLASHLAYOUT_DEFAULT_SRC ??= ""
# Configure flashlayout file name default format
FLASHLAYOUT_BASENAME ??= "FlashLayout"
FLASHLAYOUT_SUFFIX ??= "tsv"
# Configure flashlayout file generation for stm32wrapper4dbg
ENABLE_FLASHLAYOUT_CONFIG_WRAPPER4DBG ??= "0"
# Configure folders for flashlayout file generation
FLASHLAYOUT_DEPLOYDIR ?= "${DEPLOY_DIR}/images/${MACHINE}"
FLASHLAYOUT_TOPDIR ?= "${WORKDIR}/flashlayout-destdir/"
FLASHLAYOUT_SUBDIR ?= "flashlayout_${PN}"
FLASHLAYOUT_DESTDIR = "${FLASHLAYOUT_TOPDIR}/${FLASHLAYOUT_SUBDIR}"
# Init bootscheme and config labels
FLASHLAYOUT_BOOTSCHEME_LABELS ??= ""
FLASHLAYOUT_CONFIG_LABELS ??= ""
# Init partition image list (used to configure partitions)
FLASHLAYOUT_PARTITION_IMAGES ??= ""
# Init partition and type labels
# Note: possible override with bootscheme and/or config
FLASHLAYOUT_PARTITION_LABELS ??= ""
FLASHLAYOUT_TYPE_LABELS ??= ""
# Init flashlayout partition vars
# Note: possible override with bootscheme and/or config and/or partition
FLASHLAYOUT_PARTITION_ENABLE ??= ""
FLASHLAYOUT_PARTITION_ID ??= ""
FLASHLAYOUT_PARTITION_TYPE ??= ""
FLASHLAYOUT_PARTITION_DEVICE ??= ""
FLASHLAYOUT_PARTITION_OFFSET ??= ""
FLASHLAYOUT_PARTITION_BIN2LOAD ??= ""
FLASHLAYOUT_PARTITION_SIZE ??= ""
FLASHLAYOUT_PARTITION_REPLACE_PATTERNS ??= ""
ENABLE_FLASHLAYOUT_DEFAULT ??= "0"
FLASHLAYOUT_DEFAULT_SRC ??= ""
# List all specific dependencies to image_complete task for successfull build
FLASHLAYOUT_DEPEND_TASKS ??= ""
# List configuration files to monitor to trigger new flashlayout generation
FLASHLAYOUT_CONFIGURE_FILES ??= ""
# -----------------------------------------------------------------------------
# Make sure to add the flashlayout file creation after ROOTFS build
# So we should identify image ROOTFS build and only the ROOTFS (for now)
# As we know that PARTITIONS may be built as part of ROOTFS build, let's
# avoid amending the partition images
# -----------------------------------------------------------------------------
python __anonymous () {
flashlayout_config = d.getVar('ENABLE_FLASHLAYOUT_CONFIG')
if flashlayout_config == "1":
# -----------------------------------------------------------------------------
# Make sure to add the flashlayout file creation after ROOTFS build
# So we should identify image ROOTFS build and only the ROOTFS (for now)
# As we know that PARTITIONS may be built as part of ROOTFS build, let's
# avoid amending the partition images
# -----------------------------------------------------------------------------
if d.getVar('ENABLE_FLASHLAYOUT_CONFIG') == "1":
# Gather all current tasks
tasks = filter(lambda k: d.getVarFlag(k, "task", True), d.keys())
for task in tasks:
@@ -135,18 +150,35 @@ python __anonymous () {
initramfs = d.getVar('INITRAMFS_IMAGE') or ""
# Init INITRD image if any
initrd = d.getVar('INITRD_IMAGE') or ""
# Init partition list from PARTITIONS_IMAGE
image_partitions = (d.getVar('PARTITIONS_IMAGE') or "").split()
# We need to clearly identify ROOTFS build, not InitRAMFS one (if any)
# Init partition list from PARTITIONS_CONFIG
image_partitions = []
# Append image_partitions list with all configured partition images:
partitionsconfigflags = d.getVarFlags('PARTITIONS_CONFIG')
# The "doc" varflag is special, we don't want to see it here
partitionsconfigflags.pop('doc', None)
partitionsconfig = (d.getVar('PARTITIONS_CONFIG') or "").split()
if len(partitionsconfig) > 0:
for config in partitionsconfig:
for f, v in partitionsconfigflags.items():
if config == f:
items = v.split(',')
# Make sure about PARTITIONS_CONFIG contents
if items[0] and len(items) > 5:
bb.fatal('[PARTITIONS_CONFIG] Only image,label,mountpoint,size,type can be specified!')
# Make sure that we're dealing with partition image and not rootfs image
if len(items) > 2 and items[2]:
# Mount point is available, so we're dealing with partition image
# Append image to image_partitions list
image_partitions.append(d.expand(items[0]))
break
# We need to clearly identify ROOTFS build, not InitRAMFS/initRD one (if any), not partition one either
if current_image_name not in image_partitions and current_image_name != initramfs and current_image_name != initrd:
# We need to make sure to add all extra dependencies as 'depends'
# for image_complete task
if d.getVar('FLASHLAYOUT_DEPEND_TASKS'):
d.appendVarFlag('do_image_complete', 'depends', ' %s' % (d.getVar('FLASHLAYOUT_DEPEND_TASKS',)))
# We can append the flashlayout file creation task to this ROOTFS build
d.appendVar('IMAGE_POSTPROCESS_COMMAND', 'do_create_flashlayout_config ; ')
# Append also the configuration files to properly take into account any updates
d.appendVarFlag('do_image_complete', 'file-checksums', ' ${FLASHLAYOUT_CONFIGURE_FILES} ')
# We add the flashlayout file creation task just after the do_image_complete for ROOTFS build
bb.build.addtask('do_create_flashlayout_config', 'do_build', 'do_image_complete', d)
# We add also the function that feeds the FLASHLAYOUT_PARTITION_* vars from PARTITIONS_CONFIG
d.appendVarFlag('do_create_flashlayout_config', 'prefuncs', ' flashlayout_partition_image_config')
}
def expand_var(var, bootscheme, config, partition, d):
@@ -179,30 +211,98 @@ def expand_var(var, bootscheme, config, partition, d):
# Return expanded and/or overriden var value
return expanded_var
def get_offset(new_offset, bootscheme, config, partition, d):
def get_device(bootscheme, config, partition, d):
"""
This function return a couple of strings: offset, next_offset
This function returns the device configured from FLASHLAYOUT_PARTITION_DEVICE for
the requested partition for label and bootscheme configured.
The var FLASHLAYOUT_PARTITION_DEVICE can be configured through different scheme
FLASHLAYOUT_PARTITION_DEVICE = '<device0>:<dev0part_0> <dev0part_1>,<device1>:<dev1part0>'
FLASHLAYOUT_PARTITION_DEVICE = '<device0>:default,<device1>:<dev1part0> <dev1part1>,<device2>:<dev2part0>'
FLASHLAYOUT_PARTITION_DEVICE = '<device0>'
Then, to set the device for the current partition, the logic followed is:
If the configuration provides a single device, then partition device is set
to this value.
Else,
If the current partition is specified in any of the configured partition
lists, the matching configured device is set as partition device.
And if the current partition is not found, the default device configured
is set as partition device.
"""
# Set device configuration
device_configs = expand_var('FLASHLAYOUT_PARTITION_DEVICE', bootscheme, config, partition, d)
bb.note('>>> Selected FLASHLAYOUT_PARTITION_DEVICE: %s' % device_configs)
if len(device_configs.split(',')) == 1:
bb.note('>>> Only one device configuration set for %s partition for %s label for %s bootscheme' % (partition, config, bootscheme))
device = device_configs.split(':')[0]
else:
bb.note('>>> Multiple device configurations set for %s partition for %s label for %s bootscheme' % (partition, config, bootscheme))
# Init default_device and device to empty string
default_device = ''
device = ''
for device_config in device_configs.split(','):
cfg_devc = device_config.split(':')[0].strip()
cfg_part = device_config.split(':')[1] or 'default'
# Make sure configuration is correct
if len(cfg_devc.split()) > 1:
bb.fatal('Only one device configuration can be specified: found %s for %s partition for %s label for %s bootscheme' % (cfg_devc, partition, config, bootscheme))
# Configure the default device configuration if any
if cfg_part == 'default':
if default_device != '':
bb.fatal('Found two "default" device configuration for %s partition for %s label for %s bootscheme in FLASHLAYOUT_PARTITION_DEVICE var' % (partition, config, bootscheme))
default_device = cfg_devc
bb.note('>>> Set default device configuration to %s' % default_device)
else:
# Find out if any device is configured for current partition
for p in cfg_part.split():
if p == partition:
device = cfg_devc
break
# If 'device' is still empty for current partition, check if we can apply default device configuration
if device == '':
if default_device == '':
bb.fatal('Not able to get device configuration for %s partition for %s label for %s bootscheme' % (partition, config, bootscheme))
else:
bb.note('>>> Configure device to default device setting')
device = default_device
bb.note('>>> New device configured: %s' % device)
# Return the value computed
return device
def get_offset(new_offset, current_device, bootscheme, config, partition, d):
"""
This function returns a couple of strings: offset, next_offset
The offset is the one to use in flashlayout file for the requested partition,
and next_offset is the one to use in flashlayout for next partition (if any).
The offset can be directly configured for the current partition through the
FLASHLAYOUT_PARTITION_OFFSET variable. If this one is set to 'none' for the
current partition, then we use the one provided through 'new_offset'.
current partition, then we use the one provided through 'new_offset' if set,
else we default to DEVICE_START_OFFSET_<device> one where <device> is feed from
'current_device' input.
The next_offset is computed by first getting the FLASHLAYOUT_PARTITION_SIZE for
the current partition, and we make sure to align properly the next_offset
according to the DEVICE_ALIGNMENT_SIZE_<device> where <device> is feed from
FLASHLAYOUT_PARTITION_DEVICE.
'current_device' input.
"""
import re
# Get current_device alias
device_alias = d.getVar('DEVICE_%s' % current_device) or ""
# Set offset
offset = expand_var('FLASHLAYOUT_PARTITION_OFFSET', bootscheme, config, partition, d)
bb.note('>>> Selected FLASHLAYOUT_PARTITION_OFFSET: %s' % offset)
if offset == 'none':
if new_offset == 'none':
bb.fatal('Missing %s partition offset configuration for %s label for %s bootscheme!' % (partition, config, bootscheme))
offset = new_offset
bb.note('>>> No %s partition offset configured (%s device) for %s label for %s bootscheme, so default to default origin device one.' % (partition, current_device, config, bootscheme))
start_offset = d.getVar('DEVICE_START_OFFSET_%s' % device_alias) or "none"
if start_offset == 'none':
bb.fatal('Missing DEVICE_START_OFFSET_%s value' % device_alias)
offset = start_offset
else:
offset = new_offset
bb.note('>>> New offset configured: %s' % offset)
# Set next offset
@@ -213,11 +313,10 @@ def get_offset(new_offset, bootscheme, config, partition, d):
next_offset = "none"
else:
if re.match('^0x.*$', offset):
current_device = expand_var('FLASHLAYOUT_PARTITION_DEVICE', bootscheme, config, partition, d)
bb.note('>>> Current device is %s' % current_device)
alignment_size = d.getVar('DEVICE_ALIGNMENT_SIZE_%s' % current_device) or "none"
bb.note('>>> Current device is %s (%s alias)' % (current_device, device_alias))
alignment_size = d.getVar('DEVICE_ALIGNMENT_SIZE_%s' % device_alias) or "none"
if alignment_size == 'none':
bb.fatal('Missing DEVICE_ALIGNMENT_SIZE_%s value' % current_device)
bb.fatal('Missing DEVICE_ALIGNMENT_SIZE_%s value' % device_alias)
if ( int(partition_size) * 1024 ) % int(alignment_size, 16) == 0:
bb.note('>>> The partition size properly follows %s erase size' % alignment_size)
else:
@@ -236,7 +335,6 @@ def get_offset(new_offset, bootscheme, config, partition, d):
# Return both offset and next offset
return str(offset), str(next_offset)
def get_binaryname(labeltype, bootscheme, config, partition, d):
"""
Return proper binary name to use in flashlayout file by applying any specific
@@ -260,7 +358,7 @@ def get_binaryname(labeltype, bootscheme, config, partition, d):
binary_type = labeltype + '-' + bootscheme
bb.note('>>> Binary type used: %s' % binary_type)
# Check for any replace pattern
replace_patterns = expand_var('BIN2BOOT_REPLACE_PATTERNS', bootscheme, config, partition, d)
replace_patterns = expand_var('FLASHLAYOUT_PARTITION_REPLACE_PATTERNS', bootscheme, config, partition, d)
bb.note('>>> Substitution patterns: %s' % replace_patterns)
# Apply replacement patterns on binary_type
if replace_patterns != 'none':
@@ -291,7 +389,7 @@ def flashlayout_search(d, files):
search_path = d.getVar("BBPATH").split(":")
for file in files.split():
for p in search_path:
file_path = p + "/" + file
file_path = os.path.join(p, file)
if os.path.isfile(file_path):
return (True, file_path)
return (False, "")
@@ -317,15 +415,16 @@ python do_create_flashlayout_config() {
bb.fatal("FLASHLAYOUT_DEFAULT_SRC not defined, please set a proper value")
if not flashlayout_src.strip():
bb.fatal("No static flashlayout file configured, nothing to do")
found, f = flashlayout_search(d, flashlayout_src)
if found:
flashlayout_staticname=os.path.basename(f)
flashlayout_file = d.expand("${FLASHLAYOUT_DESTDIR}/%s" % flashlayout_staticname)
shutil.copy2(f, flashlayout_file)
bb.note('Copy %s to output file %s' % (f, flashlayout_file))
return
else:
bb.fatal("Configure static file: %s not found" % flashlayout_src)
for fl_src in flashlayout_src.split():
found, f = flashlayout_search(d, fl_src)
if found:
flashlayout_staticname=os.path.basename(f)
flashlayout_file = os.path.join(d.getVar('FLASHLAYOUT_DESTDIR'), flashlayout_staticname)
shutil.copy2(f, flashlayout_file)
bb.note('Copy %s to output file %s' % (f, flashlayout_file))
else:
bb.fatal("Configure static file: %s not found" % fl_src)
return
# Set bootschemes for partition var override configuration
bootschemes = d.getVar('FLASHLAYOUT_BOOTSCHEME_LABELS')
@@ -341,7 +440,6 @@ python do_create_flashlayout_config() {
for bootscheme in bootschemes.split():
bb.note('*** Loop for bootscheme label: %s' % bootscheme)
# Get the different flashlayout config label
configs = expand_var('FLASHLAYOUT_CONFIG_LABELS', bootscheme, '', '', d)
# Make sure there is no '_' in FLASHLAYOUT_CONFIG_LABELS
@@ -350,16 +448,25 @@ python do_create_flashlayout_config() {
bb.fatal("Please remove all '_' for configs defined in FLASHLAYOUT_CONFIG_LABELS")
bb.note('FLASHLAYOUT_CONFIG_LABELS: %s' % configs)
if configs.strip() == 'none':
bb.note("FLASHLAYOUT_CONFIG_LABELS is none, so no flashlayout file to generate.")
continue
# Create bootscheme subfolder for flashlayout files
flashlayout_subfolder_path = os.path.join(d.getVar('FLASHLAYOUT_DESTDIR'), bootscheme)
bb.utils.mkdirhier(flashlayout_subfolder_path)
for config in configs.split():
bb.note('*** Loop for config label: %s' % config)
# Set labeltypes list
labeltypes = expand_var('FLASHLAYOUT_TYPE_LABELS', bootscheme, config, '', d)
bb.note('FLASHLAYOUT_TYPE_LABELS: %s' % labeltypes)
if labeltypes == 'none':
if labeltypes.strip() == 'none':
bb.note("FLASHLAYOUT_TYPE_LABELS is none, so no flashlayout file to generate.")
continue
for labeltype in labeltypes.split():
bb.note('*** Loop for label type: %s' % labeltype)
# Init current label
current_label = labeltype
# Init flashlayout file name
if config == 'none':
config_append = ''
@@ -369,7 +476,7 @@ python do_create_flashlayout_config() {
labeltype_append = ''
else:
labeltype_append = '_' + labeltype + '-' + bootscheme
flashlayout_file = d.expand("${FLASHLAYOUT_DESTDIR}/${FLASHLAYOUT_BASENAME}%s%s.${FLASHLAYOUT_SUFFIX}" % (config_append, labeltype_append))
flashlayout_file = os.path.join(flashlayout_subfolder_path, d.expand("${FLASHLAYOUT_BASENAME}%s%s.${FLASHLAYOUT_SUFFIX}" % (config_append, labeltype_append)))
# Get the partition list to write in flashlayout file
partitions = expand_var('FLASHLAYOUT_PARTITION_LABELS', bootscheme, config, '', d)
bb.note('FLASHLAYOUT_PARTITION_LABELS: %s' % partitions)
@@ -383,6 +490,8 @@ python do_create_flashlayout_config() {
fl_file.write('#Opt\tId\tName\tType\tIP\tOffset\tBinary\n')
# Init partition next offset to 'none'
partition_nextoffset = "none"
# Init partition previous device to 'none'
partition_prevdevice = "none"
for partition in partitions.split():
bb.note('*** Loop for partition: %s' % partition)
# Init partition settings
@@ -390,9 +499,14 @@ python do_create_flashlayout_config() {
partition_id = expand_var('FLASHLAYOUT_PARTITION_ID', bootscheme, config, partition, d)
partition_name = partition
partition_type = expand_var('FLASHLAYOUT_PARTITION_TYPE', bootscheme, config, partition, d)
partition_device = expand_var('FLASHLAYOUT_PARTITION_DEVICE', bootscheme, config, partition, d)
partition_device = get_device(bootscheme, config, partition, d)
# Reset partition_nextoffset to 'none' in case partition device has changed
if partition_device != partition_prevdevice:
partition_nextoffset = "none"
# Save partition current device to previous one for next loop
partition_prevdevice = partition_device
# Get partition offset
partition_offset, partition_nextoffset = get_offset(partition_nextoffset, bootscheme, config, partition, d)
partition_offset, partition_nextoffset = get_offset(partition_nextoffset, partition_device, bootscheme, config, partition, d)
# Get binary name
partition_bin2load = get_binaryname(labeltype, bootscheme, config, partition, d)
# Be verbose in log file
@@ -405,6 +519,14 @@ python do_create_flashlayout_config() {
bb.note('>>> FLASHLAYOUT_PARTITION_OFFSET: %s' % partition_offset)
bb.note('>>> FLASHLAYOUT_PARTITION_BIN2LOAD: %s' % partition_bin2load)
bb.note('>>> done')
# Get the supported labels for current storage device
partition_device_alias = d.getVar('DEVICE_%s' % partition_device) or ""
partition_type_supported_labels = d.getVar('DEVICE_BOARD_ENABLE_%s' % partition_device_alias) or "none"
# Check if partition type is supported for the current label
if partition_device != 'none' and current_label not in partition_type_supported_labels.split():
bb.note('>>> FLASHLAYOUT_PARTITION_DEVICE (%s, alias %s) is not supported for current label (%s): partition %s not appended in flashlayout file' % (partition_device, partition_device_alias, current_label, partition_name))
bb.note('>>> DEVICE_BOARD_ENABLE_%s: %s' % (partition_device_alias, partition_type_supported_labels))
continue
# Write to flashlayout file the partition configuration
fl_file.write('%s\t%s\t%s\t%s\t%s\t%s\t%s\n' %
(partition_enable, partition_id, partition_name, partition_type, partition_device, partition_offset, partition_bin2load))
@@ -444,3 +566,99 @@ python do_create_flashlayout_config() {
else:
os.remove(tmp_flashlayout_file)
}
do_create_flashlayout_config[dirs] = "${FLASHLAYOUT_DESTDIR}"
FLASHLAYOUT_DEPEND_TASKS ?= ""
do_create_flashlayout_config[depends] += "${FLASHLAYOUT_DEPEND_TASKS}"
SSTATETASKS += "do_create_flashlayout_config"
do_create_flashlayout_config[cleandirs] = "${FLASHLAYOUT_TOPDIR}"
do_create_flashlayout_config[sstate-inputdirs] = "${FLASHLAYOUT_TOPDIR}"
do_create_flashlayout_config[sstate-outputdirs] = "${FLASHLAYOUT_DEPLOYDIR}/"
python do_create_flashlayout_config_setscene () {
sstate_setscene(d)
}
addtask do_create_flashlayout_config_setscene
python flashlayout_partition_image_config() {
"""
Set the different flashlayout partition vars for the configure partition
images.
Based on PARTITIONS_CONFIG, feed:
FLASHLAYOUT_PARTITION_IMAGES
FLASHLAYOUT_PARTITION_ID_
FLASHLAYOUT_PARTITION_TYPE_
FLASHLAYOUT_PARTITION_SIZE_
FLASHLAYOUT_PARTITION_BIN2LOAD_
"""
partitionsconfigflags = d.getVarFlags('PARTITIONS_CONFIG')
# The "doc" varflag is special, we don't want to see it here
partitionsconfigflags.pop('doc', None)
partitionsconfig = (d.getVar('PARTITIONS_CONFIG') or "").split()
if len(partitionsconfig) > 0:
# Init default partition id for binary type and other
id_bin = 4
id_oth = 33
for config in partitionsconfig:
for f, v in partitionsconfigflags.items():
if config == f:
items = v.split(',')
# Make sure about PARTITIONS_CONFIG contents
if items[0] and len(items) > 5:
bb.fatal('[PARTITIONS_CONFIG] Only image,label,mountpoint,size,type can be specified!')
if items[1]:
bb.debug(1, "Appending %s to FLASHLAYOUT_PARTITION_IMAGES." % items[1])
d.appendVar('FLASHLAYOUT_PARTITION_IMAGES', ' ' + items[1])
else:
bb.fatal('[PARTITIONS_CONFIG] Missing image label setting')
# Init flashlayout label
fl_label = d.expand(items[1])
if items[2] == '':
# There is no mountpoint specified, so we apply rootfs image format
bb.debug(1, "Set FLASHLAYOUT_PARTITION_BIN2LOAD_%s to %s." % (fl_label, items[0] + "-${MACHINE}.ext4"))
d.setVar('FLASHLAYOUT_PARTITION_BIN2LOAD_%s' % fl_label, items[0] + "-${MACHINE}.ext4")
else:
bb.debug(1, "Set FLASHLAYOUT_PARTITION_BIN2LOAD_%s to %s." % (fl_label, items[0] + "-${DISTRO}-${MACHINE}.ext4"))
d.setVar('FLASHLAYOUT_PARTITION_BIN2LOAD_%s' % fl_label, items[0] + "-${DISTRO}-${MACHINE}.ext4")
if items[3]:
bb.debug(1, "Set FLASHLAYOUT_PARTITION_SIZE_%s to %s." % (fl_label, items[3]))
d.setVar('FLASHLAYOUT_PARTITION_SIZE_%s' % fl_label, items[3])
else:
bb.fatal('[PARTITIONS_CONFIG] Missing PARTITION_SIZE setting for % label' % fl_label)
if items[4]:
bb.debug(1, "Set FLASHLAYOUT_PARTITION_TYPE_%s to %s." % (fl_label, items[4]))
d.setVar('FLASHLAYOUT_PARTITION_TYPE_%s' % fl_label, items[4])
# Compute partition id according to type set
if items[4] == 'Binary':
part_id = '0x{0:0{1}X}'.format(id_bin, 2)
id_bin = id_bin + 1
else:
part_id = '0x{0:0{1}X}'.format(id_oth, 2)
id_oth = id_oth + 1
bb.debug(1, "Set FLASHLAYOUT_PARTITION_ID_%s to %s." % (fl_label, part_id))
d.setVar('FLASHLAYOUT_PARTITION_ID_%s' % fl_label, "%s" % part_id)
else:
bb.fatal('[PARTITIONS_CONFIG] Missing PARTITION_TYPE setting for % label' % fl_label)
break
}
# -----------------------------------------------------------------------------
# Manage specific var dependency:
# Because of local overrides within create_flashlayout_config() function, we
# need to make sure to add each variables to the vardeps list.
FLASHLAYOUT_LABELS_VARS = "CONFIG_LABELS PARTITION_LABELS TYPE_LABELS"
FLASHLAYOUT_LABELS_OVERRIDES = "${@' '.join('%s %s %s_%s' % (b, c, b, c) for b in d.getVar('FLASHLAYOUT_BOOTSCHEME_LABELS').split() for c in d.getVar('FLASHLAYOUT_CONFIG_LABELS').split())}"
do_create_flashlayout_config[vardeps] += "${@' '.join(['FLASHLAYOUT_%s_%s' % (v, o) for v in d.getVar('FLASHLAYOUT_LABELS_VARS').split() for o in d.getVar('FLASHLAYOUT_LABELS_OVERRIDES').split()])}"
FLASHLAYOUT_PARTITION_VARS = "ENABLE ID TYPE DEVICE OFFSET BIN2LOAD SIZE REPLACE_PATTERNS"
FLASHLAYOUT_PARTITION_CONFIGURED = "${@" ".join(map(lambda o: "%s" % d.getVar("FLASHLAYOUT_PARTITION_LABELS_%s" % o), d.getVar('FLASHLAYOUT_LABELS_OVERRIDES').split()))}"
FLASHLAYOUT_PARTITION_OVERRIDES = "${@' '.join('%s %s %s_%s' % (o, p, o, p) for o in d.getVar('FLASHLAYOUT_LABELS_OVERRIDES').split() for p in d.getVar('FLASHLAYOUT_PARTITION_CONFIGURED').split())}"
do_create_flashlayout_config[vardeps] += "${@' '.join(['FLASHLAYOUT_PARTITION_%s_%s' % (v, o) for v in d.getVar('FLASHLAYOUT_PARTITION_VARS').split() for o in d.getVar('FLASHLAYOUT_PARTITION_OVERRIDES').split()])}"
FLASHLAYOUT_DEVICE_VARS = "ALIGNMENT_SIZE BOARD_ENABLE START_OFFSET"
FLASHLAYOUT_PARTITION_DEVICE_CONFIGURED = "${@" ".join(map(lambda p: "%s" % d.getVar("DEVICE_%s" % p), d.getVar('DEVICE_STORAGE_NAMES').split()))}"
do_create_flashlayout_config[vardeps] += "${@' '.join(['DEVICE_%s_%s' % (v, o) for v in d.getVar('FLASHLAYOUT_DEVICE_VARS').split() for o in d.getVar('FLASHLAYOUT_PARTITION_DEVICE_CONFIGURED').split()])}"