minor sandbox fixes

a37xx fix
 Add camel-case tool, since the conversion will take a while
 -----BEGIN PGP SIGNATURE-----
 
 iQFFBAABCgAvFiEEslwAIq+Gp8wWVbYnfxc6PpAIreYFAmP/mFkRHHNqZ0BjaHJv
 bWl1bS5vcmcACgkQfxc6PpAIreaysQgAyynEVw1/Keh23dMTILTZARJjo820FsA3
 axQ++cABz4f5m1xgnECp+W5atDrt0Dpgdk4IZPXdKO4unqMoPzVinXlPvfYNrJYE
 nhTIdbTt1Ce8kBtge5E8G9uAXRYgZvfZXpMB0+hbpWHFCH5m/wWULAKbE2YXsIus
 9dG2JFpmt9ob2BtpBfwKj0jL4e00ffNIsWx7oXdFjygz7j3+YHfH7o7CBVzN+vf4
 bMrHLctmstqJbyWVoa+Qm0/YmDm7wACcwPTuOIc21sIJuNlnSmhEshCDseHq6U+V
 nutUfel36Hh1PYMa2nvV/06TgFMy8xqA1/YWtpsOIF9bkrCEl168Gw==
 =5w21
 -----END PGP SIGNATURE-----

Merge tag 'dm-pull-29feb23' of https://source.denx.de/u-boot/custodians/u-boot-dm

minor sandbox fixes
a37xx fix
Add camel-case tool, since the conversion will take a while

MAINTAINERS

@@ -1336,6 +1336,7 @@ M:	Simon Glass <sjg@chromium.org>
 S:	Maintained
 F:	arch/sandbox/
 F:	doc/arch/sandbox.rst
+F:	drivers/*/*sandbox*.c
 F:	include/dt-bindings/*/sandbox*.h
 
 SEAMA

arch/sandbox/include/asm/types.h

@@ -18,11 +18,7 @@ typedef unsigned short umode_t;
 /*
  * Number of bits in a C 'long' on this architecture.
  */
-#ifdef	CONFIG_PHYS_64BIT
-#define BITS_PER_LONG 64
-#else	/* CONFIG_PHYS_64BIT */
-#define BITS_PER_LONG 32
-#endif	/* CONFIG_PHYS_64BIT */
+#define BITS_PER_LONG CONFIG_SANDBOX_BITS_PER_LONG
 
 #ifdef	CONFIG_PHYS_64BIT
 typedef unsigned long long dma_addr_t;

configs/sandbox_spl_defconfig

@@ -33,6 +33,7 @@ CONFIG_SPL_NO_BSS_LIMIT=y
 CONFIG_HANDOFF=y
 CONFIG_SPL_BOARD_INIT=y
 CONFIG_SPL_ENV_SUPPORT=y
+CONFIG_SPL_FPGA=y
 CONFIG_SPL_I2C=y
 CONFIG_SPL_RTC=y
 CONFIG_CMD_CPU=y
@@ -126,6 +127,8 @@ CONFIG_DM_DEMO=y
 CONFIG_DM_DEMO_SIMPLE=y
 CONFIG_DM_DEMO_SHAPE=y
 CONFIG_SPL_FIRMWARE=y
+CONFIG_DM_FPGA=y
+CONFIG_SANDBOX_FPGA=y
 CONFIG_GPIO_HOG=y
 CONFIG_QCOM_PMIC_GPIO=y
 CONFIG_SANDBOX_GPIO=y
@@ -237,6 +240,7 @@ CONFIG_FS_CRAMFS=y
 CONFIG_CMD_DHRYSTONE=y
 CONFIG_RSA_VERIFY_WITH_PKEY=y
 CONFIG_TPM=y
+CONFIG_SPL_CRC8=y
 CONFIG_LZ4=y
 CONFIG_ZSTD=y
 CONFIG_ERRNO_STR=y

drivers/pinctrl/mvebu/pinctrl-armada-37xx.c

