fba8ac988c
We generated some alias defines for children of a bus in which we had a path alias for the bus node. We never used these defines, we don't recommend they get used (child of busses should use instance defines) and they were only generated in small handful of cases (for dts that had path aliases to the bus node - i2c or spi). Remove this as effectively dead code. Signed-off-by: Kumar Gala <kumar.gala@linaro.org>
507 lines
17 KiB
Python
Executable File
507 lines
17 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
#
|
|
# Copyright (c) 2017, Linaro Limited
|
|
# Copyright (c) 2018, Bobby Noelte
|
|
#
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
#
|
|
|
|
# vim: ai:ts=4:sw=4
|
|
|
|
import os, fnmatch
|
|
import re
|
|
import yaml
|
|
import argparse
|
|
from collections import defaultdict
|
|
|
|
from devicetree import parse_file
|
|
from extract.globals import *
|
|
import extract.globals
|
|
|
|
from extract.clocks import clocks
|
|
from extract.compatible import compatible
|
|
from extract.interrupts import interrupts
|
|
from extract.reg import reg
|
|
from extract.flash import flash
|
|
from extract.pinctrl import pinctrl
|
|
from extract.default import default
|
|
|
|
|
|
def extract_bus_name(node_path, def_label):
|
|
label = def_label + '_BUS_NAME'
|
|
prop_alias = {}
|
|
|
|
add_compat_alias(node_path, 'BUS_NAME', label, prop_alias)
|
|
|
|
# Generate defines for node aliases
|
|
if node_path in aliases:
|
|
add_prop_aliases(
|
|
node_path,
|
|
lambda alias: str_to_label(alias) + '_BUS_NAME',
|
|
label,
|
|
prop_alias)
|
|
|
|
insert_defs(node_path,
|
|
{label: '"' + find_parent_prop(node_path, 'label') + '"'},
|
|
prop_alias)
|
|
|
|
|
|
def extract_string_prop(node_path, key, label):
|
|
if node_path not in defs:
|
|
# Make all defs have the special 'aliases' key, to remove existence
|
|
# checks elsewhere
|
|
defs[node_path] = {'aliases': {}}
|
|
|
|
defs[node_path][label] = '"' + reduced[node_path]['props'][key] + '"'
|
|
|
|
|
|
def generate_prop_defines(node_path, prop):
|
|
# Generates #defines (and .conf file values) from the prop
|
|
# named 'prop' on the device tree node at 'node_path'
|
|
|
|
binding = get_binding(node_path)
|
|
if 'parent' in binding and 'bus' in binding['parent']:
|
|
# If the binding specifies a parent for the node, then include the
|
|
# parent in the #define's generated for the properties
|
|
parent_path = get_parent_path(node_path)
|
|
def_label = 'DT_' + node_label(parent_path) + '_' \
|
|
+ node_label(node_path)
|
|
else:
|
|
def_label = 'DT_' + node_label(node_path)
|
|
|
|
names = prop_names(reduced[node_path], prop)
|
|
|
|
if prop == 'reg':
|
|
reg.extract(node_path, names, def_label, 1)
|
|
elif prop == 'interrupts' or prop == 'interrupts-extended':
|
|
interrupts.extract(node_path, prop, names, def_label)
|
|
elif prop == 'compatible':
|
|
compatible.extract(node_path, prop, def_label)
|
|
elif 'pinctrl-' in prop:
|
|
pinctrl.extract(node_path, prop, def_label)
|
|
elif 'clocks' in prop:
|
|
clocks.extract(node_path, prop, def_label)
|
|
elif 'pwms' in prop or 'gpios' in prop:
|
|
prop_values = reduced[node_path]['props'][prop]
|
|
generic = prop[:-1] # Drop the 's' from the prop
|
|
|
|
extract_controller(node_path, prop, prop_values, 0,
|
|
def_label, generic)
|
|
extract_cells(node_path, prop, prop_values,
|
|
names, 0, def_label, generic)
|
|
else:
|
|
default.extract(node_path, prop,
|
|
binding['properties'][prop]['type'],
|
|
def_label)
|
|
|
|
|
|
def generate_node_defines(node_path):
|
|
# Generates #defines (and .conf file values) from the device
|
|
# tree node at 'node_path'
|
|
|
|
if get_compat(node_path) not in get_binding_compats():
|
|
return
|
|
|
|
# We extract a few different #defines for a flash partition, so it's easier
|
|
# to handle it in one step
|
|
if 'partition@' in node_path:
|
|
flash.extract_partition(node_path)
|
|
return
|
|
|
|
generate_bus_defines(node_path)
|
|
|
|
# Generate per-property ('foo = <1 2 3>', etc.) #defines
|
|
for yaml_prop, yaml_val in get_binding(node_path)['properties'].items():
|
|
if 'generation' not in yaml_val:
|
|
continue
|
|
|
|
match = False
|
|
|
|
# Handle each property individually, this ends up handling common
|
|
# patterns for things like reg, interrupts, etc that we don't need
|
|
# any special case handling at a node level
|
|
for prop in reduced[node_path]['props']:
|
|
if re.fullmatch(yaml_prop, prop):
|
|
match = True
|
|
generate_prop_defines(node_path, prop)
|
|
|
|
# Handle the case that we have a boolean property, but its not
|
|
# in the dts
|
|
if not match and yaml_val['type'] == 'boolean':
|
|
generate_prop_defines(node_path, yaml_prop)
|
|
|
|
|
|
def generate_bus_defines(node_path):
|
|
# Generates any node-level #defines related to
|
|
#
|
|
# parent:
|
|
# bus: ...
|
|
|
|
binding = get_binding(node_path)
|
|
if not ('parent' in binding and 'bus' in binding['parent']):
|
|
return
|
|
|
|
parent_path = get_parent_path(node_path)
|
|
|
|
# Check that parent has matching child bus value
|
|
try:
|
|
parent_binding = get_binding(parent_path)
|
|
parent_bus = parent_binding['child']['bus']
|
|
except (KeyError, TypeError):
|
|
raise Exception("{0} defines parent {1} as bus master, but {1} is not "
|
|
"configured as bus master in binding"
|
|
.format(node_path, parent_path))
|
|
|
|
if parent_bus != binding['parent']['bus']:
|
|
raise Exception("{0} defines parent {1} as {2} bus master, but {1} is "
|
|
"configured as {3} bus master"
|
|
.format(node_path, parent_path,
|
|
binding['parent']['bus'], parent_bus))
|
|
|
|
# Generate *_BUS_NAME #define
|
|
extract_bus_name(
|
|
node_path,
|
|
'DT_' + node_label(parent_path) + '_' + node_label(node_path))
|
|
|
|
|
|
def prop_names(node, prop_name):
|
|
# Returns a list with the *-names for the property (reg-names,
|
|
# interrupt-names, etc.) The list is copied so that it can be modified
|
|
# in-place later without stomping on the device tree data.
|
|
|
|
if prop_name.startswith('pinctrl-'):
|
|
names = node['props'].get('pinctrl-names', [])
|
|
else:
|
|
# The first case turns 'interrupts' into 'interrupt-names'
|
|
names = node['props'].get(prop_name[:-1] + '-names', []) or \
|
|
node['props'].get(prop_name + '-names', [])
|
|
|
|
if isinstance(names, list):
|
|
# Allow the list of names to be modified in-place without
|
|
# stomping on the property
|
|
return names.copy()
|
|
|
|
return [names]
|
|
|
|
|
|
def merge_properties(parent, fname, to_dict, from_dict):
|
|
# Recursively merges the 'from_dict' dictionary into 'to_dict', to
|
|
# implement !include. 'parent' is the current parent key being looked at.
|
|
# 'fname' is the top-level .yaml file.
|
|
|
|
for k in from_dict:
|
|
if (k in to_dict and isinstance(to_dict[k], dict)
|
|
and isinstance(from_dict[k], dict)):
|
|
merge_properties(k, fname, to_dict[k], from_dict[k])
|
|
else:
|
|
to_dict[k] = from_dict[k]
|
|
|
|
# Warn when overriding a property and changing its value...
|
|
if (k in to_dict and to_dict[k] != from_dict[k] and
|
|
# ...unless it's the 'title', 'description', or 'version'
|
|
# property. These are overriden deliberately.
|
|
not k in {'title', 'version', 'description'} and
|
|
# Also allow the category to be changed from 'optional' to
|
|
# 'required' without a warning
|
|
not (k == "category" and to_dict[k] == "optional" and
|
|
from_dict[k] == "required")):
|
|
|
|
print("extract_dts_includes.py: {}('{}') merge of property "
|
|
"'{}': '{}' overwrites '{}'"
|
|
.format(fname, parent, k, from_dict[k], to_dict[k]))
|
|
|
|
|
|
def merge_included_bindings(fname, node):
|
|
# Recursively merges properties from files !include'd from the 'inherits'
|
|
# section of the binding. 'fname' is the path to the top-level binding
|
|
# file, and 'node' the current top-level YAML node being processed.
|
|
|
|
check_binding_properties(node)
|
|
|
|
if 'inherits' in node:
|
|
for inherited in node.pop('inherits'):
|
|
inherited = merge_included_bindings(fname, inherited)
|
|
merge_properties(None, fname, inherited, node)
|
|
node = inherited
|
|
|
|
return node
|
|
|
|
|
|
def check_binding_properties(node):
|
|
# Checks that the top-level YAML node 'node' has the expected properties.
|
|
# Prints warnings and substitutes defaults otherwise.
|
|
|
|
if 'title' not in node:
|
|
print("extract_dts_includes.py: node without 'title' -", node)
|
|
|
|
for prop in 'title', 'version', 'description':
|
|
if prop not in node:
|
|
node[prop] = "<unknown {}>".format(prop)
|
|
print("extract_dts_includes.py: '{}' property missing "
|
|
"in '{}' binding. Using '{}'."
|
|
.format(prop, node['title'], node[prop]))
|
|
|
|
if 'id' in node:
|
|
print("extract_dts_includes.py: WARNING: id field set "
|
|
"in '{}', should be removed.".format(node['title']))
|
|
|
|
|
|
def define_str(name, value, value_tabs, is_deprecated=False):
|
|
line = "#define " + name
|
|
if is_deprecated:
|
|
line += " __DEPRECATED_MACRO "
|
|
return line + (value_tabs - len(line)//8)*'\t' + str(value) + '\n'
|
|
|
|
|
|
def write_conf(f):
|
|
for node in sorted(defs):
|
|
f.write('# ' + node.split('/')[-1] + '\n')
|
|
|
|
for prop in sorted(defs[node]):
|
|
if prop != 'aliases' and prop.startswith("DT_"):
|
|
f.write('%s=%s\n' % (prop, defs[node][prop]))
|
|
|
|
for alias in sorted(defs[node]['aliases']):
|
|
alias_target = defs[node]['aliases'][alias]
|
|
if alias_target not in defs[node]:
|
|
alias_target = defs[node]['aliases'][alias_target]
|
|
if alias.startswith("DT_"):
|
|
f.write('%s=%s\n' % (alias, defs[node].get(alias_target)))
|
|
|
|
f.write('\n')
|
|
|
|
|
|
def write_header(f):
|
|
f.write('''\
|
|
/**********************************************
|
|
* Generated include file
|
|
* DO NOT MODIFY
|
|
*/
|
|
#ifndef GENERATED_DTS_BOARD_UNFIXED_H
|
|
#define GENERATED_DTS_BOARD_UNFIXED_H
|
|
''')
|
|
|
|
def max_dict_key(dct):
|
|
return max(len(key) for key in dct)
|
|
|
|
for node in sorted(defs):
|
|
f.write('/* ' + node.split('/')[-1] + ' */\n')
|
|
|
|
maxlen = max_dict_key(defs[node])
|
|
if defs[node]['aliases']:
|
|
maxlen = max(maxlen, max_dict_key(defs[node]['aliases']))
|
|
maxlen += len('#define ')
|
|
|
|
value_tabs = (maxlen + 8)//8 # Tabstop index for value
|
|
if 8*value_tabs - maxlen <= 2:
|
|
# Add some minimum room between the macro name and the value
|
|
value_tabs += 1
|
|
|
|
for prop in sorted(defs[node]):
|
|
if prop != 'aliases':
|
|
f.write(define_str(prop, defs[node][prop], value_tabs))
|
|
|
|
for alias in sorted(defs[node]['aliases']):
|
|
alias_target = defs[node]['aliases'][alias]
|
|
deprecated_warn = False
|
|
# Mark any non-DT_ prefixed define as deprecated except
|
|
# for now we special case LED, SW, and *PWM_LED*
|
|
if not alias.startswith(('DT_', 'LED', 'SW')) and not 'PWM_LED' in alias:
|
|
deprecated_warn = True
|
|
f.write(define_str(alias, alias_target, value_tabs, deprecated_warn))
|
|
|
|
f.write('\n')
|
|
|
|
f.write('#endif\n')
|
|
|
|
|
|
def load_bindings(root, binding_dirs):
|
|
find_binding_files(binding_dirs)
|
|
dts_compats = all_compats(root)
|
|
|
|
compat_to_binding = {}
|
|
# Maps buses to dictionaries that map compats to YAML nodes
|
|
bus_to_binding = defaultdict(dict)
|
|
compats = []
|
|
|
|
# Add '!include foo.yaml' handling
|
|
yaml.Loader.add_constructor('!include', yaml_include)
|
|
|
|
loaded_yamls = set()
|
|
|
|
for file in binding_files:
|
|
# Extract compat from 'constraint:' line
|
|
for line in open(file, 'r', encoding='utf-8'):
|
|
match = re.match(r'\s+constraint:\s*"([^"]*)"', line)
|
|
if match:
|
|
break
|
|
else:
|
|
# No 'constraint:' line found. Move on to next yaml file.
|
|
continue
|
|
|
|
compat = match.group(1)
|
|
if compat not in dts_compats or file in loaded_yamls:
|
|
# The compat does not appear in the device tree, or the yaml
|
|
# file has already been loaded
|
|
continue
|
|
|
|
# Found a binding (.yaml file) for a 'compatible' value that
|
|
# appears in DTS. Load it.
|
|
|
|
loaded_yamls.add(file)
|
|
|
|
if compat not in compats:
|
|
compats.append(compat)
|
|
|
|
with open(file, 'r', encoding='utf-8') as yf:
|
|
binding = merge_included_bindings(file,
|
|
yaml.load(yf, Loader=yaml.Loader))
|
|
|
|
if 'parent' in binding:
|
|
bus_to_binding[binding['parent']['bus']][compat] = binding
|
|
|
|
compat_to_binding[compat] = binding
|
|
|
|
if not compat_to_binding:
|
|
raise Exception("No bindings found in '{}'".format(binding_dirs))
|
|
|
|
extract.globals.bindings = compat_to_binding
|
|
extract.globals.bus_bindings = bus_to_binding
|
|
extract.globals.binding_compats = compats
|
|
|
|
|
|
def find_binding_files(binding_dirs):
|
|
# Initializes the global 'binding_files' variable with a list of paths to
|
|
# binding (.yaml) files
|
|
|
|
global binding_files
|
|
|
|
binding_files = []
|
|
|
|
for binding_dir in binding_dirs:
|
|
for root, _, filenames in os.walk(binding_dir):
|
|
for filename in fnmatch.filter(filenames, '*.yaml'):
|
|
binding_files.append(os.path.join(root, filename))
|
|
|
|
|
|
def yaml_include(loader, node):
|
|
# Implements !include. Returns a list with the top-level YAML structures
|
|
# for the included files (a single-element list if there's just one file).
|
|
|
|
if isinstance(node, yaml.ScalarNode):
|
|
# !include foo.yaml
|
|
return [load_binding_file(loader.construct_scalar(node))]
|
|
|
|
if isinstance(node, yaml.SequenceNode):
|
|
# !include [foo.yaml, bar.yaml]
|
|
return [load_binding_file(fname)
|
|
for fname in loader.construct_sequence(node)]
|
|
|
|
yaml_inc_error("Error: unrecognised node type in !include statement")
|
|
|
|
|
|
def load_binding_file(fname):
|
|
# yaml_include() helper for loading an !include'd file. !include takes just
|
|
# the basename of the file, so we need to make sure that there aren't
|
|
# multiple candidates.
|
|
|
|
filepaths = [filepath for filepath in binding_files
|
|
if os.path.basename(filepath) == os.path.basename(fname)]
|
|
|
|
if not filepaths:
|
|
yaml_inc_error("Error: unknown file name '{}' in !include statement"
|
|
.format(fname))
|
|
|
|
if len(filepaths) > 1:
|
|
yaml_inc_error("Error: multiple candidates for file name '{}' in "
|
|
"!include statement: {}".format(fname, filepaths))
|
|
|
|
with open(filepaths[0], 'r', encoding='utf-8') as f:
|
|
return yaml.load(f, Loader=yaml.Loader)
|
|
|
|
|
|
def yaml_inc_error(msg):
|
|
# Helper for reporting errors in the !include implementation
|
|
|
|
raise yaml.constructor.ConstructorError(None, None, msg)
|
|
|
|
|
|
def generate_defines():
|
|
# Generates #defines (and .conf file values) from DTS
|
|
|
|
# sorted() otherwise Python < 3.6 randomizes the order of the flash
|
|
# partition table
|
|
for node_path in sorted(reduced.keys()):
|
|
generate_node_defines(node_path)
|
|
|
|
if not defs:
|
|
raise Exception("No information parsed from dts file.")
|
|
|
|
for k, v in regs_config.items():
|
|
if k in chosen:
|
|
reg.extract(chosen[k], None, v, 1024)
|
|
|
|
for k, v in name_config.items():
|
|
if k in chosen:
|
|
extract_string_prop(chosen[k], "label", v)
|
|
|
|
flash.extract_flash()
|
|
flash.extract_code_partition()
|
|
|
|
# Add DT_CHOSEN_<X> defines
|
|
for c in sorted(chosen):
|
|
insert_defs('chosen', {'DT_CHOSEN_' + str_to_label(c): '1'}, {})
|
|
|
|
|
|
def parse_arguments():
|
|
rdh = argparse.RawDescriptionHelpFormatter
|
|
parser = argparse.ArgumentParser(description=__doc__, formatter_class=rdh)
|
|
|
|
parser.add_argument("-d", "--dts", required=True, help="DTS file")
|
|
parser.add_argument("-y", "--yaml", nargs='+', required=True,
|
|
help="YAML file directories, we allow multiple")
|
|
parser.add_argument("-i", "--include",
|
|
help="Generate include file for the build system")
|
|
parser.add_argument("-k", "--keyvalue",
|
|
help="Generate config file for the build system")
|
|
parser.add_argument("--old-alias-names", action='store_true',
|
|
help="Generate aliases also in the old way, without "
|
|
"compatibility information in their labels")
|
|
return parser.parse_args()
|
|
|
|
|
|
def main():
|
|
args = parse_arguments()
|
|
enable_old_alias_names(args.old_alias_names)
|
|
|
|
# Parse DTS and fetch the root node
|
|
with open(args.dts, 'r', encoding='utf-8') as f:
|
|
root = parse_file(f)['/']
|
|
|
|
# Create some global data structures from the parsed DTS
|
|
create_reduced(root, '/')
|
|
create_phandles(root, '/')
|
|
create_aliases(root)
|
|
create_chosen(root)
|
|
|
|
# Load any bindings (.yaml files) that match 'compatible' values from the
|
|
# DTS
|
|
load_bindings(root, args.yaml)
|
|
|
|
# Generate keys and values for the configuration file and the header file
|
|
generate_defines()
|
|
|
|
# Write the configuration file and the header file
|
|
|
|
if args.keyvalue is not None:
|
|
with open(args.keyvalue, 'w', encoding='utf-8') as f:
|
|
write_conf(f)
|
|
|
|
if args.include is not None:
|
|
with open(args.include, 'w', encoding='utf-8') as f:
|
|
write_header(f)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|