390 lines
16 KiB
Python
390 lines
16 KiB
Python
COPYRIGHT = '''
|
|
/*
|
|
* Copyright 2015-2019 Advanced Micro Devices, Inc.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* on the rights to use, copy, modify, merge, publish, distribute, sub
|
|
* license, and/or sell copies of the Software, and to permit persons to whom
|
|
* the Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the next
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
* Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
|
|
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
* USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
*/
|
|
'''
|
|
"""
|
|
Create the (combined) register header from register JSON. Use --help for usage.
|
|
"""
|
|
|
|
import argparse
|
|
from collections import defaultdict
|
|
import itertools
|
|
import json
|
|
import re
|
|
import sys
|
|
|
|
from regdb import Object, RegisterDatabase, deduplicate_enums, deduplicate_register_types
|
|
|
|
|
|
######### BEGIN HARDCODED CONFIGURATION
|
|
|
|
# Chips are sorted chronologically
|
|
CHIPS = [
|
|
Object(name='gfx6', disambiguation='GFX6'),
|
|
Object(name='gfx7', disambiguation='GFX7'),
|
|
Object(name='gfx8', disambiguation='GFX8'),
|
|
Object(name='gfx81', disambiguation='GFX81'),
|
|
Object(name='gfx9', disambiguation='GFX9'),
|
|
Object(name='gfx10', disambiguation='GFX10'),
|
|
Object(name='gfx103', disambiguation='GFX103'),
|
|
]
|
|
|
|
######### END HARDCODED CONFIGURATION
|
|
|
|
def get_chip_index(chip):
|
|
"""
|
|
Given a chip name, return its index in the global CHIPS list.
|
|
"""
|
|
return next(idx for idx, obj in enumerate(CHIPS) if obj.name == chip)
|
|
|
|
def get_disambiguation_suffix(chips):
|
|
"""
|
|
Disambiguation suffix to be used for an enum entry or field name that
|
|
is supported in the given set of chips.
|
|
"""
|
|
oldest_chip_index = min([get_chip_index(chip) for chip in chips])
|
|
return CHIPS[oldest_chip_index].disambiguation
|
|
|
|
def get_chips_comment(chips, parent=None):
|
|
"""
|
|
Generate a user-friendly comment describing the given set of chips.
|
|
|
|
The return value may be None, if such a comment is deemed unnecessary.
|
|
|
|
parent is an optional set of chips supporting a parent structure, e.g.
|
|
where chips may be the set of chips supporting a specific enum value,
|
|
parent would be the set of chips supporting the field containing the enum,
|
|
the idea being that no comment is necessary if all chips that support the
|
|
parent also support the child.
|
|
"""
|
|
chipflags = [chip.name in chips for chip in CHIPS]
|
|
if all(chipflags):
|
|
return None
|
|
|
|
if parent is not None:
|
|
parentflags = [chip.name in parent for chip in CHIPS]
|
|
if all(childflag or not parentflag for childflag, parentflag in zip(chipflags, parentflags)):
|
|
return None
|
|
|
|
prefix = 0
|
|
for idx, chip, flag in zip(itertools.count(), CHIPS, chipflags):
|
|
if not flag:
|
|
break
|
|
prefix = idx + 1
|
|
|
|
suffix = len(CHIPS)
|
|
for idx, chip, flag in zip(itertools.count(), reversed(CHIPS), reversed(chipflags)):
|
|
if not flag:
|
|
break
|
|
suffix = len(CHIPS) - idx - 1
|
|
|
|
comment = []
|
|
if prefix > 0:
|
|
comment.append('<= {0}'.format(CHIPS[prefix - 1].name))
|
|
for chip, flag in zip(CHIPS[prefix:suffix], chipflags[prefix:suffix]):
|
|
if flag:
|
|
comment.append(chip.name)
|
|
if suffix < len(CHIPS):
|
|
comment.append('>= {0}'.format(CHIPS[suffix].name))
|
|
|
|
return ', '.join(comment)
|
|
|
|
def detect_conflict(regdb, field_in_type1, field_in_type2):
|
|
"""
|
|
Returns False if field_in_type1 and field_in_type2 can be merged
|
|
into a single field = if writing to field_in_type1 bits won't
|
|
overwrite adjacent fields in type2, and the other way around.
|
|
"""
|
|
for idx, type_refs in enumerate([field_in_type1.type_refs, field_in_type2.type_refs]):
|
|
ref = field_in_type2 if idx == 0 else field_in_type1
|
|
for type_ref in type_refs:
|
|
for field in regdb.register_type(type_ref).fields:
|
|
# If a different field in the other type starts in
|
|
# the tested field's bits[0, 1] interval
|
|
if (field.bits[0] > ref.bits[0] and
|
|
field.bits[0] <= ref.bits[1]):
|
|
return True
|
|
|
|
return False
|
|
|
|
class HeaderWriter(object):
|
|
def __init__(self, regdb, guard=None):
|
|
self.guard = guard
|
|
|
|
# The following contain: Object(address, chips, name, regmap/field/enumentry)
|
|
self.register_lines = []
|
|
self.field_lines = []
|
|
self.value_lines = []
|
|
|
|
regtype_emit = defaultdict(set)
|
|
enum_emit = defaultdict(set)
|
|
|
|
for regmap in regdb.register_mappings():
|
|
type_ref = getattr(regmap, 'type_ref', None)
|
|
self.register_lines.append(Object(
|
|
address=regmap.map.at,
|
|
chips=set(regmap.chips),
|
|
name=regmap.name,
|
|
regmap=regmap,
|
|
type_refs=set([type_ref]) if type_ref else set(),
|
|
))
|
|
|
|
basename = re.sub(r'[0-9]+', '', regmap.name)
|
|
key = '{type_ref}::{basename}'.format(**locals())
|
|
if type_ref is not None and regtype_emit[key].isdisjoint(regmap.chips):
|
|
regtype_emit[key].update(regmap.chips)
|
|
|
|
regtype = regdb.register_type(type_ref)
|
|
for field in regtype.fields:
|
|
if field.name == 'RESERVED':
|
|
continue
|
|
|
|
enum_ref = getattr(field, 'enum_ref', None)
|
|
self.field_lines.append(Object(
|
|
address=regmap.map.at,
|
|
chips=set(regmap.chips),
|
|
name=field.name,
|
|
field=field,
|
|
bits=field.bits[:],
|
|
type_refs=set([type_ref]) if type_ref else set(),
|
|
enum_refs=set([enum_ref]) if enum_ref else set(),
|
|
))
|
|
|
|
key = '{type_ref}::{basename}::{enum_ref}'.format(**locals())
|
|
if enum_ref is not None and enum_emit[key].isdisjoint(regmap.chips):
|
|
enum_emit[key].update(regmap.chips)
|
|
|
|
enum = regdb.enum(enum_ref)
|
|
for entry in enum.entries:
|
|
self.value_lines.append(Object(
|
|
address=regmap.map.at,
|
|
chips=set(regmap.chips),
|
|
name=entry.name,
|
|
enumentry=entry,
|
|
enum_refs=set([enum_ref]) if enum_ref else set(),
|
|
))
|
|
|
|
# Merge register lines
|
|
lines = self.register_lines
|
|
lines.sort(key=lambda line: (line.address, line.name))
|
|
|
|
self.register_lines = []
|
|
for line in lines:
|
|
prev = self.register_lines[-1] if self.register_lines else None
|
|
if prev and prev.address == line.address and prev.name == line.name:
|
|
prev.chips.update(line.chips)
|
|
prev.type_refs.update(line.type_refs)
|
|
continue
|
|
self.register_lines.append(line)
|
|
|
|
# Merge field lines
|
|
lines = self.field_lines
|
|
lines.sort(key=lambda line: (line.address, line.name))
|
|
|
|
self.field_lines = []
|
|
for line in lines:
|
|
merged = False
|
|
for prev in reversed(self.field_lines):
|
|
if prev.address != line.address or prev.name != line.name:
|
|
break
|
|
|
|
# Can merge fields if they have the same starting bit and the
|
|
# range of the field as intended by the current line does not
|
|
# conflict with any of the regtypes covered by prev.
|
|
if prev.bits[0] != line.bits[0]:
|
|
continue
|
|
|
|
if prev.bits[1] != line.bits[1]:
|
|
# Current line's field extends beyond the range of prev.
|
|
# Need to check for conflicts
|
|
if detect_conflict(regdb, prev, line):
|
|
continue
|
|
|
|
prev.bits[1] = max(prev.bits[1], line.bits[1])
|
|
prev.chips.update(line.chips)
|
|
prev.type_refs.update(line.type_refs)
|
|
prev.enum_refs.update(line.enum_refs)
|
|
merged = True
|
|
break
|
|
if not merged:
|
|
self.field_lines.append(line)
|
|
|
|
# Merge value lines
|
|
lines = self.value_lines
|
|
lines.sort(key=lambda line: (line.address, line.name))
|
|
|
|
self.value_lines = []
|
|
for line in lines:
|
|
for prev in reversed(self.value_lines):
|
|
if prev.address == line.address and prev.name == line.name and\
|
|
prev.enumentry.value == line.enumentry.value:
|
|
prev.chips.update(line.chips)
|
|
prev.enum_refs.update(line.enum_refs)
|
|
break
|
|
else:
|
|
self.value_lines.append(line)
|
|
|
|
# Disambiguate field and value lines
|
|
for idx, line in enumerate(self.field_lines):
|
|
prev = self.field_lines[idx - 1] if idx > 0 else None
|
|
next = self.field_lines[idx + 1] if idx + 1 < len(self.field_lines) else None
|
|
if (prev and prev.address == line.address and prev.field.name == line.field.name) or\
|
|
(next and next.address == line.address and next.field.name == line.field.name):
|
|
line.name += '_' + get_disambiguation_suffix(line.chips)
|
|
|
|
for idx, line in enumerate(self.value_lines):
|
|
prev = self.value_lines[idx - 1] if idx > 0 else None
|
|
next = self.value_lines[idx + 1] if idx + 1 < len(self.value_lines) else None
|
|
if (prev and prev.address == line.address and prev.enumentry.name == line.enumentry.name) or\
|
|
(next and next.address == line.address and next.enumentry.name == line.enumentry.name):
|
|
line.name += '_' + get_disambiguation_suffix(line.chips)
|
|
|
|
def print(self, filp, sort='address'):
|
|
"""
|
|
Print out the entire register header.
|
|
"""
|
|
if sort == 'address':
|
|
self.register_lines.sort(key=lambda line: (line.address, line.name))
|
|
else:
|
|
assert sort == 'name'
|
|
self.register_lines.sort(key=lambda line: (line.name, line.address))
|
|
|
|
# Collect and sort field lines by address
|
|
field_lines_by_address = defaultdict(list)
|
|
for line in self.field_lines:
|
|
field_lines_by_address[line.address].append(line)
|
|
for field_lines in field_lines_by_address.values():
|
|
if sort == 'address':
|
|
field_lines.sort(key=lambda line: (line.bits[0], line.name))
|
|
else:
|
|
field_lines.sort(key=lambda line: (line.name, line.bits[0]))
|
|
|
|
# Collect and sort value lines by address
|
|
value_lines_by_address = defaultdict(list)
|
|
for line in self.value_lines:
|
|
value_lines_by_address[line.address].append(line)
|
|
for value_lines in value_lines_by_address.values():
|
|
if sort == 'address':
|
|
value_lines.sort(key=lambda line: (line.enumentry.value, line.name))
|
|
else:
|
|
value_lines.sort(key=lambda line: (line.name, line.enumentry.value))
|
|
|
|
print('/* Automatically generated by amd/registers/makeregheader.py */\n', file=filp)
|
|
print(file=filp)
|
|
print(COPYRIGHT.strip(), file=filp)
|
|
print(file=filp)
|
|
|
|
if self.guard:
|
|
print('#ifndef {self.guard}'.format(**locals()), file=filp)
|
|
print('#define {self.guard}\n'.format(**locals()), file=filp)
|
|
|
|
for register_line in self.register_lines:
|
|
comment = get_chips_comment(register_line.chips)
|
|
|
|
address = '{0:X}'.format(register_line.address)
|
|
address = address.rjust(3 if register_line.regmap.map.to == 'pkt3' else 6, '0')
|
|
|
|
define_name = 'R_{address}_{register_line.name}'.format(**locals()).ljust(63)
|
|
comment = ' /* {0} */'.format(comment) if comment else ''
|
|
print('#define {define_name} 0x{address}{comment}'.format(**locals()), file=filp)
|
|
|
|
field_lines = field_lines_by_address[register_line.address]
|
|
field_idx = 0
|
|
while field_idx < len(field_lines):
|
|
field_line = field_lines[field_idx]
|
|
|
|
if field_line.type_refs.isdisjoint(register_line.type_refs):
|
|
field_idx += 1
|
|
continue
|
|
del field_lines[field_idx]
|
|
|
|
comment = get_chips_comment(field_line.chips, register_line.chips)
|
|
|
|
mask = (1 << (field_line.bits[1] - field_line.bits[0] + 1)) - 1
|
|
define_name = '_{address}_{field_line.name}(x)'.format(**locals()).ljust(58)
|
|
comment = ' /* {0} */'.format(comment) if comment else ''
|
|
print(
|
|
'#define S{define_name} (((unsigned)(x) & 0x{mask:X}) << {field_line.bits[0]}){comment}'
|
|
.format(**locals()), file=filp)
|
|
print('#define G{define_name} (((x) >> {field_line.bits[0]}) & 0x{mask:X})'
|
|
.format(**locals()), file=filp)
|
|
|
|
complement = ((1 << 32) - 1) ^ (mask << field_line.bits[0])
|
|
define_name = '_{address}_{field_line.name}'.format(**locals()).ljust(58)
|
|
print('#define C{define_name} 0x{complement:08X}'
|
|
.format(**locals()), file=filp)
|
|
|
|
value_lines = value_lines_by_address[register_line.address]
|
|
value_idx = 0
|
|
while value_idx < len(value_lines):
|
|
value_line = value_lines[value_idx]
|
|
|
|
if value_line.enum_refs.isdisjoint(field_line.enum_refs):
|
|
value_idx += 1
|
|
continue
|
|
del value_lines[value_idx]
|
|
|
|
comment = get_chips_comment(value_line.chips, field_line.chips)
|
|
|
|
define_name = 'V_{address}_{value_line.name}'.format(**locals()).ljust(55)
|
|
comment = ' /* {0} */'.format(comment) if comment else ''
|
|
print('#define {define_name} {value_line.enumentry.value}{comment}'
|
|
.format(**locals()), file=filp)
|
|
|
|
if self.guard:
|
|
print('\n#endif // {self.guard}'.format(**locals()), file=filp)
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument('--chip', dest='chips', type=str, nargs='*',
|
|
help='Chip for which to generate the header (all chips if unspecified)')
|
|
parser.add_argument('--sort', choices=['name', 'address'], default='address',
|
|
help='Sort key for registers, fields, and enum values')
|
|
parser.add_argument('--guard', type=str, help='Name of the #include guard')
|
|
parser.add_argument('files', metavar='FILE', type=str, nargs='+',
|
|
help='Register database file')
|
|
args = parser.parse_args()
|
|
|
|
regdb = None
|
|
for filename in args.files:
|
|
with open(filename, 'r') as filp:
|
|
db = RegisterDatabase.from_json(json.load(filp))
|
|
if regdb is None:
|
|
regdb = db
|
|
else:
|
|
regdb.update(db)
|
|
|
|
deduplicate_enums(regdb)
|
|
deduplicate_register_types(regdb)
|
|
|
|
w = HeaderWriter(regdb, guard=args.guard)
|
|
w.print(sys.stdout, sort=args.sort)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|
|
|
|
# kate: space-indent on; indent-width 4; replace-tabs on;
|