@@ -745,6 +745,19 @@ static int armada_37xx_pinctrl_probe(struct udevice *dev)
 	return 0;
 }
 
+static int armada_37xx_pinctrl_bind(struct udevice *dev)
+{
+	/*
+	 * Make sure that the pinctrl driver gets probed after binding
+	 * as on A37XX the pinctrl driver is the one that is also
+	 * registering the GPIO one during probe, so if its not probed
+	 * GPIO-s are not registered as well.
+	 */
+	dev_or_flags(dev, DM_FLAG_PROBE_AFTER_BIND);
+
+	return 0;
+}
+
 static const struct udevice_id armada_37xx_pinctrl_of_match[] = {
 	{
 		.compatible = "marvell,armada3710-sb-pinctrl",
@@ -762,6 +775,7 @@ U_BOOT_DRIVER(armada_37xx_pinctrl) = {
 	.id = UCLASS_PINCTRL,
 	.of_match = of_match_ptr(armada_37xx_pinctrl_of_match),
 	.probe = armada_37xx_pinctrl_probe,
+	.bind = armada_37xx_pinctrl_bind,
 	.priv_auto	= sizeof(struct armada_37xx_pinctrl),
 	.ops = &armada_37xx_pinctrl_ops,
 };

drivers/timer/sandbox_timer.c

@@ -66,6 +66,8 @@ U_BOOT_DRIVER(sandbox_timer) = {
 };
 
 /* This is here in case we don't have a device tree */
+#if !CONFIG_IS_ENABLED(OF_PLATDATA)
 U_BOOT_DRVINFO(sandbox_timer_non_fdt) = {
 	.name = "sandbox_timer",
 };
+#endif

scripts/style.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: GPL-2.0+
+#
+# Copyright 2021 Google LLC
+#
+
+"""Changes the functions and class methods in a file to use snake case, updating
+other tools which use them"""
+
+from argparse import ArgumentParser
+import glob
+import os
+import re
+import subprocess
+
+import camel_case
+
+# Exclude functions with these names
+EXCLUDE_NAMES = set(['setUp', 'tearDown', 'setUpClass', 'tearDownClass'])
+
+# Find function definitions in a file
+RE_FUNC = re.compile(r' *def (\w+)\(')
+
+# Where to find files that might call the file being converted
+FILES_GLOB = 'tools/**/*.py'
+
+def collect_funcs(fname):
+    """Collect a list of functions in a file
+
+    Args:
+        fname (str): Filename to read
+
+    Returns:
+        tuple:
+            str: contents of file
+            list of str: List of function names
+    """
+    with open(fname, encoding='utf-8') as inf:
+        data = inf.read()
+        funcs = RE_FUNC.findall(data)
+    return data, funcs
+
+def get_module_name(fname):
+    """Convert a filename to a module name
+
+    Args:
+        fname (str): Filename to convert, e.g. 'tools/patman/command.py'
+
+    Returns:
+        tuple:
+            str: Full module name, e.g. 'patman.command'
+            str: Leaf module name, e.g. 'command'
+            str: Program name, e.g. 'patman'
+    """
+    parts = os.path.splitext(fname)[0].split('/')[1:]
+    module_name = '.'.join(parts)
+    return module_name, parts[-1], parts[0]
+
+def process_caller(data, conv, module_name, leaf):
+    """Process a file that might call another module
+
+    This converts all the camel-case references in the provided file contents
+    with the corresponding snake-case references.
+
+    Args:
+        data (str): Contents of file to convert
+        conv (dict): Identifies to convert
+            key: Current name in camel case, e.g. 'DoIt'
+            value: New name in snake case, e.g. 'do_it'
+        module_name: Name of module as referenced by the file, e.g.
+            'patman.command'
+        leaf: Leaf module name, e.g. 'command'
+
+    Returns:
+        str: New file contents, or None if it was not modified
+    """
+    total = 0
+
+    # Update any simple functions calls into the module
+    for name, new_name in conv.items():
+        newdata, count = re.subn(fr'{leaf}.{name}\(',
+                                 f'{leaf}.{new_name}(', data)
+        total += count
+        data = newdata
+
+    # Deal with files that import symbols individually
+    imports = re.findall(fr'from {module_name} import (.*)\n', data)
+    for item in imports:
+        #print('item', item)
+        names = [n.strip() for n in item.split(',')]
+        new_names = [conv.get(n) or n for n in names]
+        new_line = f"from {module_name} import {', '.join(new_names)}\n"
+        data = re.sub(fr'from {module_name} import (.*)\n', new_line, data)
+        for name in names:
+            new_name = conv.get(name)
+            if new_name:
+                newdata = re.sub(fr'\b{name}\(', f'{new_name}(', data)
+                data = newdata
+
+    # Deal with mocks like:
+    # unittest.mock.patch.object(module, 'Function', ...
+    for name, new_name in conv.items():
+        newdata, count = re.subn(fr"{leaf}, '{name}'",
+                                 f"{leaf}, '{new_name}'", data)
+        total += count
+        data = newdata
+
+    if total or imports:
+        return data
+    return None
+
+def process_file(srcfile, do_write, commit):
+    """Process a file to rename its camel-case functions
+
+    This renames the class methods and functions in a file so that they use
+    snake case. Then it updates other modules that call those functions.
+
+    Args:
+        srcfile (str): Filename to process
+        do_write (bool): True to write back to files, False to do a dry run
+        commit (bool): True to create a commit with the changes
+    """
+    data, funcs = collect_funcs(srcfile)
+    module_name, leaf, prog = get_module_name(srcfile)
+    #print('module_name', module_name)
+    #print(len(funcs))
+    #print(funcs[0])
+    conv = {}
+    for name in funcs:
+        if name not in EXCLUDE_NAMES:
+            conv[name] = camel_case.to_snake(name)
+
+    # Convert name to new_name in the file
+    for name, new_name in conv.items():
+        #print(name, new_name)
+        # Don't match if it is preceded by a '.', since that indicates that
+        # it is calling this same function name but in a different module
+        newdata = re.sub(fr'(?<!\.){name}\(', f'{new_name}(', data)
+        data = newdata
+
+        # But do allow self.xxx
+        newdata = re.sub(fr'self.{name}\(', f'self.{new_name}(', data)
+        data = newdata
+    if do_write:
+        with open(srcfile, 'w', encoding='utf-8') as out:
+            out.write(data)
+
+    # Now find all files which use these functions and update them
+    for fname in glob.glob(FILES_GLOB, recursive=True):
+        with open(fname, encoding='utf-8') as inf:
+            data = inf.read()
+        newdata = process_caller(fname, conv, module_name, leaf)
+        if do_write and newdata:
+            with open(fname, 'w', encoding='utf-8') as out:
+                out.write(newdata)
+
+    if commit:
+        subprocess.call(['git', 'add', '-u'])
+        subprocess.call([
+            'git', 'commit', '-s', '-m',
+            f'''{prog}: Convert camel case in {os.path.basename(srcfile)}
+
+Convert this file to snake case and update all files which use it.
+'''])
+
+
+def main():
+    """Main program"""
+    epilog = 'Convert camel case function names to snake in a file and callers'
+    parser = ArgumentParser(epilog=epilog)
+    parser.add_argument('-c', '--commit', action='store_true',
+                        help='Add a commit with the changes')
+    parser.add_argument('-n', '--dry_run', action='store_true',
+                        help='Dry run, do not write back to files')
+    parser.add_argument('-s', '--srcfile', type=str, required=True, help='Filename to convert')
+    args = parser.parse_args()
+    process_file(args.srcfile, not args.dry_run, args.commit)
+
+if __name__ == '__main__':
+    main()

tools/binman/binman.rst

@@ -393,9 +393,9 @@ system-library directory, replace the last line with:
 Running binman
 --------------
 
-Type::
+Type:
 
-.. code-block: bash
+.. code-block:: bash
 
    make NO_PYTHON=1 PREFIX=/ install
     binman build -b <board_name>