[ot] scripts/opentitan: otptool.py: add LC template generation

Rework all generation-related option to simplify the syntax.

Signed-off-by: Emmanuel Blot <eblot@rivosinc.com>

Author: rivos-eblot

docs/opentitan/otptool.md

@@ -10,7 +10,8 @@ usage: otptool.py [-h] [-j HJSON] [-m VMEM] [-l SV] [-o C] [-r RAW]
                   [-k {auto,otp,fuz}] [-e BITS] [-C CONFIG] [-c INT] [-i INT]
                   [-w] [-n] [-s] [-E] [-D] [-U] [--empty PARTITION]
                   [--clear-bit CLEAR_BIT] [--set-bit SET_BIT]
-                  [--toggle-bit TOGGLE_BIT] [-L | -P | -R] [-v] [-d]
+                  [--toggle-bit TOGGLE_BIT] [-G {LCVAL,LCTPL,PARTS,REGS}] [-v]
+                  [-d]
 
 QEMU OT tool to manage OTP files.
 
@@ -23,7 +24,7 @@ Files:
   -m VMEM, --vmem VMEM  input VMEM file
   -l SV, --lifecycle SV
                         input lifecycle system verilog file
-  -o C, --output C      output C file
+  -o C, --output C      output filename for C file generation
   -r RAW, --raw RAW     QEMU OTP raw image file
 
 Parameters:
@@ -50,9 +51,8 @@ Commands:
   --set-bit SET_BIT     set a bit at specified location
   --toggle-bit TOGGLE_BIT
                         toggle a bit at specified location
-  -L, --generate-lc     generate lc_ctrl C arrays
-  -P, --generate-parts  generate partition descriptor C arrays
-  -R, --generate-regs   generate partition register C definitions
+  -G {LCVAL,LCTPL,PARTS,REGS}, --generate {LCVAL,LCTPL,PARTS,REGS}
+                        generate C code, see doc for options
 
 Extras:
   -v, --verbose         increase verbosity
@@ -124,8 +124,9 @@ Fuse RAW images only use the v1 type.
   the kind of the input VMEM file from its content when this option is not specified or set to
   `auto`. It is fails to detect the file kind or if the kind needs to be enforced, use this option.
 
-* `-L` generate a file describing the LifeCycle contants as C arrays. Mutually exclusive with the
-  `-P` and `-R` option switches. See `-o` to specify an output file.
+* `-G` can be used to generate C code for QEMU, from OTP and LifeCycle known definitions. See the
+  [Generation](#generation) section for details. See option `-o` to specify the path to the file to
+  generate
 
 * `-l` specify the life cycle system verilog file that defines the encoding of the life cycle
   states. This option is not required to generate a RAW image file, but required when the `-L`
@@ -136,14 +137,8 @@ Fuse RAW images only use the v1 type.
 * `-n` tell the script not to attempt to decode the content of encoded fields, such as the hardened
   booleans values. When used, the raw value of each field is printed out.
 
-* `-o` specify the path to the output C file to generate, see `-L`, `-P` and `-R` option switches.
-  Defaults to the standard output.
-
-* `-P` generate a file describing the OTP partition properties as C arrays. Mutually exclusive with
-  the `-L` and `-R` option switches. See `-o` to specify an output file.
-
-* `-R` generate a file describing the OTP partition registers as C defintion. Mutually exclusive
-  with the `-L` and `-P` option switches. See `-o` to specify an output file.
+* `-o` specify the path to the output C file to generate, see `-G` option. If not specified, the
+  generated file is emitted on the standard output.
 
 * `-r` specify the path to the QEMU OTP RAW image file. When used with the `-m` option switch, a
   new QEMU OTP image file is generated. Otherwise, the QEMU OTP RAW image file should exist and is
@@ -194,6 +189,22 @@ If the bit is larger than the data slot, it indicates the location with the ECC
 fuses are organized as 16-bit slots wtih 6-bit ECC, bit 0 to 15 indicates a bit into the data slot,
 while bit 16 to 21 indicates an ECC bit.
 
+### Generation [#generation]
+
+The generation feature may be used to generate part of the OTP and LifeCycle QEMU implementation,
+based on known definitions from the OpenTitan constants. This option accepts on of the following
+argument:
+
+* `LCVAL` generates a file describing the LifeCycle constants as C arrays. Requires `-l` option.
+* `LCTPL` generates a file describing the LifeCycle State encoding as a C array. . Requires `-l`
+  option.
+* `PARTS` generates a file describing the OTP partition properties as C arrays. Requires `-j`
+  option.
+* `REGS` generates a file describing the OTP partition registers as C definitions. Requires `-j`
+  option.
+
+ See `-o` to specify an output file for the generated file.
+
 ### Examples
 
 Generate a QEMU RAW v1 image for the virtual OTP controller, here with an RMA OTP configuration:
@@ -248,10 +259,10 @@ scripts/opentitan/otptool.py -r otp.raw -j otp_ctrl_mmap.hjson -D \
 
 Generate a C source file with LifeCycle constant definitions:
 ````sh
-scripts/opentitan/otptool.py -L -l lc_ctrl_state_pkg.sv -o lc_state.c
+scripts/opentitan/otptool.py -G LCVAL -l lc_ctrl_state_pkg.sv -o lc_state.c
 ````
 
 Generates a C source file with OTP partition properties:
 ````sh
-scripts/opentitan/otptool.py -j otp_ctrl_mmap.hjson -P -o otp_part.c
+scripts/opentitan/otptool.py -j otp_ctrl_mmap.hjson -G PARTS -o otp_part.c
 ````

scripts/opentitan/cfggen.py

@@ -13,7 +13,7 @@
 from logging import getLogger
 from os.path import isdir, isfile, join as joinpath, normpath
 from re import match, search
-from sys import exit as sysexit, modules, stderr
+from sys import exit as sysexit, modules, stderr, stdout
 from traceback import format_exc
 from typing import Optional
 
@@ -107,7 +107,7 @@ def save(self, socid: Optional[str] = None, count: Optional[int] = 1,
             with open(outpath, 'wt') as ofp:
                 cfg.write(ofp)
         else:
-            cfg.write(stderr)
+            cfg.write(stdout)
 
     @classmethod
     def add_pair(cls, data: dict[str, str], kname: str, value: str) -> None:

scripts/opentitan/ot/otp/lifecycle.py

@@ -10,11 +10,11 @@
 from io import StringIO
 from logging import getLogger
 from os.path import basename
-from re import finditer, match
+from re import finditer, match, sub
 from textwrap import fill
 from typing import TextIO
 
-from ot.util.misc import camel_to_snake_case
+from ot.util.misc import camel_to_snake_case, group
 
 
 class OtpLifecycle:
@@ -31,6 +31,7 @@ class OtpLifecycle:
 
     def __init__(self):
         self._log = getLogger('otp.lc')
+        self._sequences: dict[str, list[str]] = {}
         self._tables: dict[str, dict[str, str]] = {}
         self._tokens: dict[str, str] = {}
 
@@ -55,6 +56,7 @@ def load(self, svp: TextIO):
                 name = abmo.group(1)
                 sval = abmo.group(2)
                 val = int(sval[1:], 2 if sval.startswith('b') else 16)
+                val = ((val >> 8) & 0xff) | ((val & 0xff) << 8)
                 if name in codes:
                     self._log.error('Redefinition of %s', name)
                     continue
@@ -65,14 +67,15 @@ def load(self, svp: TextIO):
                 kind = smo.group(1).lower()
                 name = smo.group(2)
                 seq = smo.group(3)
-                items = [x.strip() for x in seq.split(',')]
+                items = [x.strip() for x in reversed(seq.split(','))]
                 inv = [it for it in items if it not in codes]
                 if inv:
                     self._log.error('Unknown state seq: %s', ', '.join(inv))
                 if kind not in sequences:
                     sequences[kind] = {}
                 sequences[kind][name] = items
                 continue
+        self._sequences = sequences
         svp.seek(0)
         for tmo in finditer(r"\s+parameter\s+lc_token_t\s+(\w+)\s+="
                             r"\s+\{\s+128'h([0-9A-F]+)\s+\};",
@@ -89,13 +92,21 @@ def load(self, svp: TextIO):
                 seq = ''.join((f'{x:04x}'for x in map(codes.get, seq)))
                 self._tables[mkind][seq] = conv(ref)
 
-    def save(self, cfp: TextIO):
+    def save(self, cfp: TextIO, data_mode: bool) -> None:
         """Save OTP life cycle definitions as a C file.
 
            :param cfp: output text stream
+           :param data_mode: whether to output data or template
         """
         print(f'/* Section auto-generated with {basename(__file__)} '
               f'script */', file=cfp)
+        if data_mode:
+            self._save_data(cfp)
+        else:
+            self._save_template(cfp)
+        print('/* End of auto-generated section */', file=cfp)
+
+    def _save_data(self, cfp: TextIO) -> None:
         for kind, table in self._tables.items():
             enum_io = StringIO()
             array_io = StringIO()
@@ -125,7 +136,22 @@ def save(self, cfp: TextIO):
                 # likely to be moved to a header file
                 print(f'enum {kind.lower()} {{\n{enum_str}}};\n', file=cfp)
             print(f'{array_io.getvalue()}', file=cfp)
-        print('/* End of auto-generated section */', file=cfp)
+
+    def _save_template(self, cfp: TextIO) -> None:
+        print('/* clang-format off */', file=cfp)
+        states = self._sequences.get('st') or {}
+        print('static const uint8_t', file=cfp)
+        print('LC_STATES_TPL[LC_STATE_VALID_COUNT][LC_STATE_SLOT_COUNT] = {',
+              file=cfp)
+        for stname, stwords in states.items():
+            print(f'    [LC_STATE_{stname.upper()}] = {{', file=cfp)
+            for wgrp in group(stwords, len(stwords)//2):
+                items = (sub(r'(\d+)', r'(\1)', wg) for wg in wgrp)
+                stws = ' '.join(f'{w:<6s}' for w in (f'{i},' for i in items))
+                print(f'        {stws.rstrip()}', file=cfp)
+            print('    },', file=cfp)
+        print('};', file=cfp)
+        print('/* clang-format on */', file=cfp)
 
     def get_configuration(self, name: str) -> dict[str, str]:
         """Provide a dictionary of configurable elements for QEMU."""

scripts/opentitan/otptool.py

@@ -28,6 +28,7 @@
 def main():
     """Main routine"""
     debug = True
+    genfmts = 'LCVAL LCTPL PARTS REGS'.split()
     try:
         desc = modules[__name__].__doc__.split('.', 1)[0].strip()
         argparser = ArgumentParser(description=f'{desc}.')
@@ -41,7 +42,7 @@ def main():
                            metavar='SV',
                            help='input lifecycle system verilog file')
         files.add_argument('-o', '--output', metavar='C', type=FileType('wt'),
-                           help='output C file')
+                           help='output filename for C file generation')
         files.add_argument('-r', '--raw',
                            help='QEMU OTP raw image file')
         params = argparser.add_argument_group(title='Parameters')
@@ -85,13 +86,8 @@ def main():
                               help='set a bit at specified location')
         commands.add_argument('--toggle-bit', action='append',  default=[],
                               help='toggle a bit at specified location')
-        generate = commands.add_mutually_exclusive_group()
-        generate.add_argument('-L', '--generate-lc', action='store_true',
-                              help='generate lc_ctrl C arrays')
-        generate.add_argument('-P', '--generate-parts', action='store_true',
-                              help='generate partition descriptor C arrays')
-        generate.add_argument('-R', '--generate-regs', action='store_true',
-                              help='generate partition register C definitions')
+        commands.add_argument('-G', '--generate', choices=genfmts,
+                              help='generate C code, see doc for options')
         extra = argparser.add_argument_group(title='Extras')
         extra.add_argument('-v', '--verbose', action='count',
                            help='increase verbosity')
@@ -136,7 +132,7 @@ def main():
         partdesc: Optional[OTPPartitionDesc] = None
 
         if not args.otp_map:
-            if args.generate_parts or args.generate_regs:
+            if args.generate in ('PARTS', 'REGS'):
                 argparser.error('Generator requires an OTP map')
             if args.show:
                 argparser.error('Cannot decode OTP values without an OTP map')
@@ -151,22 +147,26 @@ def main():
         if args.lifecycle:
             lcext = OtpLifecycleExtension()
             lcext.load(args.lifecycle)
+        elif args.generate in ('LCVAL', 'LCTPL'):
+            argparser.error('Cannot generate LC array w/o a lifecycle file')
 
         output = stdout if not args.output else args.output
 
-        if args.generate_parts:
+        if not args.generate:
+            pass
+        elif args.generate == 'PARTS':
             partdesc = OTPPartitionDesc(otpmap)
             partdesc.save(basename(args.otp_map.name), basename(argv[0]),
                           output)
-
-        if args.generate_regs:
+        elif args.generate == 'REGS':
             regdef = OTPRegisterDef(otpmap)
             regdef.save(basename(args.otp_map.name), basename(argv[0]), output)
-
-        if args.generate_lc:
-            if not lcext:
-                argparser.error('Cannot generate LC array w/o a lifecycle file')
-            lcext.save(output)
+        elif args.generate == 'LCVAL':
+            lcext.save(output, True)
+        elif args.generate == 'LCTPL':
+            lcext.save(output, False)
+        else:
+            argparser.error(f'Unsupported generation: {args.generate}')
 
         if args.vmem:
             otp.load_vmem(args.vmem, args.kind)
@@ -186,8 +186,7 @@ def main():
 
         if otp.loaded:
             if not otp.is_opentitan:
-                ot_opts = ('iv', 'constant', 'digest', 'generate_parts',
-                           'generate_regs', 'generate_lc', 'otp_map',
+                ot_opts = ('iv', 'constant', 'digest', 'generate', 'otp_map',
                            'lifecycle')
                 if any(getattr(args, a) for a in ot_opts):
                     argparser.error('Selected option only applies to OpenTitan '